* renamed .h to .inc

    * prepeared for dynamic linking support

git-svn-id: trunk@11530 -

.gitattributes

@@ -3273,54 +3273,54 @@ packages/libxml/examples/reader2.pas svneol=native#text/plain
 packages/libxml/examples/test1.xml svneol=native#text/plain
 packages/libxml/examples/test2.xml svneol=native#text/plain
 packages/libxml/fpmake.pp svneol=native#text/plain
-packages/libxml/src/DOCBparser.h svneol=native#text/plain
-packages/libxml/src/HTMLparser.h svneol=native#text/plain
-packages/libxml/src/HTMLtree.h svneol=native#text/plain
-packages/libxml/src/SAX.h svneol=native#text/plain
-packages/libxml/src/SAX2.h svneol=native#text/plain
-packages/libxml/src/c14n.h svneol=native#text/plain
-packages/libxml/src/catalog.h svneol=native#text/plain
-packages/libxml/src/chvalid.h svneol=native#text/plain
-packages/libxml/src/debugXML.h svneol=native#text/plain
-packages/libxml/src/dict.h svneol=native#text/plain
-packages/libxml/src/encoding.h svneol=native#text/plain
-packages/libxml/src/entities.h svneol=native#text/plain
-packages/libxml/src/globals.h svneol=native#text/plain
-packages/libxml/src/hash.h svneol=native#text/plain
+packages/libxml/src/DOCBparser.inc svneol=native#text/plain
+packages/libxml/src/HTMLparser.inc svneol=native#text/plain
+packages/libxml/src/HTMLtree.inc svneol=native#text/plain
+packages/libxml/src/SAX.inc svneol=native#text/plain
+packages/libxml/src/SAX2.inc svneol=native#text/plain
+packages/libxml/src/c14n.inc svneol=native#text/plain
+packages/libxml/src/catalog.inc svneol=native#text/plain
+packages/libxml/src/chvalid.inc svneol=native#text/plain
+packages/libxml/src/debugXML.inc svneol=native#text/plain
+packages/libxml/src/dict.inc svneol=native#text/plain
+packages/libxml/src/encoding.inc svneol=native#text/plain
+packages/libxml/src/entities.inc svneol=native#text/plain
+packages/libxml/src/globals.inc svneol=native#text/plain
+packages/libxml/src/hash.inc svneol=native#text/plain
 packages/libxml/src/libxml2.pas svneol=native#text/plain
-packages/libxml/src/list.h svneol=native#text/plain
-packages/libxml/src/nanoftp.h svneol=native#text/plain
-packages/libxml/src/nanohttp.h svneol=native#text/plain
-packages/libxml/src/parser.h svneol=native#text/plain
-packages/libxml/src/parserInternals.h svneol=native#text/plain
-packages/libxml/src/pattern.h svneol=native#text/plain
-packages/libxml/src/relaxng.h svneol=native#text/plain
-packages/libxml/src/schemasInternals.h svneol=native#text/plain
-packages/libxml/src/schematron.h svneol=native#text/plain
-packages/libxml/src/threads.h svneol=native#text/plain
-packages/libxml/src/tree.h svneol=native#text/plain
-packages/libxml/src/uri.h svneol=native#text/plain
-packages/libxml/src/valid.h svneol=native#text/plain
-packages/libxml/src/xinclude.h svneol=native#text/plain
-packages/libxml/src/xlink.h svneol=native#text/plain
-packages/libxml/src/xmlIO.h svneol=native#text/plain
-packages/libxml/src/xmlautomata.h svneol=native#text/plain
-packages/libxml/src/xmlerror.h svneol=native#text/plain
-packages/libxml/src/xmlexports.h svneol=native#text/plain
-packages/libxml/src/xmlmemory.h svneol=native#text/plain
-packages/libxml/src/xmlmodule.h svneol=native#text/plain
-packages/libxml/src/xmlreader.h svneol=native#text/plain
-packages/libxml/src/xmlregexp.h svneol=native#text/plain
-packages/libxml/src/xmlsave.h svneol=native#text/plain
-packages/libxml/src/xmlschemas.h svneol=native#text/plain
-packages/libxml/src/xmlschemastypes.h svneol=native#text/plain
-packages/libxml/src/xmlstring.h svneol=native#text/plain
-packages/libxml/src/xmlunicode.h svneol=native#text/plain
-packages/libxml/src/xmlversion.h svneol=native#text/plain
-packages/libxml/src/xmlwriter.h svneol=native#text/plain
-packages/libxml/src/xpath.h svneol=native#text/plain
-packages/libxml/src/xpathInternals.h svneol=native#text/plain
-packages/libxml/src/xpointer.h svneol=native#text/plain
+packages/libxml/src/list.inc svneol=native#text/plain
+packages/libxml/src/nanoftp.inc svneol=native#text/plain
+packages/libxml/src/nanohttp.inc svneol=native#text/plain
+packages/libxml/src/parser.inc svneol=native#text/plain
+packages/libxml/src/parserInternals.inc svneol=native#text/plain
+packages/libxml/src/pattern.inc svneol=native#text/plain
+packages/libxml/src/relaxng.inc svneol=native#text/plain
+packages/libxml/src/schemasInternals.inc svneol=native#text/plain
+packages/libxml/src/schematron.inc svneol=native#text/plain
+packages/libxml/src/threads.inc svneol=native#text/plain
+packages/libxml/src/tree.inc svneol=native#text/plain
+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/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/xmlregexp.inc svneol=native#text/plain
+packages/libxml/src/xmlsave.inc svneol=native#text/plain
+packages/libxml/src/xmlschemas.inc svneol=native#text/plain
+packages/libxml/src/xmlschemastypes.inc svneol=native#text/plain
+packages/libxml/src/xmlstring.inc svneol=native#text/plain
+packages/libxml/src/xmlunicode.inc svneol=native#text/plain
+packages/libxml/src/xmlversion.inc svneol=native#text/plain
+packages/libxml/src/xmlwriter.inc svneol=native#text/plain
+packages/libxml/src/xpath.inc svneol=native#text/plain
+packages/libxml/src/xpathInternals.inc svneol=native#text/plain
+packages/libxml/src/xpointer.inc svneol=native#text/plain
 packages/lua/Makefile svneol=native#text/plain
 packages/lua/Makefile.fpc svneol=native#text/plain
 packages/lua/fpmake.pp svneol=native#text/plain

packages/libxml/src/dict.h → packages/libxml/src/dict.inc

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

packages/libxml/src/encoding.h → packages/libxml/src/encoding.inc

@@ -125,37 +125,37 @@
 (*
  * Interfaces for encoding handlers.
  *)
-procedure xmlInitCharEncodingHandlers; cdecl; external;
-procedure xmlCleanupCharEncodingHandlers; cdecl; external;
-procedure xmlRegisterCharEncodingHandler(handler: xmlCharEncodingHandlerPtr); cdecl; external;
-function xmlGetCharEncodingHandler(enc: xmlCharEncoding): xmlCharEncodingHandlerPtr; cdecl; external;
-function xmlFindCharEncodingHandler(name: pchar): xmlCharEncodingHandlerPtr; cdecl; external;
-function xmlNewCharEncodingHandler(name: pchar; input: xmlCharEncodingInputFunc; output: xmlCharEncodingOutputFunc): xmlCharEncodingHandlerPtr; cdecl; external;
+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;
 
 (*
  * Interfaces for encoding names and aliases.
  *)
-function xmlAddEncodingAlias(name: pchar; alias: pchar): cint; cdecl; external;
-function xmlDelEncodingAlias(alias: pchar): cint; cdecl; external;
-function xmlGetEncodingAlias(alias: pchar): pchar; cdecl; external;
-procedure xmlCleanupEncodingAliases; cdecl; external;
-function xmlParseCharEncoding(name: pchar): xmlCharEncoding; cdecl; external;
-function xmlGetCharEncodingName(enc: xmlCharEncoding): pchar; cdecl; external;
+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;
 
 (*
  * Interfaces directly used by the parsers.
  *)
-function xmlDetectCharEncoding(_in: pchar; len: cint): xmlCharEncoding; cdecl; external;
-function xmlCharEncOutFunc(handler: xmlCharEncodingHandlerPtr; _out, _in: xmlBufferPtr): cint; cdecl; external;
-function xmlCharEncInFunc(handler: xmlCharEncodingHandlerPtr; _out, _in: xmlBufferPtr): cint; cdecl; external;
-function xmlCharEncFirstLine(handler: xmlCharEncodingHandlerPtr; _out, _in: xmlBufferPtr): cint; cdecl; external;
-function xmlCharEncCloseFunc(handler: xmlCharEncodingHandlerPtr): cint; cdecl; external;
+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;
 
 (*
  * Export a few useful functions
  *)
 {$IFDEF LIBXML_OUTPUT_ENABLED}
-function UTF8Toisolat1(_out: pchar; outlen: pcint; _in: pchar; inlen: pcint): cint; cdecl; external;
+function UTF8Toisolat1(_out: pchar; outlen: pcint; _in: pchar; inlen: pcint): cint; XMLCALL; XMLPUBFUN;
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
-function isolat1ToUTF8(_out: pchar; outlen: pcint; _in: pchar; inlen: pcint): cint; cdecl; external;
+function isolat1ToUTF8(_out: pchar; outlen: pcint; _in: pchar; inlen: pcint): cint; XMLCALL; XMLPUBFUN;
 {$ENDIF}

packages/libxml/src/entities.h → packages/libxml/src/entities.inc

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

packages/libxml/src/globals.h → packages/libxml/src/globals.inc

@@ -12,8 +12,8 @@
  *)
 
 {$IFDEF FUNCTION}
-procedure xmlInitGlobals; cdecl; external;
-procedure xmlCleanupGlobals; cdecl; external;
+procedure xmlInitGlobals; XMLCALL; XMLPUBFUN;
+procedure xmlCleanupGlobals; XMLCALL; XMLPUBFUN;
 {$ENDIF}
 
 {$IFDEF TYPE}
@@ -22,8 +22,8 @@ procedure xmlCleanupGlobals; cdecl; external;
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-function xmlParserInputBufferCreateFilenameDefault(func: xmlParserInputBufferCreateFilenameFunc): xmlParserInputBufferCreateFilenameFunc; cdecl; external;
-function xmlOutputBufferCreateFilenameDefault(func: xmlOutputBufferCreateFilenameFunc): xmlOutputBufferCreateFilenameFunc; cdecl; external;
+function xmlParserInputBufferCreateFilenameDefault(func: xmlParserInputBufferCreateFilenameFunc): xmlParserInputBufferCreateFilenameFunc; XMLCALL; XMLPUBFUN;
+function xmlOutputBufferCreateFilenameDefault(func: xmlOutputBufferCreateFilenameFunc): xmlOutputBufferCreateFilenameFunc; XMLCALL; XMLPUBFUN;
 {$ENDIF}
 
 (*
@@ -82,17 +82,17 @@ function xmlOutputBufferCreateFilenameDefault(func: xmlOutputBufferCreateFilenam
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-procedure xmlInitializeGlobalState(gs: xmlGlobalStatePtr); cdecl; external;
-procedure xmlThrDefSetGenericErrorFunc(ctx: pointer; handler: xmlGenericErrorFunc); cdecl; external;
-procedure xmlThrDefSetStructuredErrorFunc(ctx: pointer; handler: xmlStructuredErrorFunc); cdecl; external;
+procedure xmlInitializeGlobalState(gs: xmlGlobalStatePtr); XMLCALL; XMLPUBFUN;
+procedure xmlThrDefSetGenericErrorFunc(ctx: pointer; handler: xmlGenericErrorFunc); XMLCALL; XMLPUBFUN;
+procedure xmlThrDefSetStructuredErrorFunc(ctx: pointer; handler: xmlStructuredErrorFunc); XMLCALL; XMLPUBFUN;
 
-function xmlRegisterNodeDefault(func: xmlRegisterNodeFunc): xmlRegisterNodeFunc; cdecl; external;
-function xmlThrDefRegisterNodeDefault(func: xmlRegisterNodeFunc): xmlRegisterNodeFunc; cdecl; external;
-function xmlDeregisterNodeDefault(func: xmlRegisterNodeFunc): xmlDeregisterNodeFunc; cdecl; external;
-function xmlThrDefDeregisterNodeDefault(func: xmlRegisterNodeFunc): xmlDeregisterNodeFunc; cdecl; external;
+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 xmlDeregisterNodeDefault(func: xmlOutputBufferCreateFilenameFunc): xmlOutputBufferCreateFilenameFunc; cdecl; external;
-function xmlThrDefDeregisterNodeDefault(func: xmlParserInputBufferCreateFilenameFunc): xmlParserInputBufferCreateFilenameFunc; cdecl; external;
+function xmlDeregisterNodeDefault(func: xmlOutputBufferCreateFilenameFunc): xmlOutputBufferCreateFilenameFunc; XMLCALL; XMLPUBFUN;
+function xmlThrDefDeregisterNodeDefault(func: xmlParserInputBufferCreateFilenameFunc): xmlParserInputBufferCreateFilenameFunc; XMLCALL; XMLPUBFUN;
 
 {$IFDEF 0}
 (** DOC_DISABLE *)

packages/libxml/src/hash.h → packages/libxml/src/hash.inc

@@ -74,44 +74,44 @@
 (*
  * Constructor and destructor.
  *)
-function xmlHashCreate(size: cint): xmlHashTablePtr; cdecl; external;
-function xmlHashCreateDict(size: cint; dict: xmlDictPtr): xmlHashTablePtr; cdecl; external;
-procedure xmlHashFree(table: xmlHashTablePtr; f: xmlHashDeallocator); cdecl; external;
+function xmlHashCreate(size: cint): xmlHashTablePtr; XMLCALL; XMLPUBFUN;
+function xmlHashCreateDict(size: cint; dict: xmlDictPtr): xmlHashTablePtr; XMLCALL; XMLPUBFUN;
+procedure xmlHashFree(table: xmlHashTablePtr; f: xmlHashDeallocator); XMLCALL; XMLPUBFUN;
 
 (*
  * Add a new entry to the hash table.
  *)
-function xmlHashAddEntry(table: xmlHashTablePtr; name: xmlCharPtr; userdata: pointer): cint; cdecl; external;
-function xmlHashUpdateEntry(table: xmlHashTablePtr; name: xmlCharPtr; userdata: pointer; f: xmlHashDeallocator): cint; cdecl; external;
-function xmlHashAddEntry2(table: xmlHashTablePtr; name, name2: xmlCharPtr; userdata: pointer): cint; cdecl; external;
-function xmlHashUpdateEntry2(table: xmlHashTablePtr; name, name2: xmlCharPtr; userdata: pointer; f: xmlHashDeallocator): cint; cdecl; external;
-function xmlHashAddEntry3(table: xmlHashTablePtr; name, name2, name3: xmlCharPtr; userdata: pointer): cint; cdecl; external;
-function xmlHashUpdateEntry2(table: xmlHashTablePtr; name, name2, name3: xmlCharPtr; userdata: pointer; f: xmlHashDeallocator): cint; cdecl; external;
+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;
 
 (*
  * Remove an entry from the hash table.
  *)
-function xmlHashRemoveEntry(table: xmlHashTablePtr; name: xmlCharPtr; f: xmlHashDeallocator): cint; cdecl; external;
-function xmlHashRemoveEntry2(table: xmlHashTablePtr; name, name2: xmlCharPtr; f: xmlHashDeallocator): cint; cdecl; external;
-function xmlHashRemoveEntry3(table: xmlHashTablePtr; name, name2, name3: xmlCharPtr; f: xmlHashDeallocator): cint; cdecl; external;
+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;
 
 (*
  * Retrieve the userdata.
  *)
-function xmlHashRemoveEntry(table: xmlHashTablePtr; name: xmlCharPtr): pointer; cdecl; external;
-function xmlHashRemoveEntry2(table: xmlHashTablePtr; name, name2: xmlCharPtr): pointer; cdecl; external;
-function xmlHashRemoveEntry3(table: xmlHashTablePtr; name, name2, name3: xmlCharPtr): pointer; cdecl; external;
-function xmlHashQLookup(table: xmlHashTablePtr; name, prefix: xmlCharPtr): pointer; cdecl; external;
-function xmlHashQLookup2(table: xmlHashTablePtr; name, prefix, name2, prefix2: xmlCharPtr): pointer; cdecl; external;
-function xmlHashQLookup3(table: xmlHashTablePtr; name, prefix, name2, prefix2, name3, prefix3: xmlCharPtr): pointer; cdecl; external;
+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;
 
 (*
  * Helpers.
  *)
-function xmlHashCopy(table: xmlHashTablePtr; f: xmlHashCopier): xmlHashTablePtr; cdecl; external;
-function xmlHashSize(table: xmlHashTablePtr): cint; cdecl; external;
-procedure xmlHashScan(table: xmlHashTablePtr; f: xmlHashScanner; data: pointer); cdecl; external;
-procedure xmlHashScan(table: xmlHashTablePtr; name, name2, name3: xmlCharPtr; f: xmlHashScanner; data: pointer); cdecl; external;
-procedure xmlHashScanFull(table: xmlHashTablePtr; f: xmlHashScannerFull; data: pointer); cdecl; external;
-procedure xmlHashScanFull(table: xmlHashTablePtr; name, name2, name3: xmlCharPtr; f: xmlHashScannerFull; data: pointer); cdecl; external;
+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;
 {$ENDIF}

packages/libxml/src/libxml2.pas

@@ -5,13 +5,20 @@ unit libxml2;
 
 interface
 
-{$LINKLIB libxml2.so}
-
 uses
   ctypes;
 
-{$i xmlexports.h}
-{$i xmlversion.h}
+{.$DEFINE DYNLINK}
+
+{$IFDEF DYNLINK}
+const
+  libxml2lib = 'libxml2.so';
+{$ELSE}
+  {$LINKLIB libxml2.so}
+{$ENDIF}
+
+{$i xmlexports.inc}
+{$i xmlversion.inc}
 
 type
   iconv_t = pointer;
@@ -21,23 +28,23 @@ type
 (*
   pointer forwarders
 *)
-// dict.h
+// dict.inc
   xmlDictPtr = ^xmlDict;
 
-// encoding.h
+// encoding.inc
   xmlCharEncodingHandlerPtr = ^xmlCharEncodingHandler;
 
-// entities.h
+// entities.inc
   xmlEntityPtr = ^xmlEntity;
   xmlEntitiesTablePtr = ^xmlEntitiesTable;
 
-// globals.h
+// globals.inc
   xmlGlobalStatePtr = ^xmlGlobalState;
 
-// hash.h
+// hash.inc
   xmlHashTablePtr = ^xmlHashTable;
 
-// parser.h
+// parser.inc
   xmlParserInputPtr = ^xmlParserInput;
   xmlParserInputPtrPtr = ^xmlParserInputPtr;
   xmlParserNodeInfoPtr = ^xmlParserNodeInfo;
@@ -47,7 +54,7 @@ type
   xmlSAXHandlerPtr = ^xmlSAXHandler;
   xmlSAXHandlerV1Ptr = ^xmlSAXHandlerV1;
 
-// tree.h
+// tree.inc
   xmlBufferPtr = ^xmlBuffer;
   xmlNotationPtr = ^xmlNotation;
   xmlEnumerationPtr = ^xmlEnumeration;
@@ -64,19 +71,19 @@ type
   xmlDocPtr = ^xmlDoc;
   xmlDOMWrapCtxtPtr = ^xmlDOMWrapCtxt;
 
-// list.h
+// list.inc
   xmlLinkPtr = ^xmlLink;
   xmlListPtr = ^xmlList;
 
-// uri.h
+// uri.inc
   xmlURIPtr = ^xmlURI;
 
-// relaxng.h
+// relaxng.inc
   xmlRelaxNGPtr = ^xmlRelaxNG;
   xmlRelaxNGParserCtxtPtr = ^xmlRelaxNGParserCtxt;
   xmlRelaxNGValidCtxtPtr = ^xmlRelaxNGValidCtxt;
 
-// valid.h
+// valid.inc
   xmlValidStatePtr = ^xmlValidState;
   xmlValidCtxtPtr = ^xmlValidCtxt;
   xmlNotationTablePtr = ^xmlNotationTable;
@@ -85,139 +92,139 @@ type
   xmlIDTablePtr = ^xmlIDTable;
   xmlRefTablePtr = ^xmlRefTable;
 
-// xmlautomata.h
+// xmlautomata.inc
   xmlAutomataPtr = ^xmlAutomata;
   xmlAutomataStatePtr = ^xmlAutomataState;
 
-// xmlerror.h
+// xmlerror.inc
   xmlErrorPtr = ^xmlError;
 
-// xmlIO.h
+// xmlIO.inc
   xmlParserInputBufferPtr = ^xmlParserInputBuffer;
   xmlOutputBufferPtr = ^xmlOutputBuffer;
 
-// xmlmodule.h
+// xmlmodule.inc
   xmlModulePtr = ^xmlModule;
 
-// xmlreader.h
+// xmlreader.inc
   xmlTextReaderPtr = ^xmlTextReader;
 
-// xmlregexp.h
+// xmlregexp.inc
   xmlRegexpPtr = ^xmlRegexp;
   xmlRegExecCtxtPtr = ^xmlRegExecCtxt;
   xmlExpCtxtPtr = ^xmlExpCtxt;
 
-// xmlsave.h
+// xmlsave.inc
   xmlSaveCtxtPtr = ^xmlSaveCtxt;
 
-// xmlschemas.h
+// xmlschemas.inc
   xmlSchemaPtr = ^xmlSchema;
   xmlSchemaParserCtxtPtr = ^xmlSchemaParserCtxt;
   xmlSchemaValidCtxtPtr = ^xmlSchemaValidCtxt;
   xmlSchemaSAXPlugPtr = ^xmlSchemaSAXPlugStruct;
 
-// xmlstring.h
+// xmlstring.inc
   xmlCharPtr = pchar;
   xmlCharPtrPtr = ^xmlCharPtr;
 
-// xmlwriter.h
+// xmlwriter.inc
   xmlTextWriterPtr = ^xmlTextWriter;
 
 (*
   include types
 *)
 {$DEFINE TYPE}
-  {$i dict.h}
-  {$i encoding.h}
-  {$i tree.h}
-  {$i list.h}
-  {$i entities.h}
-  {$i xmlerror.h}
-  {$i xmlmemory.h}
-  {$i hash.h}
-  {$i schemasInternals.h}
-  {$i valid.h}
-  {$i parser.h}
-  {$i uri.h}
-  {$i relaxng.h}
-  {$i globals.h}
-  {$i xmlautomata.h}
-  {$i xmlIO.h}
-  {$i xmlmodule.h}
-  {$i xmlreader.h}
-  {$i xmlregexp.h}
-  {$i xmlsave.h}
-  {$i xmlschemas.h}
-  {$i xmlschemastypes.h}
-  {$i xmlstring.h}
-  {$i xmlunicode.h}
-  {$i xmlwriter.h}
-  {.$i xpath.h}
-  {.$i c14n.h}
+  {$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 schemasInternals.inc}
+  {$i valid.inc}
+  {$i parser.inc}
+  {$i uri.inc}
+  {$i relaxng.inc}
+  {$i globals.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 xpath.inc}
+  {.$i c14n.inc}
 {$UNDEF TYPE}
 
 const
 {$DEFINE CONST}
-  {$i dict.h}
-  {$i encoding.h}
-  {$i tree.h}
-  {$i list.h}
-  {$i entities.h}
-  {$i xmlerror.h}
-  {$i xmlmemory.h}
-  {$i schemasInternals.h}
-  {$i hash.h}
-  {$i valid.h}
-  {$i parser.h}
-  {$i uri.h}
-  {$i relaxng.h}
-  {$i globals.h}
-  {$i xmlautomata.h}
-  {$i xmlIO.h}
-  {$i xmlmodule.h}
-  {$i xmlreader.h}
-  {$i xmlregexp.h}
-  {$i xmlsave.h}
-  {$i xmlschemas.h}
-  {$i xmlschemastypes.h}
-  {$i xmlstring.h}
-  {$i xmlunicode.h}
-  {$i xmlwriter.h}
-  {.$i xpath.h}
-  {.$i c14n.h}
+  {$i dict.inc}
+  {$i encoding.inc}
+  {$i tree.inc}
+  {$i list.inc}
+  {$i entities.inc}
+  {$i xmlerror.inc}
+  {$i xmlmemory.inc}
+  {$i schemasInternals.inc}
+  {$i hash.inc}
+  {$i valid.inc}
+  {$i parser.inc}
+  {$i uri.inc}
+  {$i relaxng.inc}
+  {$i globals.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 xpath.inc}
+  {.$i c14n.inc}
 {$UNDEF CONST}
 
 (*
   include functions
 *)
 {$DEFINE FUNCTION}
-  {$i dict.h}
-  {$i encoding.h}
-  {$i tree.h}
-  {$i list.h}
-  {$i entities.h}
-  {$i xmlerror.h}
-  {$i xmlmemory.h}
-  {$i schemasInternals.h}
-  {$i hash.h}
-  {$i valid.h}
-  {$i parser.h}
-  {$i uri.h}
-  {$i relaxng.h}
-  {$i globals.h}
-  {$i xmlautomata.h}
-  {$i xmlIO.h}
-  {$i xmlmodule.h}
-  {$i xmlreader.h}
-  {$i xmlregexp.h}
-  {$i xmlsave.h}
-  {$i xmlschemas.h}
-  {$i xmlschemastypes.h}
-  {$i xmlstring.h}
-  {$i xmlunicode.h}
-  {$i xmlwriter.h}
-  {.$i xpath.h}
-  {.$i c14n.h}
+  {$i dict.inc}
+  {$i encoding.inc}
+  {$i tree.inc}
+  {$i list.inc}
+  {$i entities.inc}
+  {$i xmlerror.inc}
+  {$i xmlmemory.inc}
+  {$i schemasInternals.inc}
+  {$i hash.inc}
+  {$i valid.inc}
+  {$i parser.inc}
+  {$i uri.inc}
+  {$i relaxng.inc}
+  {$i globals.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 xpath.inc}
+  {.$i c14n.inc}
 {$UNDEF FUNCTION}
 
 implementation

packages/libxml/src/list.h

@@ -1,80 +0,0 @@
-(*
- * Summary: lists interfaces
- * Description: this module implement the list support used in 
- * various place in the library.
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Gary Pennington <[email protected]>
- *)
-
-{$IFDEF TYPE}
-  xmlLink = record end;
-  xmlList = record end;
-
-(**
- * xmlListDeallocator:
- * @lk:  the data to deallocate
- *
- * Callback function used to free data from a list.
- *)
-  xmlListDeallocator = procedure(lk: xmlLinkPtr); cdecl;
-
-(**
- * xmlListDataCompare:
- * @data0: the first data
- * @data1: the second data
- *
- * Callback function used to compare 2 data.
- *
- * Returns 0 is equality, -1 or 1 otherwise depending on the ordering.
- *)
-  xmlListDataCompare = function(data0, data1: pointer): cint; cdecl;
-
-(**
- * xmlListWalker:
- * @data: the data found in the list
- * @user: extra user provided data to the walker
- *
- * Callback function used when walking a list with xmlListWalk().
- *
- * Returns 0 to stop walking the list, 1 otherwise.
- *)
-  xmlListWalker = function(data, user: pointer): cint; cdecl;
-{$ENDIF}
-
-{$IFDEF FUNCTION}
-(* Creation/Deletion *)
-function xmlListCreate(deallocator: xmlListDeallocator; compare: xmlListDataCompare): xmlListPtr; cdecl; external;
-procedure xmlListDelete(l: xmlListPtr); cdecl; external;
-
-(* Basic Operators *)
-function xmlListSearch(l: xmlListPtr; data: pointer): pointer; cdecl; external;
-function xmlListReverseSearch(l: xmlListPtr; data: pointer): pointer; cdecl; external;
-function xmlListInsert(l: xmlListPtr; data: pointer): cint; cdecl; external;
-function xmlListAppend(l: xmlListPtr; data: pointer): cint; cdecl; external;
-function xmlListRemoveFirst(l: xmlListPtr; data: pointer): cint; cdecl; external;
-function xmlListRemoveLast(l: xmlListPtr; data: pointer): cint; cdecl; external;
-function xmlListRemoveAll(l: xmlListPtr; data: pointer): cint; cdecl; external;
-procedure xmlListClear(l: xmlListPtr); cdecl; external;
-function xmlListEmpty(l: xmlListPtr): cint; cdecl; external;
-function xmlListFront(l: xmlListPtr): xmlLinkPtr; cdecl; external;
-function xmlListEnd(l: xmlListPtr): xmlLinkPtr; cdecl; external;
-function xmlListSize(l: xmlListPtr): cint; cdecl; external;
-procedure xmlListPopFront(l: xmlListPtr); cdecl; external;
-procedure xmlListPopBack(l: xmlListPtr); cdecl; external;
-function xmlListPushFront(l: xmlListPtr; data: pointer): cint; cdecl; external;
-function xmlListPushBack(l: xmlListPtr; data: pointer): cint; cdecl; external;
-
-(* Advanced Operators *)
-procedure xmlListReverse(l: xmlListPtr); cdecl; external;
-procedure xmlListSort(l: xmlListPtr); cdecl; external;
-procedure xmlListWalk(l: xmlListPtr; walker: xmlListWalker; user: pointer); cdecl; external;
-procedure xmlListReverseWalk(l: xmlListPtr; walker: xmlListWalker; user: pointer); cdecl; external;
-procedure xmlListMerge(l1, l2: xmlListPtr); cdecl; external;
-function xmlListDup(old: xmlListPtr): xmlListPtr; cdecl; external;
-function xmlListDup(cur, old: xmlListPtr): cint; cdecl; external;
-
-(* Link operators *)
-function xmlLinkGetData(lk: xmlLinkPtr): cint; cdecl; external;
-{$ENDIF}

packages/libxml/src/list.inc

@@ -0,0 +1,80 @@
+(*
+ * Summary: lists interfaces
+ * Description: this module implement the list support used in 
+ * various place in the library.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Gary Pennington <[email protected]>
+ *)
+
+{$IFDEF TYPE}
+  xmlLink = record end;
+  xmlList = record end;
+
+(**
+ * xmlListDeallocator:
+ * @lk:  the data to deallocate
+ *
+ * Callback function used to free data from a list.
+ *)
+  xmlListDeallocator = procedure(lk: xmlLinkPtr); XMLCALL;
+
+(**
+ * xmlListDataCompare:
+ * @data0: the first data
+ * @data1: the second data
+ *
+ * Callback function used to compare 2 data.
+ *
+ * Returns 0 is equality, -1 or 1 otherwise depending on the ordering.
+ *)
+  xmlListDataCompare = function(data0, data1: pointer): cint; XMLCALL;
+
+(**
+ * xmlListWalker:
+ * @data: the data found in the list
+ * @user: extra user provided data to the walker
+ *
+ * Callback function used when walking a list with xmlListWalk().
+ *
+ * Returns 0 to stop walking the list, 1 otherwise.
+ *)
+  xmlListWalker = function(data, user: pointer): cint; XMLCALL;
+{$ENDIF}
+
+{$IFDEF FUNCTION}
+(* Creation/Deletion *)
+function xmlListCreate(deallocator: xmlListDeallocator; compare: xmlListDataCompare): xmlListPtr; XMLCALL; XMLPUBFUN;
+procedure xmlListDelete(l: xmlListPtr); XMLCALL; XMLPUBFUN;
+
+(* 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;
+
+(* 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;
+
+(* Link operators *)
+function xmlLinkGetData(lk: xmlLinkPtr): cint; XMLCALL; XMLPUBFUN;
+{$ENDIF}

packages/libxml/src/parser.h → packages/libxml/src/parser.inc

@@ -32,7 +32,7 @@
  *
  * Callback for freeing some parser input allocations.
  *)
-  xmlParserInputDeallocate = procedure(str: xmlCharPtr); cdecl;
+  xmlParserInputDeallocate = procedure(str: xmlCharPtr); XMLCALL;
 
   xmlParserInput = record
     (* Input buffer *)
@@ -316,7 +316,7 @@
  *
  * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
  *)
-  resolveEntitySAXFunc = function(ctx: pointer; publicID, systemID: xmlCharPtr): xmlParserInputPtr; cdecl;
+  resolveEntitySAXFunc = function(ctx: pointer; publicID, systemID: xmlCharPtr): xmlParserInputPtr; XMLCALL;
 
 (**
  * internalSubsetSAXFunc:
@@ -327,7 +327,7 @@
  *
  * Callback on internal subset declaration.
  *)
-  internalSubsetSAXFunc = procedure(ctx: pointer; name, ExternalID, SystemID: xmlCharPtr); cdecl;
+  internalSubsetSAXFunc = procedure(ctx: pointer; name, ExternalID, SystemID: xmlCharPtr); XMLCALL;
 
 (**
  * externalSubsetSAXFunc:
@@ -338,7 +338,7 @@
  *
  * Callback on external subset declaration.
  *)
-  externalSubsetSAXFunc = procedure(ctx: pointer; name, ExternalID, SystemID: xmlCharPtr); cdecl;
+  externalSubsetSAXFunc = procedure(ctx: pointer; name, ExternalID, SystemID: xmlCharPtr); XMLCALL;
 
 (**
  * getEntitySAXFunc:
@@ -349,7 +349,7 @@
  *
  * Returns the xmlEntityPtr if found.
  *)
-  getEntitySAXFunc = function(ctx: pointer; name: xmlCharPtr): xmlEntityPtr; cdecl;
+  getEntitySAXFunc = function(ctx: pointer; name: xmlCharPtr): xmlEntityPtr; XMLCALL;
 
 (**
  * getParameterEntitySAXFunc:
@@ -360,7 +360,7 @@
  *
  * Returns the xmlEntityPtr if found.
  *)
-  getParameterEntitySAXFunc = function(ctx: pointer; name: xmlCharPtr): xmlEntityPtr; cdecl;
+  getParameterEntitySAXFunc = function(ctx: pointer; name: xmlCharPtr): xmlEntityPtr; XMLCALL;
 
 (**
  * entityDeclSAXFunc:
@@ -373,7 +373,7 @@
  *
  * An entity definition has been parsed.
  *)
-  entityDeclSAXFunc = procedure(ctx: pointer; name: xmlCharPtr; _type: cint; publicId, systemId, content: xmlCharPtr); cdecl;
+  entityDeclSAXFunc = procedure(ctx: pointer; name: xmlCharPtr; _type: cint; publicId, systemId, content: xmlCharPtr); XMLCALL;
 
 (**
  * notationDeclSAXFunc:
@@ -384,7 +384,7 @@
  *
  * What to do when a notation declaration has been parsed.
  *)
-  notationDeclSAXFunc = procedure(ctx: pointer; name, publicId, systemId: xmlCharPtr); cdecl;
+  notationDeclSAXFunc = procedure(ctx: pointer; name, publicId, systemId: xmlCharPtr); XMLCALL;
 
 (**
  * attributeDeclSAXFunc:
@@ -398,7 +398,7 @@
  *
  * An attribute definition has been parsed.
  *)
-  attributeDeclSAXFunc = procedure(ctx: pointer; elem, fullname: xmlCharPtr; _type, def: cint; defaultValue: xmlCharPtr; tree: xmlEnumerationPtr); cdecl;
+  attributeDeclSAXFunc = procedure(ctx: pointer; elem, fullname: xmlCharPtr; _type, def: cint; defaultValue: xmlCharPtr; tree: xmlEnumerationPtr); XMLCALL;
 
 (**
  * elementDeclSAXFunc:
@@ -409,7 +409,7 @@
  *
  * An element definition has been parsed.
  *)
-  elementDeclSAXFunc = procedure(ctx: pointer; name: xmlCharPtr; _type: cint; content: xmlElementContentPtr); cdecl;
+  elementDeclSAXFunc = procedure(ctx: pointer; name: xmlCharPtr; _type: cint; content: xmlElementContentPtr); XMLCALL;
 
 (**
  * unparsedEntityDeclSAXFunc:
@@ -421,7 +421,7 @@
  *
  * What to do when an unparsed entity declaration is parsed.
  *)
-  unparsedEntityDeclSAXFunc = procedure(ctx: pointer; name, publicId, systemId, notationName: xmlCharPtr); cdecl;
+  unparsedEntityDeclSAXFunc = procedure(ctx: pointer; name, publicId, systemId, notationName: xmlCharPtr); XMLCALL;
 
 (**
  * setDocumentLocatorSAXFunc:
@@ -431,7 +431,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); cdecl;
+  setDocumentLocatorSAXFunc = procedure(ctx: pointer; loc: xmlSAXLocatorPtr); XMLCALL;
 
 (**
  * startDocumentSAXFunc:
@@ -439,7 +439,7 @@
  *
  * Called when the document start being processed.
  *)
-  startDocumentSAXFunc = procedure(ctx: pointer); cdecl;
+  startDocumentSAXFunc = procedure(ctx: pointer); XMLCALL;
 
 (**
  * endDocumentSAXFunc:
@@ -447,7 +447,7 @@
  *
  * Called when the document end has been detected.
  *)
-  endDocumentSAXFunc = procedure(ctx: pointer); cdecl;
+  endDocumentSAXFunc = procedure(ctx: pointer); XMLCALL;
 
 (**
  * startElementSAXFunc:
@@ -457,7 +457,7 @@
  *
  * Called when an opening tag has been processed.
  *)
-  startElementSAXFunc = procedure(ctx: pointer; name: xmlCharPtr; atts: xmlCharPtrPtr); cdecl;
+  startElementSAXFunc = procedure(ctx: pointer; name: xmlCharPtr; atts: xmlCharPtrPtr); XMLCALL;
 
 (**
  * endElementSAXFunc:
@@ -466,7 +466,7 @@
  *
  * Called when the end of an element has been detected.
  *)
-  endElementSAXFunc = procedure(ctx: pointer; name: xmlCharPtr); cdecl;
+  endElementSAXFunc = procedure(ctx: pointer; name: xmlCharPtr); XMLCALL;
 
 (**
  * attributeSAXFunc:
@@ -479,7 +479,7 @@
  * DOM subtree and past it in a new xmlAttr element added to
  * the element.
  *)
-  attributeSAXFunc = procedure(ctx: pointer; name, value: xmlCharPtr); cdecl;
+  attributeSAXFunc = procedure(ctx: pointer; name, value: xmlCharPtr); XMLCALL;
 
 (**
  * referenceSAXFunc:
@@ -488,7 +488,7 @@
  *
  * Called when an entity reference is detected. 
  *)
-  referenceSAXFunc = procedure(ctx: pointer; name: xmlCharPtr); cdecl;
+  referenceSAXFunc = procedure(ctx: pointer; name: xmlCharPtr); XMLCALL;
 
 (**
  * charactersSAXFunc:
@@ -498,7 +498,7 @@
  *
  * Receiving some chars from the parser.
  *)
-  charactersSAXFunc = procedure(ctx: pointer; ch: xmlCharPtr; len: cint); cdecl;
+  charactersSAXFunc = procedure(ctx: pointer; ch: xmlCharPtr; len: cint); XMLCALL;
 
 (**
  * ignorableWhitespaceSAXFunc:
@@ -509,7 +509,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); cdecl;
+  ignorableWhitespaceSAXFunc = procedure(ctx: pointer; ch: xmlCharPtr; len: cint); XMLCALL;
 
 (**
  * processingInstructionSAXFunc:
@@ -519,7 +519,7 @@
  *
  * A processing instruction has been parsed.
  *)
-  processingInstructionSAXFunc = procedure(ctx: pointer; target, data: xmlCharPtr); cdecl;
+  processingInstructionSAXFunc = procedure(ctx: pointer; target, data: xmlCharPtr); XMLCALL;
 
 (**
  * commentSAXFunc:
@@ -528,7 +528,7 @@
  *
  * A comment has been parsed.
  *)
-  commentSAXFunc = procedure(ctx: pointer; value: xmlCharPtr); cdecl;
+  commentSAXFunc = procedure(ctx: pointer; value: xmlCharPtr); XMLCALL;
 
 (**
  * cdataBlockSAXFunc:
@@ -538,7 +538,7 @@
  *
  * Called when a pcdata block has been parsed.
  *)
-  cdataBlockSAXFunc = procedure(ctx: pointer; value: xmlCharPtr; len: cint); cdecl;
+  cdataBlockSAXFunc = procedure(ctx: pointer; value: xmlCharPtr; len: cint); XMLCALL;
 
 (**
  * warningSAXFunc:
@@ -548,7 +548,7 @@
  * 
  * Display and format a warning messages, callback.
  *)
-  warningSAXFunc = procedure(ctx: pointer; msg: pchar; args: array of const); cdecl;
+  warningSAXFunc = procedure(ctx: pointer; msg: pchar; args: array of const); XMLCDECL;
 
 (**
  * errorSAXFunc:
@@ -558,7 +558,7 @@
  * 
  * Display and format an error messages, callback.
  *)
-  errorSAXFunc = procedure(ctx: pointer; msg: pchar; args: array of const); cdecl;
+  errorSAXFunc = procedure(ctx: pointer; msg: pchar; args: array of const); XMLCDECL;
 
 (**
  * fatalErrorSAXFunc:
@@ -570,7 +570,7 @@
  * Note: so far fatalError() SAX callbacks are not used, error()
  *       get all the callbacks for errors.
  *)
-  fatalErrorSAXFunc = procedure(ctx: pointer; msg: pchar; args: array of const); cdecl;
+  fatalErrorSAXFunc = procedure(ctx: pointer; msg: pchar; args: array of const); XMLCDECL;
 
 (**
  * isStandaloneSAXFunc:
@@ -580,7 +580,7 @@
  *
  * Returns 1 if true
  *)
-  isStandaloneSAXFunc = function(ctx: pointer): cint; cdecl;
+  isStandaloneSAXFunc = function(ctx: pointer): cint; XMLCALL;
 
 (**
  * hasInternalSubsetSAXFunc:
@@ -590,7 +590,7 @@
  *
  * Returns 1 if true
  *)
-  hasInternalSubsetSAXFunc = function(ctx: pointer): cint; cdecl;
+  hasInternalSubsetSAXFunc = function(ctx: pointer): cint; XMLCALL;
 
 (**
  * hasExternalSubsetSAXFunc:
@@ -600,7 +600,7 @@
  *
  * Returns 1 if true
  *)
-  hasExternalSubsetSAXFunc = function(ctx: pointer): cint; cdecl;
+  hasExternalSubsetSAXFunc = function(ctx: pointer): cint; XMLCALL;
 
 
 (************************************************************************
@@ -803,146 +803,146 @@ const
 (*
  * Init/Cleanup
  *)
-procedure xmlInitParser; cdecl; external;
-procedure xmlCleanupParser; cdecl; external;
+procedure xmlInitParser; XMLCALL; XMLPUBFUN;
+procedure xmlCleanupParser; XMLCALL; XMLPUBFUN;
 
 (*
  * Input functions
  *)
-function xmlParserInputRead(_in: xmlParserInputPtr; len: cint): cint; cdecl; external;
-function xmlParserInputGrow(_in: xmlParserInputPtr; len: cint): cint; cdecl; external;
+function xmlParserInputRead(_in: xmlParserInputPtr; len: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlParserInputGrow(_in: xmlParserInputPtr; len: cint): cint; XMLCALL; XMLPUBFUN;
 
 (*
  * Basic parsing Interfaces
  *)
 {$IFDEF LIBXML_SAX1_ENABLED}
-function xmlParseDoc(cur: xmlCharPtr): xmlDocPtr; cdecl; external;
-function xmlParseFile(filename: pchar): xmlDocPtr; cdecl; external;
-function xmlParseMemory(buffer: pchar; size: cint): xmlDocPtr; cdecl; external;
+function xmlParseDoc(cur: xmlCharPtr): xmlDocPtr; XMLCALL; XMLPUBFUN;
+function xmlParseFile(filename: pchar): xmlDocPtr; XMLCALL; XMLPUBFUN;
+function xmlParseMemory(buffer: pchar; size: cint): xmlDocPtr; XMLCALL; XMLPUBFUN;
 {$ENDIF} (* LIBXML_SAX1_ENABLED *)
-function xmlSubstituteEntitiesDefault(val: cint): cint; cdecl; external;
-function xmlKeepBlanksDefault(val: cint): cint; cdecl; external;
-procedure xmlStopParser(ctxt: xmlParserCtxtPtr); cdecl; external;
-function xmlPedanticParserDefault(val: cint): cint; cdecl; external;
-function xmlLineNumbersDefault(val: cint): cint; cdecl; external;
+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;
 
 {$IFDEF LIBXML_SAX1_ENABLED}
 (*
  * Recovery mode 
  *)
-function xmlRecoverDoc(cur: xmlCharPtr): xmlDocPtr; cdecl; external;
-function xmlRecoverMemory(buffer: pchar; size: cint): xmlDocPtr; cdecl; external;
-function xmlRecoverFile(filename: pchar): xmlDocPtr; cdecl; external;
+function xmlRecoverDoc(cur: xmlCharPtr): xmlDocPtr; XMLCALL; XMLPUBFUN;
+function xmlRecoverMemory(buffer: pchar; size: cint): xmlDocPtr; XMLCALL; XMLPUBFUN;
+function xmlRecoverFile(filename: pchar): xmlDocPtr; XMLCALL; XMLPUBFUN;
 {$ENDIF} (* LIBXML_SAX1_ENABLED *)
 
 (*
  * Less common routines and SAX interfaces
  *)
-function xmlParseDocument(ctxt: xmlParserCtxtPtr): cint; cdecl; external;
-function xmlParseExtParsedEnt(ctxt: xmlParserCtxtPtr): cint; cdecl; external;
+function xmlParseDocument(ctxt: xmlParserCtxtPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlParseExtParsedEnt(ctxt: xmlParserCtxtPtr): cint; XMLCALL; XMLPUBFUN;
 {$IFDEF LIBXML_SAX1_ENABLED}
-function xmlSAXUserParseFile(sax: xmlSAXHandlerPtr; user_data: pointer; filename: pchar): cint; cdecl; external;
-function xmlSAXUserParseMemory(sax: xmlSAXHandlerPtr; user_data: pointer; buffer: pchar; size: cint): cint; cdecl; external;
-function xmlSAXParseDoc(sax: xmlSAXHandlerPtr; cur: xmlCharPtr; recovery: cint): xmlDocPtr; cdecl; external;
-function xmlSAXParseMemory(sax: xmlSAXHandlerPtr; buffer: pchar; size: cint; recovery: cint): xmlDocPtr; cdecl; external;
-function xmlSAXParseMemoryWithData(sax: xmlSAXHandlerPtr; buffer: pchar; size: cint; recovery: cint; data: pointer): xmlDocPtr; cdecl; external;
-function xmlSAXParseFile(sax: xmlSAXHandlerPtr; filename: pchar; recovery: cint): xmlDocPtr; cdecl; external;
-function xmlSAXParseFileWithData(sax: xmlSAXHandlerPtr; filename: pchar; recovery: cint; data: pointer): xmlDocPtr; cdecl; external;
-function xmlSAXParseEntity(sax: xmlSAXHandlerPtr; filename: pchar): xmlDocPtr; cdecl; external;
-function xmlParseEntity(filename: pchar): xmlDocPtr; cdecl; external;
+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;
 {$ENDIF} (* LIBXML_SAX1_ENABLED *)
 
 {$IFDEF LIBXML_VALID_ENABLED}
-function xmlSAXParseDTD(sax: xmlSAXHandlerPtr; ExternalID, SystemID: xmlCharPtr): xmlDtdPtr; cdecl; external;
-function xmlParseDTD(ExternalID, SystemID: xmlCharPtr): xmlDtdPtr; cdecl; external;
-function xmlIOParseDTD(sax: xmlSAXHandlerPtr; input: xmlParserInputBufferPtr; enc: xmlCharEncoding): xmlDtdPtr; cdecl; external;
+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;
 {$ENDIF} (* LIBXML_VALID_ENABLE *)
 {$IFDEF LIBXML_SAX1_ENABLED}
-function xmlParseBalancedChunkMemory(doc: xmlDocPtr; sax: xmlSAXHandlerPtr; user_data: pointer; depth: cint; _string: xmlCharPtr; lst: xmlNodePtrPtr): cint; cdecl; external;
+function xmlParseBalancedChunkMemory(doc: xmlDocPtr; sax: xmlSAXHandlerPtr; user_data: pointer; depth: cint; _string: xmlCharPtr; lst: xmlNodePtrPtr): cint; XMLCALL; XMLPUBFUN;
 {$ENDIF} (* LIBXML_SAX1_ENABLED *)
-function xmlParseInNodeContext(node: xmlNodePtr; data: pchar; datalen, options: cint; lst: xmlNodePtrPtr): xmlParserErrors; cdecl; external;
+function xmlParseInNodeContext(node: xmlNodePtr; data: pchar; datalen, options: cint; lst: xmlNodePtrPtr): xmlParserErrors; XMLCALL; XMLPUBFUN;
 {$IFDEF LIBXML_SAX1_ENABLED}
 function xmlParseBalancedChunkMemoryRecover(doc: xmlDocPtr; sax: xmlSAXHandlerPtr; user_data: pointer;
-  depth: cint; _string: xmlCharPtr; lst: xmlNodePtrPtr; recover: cint): cint; cdecl; external;
+  depth: cint; _string: xmlCharPtr; lst: xmlNodePtrPtr; recover: cint): cint; XMLCALL; XMLPUBFUN;
 function xmlParseExternalEntity(doc: xmlDocPtr; sax: xmlSAXHandlerPtr; user_data: pointer;
-  depth: cint; URL, ID: xmlCharPtr; lst: xmlNodePtrPtr): cint; cdecl; external;
+  depth: cint; URL, ID: xmlCharPtr; lst: xmlNodePtrPtr): cint; XMLCALL; XMLPUBFUN;
 
 {$ENDIF} (* LIBXML_SAX1_ENABLED *)
-function xmlParseCtxtExternalEntity(ctx: xmlParserCtxtPtr; URL, ID: xmlCharPtr; lst: xmlNodePtrPtr): cint; cdecl; external;
+function xmlParseCtxtExternalEntity(ctx: xmlParserCtxtPtr; URL, ID: xmlCharPtr; lst: xmlNodePtrPtr): cint; XMLCALL; XMLPUBFUN;
 
 (*
  * Parser contexts handling.
  *)
-function xmlNewParserCtxt: xmlParserCtxtPtr; cdecl; external;
-function xmlInitParserCtxt(ctxt: xmlParserCtxtPtr): cint; cdecl; external;
-procedure xmlClearParserCtxt(ctxt: xmlParserCtxtPtr); cdecl; external;
-procedure xmlFreeParserCtxt(ctxt: xmlParserCtxtPtr); cdecl; external;
+function xmlNewParserCtxt: xmlParserCtxtPtr; XMLCALL; XMLPUBFUN;
+function xmlInitParserCtxt(ctxt: xmlParserCtxtPtr): cint; XMLCALL; XMLPUBFUN;
+procedure xmlClearParserCtxt(ctxt: xmlParserCtxtPtr); XMLCALL; XMLPUBFUN;
+procedure xmlFreeParserCtxt(ctxt: xmlParserCtxtPtr); XMLCALL; XMLPUBFUN;
 {$IFDEF LIBXML_SAX1_ENABLED}
-procedure xmlSetupParserForBuffer(ctxt: xmlParserCtxtPtr; buffer: xmlCharPtr; filename: pchar); cdecl; external;
+procedure xmlSetupParserForBuffer(ctxt: xmlParserCtxtPtr; buffer: xmlCharPtr; filename: pchar); XMLCALL; XMLPUBFUN;
 {$ENDIF} (* LIBXML_SAX1_ENABLED *)
-function xmlCreateDocParserCtxt(cur: xmlCharPtr): xmlParserCtxtPtr; cdecl; external;
+function xmlCreateDocParserCtxt(cur: xmlCharPtr): xmlParserCtxtPtr; XMLCALL; XMLPUBFUN;
 
 {$IFDEF LIBXML_LEGACY_ENABLED}
 (*
  * Reading/setting optional parsing features.
  *)
-function xmlGetFeaturesList(var len: cint; var result: pchar): cint; cdecl; external;
-function xmlGetFeature(ctxt: xmlParserCtxtPtr; name: pchar; result: pointer): cint; cdecl; external;
-function xmlSetFeature(ctxt: xmlParserCtxtPtr; name: pchar; value: pointer): cint; cdecl; external;
+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;
 {$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; cdecl; external;
-function xmlParseChunk(ctxt: xmlParserCtxtPtr; chunk: pchar; size, terminate: cint): cint; cdecl; external;
+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;
 {$ENDIF} (* LIBXML_PUSH_ENABLED *)
 
 (*
  * Special I/O mode.
  *)
 function xmlCreateIOParserCtxt(sax: xmlSAXHandlerPtr; user_data: pointer; ioread: xmlInputReadCallback;
-  ioclose: xmlInputCloseCallback; ioctx: pointer; enc: xmlCharEncoding): xmlParserCtxtPtr; cdecl; external;
-function xmlNewIOInputStream(ctxt: xmlParserCtxtPtr; input: xmlParserInputBufferPtr; enc: xmlCharEncoding): xmlParserInputPtr; cdecl; external;
+  ioclose: xmlInputCloseCallback; ioctx: pointer; enc: xmlCharEncoding): xmlParserCtxtPtr; XMLCALL; XMLPUBFUN;
+function xmlNewIOInputStream(ctxt: xmlParserCtxtPtr; input: xmlParserInputBufferPtr; enc: xmlCharEncoding): xmlParserInputPtr; XMLCALL; XMLPUBFUN;
 
 (*
  * Node infos.
  *)
-function xmlParserFindNodeInfo(ctxt: xmlParserCtxtPtr; node: xmlNodePtr): xmlParserNodeInfoPtr; cdecl; external;
-procedure xmlInitNodeInfoSeq(seq: xmlParserNodeInfoSeqPtr); cdecl; external;
-procedure xmlClearNodeInfoSeq(seq: xmlParserNodeInfoSeqPtr); cdecl; external;
-function xmlParserFindNodeInfoIndex(seq: xmlParserNodeInfoSeqPtr; node: xmlNodePtr): culong; cdecl; external;
-procedure xmlParserAddNodeInfo(ctxt: xmlParserCtxtPtr; info: xmlParserNodeInfoPtr); cdecl; external;
+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;
 
 (*
  * External entities handling actually implemented in xmlIO.
  *)
-procedure xmlSetExternalEntityLoader(f: xmlExternalEntityLoader); cdecl; external;
-function xmlGetExternalEntityLoader(): xmlExternalEntityLoader; cdecl; external;
-function xmlLoadExternalEntity(URL, ID: pchar; ctxt: xmlParserCtxtPtr): xmlParserInputPtr; cdecl; external;
+procedure xmlSetExternalEntityLoader(f: xmlExternalEntityLoader); XMLCALL; XMLPUBFUN;
+function xmlGetExternalEntityLoader(): xmlExternalEntityLoader; XMLCALL; XMLPUBFUN;
+function xmlLoadExternalEntity(URL, ID: pchar; ctxt: xmlParserCtxtPtr): xmlParserInputPtr; XMLCALL; XMLPUBFUN;
 
 (*
  * Index lookup, actually implemented in the encoding module
  *)
-function xmlByteConsumed(ctxt: xmlParserCtxtPtr): culong; cdecl; external;
+function xmlByteConsumed(ctxt: xmlParserCtxtPtr): culong; XMLCALL; XMLPUBFUN;
 
 (*
  * New set of simpler/more flexible APIs
  *)
-procedure xmlCtxtReset(ctxt: xmlParserCtxtPtr); cdecl; external;
-function xmlCtxtResetPush(ctxt: xmlParserCtxtPtr; chunk: pchar; size: cint; filename, encoding: pchar): cint; cdecl; external;
-function xmlCtxtUseOptions(ctxt: xmlParserCtxtPtr; options: cint): cint; cdecl; external;
-function xmlReadDoc(cur: xmlCharPtr; URL, encoding: pchar; options: cint): xmlDocPtr; cdecl; external;
-function xmlReadFile(filename, encoding: pchar; options: cint): xmlDocPtr; cdecl; external;
-function xmlReadMemory(buffer: pchar; size: cint; URL, encoding: pchar; options: cint): xmlDocPtr; cdecl; external;
-function xmlReadFd(fd: cint; URL, encoding: pchar; options: cint): xmlDocPtr; cdecl; external;
-function xmlReadIO(ioread: xmlInputReadCallback; ioclose: xmlInputCloseCallback; ioctx: pchar; URL, encoding: pchar; options: cint): xmlDocPtr; cdecl; external;
-function xmlCtxtReadDoc(ctxt: xmlParserCtxtPtr; cur: xmlCharPtr; URL, encoding: pchar; options: cint): xmlDocPtr; cdecl; external;
-function xmlCtxtReadFile(ctxt: xmlParserCtxtPtr; filename, encoding: pchar; options: cint): xmlDocPtr; cdecl; external;
-function xmlCtxtReadMemory(ctxt: xmlParserCtxtPtr; buffer: pchar; size: cint; URL, encoding: pchar; options: cint): xmlDocPtr; cdecl; external;
-function xmlCtxtReadFd(ctxt: xmlParserCtxtPtr; fd: cint; URL, encoding: pchar; options: cint): xmlDocPtr; cdecl; external;
-function xmlCtxtReadIO(ctxt: xmlParserCtxtPtr; ioread: xmlInputReadCallback; ioclose: xmlInputCloseCallback; ioctx: pchar; URL, encoding: pchar; options: cint): xmlDocPtr; cdecl; external;
+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;
 
 (*
  * Library wide options
@@ -954,6 +954,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; cdecl; external;
+function xmlHasFeature(feature: xmlFeature): cint; XMLCALL; XMLPUBFUN;
 {$ENDIF}
 

packages/libxml/src/relaxng.h → packages/libxml/src/relaxng.inc

@@ -17,8 +17,8 @@
 (**
  * A schemas validation context
  *)
-  xmlRelaxNGValidityErrorFunc = procedure(ctx: pointer; msg: pchar; args: array of const); cdecl;
-  xmlRelaxNGValidityWarningFunc = procedure(ctx: pointer; msg: pchar; args: array of const); cdecl;
+  xmlRelaxNGValidityErrorFunc = procedure(ctx: pointer; msg: pchar; args: array of const); XMLCDECL;
+  xmlRelaxNGValidityWarningFunc = procedure(ctx: pointer; msg: pchar; args: array of const); XMLCDECL;
 
   xmlRelaxNGParserCtxt = record
   end;
@@ -88,22 +88,22 @@
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-function xmlRelaxNGInitTypes: cint; cdecl; external;
-function xmlRelaxNGCleanupTypes: cint; cdecl; external;
+function xmlRelaxNGInitTypes: cint; XMLCALL; XMLPUBFUN;
+function xmlRelaxNGCleanupTypes: cint; XMLCALL; XMLPUBFUN;
 
 (*
  * Interfaces for parsing.
  *)
-function xmlRelaxNGNewParserCtxt(URL: pchar): xmlRelaxNGParserCtxtPtr; cdecl; external;
-function xmlRelaxNGNewMemParserCtxt(buffer: pchar; size: cint): xmlRelaxNGParserCtxtPtr; cdecl; external;
-function xmlRelaxNGNewDocParserCtxt(doc: xmlDocPtr): xmlRelaxNGParserCtxtPtr; cdecl; external;
-function xmlRelaxParserSetFlag(ctxt: xmlRelaxNGParserCtxtPtr; flag: cint; doc: xmlDocPtr): cint; cdecl; external;
-procedure xmlRelaxNGFreeParserCtxt(ctxt: xmlRelaxNGParserCtxtPtr); cdecl; external;
-procedure xmlRelaxNGSetParserErrors(ctxt: xmlRelaxNGParserCtxtPtr; err: xmlRelaxNGValidityErrorFunc; warn: xmlRelaxNGValidityWarningFunc; ctx: pointer); cdecl; external;
-function xmlRelaxNGGetParserErrors(ctxt: xmlRelaxNGParserCtxtPtr; var err: xmlRelaxNGValidityErrorFunc; var warn: xmlRelaxNGValidityWarningFunc; var ctx: pointer): cint; cdecl; external;
-procedure xmlRelaxNGSetParserStructuredErrors(ctxt: xmlRelaxNGParserCtxtPtr; serror: xmlStructuredErrorFunc; ctx: pointer); cdecl; external;
-function xmlRelaxNGParse(ctxt: xmlRelaxNGParserCtxtPtr): xmlRelaxNGPtr; cdecl; external;
-procedure xmlRelaxNGFree(schema: xmlRelaxNGPtr); cdecl; external;
+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;
 {$IFDEF LIBXML_OUTPUT_ENABLED}
 {XMLPUBFUN void XMLCALL
 		    xmlRelaxNGDump		(FILE *output,
@@ -116,20 +116,20 @@ XMLPUBFUN void XMLCALL
 (*
  * Interfaces for validating
  *)
-procedure xmlRelaxNGSetValidErrors(ctxt: xmlRelaxNGValidCtxtPtr; err: xmlRelaxNGValidityErrorFunc; warn: xmlRelaxNGValidityWarningFunc; ctx: pointer); cdecl; external;
-function xmlRelaxNGGetValidErrors(ctxt: xmlRelaxNGValidCtxtPtr; var err: xmlRelaxNGValidityErrorFunc; var warn: xmlRelaxNGValidityWarningFunc; var ctx: pointer): cint; cdecl; external;
-procedure xmlRelaxNGSetValidErrors(ctxt: xmlRelaxNGValidCtxtPtr; serror: xmlStructuredErrorFunc; ctx: pointer); cdecl; external;
-function xmlRelaxNGNewValidCtxt(schema: xmlRelaxNGPtr): xmlRelaxNGValidCtxtPtr; cdecl; external;
-procedure xmlRelaxNGFreeValidCtxt(ctxt: xmlRelaxNGValidCtxtPtr); cdecl; external;
-function xmlRelaxNGValidateDoc(ctxt: xmlRelaxNGValidCtxtPtr; doc: xmlDocPtr): cint; cdecl; external;
+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;
 
 (*
  * Interfaces for progressive validation when possible
  *)
-function xmlRelaxNGValidatePushElement(ctxt: xmlRelaxNGValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr): cint; cdecl; external;
-function xmlRelaxNGValidatePushCData(ctxt: xmlRelaxNGValidCtxtPtr; data: xmlCharPtr; len: cint): cint; cdecl; external;
-function xmlRelaxNGValidatePopElement(ctxt: xmlRelaxNGValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr): cint; cdecl; external;
-function xmlRelaxNGValidateFullElement(ctxt: xmlRelaxNGValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr): cint; cdecl; external;
+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;
 {$ENDIF}
 {$ENDIF} (* LIBXML_SCHEMAS_ENABLED *)
 

packages/libxml/src/tree.h → packages/libxml/src/tree.inc

@@ -523,43 +523,43 @@
 {$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; cdecl; external;
+function xmlValidateNCName(value: xmlCharPtr; space: cint): cint; XMLCALL; XMLPUBFUN;
 {$ENDIF}
 
 {$IF defined(LIBXML_TREE_ENABLED) or defined(LIBXML_SCHEMAS_ENABLED)}
-function xmlValidateQName(value: xmlCharPtr; space: cint): cint; cdecl; external;
-function xmlValidateName(value: xmlCharPtr; space: cint): cint; cdecl; external;
-function xmlValidateNMToken(value: xmlCharPtr; space: cint): cint; cdecl; external;
+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;
 {$ENDIF}
 
-function xmlValidateQName(ncname, prefix, memory: xmlCharPtr; len: cint): xmlCharPtr; cdecl; external;
-function xmlSplitQName2(name: xmlCharPtr; var prefix: xmlCharPtr): xmlCharPtr; cdecl; external;
-function xmlSplitQName3(name: xmlCharPtr; var prefix: xmlCharPtr; var len: cint): xmlCharPtr; cdecl; external;
+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;
 
 (*
  * Handling Buffers.
  *)
-procedure xmlSetBufferAllocationScheme(scheme: xmlBufferAllocationScheme); cdecl; external;
-function xmlGetBufferAllocationScheme: xmlBufferAllocationScheme; cdecl; external;
-
-function xmlBufferCreate: xmlBufferPtr; cdecl; external;
-function xmlBufferCreateSize(size: size_t): xmlBufferPtr; cdecl; external;
-function xmlBufferCreateStatic(mem: pointer; size: size_t): xmlBufferPtr; cdecl; external;
-function xmlBufferResize(buf: xmlBufferPtr; size: cuint): cint; cdecl; external;
-procedure xmlBufferFree(buf: xmlBufferPtr); cdecl; external;
+procedure xmlSetBufferAllocationScheme(scheme: xmlBufferAllocationScheme); XMLCALL; XMLPUBFUN;
+function xmlGetBufferAllocationScheme: xmlBufferAllocationScheme; XMLCALL; XMLPUBFUN;
+
+function xmlBufferCreate: xmlBufferPtr; XMLCALL; XMLPUBFUN;
+function xmlBufferCreateSize(size: size_t): xmlBufferPtr; XMLCALL; XMLPUBFUN;
+function xmlBufferCreateStatic(mem: pointer; size: size_t): xmlBufferPtr; XMLCALL; XMLPUBFUN;
+function xmlBufferResize(buf: xmlBufferPtr; size: cuint): cint; XMLCALL; XMLPUBFUN;
+procedure xmlBufferFree(buf: xmlBufferPtr); XMLCALL; XMLPUBFUN;
 {XMLPUBFUN int XMLCALL
     xmlBufferDump   (FILE *file,
            xmlBufferPtr buf);}
-function xmlBufferAdd(buf: xmlBufferPtr; str: xmlCharPtr; len: cint): cint; cdecl; external;
-function xmlBufferAddHead(buf: xmlBufferPtr; str: xmlCharPtr; len: cint): cint; cdecl; external;
-function xmlBufferCat(buf: xmlBufferPtr; str: xmlCharPtr): cint; cdecl; external;
-function xmlBufferCCat(buf: xmlBufferPtr; str: pchar): cint; cdecl; external;
-function xmlBufferShrink(buf: xmlBufferPtr; len: cuint): cint; cdecl; external;
-function xmlBufferGrow(buf: xmlBufferPtr; len: cuint): cint; cdecl; external;
-procedure xmlBufferEmpty(buf: xmlBufferPtr); cdecl; external;
-function xmlBufferContent(buf: xmlBufferPtr): xmlCharPtr; cdecl; external;
-procedure xmlBufferSetAllocationScheme(buf: xmlBufferPtr; scheme: xmlBufferAllocationScheme); cdecl; external;
-function xmlBufferLength(buf: xmlBufferPtr): cint; cdecl; external;
+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;
 {$IFDEF 0}
 
 (*
@@ -1057,10 +1057,10 @@ XMLPUBFUN void XMLCALL
 (*
 * DOM-wrapper helper functions.
 *)
-function xmlDOMWrapNewCtxt: xmlDOMWrapCtxtPtr; cdecl; external;
-procedure xmlDOMWrapNewCtxt(ctxt: xmlDOMWrapCtxtPtr); cdecl; external;
-function xmlDOMWrapReconcileNamespaces(ctxt: xmlDOMWrapCtxtPtr; elem: xmlNodePtr; options: cint): cint; cdecl; external;
-function xmlDOMWrapAdoptNode(ctxt: xmlDOMWrapCtxtPtr; sourceDoc: xmlDocPtr; node: xmlNodePtr; destDoc: xmlDocPtr; destParent: xmlNodePtr; options: cint): cint; cdecl; external;
-function xmlDOMWrapRemoveNode(ctxt: xmlDOMWrapCtxtPtr; doc: xmlDocPtr; node: xmlNodePtr; options: cint): cint; cdecl; external;
-function xmlDOMWrapCloneNode(ctxt: xmlDOMWrapCtxtPtr; sourceDoc: xmlDocPtr; node: xmlNodePtr; var clonedNode: xmlNodePtr; destDoc: xmlDocPtr; destParent: xmlNodePtr; deep, options: cint): cint; cdecl; external;
+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}

packages/libxml/src/uri.h → packages/libxml/src/uri.inc

@@ -40,19 +40,19 @@
  * xmlChar *	xmlNodeGetBase	(xmlDocPtr doc,
  *                               xmlNodePtr cur);
  *)
-function xmlCreateURI(): xmlURIPtr; cdecl; external;
-function xmlBuildURI(URI: xmlCharPtr; base: xmlCharPtr): xmlCharPtr; cdecl; external;
-function xmlBuildRelativeURI(URI: xmlCharPtr; base: xmlCharPtr): xmlCharPtr; cdecl; external;
-function xmlParseURI(str: pchar): xmlURIPtr; cdecl; external;
-function xmlParseURI(str: pchar; raw: cint): xmlURIPtr; cdecl; external;
-function xmlParseURIReference(uri: xmlURIPtr; str: pchar): cint; cdecl; external;
-function xmlSaveUri(uri: xmlURIPtr): pchar; cdecl; external;
-//procedure xmlPrintURI(stream: FILE; uri: xmlURIPtr); cdecl; external;
-function xmlURIEscapeStr(str: xmlCharPtr; list: xmlCharPtr): xmlCharPtr; cdecl; external;
-function xmlURIUnescapeString(str: pchar; len: cint; target: pchar): xmlCharPtr; cdecl; external;
-function xmlNormalizeURIPath(path: pchar): cint; cdecl; external;
-function xmlURIEscape(str: xmlCharPtr): xmlCharPtr; cdecl; external;
-procedure xmlPrintURI(uri: xmlURIPtr); cdecl; external;
-function xmlCanonicPath(path: xmlCharPtr): xmlCharPtr; cdecl; external;
-function xmlPathToURI(path: xmlCharPtr): xmlCharPtr; cdecl; external;
+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: FILE; 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;
 {$ENDIF}

packages/libxml/src/valid.h → packages/libxml/src/valid.inc

@@ -24,7 +24,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; args: array of const); cdecl;
+  xmlValidityErrorFunc = procedure(ctx: pointer; msg: pchar; args: array of const); XMLCDECL;
 
 (**
  * xmlValidityWarningFunc:
@@ -37,7 +37,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; args: array of const); cdecl;
+  xmlValidityWarningFunc = procedure(ctx: pointer; msg: pchar; args: array of const); XMLCDECL;
 
 (*
  * xmlValidCtxt:
@@ -107,27 +107,27 @@
 
 {$IFDEF FUNCTION}
 (* Notation *)
-function xmlAddNotationDecl(ctxt: xmlValidCtxtPtr; dtd: xmlDtdPtr; name, PublicID, SystemID: xmlCharPtr): xmlNotationPtr; cdecl; external;
+function xmlAddNotationDecl(ctxt: xmlValidCtxtPtr; dtd: xmlDtdPtr; name, PublicID, SystemID: xmlCharPtr): xmlNotationPtr; XMLCALL; XMLPUBFUN;
 {$IFDEF LIBXML_TREE_ENABLED}
-function xmlCopyNotationTable(table: xmlNotationTablePtr): xmlNotationTablePtr; cdecl; external;
+function xmlCopyNotationTable(table: xmlNotationTablePtr): xmlNotationTablePtr; XMLCALL; XMLPUBFUN;
 {$ENDIF} (* LIBXML_TREE_ENABLED *)
-procedure xmlFreeNotationTable(table: xmlNotationTablePtr); cdecl; external;
+procedure xmlFreeNotationTable(table: xmlNotationTablePtr); XMLCALL; XMLPUBFUN;
 {$IFDEF LIBXML_OUTPUT_ENABLED}
-procedure xmlDumpNotationDecl(buf: xmlBufferPtr; nota: xmlNotationPtr); cdecl; external;
-procedure xmlDumpNotationTable(buf: xmlBufferPtr; table: xmlNotationTablePtr); cdecl; external;
+procedure xmlDumpNotationDecl(buf: xmlBufferPtr; nota: xmlNotationPtr); XMLCALL; XMLPUBFUN;
+procedure xmlDumpNotationTable(buf: xmlBufferPtr; table: xmlNotationTablePtr); XMLCALL; XMLPUBFUN;
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
 
 (* Element Content *)
 (* the non Doc version are being deprecated *)
-function xmlNewElementContent(name: xmlCharPtr; _type: xmlElementContentType): xmlElementContentPtr; cdecl; external;
-function xmlCopyElementContent(content: xmlElementContentPtr): xmlElementContentPtr; cdecl; external;
-procedure xmlFreeElementContent(cur: xmlElementContentPtr); cdecl; external;
+function xmlNewElementContent(name: xmlCharPtr; _type: xmlElementContentType): xmlElementContentPtr; XMLCALL; XMLPUBFUN;
+function xmlCopyElementContent(content: xmlElementContentPtr): xmlElementContentPtr; XMLCALL; XMLPUBFUN;
+procedure xmlFreeElementContent(cur: xmlElementContentPtr); XMLCALL; XMLPUBFUN;
 
 (* the new versions with doc argument *)
-function xmlNewDocElementContent(doc: xmlDocPtr; name: xmlCharPtr; _type: xmlElementContentType): xmlElementContentPtr; cdecl; external;
-function xmlCopyDocElementContent(doc: xmlDocPtr; content: xmlElementContentPtr): xmlElementContentPtr; cdecl; external;
-procedure xmlFreeDocElementContent(doc: xmlDocPtr; cur: xmlElementContentPtr); cdecl; external;
-procedure xmlSnprintfElementContent(buf: pchar; size: cint; content: xmlElementContentPtr; englob: cint); cdecl; external;
+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;
 {$IFDEF LIBXML_OUTPUT_ENABLED}
 (* DEPRECATED *)
 {XMLPUBFUN void XMLCALL		     
@@ -138,101 +138,101 @@ procedure xmlSnprintfElementContent(buf: pchar; size: cint; content: xmlElementC
 (* DEPRECATED *)
 
 (* Element *)
-function xmlAddElementDecl(ctxt: xmlValidCtxtPtr; dtd: xmlDtdPtr; name: xmlCharPtr; _type: xmlElementTypeVal; content: xmlElementContentPtr): xmlElementPtr; cdecl; external;
+function xmlAddElementDecl(ctxt: xmlValidCtxtPtr; dtd: xmlDtdPtr; name: xmlCharPtr; _type: xmlElementTypeVal; content: xmlElementContentPtr): xmlElementPtr; XMLCALL; XMLPUBFUN;
 {$IFDEF LIBXML_TREE_ENABLED}
-function xmlCopyElementTable(table: xmlElementTablePtr): xmlElementTablePtr; cdecl; external;
+function xmlCopyElementTable(table: xmlElementTablePtr): xmlElementTablePtr; XMLCALL; XMLPUBFUN;
 {$ENDIF} (* LIBXML_TREE_ENABLED *)
-procedure xmlFreeElementTable(table: xmlElementTablePtr); cdecl; external;
+procedure xmlFreeElementTable(table: xmlElementTablePtr); XMLCALL; XMLPUBFUN;
 {$IFDEF LIBXML_OUTPUT_ENABLED}
-procedure xmlDumpElementTable(buf: xmlBufferPtr; table: xmlElementTablePtr); cdecl; external;
-procedure xmlDumpElementDecl(buf: xmlBufferPtr; elem: xmlElementPtr); cdecl; external;
+procedure xmlDumpElementTable(buf: xmlBufferPtr; table: xmlElementTablePtr); XMLCALL; XMLPUBFUN;
+procedure xmlDumpElementDecl(buf: xmlBufferPtr; elem: xmlElementPtr); XMLCALL; XMLPUBFUN;
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
 
 (* Enumeration *)
-function xmlCreateEnumeration(name: xmlCharPtr): xmlEnumerationPtr; cdecl; external;
-procedure xmlFreeEnumeration(cur: xmlEnumerationPtr); cdecl; external;
+function xmlCreateEnumeration(name: xmlCharPtr): xmlEnumerationPtr; XMLCALL; XMLPUBFUN;
+procedure xmlFreeEnumeration(cur: xmlEnumerationPtr); XMLCALL; XMLPUBFUN;
 {$IFDEF LIBXML_TREE_ENABLED}
-function xmlCopyEnumeration(cur: xmlEnumerationPtr): xmlEnumerationPtr; cdecl; external;
+function xmlCopyEnumeration(cur: xmlEnumerationPtr): xmlEnumerationPtr; XMLCALL; XMLPUBFUN;
 {$ENDIF} (* LIBXML_TREE_ENABLED *)
 
 (* Attribute *)
 function xmlAddAttributeDecl(ctxt: xmlValidCtxtPtr; dtd: xmlDtdPtr; elem, name, ns: xmlCharPtr; _type: xmlAttributeType;
-  def: xmlAttributeDefault; defaultValue: xmlCharPtr; tree: xmlEnumerationPtr): xmlAttributePtr; cdecl; external;
+  def: xmlAttributeDefault; defaultValue: xmlCharPtr; tree: xmlEnumerationPtr): xmlAttributePtr; XMLCALL; XMLPUBFUN;
 {$IFDEF LIBXML_TREE_ENABLED}
-function xmlCopyAttributeTable(table: xmlAttributeTablePtr): xmlAttributeTablePtr; cdecl; external;
+function xmlCopyAttributeTable(table: xmlAttributeTablePtr): xmlAttributeTablePtr; XMLCALL; XMLPUBFUN;
 {$ENDIF} (* LIBXML_TREE_ENABLED *)
-procedure xmlFreeAttributeTable(table: xmlAttributeTablePtr); cdecl; external;
+procedure xmlFreeAttributeTable(table: xmlAttributeTablePtr); XMLCALL; XMLPUBFUN;
 {$IFDEF LIBXML_OUTPUT_ENABLED}
-procedure xmlDumpAttributeTable(buf: xmlBufferPtr; table: xmlAttributeTablePtr); cdecl; external;
-procedure xmlDumpAttributeDecl(buf: xmlBufferPtr; attr: xmlAttributePtr); cdecl; external;
+procedure xmlDumpAttributeTable(buf: xmlBufferPtr; table: xmlAttributeTablePtr); XMLCALL; XMLPUBFUN;
+procedure xmlDumpAttributeDecl(buf: xmlBufferPtr; attr: xmlAttributePtr); XMLCALL; XMLPUBFUN;
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
 
 (* IDs *)
-function xmlAddID(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; value: xmlCharPtr; attr: xmlAttrPtr): xmlIDPtr; cdecl; external;
-procedure xmlFreeIDTable(table: xmlIDTablePtr); cdecl; external;
-function xmlGetID(doc: xmlDocPtr; ID: xmlCharPtr): xmlAttrPtr; cdecl; external;
-function xmlIsID(doc: xmlDocPtr; elem: xmlNodePtr; attr: xmlAttrPtr): cint; cdecl; external;
-function xmlRemoveID(doc: xmlDocPtr; attr: xmlAttrPtr): cint; cdecl; external;
+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;
 
 (* IDREFs *)
-function xmlAddRef(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; value: xmlCharPtr; attr: xmlAttrPtr): xmlRefPtr; cdecl; external;
-procedure xmlFreeRefTable(table: xmlRefTablePtr); cdecl; external;
-function xmlIsRef(doc: xmlDocPtr; elem: xmlNodePtr; attr: xmlAttrPtr): cint; cdecl; external;
-function xmlRemoveRef(doc: xmlDocPtr; attr: xmlAttrPtr): cint; cdecl; external;
-function xmlGetRefs(doc: xmlDocPtr; ID: xmlCharPtr): xmlListPtr; cdecl; external;
+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;
 
 (**
  * The public function calls related to validity checking.
  *)
 {$IFDEF LIBXML_VALID_ENABLED}
 (* Allocate/Release Validation Contexts *)
-function xmlNewValidCtxt: xmlValidCtxtPtr; cdecl; external;
-procedure xmlFreeValidCtxt(table: xmlValidCtxtPtr); cdecl; external;
-function xmlValidateRoot(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr): cint; cdecl; external;
-function xmlValidateElementDecl(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlElementPtr): cint; cdecl; external;
-function xmlValidNormalizeAttributeValue(doc: xmlDocPtr; elem: xmlNodePtr; name, value: xmlCharPtr): xmlCharPtr; cdecl; external;
-function xmlValidCtxtNormalizeAttributeValue(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr; name, value: xmlCharPtr): xmlCharPtr; cdecl; external;
-function xmlValidateAttributeDecl(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; attr: xmlAttributePtr): cint; cdecl; external;
-function xmlValidateAttributeValue(_type: xmlAttributeType; value: xmlCharPtr): cint; cdecl; external;
-function xmlValidateNotationDecl(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; nota: xmlNotationPtr): cint; cdecl; external;
-function xmlValidateDtd(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; dtd: xmlDtdPtr): cint; cdecl; external;
-function xmlValidateDtdFinal(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr): cint; cdecl; external;
-function xmlValidateDocument(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr): cint; cdecl; external;
-function xmlValidateElement(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr): cint; cdecl; external;
-function xmlValidateOneElement(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr): cint; cdecl; external;
-function xmlValidateOneAttribute(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr; attr: xmlAttrPtr; value: xmlCharPtr): cint; cdecl; external;
-function xmlValidateOneNamespace(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr; prefix: xmlCharPtr; ns: xmlNsPtr; value: xmlCharPtr): cint; cdecl; external;
-function xmlValidateDocumentFinal(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr): cint; cdecl; external;
+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;
 {$ENDIF} (* LIBXML_VALID_ENABLED *)
 
 {$IF defined(LIBXML_VALID_ENABLED) ordefined(LIBXML_SCHEMAS_ENABLED)}
-function xmlValidateNotationUse(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; notationName: xmlCharPtr): cint; cdecl; external;
+function xmlValidateNotationUse(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; notationName: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
 {$ENDIF} (* LIBXML_VALID_ENABLED or LIBXML_SCHEMAS_ENABLED *)
 
-function xmlIsMixedElement(doc: xmlDocPtr; name: xmlCharPtr): cint; cdecl; external;
-function xmlGetDtdAttrDesc(dtd: xmlDtdPtr; elem, name: xmlCharPtr): xmlAttributePtr; cdecl; external;
-function xmlGetDtdQAttrDesc(dtd: xmlDtdPtr; elem, name, prefix: xmlCharPtr): xmlAttributePtr; cdecl; external;
-function xmlGetDtdNotationDesc(dtd: xmlDtdPtr; name: xmlCharPtr): xmlNotationPtr; cdecl; external;
-function xmlGetDtdQElementDesc(dtd: xmlDtdPtr; name, prefix: xmlCharPtr): xmlElementPtr; cdecl; external;
-function xmlGetDtdElementDesc(dtd: xmlDtdPtr; name: xmlCharPtr): xmlElementPtr; cdecl; external;
+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;
 {$IFDEF LIBXML_VALID_ENABLED}
 
-function xmlGetDtdElementDesc(ctree: xmlElementContentPtr; var names: xmlCharPtr; var len: cint; max: cint): cint; cdecl; external;
-function xmlValidGetValidElements(prev, next: xmlNodePtr; var names: xmlCharPtr; max: cint): cint; cdecl; external;
-function xmlValidateNameValue(value: xmlCharPtr): cint; cdecl; external;
-function xmlValidateNamesValue(value: xmlCharPtr): cint; cdecl; external;
-function xmlValidateNmtokenValue(value: xmlCharPtr): cint; cdecl; external;
-function xmlValidateNmtokensValue(value: xmlCharPtr): cint; cdecl; external;
+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;
 
 
 {$IFDEF LIBXML_REGEXP_ENABLED}
 (*
  * Validation based on the regexp support
  *)
-function xmlValidBuildContentModel(ctxt: xmlValidCtxtPtr; elem: xmlElementPtr): cint; cdecl; external;
-function xmlValidatePushElement(ctxt: xmlValidCtxtPtr; doc: xmlNodePtr; elem: xmlElementPtr; qname: xmlCharPtr): cint; cdecl; external;
-function xmlValidatePushCData(ctxt: xmlValidCtxtPtr; data: xmlCharPtr; len: cint): cint; cdecl; external;
-function xmlValidatePopElement(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr; qname: xmlCharPtr): cint; cdecl; external;
+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;
 {$ENDIF} (* LIBXML_REGEXP_ENABLED *)
 {$ENDIF} (* LIBXML_VALID_ENABLED *)
 {$ENDIF}

packages/libxml/src/xmlIO.h → packages/libxml/src/xmlIO.inc

@@ -136,94 +136,94 @@
 (*
  * Interfaces for input
  *)
-procedure xmlCleanupInputCallbacks; cdecl; external;
-function xmlPopInputCallbacks: cint; cdecl; external;
-procedure xmlRegisterDefaultInputCallbacks; cdecl; external;
-function xmlAllocParserInputBuffer(enc: xmlCharEncoding): xmlParserInputBufferPtr; cdecl; external;
-function xmlParserInputBufferCreateFilename(URI: pchar; enc: xmlCharEncoding): xmlParserInputBufferPtr; cdecl; external;
-//function xmlParserInputBufferCreateFile(file: FILE; enc: xmlCharEncoding): xmlParserInputBufferPtr; cdecl; external;
-function xmlParserInputBufferCreateFd(fd: cint; enc: xmlCharEncoding): xmlParserInputBufferPtr; cdecl; external;
-function xmlParserInputBufferCreateMem(mem: pchar; size: cint; enc: xmlCharEncoding): xmlParserInputBufferPtr; cdecl; external;
-function xmlParserInputBufferCreateStatic(mem: pchar; size: cint; enc: xmlCharEncoding): xmlParserInputBufferPtr; cdecl; external;
-
-function xmlParserInputBufferCreateIO(ioread: xmlInputReadCallback; ioclose: xmlInputCloseCallback; ioctx: pointer; enc: xmlCharEncoding): xmlParserInputBufferPtr; cdecl; external;
-function xmlParserInputBufferRead(_in: xmlParserInputBufferPtr; len: cint): cint; cdecl; external;
-function xmlParserInputBufferGrow(_in: xmlParserInputBufferPtr; len: cint): cint; cdecl; external;
-function xmlParserInputBufferPush(_in: xmlParserInputBufferPtr; len: cint; buf: pchar): cint; cdecl; external;
-procedure xmlFreeParserInputBuffer(_in: xmlParserInputBufferPtr); cdecl; external;
-function xmlParserGetDirectory(filename: pchar): pchar; cdecl; external;
-function xmlRegisterInputCallbacks(matchFunc: xmlInputMatchCallback; openFunc: xmlInputOpenCallback; readFunc: xmlInputReadCallback; closeFunc: xmlInputCloseCallback): cint; cdecl; external;
-function __xmlParserInputBufferCreateFilename(URI: pchar; enc: xmlCharEncoding): xmlParserInputBufferPtr; cdecl; external;
+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(file: FILE; 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;
 
 {$IFDEF LIBXML_OUTPUT_ENABLED}
 (*
  * Interfaces for output
  *)
-procedure xmlCleanupOutputCallbacks; cdecl; external;
-procedure xmlRegisterDefaultOutputCallbacks; cdecl; external;
-function xmlAllocOutputBuffer(encoder: xmlCharEncodingHandlerPtr): xmlOutputBufferPtr; cdecl; external;
-
-function xmlOutputBufferCreateFilename(URI: pchar; encoder: xmlCharEncodingHandlerPtr; compression: cint): xmlOutputBufferPtr; cdecl; external;
-//function xmlOutputBufferCreateFile(file: FILE; encoder: xmlCharEncodingHandlerPtr): xmlOutputBufferPtr; cdecl; external;
-function xmlOutputBufferCreateBuffer(buffer: xmlBufferPtr; encoder: xmlCharEncodingHandlerPtr): xmlOutputBufferPtr; cdecl; external;
-function xmlOutputBufferCreateFd(fd: cint; encoder: xmlCharEncodingHandlerPtr): xmlOutputBufferPtr; cdecl; external;
-function xmlOutputBufferCreateIO(iowrite: xmlOutputWriteCallback; ioclose: xmlOutputCloseCallback; ioctx: pointer; encoder: xmlCharEncodingHandlerPtr): xmlOutputBufferPtr; cdecl; external;
-function xmlOutputBufferWrite(_out: xmlOutputBufferPtr; len: cint; buf: pchar): cint; cdecl; external;
-function xmlOutputBufferWriteString(_out: xmlOutputBufferPtr; str: pchar): cint; cdecl; external;
-function xmlOutputBufferWriteEscape(_out: xmlOutputBufferPtr; str: xmlCharPtr; escaping: xmlCharEncodingOutputFunc): cint; cdecl; external;
-function xmlOutputBufferFlush(_out: xmlOutputBufferPtr): cint; cdecl; external;
-function xmlOutputBufferClose(_out: xmlOutputBufferPtr): cint; cdecl; external;
-function xmlRegisterOutputCallbacks(matchFunc: xmlOutputMatchCallback; openFunc: xmlOutputOpenCallback; writeFunc: xmlOutputWriteCallback; closeFunc: xmlOutputCloseCallback): cint; cdecl; external;
-function __xmlOutputBufferCreateFilename(URI: pchar; encoder: xmlCharEncodingHandlerPtr; compression: cint): xmlOutputBufferPtr; cdecl; external;
+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(file: FILE; 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;
 
 {$IFDEF LIBXML_HTTP_ENABLED}
 (*  This function only exists if HTTP support built into the library  *)
-procedure xmlRegisterHTTPPostCallbacks; cdecl; external;
+procedure xmlRegisterHTTPPostCallbacks; XMLCALL; XMLPUBFUN;
 {$ENDIF} (* LIBXML_HTTP_ENABLED *)
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
 
-function xmlCheckHTTPInput(ctxt: xmlParserCtxtPtr; ret: xmlParserInputPtr): xmlParserInputPtr; cdecl; external;
+function xmlCheckHTTPInput(ctxt: xmlParserCtxtPtr; ret: xmlParserInputPtr): xmlParserInputPtr; XMLCALL; XMLPUBFUN;
 
 (*
  * A predefined entity loader disabling network accesses
  *)
-function xmlNoNetExternalEntityLoader(URL: pchar; ID: pchar; ctxt: xmlParserCtxtPtr): xmlParserInputPtr; cdecl; external;
+function xmlNoNetExternalEntityLoader(URL: pchar; ID: pchar; ctxt: xmlParserCtxtPtr): xmlParserInputPtr; XMLCALL; XMLPUBFUN;
 
 (*
  * xmlNormalizeWindowsPath is obsolete, don't use it.
  * Check xmlCanonicPath in uri.h for a better alternative.
  *)
-function xmlNormalizeWindowsPath(path: xmlCharPtr): xmlCharPtr; cdecl; external;
-function xmlCheckFilename(path: pchar): cint; cdecl; external;
+function xmlNormalizeWindowsPath(path: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
+function xmlCheckFilename(path: pchar): cint; XMLCALL; XMLPUBFUN;
 
 (**
  * Default 'file://' protocol callbacks
  *)
-function xmlFileMatch(filename: pchar): cint; cdecl; external;
-function xmlFileOpen(filename: pchar): pointer; cdecl; external;
-function xmlFileRead(context: pointer; buffer: pchar; len: cint): cint; cdecl; external;
-function xmlFileClose(context: pointer): cint; cdecl; external;
+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;
 
 (**
  * Default 'http://' protocol callbacks
  *)
 {$IFDEF LIBXML_HTTP_ENABLED}
-function xmlIOHTTPMatch(filename: pchar): cint; cdecl; external;
-function xmlIOHTTPOpen(filename: pchar): pointer; cdecl; external;
+function xmlIOHTTPMatch(filename: pchar): cint; XMLCALL; XMLPUBFUN;
+function xmlIOHTTPOpen(filename: pchar): pointer; XMLCALL; XMLPUBFUN;
 {$IFDEF LIBXML_OUTPUT_ENABLED}
-function xmlIOHTTPOpenW(post_uri: pchar; compression: cint): pointer; cdecl; external;
+function xmlIOHTTPOpenW(post_uri: pchar; compression: cint): pointer; XMLCALL; XMLPUBFUN;
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
-function xmlIOHTTPRead(context: pointer; buffer: pchar; len: cint): cint; cdecl; external;
-function xmlIOHTTPClose(context: pointer): cint; cdecl; external;
+function xmlIOHTTPRead(context: pointer; buffer: pchar; len: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlIOHTTPClose(context: pointer): cint; XMLCALL; XMLPUBFUN;
 {$ENDIF} (* LIBXML_HTTP_ENABLED *)
 
 (**
  * Default 'ftp://' protocol callbacks
  *)
 {$IFDEF LIBXML_FTP_ENABLED}
-function xmlIOFTPMatch(filename: pchar): cint; cdecl; external;
-function xmlIOFTPOpen(filename: pchar): pointer; cdecl; external;
-function xmlIOFTPRead(context: pointer; buffer: pchar; len: cint): cint; cdecl; external;
-function xmlIOFTPClose(context: pointer): cint; cdecl; external;
+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;
 {$ENDIF} (* LIBXML_FTP_ENABLED *)
 {$ENDIF}

packages/libxml/src/xmlautomata.h → packages/libxml/src/xmlautomata.inc

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

packages/libxml/src/xmlerror.h → packages/libxml/src/xmlerror.inc

@@ -843,30 +843,30 @@
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-procedure xmlSetGenericErrorFunc(ctx: pointer; handler: xmlGenericErrorFunc); cdecl; external;
-procedure initGenericErrorDefaultFunc(var handler: xmlGenericErrorFunc); cdecl; external;
-procedure xmlSetStructuredErrorFunc(ctx: pointer; handler: xmlStructuredErrorFunc); cdecl; external;
+procedure xmlSetGenericErrorFunc(ctx: pointer; handler: xmlGenericErrorFunc); XMLCALL; XMLPUBFUN;
+procedure initGenericErrorDefaultFunc(var handler: xmlGenericErrorFunc); XMLCALL; XMLPUBFUN;
+procedure xmlSetStructuredErrorFunc(ctx: pointer; handler: xmlStructuredErrorFunc); XMLCALL; XMLPUBFUN;
 
 (*
  * Default message routines used by SAX and Valid context for error
  * and warning reporting.
  *)
-procedure xmlParserError(ctx: pointer; msg: pchar; args: array of const); cdecl; external;
-procedure xmlParserWarning(ctx: pointer; msg: pchar; args: array of const); cdecl; external;
-procedure xmlParserValidityError(ctx: pointer; msg: pchar; args: array of const); cdecl; external;
-procedure xmlParserValidityWarning(ctx: pointer; msg: pchar; args: array of const); cdecl; external;
-procedure xmlParserPrintFileInfo(input: xmlParserInputPtr); cdecl; external;
-procedure xmlParserPrintFileContext(input: xmlParserInputPtr); cdecl; external;
+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;
 
 (*
  * Extended error information routines
  *)
-function xmlGetLastError: xmlErrorPtr; cdecl; external;
-procedure xmlResetLastError; cdecl; external;
-function xmlCtxtGetLastError(ctx: pointer): xmlErrorPtr; cdecl; external;
-procedure xmlCtxtResetLastError(ctx: pointer); cdecl; external;
-procedure xmlResetError(err: xmlErrorPtr); cdecl; external;
-function xmlResetError(from, _to: xmlErrorPtr): cint; cdecl; external;
+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;
 
 {$IFDEF IN_LIBXML}
 (*

packages/libxml/src/xmlexports.h → packages/libxml/src/xmlexports.inc

@@ -24,7 +24,7 @@
  *
  * Macros which declare an exportable function
  *)
-//#define XMLPUBFUN
+{$DEFINE XMLPUBFUN := external {$IFDEF DYNLINK}libxml2lib{$ENDIF}}
 
 (**
  * XMLPUBVAR:
@@ -38,7 +38,7 @@
  *
  * Macros which declare the called convention for exported functions
  *)
-//#define XMLCALL
+{$DEFINE XMLCALL := cdecl}
 
 (**
  * XMLCDECL:

packages/libxml/src/xmlmemory.h → packages/libxml/src/xmlmemory.inc

@@ -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; cdecl; external;
-function xmlMemGet(var freeFunc: xmlFreeFunc; var mallocFunc: xmlMallocFunc; var reallocFunc: xmlReallocFunc; var strdupFunc: xmlStrdupFunc): cint; cdecl; external;
-function xmlGcMemSetup(freeFunc: xmlFreeFunc; mallocFunc: xmlMallocFunc; mallocAtomicFunc: xmlMallocFunc; reallocFunc: xmlReallocFunc; strdupFunc: xmlStrdupFunc): cint; cdecl; external;
-function xmlGcMemGet(var freeFunc: xmlFreeFunc; var mallocFunc: xmlMallocFunc; var mallocAtomicFunc: xmlMallocFunc; var reallocFunc: xmlReallocFunc; var strdupFunc: xmlStrdupFunc): cint; cdecl; external;
+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;
 
 (*
  * Initialization of the memory layer.
  *)
-function xmlInitMemory(): cint; cdecl; external;
+function xmlInitMemory(): cint; XMLCALL; XMLPUBFUN;
 
 (* 
  * Cleanup of the memory layer.
  *)
-procedure xmlCleanupMemory(); cdecl; external;
+procedure xmlCleanupMemory(); XMLCALL; XMLPUBFUN;
 
 (*
  * These are specific to the XML debug memory wrapper.
  *)
-function xmlMemUsed(): cint; cdecl; external;
-function xmlMemBlocks(): cint; cdecl; external;
+function xmlMemUsed(): cint; XMLCALL; XMLPUBFUN;
+function xmlMemBlocks(): cint; XMLCALL; XMLPUBFUN;
 {XMLPUBFUN void XMLCALL	xmlMemDisplay	(FILE *fp);
 XMLPUBFUN void XMLCALL	xmlMemShow	(FILE *fp, int nr);}
-procedure xmlMemoryDump(); cdecl; external;
-function xmlMemMalloc(size: size_t): pointer; cdecl; external;
-function xmlMemRealloc(ptr: pointer; size: size_t): pointer; cdecl; external;
-procedure xmlMemFree(ptr: pointer); cdecl; external;
-function xmlMemoryStrdup(str: pchar): pchar; cdecl; external;
-
-function xmlMallocLoc(size: size_t; _file: pchar; line: cint): pointer; cdecl; external;
-function xmlReallocLoc(ptr: pointer; size: size_t; _file: pchar; line: cint): pointer; cdecl; external;
-function xmlMallocAtomicLoc(size: size_t; _file: pchar; line: cint): pointer; cdecl; external;
-function xmlMemStrdupLoc(str: pchar; _file: pchar; line: cint): pchar; cdecl; external;
+procedure xmlMemoryDump(); XMLCALL; XMLPUBFUN;
+function xmlMemMalloc(size: size_t): pointer; XMLCALL; XMLPUBFUN;
+function xmlMemRealloc(ptr: pointer; size: size_t): pointer; XMLCALL; XMLPUBFUN;
+procedure xmlMemFree(ptr: pointer); XMLCALL; XMLPUBFUN;
+function xmlMemoryStrdup(str: pchar): pchar; XMLCALL; XMLPUBFUN;
+
+function xmlMallocLoc(size: size_t; _file: pchar; line: cint): pointer; XMLCALL; XMLPUBFUN;
+function xmlReallocLoc(ptr: pointer; size: size_t; _file: pchar; line: cint): pointer; XMLCALL; XMLPUBFUN;
+function xmlMallocAtomicLoc(size: size_t; _file: pchar; line: cint): pointer; XMLCALL; XMLPUBFUN;
+function xmlMemStrdupLoc(str: pchar; _file: pchar; line: cint): pchar; XMLCALL; XMLPUBFUN;
 
 {$IFDEF DEBUG_MEMORY_LOCATION}
 (**

packages/libxml/src/xmlmodule.h → packages/libxml/src/xmlmodule.inc

@@ -30,10 +30,10 @@
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-function xmlModuleOpen(filename: char; options: cint): xmlModulePtr; cdecl; external;
-function xmlModuleSymbol(module: xmlModulePtr; name: pchar; var result: pointer): cint; cdecl; external;
-function xmlModuleClose(module: xmlModulePtr): cint; cdecl; external;
-function xmlModuleFree(module: xmlModulePtr): cint; cdecl; external;
+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;
 {$ENDIF}
 
 {$ENDIF} (* LIBXML_MODULES_ENABLED *)

packages/libxml/src/xmlreader.h → packages/libxml/src/xmlreader.inc

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

packages/libxml/src/xmlregexp.h → packages/libxml/src/xmlregexp.inc

@@ -37,21 +37,21 @@
 (*
  * The POSIX like API
  *)
-function xmlRegexpCompile(regexp: xmlCharPtr): xmlRegexpPtr; cdecl; external;
-procedure xmlRegFreeRegexp(regexp: xmlRegexpPtr); cdecl; external;
-function xmlRegexpExec(comp: xmlRegexpPtr; value: xmlCharPtr): cint; cdecl; external;
-//procedure xmlRegexpPrint(output: FILE; regexp: xmlRegexpPtr); cdecl; external;
-function xmlRegexpIsDeterminist(comp: xmlRegexpPtr): cint; cdecl; external;
+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: FILE; regexp: xmlRegexpPtr); XMLCALL; XMLPUBFUN;
+function xmlRegexpIsDeterminist(comp: xmlRegexpPtr): cint; XMLCALL; XMLPUBFUN;
 
 (*
  * The progressive API
  *)
-function xmlRegNewExecCtxt(comp: xmlRegexpPtr; callback: xmlRegExecCallbacks; data: pointer): xmlRegExecCtxtPtr; cdecl; external;
-procedure xmlRegFreeExecCtxt(exec: xmlRegExecCtxtPtr); cdecl; external;
-function xmlRegExecPushString(exec: xmlRegExecCtxtPtr; value: xmlCharPtr; data: pointer): cint; cdecl; external;
-function xmlRegExecPushString2(exec: xmlRegExecCtxtPtr; value, value2: xmlCharPtr; data: pointer): cint; cdecl; external;
-function xmlRegExecNextValues(exec: xmlRegExecCtxtPtr; nbval, nbneg: pcint; values: xmlCharPtrPtr; terminal: pcint): cint; cdecl; external;
-function xmlRegExecErrInfo(exec: xmlRegExecCtxtPtr; _string: xmlCharPtrPtr; nbval, nbneg: pcint; values: xmlCharPtrPtr; terminal: pcint): cint; cdecl; external;
+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;
 {$ENDIF}
 
 {$IFDEF LIBXML_EXPR_ENABLED}
@@ -81,10 +81,10 @@ function xmlRegExecErrInfo(exec: xmlRegExecCtxtPtr; _string: xmlCharPtrPtr; nbva
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-procedure xmlRegFreeExecCtxt(ctxt: xmlExpCtxtPtr); cdecl; external;
-function xmlExpNewCtxt(maxNodes: cint; dict: xmlDictPtr): xmlExpCtxtPtr; cdecl; external;
-function xmlExpCtxtNbNodes(ctxt: xmlExpCtxtPtr): cint; cdecl; external;
-function xmlExpCtxtNbCons(ctxt: xmlExpCtxtPtr): cint; cdecl; external;
+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;
 
 (*
  * 2 core expressions shared by all for the empty language set
@@ -97,29 +97,29 @@ var
 (*
  * Expressions are reference counted internally
  *)
-procedure xmlExpFree(ctxt: xmlExpCtxtPtr; expr: xmlExpNodePtr); cdecl; external;
-procedure xmlExpRef(expr: xmlExpNodePtr); cdecl; external;
+procedure xmlExpFree(ctxt: xmlExpCtxtPtr; expr: xmlExpNodePtr); XMLCALL; XMLPUBFUN;
+procedure xmlExpRef(expr: xmlExpNodePtr); XMLCALL; XMLPUBFUN;
 
 (*
  * constructors can be either manual or from a string
  *)
-function xmlExpParse(ctxt: xmlExpCtxtPtr; expr: pchar): xmlExpNodePtr; cdecl; external;
-function xmlExpNewAtom(ctxt: xmlExpCtxtPtr; name: xmlCharPtr; len: cint): xmlExpNodePtr; cdecl; external;
-function xmlExpNewOr(ctxt: xmlExpCtxtPtr; left, right: xmlExpNodePtr): xmlExpNodePtr; cdecl; external;
-function xmlExpNewSeq(ctxt: xmlExpCtxtPtr; left, right: xmlExpNodePtr): xmlExpNodePtr; cdecl; external;
-function xmlExpNewRange(ctxt: xmlExpCtxtPtr; subset: xmlExpNodePtr; min, max: cint): xmlExpNodePtr; cdecl; external;
+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;
 
 (*
  * The really interesting APIs
  *)
-function xmlExpIsNillable(expr: xmlExpNodePtr): cint; cdecl; external;
-function xmlExpMaxToken(expr: xmlExpNodePtr): cint; cdecl; external;
-function xmlExpGetLanguage(ctxt: xmlExpCtxtPtr; expr: xmlExpNodePtr; langList: xmlCharPtrPtr; len: cint): cint; cdecl; external;
-function xmlExpGetStart(ctxt: xmlExpCtxtPtr; expr: xmlExpNodePtr; tokList: xmlCharPtrPtr; len: cint): cint; cdecl; external;
-function xmlExpStringDerive(ctxt: xmlExpCtxtPtr; expr: xmlExpNodePtr; str: xmlCharPtr; len: cint): xmlExpNodePtr; cdecl; external;
-function xmlExpExpDerive(ctxt: xmlExpCtxtPtr; expr, sub: xmlExpNodePtr): xmlExpNodePtr; cdecl; external;
-function xmlExpSubsume(ctxt: xmlExpCtxtPtr; expr, sub: xmlExpNodePtr): cint; cdecl; external;
-procedure xmlExpDump(buf: xmlBufferPtr; expr: xmlExpNodePtr); cdecl; external;
+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;
 {$ENDIF}
 {$ENDIF} (* LIBXML_EXPR_ENABLED *)
 {$ENDIF} (* LIBXML_REGEXP_ENABLED *)

packages/libxml/src/xmlsave.h → packages/libxml/src/xmlsave.inc

@@ -28,17 +28,17 @@
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-function xmlSaveToFd(fd: cint; encoding: pchar; options: cint): xmlSaveCtxtPtr; cdecl; external;
-function xmlSaveToFilename(filename: pchar; encoding: pchar; options: cint): xmlSaveCtxtPtr; cdecl; external;
-function xmlSaveToBuffer(buffer: xmlBufferPtr; encoding: pchar; options: cint): xmlSaveCtxtPtr; cdecl; external;
-function xmlSaveToIO(iowrite: xmlOutputWriteCallback; ioclose: xmlOutputCloseCallback; ioctx: pointer; encoding: pchar; options: cint): xmlSaveCtxtPtr; cdecl; external;
-
-function xmlSaveDoc(ctxt: xmlSaveCtxtPtr; doc: xmlDocPtr): clong; cdecl; external;
-function xmlSaveTree(ctxt: xmlSaveCtxtPtr; node: xmlNodePtr): clong; cdecl; external;
-function xmlSaveFlush(ctxt: xmlSaveCtxtPtr): cint; cdecl; external;
-function xmlSaveClose(ctxt: xmlSaveCtxtPtr): cint; cdecl; external;
-function xmlSaveSetEscape(ctxt: xmlSaveCtxtPtr; escape: xmlCharEncodingOutputFunc): cint; cdecl; external;
-function xmlSaveSetAttrEscape(ctxt: xmlSaveCtxtPtr; escape: xmlCharEncodingOutputFunc): cint; cdecl; external;
+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;
 {$ENDIF}
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
 

packages/libxml/src/xmlschemas.h → packages/libxml/src/xmlschemas.inc

@@ -93,16 +93,16 @@
 (*
  * Interfaces for parsing.
  *)
-function xmlSchemaNewParserCtxt(URL: pchar): xmlSchemaParserCtxtPtr; cdecl; external;
-function xmlSchemaNewMemParserCtxt(buffer: pchar; size: cint): xmlSchemaParserCtxtPtr; cdecl; external;
-function xmlSchemaNewDocParserCtxt(doc: xmlDocPtr): xmlSchemaParserCtxtPtr; cdecl; external;
-procedure xmlSchemaFreeParserCtxt(ctxt: xmlSchemaParserCtxtPtr); cdecl; external;
-procedure xmlSchemaSetParserErrors(ctxt: xmlSchemaParserCtxtPtr; err: xmlSchemaValidityErrorFunc; warn: xmlSchemaValidityWarningFunc; ctx: pointer); cdecl; external;
-procedure xmlSchemaSetParserStructuredErrors(ctxt: xmlSchemaParserCtxtPtr; serror: xmlStructuredErrorFunc; ctx: pointer); cdecl; external;
-function xmlSchemaSetParserErrors(ctxt: xmlSchemaParserCtxtPtr; var err: xmlSchemaValidityErrorFunc; var warn: xmlSchemaValidityWarningFunc; var ctx: pointer): cint; cdecl; external;
-function xmlSchemaIsValid(ctxt: xmlSchemaValidCtxtPtr): cint; cdecl; external;
-function xmlSchemaParse(ctxt: xmlSchemaParserCtxtPtr): xmlSchemaPtr; cdecl; external;
-procedure xmlSchemaFree(schema: xmlSchemaPtr); cdecl; external;
+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;
 {$IFDEF LIBXML_OUTPUT_ENABLED}
 {XMLPUBFUN void XMLCALL		
 	    xmlSchemaDump		(FILE *output,
@@ -112,23 +112,23 @@ procedure xmlSchemaFree(schema: xmlSchemaPtr); cdecl; external;
 (*
  * Interfaces for validating
  *)
-procedure xmlSchemaSetValidErrors(ctxt: xmlSchemaParserCtxtPtr; err: xmlSchemaValidityErrorFunc; warn: xmlSchemaValidityWarningFunc; ctx: pointer); cdecl; external;
-procedure xmlSchemaSetValidStructuredErrors(ctxt: xmlSchemaParserCtxtPtr; serror: xmlStructuredErrorFunc; ctx: pointer); cdecl; external;
-function xmlSchemaGetValidErrors(ctxt: xmlSchemaParserCtxtPtr; var err: xmlSchemaValidityErrorFunc; var warn: xmlSchemaValidityWarningFunc; var ctx: pointer): cint; cdecl; external;
-function xmlSchemaSetValidOptions(ctxt: xmlSchemaValidCtxtPtr; options: cint): cint; cdecl; external;
-function xmlSchemaValidCtxtGetOptions(ctxt: xmlSchemaValidCtxtPtr): cint; cdecl; external;
-function xmlSchemaNewValidCtxt(schema: xmlSchemaPtr): xmlSchemaValidCtxtPtr; cdecl; external;
-procedure xmlSchemaFreeValidCtxt(ctxt: xmlSchemaValidCtxtPtr); cdecl; external;
-function xmlSchemaNewValidCtxt(ctxt: xmlSchemaValidCtxtPtr; instance: xmlDocPtr): cint; cdecl; external;
-function xmlSchemaValidateOneElement(ctxt: xmlSchemaValidCtxtPtr; elem: xmlNodePtr): cint; cdecl; external;
-function xmlSchemaValidateStream(ctxt: xmlSchemaValidCtxtPtr; input: xmlParserInputBufferPtr; enc: xmlCharEncoding; sax: xmlSAXHandlerPtr; user_data: pointer): cint; cdecl; external;
-function xmlSchemaValidateFile(ctxt: xmlSchemaValidCtxtPtr; filename: pchar; options: cint): cint; cdecl; external;
+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;
 
 (*
  * Interface to insert Schemas SAX velidation in a SAX stream
  *)
-function xmlSchemaSAXPlug(ctxt: xmlSchemaValidCtxtPtr; var sax: xmlSchemaSAXPlugPtr; var user_data: pointer): xmlSchemaSAXPlugPtr; cdecl; external;
-function xmlSchemaSAXUnplug(plug: xmlSchemaSAXPlugPtr): cint; cdecl; external;
+function xmlSchemaSAXPlug(ctxt: xmlSchemaValidCtxtPtr; var sax: xmlSchemaSAXPlugPtr; var user_data: pointer): xmlSchemaSAXPlugPtr; XMLCALL; XMLPUBFUN;
+function xmlSchemaSAXUnplug(plug: xmlSchemaSAXPlugPtr): cint; XMLCALL; XMLPUBFUN;
 {$ENDIF}
 
 {$ENDIF} (* LIBXML_SCHEMAS_ENABLED *)

packages/libxml/src/xmlschemastypes.h → packages/libxml/src/xmlschemastypes.inc

@@ -20,28 +20,28 @@
 {$ENDIF}
 
 {$IFDEF FUNCTION_}
-procedure xmlSchemaInitTypes; cdecl; external;
-procedure xmlSchemaCleanupTypes; cdecl; external;
-function xmlSchemaGetPredefinedType(name, ns: xmlCharPtr): xmlSchemaTypePtr; cdecl; external;
-function xmlSchemaValidatePredefinedType(_type: xmlSchemaTypePtr; value: xmlCharPtr; var val: xmlSchemaValPtr): cint; cdecl; external;
-function xmlSchemaValPredefTypeNode(_type: xmlSchemaTypePtr; value: xmlCharPtr; var val: xmlSchemaValPtr; node: xmlNodePtr): cint; cdecl; external;
-function xmlSchemaValidateFacet(base: xmlSchemaTypePtr; facet: xmlSchemaFacetPtr; value: xmlCharPtr; val: xmlSchemaValPtr): cint; cdecl; external;
+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;
 function xmlSchemaValidateFacetWhtsp(facet: xmlSchemaFacetPtr; fws: xmlSchemaWhitespaceValueType; valType: xmlSchemaValType;
-  value: xmlCharPtr; val: xmlSchemaValPtr; ws: xmlSchemaWhitespaceValueType): cint; cdecl; external;
-procedure xmlSchemaFreeValue(val: xmlSchemaValPtr); cdecl; external;
-function xmlSchemaNewFacet: xmlSchemaFacetPtr; cdecl; external;
-function xmlSchemaCheckFacet(facet: xmlSchemaFacetPtr; typeDecl: xmlSchemaTypePtr; ctxt: xmlSchemaParserCtxtPtr; name: xmlCharPtr): cint; cdecl; external;
-procedure xmlSchemaFreeFacet(facet: xmlSchemaFacetPtr); cdecl; external;
-function xmlSchemaCompareValues(x, y: xmlSchemaValPtr): cint; cdecl; external;
-function xmlSchemaGetBuiltInListSimpleTypeItemType(_type: xmlSchemaTypePtr): xmlSchemaTypePtr; cdecl; external;
-function xmlSchemaValidateListSimpleTypeFacet(facet: xmlSchemaFacetPtr; value: xmlCharPtr; actualLen: culong; expectedLen: pculong): cint; cdecl; external;
-function xmlSchemaGetBuiltInType(_type: xmlSchemaValType): xmlSchemaTypePtr; cdecl; external;
-function xmlSchemaIsBuiltInTypeFacet(_type: xmlSchemaTypePtr; faceType: cint): xmlSchemaTypePtr; cdecl; external;
-function xmlSchemaCollapseString(value: xmlCharPtr): xmlCharPtr; cdecl; external;
-function xmlSchemaWhiteSpaceReplace(value: xmlCharPtr): xmlCharPtr; cdecl; external;
-function xmlSchemaGetFacetValueAsULong(facet: xmlSchemaFacetPtr): culong; cdecl; external;
-function xmlSchemaValidateLengthFacet(_type: xmlSchemaTypePtr; facet: xmlSchemaFacetPtr; value: xmlCharPtr; val: xmlSchemaValPtr; length: pculong): cint; cdecl; external;
-function xmlSchemaValidateLengthFacetWhtsp(facet: xmlSchemaFacetPtr; valType: xmlSchemaValType; value: xmlCharPtr; val: xmlSchemaValPtr; length: pculong; ws: xmlSchemaWhitespaceValueType): cint; cdecl; external;
+  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;
 
 
 XMLPUBFUN int XMLCALL

packages/libxml/src/xmlstring.h → packages/libxml/src/xmlstring.inc

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

packages/libxml/src/xmlunicode.h

@@ -1,190 +0,0 @@
-(*
- * Summary: Unicode character APIs
- * Description: API for the Unicode character APIs
- *
- * This file is automatically generated from the
- * UCS description files of the Unicode Character Database
- * http://www.unicode.org/Public/4.0-Update1/UCD-4.0.1.html
- * using the genUnicode.py Python script.
- *
- * Generation date: Mon Mar 27 11:09:52 2006
- * Sources: Blocks-4.0.1.txt UnicodeData-4.0.1.txt
- * Author: Daniel Veillard
- *)
-
-{$IFDEF LIBXML_UNICODE_ENABLED}
-
-{$IFDEF FUNCTION}
-function xmlUCSIsAegeanNumbers	(code: cint): cint; cdecl; external;
-function xmlUCSIsAlphabeticPresentationForms	(code: cint): cint; cdecl; external;
-function xmlUCSIsArabic	(code: cint): cint; cdecl; external;
-function xmlUCSIsArabicPresentationFormsA	(code: cint): cint; cdecl; external;
-function xmlUCSIsArabicPresentationFormsB	(code: cint): cint; cdecl; external;
-function xmlUCSIsArmenian	(code: cint): cint; cdecl; external;
-function xmlUCSIsArrows	(code: cint): cint; cdecl; external;
-function xmlUCSIsBasicLatin	(code: cint): cint; cdecl; external;
-function xmlUCSIsBengali	(code: cint): cint; cdecl; external;
-function xmlUCSIsBlockElements	(code: cint): cint; cdecl; external;
-function xmlUCSIsBopomofo	(code: cint): cint; cdecl; external;
-function xmlUCSIsBopomofoExtended	(code: cint): cint; cdecl; external;
-function xmlUCSIsBoxDrawing	(code: cint): cint; cdecl; external;
-function xmlUCSIsBraillePatterns	(code: cint): cint; cdecl; external;
-function xmlUCSIsBuhid	(code: cint): cint; cdecl; external;
-function xmlUCSIsByzantineMusicalSymbols	(code: cint): cint; cdecl; external;
-function xmlUCSIsCJKCompatibility	(code: cint): cint; cdecl; external;
-function xmlUCSIsCJKCompatibilityForms	(code: cint): cint; cdecl; external;
-function xmlUCSIsCJKCompatibilityIdeographs	(code: cint): cint; cdecl; external;
-function xmlUCSIsCJKCompatibilityIdeographsSupplement	(code: cint): cint; cdecl; external;
-function xmlUCSIsCJKRadicalsSupplement	(code: cint): cint; cdecl; external;
-function xmlUCSIsCJKSymbolsandPunctuation	(code: cint): cint; cdecl; external;
-function xmlUCSIsCJKUnifiedIdeographs	(code: cint): cint; cdecl; external;
-function xmlUCSIsCJKUnifiedIdeographsExtensionA	(code: cint): cint; cdecl; external;
-function xmlUCSIsCJKUnifiedIdeographsExtensionB	(code: cint): cint; cdecl; external;
-function xmlUCSIsCherokee	(code: cint): cint; cdecl; external;
-function xmlUCSIsCombiningDiacriticalMarks	(code: cint): cint; cdecl; external;
-function xmlUCSIsCombiningDiacriticalMarksforSymbols	(code: cint): cint; cdecl; external;
-function xmlUCSIsCombiningHalfMarks	(code: cint): cint; cdecl; external;
-function xmlUCSIsCombiningMarksforSymbols	(code: cint): cint; cdecl; external;
-function xmlUCSIsControlPictures	(code: cint): cint; cdecl; external;
-function xmlUCSIsCurrencySymbols	(code: cint): cint; cdecl; external;
-function xmlUCSIsCypriotSyllabary	(code: cint): cint; cdecl; external;
-function xmlUCSIsCyrillic	(code: cint): cint; cdecl; external;
-function xmlUCSIsCyrillicSupplement	(code: cint): cint; cdecl; external;
-function xmlUCSIsDeseret	(code: cint): cint; cdecl; external;
-function xmlUCSIsDevanagari	(code: cint): cint; cdecl; external;
-function xmlUCSIsDingbats	(code: cint): cint; cdecl; external;
-function xmlUCSIsEnclosedAlphanumerics	(code: cint): cint; cdecl; external;
-function xmlUCSIsEnclosedCJKLettersandMonths	(code: cint): cint; cdecl; external;
-function xmlUCSIsEthiopic	(code: cint): cint; cdecl; external;
-function xmlUCSIsGeneralPunctuation	(code: cint): cint; cdecl; external;
-function xmlUCSIsGeometricShapes	(code: cint): cint; cdecl; external;
-function xmlUCSIsGeorgian	(code: cint): cint; cdecl; external;
-function xmlUCSIsGothic	(code: cint): cint; cdecl; external;
-function xmlUCSIsGreek	(code: cint): cint; cdecl; external;
-function xmlUCSIsGreekExtended	(code: cint): cint; cdecl; external;
-function xmlUCSIsGreekandCoptic	(code: cint): cint; cdecl; external;
-function xmlUCSIsGujarati	(code: cint): cint; cdecl; external;
-function xmlUCSIsGurmukhi	(code: cint): cint; cdecl; external;
-function xmlUCSIsHalfwidthandFullwidthForms	(code: cint): cint; cdecl; external;
-function xmlUCSIsHangulCompatibilityJamo	(code: cint): cint; cdecl; external;
-function xmlUCSIsHangulJamo	(code: cint): cint; cdecl; external;
-function xmlUCSIsHangulSyllables	(code: cint): cint; cdecl; external;
-function xmlUCSIsHanunoo	(code: cint): cint; cdecl; external;
-function xmlUCSIsHebrew	(code: cint): cint; cdecl; external;
-function xmlUCSIsHighPrivateUseSurrogates	(code: cint): cint; cdecl; external;
-function xmlUCSIsHighSurrogates	(code: cint): cint; cdecl; external;
-function xmlUCSIsHiragana	(code: cint): cint; cdecl; external;
-function xmlUCSIsIPAExtensions	(code: cint): cint; cdecl; external;
-function xmlUCSIsIdeographicDescriptionCharacters	(code: cint): cint; cdecl; external;
-function xmlUCSIsKanbun	(code: cint): cint; cdecl; external;
-function xmlUCSIsKangxiRadicals	(code: cint): cint; cdecl; external;
-function xmlUCSIsKannada	(code: cint): cint; cdecl; external;
-function xmlUCSIsKatakana	(code: cint): cint; cdecl; external;
-function xmlUCSIsKatakanaPhoneticExtensions	(code: cint): cint; cdecl; external;
-function xmlUCSIsKhmer	(code: cint): cint; cdecl; external;
-function xmlUCSIsKhmerSymbols	(code: cint): cint; cdecl; external;
-function xmlUCSIsLao	(code: cint): cint; cdecl; external;
-function xmlUCSIsLatin1Supplement	(code: cint): cint; cdecl; external;
-function xmlUCSIsLatinExtendedA	(code: cint): cint; cdecl; external;
-function xmlUCSIsLatinExtendedB	(code: cint): cint; cdecl; external;
-function xmlUCSIsLatinExtendedAdditional	(code: cint): cint; cdecl; external;
-function xmlUCSIsLetterlikeSymbols	(code: cint): cint; cdecl; external;
-function xmlUCSIsLimbu	(code: cint): cint; cdecl; external;
-function xmlUCSIsLinearBIdeograms	(code: cint): cint; cdecl; external;
-function xmlUCSIsLinearBSyllabary	(code: cint): cint; cdecl; external;
-function xmlUCSIsLowSurrogates	(code: cint): cint; cdecl; external;
-function xmlUCSIsMalayalam	(code: cint): cint; cdecl; external;
-function xmlUCSIsMathematicalAlphanumericSymbols	(code: cint): cint; cdecl; external;
-function xmlUCSIsMathematicalOperators	(code: cint): cint; cdecl; external;
-function xmlUCSIsMiscellaneousMathematicalSymbolsA	(code: cint): cint; cdecl; external;
-function xmlUCSIsMiscellaneousMathematicalSymbolsB	(code: cint): cint; cdecl; external;
-function xmlUCSIsMiscellaneousSymbols	(code: cint): cint; cdecl; external;
-function xmlUCSIsMiscellaneousSymbolsandArrows	(code: cint): cint; cdecl; external;
-function xmlUCSIsMiscellaneousTechnical	(code: cint): cint; cdecl; external;
-function xmlUCSIsMongolian	(code: cint): cint; cdecl; external;
-function xmlUCSIsMusicalSymbols	(code: cint): cint; cdecl; external;
-function xmlUCSIsMyanmar	(code: cint): cint; cdecl; external;
-function xmlUCSIsNumberForms	(code: cint): cint; cdecl; external;
-function xmlUCSIsOgham	(code: cint): cint; cdecl; external;
-function xmlUCSIsOldItalic	(code: cint): cint; cdecl; external;
-function xmlUCSIsOpticalCharacterRecognition	(code: cint): cint; cdecl; external;
-function xmlUCSIsOriya	(code: cint): cint; cdecl; external;
-function xmlUCSIsOsmanya	(code: cint): cint; cdecl; external;
-function xmlUCSIsPhoneticExtensions	(code: cint): cint; cdecl; external;
-function xmlUCSIsPrivateUse	(code: cint): cint; cdecl; external;
-function xmlUCSIsPrivateUseArea	(code: cint): cint; cdecl; external;
-function xmlUCSIsRunic	(code: cint): cint; cdecl; external;
-function xmlUCSIsShavian	(code: cint): cint; cdecl; external;
-function xmlUCSIsSinhala	(code: cint): cint; cdecl; external;
-function xmlUCSIsSmallFormVariants	(code: cint): cint; cdecl; external;
-function xmlUCSIsSpacingModifierLetters	(code: cint): cint; cdecl; external;
-function xmlUCSIsSpecials	(code: cint): cint; cdecl; external;
-function xmlUCSIsSuperscriptsandSubscripts	(code: cint): cint; cdecl; external;
-function xmlUCSIsSupplementalArrowsA	(code: cint): cint; cdecl; external;
-function xmlUCSIsSupplementalArrowsB	(code: cint): cint; cdecl; external;
-function xmlUCSIsSupplementalMathematicalOperators	(code: cint): cint; cdecl; external;
-function xmlUCSIsSupplementaryPrivateUseAreaA	(code: cint): cint; cdecl; external;
-function xmlUCSIsSupplementaryPrivateUseAreaB	(code: cint): cint; cdecl; external;
-function xmlUCSIsSyriac	(code: cint): cint; cdecl; external;
-function xmlUCSIsTagalog	(code: cint): cint; cdecl; external;
-function xmlUCSIsTagbanwa	(code: cint): cint; cdecl; external;
-function xmlUCSIsTags	(code: cint): cint; cdecl; external;
-function xmlUCSIsTaiLe	(code: cint): cint; cdecl; external;
-function xmlUCSIsTaiXuanJingSymbols	(code: cint): cint; cdecl; external;
-function xmlUCSIsTamil	(code: cint): cint; cdecl; external;
-function xmlUCSIsTelugu	(code: cint): cint; cdecl; external;
-function xmlUCSIsThaana	(code: cint): cint; cdecl; external;
-function xmlUCSIsThai	(code: cint): cint; cdecl; external;
-function xmlUCSIsTibetan	(code: cint): cint; cdecl; external;
-function xmlUCSIsUgaritic	(code: cint): cint; cdecl; external;
-function xmlUCSIsUnifiedCanadianAboriginalSyllabics	(code: cint): cint; cdecl; external;
-function xmlUCSIsVariationSelectors	(code: cint): cint; cdecl; external;
-function xmlUCSIsVariationSelectorsSupplement	(code: cint): cint; cdecl; external;
-function xmlUCSIsYiRadicals	(code: cint): cint; cdecl; external;
-function xmlUCSIsYiSyllables	(code: cint): cint; cdecl; external;
-function xmlUCSIsYijingHexagramSymbols	(code: cint): cint; cdecl; external;
-
-function xmlUCSIsBlock	(code: cint; block: pchar): cint; cdecl; external;
-
-function xmlUCSIsCatC	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatCc	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatCf	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatCo	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatCs	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatL	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatLl	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatLm	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatLo	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatLt	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatLu	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatM	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatMc	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatMe	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatMn	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatN	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatNd	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatNl	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatNo	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatP	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatPc	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatPd	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatPe	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatPf	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatPi	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatPo	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatPs	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatS	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatSc	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatSk	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatSm	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatSo	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatZ	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatZl	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatZp	(code: cint): cint; cdecl; external;
-function xmlUCSIsCatZs	(code: cint): cint; cdecl; external;
-
-function xmlUCSIsCat  (code: cint; cat: pchar): cint; cdecl; external;
-{$ENDIF}
-
-{$ENDIF} (* LIBXML_UNICODE_ENABLED *)
-

packages/libxml/src/xmlunicode.inc

@@ -0,0 +1,190 @@
+(*
+ * Summary: Unicode character APIs
+ * Description: API for the Unicode character APIs
+ *
+ * This file is automatically generated from the
+ * UCS description files of the Unicode Character Database
+ * http://www.unicode.org/Public/4.0-Update1/UCD-4.0.1.html
+ * using the genUnicode.py Python script.
+ *
+ * Generation date: Mon Mar 27 11:09:52 2006
+ * Sources: Blocks-4.0.1.txt UnicodeData-4.0.1.txt
+ * Author: Daniel Veillard
+ *)
+
+{$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 xmlUCSIsBlock	(code: cint; block: pchar): cint; XMLCALL; XMLPUBFUN;
+
+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 xmlUCSIsCat  (code: cint; cat: pchar): cint; XMLCALL; XMLPUBFUN;
+{$ENDIF}
+
+{$ENDIF} (* LIBXML_UNICODE_ENABLED *)
+

packages/libxml/src/xmlversion.h → 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); cdecl; external;
+procedure xmlCheckVersion(version: cint); XMLCALL; XMLPUBFUN;
 
 
 (**

packages/libxml/src/xmlwriter.h → packages/libxml/src/xmlwriter.inc

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