paweld/lazarus
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/lazarus/lazarus.git synced 2025-05-31 03:12:32 +02:00
Code Issues Packages Projects Releases Wiki Activity
9f7df59b14
lazarus/components/aggpas/expat-wrap/expat.pas
mattias 36a2b1ea07 added aggpas 
git-svn-id: trunk@21942 -
2009-10-01 12:24:32 +00:00

1025 lines
40 KiB
ObjectPascal
Raw Blame History

{**************************************************************************}
{ }
{ This C DLL header file first (automatic) conversion generated by: }
{ HeadConv 4.0 (c) 2000 by Bob Swart (aka Dr.Bob - www.drbob42.com) }
{ Final Delphi-Jedi (Darth) command-line units edition }
{ }
{ Generated Date: 10/02/2001 }
{ Generated Time: 11:22:30 }
{ }
{**************************************************************************}
//
// Extensive hand editing and correcting by Danny Heijl
// Feb 10, 2001 Danny.Heijl@pandora.be
//
// Adapted for working with Windows and Kylix Open Edtion on Linux
// Jul 29, 2001 Danny.Heijl@pandora.be
//
// Further Modifications and naming changes by Karl Waclawek
// Oct. 25, 2001 karl@waclawek.net
//
// Added include file directive for "expat.inc", by Karl Waclawek
// March 11, 2002 karl@waclawek.net
//
// Added support for new API members in Expat 1.95.5 and 1.95.6
// Jan. 29, 2003 karl@waclawek.net
//
// Adjusted for Expat 2.0.0 on Win/Linux/Mac [see {milano}]
// Jan. 3, 2007 milan@marusinec.sk
{ Notes
* For UTF-16 output, Expat must have been compiled with
XML_UNICODE and possibly XML_UNICODE_WCHAR_T defined,
matching exactly the status of these conditionals here
}
unit Expat;
interface
{$IFDEF MSWINDOWS}
uses
Windows;
{$ENDIF}
const
{$IFDEF XML_UNICODE}
LIBPOSTFIX = 'w';
{$ELSE}
LIBPOSTFIX = '';
{$ENDIF}
{$IFDEF LINUX }
EXPATLIB = 'libexpat' + LIBPOSTFIX + '.so';
{$ELSE}
EXPATLIB = 'libexpat' + LIBPOSTFIX + '.dll';
{$ENDIF}{milano}
{= > EXPAT.H <=}
{+// }
{-Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd }
{-See the file COPYING for copying permission. }
{= }
// for compatibility with C enum :
{$MINENUMSIZE 4}
type
TXMLParser = Pointer;
PXMLParser = ^TXMLParser;
PPXMLParser = ^PXMLParser;
XML_Parser = TXMLParser;
{ The XML_Status enum gives the possible return values for several API functions. }
XML_Status = (XML_STATUS_ERROR ,XML_STATUS_OK ,XML_STATUS_SUSPENDED );
{$IFDEF XML_UNICODE} {+// Information is UTF-16 encoded.*/ }
TXMLChar = WideChar;
PXMLChar = PWideChar;
{$IFDEF XML_UNICODE_WCHAR_T}
TXMLLChar = WideChar;
PXMLLChar = PWideChar;
{$ELSE}
TXMLLChar = Char;
PXMLLChar = PChar;
{$ENDIF}
{$ELSE} {+// Information is UTF-8 encoded.*/ }
TXMLChar = Char;
TXMLLChar = Char;
PXMLChar = PChar;
PXMLLChar = PChar;
{$ENDIF}
//PXMLChar = ^TXMLChar;
//PXMLLChar = ^TXMLLChar;
TXMLContentType = (
XML_CTYPE_ILLEGAL, //dummy, to make XML_CTYPE_EMPTY = 1
XML_CTYPE_EMPTY,
XML_CTYPE_ANY,
XML_CTYPE_MIXED,
XML_CTYPE_NAME,
XML_CTYPE_CHOICE,
XML_CTYPE_SEQ);
TXMLContentQuant = (
XML_CQUANT_NONE,
XML_CQUANT_OPT,
XML_CQUANT_REP,
XML_CQUANT_PLUS);
{+// If type == XML_CTYPE_EMPTY or XML_CTYPE_ANY, then quant will be }
{- XML_CQUANT_NONE, and the other fields will be zero or NULL. }
{- If type == XML_CTYPE_MIXED, then quant will be NONE or REP and }
{- numchildren will contain number of elements that may be mixed in }
{- and children point to an array of XMLContent cells that will be }
{- all of XML_CTYPE_NAME type with no quantification. }
{- If type == XML_CTYPE_NAME, then the name points to the name, and }
{- the numchildren field will be zero and children will be NULL. The }
{- quant fields indicates any quantifiers placed on the name. }
{- CHOICE and SEQ will have name NULL, the number of children in }
{- numchildren and children will point, recursively, to an array }
{- of XMLContent cells. }
{- The EMPTY, ANY, and MIXED types will only occur at top level. }
{= }
PXMLContent = ^TXMLContent;
PXMLContents = ^TXMLContents;
TXMLCp = packed record
Type_: TXMLContentType;
Quant: TXMLContentQuant;
Name: PXMLChar;
NumChildren:Cardinal;
Children: PXMLContents;
end;
TXMLContent = TXMLCp;
TXMLContents = packed array[0.. (MaxInt div SizeOf(TXMLContent)) - 1] of TXMLContent;
{+// This is called for an element declaration. See above for }
{- description of the model argument. It's the caller's responsibility }
{- to free model when finished with it. }
{= }
TXMLElementDeclhandler = procedure(
UserData: Pointer;
const Name: PXMLChar;
Model: PXMLContent); cdecl;
procedure XMLSetElementDeclhandler(
Parser: TXMLParser;
ElDecl: TXMLElementDeclHandler); cdecl;
type
{+// }
{- The Attlist declaration handler is called for*each* attribute. So }
{- a single Attlist declaration with multiple attributes declared will }
{- generate multiple calls to this handler. The "default" parameter }
{ may be NULL in the case of the "#IMPLIED" or "#REQUIRED" keyword. }
{- The "isrequired" parameter will be true and the default value will }
{ be NULL in the case of "#REQUIRED". If "isrequired" is true and }
{ default is non-NULL, then this is a "#FIXED" default. }
{= }
TXMLAttlistDeclHandler = procedure(
UserData: Pointer;
const ElName: PXMLChar;
const Attname, AttType, Dflt: PXMLChar;
IsRequired: Integer); cdecl;
procedure XMLSetAttlistDeclHandler(
Parser: TXMLParser;
AttDecl: TXMLAttlistDeclHandler); cdecl;
type
{+// The XML declaration handler is called for*both* XML declarations and }
{- text declarations. The way to distinguish is that the version parameter }
{- will be null for text declarations. The encoding parameter may be null }
{- for XML declarations. The standalone parameter will be -1, 0, or 1 }
{- indicating respectively that there was no standalone parameter in }
{- the declaration, that it was given as no, or that it was given as yes. }
{= }
TXMLXmlDeclHandler = procedure(
UserData: Pointer;
const Version, Encoding: PXMLChar;
Standalone: Integer); cdecl;
procedure XMLSetXmlDeclHandler(
Parser: TXMLParser;
XmlDecl: TXMLXMLdeclHandler); cdecl;
{+// Constructs a new Parser; encoding is the encoding specified by the external }
{= protocol or null if there is none specified. }
function XML_ParserCreate(const Encoding: PXMLChar): TXMLParser; cdecl;
{+// Constructs a new Parser and namespace processor. Element type names }
{- and attribute names that belong to a namespace will be expanded; }
{- unprefixed attribute names are never expanded; unprefixed element type }
{- names are expanded only if there is a default namespace. The expanded }
{- name is the concatenation of the namespace URI, the namespace separator character, }
{- and the local part of the name. If the namespace separator is '\0' then }
{- the namespace URI and the local part will be concatenated without any }
{- separator. When a namespace is not declared, the name and prefix will be }
{= passed through without expansion. }
function XMLParserCreateNS(
const Encoding: PXMLChar;
NamespaceSeparator: TXMLChar): TXMLParser; cdecl;
{+// Constructs a new Parser using the memory management suit referred to }
{- by memsuite. If memsuite is NULL, then use the standard library memory }
{- suite. If namespaceSeparator is non-NULL it creates a Parser with }
{- namespace processing as described above. The character pointed at }
{- will serve as the namespace separator. }
{- All further memory operations used for the created Parser will come from }
{- the given suite. }
{= }
type
TMallocFcn = function(Size: Integer): Pointer; cdecl;
TReallocFcn = function(Ptr: Pointer; Size: Integer): Pointer; cdecl;
TFreeFcn = procedure(Ptr: Pointer); cdecl;
PXMLMemoryHandlingSuite = ^TXMLMemoryHandlingSuite;
TXMLMemoryHandlingSuite = packed record
MallocFcn: TMallocFcn;
ReallocFcn: TReallocFcn;
FreeFcn: TFReeFcn;
end;
function XMLParserCreateMM(
const Encoding: PXMLChar;
const MemSuite: PXMLMemoryHandlingSuite;
const NamespaceSeparator: PXMLChar): TXMLParser; cdecl;
{+// Prepare a parser object to be re-used. This is particularly }
{- valuable when memory allocation overhead is disproportionatly high, }
{- such as when a large number of small documnents need to be parsed. }
{- All handlers are cleared from the parser, except for the }
{- unknownEncodingHandler. The parser's external state is re-initialized }
{= except for the values of ns, ns_triplets and useForeignDTD. }
(*function XMLParserReset(
Parser: TXMLParser;
const Encoding: PXMLChar): Integer;*){milano}
type
{+// attrs is array of name/value pairs, terminated by 0; }
{= names and values are 0 terminated. }
TAttrs = array[0..(MaxInt div SizeOf(PXMLChar)) - 1] of PXMLChar;
PAttrs = ^TAttrs;
TXMLStartElementHandler = procedure(
UserData: Pointer;
const Name: PXMLChar;
const Atts: TAttrs); cdecl;
TXMLEndElementHandler = procedure(
UserData: Pointer;
const Name: PXMLChar); cdecl;
{+// s is not 0 terminated.*/ }
TXMLCharacterDataHandler = procedure(
UserData: Pointer;
const S: PXMLChar;
Len: integer); cdecl;
{+// target and data are 0 terminated*/ }
TXMLProcessingInstructionHandler = procedure(
UserData: Pointer;
const Target: PXMLChar;
const Data: PXMLChar); cdecl;
{+// data is 0 terminated*/ }
TXMLCommentHandler = procedure(
UserData: Pointer;
const Data: PXMLChar); cdecl;
TXMLStartCdataSectionHandler = procedure(UserData: Pointer); cdecl;
TXMLEndCdataSectionHandler = procedure(UserData: Pointer); cdecl;
{+// This is called for any characters in the XML document for }
{- which there is no applicable handler. This includes both }
{- characters that are part of markup which is of a kind that is }
{- not reported (comments, markup declarations), or characters }
{- that are part of a construct which could be reported but }
{- for which no handler has been supplied. The characters are passed }
{- exactly as they were in the XML document except that }
{- they will be encoded in UTF-8. Line boundaries are not normalized. }
{- Note that a byte order mark character is not passed to the default handler. }
{- There are no guarantees about how characters are divided between calls }
{- to the default handler: for example, a comment might be split between }
{= multiple calls. }
TXMLDefaultHandler = procedure(
UserData: Pointer;
const S: PXMLChar;
Len: Integer); cdecl;
{+// This is called for the start of the DOCTYPE declaration, before }
{= any DTD or internal subset is parsed. }
TXMLStartDoctypeDeclHandler = procedure(
UserData: Pointer;
const DoctypeName: PXMLChar;
const SysId: PXMLChar;
const PubId: PXMLChar;
HasInternalSubset: Integer); cdecl;
{+// This is called for the start of the DOCTYPE declaration when the }
{= closing > is encountered, but after processing any external subset. }
TXMLEndDoctypeDeclHandler = procedure(UserData: Pointer); cdecl;
{+// This is called for entity declarations. The is_parameter_entity }
{- argument will be non-zero if the entity is a parameter entity, zero }
{- otherwise. }
{- For internal entities (<!ENTITY foo "bar">), value will }
{- be non-null and systemId, publicID, and notationName will be null. }
{- The value string is NOT null terminated; the length is provided in }
{- the value_length argument. Since it is legal to have zero-length }
{- values, do not use this argument to test for internal entities. }
{- For external entities, value will be null and systemId will be non-null. }
{- The publicId argument will be null unless a public identifier was }
{- provided. The notationName argument will have a non-null value only }
{- for unparsed entity declarations. }
{= }
TXMLEntityDeclHandler = procedure(
UserData: Pointer;
const EntityName: PXMLChar;
IsParameterEntity: Integer;
const Value: PXMLChar;
ValueLength: Integer;
const Base: PXMLChar;
const SystemId: PXMLChar;
const PublicId: PXMLChar;
const NotationName: PXMLChar); cdecl;
procedure XMLSetEntityDeclHandler(
Parser: TXMLParser;
Handler: TXMLEntityDeclHandler); cdecl;
type
{+// OBSOLETE -- OBSOLETE -- OBSOLETE }
{- This handler has been superceded by the EntityDeclHandler above. }
{- It is provided here for backward compatibility. }
{- This is called for a declaration of an unparsed (NDATA) }
{- entity. The base argument is whatever was set by XMLSetBase. }
{- The entityName, systemId and notationName arguments will never be null. }
{= The other arguments may be. }
TXMLUnparsedEntityDeclHandler = procedure(
UserData: Pointer;
const EntityName: PXMLChar;
const Base: PXMLChar;
const SystemId: PXMLChar;
const PublicId: PXMLChar;
const NotationName: PXMLChar); cdecl;
{+// This is called for a declaration of notation. }
{- The base argument is whatever was set by XMLSetBase. }
{= The notationName will never be null. The other arguments can be. }
TXMLNotationDeclHandler = procedure(
UserData: Pointer;
const NotationName: PXMLChar;
const Base: PXMLChar;
const SystemId: PXMLChar;
const PublicId: PXMLChar); cdecl;
{+// When namespace processing is enabled, these are called once for }
{- each namespace declaration. The call to the start and end element }
{- handlers occur between the calls to the start and end namespace }
{- declaration handlers. For an xmlns attribute, prefix will be null. }
{= For an xmlns="" attribute, uri will be null. }
TXMLStartNamespaceDeclHandler = procedure(
UserData: pointer;
const Prefix: PXMLChar;
const Uri: PXMLChar); cdecl;
TXMLEndNamespaceDeclHandler = procedure(
UserData: Pointer;
const Prefix: PXMLChar); cdecl;
{+// This is called if the document is not standalone (it has an }
{- external subset or a reference to a parameter entity, but does not }
{- have standalone="yes"). If this handler returns 0, then processing }
{- will not continue, and the Parser will return a }
{= XML_ERROR_NOT_STANDALONE error. }
TXMLNotStandaloneHandler = function(UserData: Pointer): Integer; cdecl;
{+// This is called for a reference to an external parsed general entity. }
{- The referenced entity is not automatically parsed. }
{- The application can parse it immediately or later using }
{- XMLExternalEntityParserCreate. }
{- The Parser argument is the Parser parsing the entity containing the reference; }
{- it can be passed as the Parser argument to XMLExternalEntityParserCreate. }
{- The systemId argument is the system identifier as specified in the entity declaration; }
{- it will not be null. }
{- The base argument is the system identifier that should be used as the base for }
{- resolving systemId if systemId was relative; this is set by XMLSetBase; }
{- it may be null. }
{- The publicId argument is the public identifier as specified in the entity declaration, }
{- or null if none was specified; the whitespace in the public identifier }
{- will have been normalized as required by the XML spec. }
{- The context argument specifies the parsing context in the format }
{- expected by the context argument to }
{- XMLExternalEntityParserCreate; context is valid only until the handler }
{- returns, so if the referenced entity is to be parsed later, it must be copied. }
{- The handler should return 0 if processing should not continue because of }
{- a fatal error in the handling of the external entity. }
{- In this case the calling Parser will return an XML_ERROR_EXTERNAL_ENTITY_HANDLING }
{- error. }
{= Note that unlike other handlers the first argument is the Parser, not UserData. }
TXMLExternalEntityRefHandler = function(
Parser: TXMLParser;
const Context: PXMLChar;
const Base: PXMLChar;
const SystemId: PXMLChar;
const PublicId: PXMLChar): Integer; cdecl;
{+// This is called in two situations: }
{- 1) An entity reference is encountered for which no declaration }
{- has been read *and* this is not an error. }
{- 2) An internal entity reference is read, but not expanded, because }
{= XML_SetDefaultHandler has been called. }
TXMLSkippedEntityHandler = procedure(
UserData: Pointer;
const EntityName: PXMLChar;
IsParameterEntity: Integer); cdecl;
{+// This structure is filled in by the XMLUnknownEncodingHandler }
{- to provide information to the Parser about encodings that are unknown }
{- to the Parser. }
{- The map[b] member gives information about byte sequences }
{- whose first byte is b. }
{- If map[b] is c where c is >= 0, then b by itself encodes the Unicode scalar value c. }
{- If map[b] is -1, then the byte sequence is malformed. }
{- If map[b] is -n, where n >= 2, then b is the first byte of an n-byte }
{- sequence that encodes a single Unicode scalar value. }
{- The data member will be passed as the first argument to the convert function. }
{- The convert function is used to convert multibyte sequences; }
{- s will point to a n-byte sequence where map[(unsigned char)*s] == -n. }
{- The convert function must return the Unicode scalar value }
{- represented by this byte sequence or -1 if the byte sequence is malformed. }
{- The convert function may be null if the encoding is a single-byte encoding, }
{- that is if map[b] >= -1 for all bytes b. }
{- When the Parser is finished with the encoding, then if release is not null, }
{- it will call release passing it the data member; }
{- once release has been called, the convert function will not be called again. }
{- Expat places certain restrictions on the encodings that are supported }
{- using this mechanism. }
{- 1. Every ASCII character that can appear in a well-formed XML document, }
{- other than the characters }
(* $@\^`{}~ *)
{- must be represented by a single byte, and that byte must be the }
{- same byte that represents that character in ASCII. }
{- 2. No character may require more than 4 bytes to encode. }
{- 3. All characters encoded must have Unicode scalar values <= 0xFFFF, }
{- (ie characters that would be encoded by surrogates in UTF-16 }
{- are not allowed). Note that this restriction doesn't apply to }
{- the built-in support for UTF-8 and UTF-16. }
{- 4. No Unicode character may be encoded by more than one distinct sequence }
{= of bytes. }
TConvertEncoding = function(Data: Pointer; S: Pchar): Integer; cdecl;
TReleaseEncoding = procedure(Data: Pointer); cdecl;
PXMLEncoding = ^TXMLEncoding;
TXMLEncoding = packed record
Map: array[0..255] of Integer;
Data: Pointer;
Convert: TConvertEncoding;
Release: TReleaseEncoding;
end;
{+// This is called for an encoding that is unknown to the Parser. }
{- The encodingHandlerData argument is that which was passed as the }
{- second argument to XMLSetUnknownEncodingHandler. }
{- The name argument gives the name of the encoding as specified in }
{- the encoding declaration. }
{- If the callback can provide information about the encoding, }
{- it must fill in the XMLEncoding structure, and return 1. }
{- Otherwise it must return 0. }
{- If info does not describe a suitable encoding, }
{= then the Parser will return an XML_UNKNOWN_ENCODING error. }
TXMLUnknownEncodingHandler = function(
EncodingHandlerData: Pointer;
const Name: PXMLChar;
Info: PXMLEncoding): Integer; cdecl;
procedure XML_SetElementHandler(
Parser: TXMLParser;
Start: TXMLStartElementHandler;
End_: TXMLEndElementHandler); cdecl;
procedure XMLSetStartElementhandler(
Parser: TXMLParser;
Handler: TXMLStartElementHandler); cdecl;
procedure XMLSetEndElementHandler(
Parser: TXMLParser;
Handler: TXMLEndElementHandler); cdecl;
procedure XML_SetCharacterDataHandler(
Parser: TXMLParser;
Handler: TXMLCharacterDataHandler); cdecl;
procedure XMLSetProcessingInstructionHandler(
Parser: TXMLParser;
Handler: TXMLProcessingInstructionHandler); cdecl;
procedure XMLSetCommentHandler(
Parser: TXMLParser;
Handler: TXMLCommentHandler); cdecl;
procedure XMLSetCdataSectionHandler(
Parser: TXMLParser;
Start: TXMLStartCdataSectionHandler;
End_: TXMLEndCdataSectionHandler); cdecl;
procedure XMLSetStartCdataSectionHandler(
Parser: TXMLParser;
Start: TXMLStartCdataSectionHandler); cdecl;
procedure XMLSetEndCdataSectionHandler(
Parser: TXMLParser;
End_: TXMLEndCdataSectionHandler); cdecl;
{+// This sets the default handler and also inhibits expansion of internal entities. }
{- The entity references will be passed to the default handler, or to the
{= skipped entity handler, if one is set. }
procedure XMLSetdefaultHandler(
Parser: TXMLParser;
Handler: TXMLDefaultHandler); cdecl;
{+// This sets the default handler but does not inhibit expansion of internal entities. }
{= The entity reference will not be passed to the default handler. }
procedure XMLSetDefaultHandlerExpand(
Parser: TXMLParser;
Handler: TXMLDefaultHandler); cdecl;
procedure XMLSetDoctypeDeclHandler(
Parser: TXMLParser;
Start: TXMLStartDoctypeDeclHandler;
End_: TXMLEndDoctypeDeclHandler); cdecl;
procedure XMLSetStartDoctypeDeclHandler(
Parser: TXMLParser;
Start: TXMLStartDoctypeDeclHandler); cdecl;
procedure XMLSetEndDoctypeDeclHandler(
Parser: TXMLParser;
End_: TXMLEndDoctypeDeclHandler); cdecl;
procedure XMLSetUnparsedEntityDeclHandler(
Parser: TXMLParser;
Handler: TXMLUnparsedEntityDeclHandler); cdecl;
procedure XMLSetNotationDeclHandler(
Parser: TXMLParser;
Handler: TXMLNotationDeclHandler); cdecl;
procedure XMLSetNameSpaceDeclHandler(
Parser: TXMLParser;
Start: TXMLStartNamespaceDeclHandler;
End_: TXMLEndNamespaceDeclHandler); cdecl;
procedure XMLSetStartNameSpaceDeclHandler(
Parser: TXMLParser;
Start: TXMLStartNamespaceDeclHandler); cdecl;
procedure XMLSetEndNameSpaceDeclHandler(
Parser: TXMLParser;
End_: TXMLEndNamespaceDeclHandler); cdecl;
procedure XMLSetNotstandaloneHandler(
Parser: TXMLParser;
Handler: TXMLNotStandaloneHandler); cdecl;
procedure XMLSetExternalEntityRefHandler(
Parser: TXMLParser;
Handler: TXMLExternalEntityRefHandler); cdecl;
{+// If a non-null value for arg is specified here, then it will be passed }
{- as the first argument to the external entity ref handler instead }
{= of the Parser object. }
procedure XMLSetExternalEntityRefHandlerArg(
Parser: TXMLParser;
Arg: Pointer); cdecl;
procedure XMLSetSkippedEntityHandler(
Parser: TXMLParser;
Handler: TXMLSkippedEntityHandler); cdecl;
{ EncodingHandlerData works like UserData }
procedure XMLSetUnknownEncodingHandler(
Parser: TXMLPARSER;
Handler: TXMLUnknownEncodingHandler;
EncodingHandlerData: Pointer); cdecl;
{+// This can be called within a handler for a start element, end element, }
{- processing instruction or character data. It causes the corresponding }
{= markup to be passed to the default handler. }
procedure XMLDefaultCurrent(Parser: TXMLParser); cdecl;
{+// If do_nst is non-zero, and namespace processing is in effect, and }
{- a name has a prefix (i.e. an explicit namespace qualifier) then }
{- that name is returned as a triplet in a single }
{- string separated by the separator character specified when the Parser }
{- was created: URI + sep + local_name + sep + prefix. }
{- If do_nst is zero, then namespace information is returned in the }
{- default manner (URI + sep + local_name) whether or not the names }
{- has a prefix. }
{= }
procedure XMLSetReturnNSTriplet(
Parser: TXMLParser;
DoNst: Integer); cdecl;
{+// This value is passed as the UserData argument to callbacks.*/ }
procedure XML_SetUserData(
Parser: TXMLParser;
UserData: Pointer); cdecl;
{+// Returns the last value set by XMLSetUserData or null.*/ }
{ #define XMLGetUserData(Parser) (*(void **)(Parser)) }
function XMLGetUserData(Parser: TXMLParser): Pointer;
{+// This is equivalent to supplying an encoding argument }
{- to XMLParserCreate. It must not be called after XMLParse }
{= or XMLParseBuffer. }
function XMLSetEncoding(
Parser: TXMLParser;
const Encoding: PXMLChar): Integer; cdecl;
{+// If this function is called, then the Parser will be passed }
{- as the first argument to callbacks instead of UserData. }
{= The UserData will still be accessible using XMLGetUserData. }
procedure XMLUseParserAsHandlerArg(Parser: TXMLParser); cdecl;
{+// If useDTD == XML_TRUE is passed to this function, then the parser }
{- will assume that there is an external subset, even if none is }
{- specified in the document. In such a case the parser will call the }
{- externalEntityRefHandler with a value of NULL for the systemId }
{- argument (the publicId and context arguments will be NULL as well). }
{- Note: If this function is called, then this must be done before }
{- the first call to XML_Parse or XML_ParseBuffer, since it will }
{- have no effect after that. Returns }
{- XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING. }
{- Note: If the document does not have a DOCTYPE declaration at all, }
{- then startDoctypeDeclHandler and endDoctypeDeclHandler will not }
{- be called, despite an external subset being parsed. }
{- Note: If XML_DTD is not defined when Expat is compiled, returns }
{= XML_ERROR_FEATURE_REQUIRES_XML_DTD. }
procedure XMLUseForeignDTD(
Parser: TXMLParser;
useDTD: ByteBool); cdecl;
{+// Sets the base to be used for resolving relative URIs in system identifiers in }
{- declarations. Resolving relative identifiers is left to the application: }
{- this value will be passed through as the base argument to the }
{- XMLExternalEntityRefHandler, XMLNotationDeclHandler }
{- and XMLUnparsedEntityDeclHandler. The base argument will be copied. }
{= Returns zero if out of memory, non-zero otherwise. }
function XMLSetBase(
Parser: TXMLParser;
const Base: PXMLChar): Integer; cdecl;
function XMLGetBase(Parser: TXMLParser): PXMLChar; cdecl;
{+// Returns the number of the attribute/value pairs passed in last call }
{- to the XMLStartElementHandler that were specified in the start-tag }
{- rather than defaulted. Each attribute/value pair counts as 2; thus }
{- this correspondds to an index into the atts array passed to the }
{= XMLStartElementHandler. }
function XMLGetSpecifiedAttributeCount(Parser: TXMLParser): Integer; cdecl;
{+// Returns the index of the ID attribute passed in the last call to }
{- XMLStartElementHandler, or -1 if there is no ID attribute. Each }
{- attribute/value pair counts as 2; thus this correspondds to an index }
{= into the atts array passed to the XMLStartElementHandler. }
function XMLGetIdAttributeIndex(Parser: TXMLParser): Integer; cdecl;
{+// Parses some input. Returns 0 if a fatal error is detected. }
{- The last call to XMLParse must have isFinal true; }
{= len may be zero for this call (or any other). }
function XML_Parse(
Parser: TXMLParser;
const S: PChar;
Len: Integer;
IsFinal: Integer): XML_Status; cdecl;
function XMLGetBuffer(
Parser: TXMLParser;
Len: Integer): Pointer; cdecl;
function XMLParseBuffer(
Parser: TXMLParser;
Len: Integer;
IsFinal: Integer): Integer; cdecl;
{+// Creates an XMLParser object that can parse an external general entity; }
{- context is a '\0'-terminated string specifying the parse context; }
{- encoding is a '\0'-terminated string giving the name of the externally specified encoding, }
{- or null if there is no externally specified encoding. }
{- The context string consists of a sequence of tokens separated by formfeeds (\f); }
{- a token consisting of a name specifies that the general entity of the name }
{- is open; a token of the form prefix=uri specifies the namespace for a particular }
{- prefix; a token of the form =uri specifies the default namespace. }
{- This can be called at any point after the first call to an ExternalEntityRefHandler }
{- so longer as the Parser has not yet been freed. }
{- The new Parser is completely independent and may safely be used in a separate thread. }
{- The handlers and UserData are initialized from the Parser argument. }
{= Returns 0 if out of memory. Otherwise returns a new XMLParser object. }
function XMLExternalEntityParserCreate(
Parser: TXMLParser;
const Context: PXMLChar;
const Encoding: PXMLChar): TXMLParser; cdecl;
type
TXMLParamEntityParsing = (
XML_PARAM_ENTITY_PARSING_NEVER,
XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE,
XML_PARAM_ENTITY_PARSING_ALWAYS);
{+// Controls parsing of parameter entities (including the external DTD }
{- subset). If parsing of parameter entities is enabled, then references }
{- to external parameter entities (including the external DTD subset) }
{- will be passed to the handler set with }
{- XMLSetExternalEntityRefHandler. The context passed will be 0. }
{- Unlike external general entities, external parameter entities can only }
{- be parsed synchronously. If the external parameter entity is to be }
{- parsed, it must be parsed during the call to the external entity ref }
{- handler: the complete sequence of XMLExternalEntityParserCreate, }
{- XMLParse/XMLParseBuffer and XMLParserFree calls must be made during }
{- this call. After XMLExternalEntityParserCreate has been called to }
{- create the Parser for the external parameter entity (context must be 0 }
{- for this call), it is illegal to make any calls on the old Parser }
{- until XMLParserFree has been called on the newly created Parser. If }
{- the library has been compiled without support for parameter entity }
{- parsing (ie without XML_DTD being defined), then }
{- XMLSetParamEntityParsing will return 0 if parsing of parameter }
{= entities is requested; otherwise it will return non-zero. }
function XMLSetParamEntityParsing(
Parser: TXMLParser;
Parsing: TXMLParamEntityParsing): Integer; cdecl;
type
TXMLError = (
XML_ERROR_NONE,
XML_ERROR_NO_MEMORY,
XML_ERROR_SYNTAX,
XML_ERROR_NO_ELEMENTS,
XML_ERROR_INVALID_TOKEN,
XML_ERROR_UNCLOSED_TOKEN,
XML_ERROR_PARTIAL_CHAR,
XML_ERROR_TAG_MISMATCH,
XML_ERROR_DUPLICATE_ATTRIBUTE,
XML_ERROR_JUNK_AFTER_DOC_ELEMENT,
XML_ERROR_PARAM_ENTITY_REF,
XML_ERROR_UNDEFINED_ENTITY,
XML_ERROR_RECURSIVE_ENTITY_REF,
XML_ERROR_ASYNC_ENTITY,
XML_ERROR_BAD_CHAR_REF,
XML_ERROR_BINARY_ENTITY_REF,
XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
XML_ERROR_MISPLACED_XML_PI,
XML_ERROR_UNKNOWN_ENCODING,
XML_ERROR_INCORRECT_ENCODING,
XML_ERROR_UNCLOSED_CDATA_SECTION,
XML_ERROR_EXTERNAL_ENTITY_HANDLING,
XML_ERROR_NOT_STANDALONE,
XML_ERROR_UNEXPECTED_STATE);
XML_Error = TXMLError;
{+// If XMLParse or XMLParseBuffer have returned 0, then XMLGetErrorCode );
{= returns information about the error. }
function XML_GetErrorCode(Parser: TXMLParser): TXMLError; cdecl;
{+// These functions return information about the current parse location. );
{- They may be called when XMLParse or XMLParseBuffer return 0; }
{- in this case the location is the location of the character at which }
{- the error was detected. }
{- They may also be called from any other callback called to report }
{- some parse event; in this the location is the location of the first }
{= of the sequence of characters that generated the event. }
function XML_GetCurrentLineNumber(Parser: TXMLParser): Integer; cdecl;
function XMLGetCurrentColumnNumber(Parser: TXMLParser): Integer; cdecl;
function XMLGetCurrentByteIndex(Parser: TXMLParser): Longint; cdecl;
{+// Return the number of bytes in the current event. }
{= Returns 0 if the event is in an internal entity. }
function XMLGetCurrentByteCount(Parser: TXMLParser): Integer; cdecl;
{+// If XML_CONTEXT_BYTES is defined, returns the input buffer, sets }
{- the integer pointed to by offset to the offset within this buffer }
{- of the current parse position, and sets the integer pointed to by size }
{- to the size of this buffer (the number of input bytes). Otherwise }
{- returns a null pointer. Also returns a null pointer if a parse isn't active. }
{- NOTE: The character pointer returned should not be used outside }
{= the handler that makes the call. }
function XMLGetInputContext(
Parser: TXMLParser;
var Offset: Integer;
var Size: Integer): PChar; cdecl;
{+// For backwards compatibility with previous versions. }
// #define XMLGetErrorLineNumber XMLGetCurrentLineNumber
// #define XMLGetErrorColumnNumber XMLGetCurrentColumnNumber
// #define XMLGetErrorByteIndex XMLGetCurrentByteIndex
{+// Frees memory used by the Parser. }
procedure XML_ParserFree(Parser: TXMLParser); cdecl;
{+// Returns a string describing the error. }
function XML_ErrorString(Code: Integer): PXMLLChar; cdecl;
{+// Return a string containing the version number of this expat }
function XMLExpatVersion: PXMLLChar; cdecl;
type
TXMLExpatVersion = packed record
Major: Longint;
Minor: Longint;
Micro: Longint;
end;
{+// Return a TXMLExpatVersion record with version details }
function XMLExpatVersionInfo: TXMLExpatVersion; cdecl;
type
{+// Added in Expat 1.95.5. }
TXMLFeature = (
XML_FEATURE_END,
XML_FEATURE_UNICODE,
XML_FEATURE_UNICODE_WCHAR_T,
XML_FEATURE_DTD,
XML_FEATURE_CONTEXT_BYTES,
XML_FEATURE_MIN_SIZE,
XML_FEATURE_SIZEOF_XML_CHAR,
XML_FEATURE_SIZEOF_XML_LCHAR);
{+// Additional features must be added to the end of this enum. }
PXMLFeatureInfo = ^TXMLFeatureInfo;
TXMLFeatureInfo = packed record
Feature: TXMLFeature;
Name: PXMLLChar;
Value: Longint
end;
PXMLFeatureList = ^TXMLFeatureList;
TXMLFeatureList = packed array[0.. (MaxInt div SizeOf(TXMLFeatureInfo)) - 1]
of TXMLFeatureInfo;
{+// Return a list feature macro descriptions }
function XMLGetFeatureList: PXMLFeatureList; cdecl;
{+// Frees the content model passed to the element declaration handler }
procedure XMLFreeContentModel(Parser: TXMLParser; Model: PXMLContent); cdecl;
{+// Exposing the memory handling functions used in Expat }
function XMLMemMalloc(
Parser: TXMLParser;
Size: Longword): Pointer; cdecl;
function XMLMemRealloc(
Parser: TXMLParser;
Ptr: Pointer;
Size: Longword): Pointer; cdecl;
procedure XMLMemFree(
Parser: TXMLParser;
Ptr: Pointer); cdecl;
implementation
{ XML_GetUserData is defined as a macro in Expat:
#define XML_GetUserData(Parser) (*(void **)(Parser))
So we can't call an API function, but we can duplicate what it does }
type
PPointer = ^Pointer;
function XMLGetUserData(Parser: TXMLParser): Pointer;
begin
Result := PPointer(Parser)^;
end;
procedure XMLDefaultCurrent;
external EXPATLIB name 'XML_DefaultCurrent';
function XML_ErrorString;
external EXPATLIB name 'XML_ErrorString';
function XMLExpatVersion;
external EXPATLIB name 'XML_ExpatVersion';
function XMLExpatVersionInfo;
external EXPATLIB name 'XML_ExpatVersionInfo';
function XMLExternalEntityParserCreate;
external EXPATLIB name 'XML_ExternalEntityParserCreate';
function XMLGetBase;
external EXPATLIB name 'XML_GetBase';
function XMLGetBuffer;
external EXPATLIB name 'XML_GetBuffer';
function XMLGetCurrentByteCount;
external EXPATLIB name 'XML_GetCurrentByteCount';
function XMLGetCurrentByteIndex;
external EXPATLIB name 'XML_GetCurrentByteIndex';
function XMLGetCurrentColumnNumber;
external EXPATLIB name 'XML_GetCurrentColumnNumber';
function XML_GetCurrentLineNumber;
external EXPATLIB name 'XML_GetCurrentLineNumber';
function XML_GetErrorCode;
external EXPATLIB name 'XML_GetErrorCode';
function XMLGetIdAttributeIndex;
external EXPATLIB name 'XML_GetIdAttributeIndex';
function XMLGetInputContext;
external EXPATLIB name 'XML_GetInputContext';
function XMLGetSpecifiedAttributeCount;
external EXPATLIB name 'XML_GetSpecifiedAttributeCount';
function XML_Parse;
external EXPATLIB name 'XML_Parse';
function XMLParseBuffer;
external EXPATLIB name 'XML_ParseBuffer';
function XML_ParserCreate;
external EXPATLIB name 'XML_ParserCreate';
function XMLParserCreateNS;
external EXPATLIB name 'XML_ParserCreateNS';
function XMLParserCreateMM;
external EXPATLIB name 'XML_ParserCreate_MM';
procedure XML_ParserFree;
external EXPATLIB name 'XML_ParserFree';
procedure XMLSetAttlistDeclHandler;
external EXPATLIB name 'XML_SetAttlistDeclHandler';
function XMLSetBase;
external EXPATLIB name 'XML_SetBase';
procedure XMLSetCdataSectionHandler;
external EXPATLIB name 'XML_SetCdataSectionHandler';
procedure XML_SetCharacterDataHandler;
external EXPATLIB name 'XML_SetCharacterDataHandler';
procedure XMLSetCommentHandler;
external EXPATLIB name 'XML_SetCommentHandler';
procedure XMLSetDefaultHandler;
external EXPATLIB name 'XML_SetDefaultHandler';
procedure XMLSetDefaultHandlerExpand;
external EXPATLIB name 'XML_SetDefaultHandlerExpand';
procedure XMLSetDoctypeDeclHandler;
external EXPATLIB name 'XML_SetDoctypeDeclHandler';
procedure XMLSetElementDeclHandler;
external EXPATLIB name 'XML_SetElementDeclHandler';
procedure XML_SetElementHandler;
external EXPATLIB name 'XML_SetElementHandler';
function XMLSetEncoding;
external EXPATLIB name 'XML_SetEncoding';
procedure XMLSetEndCdataSectionHandler;
external EXPATLIB name 'XML_SetEndCdataSectionHandler';
procedure XMLSetEndDoctypeDeclHandler;
external EXPATLIB name 'XML_SetEndDoctypeDeclHandler';
procedure XMLSetEndElementHandler;
external EXPATLIB name 'XML_SetEndElementHandler';
procedure XMLSetEndNamespaceDeclHandler;
external EXPATLIB name 'XML_SetEndNamespaceDeclHandler';
procedure XMLSetEntityDeclHandler;
external EXPATLIB name 'XML_SetEntityDeclHandler';
procedure XMLSetExternalEntityRefHandler;
external EXPATLIB name 'XML_SetExternalEntityRefHandler';
procedure XMLSetExternalEntityRefHandlerArg;
external EXPATLIB name 'XML_SetExternalEntityRefHandlerArg';
procedure XMLSetNamespaceDeclHandler;
external EXPATLIB name 'XML_SetNamespaceDeclHandler';
procedure XMLSetNotStandaloneHandler;
external EXPATLIB name 'XML_SetNotStandaloneHandler';
procedure XMLSetNotationDeclHandler;
external EXPATLIB name 'XML_SetNotationDeclHandler';
function XMLSetParamEntityParsing;
external EXPATLIB name 'XML_SetParamEntityParsing';
procedure XMLSetProcessingInstructionHandler;
external EXPATLIB name 'XML_SetProcessingInstructionHandler';
procedure XMLSetReturnNSTriplet;
external EXPATLIB name 'XML_SetReturnNSTriplet';
procedure XMLSetStartCdataSectionHandler;
external EXPATLIB name 'XML_SetStartCdataSectionHandler';
procedure XMLSetStartDoctypeDeclHandler;
external EXPATLIB name 'XML_SetStartDoctypeDeclHandler';
procedure XMLSetStartElementHandler;
external EXPATLIB name 'XML_SetStartElementHandler';
procedure XMLSetStartNamespaceDeclHandler;
external EXPATLIB name 'XML_SetStartNamespaceDeclHandler';
procedure XMLSetUnknownEncodingHandler;
external EXPATLIB name 'XML_SetUnknownEncodingHandler';
procedure XMLSetUnparsedEntityDeclHandler;
external EXPATLIB name 'XML_SetUnparsedEntityDeclHandler';
procedure XML_SetUserData;
external EXPATLIB name 'XML_SetUserData';
procedure XMLSetXmlDeclHandler;
external EXPATLIB name 'XML_SetXmlDeclHandler';
procedure XMLUseParserAsHandlerArg;
external EXPATLIB name 'XML_UseParserAsHandlerArg';
// added with version 1.95.3
(*function XMLParserReset;
external EXPATLIB name 'XML_ParserReset';*){milano}
procedure XMLSetSkippedEntityHandler;
external EXPATLIB name 'XML_SetSkippedEntityHandler';
// added with version 1.95.5
function XMLGetFeatureList;
external EXPATLIB name 'XML_GetFeatureList';
procedure XMLUseForeignDTD;
external EXPATLIB name 'XML_UseForeignDTD';
// added with version 1.95.6
procedure XMLFreeContentModel;
external EXPATLIB name 'XML_FreeContentModel';
function XMLMemMalloc;
external EXPATLIB name 'XML_MemMalloc';
function XMLMemRealloc;
external EXPATLIB name 'XML_MemRealloc';
procedure XMLMemFree;
external EXPATLIB name 'XML_MemFree';
end.
Reference in New Issue View Git Blame Copy Permalink