diff options
Diffstat (limited to 'lib/wrappers/expat.nim')
| -rwxr-xr-x | lib/wrappers/expat.nim | 877 |
1 files changed, 0 insertions, 877 deletions
diff --git a/lib/wrappers/expat.nim b/lib/wrappers/expat.nim deleted file mode 100755 index 3400dfdf7..000000000 --- a/lib/wrappers/expat.nim +++ /dev/null @@ -1,877 +0,0 @@ -# Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd -# See the file COPYING for copying permission. -# - -when not defined(expatDll): - when defined(windows): - const - expatDll = "expat.dll" - elif defined(macosx): - const - expatDll = "libexpat.dylib" - else: - const - expatDll = "libexpat.so(.1|)" -type - TParserStruct{.pure, final.} = object - - PParser* = ptr TParserStruct - -# The XML_Status enum gives the possible return values for several -# API functions. The preprocessor #defines are included so this -# stanza can be added to code that still needs to support older -# versions of Expat 1.95.x: -# -# #ifndef XML_STATUS_OK -# #define XML_STATUS_OK 1 -# #define XML_STATUS_ERROR 0 -# #endif -# -# Otherwise, the #define hackery is quite ugly and would have been -# dropped. -# - -type - TStatus*{.size: sizeof(cint).} = enum - STATUS_ERROR = 0, STATUS_OK = 1, STATUS_SUSPENDED = 2 - TError*{.size: sizeof(cint).} = enum - ERROR_NONE, ERROR_NO_MEMORY, ERROR_SYNTAX, ERROR_NO_ELEMENTS, - ERROR_INVALID_TOKEN, ERROR_UNCLOSED_TOKEN, ERROR_PARTIAL_CHAR, - ERROR_TAG_MISMATCH, ERROR_DUPLICATE_ATTRIBUTE, - ERROR_JUNK_AFTER_DOC_ELEMENT, - ERROR_PARAM_ENTITY_REF, ERROR_UNDEFINED_ENTITY, ERROR_RECURSIVE_ENTITY_REF, - ERROR_ASYNC_ENTITY, ERROR_BAD_CHAR_REF, ERROR_BINARY_ENTITY_REF, - ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF, ERROR_MISPLACED_XML_PI, - ERROR_UNKNOWN_ENCODING, ERROR_INCORRECT_ENCODING, - ERROR_UNCLOSED_CDATA_SECTION, ERROR_EXTERNAL_ENTITY_HANDLING, - ERROR_NOT_STANDALONE, ERROR_UNEXPECTED_STATE, ERROR_ENTITY_DECLARED_IN_PE, - ERROR_FEATURE_REQUIRES_XML_DTD, ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING, - ERROR_UNBOUND_PREFIX, - ERROR_UNDECLARING_PREFIX, ERROR_INCOMPLETE_PE, ERROR_XML_DECL, - ERROR_TEXT_DECL, ERROR_PUBLICID, ERROR_SUSPENDED, ERROR_NOT_SUSPENDED, - ERROR_ABORTED, ERROR_FINISHED, ERROR_SUSPEND_PE, - ERROR_RESERVED_PREFIX_XML, ERROR_RESERVED_PREFIX_XMLNS, - ERROR_RESERVED_NAMESPACE_URI - TContent_Type*{.size: sizeof(cint).} = enum - CTYPE_EMPTY = 1, CTYPE_ANY, CTYPE_MIXED, CTYPE_NAME, CTYPE_CHOICE, CTYPE_SEQ - TContent_Quant*{.size: sizeof(cint).} = enum - CQUANT_NONE, CQUANT_OPT, CQUANT_REP, 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 XML_Content 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 XML_Content cells. -# -# The EMPTY, ANY, and MIXED types will only occur at top level. -# - -type - TContent*{.pure, final.} = object - typ*: TContent_Type - quant*: TContent_Quant - name*: cstring - numchildren*: cint - children*: ptr TContent - - -# 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. -# - -type - TElementDeclHandler* = proc (userData: pointer, name: cstring, - model: ptr TContent){.cdecl.} - -proc SetElementDeclHandler*(parser: PParser, eldecl: TElementDeclHandler){. - cdecl, importc: "XML_SetElementDeclHandler", dynlib: expatDll.} -# 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. -# - -type - TAttlistDeclHandler* = proc (userData: pointer, elname: cstring, - attname: cstring, att_type: cstring, - dflt: cstring, isrequired: cint){.cdecl.} - -proc SetAttlistDeclHandler*(parser: PParser, attdecl: TAttlistDeclHandler){. - cdecl, importc: "XML_SetAttlistDeclHandler", dynlib: expatDll.} -# 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. -# - -type - TXmlDeclHandler* = proc (userData: pointer, version: cstring, - encoding: cstring, standalone: cint){.cdecl.} - -proc SetXmlDeclHandler*(parser: PParser, xmldecl: TXmlDeclHandler){.cdecl, - importc: "XML_SetXmlDeclHandler", dynlib: expatDll.} -type - TMemory_Handling_Suite*{.pure, final.} = object - malloc_fcn*: proc (size: int): pointer{.cdecl.} - realloc_fcn*: proc (p: pointer, size: int): pointer{.cdecl.} - free_fcn*: proc (p: pointer){.cdecl.} - - -# Constructs a new parser; encoding is the encoding specified by the -# external protocol or NULL if there is none specified. -# - -proc ParserCreate*(encoding: cstring): PParser{.cdecl, - importc: "XML_ParserCreate", dynlib: expatDll.} -# 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. -# It is a programming error to use the separator '\0' with namespace -# triplets (see XML_SetReturnNSTriplet). -# - -proc ParserCreateNS*(encoding: cstring, namespaceSeparator: char): PParser{. - cdecl, importc: "XML_ParserCreateNS", dynlib: expatDll.} -# Constructs a new parser using the memory management suite 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. -# - -proc ParserCreate_MM*(encoding: cstring, memsuite: ptr TMemory_Handling_Suite, - namespaceSeparator: cstring): PParser{.cdecl, - importc: "XML_ParserCreate_MM", dynlib: expatDll.} -# 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 and ns_triplets. -# -# Added in Expat 1.95.3. -# - -proc ParserReset*(parser: PParser, encoding: cstring): Bool{.cdecl, - importc: "XML_ParserReset", dynlib: expatDll.} -# atts is array of name/value pairs, terminated by 0; -# names and values are 0 terminated. -# - -type - TStartElementHandler* = proc (userData: pointer, name: cstring, - atts: cstringArray){.cdecl.} - TEndElementHandler* = proc (userData: pointer, name: cstring){.cdecl.} - -# s is not 0 terminated. - -type - TCharacterDataHandler* = proc (userData: pointer, s: cstring, len: cint){. - cdecl.} - -# target and data are 0 terminated - -type - TProcessingInstructionHandler* = proc (userData: pointer, target: cstring, - data: cstring){.cdecl.} - -# data is 0 terminated - -type - TCommentHandler* = proc (userData: pointer, data: cstring){.cdecl.} - TStartCdataSectionHandler* = proc (userData: pointer){.cdecl.} - TEndCdataSectionHandler* = proc (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 or UTF-16. -# 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. -# - -type - TDefaultHandler* = proc (userData: pointer, s: cstring, len: cint){.cdecl.} - -# This is called for the start of the DOCTYPE declaration, before -# any DTD or internal subset is parsed. -# - -type - TStartDoctypeDeclHandler* = proc (userData: pointer, doctypeName: cstring, - sysid: cstring, pubid: cstring, - has_internal_subset: cint){.cdecl.} - -# This is called for the start of the DOCTYPE declaration when the -# closing > is encountered, but after processing any external -# subset. -# - -type - TEndDoctypeDeclHandler* = proc (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 nul-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. -# -# Note that is_parameter_entity can't be changed to XML_Bool, since -# that would break binary compatibility. -# - -type - TEntityDeclHandler* = proc (userData: pointer, entityName: cstring, - is_parameter_entity: cint, value: cstring, - value_length: cint, base: cstring, - systemId: cstring, publicId: cstring, - notationName: cstring){.cdecl.} - -proc SetEntityDeclHandler*(parser: PParser, handler: TEntityDeclHandler){.cdecl, - importc: "XML_SetEntityDeclHandler", dynlib: expatDll.} -# 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 XML_SetBase. The -# entityName, systemId and notationName arguments will never be -# NULL. The other arguments may be. -# - -type - TUnparsedEntityDeclHandler* = proc (userData: pointer, entityName: cstring, - base: cstring, systemId: cstring, - publicId, notationName: cstring){. - cdecl.} - -# This is called for a declaration of notation. The base argument is -# whatever was set by XML_SetBase. The notationName will never be -# NULL. The other arguments can be. -# - -type - TNotationDeclHandler* = proc (userData: pointer, notationName: cstring, - base: cstring, systemId: cstring, - publicId: cstring){.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. -# - -type - TStartNamespaceDeclHandler* = proc (userData: pointer, prefix: cstring, - uri: cstring){.cdecl.} - TEndNamespaceDeclHandler* = proc (userData: pointer, prefix: cstring){.cdecl.} - -# This is called if the document is not standalone, that is, it has an -# external subset or a reference to a parameter entity, but does not -# have standalone="yes". If this handler returns XML_STATUS_ERROR, -# then processing will not continue, and the parser will return a -# XML_ERROR_NOT_STANDALONE error. -# If parameter entity parsing is enabled, then in addition to the -# conditions above this handler will only be called if the referenced -# entity was actually read. -# - -type - TNotStandaloneHandler* = proc (userData: pointer): cint{.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 -# XML_ExternalEntityParserCreate. -# -# The parser argument is the parser parsing the entity containing the -# reference; it can be passed as the parser argument to -# XML_ExternalEntityParserCreate. 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 XML_SetBase; 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 XML_ExternalEntityParserCreate; -# context is valid only until the handler returns, so if the -# referenced entity is to be parsed later, it must be copied. -# context is NULL only when the entity is a parameter entity. -# -# The handler should return XML_STATUS_ERROR 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. -# - -type - TExternalEntityRefHandler* = proc (parser: PParser, context: cstring, - base: cstring, systemId: cstring, - publicId: cstring): cint{.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. -# Note: skipped parameter entities in declarations and skipped general -# entities in attribute values cannot be reported, because -# the event would be out of sync with the reporting of the -# declarations or attribute values -# - -type - TSkippedEntityHandler* = proc (userData: pointer, entityName: cstring, - is_parameter_entity: cint){.cdecl.} - -# This structure is filled in by the XML_UnknownEncodingHandler 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, (i.e., 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. -# - -type - TEncoding*{.pure, final.} = object - map*: array[0..256 - 1, cint] - data*: pointer - convert*: proc (data: pointer, s: cstring): cint{.cdecl.} - release*: proc (data: pointer){.cdecl.} - - -# 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 XML_SetUnknownEncodingHandler. -# -# 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 XML_Encoding structure, and return XML_STATUS_OK. -# Otherwise it must return XML_STATUS_ERROR. -# -# If info does not describe a suitable encoding, then the parser will -# return an XML_UNKNOWN_ENCODING error. -# - -type - TUnknownEncodingHandler* = proc (encodingHandlerData: pointer, name: cstring, - info: ptr TEncoding): cint{.cdecl.} - -proc SetElementHandler*(parser: PParser, start: TStartElementHandler, - endHandler: TEndElementHandler){.cdecl, - importc: "XML_SetElementHandler", dynlib: expatDll.} -proc SetStartElementHandler*(parser: PParser, handler: TStartElementHandler){. - cdecl, importc: "XML_SetStartElementHandler", dynlib: expatDll.} -proc SetEndElementHandler*(parser: PParser, handler: TEndElementHandler){.cdecl, - importc: "XML_SetEndElementHandler", dynlib: expatDll.} -proc SetCharacterDataHandler*(parser: PParser, handler: TCharacterDataHandler){. - cdecl, importc: "XML_SetCharacterDataHandler", dynlib: expatDll.} -proc SetProcessingInstructionHandler*(parser: PParser, - handler: TProcessingInstructionHandler){. - cdecl, importc: "XML_SetProcessingInstructionHandler", dynlib: expatDll.} -proc SetCommentHandler*(parser: PParser, handler: TCommentHandler){.cdecl, - importc: "XML_SetCommentHandler", dynlib: expatDll.} -proc SetCdataSectionHandler*(parser: PParser, start: TStartCdataSectionHandler, - endHandler: TEndCdataSectionHandler){.cdecl, - importc: "XML_SetCdataSectionHandler", dynlib: expatDll.} -proc SetStartCdataSectionHandler*(parser: PParser, - start: TStartCdataSectionHandler){.cdecl, - importc: "XML_SetStartCdataSectionHandler", dynlib: expatDll.} -proc SetEndCdataSectionHandler*(parser: PParser, - endHandler: TEndCdataSectionHandler){.cdecl, - importc: "XML_SetEndCdataSectionHandler", dynlib: expatDll.} -# This sets the default handler and also inhibits expansion of -# internal entities. These entity references will be passed to the -# default handler, or to the skipped entity handler, if one is set. -# - -proc SetDefaultHandler*(parser: PParser, handler: TDefaultHandler){.cdecl, - importc: "XML_SetDefaultHandler", dynlib: expatDll.} -# This sets the default handler but does not inhibit expansion of -# internal entities. The entity reference will not be passed to the -# default handler. -# - -proc SetDefaultHandlerExpand*(parser: PParser, handler: TDefaultHandler){.cdecl, - importc: "XML_SetDefaultHandlerExpand", dynlib: expatDll.} -proc SetDoctypeDeclHandler*(parser: PParser, start: TStartDoctypeDeclHandler, - endHandler: TEndDoctypeDeclHandler){.cdecl, - importc: "XML_SetDoctypeDeclHandler", dynlib: expatDll.} -proc SetStartDoctypeDeclHandler*(parser: PParser, - start: TStartDoctypeDeclHandler){.cdecl, - importc: "XML_SetStartDoctypeDeclHandler", dynlib: expatDll.} -proc SetEndDoctypeDeclHandler*(parser: PParser, - endHandler: TEndDoctypeDeclHandler){.cdecl, - importc: "XML_SetEndDoctypeDeclHandler", dynlib: expatDll.} -proc SetUnparsedEntityDeclHandler*(parser: PParser, - handler: TUnparsedEntityDeclHandler){.cdecl, - importc: "XML_SetUnparsedEntityDeclHandler", dynlib: expatDll.} -proc SetNotationDeclHandler*(parser: PParser, handler: TNotationDeclHandler){. - cdecl, importc: "XML_SetNotationDeclHandler", dynlib: expatDll.} -proc SetNamespaceDeclHandler*(parser: PParser, - start: TStartNamespaceDeclHandler, - endHandler: TEndNamespaceDeclHandler){.cdecl, - importc: "XML_SetNamespaceDeclHandler", dynlib: expatDll.} -proc SetStartNamespaceDeclHandler*(parser: PParser, - start: TStartNamespaceDeclHandler){.cdecl, - importc: "XML_SetStartNamespaceDeclHandler", dynlib: expatDll.} -proc SetEndNamespaceDeclHandler*(parser: PParser, - endHandler: TEndNamespaceDeclHandler){.cdecl, - importc: "XML_SetEndNamespaceDeclHandler", dynlib: expatDll.} -proc SetNotStandaloneHandler*(parser: PParser, handler: TNotStandaloneHandler){. - cdecl, importc: "XML_SetNotStandaloneHandler", dynlib: expatDll.} -proc SetExternalEntityRefHandler*(parser: PParser, - handler: TExternalEntityRefHandler){.cdecl, - importc: "XML_SetExternalEntityRefHandler", dynlib: expatDll.} -# 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. -# - -proc SetExternalEntityRefHandlerArg*(parser: PParser, arg: pointer){.cdecl, - importc: "XML_SetExternalEntityRefHandlerArg", dynlib: expatDll.} -proc SetSkippedEntityHandler*(parser: PParser, handler: TSkippedEntityHandler){. - cdecl, importc: "XML_SetSkippedEntityHandler", dynlib: expatDll.} -proc SetUnknownEncodingHandler*(parser: PParser, - handler: TUnknownEncodingHandler, - encodingHandlerData: pointer){.cdecl, - importc: "XML_SetUnknownEncodingHandler", dynlib: expatDll.} -# 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. -# - -proc DefaultCurrent*(parser: PParser){.cdecl, importc: "XML_DefaultCurrent", - dynlib: expatDll.} -# 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 name -# has a prefix. -# -# Note: Calling XML_SetReturnNSTriplet after XML_Parse or -# XML_ParseBuffer has no effect. -# - -proc SetReturnNSTriplet*(parser: PParser, do_nst: cint){.cdecl, - importc: "XML_SetReturnNSTriplet", dynlib: expatDll.} -# This value is passed as the userData argument to callbacks. - -proc SetUserData*(parser: PParser, userData: pointer){.cdecl, - importc: "XML_SetUserData", dynlib: expatDll.} -# Returns the last value set by XML_SetUserData or NULL. - -template GetUserData*(parser: expr): expr = - (cast[ptr pointer]((parser))[] ) - -# This is equivalent to supplying an encoding argument to -# XML_ParserCreate. On success XML_SetEncoding returns non-zero, -# zero otherwise. -# Note: Calling XML_SetEncoding after XML_Parse or XML_ParseBuffer -# has no effect and returns XML_STATUS_ERROR. -# - -proc SetEncoding*(parser: PParser, encoding: cstring): TStatus{.cdecl, - importc: "XML_SetEncoding", dynlib: expatDll.} -# 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 XML_GetUserData. -# - -proc UseParserAsHandlerArg*(parser: PParser){.cdecl, - importc: "XML_UseParserAsHandlerArg", dynlib: expatDll.} -# 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: For the purpose of checking WFC: Entity Declared, passing -# useDTD == XML_TRUE will make the parser behave as if the document -# had a DTD with an external subset. -# 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. -# - -proc UseForeignDTD*(parser: PParser, useDTD: Bool): TError{.cdecl, - importc: "XML_UseForeignDTD", dynlib: expatDll.} -# 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 XML_ExternalEntityRefHandler, -# XML_NotationDeclHandler and XML_UnparsedEntityDeclHandler. The base -# argument will be copied. Returns XML_STATUS_ERROR if out of memory, -# XML_STATUS_OK otherwise. -# - -proc SetBase*(parser: PParser, base: cstring): TStatus{.cdecl, - importc: "XML_SetBase", dynlib: expatDll.} -proc GetBase*(parser: PParser): cstring{.cdecl, importc: "XML_GetBase", - dynlib: expatDll.} -# Returns the number of the attribute/value pairs passed in last call -# to the XML_StartElementHandler 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 -# XML_StartElementHandler. -# - -proc GetSpecifiedAttributeCount*(parser: PParser): cint{.cdecl, - importc: "XML_GetSpecifiedAttributeCount", dynlib: expatDll.} -# Returns the index of the ID attribute passed in the last call to -# XML_StartElementHandler, 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 XML_StartElementHandler. -# - -proc GetIdAttributeIndex*(parser: PParser): cint{.cdecl, - importc: "XML_GetIdAttributeIndex", dynlib: expatDll.} -# Parses some input. Returns XML_STATUS_ERROR if a fatal error is -# detected. The last call to XML_Parse must have isFinal true; len -# may be zero for this call (or any other). -# -# Though the return values for these functions has always been -# described as a Boolean value, the implementation, at least for the -# 1.95.x series, has always returned exactly one of the XML_Status -# values. -# - -proc Parse*(parser: PParser, s: cstring, len: cint, isFinal: cint): TStatus{. - cdecl, importc: "XML_Parse", dynlib: expatDll.} -proc GetBuffer*(parser: PParser, len: cint): pointer{.cdecl, - importc: "XML_GetBuffer", dynlib: expatDll.} -proc ParseBuffer*(parser: PParser, len: cint, isFinal: cint): TStatus{.cdecl, - importc: "XML_ParseBuffer", dynlib: expatDll.} -# Stops parsing, causing XML_Parse() or XML_ParseBuffer() to return. -# Must be called from within a call-back handler, except when aborting -# (resumable = 0) an already suspended parser. Some call-backs may -# still follow because they would otherwise get lost. Examples: -# - endElementHandler() for empty elements when stopped in -# startElementHandler(), -# - endNameSpaceDeclHandler() when stopped in endElementHandler(), -# and possibly others. -# -# Can be called from most handlers, including DTD related call-backs, -# except when parsing an external parameter entity and resumable != 0. -# Returns XML_STATUS_OK when successful, XML_STATUS_ERROR otherwise. -# Possible error codes: -# - XML_ERROR_SUSPENDED: when suspending an already suspended parser. -# - XML_ERROR_FINISHED: when the parser has already finished. -# - XML_ERROR_SUSPEND_PE: when suspending while parsing an external PE. -# -# When resumable != 0 (true) then parsing is suspended, that is, -# XML_Parse() and XML_ParseBuffer() return XML_STATUS_SUSPENDED. -# Otherwise, parsing is aborted, that is, XML_Parse() and XML_ParseBuffer() -# return XML_STATUS_ERROR with error code XML_ERROR_ABORTED. -# -# Note*: -# This will be applied to the current parser instance only, that is, if -# there is a parent parser then it will continue parsing when the -# externalEntityRefHandler() returns. It is up to the implementation of -# the externalEntityRefHandler() to call XML_StopParser() on the parent -# parser (recursively), if one wants to stop parsing altogether. -# -# When suspended, parsing can be resumed by calling XML_ResumeParser(). -# - -proc StopParser*(parser: PParser, resumable: Bool): TStatus{.cdecl, - importc: "XML_StopParser", dynlib: expatDll.} -# Resumes parsing after it has been suspended with XML_StopParser(). -# Must not be called from within a handler call-back. Returns same -# status codes as XML_Parse() or XML_ParseBuffer(). -# Additional error code XML_ERROR_NOT_SUSPENDED possible. -# -# Note*: -# This must be called on the most deeply nested child parser instance -# first, and on its parent parser only after the child parser has finished, -# to be applied recursively until the document entity's parser is restarted. -# That is, the parent parser will not resume by itself and it is up to the -# application to call XML_ResumeParser() on it at the appropriate moment. -# - -proc ResumeParser*(parser: PParser): TStatus{.cdecl, - importc: "XML_ResumeParser", dynlib: expatDll.} -type - TParsing* = enum - INITIALIZED, PARSING, FINISHED, SUSPENDED - TParsingStatus*{.pure, final.} = object - parsing*: TParsing - finalBuffer*: Bool - - -# Returns status of parser with respect to being initialized, parsing, -# finished, or suspended and processing the final buffer. -# XXX XML_Parse() and XML_ParseBuffer() should return XML_ParsingStatus, -# XXX with XML_FINISHED_OK or XML_FINISHED_ERROR replacing XML_FINISHED -# - -proc GetParsingStatus*(parser: PParser, status: ptr TParsingStatus){.cdecl, - importc: "XML_GetParsingStatus", dynlib: expatDll.} -# Creates an XML_Parser 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 NULL if out of memory. -# Otherwise returns a new XML_Parser object. -# - -proc ExternalEntityParserCreate*(parser: PParser, context: cstring, - encoding: cstring): PParser{.cdecl, - importc: "XML_ExternalEntityParserCreate", dynlib: expatDll.} -type - TParamEntityParsing* = enum - PARAM_ENTITY_PARSING_NEVER, PARAM_ENTITY_PARSING_UNLESS_STANDALONE, - 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 -# XML_SetExternalEntityRefHandler. 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 -# XML_ExternalEntityParserCreate, XML_Parse/XML_ParseBuffer and -# XML_ParserFree calls must be made during this call. After -# XML_ExternalEntityParserCreate 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 -# XML_ParserFree 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 -# XML_SetParamEntityParsing will return 0 if parsing of parameter -# entities is requested; otherwise it will return non-zero. -# Note: If XML_SetParamEntityParsing is called after XML_Parse or -# XML_ParseBuffer, then it has no effect and will always return 0. -# - -proc SetParamEntityParsing*(parser: PParser, parsing: TParamEntityParsing): cint{. - cdecl, importc: "XML_SetParamEntityParsing", dynlib: expatDll.} -# If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then -# XML_GetErrorCode returns information about the error. -# - -proc GetErrorCode*(parser: PParser): TError{.cdecl, importc: "XML_GetErrorCode", - dynlib: expatDll.} -# These functions return information about the current parse -# location. They may be called from any callback called to report -# some parse event; in this case the location is the location of the -# first of the sequence of characters that generated the event. When -# called from callbacks generated by declarations in the document -# prologue, the location identified isn't as neatly defined, but will -# be within the relevant markup. When called outside of the callback -# functions, the position indicated will be just past the last parse -# event (regardless of whether there was an associated callback). -# -# They may also be called after returning from a call to XML_Parse -# or XML_ParseBuffer. If the return value is XML_STATUS_ERROR then -# the location is the location of the character at which the error -# was detected; otherwise the location is the location of the last -# parse event, as described above. -# - -proc GetCurrentLineNumber*(parser: PParser): int{.cdecl, - importc: "XML_GetCurrentLineNumber", dynlib: expatDll.} -proc GetCurrentColumnNumber*(parser: PParser): int{.cdecl, - importc: "XML_GetCurrentColumnNumber", dynlib: expatDll.} -proc GetCurrentByteIndex*(parser: PParser): int{.cdecl, - importc: "XML_GetCurrentByteIndex", dynlib: expatDll.} -# Return the number of bytes in the current event. -# Returns 0 if the event is in an internal entity. -# - -proc GetCurrentByteCount*(parser: PParser): cint{.cdecl, - importc: "XML_GetCurrentByteCount", dynlib: expatDll.} -# 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. -# - -proc GetInputContext*(parser: PParser, offset: ptr cint, size: ptr cint): cstring{. - cdecl, importc: "XML_GetInputContext", dynlib: expatDll.} -# Frees the content model passed to the element declaration handler - -proc FreeContentModel*(parser: PParser, model: ptr TContent){.cdecl, - importc: "XML_FreeContentModel", dynlib: expatDll.} -# Exposing the memory handling functions used in Expat - -proc MemMalloc*(parser: PParser, size: int): pointer{.cdecl, - importc: "XML_MemMalloc", dynlib: expatDll.} -proc MemRealloc*(parser: PParser, p: pointer, size: int): pointer{.cdecl, - importc: "XML_MemRealloc", dynlib: expatDll.} -proc MemFree*(parser: PParser, p: pointer){.cdecl, importc: "XML_MemFree", - dynlib: expatDll.} -# Frees memory used by the parser. - -proc ParserFree*(parser: PParser){.cdecl, importc: "XML_ParserFree", - dynlib: expatDll.} -# Returns a string describing the error. - -proc ErrorString*(code: TError): cstring{.cdecl, importc: "XML_ErrorString", - dynlib: expatDll.} -# Return a string containing the version number of this expat - -proc ExpatVersion*(): cstring{.cdecl, importc: "XML_ExpatVersion", - dynlib: expatDll.} -type - TExpat_Version*{.pure, final.} = object - major*: cint - minor*: cint - micro*: cint - - -# Return an XML_Expat_Version structure containing numeric version -# number information for this version of expat. -# - -proc ExpatVersionInfo*(): TExpat_Version{.cdecl, - importc: "XML_ExpatVersionInfo", dynlib: expatDll.} -# Added in Expat 1.95.5. - -type - TFeatureEnum* = enum - FEATURE_END = 0, FEATURE_UNICODE, FEATURE_UNICODE_WCHAR_T, FEATURE_DTD, - FEATURE_CONTEXT_BYTES, FEATURE_MIN_SIZE, FEATURE_SIZEOF_XML_CHAR, - FEATURE_SIZEOF_XML_LCHAR, FEATURE_NS, FEATURE_LARGE_SIZE # Additional features must be added to the end of this enum. - TFeature*{.pure, final.} = object - feature*: TFeatureEnum - name*: cstring - value*: int - - -proc GetFeatureList*(): ptr TFeature{.cdecl, importc: "XML_GetFeatureList", - dynlib: expatDll.} -# Expat follows the GNU/Linux convention of odd number minor version for -# beta/development releases and even number minor version for stable -# releases. Micro is bumped with each release, and set to 0 with each -# change to major or minor version. -# - -const - MAJOR_VERSION* = 2 - MINOR_VERSION* = 0 - MICRO_VERSION* = 1 |