paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-08-12 07:06:08 +02:00
Code Issues Packages Projects Releases Wiki Activity

* progress on libxml2 translation

Browse Source 
git-svn-id: trunk@11583 -
This commit is contained in:
ivost 2008-08-15 09:56:06 +00:00
parent cd9cb036b9
commit fe9092be31
6 changed files with 192 additions and 487 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

182
packages/libxml/src/HTMLparser.inc
View File

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

168
packages/libxml/src/SAX.inc
View File

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

180
packages/libxml/src/SAX2.inc
View File

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

21
packages/libxml/src/libxml2.pas
View File

@ -55,6 +55,7 @@ type
{$i schemasInternals.inc} {$i schemasInternals.inc}
{$i valid.inc} {$i valid.inc}
{$i parser.inc} {$i parser.inc}
{$i parserInternals.inc}
{$i schematron.inc} {$i schematron.inc}
{$i threads.inc} {$i threads.inc}
{$i uri.inc} {$i uri.inc}
@ -103,6 +104,7 @@ type
{$i schemasInternals.inc} {$i schemasInternals.inc}
{$i valid.inc} {$i valid.inc}
{$i parser.inc} {$i parser.inc}
{$i parserInternals.inc}
{$i schematron.inc} {$i schematron.inc}
{$i threads.inc} {$i threads.inc}
{$i uri.inc} {$i uri.inc}
@ -152,6 +154,7 @@ const
{$i hash.inc} {$i hash.inc}
{$i valid.inc} {$i valid.inc}
{$i parser.inc} {$i parser.inc}
{$i parserInternals.inc}
{$i schematron.inc} {$i schematron.inc}
{$i threads.inc} {$i threads.inc}
{$i uri.inc} {$i uri.inc}
@ -200,6 +203,7 @@ const
{$i hash.inc} {$i hash.inc}
{$i valid.inc} {$i valid.inc}
{$i parser.inc} {$i parser.inc}
{$i parserInternals.inc}
{$i schematron.inc} {$i schematron.inc}
{$i threads.inc} {$i threads.inc}
{$i uri.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 * macros from tree.inc

79
packages/libxml/src/parserInternals.inc
View File

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

49
packages/libxml/src/tree.inc
View File

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