* progress on libxml2 translation

git-svn-id: trunk@11583 -

packages/libxml/src/HTMLparser.inc

@@ -74,92 +74,41 @@
   end;
 {$ENDIF}
 
-{$IFDEF FUNCTION_}
+{$IFDEF FUNCTION}
 (*
  * There is only few public functions.
  *)
-XMLPUBFUN htmlElemDesc * XMLCALL
-			htmlTagLookup	(xmlChar *tag);
-XMLPUBFUN htmlEntityDesc * XMLCALL
-			htmlEntityLookup(xmlChar *name);
-XMLPUBFUN htmlEntityDesc * XMLCALL
-			htmlEntityValueLookup(unsigned int value);
-
-XMLPUBFUN int XMLCALL
-			htmlIsAutoClosed(htmlDocPtr doc,
-					 htmlNodePtr elem);
-XMLPUBFUN int XMLCALL
-			htmlAutoCloseTag(htmlDocPtr doc,
-					 xmlChar *name,
-					 htmlNodePtr elem);
-XMLPUBFUN htmlEntityDesc * XMLCALL
-			htmlParseEntityRef(htmlParserCtxtPtr ctxt,
-					 xmlChar **str);
-XMLPUBFUN int XMLCALL
-			htmlParseCharRef(htmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL
-			htmlParseElement(htmlParserCtxtPtr ctxt);
-
-XMLPUBFUN htmlParserCtxtPtr XMLCALL
-			htmlNewParserCtxt(void);
-
-XMLPUBFUN htmlParserCtxtPtr XMLCALL
-			htmlCreateMemoryParserCtxt(char *buffer,
-						   int size);
-
-XMLPUBFUN int XMLCALL
-			htmlParseDocument(htmlParserCtxtPtr ctxt);
-XMLPUBFUN htmlDocPtr XMLCALL
-			htmlSAXParseDoc	(xmlChar *cur,
-					 char *encoding,
-					 htmlSAXHandlerPtr sax,
-					 void *userData);
-XMLPUBFUN htmlDocPtr XMLCALL
-			htmlParseDoc	(xmlChar *cur,
-					 char *encoding);
-XMLPUBFUN htmlDocPtr XMLCALL
-			htmlSAXParseFile(char *filename,
-					 char *encoding,
-					 htmlSAXHandlerPtr sax,
-					 void *userData);
-XMLPUBFUN htmlDocPtr XMLCALL
-			htmlParseFile	(char *filename,
-					 char *encoding);
-XMLPUBFUN int XMLCALL
-			UTF8ToHtml	(unsigned char *out,
-					 int *outlen,
-					 unsigned char *in,
-					 int *inlen);
-XMLPUBFUN int XMLCALL
-			htmlEncodeEntities(unsigned char *out,
-					 int *outlen,
-					 unsigned char *in,
-					 int *inlen, int quoteChar);
-XMLPUBFUN int XMLCALL
-			htmlIsScriptAttribute(xmlChar *name);
-XMLPUBFUN int XMLCALL
-			htmlHandleOmittedElem(int val);
+function htmlTagLookup(tag: xmlCharPtr): htmlElemDescPtr; XMLCALL; XMLPUBFUN;
+function htmlEntityLookup(tag: xmlCharPtr): htmlEntityDescPtr; XMLCALL; XMLPUBFUN;
+function htmlEntityValueLookup(value: cuint): htmlEntityDescPtr; XMLCALL; XMLPUBFUN;
+
+function htmlIsAutoClosed(doc: htmlDocPtr; elem: htmlNodePtr): cint; XMLCALL; XMLPUBFUN;
+function htmlAutoCloseTag(doc: htmlDocPtr; name: xmlCharPtr; elem: htmlNodePtr): cint; XMLCALL; XMLPUBFUN;
+function htmlParseEntityRef(ctxt: htmlParserCtxtPtr; str: xmlCharPtrPtr): htmlEntityDescPtr; XMLCALL; XMLPUBFUN;
+
+function htmlParseCharRef(ctxt: htmlParserCtxtPtr): cint; XMLCALL; XMLPUBFUN;
+function htmlParseElement(ctxt: htmlParserCtxtPtr): cint; XMLCALL; XMLPUBFUN;
+function htmlNewParserCtxt: htmlParserCtxtPtr; XMLCALL; XMLPUBFUN;
+function htmlCreateMemoryParserCtxt(buffer: pchar; size: cint): htmlParserCtxtPtr; XMLCALL; XMLPUBFUN;
+
+function htmlParseDocument(doc: htmlDocPtr; elem: htmlNodePtr): cint; XMLCALL; XMLPUBFUN;
+function htmlSAXParseDoc(cur: xmlCharPtr; encoding: pchar; sax: htmlSAXHandlerPtr; userdata: pointer): htmlDocPtr; XMLCALL; XMLPUBFUN;
+function htmlParseDoc(cur: xmlCharPtr; encoding: pchar): htmlDocPtr; XMLCALL; XMLPUBFUN;
+function htmlSAXParseFile(filename, encoding: pchar; sax: htmlSAXHandlerPtr; userdata: pointer): htmlDocPtr; XMLCALL; XMLPUBFUN;
+function htmlParseFile(filename, encoding: pchar): htmlDocPtr; XMLCALL; XMLPUBFUN;
+function UTF8ToHtml(_out: pointer; outlen: cint; _in: pointer; inlen: cint): cint; XMLCALL; XMLPUBFUN;
+function htmlEncodeEntities(_out: pointer; outlen: cint; _in: pointer; inlen, quoteChar: cint): cint; XMLCALL; XMLPUBFUN;
+function htmlIsScriptAttribute(name: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function htmlHandleOmittedElem(val: cint): cint; XMLCALL; XMLPUBFUN;
 
 {$IFDEF LIBXML_PUSH_ENABLED}
 (**
  * Interfaces for the Push mode.
  *)
-XMLPUBFUN htmlParserCtxtPtr XMLCALL
-			htmlCreatePushParserCtxt(htmlSAXHandlerPtr sax,
-						 void *user_data,
-						 char *chunk,
-						 int size,
-						 char *filename,
-						 xmlCharEncoding enc);
-XMLPUBFUN int XMLCALL
-			htmlParseChunk		(htmlParserCtxtPtr ctxt,
-						 char *chunk,
-						 int size,
-						 int terminate);
+function htmlCreatePushParserCtxt(sax: htmlSAXHandlerPtr; userdata: pointer; chunk: pchar; size: cint; filename: pchar; enc: xmlCharEncoding): htmlParserCtxtPtr; XMLCALL; XMLPUBFUN;
+function htmlParseChunk(ctxt: htmlParserCtxtPtr; chunk: pchar; size, terminate: cint): htmlParserCtxtPtr; XMLCALL; XMLPUBFUN;
 {$ENDIF} (* LIBXML_PUSH_ENABLED *)
-
-XMLPUBFUN void XMLCALL
-			htmlFreeParserCtxt	(htmlParserCtxtPtr ctxt);
+procedure htmlFreeParserCtxt(ctxt: htmlParserCtxtPtr); XMLCALL; XMLPUBFUN;
 {$ENDIF}
 
 {$IFDEF TYPE}
@@ -184,71 +133,19 @@ XMLPUBFUN void XMLCALL
   HTML_PARSE_COMPACT  = 1 shl 16; (* compact small text nodes *)
 {$ENDIF}
 
-{$IFDEF FUNCTION_}
-XMLPUBFUN void XMLCALL
-		htmlCtxtReset		(htmlParserCtxtPtr ctxt);
-XMLPUBFUN int XMLCALL
-		htmlCtxtUseOptions	(htmlParserCtxtPtr ctxt,
-					 int options);
-XMLPUBFUN htmlDocPtr XMLCALL
-		htmlReadDoc		(xmlChar *cur,
-					 char *URL,
-					 char *encoding,
-					 int options);
-XMLPUBFUN htmlDocPtr XMLCALL
-		htmlReadFile		(char *URL,
-					 char *encoding,
-					 int options);
-XMLPUBFUN htmlDocPtr XMLCALL
-		htmlReadMemory		(char *buffer,
-					 int size,
-					 char *URL,
-					 char *encoding,
-					 int options);
-XMLPUBFUN htmlDocPtr XMLCALL
-		htmlReadFd		(int fd,
-					 char *URL,
-					 char *encoding,
-					 int options);
-XMLPUBFUN htmlDocPtr XMLCALL
-		htmlReadIO		(xmlInputReadCallback ioread,
-					 xmlInputCloseCallback ioclose,
-					 void *ioctx,
-					 char *URL,
-					 char *encoding,
-					 int options);
-XMLPUBFUN htmlDocPtr XMLCALL
-		htmlCtxtReadDoc		(xmlParserCtxtPtr ctxt,
-					 xmlChar *cur,
-					 char *URL,
-					 char *encoding,
-					 int options);
-XMLPUBFUN htmlDocPtr XMLCALL
-		htmlCtxtReadFile		(xmlParserCtxtPtr ctxt,
-					 char *filename,
-					 char *encoding,
-					 int options);
-XMLPUBFUN htmlDocPtr XMLCALL
-		htmlCtxtReadMemory		(xmlParserCtxtPtr ctxt,
-					 char *buffer,
-					 int size,
-					 char *URL,
-					 char *encoding,
-					 int options);
-XMLPUBFUN htmlDocPtr XMLCALL
-		htmlCtxtReadFd		(xmlParserCtxtPtr ctxt,
-					 int fd,
-					 char *URL,
-					 char *encoding,
-					 int options);
-XMLPUBFUN htmlDocPtr XMLCALL
-		htmlCtxtReadIO		(xmlParserCtxtPtr ctxt,
-					 xmlInputReadCallback ioread,
-					 xmlInputCloseCallback ioclose,
-					 void *ioctx,
-					 char *URL,
-					 char *encoding,
-					 int options);
+{$IFDEF FUNCTION}
+procedure htmlCtxtReset(ctxt: htmlParserCtxtPtr); XMLCALL; XMLPUBFUN;
+function htmlParseChunk(ctxt: htmlParserCtxtPtr; options: cint): cint; XMLCALL; XMLPUBFUN;
+function htmlReadDoc(cur: xmlCharPtr; URL, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
+function htmlReadFile(URL, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
+function htmlReadMemory(buffer: pchar; size: cint; URL, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
+function htmlReadFd(fd: cint; URL, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
+function htmlReadIO(ioread: xmlInputReadCallback; ioclose: xmlInputCloseCallback; ioctx: pointer; URL, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
+function htmlCtxtReadDoc(ctxt: xmlParserCtxtPtr; cur: xmlCharPtr; URL, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
+function htmlCtxtReadFile(ctxt: xmlParserCtxtPtr; filename, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
+function htmlCtxtReadMemory(ctxt: xmlParserCtxtPtr; buffer: pchar; size: cint; URL, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
+function htmlCtxtReadFd(ctxt: xmlParserCtxtPtr; fd: cint; URL, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
+function htmlCtxtReadIO(ctxt: xmlParserCtxtPtr; ioread: xmlInputReadCallback; ioclose: xmlInputCloseCallback; ioctx: pointer; URL, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
 {$ENDIF}
 
 {$IFDEF TYPE}
@@ -279,7 +176,7 @@ function htmlNodeStatus(node: htmlNodePtr; val: cint): htmlStatus; XMLCALL; XMLP
  *
  * Returns the default subelement for this element
  *)
-//#define htmlDefaultSubelement(elt) elt->defaultsubelt
+function htmlDefaultSubelement(elt: htmlElemDescPtr): pchar;
 
 (**
  * htmlElementAllowedHereDesc:
@@ -291,8 +188,7 @@ function htmlNodeStatus(node: htmlNodePtr; val: cint): htmlStatus; XMLCALL; XMLP
  *
  * Returns 1 if allowed; 0 otherwise.
  *)
-{#define htmlElementAllowedHereDesc(parent,elt) \
-	htmlElementAllowedHere((parent), (elt)->name)}
+function htmlElementAllowedHereDesc(parent: htmlElemDescPtr; elt: htmlElemDescPtr): cint;
 
 (**
  * htmlRequiredAttrs:
@@ -300,7 +196,7 @@ function htmlNodeStatus(node: htmlNodePtr; val: cint): htmlStatus; XMLCALL; XMLP
  *
  * Returns the attributes required for the specified element.
  *)
-{#define htmlRequiredAttrs(elt) (elt)->attrs_req}
+function htmlRequiredAttrs(elt: htmlElemDescPtr): ppchar;
 {$ENDIF}
 
 {$ENDIF} (* LIBXML_HTML_ENABLED *)

packages/libxml/src/SAX.inc

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

packages/libxml/src/SAX2.inc

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

packages/libxml/src/libxml2.pas

@@ -55,6 +55,7 @@ type
   {$i schemasInternals.inc}
   {$i valid.inc}
   {$i parser.inc}
+  {$i parserInternals.inc}
   {$i schematron.inc}
   {$i threads.inc}
   {$i uri.inc}
@@ -103,6 +104,7 @@ type
   {$i schemasInternals.inc}
   {$i valid.inc}
   {$i parser.inc}
+  {$i parserInternals.inc}
   {$i schematron.inc}
   {$i threads.inc}
   {$i uri.inc}
@@ -152,6 +154,7 @@ const
   {$i hash.inc}
   {$i valid.inc}
   {$i parser.inc}
+  {$i parserInternals.inc}
   {$i schematron.inc}
   {$i threads.inc}
   {$i uri.inc}
@@ -200,6 +203,7 @@ const
   {$i hash.inc}
   {$i valid.inc}
   {$i parser.inc}
+  {$i parserInternals.inc}
   {$i schematron.inc}
   {$i threads.inc}
   {$i uri.inc}
@@ -373,9 +377,24 @@ end;
 
 
 (*
- * macros from globals.inc
+ * macros from HTMLparser.inc
  *)
 
+function htmlDefaultSubelement(elt: htmlElemDescPtr): pchar;
+begin
+  Result := elt^.defaultsubelt;
+end;
+
+function htmlElementAllowedHereDesc(parent: htmlElemDescPtr; elt: htmlElemDescPtr): cint;
+begin
+  Result := htmlElementAllowedHere(parent, elt^.name);
+end;
+
+function htmlRequiredAttrs(elt: htmlElemDescPtr): ppchar;
+begin
+  Result := elt^.attrs_req;
+end;
+
 
 (*
  * macros from tree.inc

packages/libxml/src/parserInternals.inc

@@ -9,18 +9,7 @@
  * Author: Daniel Veillard
  *)
 
-#ifndef __XML_PARSER_INTERNALS_H__
-#define __XML_PARSER_INTERNALS_H__
-
-#include <libxml/xmlversion.h>
-#include <libxml/parser.h>
-#include <libxml/HTMLparser.h>
-#include <libxml/chvalid.h>
-
-{ __cplusplus
-extern "C" {
-#endif
-
+{$IFDEF FUNCTION}
 (**
  * xmlParserMaxDepth:
  *
@@ -28,15 +17,18 @@ extern "C" {
  * process. This is not a limitation of the parser but a safety 
  * boundary feature.
  *)
-XMLPUBVAR unsigned int xmlParserMaxDepth;
+var
+  xmlParserMaxDepth: cuint; XMLPUBVAR;
+{$ENDIF}
 
+{$IFDEF CONST}
  (**
   * XML_MAX_NAMELEN:
   *
   * Identifiers can be longer, but this will be more costly
   * at runtime.
   *)
-#define XML_MAX_NAMELEN 100
+  XML_MAX_NAMELEN = 100;
 
 (**
  * INPUT_CHUNK:
@@ -44,8 +36,10 @@ XMLPUBVAR unsigned int xmlParserMaxDepth;
  * The parser tries to always have that amount of input ready.
  * One of the point is providing context when reporting errors.
  *)
-#define INPUT_CHUNK	250
+  INPUT_CHUNK	= 250;
+{$ENDIF}
 
+{$IFDEF FUNCTION_}
 (************************************************************************
  *									*
  * UNICODE version of the macros.      					*
@@ -243,8 +237,8 @@ XMLPUBVAR unsigned int xmlParserMaxDepth;
  * Skips the end of line chars.
  *)
 #define SKIP_EOL(p) 							\
-    if (*(p) == 0x13) { p++ ; if (*(p) == 0x10) p++; }			\
-    if (*(p) == 0x10) { p++ ; if (*(p) == 0x13) p++; }
+    if ( *(p) == 0x13) { p++ ; if ( *(p) == 0x10) p++; }			\
+    if ( *(p) == 0x10) { p++ ; if ( *(p) == 0x13) p++; }
 
 (**
  * MOVETO_ENDTAG:
@@ -253,7 +247,7 @@ XMLPUBVAR unsigned int xmlParserMaxDepth;
  * Skips to the next '>' char.
  *)
 #define MOVETO_ENDTAG(p)						\
-    while ((*p) && (*(p) != '>')) (p)++
+    while (( *p) && ( *(p) != '>')) (p)++
 
 (**
  * MOVETO_STARTTAG:
@@ -262,7 +256,7 @@ XMLPUBVAR unsigned int xmlParserMaxDepth;
  * Skips to the next '<' char.
  *)
 #define MOVETO_STARTTAG(p)						\
-    while ((*p) && (*(p) != '<')) (p)++
+    while (( *p) && ( *(p) != '<')) (p)++
 
 (**
  * Global variables used for predefined strings.
@@ -302,7 +296,7 @@ XMLPUBFUN int XMLCALL
 						 xmlParserInputPtr input,
 					 xmlCharEncodingHandlerPtr handler);
 
-{ IN_LIBXML
+{$IFDEF IN_LIBXML}
 (* internal error reporting *)
 XMLPUBFUN void XMLCALL
 			__xmlErrEncoding	(xmlParserCtxtPtr ctxt,
@@ -310,7 +304,7 @@ XMLPUBFUN void XMLCALL
 						 char *msg,
 						 xmlChar * str1,
 						 xmlChar * str2);
-#endif
+{$ENDIF}
 
 (**
  * Input Streams.
@@ -416,7 +410,7 @@ XMLPUBFUN void XMLCALL
 			xmlParsePEReference	(xmlParserCtxtPtr ctxt);
 XMLPUBFUN void XMLCALL			
 			xmlParseDocTypeDecl	(xmlParserCtxtPtr ctxt);
-{ LIBXML_SAX1_ENABLED
+{$IFDEF LIBXML_SAX1_ENABLED}
 XMLPUBFUN xmlChar * XMLCALL		
 			xmlParseAttribute	(xmlParserCtxtPtr ctxt,
 						 xmlChar **value);
@@ -424,7 +418,7 @@ XMLPUBFUN xmlChar * XMLCALL
 			xmlParseStartTag	(xmlParserCtxtPtr ctxt);
 XMLPUBFUN void XMLCALL			
 			xmlParseEndTag		(xmlParserCtxtPtr ctxt);
-#endif (* LIBXML_SAX1_ENABLED *)
+{$ENDIF} (* LIBXML_SAX1_ENABLED *)
 XMLPUBFUN void XMLCALL			
 			xmlParseCDSect		(xmlParserCtxtPtr ctxt);
 XMLPUBFUN void XMLCALL			
@@ -450,32 +444,40 @@ XMLPUBFUN void XMLCALL
 XMLPUBFUN void XMLCALL			
 			xmlParseExternalSubset	(xmlParserCtxtPtr ctxt,
 						 xmlChar *ExternalID,
-						 xmlChar *SystemID); 
+						 xmlChar *SystemID);
+{$ENDIF}
+
+{$IFDEF CONST}
 (**
  * XML_SUBSTITUTE_NONE:
  *
  * If no entities need to be substituted.
  *)
-#define XML_SUBSTITUTE_NONE	0
+  XML_SUBSTITUTE_NONE	= 0;
+
 (**
  * XML_SUBSTITUTE_REF:
  *
  * Whether general entities need to be substituted.
  *)
-#define XML_SUBSTITUTE_REF	1
+  XML_SUBSTITUTE_REF	= 1;
+
 (**
  * XML_SUBSTITUTE_PEREF:
  *
  * Whether parameter entities need to be substituted.
  *)
-#define XML_SUBSTITUTE_PEREF	2
+  XML_SUBSTITUTE_PEREF	= 2;
+
 (**
  * XML_SUBSTITUTE_BOTH:
  *
  * Both general and parameter entities need to be substituted.
  *)
-#define XML_SUBSTITUTE_BOTH 	3
+  XML_SUBSTITUTE_BOTH 	= 3;
+{$ENDIF}
 
+{$IFDEF FUNCTION_}
 XMLPUBFUN xmlChar * XMLCALL
 		xmlStringDecodeEntities		(xmlParserCtxtPtr ctxt,
 						 xmlChar *str,
@@ -528,20 +530,20 @@ XMLPUBFUN int XMLCALL			xmlCopyChar		(int len,
 XMLPUBFUN void XMLCALL			xmlNextChar		(xmlParserCtxtPtr ctxt);
 XMLPUBFUN void XMLCALL			xmlParserInputShrink	(xmlParserInputPtr in);
 
-{ LIBXML_HTML_ENABLED
+{$IFDEF LIBXML_HTML_ENABLED}
 (*
  * Actually comes from the HTML parser but launched from the init stuff.
  *)
 XMLPUBFUN void XMLCALL			htmlInitAutoClose	(void);
 XMLPUBFUN htmlParserCtxtPtr XMLCALL	htmlCreateFileParserCtxt(char *filename,
 	                                         char *encoding);
-#endif
+{$ENDIF}
 
 (*
  * Specific function to keep track of entities references
  * and used by the XSLT debugger.
  *)
-{ LIBXML_LEGACY_ENABLED
+{$IFDEF LIBXML_LEGACY_ENABLED}
 (**
  * xmlEntityReferenceFunc:
  * @ent: the entity
@@ -551,7 +553,7 @@ XMLPUBFUN htmlParserCtxtPtr XMLCALL	htmlCreateFileParserCtxt(char *filename,
  * Callback function used when one needs to be able to track back the
  * provenance of a chunk of nodes inherited from an entity replacement.
  *)
-typedef	void	(*xmlEntityReferenceFunc)	(xmlEntityPtr ent,
+typedef	void	(xmlEntityReferenceFunc)	(xmlEntityPtr ent,
 						 xmlNodePtr firstNode,
 						 xmlNodePtr lastNode);
   
@@ -571,6 +573,7 @@ XMLPUBFUN void XMLCALL	xmlParserHandleReference(xmlParserCtxtPtr ctxt);
 XMLPUBFUN xmlChar * XMLCALL		
 			xmlNamespaceParseQName	(xmlParserCtxtPtr ctxt,
 						 xmlChar **prefix);
+
 (**
  * Entities
  *)
@@ -585,18 +588,14 @@ XMLPUBFUN void XMLCALL
 			xmlHandleEntity		(xmlParserCtxtPtr ctxt,
 						 xmlEntityPtr entity);
 
-#endif (* LIBXML_LEGACY_ENABLED *)
+{$ENDIF} (* LIBXML_LEGACY_ENABLED *)
 
-{ IN_LIBXML
+{$IFDEF IN_LIBXML}
 (*
  * internal only
  *)
 XMLPUBFUN void XMLCALL
 	xmlErrMemory		(xmlParserCtxtPtr ctxt,
 				 char *extra);
-#endif
-
-{ __cplusplus
-}
-#endif
-#endif (* __XML_PARSER_INTERNALS_H__ *)
+{$ENDIF}
+{$ENDIF}

packages/libxml/src/tree.inc

@@ -608,33 +608,18 @@ function xmlCopyDtd(dtd: xmlDtdPtr): xmlDtdPtr; XMLCALL; XMLPUBFUN;
 function xmlCopyDoc(doc: xmlDocPtr; recursive: cint): xmlDocPtr; XMLCALL; XMLPUBFUN;
 {$ENDIF} (* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) *)
 
-{$IFDEF 0}
 (*
  * Creating new nodes.
  *)
-XMLPUBFUN xmlNodePtr XMLCALL
-		xmlNewDocNode		(xmlDocPtr doc,
-					 xmlNsPtr ns,
-					 xmlChar *name,
-					 xmlChar *content);
-XMLPUBFUN xmlNodePtr XMLCALL
-		xmlNewDocNodeEatName	(xmlDocPtr doc,
-					 xmlNsPtr ns,
-					 xmlChar *name,
-					 xmlChar *content);
-XMLPUBFUN xmlNodePtr XMLCALL
-		xmlNewNode		(xmlNsPtr ns,
-					 xmlChar *name);
-XMLPUBFUN xmlNodePtr XMLCALL
-		xmlNewNodeEatName	(xmlNsPtr ns,
-					 xmlChar *name);
+function xmlNewDocNode(doc: xmlDocPtr; ns: xmlNsPtr; name, content: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
+function xmlNewDocNodeEatName(doc: xmlDocPtr; ns: xmlNsPtr; name, content: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
+function xmlNewNode(ns: xmlNsPtr; name: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
+function xmlNewNodeEatName(ns: xmlNsPtr; name: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
 {$IF defined(LIBXML_TREE_ENABLED) or defined(LIBXML_SCHEMAS_ENABLED)}
-XMLPUBFUN xmlNodePtr XMLCALL
-		xmlNewChild		(xmlNodePtr parent,
-					 xmlNsPtr ns,
-					 xmlChar *name,
-					 xmlChar *content);
+function xmlNewChild(parent: xmlNodePtr; ns: xmlNsPtr; name, content: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
 {$ENDIF}
+
+{$IFDEF 0}
 XMLPUBFUN xmlNodePtr XMLCALL
 		xmlNewDocText		(xmlDocPtr doc,
 					 xmlChar *content);
@@ -1005,26 +990,20 @@ XMLPUBFUN int XMLCALL
 					 char *encoding);
 
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
+{$ENDIF}
+
 (*
  * XHTML
  *)
-XMLPUBFUN int XMLCALL
-		xmlIsXHTML		(xmlChar *systemID,
-					 xmlChar *publicID);
+function xmlIsXHTML(systemID, publicID: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
 
 (*
  * Compression.
  *)
-XMLPUBFUN int XMLCALL
-		xmlGetDocCompressMode	(xmlDocPtr doc);
-XMLPUBFUN void XMLCALL
-		xmlSetDocCompressMode	(xmlDocPtr doc,
-					 int mode);
-XMLPUBFUN int XMLCALL
-		xmlGetCompressMode	(void);
-XMLPUBFUN void XMLCALL
-		xmlSetCompressMode	(int mode);
-{$ENDIF}
+function xmlGetDocCompressMode(doc: xmlDocPtr): cint; XMLCALL; XMLPUBFUN;
+procedure xmlSetDocCompressMode(ctxt: xmlDOMWrapCtxtPtr; mode: cint); XMLCALL; XMLPUBFUN;
+function xmlGetCompressMode: cint; XMLCALL; XMLPUBFUN;
+procedure xmlSetCompressMode(mode: cint); XMLCALL; XMLPUBFUN;
 
 (*
 * DOM-wrapper helper functions.