PParser* = ptr TParserStruct

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

TContent* {.pure, final.} = object 
  typ*: TContent_Type
  quant*: TContent_Quant
  name*: cstring
  numchildren*: cint
  children*: ptr TContent

TElementDeclHandler* = proc (userData: pointer; name: cstring; 
                             model: ptr TContent) {.cdecl.}

TAttlistDeclHandler* = proc (userData: pointer; elname: cstring; 
                             attname: cstring; att_type: cstring; dflt: cstring; 
                             isrequired: cint) {.cdecl.}

TXmlDeclHandler* = proc (userData: pointer; version: cstring; encoding: cstring; 
                         standalone: cint) {.cdecl.}

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.}

TStartElementHandler* = proc (userData: pointer; name: cstring; 
                              atts: cstringArray) {.cdecl.}

TEndElementHandler* = proc (userData: pointer; name: cstring) {.cdecl.}

TCharacterDataHandler* = proc (userData: pointer; s: cstring; len: cint) {.cdecl.}

TProcessingInstructionHandler* = proc (userData: pointer; target: cstring; 
                                       data: cstring) {.cdecl.}

TCommentHandler* = proc (userData: pointer; data: cstring) {.cdecl.}

TStartCdataSectionHandler* = proc (userData: pointer) {.cdecl.}

TEndCdataSectionHandler* = proc (userData: pointer) {.cdecl.}

TDefaultHandler* = proc (userData: pointer; s: cstring; len: cint) {.cdecl.}

TStartDoctypeDeclHandler* = proc (userData: pointer; doctypeName: cstring; 
                                  sysid: cstring; pubid: cstring; 
                                  has_internal_subset: cint) {.cdecl.}

TEndDoctypeDeclHandler* = proc (userData: pointer) {.cdecl.}

TEntityDeclHandler* = proc (userData: pointer; entityName: cstring; 
                            is_parameter_entity: cint; value: cstring; 
                            value_length: cint; base: cstring; 
                            systemId: cstring; publicId: cstring; 
                            notationName: cstring) {.cdecl.}

TUnparsedEntityDeclHandler* = proc (userData: pointer; entityName: cstring; 
                                    base: cstring; systemId: cstring; 
                                    publicId, notationName: cstring) {.cdecl.}

TNotationDeclHandler* = proc (userData: pointer; notationName: cstring; 
                              base: cstring; systemId: cstring; 
                              publicId: cstring) {.cdecl.}

TStartNamespaceDeclHandler* = proc (userData: pointer; prefix: cstring; 
                                    uri: cstring) {.cdecl.}

TEndNamespaceDeclHandler* = proc (userData: pointer; prefix: cstring) {.cdecl.}

TNotStandaloneHandler* = proc (userData: pointer): cint {.cdecl.}

TExternalEntityRefHandler* = proc (parser: PParser; context: cstring; 
                                   base: cstring; systemId: cstring; 
                                   publicId: cstring): cint {.cdecl.}

TSkippedEntityHandler* = proc (userData: pointer; entityName: cstring; 
                               is_parameter_entity: cint) {.cdecl.}

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.}

TUnknownEncodingHandler* = proc (encodingHandlerData: pointer; name: cstring; 
                                 info: ptr TEncoding): cint {.cdecl.}

TParsing* = enum 
  INITIALIZED, PARSING, FINISHED, SUSPENDED

TParsingStatus* {.pure, final.} = object 
  parsing*: TParsing
  finalBuffer*: Bool

TParamEntityParsing* = enum 
  PARAM_ENTITY_PARSING_NEVER, PARAM_ENTITY_PARSING_UNLESS_STANDALONE, 
  PARAM_ENTITY_PARSING_ALWAYS

TExpat_Version* {.pure, final.} = object 
  major*: cint
  minor*: cint
  micro*: cint

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

TFeature* {.pure, final.} = object 
  feature*: TFeatureEnum
  name*: cstring
  value*: int

MAJOR_VERSION* = 2

MINOR_VERSION* = 0

MICRO_VERSION* = 1

proc SetElementDeclHandler*(parser: PParser; eldecl: TElementDeclHandler) {.
    cdecl, importc: "XML_SetElementDeclHandler", dynlib: expatDll.}

proc SetAttlistDeclHandler*(parser: PParser; attdecl: TAttlistDeclHandler) {.
    cdecl, importc: "XML_SetAttlistDeclHandler", dynlib: expatDll.}

proc SetXmlDeclHandler*(parser: PParser; xmldecl: TXmlDeclHandler) {.cdecl, 
    importc: "XML_SetXmlDeclHandler", dynlib: expatDll.}

proc ParserCreate*(encoding: cstring): PParser {.cdecl, 
    importc: "XML_ParserCreate", dynlib: expatDll.}

proc ParserCreateNS*(encoding: cstring; namespaceSeparator: char): PParser {.
    cdecl, importc: "XML_ParserCreateNS", dynlib: expatDll.}

proc ParserCreate_MM*(encoding: cstring; memsuite: ptr TMemory_Handling_Suite; 
                      namespaceSeparator: cstring): PParser {.cdecl, 
    importc: "XML_ParserCreate_MM", dynlib: expatDll.}

proc ParserReset*(parser: PParser; encoding: cstring): Bool {.cdecl, 
    importc: "XML_ParserReset", dynlib: expatDll.}

proc SetEntityDeclHandler*(parser: PParser; handler: TEntityDeclHandler) {.
    cdecl, importc: "XML_SetEntityDeclHandler", dynlib: expatDll.}

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.}

proc SetDefaultHandler*(parser: PParser; handler: TDefaultHandler) {.cdecl, 
    importc: "XML_SetDefaultHandler", dynlib: expatDll.}

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.}

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.}

proc DefaultCurrent*(parser: PParser) {.cdecl, importc: "XML_DefaultCurrent", 
                                        dynlib: expatDll.}

proc SetReturnNSTriplet*(parser: PParser; do_nst: cint) {.cdecl, 
    importc: "XML_SetReturnNSTriplet", dynlib: expatDll.}

proc SetUserData*(parser: PParser; userData: pointer) {.cdecl, 
    importc: "XML_SetUserData", dynlib: expatDll.}

proc SetEncoding*(parser: PParser; encoding: cstring): TStatus {.cdecl, 
    importc: "XML_SetEncoding", dynlib: expatDll.}

proc UseParserAsHandlerArg*(parser: PParser) {.cdecl, 
    importc: "XML_UseParserAsHandlerArg", dynlib: expatDll.}

proc UseForeignDTD*(parser: PParser; useDTD: Bool): TError {.cdecl, 
    importc: "XML_UseForeignDTD", dynlib: expatDll.}

proc SetBase*(parser: PParser; base: cstring): TStatus {.cdecl, 
    importc: "XML_SetBase", dynlib: expatDll.}

proc GetBase*(parser: PParser): cstring {.cdecl, importc: "XML_GetBase", 
    dynlib: expatDll.}

proc GetSpecifiedAttributeCount*(parser: PParser): cint {.cdecl, 
    importc: "XML_GetSpecifiedAttributeCount", dynlib: expatDll.}

proc GetIdAttributeIndex*(parser: PParser): cint {.cdecl, 
    importc: "XML_GetIdAttributeIndex", dynlib: expatDll.}

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.}

proc StopParser*(parser: PParser; resumable: Bool): TStatus {.cdecl, 
    importc: "XML_StopParser", dynlib: expatDll.}

proc ResumeParser*(parser: PParser): TStatus {.cdecl, 
    importc: "XML_ResumeParser", dynlib: expatDll.}

proc GetParsingStatus*(parser: PParser; status: ptr TParsingStatus) {.cdecl, 
    importc: "XML_GetParsingStatus", dynlib: expatDll.}

proc ExternalEntityParserCreate*(parser: PParser; context: cstring; 
                                 encoding: cstring): PParser {.cdecl, 
    importc: "XML_ExternalEntityParserCreate", dynlib: expatDll.}

proc SetParamEntityParsing*(parser: PParser; parsing: TParamEntityParsing): cint {.
    cdecl, importc: "XML_SetParamEntityParsing", dynlib: expatDll.}

proc GetErrorCode*(parser: PParser): TError {.cdecl, 
    importc: "XML_GetErrorCode", dynlib: expatDll.}

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.}

proc GetCurrentByteCount*(parser: PParser): cint {.cdecl, 
    importc: "XML_GetCurrentByteCount", dynlib: expatDll.}

proc GetInputContext*(parser: PParser; offset: ptr cint; size: ptr cint): cstring {.
    cdecl, importc: "XML_GetInputContext", dynlib: expatDll.}

proc FreeContentModel*(parser: PParser; model: ptr TContent) {.cdecl, 
    importc: "XML_FreeContentModel", dynlib: expatDll.}

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.}

proc ParserFree*(parser: PParser) {.cdecl, importc: "XML_ParserFree", 
                                    dynlib: expatDll.}

proc ErrorString*(code: TError): cstring {.cdecl, importc: "XML_ErrorString", 
    dynlib: expatDll.}

proc ExpatVersion*(): cstring {.cdecl, importc: "XML_ExpatVersion", 
                                dynlib: expatDll.}

proc ExpatVersionInfo*(): TExpat_Version {.cdecl, 
    importc: "XML_ExpatVersionInfo", dynlib: expatDll.}

proc GetFeatureList*(): ptr TFeature {.cdecl, importc: "XML_GetFeatureList", 
                                       dynlib: expatDll.}

template GetUserData*(parser: expr): expr