jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

lib/wrappers/c-r - Dropped 'T' from types

Browse source
This commit is contained in:
pdw 2015-05-24 22:43:13 -05:00 • committed by Araq
commit b2bc5440aa
14 changed files with 1458 additions and 1309 deletions
Download patch file Download diff file Expand all files Collapse all files

812
lib/wrappers/claro.nim
View file

File diff suppressed because it is too large Load diff

218
lib/wrappers/expat.nim
View file

@ -13,9 +13,9 @@ when not defined(expatDll):
const const
expatDll = "libexpat.so(.1|)" expatDll = "libexpat.so(.1|)"
type type
TParserStruct{.pure, final.} = object ParserStruct{.pure, final.} = object
PParser* = ptr TParserStruct PParser* = ptr ParserStruct
# The XML_Status enum gives the possible return values for several # The XML_Status enum gives the possible return values for several
# API functions. The preprocessor #defines are included so this # API functions. The preprocessor #defines are included so this
@ -30,11 +30,12 @@ type
# Otherwise, the #define hackery is quite ugly and would have been # Otherwise, the #define hackery is quite ugly and would have been
# dropped. # dropped.
# #
{.deprecated: [TParserStruct: ParserStruct].}
type type
TStatus*{.size: sizeof(cint).} = enum Status*{.size: sizeof(cint).} = enum
STATUS_ERROR = 0, STATUS_OK = 1, STATUS_SUSPENDED = 2 STATUS_ERROR = 0, STATUS_OK = 1, STATUS_SUSPENDED = 2
TError*{.size: sizeof(cint).} = enum Error*{.size: sizeof(cint).} = enum
ERROR_NONE, ERROR_NO_MEMORY, ERROR_SYNTAX, ERROR_NO_ELEMENTS, ERROR_NONE, ERROR_NO_MEMORY, ERROR_SYNTAX, ERROR_NO_ELEMENTS,
ERROR_INVALID_TOKEN, ERROR_UNCLOSED_TOKEN, ERROR_PARTIAL_CHAR, ERROR_INVALID_TOKEN, ERROR_UNCLOSED_TOKEN, ERROR_PARTIAL_CHAR,
ERROR_TAG_MISMATCH, ERROR_DUPLICATE_ATTRIBUTE, ERROR_TAG_MISMATCH, ERROR_DUPLICATE_ATTRIBUTE,
@ -52,10 +53,12 @@ type
ERROR_ABORTED, ERROR_FINISHED, ERROR_SUSPEND_PE, ERROR_ABORTED, ERROR_FINISHED, ERROR_SUSPEND_PE,
ERROR_RESERVED_PREFIX_XML, ERROR_RESERVED_PREFIX_XMLNS, ERROR_RESERVED_PREFIX_XML, ERROR_RESERVED_PREFIX_XMLNS,
ERROR_RESERVED_NAMESPACE_URI ERROR_RESERVED_NAMESPACE_URI
TContent_Type*{.size: sizeof(cint).} = enum ContentType*{.size: sizeof(cint).} = enum
CTYPE_EMPTY = 1, CTYPE_ANY, CTYPE_MIXED, CTYPE_NAME, CTYPE_CHOICE, CTYPE_SEQ CTYPE_EMPTY = 1, CTYPE_ANY, CTYPE_MIXED, CTYPE_NAME, CTYPE_CHOICE, CTYPE_SEQ
TContent_Quant*{.size: sizeof(cint).} = enum ContentQuant*{.size: sizeof(cint).} = enum
CQUANT_NONE, CQUANT_OPT, CQUANT_REP, CQUANT_PLUS CQUANT_NONE, CQUANT_OPT, CQUANT_REP, CQUANT_PLUS
{.deprecated: [TStatus: Status, TError: Error, TContent_Type: ContentType,
TContent_Quant: ContentQuant].}
# If type == XML_CTYPE_EMPTY or XML_CTYPE_ANY, then quant will be # 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. # XML_CQUANT_NONE, and the other fields will be zero or NULL.
@ -76,13 +79,13 @@ type
# #
type type
TContent*{.pure, final.} = object Content*{.pure, final.} = object
typ*: TContentType typ*: ContentType
quant*: TContentQuant quant*: ContentQuant
name*: cstring name*: cstring
numchildren*: cint numchildren*: cint
children*: ptr TContent children*: ptr Content
{.deprecated: [TContent: Content].}
# This is called for an element declaration. See above for # This is called for an element declaration. See above for
# description of the model argument. It's the caller's responsibility # description of the model argument. It's the caller's responsibility
@ -90,10 +93,11 @@ type
# #
type type
TElementDeclHandler* = proc (userData: pointer, name: cstring, ElementDeclHandler* = proc (userData: pointer, name: cstring,
model: ptr TContent){.cdecl.} model: ptr Content){.cdecl.}
{.deprecated: [TElementDeclHandler: ElementDeclHandler].}
proc setElementDeclHandler*(parser: PParser, eldecl: TElementDeclHandler){. proc setElementDeclHandler*(parser: PParser, eldecl: ElementDeclHandler){.
cdecl, importc: "XML_SetElementDeclHandler", dynlib: expatDll.} cdecl, importc: "XML_SetElementDeclHandler", dynlib: expatDll.}
# The Attlist declaration handler is called for *each* attribute. So # The Attlist declaration handler is called for *each* attribute. So
# a single Attlist declaration with multiple attributes declared will # a single Attlist declaration with multiple attributes declared will
@ -105,11 +109,12 @@ proc setElementDeclHandler*(parser: PParser, eldecl: TElementDeclHandler){.
# #
type type
TAttlistDeclHandler* = proc (userData: pointer, elname: cstring, AttlistDeclHandler* = proc (userData: pointer, elname: cstring,
attname: cstring, attType: cstring, attname: cstring, attType: cstring,
dflt: cstring, isrequired: cint){.cdecl.} dflt: cstring, isrequired: cint){.cdecl.}
{.deprecated: [TAttlistDeclHandler: AttlistDeclHandler].}
proc setAttlistDeclHandler*(parser: PParser, attdecl: TAttlistDeclHandler){. proc setAttlistDeclHandler*(parser: PParser, attdecl: AttlistDeclHandler){.
cdecl, importc: "XML_SetAttlistDeclHandler", dynlib: expatDll.} cdecl, importc: "XML_SetAttlistDeclHandler", dynlib: expatDll.}
# The XML declaration handler is called for *both* XML declarations # The XML declaration handler is called for *both* XML declarations
# and text declarations. The way to distinguish is that the version # and text declarations. The way to distinguish is that the version
@ -121,17 +126,18 @@ proc setAttlistDeclHandler*(parser: PParser, attdecl: TAttlistDeclHandler){.
# #
type type
TXmlDeclHandler* = proc (userData: pointer, version: cstring, XmlDeclHandler* = proc (userData: pointer, version: cstring,
encoding: cstring, standalone: cint){.cdecl.} encoding: cstring, standalone: cint){.cdecl.}
{.deprecated: [TXmlDeclHandler: XmlDeclHandler].}
proc setXmlDeclHandler*(parser: PParser, xmldecl: TXmlDeclHandler){.cdecl, proc setXmlDeclHandler*(parser: PParser, xmldecl: XmlDeclHandler){.cdecl,
importc: "XML_SetXmlDeclHandler", dynlib: expatDll.} importc: "XML_SetXmlDeclHandler", dynlib: expatDll.}
type type
TMemory_Handling_Suite*{.pure, final.} = object Memory_Handling_Suite*{.pure, final.} = object
mallocFcn*: proc (size: int): pointer{.cdecl.} mallocFcn*: proc (size: int): pointer{.cdecl.}
reallocFcn*: proc (p: pointer, size: int): pointer{.cdecl.} reallocFcn*: proc (p: pointer, size: int): pointer{.cdecl.}
freeFcn*: proc (p: pointer){.cdecl.} freeFcn*: proc (p: pointer){.cdecl.}
{.deprecated: [TMemory_Handling_Suite: MemoryHandlingSuite].}
# Constructs a new parser; encoding is the encoding specified by the # Constructs a new parser; encoding is the encoding specified by the
# external protocol or NULL if there is none specified. # external protocol or NULL if there is none specified.
@ -183,29 +189,33 @@ proc parserReset*(parser: PParser, encoding: cstring): bool{.cdecl,
# #
type type
TStartElementHandler* = proc (userData: pointer, name: cstring, StartElementHandler* = proc (userData: pointer, name: cstring,
atts: cstringArray){.cdecl.} atts: cstringArray){.cdecl.}
TEndElementHandler* = proc (userData: pointer, name: cstring){.cdecl.} EndElementHandler* = proc (userData: pointer, name: cstring){.cdecl.}
{.deprecated: [TStartElementHandler: StartElementHandler,
TEndElementHandler: EndElementHandler].}
# s is not 0 terminated. # s is not 0 terminated.
type type
TCharacterDataHandler* = proc (userData: pointer, s: cstring, len: cint){. CharacterDataHandler* = proc (userData: pointer, s: cstring, len: cint){.
cdecl.} cdecl.}
{.deprecated: [TCharacterDataHandler: CharacterDataHandler].}
# target and data are 0 terminated # target and data are 0 terminated
type type
TProcessingInstructionHandler* = proc (userData: pointer, target: cstring, ProcessingInstructionHandler* = proc (userData: pointer, target: cstring,
data: cstring){.cdecl.} data: cstring){.cdecl.}
{.deprecated: [TProcessingInstructionHandler: ProcessingInstructionHandler].}
# data is 0 terminated # data is 0 terminated
type type
TCommentHandler* = proc (userData: pointer, data: cstring){.cdecl.} CommentHandler* = proc (userData: pointer, data: cstring){.cdecl.}
TStartCdataSectionHandler* = proc (userData: pointer){.cdecl.} StartCdataSectionHandler* = proc (userData: pointer){.cdecl.}
TEndCdataSectionHandler* = proc (userData: pointer){.cdecl.} EndCdataSectionHandler* = proc (userData: pointer){.cdecl.}
{.deprecated: [TCommentHandler: CommentHandler,
TStartCdataSectionHandler: StartCdataSectionHandler,
TEndCdataSectionHandler: EndCdataSectionHandler].}
# This is called for any characters in the XML document for which # This is called for any characters in the XML document for which
# there is no applicable handler. This includes both characters that # there is no applicable handler. This includes both characters that
# are part of markup which is of a kind that is not reported # are part of markup which is of a kind that is not reported
@ -221,16 +231,17 @@ type
# #
type type
TDefaultHandler* = proc (userData: pointer, s: cstring, len: cint){.cdecl.} DefaultHandler* = proc (userData: pointer, s: cstring, len: cint){.cdecl.}
{.deprecated: [TDefaultHandler: DefaultHandler].}
# This is called for the start of the DOCTYPE declaration, before # This is called for the start of the DOCTYPE declaration, before
# any DTD or internal subset is parsed. # any DTD or internal subset is parsed.
# #
type type
TStartDoctypeDeclHandler* = proc (userData: pointer, doctypeName: cstring, StartDoctypeDeclHandler* = proc (userData: pointer, doctypeName: cstring,
sysid: cstring, pubid: cstring, sysid: cstring, pubid: cstring,
hasInternalSubset: cint){.cdecl.} hasInternalSubset: cint){.cdecl.}
{.deprecated: [TStartDoctypeDeclHandler: StartDoctypeDeclHandler].}
# This is called for the start of the DOCTYPE declaration when the # This is called for the start of the DOCTYPE declaration when the
# closing > is encountered, but after processing any external # closing > is encountered, but after processing any external
@ -238,7 +249,8 @@ type
# #
type type
TEndDoctypeDeclHandler* = proc (userData: pointer){.cdecl.} EndDoctypeDeclHandler* = proc (userData: pointer){.cdecl.}
{.deprecated: [TEndDoctypeDeclHandler: EndDoctypeDeclHandler].}
# This is called for entity declarations. The is_parameter_entity # This is called for entity declarations. The is_parameter_entity
# argument will be non-zero if the entity is a parameter entity, zero # argument will be non-zero if the entity is a parameter entity, zero
@ -260,13 +272,14 @@ type
# #
type type
TEntityDeclHandler* = proc (userData: pointer, entityName: cstring, EntityDeclHandler* = proc (userData: pointer, entityName: cstring,
isParameterEntity: cint, value: cstring, isParameterEntity: cint, value: cstring,
valueLength: cint, base: cstring, valueLength: cint, base: cstring,
systemId: cstring, publicId: cstring, systemId: cstring, publicId: cstring,
notationName: cstring){.cdecl.} notationName: cstring){.cdecl.}
{.deprecated: [TEntityDeclHandler: EntityDeclHandler].}
proc setEntityDeclHandler*(parser: PParser, handler: TEntityDeclHandler){.cdecl, proc setEntityDeclHandler*(parser: PParser, handler: EntityDeclHandler){.cdecl,
importc: "XML_SetEntityDeclHandler", dynlib: expatDll.} importc: "XML_SetEntityDeclHandler", dynlib: expatDll.}
# OBSOLETE -- OBSOLETE -- OBSOLETE # OBSOLETE -- OBSOLETE -- OBSOLETE
# This handler has been superceded by the EntityDeclHandler above. # This handler has been superceded by the EntityDeclHandler above.
@ -279,10 +292,11 @@ proc setEntityDeclHandler*(parser: PParser, handler: TEntityDeclHandler){.cdecl,
# #
type type
TUnparsedEntityDeclHandler* = proc (userData: pointer, entityName: cstring, UnparsedEntityDeclHandler* = proc (userData: pointer, entityName: cstring,
base: cstring, systemId: cstring, base: cstring, systemId: cstring,
publicId, notationName: cstring){. publicId, notationName: cstring){.
cdecl.} cdecl.}
{.deprecated: [TUnparsedEntityDeclHandler: UnparsedEntityDeclHandler].}
# This is called for a declaration of notation. The base argument is # This is called for a declaration of notation. The base argument is
# whatever was set by XML_SetBase. The notationName will never be # whatever was set by XML_SetBase. The notationName will never be
@ -290,9 +304,10 @@ type
# #
type type
TNotationDeclHandler* = proc (userData: pointer, notationName: cstring, NotationDeclHandler* = proc (userData: pointer, notationName: cstring,
base: cstring, systemId: cstring, base: cstring, systemId: cstring,
publicId: cstring){.cdecl.} publicId: cstring){.cdecl.}
{.deprecated: [TNotationDeclHandler: NotationDeclHandler].}
# When namespace processing is enabled, these are called once for # When namespace processing is enabled, these are called once for
# each namespace declaration. The call to the start and end element # each namespace declaration. The call to the start and end element
@ -302,10 +317,11 @@ type
# #
type type
TStartNamespaceDeclHandler* = proc (userData: pointer, prefix: cstring, StartNamespaceDeclHandler* = proc (userData: pointer, prefix: cstring,
uri: cstring){.cdecl.} uri: cstring){.cdecl.}
TEndNamespaceDeclHandler* = proc (userData: pointer, prefix: cstring){.cdecl.} EndNamespaceDeclHandler* = proc (userData: pointer, prefix: cstring){.cdecl.}
{.deprecated: [TStartNamespaceDeclHandler: StartNamespaceDeclHandler,
TEndNamespaceDeclHandler: EndNamespaceDeclHandler].}
# This is called if the document is not standalone, that is, it has an # 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 # external subset or a reference to a parameter entity, but does not
# have standalone="yes". If this handler returns XML_STATUS_ERROR, # have standalone="yes". If this handler returns XML_STATUS_ERROR,
@ -317,7 +333,8 @@ type
# #
type type
TNotStandaloneHandler* = proc (userData: pointer): cint{.cdecl.} NotStandaloneHandler* = proc (userData: pointer): cint{.cdecl.}
{.deprecated: [TNotStandaloneHandler: NotStandaloneHandler].}
# This is called for a reference to an external parsed general # This is called for a reference to an external parsed general
# entity. The referenced entity is not automatically parsed. The # entity. The referenced entity is not automatically parsed. The
@ -355,10 +372,10 @@ type
# #
type type
TExternalEntityRefHandler* = proc (parser: PParser, context: cstring, ExternalEntityRefHandler* = proc (parser: PParser, context: cstring,
base: cstring, systemId: cstring, base: cstring, systemId: cstring,
publicId: cstring): cint{.cdecl.} publicId: cstring): cint{.cdecl.}
{.deprecated: [TExternalEntityRefHandler: ExternalEntityRefHandler].}
# This is called in two situations: # This is called in two situations:
# 1) An entity reference is encountered for which no declaration # 1) An entity reference is encountered for which no declaration
# has been read *and* this is not an error. # has been read *and* this is not an error.
@ -371,8 +388,9 @@ type
# #
type type
TSkippedEntityHandler* = proc (userData: pointer, entityName: cstring, SkippedEntityHandler* = proc (userData: pointer, entityName: cstring,
isParameterEntity: cint){.cdecl.} isParameterEntity: cint){.cdecl.}
{.deprecated: [TSkippedEntityHandler: SkippedEntityHandler].}
# This structure is filled in by the XML_UnknownEncodingHandler to # This structure is filled in by the XML_UnknownEncodingHandler to
# provide information to the parser about encodings that are unknown # provide information to the parser about encodings that are unknown
@ -428,11 +446,12 @@ type
# #
type type
TEncoding*{.pure, final.} = object Encoding*{.pure, final.} = object
map*: array[0..256 - 1, cint] map*: array[0..256 - 1, cint]
data*: pointer data*: pointer
convert*: proc (data: pointer, s: cstring): cint{.cdecl.} convert*: proc (data: pointer, s: cstring): cint{.cdecl.}
release*: proc (data: pointer){.cdecl.} release*: proc (data: pointer){.cdecl.}
{.deprecated: [TEncoding: Encoding].}
# This is called for an encoding that is unknown to the parser. # This is called for an encoding that is unknown to the parser.
@ -452,74 +471,75 @@ type
# #
type type
TUnknownEncodingHandler* = proc (encodingHandlerData: pointer, name: cstring, UnknownEncodingHandler* = proc (encodingHandlerData: pointer, name: cstring,
info: ptr TEncoding): cint{.cdecl.} info: ptr Encoding): cint{.cdecl.}
{.deprecated: [TUnknownEncodingHandler: UnknownEncodingHandler].}
proc setElementHandler*(parser: PParser, start: TStartElementHandler, proc setElementHandler*(parser: PParser, start: StartElementHandler,
endHandler: TEndElementHandler){.cdecl, endHandler: EndElementHandler){.cdecl,
importc: "XML_SetElementHandler", dynlib: expatDll.} importc: "XML_SetElementHandler", dynlib: expatDll.}
proc setStartElementHandler*(parser: PParser, handler: TStartElementHandler){. proc setStartElementHandler*(parser: PParser, handler: StartElementHandler){.
cdecl, importc: "XML_SetStartElementHandler", dynlib: expatDll.} cdecl, importc: "XML_SetStartElementHandler", dynlib: expatDll.}
proc setEndElementHandler*(parser: PParser, handler: TEndElementHandler){.cdecl, proc setEndElementHandler*(parser: PParser, handler: EndElementHandler){.cdecl,
importc: "XML_SetEndElementHandler", dynlib: expatDll.} importc: "XML_SetEndElementHandler", dynlib: expatDll.}
proc setCharacterDataHandler*(parser: PParser, handler: TCharacterDataHandler){. proc setCharacterDataHandler*(parser: PParser, handler: CharacterDataHandler){.
cdecl, importc: "XML_SetCharacterDataHandler", dynlib: expatDll.} cdecl, importc: "XML_SetCharacterDataHandler", dynlib: expatDll.}
proc setProcessingInstructionHandler*(parser: PParser, proc setProcessingInstructionHandler*(parser: PParser,
handler: TProcessingInstructionHandler){. handler: ProcessingInstructionHandler){.
cdecl, importc: "XML_SetProcessingInstructionHandler", dynlib: expatDll.} cdecl, importc: "XML_SetProcessingInstructionHandler", dynlib: expatDll.}
proc setCommentHandler*(parser: PParser, handler: TCommentHandler){.cdecl, proc setCommentHandler*(parser: PParser, handler: CommentHandler){.cdecl,
importc: "XML_SetCommentHandler", dynlib: expatDll.} importc: "XML_SetCommentHandler", dynlib: expatDll.}
proc setCdataSectionHandler*(parser: PParser, start: TStartCdataSectionHandler, proc setCdataSectionHandler*(parser: PParser, start: StartCdataSectionHandler,
endHandler: TEndCdataSectionHandler){.cdecl, endHandler: EndCdataSectionHandler){.cdecl,
importc: "XML_SetCdataSectionHandler", dynlib: expatDll.} importc: "XML_SetCdataSectionHandler", dynlib: expatDll.}
proc setStartCdataSectionHandler*(parser: PParser, proc setStartCdataSectionHandler*(parser: PParser,
start: TStartCdataSectionHandler){.cdecl, start: StartCdataSectionHandler){.cdecl,
importc: "XML_SetStartCdataSectionHandler", dynlib: expatDll.} importc: "XML_SetStartCdataSectionHandler", dynlib: expatDll.}
proc setEndCdataSectionHandler*(parser: PParser, proc setEndCdataSectionHandler*(parser: PParser,
endHandler: TEndCdataSectionHandler){.cdecl, endHandler: EndCdataSectionHandler){.cdecl,
importc: "XML_SetEndCdataSectionHandler", dynlib: expatDll.} importc: "XML_SetEndCdataSectionHandler", dynlib: expatDll.}
# This sets the default handler and also inhibits expansion of # This sets the default handler and also inhibits expansion of
# internal entities. These entity references will be passed to the # internal entities. These entity references will be passed to the
# default handler, or to the skipped entity handler, if one is set. # default handler, or to the skipped entity handler, if one is set.
# #
proc setDefaultHandler*(parser: PParser, handler: TDefaultHandler){.cdecl, proc setDefaultHandler*(parser: PParser, handler: DefaultHandler){.cdecl,
importc: "XML_SetDefaultHandler", dynlib: expatDll.} importc: "XML_SetDefaultHandler", dynlib: expatDll.}
# This sets the default handler but does not inhibit expansion of # This sets the default handler but does not inhibit expansion of
# internal entities. The entity reference will not be passed to the # internal entities. The entity reference will not be passed to the
# default handler. # default handler.
# #
proc setDefaultHandlerExpand*(parser: PParser, handler: TDefaultHandler){.cdecl, proc setDefaultHandlerExpand*(parser: PParser, handler: DefaultHandler){.cdecl,
importc: "XML_SetDefaultHandlerExpand", dynlib: expatDll.} importc: "XML_SetDefaultHandlerExpand", dynlib: expatDll.}
proc setDoctypeDeclHandler*(parser: PParser, start: TStartDoctypeDeclHandler, proc setDoctypeDeclHandler*(parser: PParser, start: StartDoctypeDeclHandler,
endHandler: TEndDoctypeDeclHandler){.cdecl, endHandler: EndDoctypeDeclHandler){.cdecl,
importc: "XML_SetDoctypeDeclHandler", dynlib: expatDll.} importc: "XML_SetDoctypeDeclHandler", dynlib: expatDll.}
proc setStartDoctypeDeclHandler*(parser: PParser, proc setStartDoctypeDeclHandler*(parser: PParser,
start: TStartDoctypeDeclHandler){.cdecl, start: StartDoctypeDeclHandler){.cdecl,
importc: "XML_SetStartDoctypeDeclHandler", dynlib: expatDll.} importc: "XML_SetStartDoctypeDeclHandler", dynlib: expatDll.}
proc setEndDoctypeDeclHandler*(parser: PParser, proc setEndDoctypeDeclHandler*(parser: PParser,
endHandler: TEndDoctypeDeclHandler){.cdecl, endHandler: EndDoctypeDeclHandler){.cdecl,
importc: "XML_SetEndDoctypeDeclHandler", dynlib: expatDll.} importc: "XML_SetEndDoctypeDeclHandler", dynlib: expatDll.}
proc setUnparsedEntityDeclHandler*(parser: PParser, proc setUnparsedEntityDeclHandler*(parser: PParser,
handler: TUnparsedEntityDeclHandler){.cdecl, handler: UnparsedEntityDeclHandler){.cdecl,
importc: "XML_SetUnparsedEntityDeclHandler", dynlib: expatDll.} importc: "XML_SetUnparsedEntityDeclHandler", dynlib: expatDll.}
proc setNotationDeclHandler*(parser: PParser, handler: TNotationDeclHandler){. proc setNotationDeclHandler*(parser: PParser, handler: NotationDeclHandler){.
cdecl, importc: "XML_SetNotationDeclHandler", dynlib: expatDll.} cdecl, importc: "XML_SetNotationDeclHandler", dynlib: expatDll.}
proc setNamespaceDeclHandler*(parser: PParser, proc setNamespaceDeclHandler*(parser: PParser,
start: TStartNamespaceDeclHandler, start: StartNamespaceDeclHandler,
endHandler: TEndNamespaceDeclHandler){.cdecl, endHandler: EndNamespaceDeclHandler){.cdecl,
importc: "XML_SetNamespaceDeclHandler", dynlib: expatDll.} importc: "XML_SetNamespaceDeclHandler", dynlib: expatDll.}
proc setStartNamespaceDeclHandler*(parser: PParser, proc setStartNamespaceDeclHandler*(parser: PParser,
start: TStartNamespaceDeclHandler){.cdecl, start: StartNamespaceDeclHandler){.cdecl,
importc: "XML_SetStartNamespaceDeclHandler", dynlib: expatDll.} importc: "XML_SetStartNamespaceDeclHandler", dynlib: expatDll.}
proc setEndNamespaceDeclHandler*(parser: PParser, proc setEndNamespaceDeclHandler*(parser: PParser,
endHandler: TEndNamespaceDeclHandler){.cdecl, endHandler: EndNamespaceDeclHandler){.cdecl,
importc: "XML_SetEndNamespaceDeclHandler", dynlib: expatDll.} importc: "XML_SetEndNamespaceDeclHandler", dynlib: expatDll.}
proc setNotStandaloneHandler*(parser: PParser, handler: TNotStandaloneHandler){. proc setNotStandaloneHandler*(parser: PParser, handler: NotStandaloneHandler){.
cdecl, importc: "XML_SetNotStandaloneHandler", dynlib: expatDll.} cdecl, importc: "XML_SetNotStandaloneHandler", dynlib: expatDll.}
proc setExternalEntityRefHandler*(parser: PParser, proc setExternalEntityRefHandler*(parser: PParser,
handler: TExternalEntityRefHandler){.cdecl, handler: ExternalEntityRefHandler){.cdecl,
importc: "XML_SetExternalEntityRefHandler", dynlib: expatDll.} importc: "XML_SetExternalEntityRefHandler", dynlib: expatDll.}
# If a non-NULL value for arg is specified here, then it will be # 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 # passed as the first argument to the external entity ref handler
@ -528,10 +548,10 @@ proc setExternalEntityRefHandler*(parser: PParser,
proc setExternalEntityRefHandlerArg*(parser: PParser, arg: pointer){.cdecl, proc setExternalEntityRefHandlerArg*(parser: PParser, arg: pointer){.cdecl,
importc: "XML_SetExternalEntityRefHandlerArg", dynlib: expatDll.} importc: "XML_SetExternalEntityRefHandlerArg", dynlib: expatDll.}
proc setSkippedEntityHandler*(parser: PParser, handler: TSkippedEntityHandler){. proc setSkippedEntityHandler*(parser: PParser, handler: SkippedEntityHandler){.
cdecl, importc: "XML_SetSkippedEntityHandler", dynlib: expatDll.} cdecl, importc: "XML_SetSkippedEntityHandler", dynlib: expatDll.}
proc setUnknownEncodingHandler*(parser: PParser, proc setUnknownEncodingHandler*(parser: PParser,
handler: TUnknownEncodingHandler, handler: UnknownEncodingHandler,
encodingHandlerData: pointer){.cdecl, encodingHandlerData: pointer){.cdecl,
importc: "XML_SetUnknownEncodingHandler", dynlib: expatDll.} importc: "XML_SetUnknownEncodingHandler", dynlib: expatDll.}
# This can be called within a handler for a start element, end # This can be called within a handler for a start element, end
@ -573,7 +593,7 @@ template getUserData*(parser: expr): expr =
# has no effect and returns XML_STATUS_ERROR. # has no effect and returns XML_STATUS_ERROR.
# #
proc setEncoding*(parser: PParser, encoding: cstring): TStatus{.cdecl, proc setEncoding*(parser: PParser, encoding: cstring): Status{.cdecl,
importc: "XML_SetEncoding", dynlib: expatDll.} importc: "XML_SetEncoding", dynlib: expatDll.}
# If this function is called, then the parser will be passed as the # If this function is called, then the parser will be passed as the
# first argument to callbacks instead of userData. The userData will # first argument to callbacks instead of userData. The userData will
@ -601,7 +621,7 @@ proc useParserAsHandlerArg*(parser: PParser){.cdecl,
# XML_ERROR_FEATURE_REQUIRES_XML_DTD. # XML_ERROR_FEATURE_REQUIRES_XML_DTD.
# #
proc useForeignDTD*(parser: PParser, useDTD: bool): TError{.cdecl, proc useForeignDTD*(parser: PParser, useDTD: bool): Error{.cdecl,
importc: "XML_UseForeignDTD", dynlib: expatDll.} importc: "XML_UseForeignDTD", dynlib: expatDll.}
# Sets the base to be used for resolving relative URIs in system # Sets the base to be used for resolving relative URIs in system
# identifiers in declarations. Resolving relative identifiers is # identifiers in declarations. Resolving relative identifiers is
@ -612,7 +632,7 @@ proc useForeignDTD*(parser: PParser, useDTD: bool): TError{.cdecl,
# XML_STATUS_OK otherwise. # XML_STATUS_OK otherwise.
# #
proc setBase*(parser: PParser, base: cstring): TStatus{.cdecl, proc setBase*(parser: PParser, base: cstring): Status{.cdecl,
importc: "XML_SetBase", dynlib: expatDll.} importc: "XML_SetBase", dynlib: expatDll.}
proc getBase*(parser: PParser): cstring{.cdecl, importc: "XML_GetBase", proc getBase*(parser: PParser): cstring{.cdecl, importc: "XML_GetBase",
dynlib: expatDll.} dynlib: expatDll.}
@ -643,11 +663,11 @@ proc getIdAttributeIndex*(parser: PParser): cint{.cdecl,
# values. # values.
# #
proc parse*(parser: PParser, s: cstring, len: cint, isFinal: cint): TStatus{. proc parse*(parser: PParser, s: cstring, len: cint, isFinal: cint): Status{.
cdecl, importc: "XML_Parse", dynlib: expatDll.} cdecl, importc: "XML_Parse", dynlib: expatDll.}
proc getBuffer*(parser: PParser, len: cint): pointer{.cdecl, proc getBuffer*(parser: PParser, len: cint): pointer{.cdecl,
importc: "XML_GetBuffer", dynlib: expatDll.} importc: "XML_GetBuffer", dynlib: expatDll.}
proc parseBuffer*(parser: PParser, len: cint, isFinal: cint): TStatus{.cdecl, proc parseBuffer*(parser: PParser, len: cint, isFinal: cint): Status{.cdecl,
importc: "XML_ParseBuffer", dynlib: expatDll.} importc: "XML_ParseBuffer", dynlib: expatDll.}
# Stops parsing, causing XML_Parse() or XML_ParseBuffer() to return. # Stops parsing, causing XML_Parse() or XML_ParseBuffer() to return.
# Must be called from within a call-back handler, except when aborting # Must be called from within a call-back handler, except when aborting
@ -681,7 +701,7 @@ proc parseBuffer*(parser: PParser, len: cint, isFinal: cint): TStatus{.cdecl,
# When suspended, parsing can be resumed by calling XML_ResumeParser(). # When suspended, parsing can be resumed by calling XML_ResumeParser().
# #
proc stopParser*(parser: PParser, resumable: bool): TStatus{.cdecl, proc stopParser*(parser: PParser, resumable: bool): Status{.cdecl,
importc: "XML_StopParser", dynlib: expatDll.} importc: "XML_StopParser", dynlib: expatDll.}
# Resumes parsing after it has been suspended with XML_StopParser(). # Resumes parsing after it has been suspended with XML_StopParser().
# Must not be called from within a handler call-back. Returns same # Must not be called from within a handler call-back. Returns same
@ -696,15 +716,16 @@ proc stopParser*(parser: PParser, resumable: bool): TStatus{.cdecl,
# application to call XML_ResumeParser() on it at the appropriate moment. # application to call XML_ResumeParser() on it at the appropriate moment.
# #
proc resumeParser*(parser: PParser): TStatus{.cdecl, proc resumeParser*(parser: PParser): Status{.cdecl,
importc: "XML_ResumeParser", dynlib: expatDll.} importc: "XML_ResumeParser", dynlib: expatDll.}
type type
TParsing* = enum TParsing* = enum
INITIALIZED, PARSING, FINISHED, SUSPENDED INITIALIZED, PARSING, FINISHED, SUSPENDED
TParsingStatus*{.pure, final.} = object ParsingStatus*{.pure, final.} = object
parsing*: TParsing parsing*: TParsing
finalBuffer*: bool finalBuffer*: bool
{.deprecated: [#TParsing: Parsing, # Naming conflict if we drop the `T`
TParsingStatus: ParsingStatus].}
# Returns status of parser with respect to being initialized, parsing, # Returns status of parser with respect to being initialized, parsing,
# finished, or suspended and processing the final buffer. # finished, or suspended and processing the final buffer.
@ -712,7 +733,7 @@ type
# XXX with XML_FINISHED_OK or XML_FINISHED_ERROR replacing XML_FINISHED # XXX with XML_FINISHED_OK or XML_FINISHED_ERROR replacing XML_FINISHED
# #
proc getParsingStatus*(parser: PParser, status: ptr TParsingStatus){.cdecl, proc getParsingStatus*(parser: PParser, status: ptr ParsingStatus){.cdecl,
importc: "XML_GetParsingStatus", dynlib: expatDll.} importc: "XML_GetParsingStatus", dynlib: expatDll.}
# Creates an XML_Parser object that can parse an external general # Creates an XML_Parser object that can parse an external general
# entity; context is a '\0'-terminated string specifying the parse # entity; context is a '\0'-terminated string specifying the parse
@ -735,9 +756,10 @@ proc externalEntityParserCreate*(parser: PParser, context: cstring,
encoding: cstring): PParser{.cdecl, encoding: cstring): PParser{.cdecl,
importc: "XML_ExternalEntityParserCreate", dynlib: expatDll.} importc: "XML_ExternalEntityParserCreate", dynlib: expatDll.}
type type
TParamEntityParsing* = enum ParamEntityParsing* = enum
PARAM_ENTITY_PARSING_NEVER, PARAM_ENTITY_PARSING_UNLESS_STANDALONE, PARAM_ENTITY_PARSING_NEVER, PARAM_ENTITY_PARSING_UNLESS_STANDALONE,
PARAM_ENTITY_PARSING_ALWAYS PARAM_ENTITY_PARSING_ALWAYS
{.deprecated: [TParamEntityParsing: ParamEntityParsing].}
# Controls parsing of parameter entities (including the external DTD # Controls parsing of parameter entities (including the external DTD
# subset). If parsing of parameter entities is enabled, then # subset). If parsing of parameter entities is enabled, then
@ -763,13 +785,13 @@ type
# XML_ParseBuffer, then it has no effect and will always return 0. # XML_ParseBuffer, then it has no effect and will always return 0.
# #
proc setParamEntityParsing*(parser: PParser, parsing: TParamEntityParsing): cint{. proc setParamEntityParsing*(parser: PParser, parsing: ParamEntityParsing): cint{.
cdecl, importc: "XML_SetParamEntityParsing", dynlib: expatDll.} cdecl, importc: "XML_SetParamEntityParsing", dynlib: expatDll.}
# If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then # If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then
# XML_GetErrorCode returns information about the error. # XML_GetErrorCode returns information about the error.
# #
proc getErrorCode*(parser: PParser): TError{.cdecl, importc: "XML_GetErrorCode", proc getErrorCode*(parser: PParser): Error{.cdecl, importc: "XML_GetErrorCode",
dynlib: expatDll.} dynlib: expatDll.}
# These functions return information about the current parse # These functions return information about the current parse
# location. They may be called from any callback called to report # location. They may be called from any callback called to report
@ -815,7 +837,7 @@ proc getInputContext*(parser: PParser, offset: ptr cint, size: ptr cint): cstrin
cdecl, importc: "XML_GetInputContext", dynlib: expatDll.} cdecl, importc: "XML_GetInputContext", dynlib: expatDll.}
# Frees the content model passed to the element declaration handler # Frees the content model passed to the element declaration handler
proc freeContentModel*(parser: PParser, model: ptr TContent){.cdecl, proc freeContentModel*(parser: PParser, model: ptr Content){.cdecl,
importc: "XML_FreeContentModel", dynlib: expatDll.} importc: "XML_FreeContentModel", dynlib: expatDll.}
# Exposing the memory handling functions used in Expat # Exposing the memory handling functions used in Expat
@ -831,39 +853,39 @@ proc parserFree*(parser: PParser){.cdecl, importc: "XML_ParserFree",
dynlib: expatDll.} dynlib: expatDll.}
# Returns a string describing the error. # Returns a string describing the error.
proc errorString*(code: TError): cstring{.cdecl, importc: "XML_ErrorString", proc errorString*(code: Error): cstring{.cdecl, importc: "XML_ErrorString",
dynlib: expatDll.} dynlib: expatDll.}
# Return a string containing the version number of this expat # Return a string containing the version number of this expat
proc expatVersion*(): cstring{.cdecl, importc: "XML_ExpatVersion", proc expatVersion*(): cstring{.cdecl, importc: "XML_ExpatVersion",
dynlib: expatDll.} dynlib: expatDll.}
type type
TExpat_Version*{.pure, final.} = object Expat_Version*{.pure, final.} = object
major*: cint major*: cint
minor*: cint minor*: cint
micro*: cint micro*: cint
{.deprecated: [TExpat_Version: ExpatVersion].}
# Return an XML_Expat_Version structure containing numeric version # Return an XML_Expat_Version structure containing numeric version
# number information for this version of expat. # number information for this version of expat.
# #
proc expatVersionInfo*(): TExpatVersion{.cdecl, proc expatVersionInfo*(): ExpatVersion{.cdecl,
importc: "XML_ExpatVersionInfo", dynlib: expatDll.} importc: "XML_ExpatVersionInfo", dynlib: expatDll.}
# Added in Expat 1.95.5. # Added in Expat 1.95.5.
type type
TFeatureEnum* = enum FeatureEnum* = enum
FEATURE_END = 0, FEATURE_UNICODE, FEATURE_UNICODE_WCHAR_T, FEATURE_DTD, FEATURE_END = 0, FEATURE_UNICODE, FEATURE_UNICODE_WCHAR_T, FEATURE_DTD,
FEATURE_CONTEXT_BYTES, FEATURE_MIN_SIZE, FEATURE_SIZEOF_XML_CHAR, 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. 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*{.pure, final.} = object
feature*: TFeatureEnum feature*: FeatureEnum
name*: cstring name*: cstring
value*: int value*: int
{.deprecated: [TFeatureEnum: FeatureEnum, TFeature: Feature].}
proc getFeatureList*(): ptr Feature{.cdecl, importc: "XML_GetFeatureList",
proc getFeatureList*(): ptr TFeature{.cdecl, importc: "XML_GetFeatureList",
dynlib: expatDll.} dynlib: expatDll.}
# Expat follows the GNU/Linux convention of odd number minor version for # Expat follows the GNU/Linux convention of odd number minor version for
# beta/development releases and even number minor version for stable # beta/development releases and even number minor version for stable

33
lib/wrappers/joyent_http_parser.nim
View file

@ -1,20 +1,20 @@
type type
csize = int csize = int
HttpDataProc* = proc (a2: ptr THttpParser, at: cstring, length: csize): cint {.cdecl.} HttpDataProc* = proc (a2: ptr HttpParser, at: cstring, length: csize): cint {.cdecl.}
HttpProc* = proc (a2: ptr THttpParser): cint {.cdecl.} HttpProc* = proc (a2: ptr HttpParser): cint {.cdecl.}
THttpMethod* = enum HttpMethod* = enum
HTTP_DELETE = 0, HTTP_GET, HTTP_HEAD, HTTP_POST, HTTP_PUT, HTTP_CONNECT, HTTP_DELETE = 0, HTTP_GET, HTTP_HEAD, HTTP_POST, HTTP_PUT, HTTP_CONNECT,
HTTP_OPTIONS, HTTP_TRACE, HTTP_COPY, HTTP_LOCK, HTTP_MKCOL, HTTP_MOVE, HTTP_OPTIONS, HTTP_TRACE, HTTP_COPY, HTTP_LOCK, HTTP_MKCOL, HTTP_MOVE,
HTTP_PROPFIND, HTTP_PROPPATCH, HTTP_UNLOCK, HTTP_REPORT, HTTP_MKACTIVITY, HTTP_PROPFIND, HTTP_PROPPATCH, HTTP_UNLOCK, HTTP_REPORT, HTTP_MKACTIVITY,
HTTP_CHECKOUT, HTTP_MERGE, HTTP_MSEARCH, HTTP_NOTIFY, HTTP_SUBSCRIBE, HTTP_CHECKOUT, HTTP_MERGE, HTTP_MSEARCH, HTTP_NOTIFY, HTTP_SUBSCRIBE,
HTTP_UNSUBSCRIBE, HTTP_PATCH HTTP_UNSUBSCRIBE, HTTP_PATCH
THttpParserType* = enum HttpParserType* = enum
HTTP_REQUEST, HTTP_RESPONSE, HTTP_BOTH HTTP_REQUEST, HTTP_RESPONSE, HTTP_BOTH
TParserFlag* = enum ParserFlag* = enum
F_CHUNKED = 1 shl 0, F_CHUNKED = 1 shl 0,
F_CONNECTION_KEEP_ALIVE = 1 shl 1, F_CONNECTION_KEEP_ALIVE = 1 shl 1,
F_CONNECTION_CLOSE = 1 shl 2, F_CONNECTION_CLOSE = 1 shl 2,
@ -22,7 +22,7 @@ type
F_UPGRADE = 1 shl 4, F_UPGRADE = 1 shl 4,
F_SKIPBODY = 1 shl 5 F_SKIPBODY = 1 shl 5
THttpErrNo* = enum HttpErrNo* = enum
HPE_OK, HPE_CB_message_begin, HPE_CB_path, HPE_CB_query_string, HPE_CB_url, HPE_OK, HPE_CB_message_begin, HPE_CB_path, HPE_CB_query_string, HPE_CB_url,
HPE_CB_fragment, HPE_CB_header_field, HPE_CB_header_value, HPE_CB_fragment, HPE_CB_header_field, HPE_CB_header_value,
HPE_CB_headers_complete, HPE_CB_body, HPE_CB_message_complete, HPE_CB_headers_complete, HPE_CB_body, HPE_CB_message_complete,
@ -34,7 +34,7 @@ type
HPE_INVALID_CHUNK_SIZE, HPE_INVALID_CONSTANT, HPE_INVALID_INTERNAL_STATE, HPE_INVALID_CHUNK_SIZE, HPE_INVALID_CONSTANT, HPE_INVALID_INTERNAL_STATE,
HPE_STRICT, HPE_UNKNOWN HPE_STRICT, HPE_UNKNOWN
THttpParser*{.pure, final, importc: "http_parser", header: "http_parser.h".} = object HttpParser*{.pure, final, importc: "http_parser", header: "http_parser.h".} = object
typ {.importc: "type".}: char typ {.importc: "type".}: char
flags {.importc: "flags".}: char flags {.importc: "flags".}: char
state*{.importc: "state".}: char state*{.importc: "state".}: char
@ -50,7 +50,7 @@ type
upgrade {.importc: "upgrade".}: bool upgrade {.importc: "upgrade".}: bool
data*{.importc: "data".}: pointer data*{.importc: "data".}: pointer
THttpParserSettings*{.pure, final, importc: "http_parser_settings", header: "http_parser.h".} = object HttpParserSettings*{.pure, final, importc: "http_parser_settings", header: "http_parser.h".} = object
on_message_begin*{.importc: "on_message_begin".}: HttpProc on_message_begin*{.importc: "on_message_begin".}: HttpProc
on_url*{.importc: "on_url".}: HttpDataProc on_url*{.importc: "on_url".}: HttpDataProc
on_header_field*{.importc: "on_header_field".}: HttpDataProc on_header_field*{.importc: "on_header_field".}: HttpDataProc
@ -58,24 +58,27 @@ type
on_headers_complete*{.importc: "on_headers_complete".}: HttpProc on_headers_complete*{.importc: "on_headers_complete".}: HttpProc
on_body*{.importc: "on_body".}: HttpDataProc on_body*{.importc: "on_body".}: HttpDataProc
on_message_complete*{.importc: "on_message_complete".}: HttpProc on_message_complete*{.importc: "on_message_complete".}: HttpProc
{.deprecated: [THttpMethod: HttpMethod, THttpParserType: HttpParserType,
TParserFlag: ParserFlag, THttpErrNo: HttpErrNo,
THttpParser: HttpParser, THttpParserSettings: HttpParserSettings].}
proc http_parser_init*(parser: var THttpParser, typ: THttpParserType){. proc http_parser_init*(parser: var HttpParser, typ: HttpParserType){.
importc: "http_parser_init", header: "http_parser.h".} importc: "http_parser_init", header: "http_parser.h".}
proc http_parser_execute*(parser: var THttpParser, proc http_parser_execute*(parser: var HttpParser,
settings: var THttpParserSettings, data: cstring, settings: var HttpParserSettings, data: cstring,
len: csize): csize {. len: csize): csize {.
importc: "http_parser_execute", header: "http_parser.h".} importc: "http_parser_execute", header: "http_parser.h".}
proc http_should_keep_alive*(parser: var THttpParser): cint{. proc http_should_keep_alive*(parser: var HttpParser): cint{.
importc: "http_should_keep_alive", header: "http_parser.h".} importc: "http_should_keep_alive", header: "http_parser.h".}
proc http_method_str*(m: THttpMethod): cstring{. proc http_method_str*(m: HttpMethod): cstring{.
importc: "http_method_str", header: "http_parser.h".} importc: "http_method_str", header: "http_parser.h".}
proc http_errno_name*(err: THttpErrNo): cstring{. proc http_errno_name*(err: HttpErrNo): cstring{.
importc: "http_errno_name", header: "http_parser.h".} importc: "http_errno_name", header: "http_parser.h".}
proc http_errno_description*(err: THttpErrNo): cstring{. proc http_errno_description*(err: HttpErrNo): cstring{.
importc: "http_errno_description", header: "http_parser.h".} importc: "http_errno_description", header: "http_parser.h".}

252
lib/wrappers/libcurl.nim
View file

@ -31,47 +31,47 @@ elif defined(unix):
const const
libname = "libcurl.so.4" libname = "libcurl.so.4"
type type
Pcalloc_callback* = ptr Tcalloc_callback Pcalloc_callback* = ptr Calloc_callback
Pclosepolicy* = ptr Tclosepolicy Pclosepolicy* = ptr Closepolicy
Pforms* = ptr Tforms Pforms* = ptr Forms
Pftpauth* = ptr Tftpauth Pftpauth* = ptr Ftpauth
Pftpmethod* = ptr Tftpmethod Pftpmethod* = ptr Ftpmethod
Pftpssl* = ptr Tftpssl Pftpssl* = ptr Ftpssl
PHTTP_VERSION* = ptr THTTP_VERSION PHTTP_VERSION* = ptr HTTP_VERSION
Phttppost* = ptr Thttppost Phttppost* = ptr Httppost
PPcurl_httppost* = ptr Phttppost PPcurl_httppost* = ptr Phttppost
Pinfotype* = ptr Tinfotype Pinfotype* = ptr Infotype
Plock_access* = ptr Tlock_access Plock_access* = ptr Lock_access
Plock_data* = ptr Tlock_data Plock_data* = ptr Lock_data
Pmalloc_callback* = ptr Tmalloc_callback Pmalloc_callback* = ptr Malloc_callback
PNETRC_OPTION* = ptr TNETRC_OPTION PNETRC_OPTION* = ptr NETRC_OPTION
Pproxytype* = ptr Tproxytype Pproxytype* = ptr Proxytype
Prealloc_callback* = ptr Trealloc_callback Prealloc_callback* = ptr Realloc_callback
Pslist* = ptr Tslist Pslist* = ptr Slist
Psocket* = ptr Tsocket Psocket* = ptr Socket
PSSL_VERSION* = ptr TSSL_VERSION PSSL_VERSION* = ptr SSL_VERSION
Pstrdup_callback* = ptr Tstrdup_callback Pstrdup_callback* = ptr Strdup_callback
PTIMECOND* = ptr TTIMECOND PTIMECOND* = ptr TIMECOND
Pversion_info_data* = ptr Tversion_info_data Pversion_info_data* = ptr Version_info_data
Pcode* = ptr Tcode Pcode* = ptr Code
PFORMcode* = ptr TFORMcode PFORMcode* = ptr FORMcode
Pformoption* = ptr Tformoption Pformoption* = ptr Formoption
PINFO* = ptr TINFO PINFO* = ptr INFO
Piocmd* = ptr Tiocmd Piocmd* = ptr Iocmd
Pioerr* = ptr Tioerr Pioerr* = ptr Ioerr
PM* = ptr TM PM* = ptr M
PMcode* = ptr TMcode PMcode* = ptr Mcode
PMoption* = ptr TMoption PMoption* = ptr Moption
PMSG* = ptr TMSG PMSG* = ptr MSG
Poption* = ptr Toption Poption* = ptr Option
PSH* = ptr TSH PSH* = ptr SH
PSHcode* = ptr TSHcode PSHcode* = ptr SHcode
PSHoption* = ptr TSHoption PSHoption* = ptr SHoption
Pversion* = ptr Tversion Pversion* = ptr Version
Pfd_set* = pointer Pfd_set* = pointer
PCurl* = ptr TCurl PCurl* = ptr Curl
TCurl* = pointer Curl* = pointer
Thttppost*{.final, pure.} = object Httppost*{.final, pure.} = object
next*: Phttppost next*: Phttppost
name*: cstring name*: cstring
namelength*: int32 namelength*: int32
@ -85,32 +85,32 @@ type
flags*: int32 flags*: int32
showfilename*: cstring showfilename*: cstring
Tprogress_callback* = proc (clientp: pointer, dltotal: float64, Progress_callback* = proc (clientp: pointer, dltotal: float64,
dlnow: float64, ultotal: float64, dlnow: float64, ultotal: float64,
ulnow: float64): int32 {.cdecl.} ulnow: float64): int32 {.cdecl.}
Twrite_callback* = proc (buffer: cstring, size: int, nitems: int, Write_callback* = proc (buffer: cstring, size: int, nitems: int,
outstream: pointer): int{.cdecl.} outstream: pointer): int{.cdecl.}
Tread_callback* = proc (buffer: cstring, size: int, nitems: int, Read_callback* = proc (buffer: cstring, size: int, nitems: int,
instream: pointer): int{.cdecl.} instream: pointer): int{.cdecl.}
Tpasswd_callback* = proc (clientp: pointer, prompt: cstring, buffer: cstring, Passwd_callback* = proc (clientp: pointer, prompt: cstring, buffer: cstring,
buflen: int32): int32{.cdecl.} buflen: int32): int32{.cdecl.}
Tioerr* = enum Ioerr* = enum
IOE_OK, IOE_UNKNOWNCMD, IOE_FAILRESTART, IOE_LAST IOE_OK, IOE_UNKNOWNCMD, IOE_FAILRESTART, IOE_LAST
Tiocmd* = enum Iocmd* = enum
IOCMD_NOP, IOCMD_RESTARTREAD, IOCMD_LAST IOCMD_NOP, IOCMD_RESTARTREAD, IOCMD_LAST
Tioctl_callback* = proc (handle: PCurl, cmd: int32, clientp: pointer): Tioerr{. Ioctl_callback* = proc (handle: PCurl, cmd: int32, clientp: pointer): Ioerr{.
cdecl.} cdecl.}
Tmalloc_callback* = proc (size: int): pointer{.cdecl.} Malloc_callback* = proc (size: int): pointer{.cdecl.}
Tfree_callback* = proc (p: pointer){.cdecl.} Free_callback* = proc (p: pointer){.cdecl.}
Trealloc_callback* = proc (p: pointer, size: int): pointer{.cdecl.} Realloc_callback* = proc (p: pointer, size: int): pointer{.cdecl.}
Tstrdup_callback* = proc (str: cstring): cstring{.cdecl.} Strdup_callback* = proc (str: cstring): cstring{.cdecl.}
Tcalloc_callback* = proc (nmemb: int, size: int): pointer{.noconv.} Calloc_callback* = proc (nmemb: int, size: int): pointer{.noconv.}
Tinfotype* = enum Infotype* = enum
INFO_TEXT = 0, INFO_HEADER_IN, INFO_HEADER_OUT, INFO_DATA_IN, INFO_DATA_OUT, INFO_TEXT = 0, INFO_HEADER_IN, INFO_HEADER_OUT, INFO_DATA_IN, INFO_DATA_OUT,
INFO_SSL_DATA_IN, INFO_SSL_DATA_OUT, INFO_END INFO_SSL_DATA_IN, INFO_SSL_DATA_OUT, INFO_END
Tdebug_callback* = proc (handle: PCurl, theType: Tinfotype, data: cstring, Debug_callback* = proc (handle: PCurl, theType: Infotype, data: cstring,
size: int, userptr: pointer): int32{.cdecl.} size: int, userptr: pointer): int32{.cdecl.}
Tcode* = enum Code* = enum
E_OK = 0, E_UNSUPPORTED_PROTOCOL, E_FAILED_INIT, E_URL_MALFORMAT, E_OK = 0, E_UNSUPPORTED_PROTOCOL, E_FAILED_INIT, E_URL_MALFORMAT,
E_URL_MALFORMAT_USER, E_COULDNT_RESOLVE_PROXY, E_COULDNT_RESOLVE_HOST, E_URL_MALFORMAT_USER, E_COULDNT_RESOLVE_PROXY, E_COULDNT_RESOLVE_HOST,
E_COULDNT_CONNECT, E_FTP_WEIRD_SERVER_REPLY, E_FTP_ACCESS_DENIED, E_COULDNT_CONNECT, E_FTP_WEIRD_SERVER_REPLY, E_FTP_ACCESS_DENIED,
@ -135,18 +135,18 @@ type
E_LOGIN_DENIED, E_TFTP_NOTFOUND, E_TFTP_PERM, E_TFTP_DISKFULL, E_LOGIN_DENIED, E_TFTP_NOTFOUND, E_TFTP_PERM, E_TFTP_DISKFULL,
E_TFTP_ILLEGAL, E_TFTP_UNKNOWNID, E_TFTP_EXISTS, E_TFTP_NOSUCHUSER, E_TFTP_ILLEGAL, E_TFTP_UNKNOWNID, E_TFTP_EXISTS, E_TFTP_NOSUCHUSER,
E_CONV_FAILED, E_CONV_REQD, LAST E_CONV_FAILED, E_CONV_REQD, LAST
Tconv_callback* = proc (buffer: cstring, len: int): Tcode{.cdecl.} Conv_callback* = proc (buffer: cstring, len: int): Code{.cdecl.}
Tssl_ctx_callback* = proc (curl: PCurl, ssl_ctx, userptr: pointer): Tcode{.cdecl.} Ssl_ctx_callback* = proc (curl: PCurl, ssl_ctx, userptr: pointer): Code{.cdecl.}
Tproxytype* = enum Proxytype* = enum
PROXY_HTTP = 0, PROXY_SOCKS4 = 4, PROXY_SOCKS5 = 5 PROXY_HTTP = 0, PROXY_SOCKS4 = 4, PROXY_SOCKS5 = 5
Tftpssl* = enum Ftpssl* = enum
FTPSSL_NONE, FTPSSL_TRY, FTPSSL_CONTROL, FTPSSL_ALL, FTPSSL_LAST FTPSSL_NONE, FTPSSL_TRY, FTPSSL_CONTROL, FTPSSL_ALL, FTPSSL_LAST
Tftpauth* = enum Ftpauth* = enum
FTPAUTH_DEFAULT, FTPAUTH_SSL, FTPAUTH_TLS, FTPAUTH_LAST FTPAUTH_DEFAULT, FTPAUTH_SSL, FTPAUTH_TLS, FTPAUTH_LAST
Tftpmethod* = enum Ftpmethod* = enum
FTPMETHOD_DEFAULT, FTPMETHOD_MULTICWD, FTPMETHOD_NOCWD, FTPMETHOD_SINGLECWD, FTPMETHOD_DEFAULT, FTPMETHOD_MULTICWD, FTPMETHOD_NOCWD, FTPMETHOD_SINGLECWD,
FTPMETHOD_LAST FTPMETHOD_LAST
Toption* = enum Option* = enum
OPT_PORT = 0 + 3, OPT_TIMEOUT = 0 + 13, OPT_INFILESIZE = 0 + 14, OPT_PORT = 0 + 3, OPT_TIMEOUT = 0 + 13, OPT_INFILESIZE = 0 + 14,
OPT_LOW_SPEED_LIMIT = 0 + 19, OPT_LOW_SPEED_TIME = 0 + 20, OPT_LOW_SPEED_LIMIT = 0 + 19, OPT_LOW_SPEED_TIME = 0 + 20,
OPT_RESUME_FROM = 0 + 21, OPT_CRLF = 0 + 27, OPT_SSLVERSION = 0 + 32, OPT_RESUME_FROM = 0 + 21, OPT_CRLF = 0 + 27, OPT_SSLVERSION = 0 + 32,
@ -211,37 +211,37 @@ type
OPT_MAXFILESIZE_LARGE = 30000 + 117, OPT_POSTFIELDSIZE_LARGE = 30000 + 120, OPT_MAXFILESIZE_LARGE = 30000 + 117, OPT_POSTFIELDSIZE_LARGE = 30000 + 120,
OPT_MAX_SEND_SPEED_LARGE = 30000 + 145, OPT_MAX_SEND_SPEED_LARGE = 30000 + 145,
OPT_MAX_RECV_SPEED_LARGE = 30000 + 146 OPT_MAX_RECV_SPEED_LARGE = 30000 + 146
THTTP_VERSION* = enum HTTP_VERSION* = enum
HTTP_VERSION_NONE, HTTP_VERSION_1_0, HTTP_VERSION_1_1, HTTP_VERSION_LAST HTTP_VERSION_NONE, HTTP_VERSION_1_0, HTTP_VERSION_1_1, HTTP_VERSION_LAST
TNETRC_OPTION* = enum NETRC_OPTION* = enum
NETRC_IGNORED, NETRC_OPTIONAL, NETRC_REQUIRED, NETRC_LAST NETRC_IGNORED, NETRC_OPTIONAL, NETRC_REQUIRED, NETRC_LAST
TSSL_VERSION* = enum SSL_VERSION* = enum
SSLVERSION_DEFAULT, SSLVERSION_TLSv1, SSLVERSION_SSLv2, SSLVERSION_SSLv3, SSLVERSION_DEFAULT, SSLVERSION_TLSv1, SSLVERSION_SSLv2, SSLVERSION_SSLv3,
SSLVERSION_LAST SSLVERSION_LAST
TTIMECOND* = enum TIMECOND* = enum
TIMECOND_NONE, TIMECOND_IFMODSINCE, TIMECOND_IFUNMODSINCE, TIMECOND_LASTMOD, TIMECOND_NONE, TIMECOND_IFMODSINCE, TIMECOND_IFUNMODSINCE, TIMECOND_LASTMOD,
TIMECOND_LAST TIMECOND_LAST
Tformoption* = enum Formoption* = enum
FORM_NOTHING, FORM_COPYNAME, FORM_PTRNAME, FORM_NAMELENGTH, FORM_NOTHING, FORM_COPYNAME, FORM_PTRNAME, FORM_NAMELENGTH,
FORM_COPYCONTENTS, FORM_PTRCONTENTS, FORM_CONTENTSLENGTH, FORM_FILECONTENT, FORM_COPYCONTENTS, FORM_PTRCONTENTS, FORM_CONTENTSLENGTH, FORM_FILECONTENT,
FORM_ARRAY, FORM_OBSOLETE, FORM_FILE, FORM_BUFFER, FORM_BUFFERPTR, FORM_ARRAY, FORM_OBSOLETE, FORM_FILE, FORM_BUFFER, FORM_BUFFERPTR,
FORM_BUFFERLENGTH, FORM_CONTENTTYPE, FORM_CONTENTHEADER, FORM_FILENAME, FORM_BUFFERLENGTH, FORM_CONTENTTYPE, FORM_CONTENTHEADER, FORM_FILENAME,
FORM_END, FORM_OBSOLETE2, FORM_LASTENTRY FORM_END, FORM_OBSOLETE2, FORM_LASTENTRY
Tforms*{.pure, final.} = object Forms*{.pure, final.} = object
option*: Tformoption option*: Formoption
value*: cstring value*: cstring
TFORMcode* = enum FORMcode* = enum
FORMADD_OK, FORMADD_MEMORY, FORMADD_OPTION_TWICE, FORMADD_NULL, FORMADD_OK, FORMADD_MEMORY, FORMADD_OPTION_TWICE, FORMADD_NULL,
FORMADD_UNKNOWN_OPTION, FORMADD_INCOMPLETE, FORMADD_ILLEGAL_ARRAY, FORMADD_UNKNOWN_OPTION, FORMADD_INCOMPLETE, FORMADD_ILLEGAL_ARRAY,
FORMADD_DISABLED, FORMADD_LAST FORMADD_DISABLED, FORMADD_LAST
Tformget_callback* = proc (arg: pointer, buf: cstring, length: int): int{. Formget_callback* = proc (arg: pointer, buf: cstring, length: int): int{.
cdecl.} cdecl.}
Tslist*{.pure, final.} = object Slist*{.pure, final.} = object
data*: cstring data*: cstring
next*: Pslist next*: Pslist
TINFO* = enum INFO* = enum
INFO_NONE = 0, INFO_LASTONE = 30, INFO_EFFECTIVE_URL = 0x00100000 + 1, INFO_NONE = 0, INFO_LASTONE = 30, INFO_EFFECTIVE_URL = 0x00100000 + 1,
INFO_CONTENT_TYPE = 0x00100000 + 18, INFO_PRIVATE = 0x00100000 + 21, INFO_CONTENT_TYPE = 0x00100000 + 18, INFO_PRIVATE = 0x00100000 + 21,
INFO_FTP_ENTRY_PATH = 0x00100000 + 30, INFO_RESPONSE_CODE = 0x00200000 + 2, INFO_FTP_ENTRY_PATH = 0x00100000 + 30, INFO_RESPONSE_CODE = 0x00200000 + 2,
@ -261,31 +261,31 @@ type
INFO_STARTTRANSFER_TIME = 0x00300000 + 17, INFO_STARTTRANSFER_TIME = 0x00300000 + 17,
INFO_REDIRECT_TIME = 0x00300000 + 19, INFO_SSL_ENGINES = 0x00400000 + 27, INFO_REDIRECT_TIME = 0x00300000 + 19, INFO_SSL_ENGINES = 0x00400000 + 27,
INFO_COOKIELIST = 0x00400000 + 28 INFO_COOKIELIST = 0x00400000 + 28
Tclosepolicy* = enum Closepolicy* = enum
CLOSEPOLICY_NONE, CLOSEPOLICY_OLDEST, CLOSEPOLICY_LEAST_RECENTLY_USED, CLOSEPOLICY_NONE, CLOSEPOLICY_OLDEST, CLOSEPOLICY_LEAST_RECENTLY_USED,
CLOSEPOLICY_LEAST_TRAFFIC, CLOSEPOLICY_SLOWEST, CLOSEPOLICY_CALLBACK, CLOSEPOLICY_LEAST_TRAFFIC, CLOSEPOLICY_SLOWEST, CLOSEPOLICY_CALLBACK,
CLOSEPOLICY_LAST CLOSEPOLICY_LAST
Tlock_data* = enum Lock_data* = enum
LOCK_DATA_NONE = 0, LOCK_DATA_SHARE, LOCK_DATA_COOKIE, LOCK_DATA_DNS, LOCK_DATA_NONE = 0, LOCK_DATA_SHARE, LOCK_DATA_COOKIE, LOCK_DATA_DNS,
LOCK_DATA_SSL_SESSION, LOCK_DATA_CONNECT, LOCK_DATA_LAST LOCK_DATA_SSL_SESSION, LOCK_DATA_CONNECT, LOCK_DATA_LAST
Tlock_access* = enum Lock_access* = enum
LOCK_ACCESS_NONE = 0, LOCK_ACCESS_SHARED = 1, LOCK_ACCESS_SINGLE = 2, LOCK_ACCESS_NONE = 0, LOCK_ACCESS_SHARED = 1, LOCK_ACCESS_SINGLE = 2,
LOCK_ACCESS_LAST LOCK_ACCESS_LAST
Tlock_function* = proc (handle: PCurl, data: Tlock_data, Lock_function* = proc (handle: PCurl, data: Lock_data,
locktype: Tlock_access, locktype: Lock_access,
userptr: pointer){.cdecl.} userptr: pointer){.cdecl.}
Tunlock_function* = proc (handle: PCurl, data: Tlock_data, userptr: pointer){. Unlock_function* = proc (handle: PCurl, data: Lock_data, userptr: pointer){.
cdecl.} cdecl.}
TSH* = pointer SH* = pointer
TSHcode* = enum SHcode* = enum
SHE_OK, SHE_BAD_OPTION, SHE_IN_USE, SHE_INVALID, SHE_NOMEM, SHE_LAST SHE_OK, SHE_BAD_OPTION, SHE_IN_USE, SHE_INVALID, SHE_NOMEM, SHE_LAST
TSHoption* = enum SHoption* = enum
SHOPT_NONE, SHOPT_SHARE, SHOPT_UNSHARE, SHOPT_LOCKFUNC, SHOPT_UNLOCKFUNC, SHOPT_NONE, SHOPT_SHARE, SHOPT_UNSHARE, SHOPT_LOCKFUNC, SHOPT_UNLOCKFUNC,
SHOPT_USERDATA, SHOPT_LAST SHOPT_USERDATA, SHOPT_LAST
Tversion* = enum Version* = enum
VERSION_FIRST, VERSION_SECOND, VERSION_THIRD, VERSION_LAST VERSION_FIRST, VERSION_SECOND, VERSION_THIRD, VERSION_LAST
Tversion_info_data*{.pure, final.} = object Version_info_data*{.pure, final.} = object
age*: Tversion age*: Version
version*: cstring version*: cstring
version_num*: int32 version_num*: int32
host*: cstring host*: cstring
@ -299,15 +299,15 @@ type
libidn*: cstring libidn*: cstring
iconv_ver_num*: int32 iconv_ver_num*: int32
TM* = pointer M* = pointer
Tsocket* = int32 Socket* = int32
TMcode* = enum Mcode* = enum
M_CALL_MULTI_PERFORM = - 1, M_OK = 0, M_BAD_HANDLE, M_BAD_EASY_HANDLE, M_CALL_MULTI_PERFORM = - 1, M_OK = 0, M_BAD_HANDLE, M_BAD_EASY_HANDLE,
M_OUT_OF_MEMORY, M_INTERNAL_ERROR, M_BAD_SOCKET, M_UNKNOWN_OPTION, M_LAST M_OUT_OF_MEMORY, M_INTERNAL_ERROR, M_BAD_SOCKET, M_UNKNOWN_OPTION, M_LAST
TMSGEnum* = enum MSGEnum* = enum
MSG_NONE, MSG_DONE, MSG_LAST MSG_NONE, MSG_DONE, MSG_LAST
TMsg*{.pure, final.} = object Msg*{.pure, final.} = object
msg*: TMSGEnum msg*: MSGEnum
easy_handle*: PCurl easy_handle*: PCurl
whatever*: pointer #data : record whatever*: pointer #data : record
# case longint of # case longint of
@ -315,11 +315,29 @@ type
# 1 : ( result : CURLcode ); # 1 : ( result : CURLcode );
# end; # end;
Tsocket_callback* = proc (easy: PCurl, s: Tsocket, what: int32, Socket_callback* = proc (easy: PCurl, s: Socket, what: int32,
userp, socketp: pointer): int32{.cdecl.} userp, socketp: pointer): int32{.cdecl.}
TMoption* = enum Moption* = enum
MOPT_SOCKETDATA = 10000 + 2, MOPT_LASTENTRY = 10000 + 3, MOPT_SOCKETDATA = 10000 + 2, MOPT_LASTENTRY = 10000 + 3,
MOPT_SOCKETFUNCTION = 20000 + 1 MOPT_SOCKETFUNCTION = 20000 + 1
{.deprecated: [TMsg: Msg, TCurl: Curl, Thttppost: Httppost,
Tprogress_callback: Progress_callback, Twrite_callback: Write_callback,
Tread_callback: Read_callback, Tpasswd_callback: Passwd_callback, Tioerr: Ioerr,
Tiocmd: Iocmd, Tioctl_callback: Ioctl_callback, Tmalloc_callback: Malloc_callback,
Tfree_callback: Free_callback, Trealloc_callback: Realloc_callback,
Tstrdup_callback: Strdup_callback, Tcalloc_callback: Calloc_callback,
Tinfotype: Infotype, Tdebug_callback: Debug_callback, Tcode: Code,
Tconv_callback: Conv_callback, Tssl_ctx_callback: Ssl_ctx_callback,
Tproxytype: Proxytype, Tftpssl: Ftpssl, Tftpauth: Ftpauth, Tftpmethod: Ftpmethod,
Toption: Option, THTTP_VERSION: HTTP_VERSION, TNETRC_OPTION: NETRC_OPTION,
TSSL_VERSION: SSL_VERSION, TTIMECOND: TIMECOND, Tformoption: Formoption,
Tforms: Forms, TFORMcode: FORMcode, Tformget_callback: Formget_callback,
Tslist: Slist, TINFO: INFO, Tclosepolicy: Closepolicy, Tlock_data: Lock_data,
Tlock_access: Lock_access, Tlock_function: Lock_function,
Tunlock_function: Unlock_function, TSH: Sh, TSHcode: SHcode, TSHoption: SHoption,
Tversion: Version, Tversion_info_data: Version_info_data, TM: M, Tsocket: Socket,
TMcode: Mcode, TMSGEnum: MsGEnum, Tsocket_callback: Socket_callback,
TMoption: Moption].}
const const
OPT_SSLKEYPASSWD* = OPT_SSLCERTPASSWD OPT_SSLKEYPASSWD* = OPT_SSLCERTPASSWD
@ -413,9 +431,9 @@ proc strequal*(s1, s2: cstring): int32{.cdecl, dynlib: libname,
importc: "curl_strequal".} importc: "curl_strequal".}
proc strnequal*(s1, s2: cstring, n: int): int32{.cdecl, dynlib: libname, proc strnequal*(s1, s2: cstring, n: int): int32{.cdecl, dynlib: libname,
importc: "curl_strnequal".} importc: "curl_strnequal".}
proc formadd*(httppost, last_post: PPcurl_httppost): TFORMcode{.cdecl, varargs, proc formadd*(httppost, last_post: PPcurl_httppost): FORMcode{.cdecl, varargs,
dynlib: libname, importc: "curl_formadd".} dynlib: libname, importc: "curl_formadd".}
proc formget*(form: Phttppost, arg: pointer, append: Tformget_callback): int32{. proc formget*(form: Phttppost, arg: pointer, append: Formget_callback): int32{.
cdecl, dynlib: libname, importc: "curl_formget".} cdecl, dynlib: libname, importc: "curl_formget".}
proc formfree*(form: Phttppost){.cdecl, dynlib: libname, proc formfree*(form: Phttppost){.cdecl, dynlib: libname,
importc: "curl_formfree".} importc: "curl_formfree".}
@ -431,11 +449,11 @@ proc easy_unescape*(handle: PCurl, str: cstring, len: int32, outlength: var int3
proc unescape*(str: cstring, len: int32): cstring{.cdecl, dynlib: libname, proc unescape*(str: cstring, len: int32): cstring{.cdecl, dynlib: libname,
importc: "curl_unescape".} importc: "curl_unescape".}
proc free*(p: pointer){.cdecl, dynlib: libname, importc: "curl_free".} proc free*(p: pointer){.cdecl, dynlib: libname, importc: "curl_free".}
proc global_init*(flags: int32): Tcode{.cdecl, dynlib: libname, proc global_init*(flags: int32): Code{.cdecl, dynlib: libname,
importc: "curl_global_init".} importc: "curl_global_init".}
proc global_init_mem*(flags: int32, m: Tmalloc_callback, f: Tfree_callback, proc global_init_mem*(flags: int32, m: Malloc_callback, f: Free_callback,
r: Trealloc_callback, s: Tstrdup_callback, r: Realloc_callback, s: Strdup_callback,
c: Tcalloc_callback): Tcode{.cdecl, dynlib: libname, c: Calloc_callback): Code{.cdecl, dynlib: libname,
importc: "curl_global_init_mem".} importc: "curl_global_init_mem".}
proc global_cleanup*(){.cdecl, dynlib: libname, importc: "curl_global_cleanup".} proc global_cleanup*(){.cdecl, dynlib: libname, importc: "curl_global_cleanup".}
proc slist_append*(slist: Pslist, p: cstring): Pslist{.cdecl, dynlib: libname, proc slist_append*(slist: Pslist, p: cstring): Pslist{.cdecl, dynlib: libname,
@ -445,50 +463,50 @@ proc slist_free_all*(para1: Pslist){.cdecl, dynlib: libname,
proc getdate*(p: cstring, unused: ptr Time): Time{.cdecl, dynlib: libname, proc getdate*(p: cstring, unused: ptr Time): Time{.cdecl, dynlib: libname,
importc: "curl_getdate".} importc: "curl_getdate".}
proc share_init*(): PSH{.cdecl, dynlib: libname, importc: "curl_share_init".} proc share_init*(): PSH{.cdecl, dynlib: libname, importc: "curl_share_init".}
proc share_setopt*(para1: PSH, option: TSHoption): TSHcode{.cdecl, varargs, proc share_setopt*(para1: PSH, option: SHoption): SHcode{.cdecl, varargs,
dynlib: libname, importc: "curl_share_setopt".} dynlib: libname, importc: "curl_share_setopt".}
proc share_cleanup*(para1: PSH): TSHcode{.cdecl, dynlib: libname, proc share_cleanup*(para1: PSH): SHcode{.cdecl, dynlib: libname,
importc: "curl_share_cleanup".} importc: "curl_share_cleanup".}
proc version_info*(para1: Tversion): Pversion_info_data{.cdecl, dynlib: libname, proc version_info*(para1: Version): Pversion_info_data{.cdecl, dynlib: libname,
importc: "curl_version_info".} importc: "curl_version_info".}
proc easy_strerror*(para1: Tcode): cstring{.cdecl, dynlib: libname, proc easy_strerror*(para1: Code): cstring{.cdecl, dynlib: libname,
importc: "curl_easy_strerror".} importc: "curl_easy_strerror".}
proc share_strerror*(para1: TSHcode): cstring{.cdecl, dynlib: libname, proc share_strerror*(para1: SHcode): cstring{.cdecl, dynlib: libname,
importc: "curl_share_strerror".} importc: "curl_share_strerror".}
proc easy_init*(): PCurl{.cdecl, dynlib: libname, importc: "curl_easy_init".} proc easy_init*(): PCurl{.cdecl, dynlib: libname, importc: "curl_easy_init".}
proc easy_setopt*(curl: PCurl, option: Toption): Tcode{.cdecl, varargs, dynlib: libname, proc easy_setopt*(curl: PCurl, option: Option): Code{.cdecl, varargs, dynlib: libname,
importc: "curl_easy_setopt".} importc: "curl_easy_setopt".}
proc easy_perform*(curl: PCurl): Tcode{.cdecl, dynlib: libname, proc easy_perform*(curl: PCurl): Code{.cdecl, dynlib: libname,
importc: "curl_easy_perform".} importc: "curl_easy_perform".}
proc easy_cleanup*(curl: PCurl){.cdecl, dynlib: libname, importc: "curl_easy_cleanup".} proc easy_cleanup*(curl: PCurl){.cdecl, dynlib: libname, importc: "curl_easy_cleanup".}
proc easy_getinfo*(curl: PCurl, info: TINFO): Tcode{.cdecl, varargs, dynlib: libname, proc easy_getinfo*(curl: PCurl, info: INFO): Code{.cdecl, varargs, dynlib: libname,
importc: "curl_easy_getinfo".} importc: "curl_easy_getinfo".}
proc easy_duphandle*(curl: PCurl): PCurl{.cdecl, dynlib: libname, proc easy_duphandle*(curl: PCurl): PCurl{.cdecl, dynlib: libname,
importc: "curl_easy_duphandle".} importc: "curl_easy_duphandle".}
proc easy_reset*(curl: PCurl){.cdecl, dynlib: libname, importc: "curl_easy_reset".} proc easy_reset*(curl: PCurl){.cdecl, dynlib: libname, importc: "curl_easy_reset".}
proc multi_init*(): PM{.cdecl, dynlib: libname, importc: "curl_multi_init".} proc multi_init*(): PM{.cdecl, dynlib: libname, importc: "curl_multi_init".}
proc multi_add_handle*(multi_handle: PM, handle: PCurl): TMcode{.cdecl, proc multi_add_handle*(multi_handle: PM, handle: PCurl): Mcode{.cdecl,
dynlib: libname, importc: "curl_multi_add_handle".} dynlib: libname, importc: "curl_multi_add_handle".}
proc multi_remove_handle*(multi_handle: PM, handle: PCurl): TMcode{.cdecl, proc multi_remove_handle*(multi_handle: PM, handle: PCurl): Mcode{.cdecl,
dynlib: libname, importc: "curl_multi_remove_handle".} dynlib: libname, importc: "curl_multi_remove_handle".}
proc multi_fdset*(multi_handle: PM, read_fd_set: Pfd_set, write_fd_set: Pfd_set, proc multi_fdset*(multi_handle: PM, read_fd_set: Pfd_set, write_fd_set: Pfd_set,
exc_fd_set: Pfd_set, max_fd: var int32): TMcode{.cdecl, exc_fd_set: Pfd_set, max_fd: var int32): Mcode{.cdecl,
dynlib: libname, importc: "curl_multi_fdset".} dynlib: libname, importc: "curl_multi_fdset".}
proc multi_perform*(multi_handle: PM, running_handles: var int32): TMcode{. proc multi_perform*(multi_handle: PM, running_handles: var int32): Mcode{.
cdecl, dynlib: libname, importc: "curl_multi_perform".} cdecl, dynlib: libname, importc: "curl_multi_perform".}
proc multi_cleanup*(multi_handle: PM): TMcode{.cdecl, dynlib: libname, proc multi_cleanup*(multi_handle: PM): Mcode{.cdecl, dynlib: libname,
importc: "curl_multi_cleanup".} importc: "curl_multi_cleanup".}
proc multi_info_read*(multi_handle: PM, msgs_in_queue: var int32): PMsg{.cdecl, proc multi_info_read*(multi_handle: PM, msgs_in_queue: var int32): PMsg{.cdecl,
dynlib: libname, importc: "curl_multi_info_read".} dynlib: libname, importc: "curl_multi_info_read".}
proc multi_strerror*(para1: TMcode): cstring{.cdecl, dynlib: libname, proc multi_strerror*(para1: Mcode): cstring{.cdecl, dynlib: libname,
importc: "curl_multi_strerror".} importc: "curl_multi_strerror".}
proc multi_socket*(multi_handle: PM, s: Tsocket, running_handles: var int32): TMcode{. proc multi_socket*(multi_handle: PM, s: Socket, running_handles: var int32): Mcode{.
cdecl, dynlib: libname, importc: "curl_multi_socket".} cdecl, dynlib: libname, importc: "curl_multi_socket".}
proc multi_socket_all*(multi_handle: PM, running_handles: var int32): TMcode{. proc multi_socket_all*(multi_handle: PM, running_handles: var int32): Mcode{.
cdecl, dynlib: libname, importc: "curl_multi_socket_all".} cdecl, dynlib: libname, importc: "curl_multi_socket_all".}
proc multi_timeout*(multi_handle: PM, milliseconds: var int32): TMcode{.cdecl, proc multi_timeout*(multi_handle: PM, milliseconds: var int32): Mcode{.cdecl,
dynlib: libname, importc: "curl_multi_timeout".} dynlib: libname, importc: "curl_multi_timeout".}
proc multi_setopt*(multi_handle: PM, option: TMoption): TMcode{.cdecl, varargs, proc multi_setopt*(multi_handle: PM, option: Moption): Mcode{.cdecl, varargs,
dynlib: libname, importc: "curl_multi_setopt".} dynlib: libname, importc: "curl_multi_setopt".}
proc multi_assign*(multi_handle: PM, sockfd: Tsocket, sockp: pointer): TMcode{. proc multi_assign*(multi_handle: PM, sockfd: Socket, sockp: pointer): Mcode{.
cdecl, dynlib: libname, importc: "curl_multi_assign".} cdecl, dynlib: libname, importc: "curl_multi_assign".}

71
lib/wrappers/libffi/libffi.nim
View file

@ -58,8 +58,9 @@ else:
{.pragma: mylib, dynlib: "libffi.so".} {.pragma: mylib, dynlib: "libffi.so".}
type type
TArg* = int Arg* = int
TSArg* = int SArg* = int
{deprecated: [TArg: Arg, TSArg: SArg].}
when defined(windows) and defined(x86): when defined(windows) and defined(x86):
type type
@ -105,67 +106,71 @@ const
tkSMALL_STRUCT_4B* = (tkLAST + 3) tkSMALL_STRUCT_4B* = (tkLAST + 3)
type type
TType* = object Type* = object
size*: int size*: int
alignment*: uint16 alignment*: uint16
typ*: uint16 typ*: uint16
elements*: ptr ptr TType elements*: ptr ptr Type
{.deprecated: [TType: Type].}
var var
type_void* {.importc: "ffi_type_void", mylib.}: TType type_void* {.importc: "ffi_type_void", mylib.}: Type
type_uint8* {.importc: "ffi_type_uint8", mylib.}: TType type_uint8* {.importc: "ffi_type_uint8", mylib.}: Type
type_sint8* {.importc: "ffi_type_sint8", mylib.}: TType type_sint8* {.importc: "ffi_type_sint8", mylib.}: Type
type_uint16* {.importc: "ffi_type_uint16", mylib.}: TType type_uint16* {.importc: "ffi_type_uint16", mylib.}: Type
type_sint16* {.importc: "ffi_type_sint16", mylib.}: TType type_sint16* {.importc: "ffi_type_sint16", mylib.}: Type
type_uint32* {.importc: "ffi_type_uint32", mylib.}: TType type_uint32* {.importc: "ffi_type_uint32", mylib.}: Type
type_sint32* {.importc: "ffi_type_sint32", mylib.}: TType type_sint32* {.importc: "ffi_type_sint32", mylib.}: Type
type_uint64* {.importc: "ffi_type_uint64", mylib.}: TType type_uint64* {.importc: "ffi_type_uint64", mylib.}: Type
type_sint64* {.importc: "ffi_type_sint64", mylib.}: TType type_sint64* {.importc: "ffi_type_sint64", mylib.}: Type
type_float* {.importc: "ffi_type_float", mylib.}: TType type_float* {.importc: "ffi_type_float", mylib.}: Type
type_double* {.importc: "ffi_type_double", mylib.}: TType type_double* {.importc: "ffi_type_double", mylib.}: Type
type_pointer* {.importc: "ffi_type_pointer", mylib.}: TType type_pointer* {.importc: "ffi_type_pointer", mylib.}: Type
type_longdouble* {.importc: "ffi_type_longdouble", mylib.}: TType type_longdouble* {.importc: "ffi_type_longdouble", mylib.}: Type
type type
Tstatus* {.size: sizeof(cint).} = enum Status* {.size: sizeof(cint).} = enum
OK, BAD_TYPEDEF, BAD_ABI OK, BAD_TYPEDEF, BAD_ABI
TTypeKind* = cuint TypeKind* = cuint
TCif* {.pure, final.} = object TCif* {.pure, final.} = object
abi*: TABI abi*: TABI
nargs*: cuint nargs*: cuint
arg_types*: ptr ptr TType arg_types*: ptr ptr Type
rtype*: ptr TType rtype*: ptr Type
bytes*: cuint bytes*: cuint
flags*: cuint flags*: cuint
{.deprecated: [Tstatus: Status].}
type type
TRaw* = object Raw* = object
sint*: TSArg sint*: SArg
{.deprecated: [TRaw: Raw].}
proc raw_call*(cif: var Tcif; fn: proc () {.cdecl.}; rvalue: pointer; proc raw_call*(cif: var Tcif; fn: proc () {.cdecl.}; rvalue: pointer;
avalue: ptr TRaw) {.cdecl, importc: "ffi_raw_call", mylib.} avalue: ptr Raw) {.cdecl, importc: "ffi_raw_call", mylib.}
proc ptrarray_to_raw*(cif: var Tcif; args: ptr pointer; raw: ptr TRaw) {.cdecl, proc ptrarray_to_raw*(cif: var Tcif; args: ptr pointer; raw: ptr Raw) {.cdecl,
importc: "ffi_ptrarray_to_raw", mylib.} importc: "ffi_ptrarray_to_raw", mylib.}
proc raw_to_ptrarray*(cif: var Tcif; raw: ptr TRaw; args: ptr pointer) {.cdecl, proc raw_to_ptrarray*(cif: var Tcif; raw: ptr Raw; args: ptr pointer) {.cdecl,
importc: "ffi_raw_to_ptrarray", mylib.} importc: "ffi_raw_to_ptrarray", mylib.}
proc raw_size*(cif: var Tcif): int {.cdecl, importc: "ffi_raw_size", mylib.} proc raw_size*(cif: var Tcif): int {.cdecl, importc: "ffi_raw_size", mylib.}
proc prep_cif*(cif: var Tcif; abi: TABI; nargs: cuint; rtype: ptr TType; proc prep_cif*(cif: var Tcif; abi: TABI; nargs: cuint; rtype: ptr Type;
atypes: ptr ptr TType): TStatus {.cdecl, importc: "ffi_prep_cif", atypes: ptr ptr Type): Status {.cdecl, importc: "ffi_prep_cif",
mylib.} mylib.}
proc call*(cif: var Tcif; fn: proc () {.cdecl.}; rvalue: pointer; proc call*(cif: var Tcif; fn: proc () {.cdecl.}; rvalue: pointer;
avalue: ptr pointer) {.cdecl, importc: "ffi_call", mylib.} avalue: ptr pointer) {.cdecl, importc: "ffi_call", mylib.}
# the same with an easier interface: # the same with an easier interface:
type type
TParamList* = array[0..100, ptr TType] ParamList* = array[0..100, ptr Type]
TArgList* = array[0..100, pointer] ArgList* = array[0..100, pointer]
{.deprecated: [TParamList: ParamList, TArgList: ArgList].}
proc prep_cif*(cif: var Tcif; abi: TABI; nargs: cuint; rtype: ptr TType; proc prep_cif*(cif: var Tcif; abi: TABI; nargs: cuint; rtype: ptr Type;
atypes: TParamList): TStatus {.cdecl, importc: "ffi_prep_cif", atypes: ParamList): Status {.cdecl, importc: "ffi_prep_cif",
mylib.} mylib.}
proc call*(cif: var Tcif; fn, rvalue: pointer; proc call*(cif: var Tcif; fn, rvalue: pointer;
avalue: TArgList) {.cdecl, importc: "ffi_call", mylib.} avalue: ArgList) {.cdecl, importc: "ffi_call", mylib.}
# Useful for eliminating compiler warnings # Useful for eliminating compiler warnings
##define FFI_FN(f) ((void (*)(void))f) ##define FFI_FN(f) ((void (*)(void))f)

59
lib/wrappers/libsvm.nim
View file

@ -21,24 +21,24 @@ else:
const svmdll* = "libsvm.so" const svmdll* = "libsvm.so"
type type
Tnode*{.pure, final.} = object Node*{.pure, final.} = object
index*: cint index*: cint
value*: cdouble value*: cdouble
Tproblem*{.pure, final.} = object Problem*{.pure, final.} = object
L*: cint L*: cint
y*: ptr cdouble y*: ptr cdouble
x*: ptr ptr Tnode x*: ptr ptr Node
Ttype*{.size: sizeof(cint).} = enum Type*{.size: sizeof(cint).} = enum
C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR
TKernelType*{.size: sizeof(cint).} = enum KernelType*{.size: sizeof(cint).} = enum
LINEAR, POLY, RBF, SIGMOID, PRECOMPUTED LINEAR, POLY, RBF, SIGMOID, PRECOMPUTED
Tparameter*{.pure, final.} = object Parameter*{.pure, final.} = object
typ*: TType typ*: Type
kernelType*: TKernelType kernelType*: KernelType
degree*: cint # for poly degree*: cint # for poly
gamma*: cdouble # for poly/rbf/sigmoid gamma*: cdouble # for poly/rbf/sigmoid
coef0*: cdouble # for poly/sigmoid coef0*: cdouble # for poly/sigmoid
@ -53,18 +53,19 @@ type
p*: cdouble # for EPSILON_SVR p*: cdouble # for EPSILON_SVR
shrinking*: cint # use the shrinking heuristics shrinking*: cint # use the shrinking heuristics
probability*: cint # do probability estimates probability*: cint # do probability estimates
{.deprecated: [Tnode: Node, Tproblem: Problem, Ttype: Type,
TKernelType: KernelType, Tparameter: Parameter].}
# #
# svm_model # svm_model
# #
type type
TModel*{.pure, final.} = object Model*{.pure, final.} = object
param*: Tparameter # parameter param*: Parameter # parameter
nr_class*: cint # number of classes, = 2 in regression/one class svm nr_class*: cint # number of classes, = 2 in regression/one class svm
L*: cint # total #SV L*: cint # total #SV
SV*: ptr ptr Tnode # SVs (SV[l]) SV*: ptr ptr Node # SVs (SV[l])
sv_coef*: ptr ptr cdouble # coefficients for SVs in decision functions (sv_coef[k-1][l]) sv_coef*: ptr ptr cdouble # coefficients for SVs in decision functions (sv_coef[k-1][l])
rho*: ptr cdouble # constants in decision functions (rho[k*(k-1)/2]) rho*: ptr cdouble # constants in decision functions (rho[k*(k-1)/2])
probA*: ptr cdouble # pariwise probability information probA*: ptr cdouble # pariwise probability information
@ -75,41 +76,41 @@ type
# XXX # XXX
free_sv*: cint # 1 if svm_model is created by svm_load_model free_sv*: cint # 1 if svm_model is created by svm_load_model
# 0 if svm_model is created by svm_train # 0 if svm_model is created by svm_train
{.deprecated: [TModel: Model].}
proc train*(prob: ptr Problem, param: ptr Parameter): ptr Model{.cdecl,
proc train*(prob: ptr Tproblem, param: ptr Tparameter): ptr Tmodel{.cdecl,
importc: "svm_train", dynlib: svmdll.} importc: "svm_train", dynlib: svmdll.}
proc cross_validation*(prob: ptr Tproblem, param: ptr Tparameter, nr_fold: cint, proc cross_validation*(prob: ptr Problem, param: ptr Parameter, nr_fold: cint,
target: ptr cdouble){.cdecl, target: ptr cdouble){.cdecl,
importc: "svm_cross_validation", dynlib: svmdll.} importc: "svm_cross_validation", dynlib: svmdll.}
proc save_model*(model_file_name: cstring, model: ptr Tmodel): cint{.cdecl, proc save_model*(model_file_name: cstring, model: ptr Model): cint{.cdecl,
importc: "svm_save_model", dynlib: svmdll.} importc: "svm_save_model", dynlib: svmdll.}
proc load_model*(model_file_name: cstring): ptr Tmodel{.cdecl, proc load_model*(model_file_name: cstring): ptr Model{.cdecl,
importc: "svm_load_model", dynlib: svmdll.} importc: "svm_load_model", dynlib: svmdll.}
proc get_svm_type*(model: ptr Tmodel): cint{.cdecl, importc: "svm_get_svm_type", proc get_svm_type*(model: ptr Model): cint{.cdecl, importc: "svm_get_svm_type",
dynlib: svmdll.} dynlib: svmdll.}
proc get_nr_class*(model: ptr Tmodel): cint{.cdecl, importc: "svm_get_nr_class", proc get_nr_class*(model: ptr Model): cint{.cdecl, importc: "svm_get_nr_class",
dynlib: svmdll.} dynlib: svmdll.}
proc get_labels*(model: ptr Tmodel, label: ptr cint){.cdecl, proc get_labels*(model: ptr Model, label: ptr cint){.cdecl,
importc: "svm_get_labels", dynlib: svmdll.} importc: "svm_get_labels", dynlib: svmdll.}
proc get_svr_probability*(model: ptr Tmodel): cdouble{.cdecl, proc get_svr_probability*(model: ptr Model): cdouble{.cdecl,
importc: "svm_get_svr_probability", dynlib: svmdll.} importc: "svm_get_svr_probability", dynlib: svmdll.}
proc predict_values*(model: ptr Tmodel, x: ptr Tnode, dec_values: ptr cdouble): cdouble{. proc predict_values*(model: ptr Model, x: ptr Node, dec_values: ptr cdouble): cdouble{.
cdecl, importc: "svm_predict_values", dynlib: svmdll.} cdecl, importc: "svm_predict_values", dynlib: svmdll.}
proc predict*(model: ptr Tmodel, x: ptr Tnode): cdouble{.cdecl, proc predict*(model: ptr Model, x: ptr Node): cdouble{.cdecl,
importc: "svm_predict", dynlib: svmdll.} importc: "svm_predict", dynlib: svmdll.}
proc predict_probability*(model: ptr Tmodel, x: ptr Tnode, proc predict_probability*(model: ptr Model, x: ptr Node,
prob_estimates: ptr cdouble): cdouble{.cdecl, prob_estimates: ptr cdouble): cdouble{.cdecl,
importc: "svm_predict_probability", dynlib: svmdll.} importc: "svm_predict_probability", dynlib: svmdll.}
proc free_model_content*(model_ptr: ptr Tmodel){.cdecl, proc free_model_content*(model_ptr: ptr Model){.cdecl,
importc: "svm_free_model_content", dynlib: svmdll.} importc: "svm_free_model_content", dynlib: svmdll.}
proc free_and_destroy_model*(model_ptr_ptr: ptr ptr Tmodel){.cdecl, proc free_and_destroy_model*(model_ptr_ptr: ptr ptr Model){.cdecl,
importc: "svm_free_and_destroy_model", dynlib: svmdll.} importc: "svm_free_and_destroy_model", dynlib: svmdll.}
proc destroy_param*(param: ptr Tparameter){.cdecl, importc: "svm_destroy_param", proc destroy_param*(param: ptr Parameter){.cdecl, importc: "svm_destroy_param",
dynlib: svmdll.} dynlib: svmdll.}
proc check_parameter*(prob: ptr Tproblem, param: ptr Tparameter): cstring{. proc check_parameter*(prob: ptr Problem, param: ptr Parameter): cstring{.
cdecl, importc: "svm_check_parameter", dynlib: svmdll.} cdecl, importc: "svm_check_parameter", dynlib: svmdll.}
proc check_probability_model*(model: ptr Tmodel): cint{.cdecl, proc check_probability_model*(model: ptr Model): cint{.cdecl,
importc: "svm_check_probability_model", dynlib: svmdll.} importc: "svm_check_probability_model", dynlib: svmdll.}
proc set_print_string_function*(print_func: proc (arg: cstring) {.cdecl.}){. proc set_print_string_function*(print_func: proc (arg: cstring) {.cdecl.}){.

206
lib/wrappers/libuv.nim
View file

@ -10,15 +10,15 @@ else:
import posix import posix
type type
TPort* = distinct int16 ## port type Port* = distinct int16 ## port type
cssize = int cssize = int
coff = int coff = int
csize = int csize = int
AllocProc* = proc (handle: PHandle, suggested_size: csize): TBuf {.cdecl.} AllocProc* = proc (handle: PHandle, suggested_size: csize): Buf {.cdecl.}
ReadProc* = proc (stream: PStream, nread: cssize, buf: TBuf) {.cdecl.} ReadProc* = proc (stream: PStream, nread: cssize, buf: Buf) {.cdecl.}
ReadProc2* = proc (stream: PPipe, nread: cssize, buf: TBuf, pending: THandleType) {.cdecl.} ReadProc2* = proc (stream: PPipe, nread: cssize, buf: Buf, pending: HandleType) {.cdecl.}
WriteProc* = proc (req: PWrite, status: cint) {.cdecl.} WriteProc* = proc (req: PWrite, status: cint) {.cdecl.}
ConnectProc* = proc (req: PConnect, status: cint) {.cdecl.} ConnectProc* = proc (req: PConnect, status: cint) {.cdecl.}
ShutdownProc* = proc (req: PShutdown, status: cint) {.cdecl.} ShutdownProc* = proc (req: PShutdown, status: cint) {.cdecl.}
@ -41,7 +41,7 @@ type
FsEventProc* = proc (handle: PFsEvent, filename: cstring, events: cint, status: cint) FsEventProc* = proc (handle: PFsEvent, filename: cstring, events: cint, status: cint)
TErrorCode* {.size: sizeof(cint).} = enum ErrorCode* {.size: sizeof(cint).} = enum
UNKNOWN = - 1, OK = 0, EOF, EACCESS, EAGAIN, EADDRINUSE, EADDRNOTAVAIL, UNKNOWN = - 1, OK = 0, EOF, EACCESS, EAGAIN, EADDRINUSE, EADDRNOTAVAIL,
EAFNOSUPPORT, EALREADY, EBADF, EBUSY, ECONNABORTED, ECONNREFUSED, EAFNOSUPPORT, EALREADY, EBADF, EBUSY, ECONNABORTED, ECONNREFUSED,
ECONNRESET, EDESTADDRREQ, EFAULT, EHOSTUNREACH, EINTR, EINVAL, EISCONN, ECONNRESET, EDESTADDRREQ, EFAULT, EHOSTUNREACH, EINTR, EINVAL, EISCONN,
@ -50,11 +50,11 @@ type
EPROTONOSUPPORT, EPROTOTYPE, ETIMEDOUT, ECHARSET, EAIFAMNOSUPPORT, EPROTONOSUPPORT, EPROTOTYPE, ETIMEDOUT, ECHARSET, EAIFAMNOSUPPORT,
EAINONAME, EAISERVICE, EAISOCKTYPE, ESHUTDOWN, EEXIST EAINONAME, EAISERVICE, EAISOCKTYPE, ESHUTDOWN, EEXIST
THandleType* {.size: sizeof(cint).} = enum HandleType* {.size: sizeof(cint).} = enum
UNKNOWN_HANDLE = 0, TCP, UDP, NAMED_PIPE, TTY, FILE, TIMER, PREPARE, CHECK, UNKNOWN_HANDLE = 0, TCP, UDP, NAMED_PIPE, TTY, FILE, TIMER, PREPARE, CHECK,
IDLE, ASYNC, ARES_TASK, ARES_EVENT, PROCESS, FS_EVENT IDLE, ASYNC, ARES_TASK, ARES_EVENT, PROCESS, FS_EVENT
TReqType* {.size: sizeof(cint).} = enum ReqType* {.size: sizeof(cint).} = enum
rUNKNOWN_REQ = 0, rUNKNOWN_REQ = 0,
rCONNECT, rCONNECT,
rACCEPT, rACCEPT,
@ -68,57 +68,57 @@ type
rGETADDRINFO, rGETADDRINFO,
rREQ_TYPE_PRIVATE rREQ_TYPE_PRIVATE
TErr* {.pure, final, importc: "uv_err_t", header: "uv.h".} = object Err* {.pure, final, importc: "uv_err_t", header: "uv.h".} = object
code* {.importc: "code".}: TErrorCode code* {.importc: "code".}: ErrorCode
sys_errno* {.importc: "sys_errno_".}: cint sys_errno* {.importc: "sys_errno_".}: cint
TFsEventType* = enum FsEventType* = enum
evRENAME = 1, evRENAME = 1,
evCHANGE = 2 evCHANGE = 2
TFsEvent* {.pure, final, importc: "uv_fs_event_t", header: "uv.h".} = object TFsEvent* {.pure, final, importc: "uv_fs_event_t", header: "uv.h".} = object
loop* {.importc: "loop".}: PLoop loop* {.importc: "loop".}: PLoop
typ* {.importc: "type".}: THandleType typ* {.importc: "type".}: HandleType
close_cb* {.importc: "close_cb".}: CloseProc close_cb* {.importc: "close_cb".}: CloseProc
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
filename {.importc: "filename".}: cstring filename {.importc: "filename".}: cstring
PFsEvent* = ptr TFsEvent PFsEvent* = ptr TFsEvent
TFsEvents* {.pure, final, importc: "uv_fs_event_t", header: "uv.h".} = object FsEvents* {.pure, final, importc: "uv_fs_event_t", header: "uv.h".} = object
loop* {.importc: "loop".}: PLoop loop* {.importc: "loop".}: PLoop
typ* {.importc: "type".}: THandleType typ* {.importc: "type".}: HandleType
close_cb* {.importc: "close_cb".}: CloseProc close_cb* {.importc: "close_cb".}: CloseProc
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
filename* {.importc: "filename".}: cstring filename* {.importc: "filename".}: cstring
TBuf* {.pure, final, importc: "uv_buf_t", header: "uv.h"} = object Buf* {.pure, final, importc: "uv_buf_t", header: "uv.h"} = object
base* {.importc: "base".}: cstring base* {.importc: "base".}: cstring
len* {.importc: "len".}: csize len* {.importc: "len".}: csize
TAnyHandle* {.pure, final, importc: "uv_any_handle", header: "uv.h".} = object AnyHandle* {.pure, final, importc: "uv_any_handle", header: "uv.h".} = object
tcp* {.importc: "tcp".}: TTcp tcp* {.importc: "tcp".}: TTcp
pipe* {.importc: "pipe".}: TPipe pipe* {.importc: "pipe".}: Pipe
prepare* {.importc: "prepare".}: TPrepare prepare* {.importc: "prepare".}: TPrepare
check* {.importc: "check".}: TCheck check* {.importc: "check".}: TCheck
idle* {.importc: "idle".}: TIdle idle* {.importc: "idle".}: TIdle
async* {.importc: "async".}: TAsync async* {.importc: "async".}: TAsync
timer* {.importc: "timer".}: TTimer timer* {.importc: "timer".}: TTimer
getaddrinfo* {.importc: "getaddrinfo".}: TGetaddrinfo getaddrinfo* {.importc: "getaddrinfo".}: Getaddrinfo
fs_event* {.importc: "fs_event".}: TFsEvents fs_event* {.importc: "fs_event".}: FsEvents
TAnyReq* {.pure, final, importc: "uv_any_req", header: "uv.h".} = object AnyReq* {.pure, final, importc: "uv_any_req", header: "uv.h".} = object
req* {.importc: "req".}: TReq req* {.importc: "req".}: Req
write* {.importc: "write".}: TWrite write* {.importc: "write".}: Write
connect* {.importc: "connect".}: TConnect connect* {.importc: "connect".}: Connect
shutdown* {.importc: "shutdown".}: TShutdown shutdown* {.importc: "shutdown".}: Shutdown
fs_req* {.importc: "fs_req".}: Tfs fs_req* {.importc: "fs_req".}: Fs
work_req* {.importc: "work_req".}: TWork work_req* {.importc: "work_req".}: Work
## better import this ## better import this
uint64 = int64 uint64 = int64
TCounters* {.pure, final, importc: "uv_counters_t", header: "uv.h".} = object Counters* {.pure, final, importc: "uv_counters_t", header: "uv.h".} = object
eio_init* {.importc: "eio_init".}: uint64 eio_init* {.importc: "eio_init".}: uint64
req_init* {.importc: "req_init".}: uint64 req_init* {.importc: "req_init".}: uint64
handle_init* {.importc: "handle_init".}: uint64 handle_init* {.importc: "handle_init".}: uint64
@ -135,36 +135,36 @@ type
process_init* {.importc: "process_init".}: uint64 process_init* {.importc: "process_init".}: uint64
fs_event_init* {.importc: "fs_event_init".}: uint64 fs_event_init* {.importc: "fs_event_init".}: uint64
TLoop* {.pure, final, importc: "uv_loop_t", header: "uv.h".} = object Loop* {.pure, final, importc: "uv_loop_t", header: "uv.h".} = object
# ares_handles_* {.importc: "uv_ares_handles_".}: pointer # XXX: This seems to be a private field? # ares_handles_* {.importc: "uv_ares_handles_".}: pointer # XXX: This seems to be a private field?
eio_want_poll_notifier* {.importc: "uv_eio_want_poll_notifier".}: TAsync eio_want_poll_notifier* {.importc: "uv_eio_want_poll_notifier".}: TAsync
eio_done_poll_notifier* {.importc: "uv_eio_done_poll_notifier".}: TAsync eio_done_poll_notifier* {.importc: "uv_eio_done_poll_notifier".}: TAsync
eio_poller* {.importc: "uv_eio_poller".}: TIdle eio_poller* {.importc: "uv_eio_poller".}: TIdle
counters* {.importc: "counters".}: TCounters counters* {.importc: "counters".}: Counters
last_err* {.importc: "last_err".}: TErr last_err* {.importc: "last_err".}: Err
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
PLoop* = ptr TLoop PLoop* = ptr Loop
TShutdown* {.pure, final, importc: "uv_shutdown_t", header: "uv.h".} = object Shutdown* {.pure, final, importc: "uv_shutdown_t", header: "uv.h".} = object
typ* {.importc: "type".}: TReqType typ* {.importc: "type".}: ReqType
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
handle* {.importc: "handle".}: PStream handle* {.importc: "handle".}: PStream
cb* {.importc: "cb".}: ShutdownProc cb* {.importc: "cb".}: ShutdownProc
PShutdown* = ptr TShutdown PShutdown* = ptr Shutdown
THandle* {.pure, final, importc: "uv_handle_t", header: "uv.h".} = object Handle* {.pure, final, importc: "uv_handle_t", header: "uv.h".} = object
loop* {.importc: "loop".}: PLoop loop* {.importc: "loop".}: PLoop
typ* {.importc: "type".}: THandleType typ* {.importc: "type".}: HandleType
close_cb* {.importc: "close_cb".}: CloseProc close_cb* {.importc: "close_cb".}: CloseProc
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
PHandle* = ptr THandle PHandle* = ptr Handle
TStream* {.pure, final, importc: "uv_stream_t", header: "uv.h".} = object Stream* {.pure, final, importc: "uv_stream_t", header: "uv.h".} = object
loop* {.importc: "loop".}: PLoop loop* {.importc: "loop".}: PLoop
typ* {.importc: "type".}: THandleType typ* {.importc: "type".}: HandleType
alloc_cb* {.importc: "alloc_cb".}: AllocProc alloc_cb* {.importc: "alloc_cb".}: AllocProc
read_cb* {.importc: "read_cb".}: ReadProc read_cb* {.importc: "read_cb".}: ReadProc
read2_cb* {.importc: "read2_cb".}: ReadProc2 read2_cb* {.importc: "read2_cb".}: ReadProc2
@ -172,20 +172,20 @@ type
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
write_queue_size* {.importc: "write_queue_size".}: csize write_queue_size* {.importc: "write_queue_size".}: csize
PStream* = ptr TStream PStream* = ptr Stream
TWrite* {.pure, final, importc: "uv_write_t", header: "uv.h".} = object Write* {.pure, final, importc: "uv_write_t", header: "uv.h".} = object
typ* {.importc: "type".}: TReqType typ* {.importc: "type".}: ReqType
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
cb* {.importc: "cb".}: WriteProc cb* {.importc: "cb".}: WriteProc
send_handle* {.importc: "send_handle".}: PStream send_handle* {.importc: "send_handle".}: PStream
handle* {.importc: "handle".}: PStream handle* {.importc: "handle".}: PStream
PWrite* = ptr TWrite PWrite* = ptr Write
TTcp* {.pure, final, importc: "uv_tcp_t", header: "uv.h".} = object TTcp* {.pure, final, importc: "uv_tcp_t", header: "uv.h".} = object
loop* {.importc: "loop".}: PLoop loop* {.importc: "loop".}: PLoop
typ* {.importc: "type".}: THandleType typ* {.importc: "type".}: HandleType
alloc_cb* {.importc: "alloc_cb".}: AllocProc alloc_cb* {.importc: "alloc_cb".}: AllocProc
read_cb* {.importc: "read_cb".}: ReadProc read_cb* {.importc: "read_cb".}: ReadProc
read2_cb* {.importc: "read2_cb".}: ReadProc2 read2_cb* {.importc: "read2_cb".}: ReadProc2
@ -195,42 +195,42 @@ type
PTcp* = ptr TTcp PTcp* = ptr TTcp
TConnect* {.pure, final, importc: "uv_connect_t", header: "uv.h".} = object Connect* {.pure, final, importc: "uv_connect_t", header: "uv.h".} = object
typ* {.importc: "type".}: TReqType typ* {.importc: "type".}: ReqType
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
cb* {.importc: "cb".}: ConnectProc cb* {.importc: "cb".}: ConnectProc
handle* {.importc: "handle".}: PStream handle* {.importc: "handle".}: PStream
PConnect* = ptr TConnect PConnect* = ptr Connect
TUdpFlags* = enum UdpFlags* = enum
UDP_IPV6ONLY = 1, UDP_PARTIAL = 2 UDP_IPV6ONLY = 1, UDP_PARTIAL = 2
## XXX: better import this ## XXX: better import this
cunsigned = int cunsigned = int
UdpSendProc* = proc (req: PUdpSend, status: cint) UdpSendProc* = proc (req: PUdpSend, status: cint)
UdpRecvProc* = proc (handle: PUdp, nread: cssize, buf: TBuf, adr: ptr SockAddr, flags: cunsigned) UdpRecvProc* = proc (handle: PUdp, nread: cssize, buf: Buf, adr: ptr SockAddr, flags: cunsigned)
TUdp* {.pure, final, importc: "uv_udp_t", header: "uv.h".} = object TUdp* {.pure, final, importc: "uv_udp_t", header: "uv.h".} = object
loop* {.importc: "loop".}: PLoop loop* {.importc: "loop".}: PLoop
typ* {.importc: "type".}: THandleType typ* {.importc: "type".}: HandleType
close_cb* {.importc: "close_cb".}: CloseProc close_cb* {.importc: "close_cb".}: CloseProc
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
PUdp* = ptr TUdp PUdp* = ptr TUdp
TUdpSend* {.pure, final, importc: "uv_udp_send_t", header: "uv.h".} = object UdpSend* {.pure, final, importc: "uv_udp_send_t", header: "uv.h".} = object
typ* {.importc: "type".}: TReqType typ* {.importc: "type".}: ReqType
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
handle* {.importc: "handle".}: PUdp handle* {.importc: "handle".}: PUdp
cb* {.importc: "cb".}: UdpSendProc cb* {.importc: "cb".}: UdpSendProc
PUdpSend* = ptr TUdpSend PUdpSend* = ptr UdpSend
tTTy* {.pure, final, importc: "uv_tty_t", header: "uv.h".} = object tTTy* {.pure, final, importc: "uv_tty_t", header: "uv.h".} = object
loop* {.importc: "loop".}: PLoop loop* {.importc: "loop".}: PLoop
typ* {.importc: "type".}: THandleType typ* {.importc: "type".}: HandleType
alloc_cb* {.importc: "alloc_cb".}: AllocProc alloc_cb* {.importc: "alloc_cb".}: AllocProc
read_cb* {.importc: "read_cb".}: ReadProc read_cb* {.importc: "read_cb".}: ReadProc
read2_cb* {.importc: "read2_cb".}: ReadProc2 read2_cb* {.importc: "read2_cb".}: ReadProc2
@ -240,9 +240,9 @@ type
pTTy* = ptr tTTy pTTy* = ptr tTTy
TPipe* {.pure, final, importc: "uv_pipe_t", header: "uv.h".} = object Pipe* {.pure, final, importc: "uv_pipe_t", header: "uv.h".} = object
loop* {.importc: "loop".}: PLoop loop* {.importc: "loop".}: PLoop
typ* {.importc: "type".}: THandleType typ* {.importc: "type".}: HandleType
alloc_cb* {.importc: "alloc_cb".}: AllocProc alloc_cb* {.importc: "alloc_cb".}: AllocProc
read_cb* {.importc: "read_cb".}: ReadProc read_cb* {.importc: "read_cb".}: ReadProc
read2_cb* {.importc: "read2_cb".}: ReadProc2 read2_cb* {.importc: "read2_cb".}: ReadProc2
@ -251,11 +251,11 @@ type
write_queue_size* {.importc: "write_queue_size".}: csize write_queue_size* {.importc: "write_queue_size".}: csize
ipc {.importc: "ipc".}: int ipc {.importc: "ipc".}: int
PPipe* = ptr TPipe PPipe* = ptr Pipe
TPrepare* {.pure, final, importc: "uv_prepare_t", header: "uv.h".} = object TPrepare* {.pure, final, importc: "uv_prepare_t", header: "uv.h".} = object
loop* {.importc: "loop".}: PLoop loop* {.importc: "loop".}: PLoop
typ* {.importc: "type".}: THandleType typ* {.importc: "type".}: HandleType
close_cb* {.importc: "close_cb".}: CloseProc close_cb* {.importc: "close_cb".}: CloseProc
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
@ -263,7 +263,7 @@ type
TCheck* {.pure, final, importc: "uv_check_t", header: "uv.h".} = object TCheck* {.pure, final, importc: "uv_check_t", header: "uv.h".} = object
loop* {.importc: "loop".}: PLoop loop* {.importc: "loop".}: PLoop
typ* {.importc: "type".}: THandleType typ* {.importc: "type".}: HandleType
close_cb* {.importc: "close_cb".}: CloseProc close_cb* {.importc: "close_cb".}: CloseProc
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
@ -271,7 +271,7 @@ type
TIdle* {.pure, final, importc: "uv_idle_t", header: "uv.h".} = object TIdle* {.pure, final, importc: "uv_idle_t", header: "uv.h".} = object
loop* {.importc: "loop".}: PLoop loop* {.importc: "loop".}: PLoop
typ* {.importc: "type".}: THandleType typ* {.importc: "type".}: HandleType
close_cb* {.importc: "close_cb".}: CloseProc close_cb* {.importc: "close_cb".}: CloseProc
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
@ -279,7 +279,7 @@ type
TAsync* {.pure, final, importc: "uv_async_t", header: "uv.h".} = object TAsync* {.pure, final, importc: "uv_async_t", header: "uv.h".} = object
loop* {.importc: "loop".}: PLoop loop* {.importc: "loop".}: PLoop
typ* {.importc: "type".}: THandleType typ* {.importc: "type".}: HandleType
close_cb* {.importc: "close_cb".}: CloseProc close_cb* {.importc: "close_cb".}: CloseProc
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
@ -287,20 +287,20 @@ type
TTimer* {.pure, final, importc: "uv_timer_t", header: "uv.h".} = object TTimer* {.pure, final, importc: "uv_timer_t", header: "uv.h".} = object
loop* {.importc: "loop".}: PLoop loop* {.importc: "loop".}: PLoop
typ* {.importc: "type".}: THandleType typ* {.importc: "type".}: HandleType
close_cb* {.importc: "close_cb".}: CloseProc close_cb* {.importc: "close_cb".}: CloseProc
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
PTimer* = ptr TTimer PTimer* = ptr TTimer
TGetAddrInfo* {.pure, final, importc: "uv_getaddrinfo_t", header: "uv.h".} = object GetAddrInfo* {.pure, final, importc: "uv_getaddrinfo_t", header: "uv.h".} = object
typ* {.importc: "type".}: TReqType typ* {.importc: "type".}: ReqType
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
loop* {.importc: "loop".}: PLoop loop* {.importc: "loop".}: PLoop
PGetAddrInfo* = ptr TGetAddrInfo PGetAddrInfo* = ptr GetAddrInfo
TProcessOptions* {.pure, final, importc: "uv_process_options_t", header: "uv.h".} = object ProcessOptions* {.pure, final, importc: "uv_process_options_t", header: "uv.h".} = object
exit_cb* {.importc: "exit_cb".}: ExitProc exit_cb* {.importc: "exit_cb".}: ExitProc
file* {.importc: "file".}: cstring file* {.importc: "file".}: cstring
args* {.importc: "args".}: cstringArray args* {.importc: "args".}: cstringArray
@ -311,11 +311,11 @@ type
stdout_stream* {.importc: "stdout_stream".}: PPipe stdout_stream* {.importc: "stdout_stream".}: PPipe
stderr_stream* {.importc: "stderr_stream".}: PPipe stderr_stream* {.importc: "stderr_stream".}: PPipe
PProcessOptions* = ptr TProcessOptions PProcessOptions* = ptr ProcessOptions
TProcess* {.pure, final, importc: "uv_process_t", header: "uv.h".} = object TProcess* {.pure, final, importc: "uv_process_t", header: "uv.h".} = object
loop* {.importc: "loop".}: PLoop loop* {.importc: "loop".}: PLoop
typ* {.importc: "type".}: THandleType typ* {.importc: "type".}: HandleType
close_cb* {.importc: "close_cb".}: CloseProc close_cb* {.importc: "close_cb".}: CloseProc
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
exit_cb* {.importc: "exit_cb".}: ExitProc exit_cb* {.importc: "exit_cb".}: ExitProc
@ -323,47 +323,47 @@ type
PProcess* = ptr TProcess PProcess* = ptr TProcess
TWork* {.pure, final, importc: "uv_work_t", header: "uv.h".} = object Work* {.pure, final, importc: "uv_work_t", header: "uv.h".} = object
typ* {.importc: "type".}: TReqType typ* {.importc: "type".}: ReqType
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
loop* {.importc: "loop".}: PLoop loop* {.importc: "loop".}: PLoop
work_cb* {.importc: "work_cb".}: WorkProc work_cb* {.importc: "work_cb".}: WorkProc
after_work_cb* {.importc: "after_work_cb".}: AfterWorkProc after_work_cb* {.importc: "after_work_cb".}: AfterWorkProc
PWork* = ptr TWork PWork* = ptr Work
TFsType* {.size: sizeof(cint).} = enum FsType* {.size: sizeof(cint).} = enum
FS_UNKNOWN = - 1, FS_CUSTOM, FS_OPEN, FS_CLOSE, FS_READ, FS_WRITE, FS_UNKNOWN = - 1, FS_CUSTOM, FS_OPEN, FS_CLOSE, FS_READ, FS_WRITE,
FS_SENDFILE, FS_STAT, FS_LSTAT, FS_FSTAT, FS_FTRUNCATE, FS_UTIME, FS_FUTIME, FS_SENDFILE, FS_STAT, FS_LSTAT, FS_FSTAT, FS_FTRUNCATE, FS_UTIME, FS_FUTIME,
FS_CHMOD, FS_FCHMOD, FS_FSYNC, FS_FDATASYNC, FS_UNLINK, FS_RMDIR, FS_MKDIR, FS_CHMOD, FS_FCHMOD, FS_FSYNC, FS_FDATASYNC, FS_UNLINK, FS_RMDIR, FS_MKDIR,
FS_RENAME, FS_READDIR, FS_LINK, FS_SYMLINK, FS_READLINK, FS_CHOWN, FS_FCHOWN FS_RENAME, FS_READDIR, FS_LINK, FS_SYMLINK, FS_READLINK, FS_CHOWN, FS_FCHOWN
TFS* {.pure, final, importc: "uv_fs_t", header: "uv.h".} = object FS* {.pure, final, importc: "uv_fs_t", header: "uv.h".} = object
typ* {.importc: "type".}: TReqType typ* {.importc: "type".}: ReqType
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
loop* {.importc: "loop".}: PLoop loop* {.importc: "loop".}: PLoop
fs_type* {.importc: "fs_type".}: TFsType fs_type* {.importc: "fs_type".}: FsType
cb* {.importc: "cb".}: FsProc cb* {.importc: "cb".}: FsProc
result* {.importc: "result".}: cssize result* {.importc: "result".}: cssize
fsPtr* {.importc: "ptr".}: pointer fsPtr* {.importc: "ptr".}: pointer
path* {.importc: "path".}: cstring path* {.importc: "path".}: cstring
errorno* {.importc: "errorno".}: cint errorno* {.importc: "errorno".}: cint
PFS* = ptr TFS PFS* = ptr FS
TReq* {.pure, final, importc: "uv_req_t", header: "uv.h".} = object Req* {.pure, final, importc: "uv_req_t", header: "uv.h".} = object
typ* {.importc: "type".}: TReqType typ* {.importc: "type".}: ReqType
data* {.importc: "data".}: pointer data* {.importc: "data".}: pointer
PReq* = ptr TReq PReq* = ptr Req
TAresOptions* {.pure, final, importc: "ares_options", header: "uv.h".} = object AresOptions* {.pure, final, importc: "ares_options", header: "uv.h".} = object
flags* {.importc: "flags".}: int flags* {.importc: "flags".}: int
timeout* {.importc: "timeout".}: int timeout* {.importc: "timeout".}: int
tries* {.importc: "tries".}: int tries* {.importc: "tries".}: int
ndots* {.importc: "ndots".}: int ndots* {.importc: "ndots".}: int
udp_port* {.importc: "udp_port".}: TPort udp_port* {.importc: "udp_port".}: Port
tcp_port* {.importc: "tcp_port".}: TPort tcp_port* {.importc: "tcp_port".}: Port
socket_send_buffer_size* {.importc: "socket_send_buffer_size".}: int socket_send_buffer_size* {.importc: "socket_send_buffer_size".}: int
socket_recv_buffer_size* {.importc: "socket_receive_buffer_size".}: int socket_recv_buffer_size* {.importc: "socket_receive_buffer_size".}: int
servers* {.importc: "servers".}: ptr InAddr servers* {.importc: "servers".}: ptr InAddr
@ -378,8 +378,30 @@ type
#struct apattern *sortlist; #struct apattern *sortlist;
#int nsort; #int nsort;
PAresOptions* = ptr TAresOptions PAresOptions* = ptr AresOptions
PAresChannel* = pointer PAresChannel* = pointer
{.deprecated: [THandle: Handle, THandleType: HandleType, TAnyHandle: AnyHandle,
TAnyReq: AnyReq, TPort: Port, TErrorCode: ErrorCode, TReqType: ReqType,
TErr: Err, TFsEventType: FsEventType,
# TFsEvent: FsEvent, # Name conflict if we drop `T`
TFsEvents: FsEvents, TBuf: Buf, TCounters: Counters, TLoop: Loop,
TShutdown: Shutdown, TStream: Stream, TWrite: Write,
# TTcp: Tcp, # Name conflict if we drop `T`
TConnect: Connect,
TUdpFlags: UdpFlags,
# TUdp: Udp, # Name conflict if we drop `T`
TUdpSend: UdpSend,
# tTTy: TTy, # Name conflict if we drop `T`
TPipe: Pipe,
# TPrepare: Prepare, # Name conflict if we drop `T`
# TCheck: Check, # Name conflict if we drop `T`
# TIdle: Idle, # Name conflict if we drop `T`
# TAsync: Async, # Name conflict if we drop `T`
# TTimer: Timer, # Name conflict if we drop `T`
TGetAddrInfo: GetAddrInfo, TProcessOptions: ProcessOptions,
# TProcess: Process, # Name conflict if we drop `T`
TWork: Work,
TFsType: FsType, TFS: FS, TReq: Req, TAresOptions: AresOptions].}
proc loop_new*(): PLoop{. proc loop_new*(): PLoop{.
importc: "uv_loop_new", header: "uv.h".} importc: "uv_loop_new", header: "uv.h".}
@ -405,13 +427,13 @@ proc update_time*(a2: PLoop){.
proc now*(a2: PLoop): int64{. proc now*(a2: PLoop): int64{.
importc: "uv_now", header: "uv.h".} importc: "uv_now", header: "uv.h".}
proc last_error*(a2: PLoop): TErr{. proc last_error*(a2: PLoop): Err{.
importc: "uv_last_error", header: "uv.h".} importc: "uv_last_error", header: "uv.h".}
proc strerror*(err: TErr): cstring{. proc strerror*(err: Err): cstring{.
importc: "uv_strerror", header: "uv.h".} importc: "uv_strerror", header: "uv.h".}
proc err_name*(err: TErr): cstring{. proc err_name*(err: Err): cstring{.
importc: "uv_err_name", header: "uv.h".} importc: "uv_err_name", header: "uv.h".}
proc shutdown*(req: PShutdown, handle: PStream, cb: ShutdownProc): cint{. proc shutdown*(req: PShutdown, handle: PStream, cb: ShutdownProc): cint{.
@ -423,7 +445,7 @@ proc is_active*(handle: PHandle): cint{.
proc close*(handle: PHandle, close_cb: CloseProc){. proc close*(handle: PHandle, close_cb: CloseProc){.
importc: "uv_close", header: "uv.h".} importc: "uv_close", header: "uv.h".}
proc buf_init*(base: cstring, len: csize): TBuf{. proc buf_init*(base: cstring, len: csize): Buf{.
importc: "uv_buf_init", header: "uv.h".} importc: "uv_buf_init", header: "uv.h".}
proc listen*(stream: PStream, backlog: cint, cb: ConnectionProc): cint{. proc listen*(stream: PStream, backlog: cint, cb: ConnectionProc): cint{.
@ -441,10 +463,10 @@ proc read_start*(a2: PStream, alloc_cb: AllocProc, read_cb: ReadProc2): cint{.
proc read_stop*(a2: PStream): cint{. proc read_stop*(a2: PStream): cint{.
importc: "uv_read_stop", header: "uv.h".} importc: "uv_read_stop", header: "uv.h".}
proc write*(req: PWrite, handle: PStream, bufs: ptr TBuf, bufcnt: cint, cb: WriteProc): cint{. proc write*(req: PWrite, handle: PStream, bufs: ptr Buf, bufcnt: cint, cb: WriteProc): cint{.
importc: "uv_write", header: "uv.h".} importc: "uv_write", header: "uv.h".}
proc write*(req: PWrite, handle: PStream, bufs: ptr TBuf, bufcnt: cint, send_handle: PStream, cb: WriteProc): cint{. proc write*(req: PWrite, handle: PStream, bufs: ptr Buf, bufcnt: cint, send_handle: PStream, cb: WriteProc): cint{.
importc: "uv_write2", header: "uv.h".} importc: "uv_write2", header: "uv.h".}
proc tcp_init*(a2: PLoop, handle: PTcp): cint{. proc tcp_init*(a2: PLoop, handle: PTcp): cint{.
@ -480,10 +502,10 @@ proc udp_bind6*(handle: PUdp, adr: TSockAddrIn6, flags: cunsigned): cint{.
proc udp_getsockname*(handle: PUdp, name: ptr SockAddr, namelen: var cint): cint{. proc udp_getsockname*(handle: PUdp, name: ptr SockAddr, namelen: var cint): cint{.
importc: "uv_udp_getsockname", header: "uv.h".} importc: "uv_udp_getsockname", header: "uv.h".}
proc udp_send*(req: PUdpSend, handle: PUdp, bufs: ptr TBuf, bufcnt: cint, adr: SockAddrIn, send_cb: UdpSendProc): cint{. proc udp_send*(req: PUdpSend, handle: PUdp, bufs: ptr Buf, bufcnt: cint, adr: SockAddrIn, send_cb: UdpSendProc): cint{.
importc: "uv_udp_send", header: "uv.h".} importc: "uv_udp_send", header: "uv.h".}
proc udp_send6*(req: PUdpSend, handle: PUdp, bufs: ptr TBuf, bufcnt: cint, adr: TSockAddrIn6, send_cb: UdpSendProc): cint{. proc udp_send6*(req: PUdpSend, handle: PUdp, bufs: ptr Buf, bufcnt: cint, adr: TSockAddrIn6, send_cb: UdpSendProc): cint{.
importc: "uv_udp_send6", header: "uv.h".} importc: "uv_udp_send6", header: "uv.h".}
proc udp_recv_start*(handle: PUdp, alloc_cb: AllocProc, recv_cb: UdpRecvProc): cint{. proc udp_recv_start*(handle: PUdp, alloc_cb: AllocProc, recv_cb: UdpRecvProc): cint{.
@ -504,7 +526,7 @@ proc tty_get_winsize*(a2: pTTy, width: var cint, height: var cint): cint{.
proc tty_reset_mode*() {. proc tty_reset_mode*() {.
importc: "uv_tty_reset_mode", header: "uv.h".} importc: "uv_tty_reset_mode", header: "uv.h".}
proc guess_handle*(file: File): THandleType{. proc guess_handle*(file: File): HandleType{.
importc: "uv_guess_handle", header: "uv.h".} importc: "uv_guess_handle", header: "uv.h".}
proc pipe_init*(a2: PLoop, handle: PPipe, ipc: int): cint{. proc pipe_init*(a2: PLoop, handle: PPipe, ipc: int): cint{.
@ -582,7 +604,7 @@ proc getaddrinfo*(a2: PLoop, handle: PGetAddrInfo,getaddrinfo_cb: GetAddrInfoPro
proc freeaddrinfo*(ai: ptr AddrInfo){. proc freeaddrinfo*(ai: ptr AddrInfo){.
importc: "uv_freeaddrinfo", header: "uv.h".} importc: "uv_freeaddrinfo", header: "uv.h".}
proc spawn*(a2: PLoop, a3: PProcess, options: TProcessOptions): cint{. proc spawn*(a2: PLoop, a3: PProcess, options: ProcessOptions): cint{.
importc: "uv_spawn", header: "uv.h".} importc: "uv_spawn", header: "uv.h".}
proc process_kill*(a2: PProcess, signum: cint): cint{. proc process_kill*(a2: PProcess, signum: cint): cint{.

286
lib/wrappers/mysql.nim
View file

@ -51,7 +51,7 @@ const
SERVICENAME* = "MySQL" SERVICENAME* = "MySQL"
type type
Tenum_server_command* = enum Enum_server_command* = enum
COM_SLEEP, COM_QUIT, COM_INIT_DB, COM_QUERY, COM_FIELD_LIST, COM_CREATE_DB, COM_SLEEP, COM_QUIT, COM_INIT_DB, COM_QUERY, COM_FIELD_LIST, COM_CREATE_DB,
COM_DROP_DB, COM_REFRESH, COM_SHUTDOWN, COM_STATISTICS, COM_PROCESS_INFO, COM_DROP_DB, COM_REFRESH, COM_SHUTDOWN, COM_STATISTICS, COM_PROCESS_INFO,
COM_CONNECT, COM_PROCESS_KILL, COM_DEBUG, COM_PING, COM_TIME, COM_CONNECT, COM_PROCESS_KILL, COM_DEBUG, COM_PING, COM_TIME,
@ -59,6 +59,7 @@ type
COM_CONNECT_OUT, COM_REGISTER_SLAVE, COM_STMT_PREPARE, COM_STMT_EXECUTE, COM_CONNECT_OUT, COM_REGISTER_SLAVE, COM_STMT_PREPARE, COM_STMT_EXECUTE,
COM_STMT_SEND_LONG_DATA, COM_STMT_CLOSE, COM_STMT_RESET, COM_SET_OPTION, COM_STMT_SEND_LONG_DATA, COM_STMT_CLOSE, COM_STMT_RESET, COM_SET_OPTION,
COM_STMT_FETCH, COM_END COM_STMT_FETCH, COM_END
{.deprecated: [Tenum_server_command: Enum_server_command].}
const const
SCRAMBLE_LENGTH* = 20 # Length of random string sent by server on handshake; SCRAMBLE_LENGTH* = 20 # Length of random string sent by server on handshake;
@ -150,8 +151,8 @@ const
MAX_BLOB_WIDTH* = 8192 # Default width for blob MAX_BLOB_WIDTH* = 8192 # Default width for blob
type type
Pst_net* = ptr Tst_net Pst_net* = ptr St_net
Tst_net*{.final.} = object St_net*{.final.} = object
vio*: PVio vio*: PVio
buff*: cstring buff*: cstring
buff_end*: cstring buff_end*: cstring
@ -191,14 +192,15 @@ type
report_error*: my_bool # We should report error (we have unreported error) report_error*: my_bool # We should report error (we have unreported error)
return_errno*: my_bool return_errno*: my_bool
TNET* = Tst_net NET* = St_net
PNET* = ptr TNET PNET* = ptr NET
{.deprecated: [Tst_net: St_net, TNET: NET].}
const const
packet_error* = - 1 packet_error* = - 1
type type
Tenum_field_types* = enum # For backward compatibility Enum_field_types* = enum # For backward compatibility
TYPE_DECIMAL, TYPE_TINY, TYPE_SHORT, TYPE_LONG, TYPE_FLOAT, TYPE_DOUBLE, TYPE_DECIMAL, TYPE_TINY, TYPE_SHORT, TYPE_LONG, TYPE_FLOAT, TYPE_DOUBLE,
TYPE_NULL, TYPE_TIMESTAMP, TYPE_LONGLONG, TYPE_INT24, TYPE_DATE, TYPE_TIME, TYPE_NULL, TYPE_TIMESTAMP, TYPE_LONGLONG, TYPE_INT24, TYPE_DATE, TYPE_TIME,
TYPE_DATETIME, TYPE_YEAR, TYPE_NEWDATE, TYPE_VARCHAR, TYPE_BIT, TYPE_DATETIME, TYPE_YEAR, TYPE_NEWDATE, TYPE_VARCHAR, TYPE_BIT,
@ -206,6 +208,7 @@ type
TYPE_TINY_BLOB = 249, TYPE_MEDIUM_BLOB = 250, TYPE_LONG_BLOB = 251, TYPE_TINY_BLOB = 249, TYPE_MEDIUM_BLOB = 250, TYPE_LONG_BLOB = 251,
TYPE_BLOB = 252, TYPE_VAR_STRING = 253, TYPE_STRING = 254, TYPE_BLOB = 252, TYPE_VAR_STRING = 253, TYPE_STRING = 254,
TYPE_GEOMETRY = 255 TYPE_GEOMETRY = 255
{.deprecated: [Tenum_field_types: Enum_field_types].}
const const
CLIENT_MULTI_QUERIES* = CLIENT_MULTI_STATEMENTS CLIENT_MULTI_QUERIES* = CLIENT_MULTI_STATEMENTS
@ -244,16 +247,19 @@ const
SHUTDOWN_KILLABLE_UPDATE* = chr(1 shl 3) SHUTDOWN_KILLABLE_UPDATE* = chr(1 shl 3)
type type
Tenum_shutdown_level* = enum Enum_shutdown_level* = enum
SHUTDOWN_DEFAULT = 0, SHUTDOWN_WAIT_CONNECTIONS = 1, SHUTDOWN_DEFAULT = 0, SHUTDOWN_WAIT_CONNECTIONS = 1,
SHUTDOWN_WAIT_TRANSACTIONS = 2, SHUTDOWN_WAIT_UPDATES = 8, SHUTDOWN_WAIT_TRANSACTIONS = 2, SHUTDOWN_WAIT_UPDATES = 8,
SHUTDOWN_WAIT_ALL_BUFFERS = 16, SHUTDOWN_WAIT_CRITICAL_BUFFERS = 17, SHUTDOWN_WAIT_ALL_BUFFERS = 16, SHUTDOWN_WAIT_CRITICAL_BUFFERS = 17,
KILL_QUERY = 254, KILL_CONNECTION = 255 KILL_QUERY = 254, KILL_CONNECTION = 255
Tenum_cursor_type* = enum # options for mysql_set_option Enum_cursor_type* = enum # options for mysql_set_option
CURSOR_TYPE_NO_CURSOR = 0, CURSOR_TYPE_READ_ONLY = 1, CURSOR_TYPE_NO_CURSOR = 0, CURSOR_TYPE_READ_ONLY = 1,
CURSOR_TYPE_FOR_UPDATE = 2, CURSOR_TYPE_SCROLLABLE = 4 CURSOR_TYPE_FOR_UPDATE = 2, CURSOR_TYPE_SCROLLABLE = 4
Tenum_mysql_set_option* = enum Enum_mysql_set_option* = enum
OPTION_MULTI_STATEMENTS_ON, OPTION_MULTI_STATEMENTS_OFF OPTION_MULTI_STATEMENTS_ON, OPTION_MULTI_STATEMENTS_OFF
{.deprecated: [Tenum_shutdown_level: Enum_shutdown_level,
Tenum_cursor_type: Enum_cursor_type,
Tenum_mysql_set_option: Enum_mysql_set_option].}
proc my_net_init*(net: PNET, vio: PVio): my_bool{.cdecl, dynlib: lib, proc my_net_init*(net: PNET, vio: PVio): my_bool{.cdecl, dynlib: lib,
importc: "my_net_init".} importc: "my_net_init".}
@ -275,24 +281,25 @@ proc my_net_read*(net: PNET): int{.cdecl, dynlib: lib, importc: "my_net_read".}
# The following function is not meant for normal usage # The following function is not meant for normal usage
# Currently it's used internally by manager.c # Currently it's used internally by manager.c
type type
Psockaddr* = ptr Tsockaddr Psockaddr* = ptr Sockaddr
Tsockaddr*{.final.} = object # undefined structure Sockaddr*{.final.} = object # undefined structure
{.deprecated: [Tsockaddr: Sockaddr].}
proc my_connect*(s: my_socket, name: Psockaddr, namelen: cuint, timeout: cuint): cint{. proc my_connect*(s: my_socket, name: Psockaddr, namelen: cuint, timeout: cuint): cint{.
cdecl, dynlib: lib, importc: "my_connect".} cdecl, dynlib: lib, importc: "my_connect".}
type type
Prand_struct* = ptr Trand_struct Prand_struct* = ptr Rand_struct
Trand_struct*{.final.} = object # The following is for user defined functions Rand_struct*{.final.} = object # The following is for user defined functions
seed1*: int seed1*: int
seed2*: int seed2*: int
max_value*: int max_value*: int
max_value_dbl*: cdouble max_value_dbl*: cdouble
TItem_result* = enum Item_result* = enum
STRING_RESULT, REAL_RESULT, INT_RESULT, ROW_RESULT, DECIMAL_RESULT STRING_RESULT, REAL_RESULT, INT_RESULT, ROW_RESULT, DECIMAL_RESULT
PItem_result* = ptr TItem_result PItem_result* = ptr Item_result
Pst_udf_args* = ptr Tst_udf_args Pst_udf_args* = ptr St_udf_args
Tst_udf_args*{.final.} = object St_udf_args*{.final.} = object
arg_count*: cuint # Number of arguments arg_count*: cuint # Number of arguments
arg_type*: PItem_result # Pointer to item_results arg_type*: PItem_result # Pointer to item_results
args*: cstringArray # Pointer to item_results args*: cstringArray # Pointer to item_results
@ -301,18 +308,21 @@ type
attributes*: cstringArray # Pointer to attribute name attributes*: cstringArray # Pointer to attribute name
attribute_lengths*: ptr int # Length of attribute arguments attribute_lengths*: ptr int # Length of attribute arguments
TUDF_ARGS* = Tst_udf_args UDF_ARGS* = St_udf_args
PUDF_ARGS* = ptr TUDF_ARGS # This holds information about the result PUDF_ARGS* = ptr UDF_ARGS # This holds information about the result
Pst_udf_init* = ptr Tst_udf_init Pst_udf_init* = ptr St_udf_init
Tst_udf_init*{.final.} = object St_udf_init*{.final.} = object
maybe_null*: my_bool # 1 if function can return NULL maybe_null*: my_bool # 1 if function can return NULL
decimals*: cuint # for real functions decimals*: cuint # for real functions
max_length*: int # For string functions max_length*: int # For string functions
theptr*: cstring # free pointer for function data theptr*: cstring # free pointer for function data
const_item*: my_bool # free pointer for function data const_item*: my_bool # free pointer for function data
TUDF_INIT* = Tst_udf_init UDF_INIT* = St_udf_init
PUDF_INIT* = ptr TUDF_INIT # Constants when using compression PUDF_INIT* = ptr UDF_INIT # Constants when using compression
{.deprecated: [Trand_stuct: Rand_struct, TItem_result: Item_result,
Tst_udf_args: St_udf_args, TUDF_ARGS: UDF_ARGS,
Tst_udf_init: St_udf_init, TUDF_INIT: UDF_INIT].}
const const
NET_HEADER_SIZE* = 4 # standard header size NET_HEADER_SIZE* = 4 # standard header size
@ -386,8 +396,8 @@ const
CLIENT_NET_WRITE_TIMEOUT* = 365 * 24 * 3600 # Timeout on write CLIENT_NET_WRITE_TIMEOUT* = 365 * 24 * 3600 # Timeout on write
type type
Pst_mysql_field* = ptr Tst_mysql_field Pst_mysql_field* = ptr St_mysql_field
Tst_mysql_field*{.final.} = object St_mysql_field*{.final.} = object
name*: cstring # Name of column name*: cstring # Name of column
org_name*: cstring # Original column name, if an alias org_name*: cstring # Original column name, if an alias
table*: cstring # Table of column if column was a field table*: cstring # Table of column if column was a field
@ -407,19 +417,21 @@ type
flags*: cuint # Div flags flags*: cuint # Div flags
decimals*: cuint # Number of decimals in field decimals*: cuint # Number of decimals in field
charsetnr*: cuint # Character set charsetnr*: cuint # Character set
ftype*: Tenum_field_types # Type of field. See mysql_com.h for types ftype*: Enum_field_types # Type of field. See mysql_com.h for types
TFIELD* = Tst_mysql_field FIELD* = St_mysql_field
PFIELD* = ptr TFIELD PFIELD* = ptr FIELD
PROW* = ptr TROW # return data as array of strings PROW* = ptr ROW # return data as array of strings
TROW* = cstringArray ROW* = cstringArray
PFIELD_OFFSET* = ptr TFIELD_OFFSET # offset to current field PFIELD_OFFSET* = ptr FIELD_OFFSET # offset to current field
TFIELD_OFFSET* = cuint FIELD_OFFSET* = cuint
{.deprecated: [Tst_mysql_field: St_mysql_field, TFIELD: FIELD, TROW: ROW,
TFIELD_OFFSET: FIELD_OFFSET].}
proc IS_PRI_KEY*(n: int32): bool proc IS_PRI_KEY*(n: int32): bool
proc IS_NOT_NULL*(n: int32): bool proc IS_NOT_NULL*(n: int32): bool
proc IS_BLOB*(n: int32): bool proc IS_BLOB*(n: int32): bool
proc IS_NUM*(t: Tenum_field_types): bool proc IS_NUM*(t: Enum_field_types): bool
proc INTERNAL_NUM_FIELD*(f: Pst_mysql_field): bool proc INTERNAL_NUM_FIELD*(f: Pst_mysql_field): bool
proc IS_NUM_FIELD*(f: Pst_mysql_field): bool proc IS_NUM_FIELD*(f: Pst_mysql_field): bool
type type
@ -430,32 +442,34 @@ const
COUNT_ERROR* = not (my_ulonglong(0)) COUNT_ERROR* = not (my_ulonglong(0))
type type
Pst_mysql_rows* = ptr Tst_mysql_rows Pst_mysql_rows* = ptr St_mysql_rows
Tst_mysql_rows*{.final.} = object St_mysql_rows*{.final.} = object
next*: Pst_mysql_rows # list of rows next*: Pst_mysql_rows # list of rows
data*: TROW data*: ROW
len*: int len*: int
TROWS* = Tst_mysql_rows ROWS* = St_mysql_rows
PROWS* = ptr TROWS PROWS* = ptr ROWS
PROW_OFFSET* = ptr TROW_OFFSET # offset to current row PROW_OFFSET* = ptr ROW_OFFSET # offset to current row
TROW_OFFSET* = TROWS ROW_OFFSET* = ROWS
{.deprecated: [Tst_mysql_rows: St_mysql_rows, TROWS: ROWS,
TROW_OFFSET: ROW_OFFSET].}
const const
ALLOC_MAX_BLOCK_TO_DROP* = 4096 ALLOC_MAX_BLOCK_TO_DROP* = 4096
ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP* = 10 # struct for once_alloc (block) ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP* = 10 # struct for once_alloc (block)
type type
Pst_used_mem* = ptr Tst_used_mem Pst_used_mem* = ptr St_used_mem
Tst_used_mem*{.final.} = object St_used_mem*{.final.} = object
next*: Pst_used_mem # Next block in use next*: Pst_used_mem # Next block in use
left*: cuint # memory left in block left*: cuint # memory left in block
size*: cuint # size of block size*: cuint # size of block
TUSED_MEM* = Tst_used_mem USED_MEM* = St_used_mem
PUSED_MEM* = ptr TUSED_MEM PUSED_MEM* = ptr USED_MEM
Pst_mem_root* = ptr Tst_mem_root Pst_mem_root* = ptr St_mem_root
Tst_mem_root*{.final.} = object St_mem_root*{.final.} = object
free*: PUSED_MEM # blocks with free memory in it free*: PUSED_MEM # blocks with free memory in it
used*: PUSED_MEM # blocks almost without free memory used*: PUSED_MEM # blocks almost without free memory
pre_alloc*: PUSED_MEM # preallocated block pre_alloc*: PUSED_MEM # preallocated block
@ -467,27 +481,30 @@ type
first_block_usage*: cuint first_block_usage*: cuint
error_handler*: proc (){.cdecl.} error_handler*: proc (){.cdecl.}
TMEM_ROOT* = Tst_mem_root MEM_ROOT* = St_mem_root
PMEM_ROOT* = ptr TMEM_ROOT # ------------ Stop of declaration in "my_alloc.h" ---------------------- PMEM_ROOT* = ptr MEM_ROOT # ------------ Stop of declaration in "my_alloc.h" ----------------------
{.deprecated: [Tst_used_mem: St_used_mem, TUSED_MEM: USED_MEM,
Tst_mem_root: St_mem_root, TMEM_ROOT: MEM_ROOT].}
type type
Pst_mysql_data* = ptr Tst_mysql_data Pst_mysql_data* = ptr St_mysql_data
Tst_mysql_data*{.final.} = object St_mysql_data*{.final.} = object
rows*: my_ulonglong rows*: my_ulonglong
fields*: cuint fields*: cuint
data*: PROWS data*: PROWS
alloc*: TMEM_ROOT alloc*: MEM_ROOT
prev_ptr*: ptr PROWS prev_ptr*: ptr PROWS
TDATA* = Tst_mysql_data DATA* = St_mysql_data
PDATA* = ptr TDATA PDATA* = ptr DATA
Toption* = enum Option* = enum
OPT_CONNECT_TIMEOUT, OPT_COMPRESS, OPT_NAMED_PIPE, INIT_COMMAND, OPT_CONNECT_TIMEOUT, OPT_COMPRESS, OPT_NAMED_PIPE, INIT_COMMAND,
READ_DEFAULT_FILE, READ_DEFAULT_GROUP, SET_CHARSET_DIR, SET_CHARSET_NAME, READ_DEFAULT_FILE, READ_DEFAULT_GROUP, SET_CHARSET_DIR, SET_CHARSET_NAME,
OPT_LOCAL_INFILE, OPT_PROTOCOL, SHARED_MEMORY_BASE_NAME, OPT_READ_TIMEOUT, OPT_LOCAL_INFILE, OPT_PROTOCOL, SHARED_MEMORY_BASE_NAME, OPT_READ_TIMEOUT,
OPT_WRITE_TIMEOUT, OPT_USE_RESULT, OPT_USE_REMOTE_CONNECTION, OPT_WRITE_TIMEOUT, OPT_USE_RESULT, OPT_USE_REMOTE_CONNECTION,
OPT_USE_EMBEDDED_CONNECTION, OPT_GUESS_CONNECTION, SET_CLIENT_IP, OPT_USE_EMBEDDED_CONNECTION, OPT_GUESS_CONNECTION, SET_CLIENT_IP,
SECURE_AUTH, REPORT_DATA_TRUNCATION, OPT_RECONNECT SECURE_AUTH, REPORT_DATA_TRUNCATION, OPT_RECONNECT
{.deprecated: [Tst_mysql_data: St_mysql_data, TDATA: DATA, Toption: Option].}
const const
MAX_MYSQL_MANAGER_ERR* = 256 MAX_MYSQL_MANAGER_ERR* = 256
@ -499,17 +516,17 @@ const
MANAGER_INTERNAL_ERR* = 500 MANAGER_INTERNAL_ERR* = 500
type type
Tst_dynamic_array*{.final.} = object St_dynamic_array*{.final.} = object
buffer*: cstring buffer*: cstring
elements*: cuint elements*: cuint
max_element*: cuint max_element*: cuint
alloc_increment*: cuint alloc_increment*: cuint
size_of_element*: cuint size_of_element*: cuint
TDYNAMIC_ARRAY* = Tst_dynamic_array DYNAMIC_ARRAY* = St_dynamic_array
Pst_dynamic_array* = ptr Tst_dynamic_array Pst_dynamic_array* = ptr St_dynamic_array
Pst_mysql_options* = ptr Tst_mysql_options Pst_mysql_options* = ptr St_mysql_options
Tst_mysql_options*{.final.} = object St_mysql_options*{.final.} = object
connect_timeout*: cuint connect_timeout*: cuint
read_timeout*: cuint read_timeout*: cuint
write_timeout*: cuint write_timeout*: cuint
@ -543,7 +560,7 @@ type
# a read that is replication-aware # a read that is replication-aware
no_master_reads*: my_bool no_master_reads*: my_bool
separate_thread*: my_bool separate_thread*: my_bool
methods_to_use*: Toption methods_to_use*: Option
client_ip*: cstring client_ip*: cstring
secure_auth*: my_bool # Refuse client connecting to server if it uses old (pre-4.1.1) protocol secure_auth*: my_bool # Refuse client connecting to server if it uses old (pre-4.1.1) protocol
report_data_truncation*: my_bool # 0 - never report, 1 - always report (default) report_data_truncation*: my_bool # 0 - never report, 1 - always report (default)
@ -555,16 +572,16 @@ type
local_infile_error*: proc (para1: pointer, para2: cstring, para3: cuint): cint local_infile_error*: proc (para1: pointer, para2: cstring, para3: cuint): cint
local_infile_userdata*: pointer local_infile_userdata*: pointer
Tstatus* = enum Status* = enum
STATUS_READY, STATUS_GET_RESULT, STATUS_USE_RESULT STATUS_READY, STATUS_GET_RESULT, STATUS_USE_RESULT
Tprotocol_type* = enum # There are three types of queries - the ones that have to go to Protocol_type* = enum # There are three types of queries - the ones that have to go to
# the master, the ones that go to a slave, and the administrative # the master, the ones that go to a slave, and the administrative
# type which must happen on the pivot connectioin # type which must happen on the pivot connectioin
PROTOCOL_DEFAULT, PROTOCOL_TCP, PROTOCOL_SOCKET, PROTOCOL_PIPE, PROTOCOL_DEFAULT, PROTOCOL_TCP, PROTOCOL_SOCKET, PROTOCOL_PIPE,
PROTOCOL_MEMORY PROTOCOL_MEMORY
Trpl_type* = enum Rpl_type* = enum
RPL_MASTER, RPL_SLAVE, RPL_ADMIN RPL_MASTER, RPL_SLAVE, RPL_ADMIN
Tcharset_info_st*{.final.} = object Charset_info_st*{.final.} = object
number*: cuint number*: cuint
primary_number*: cuint primary_number*: cuint
binary_number*: cuint binary_number*: cuint
@ -592,10 +609,10 @@ type
cset*: pointer # was ^MY_CHARSET_HANDLER cset*: pointer # was ^MY_CHARSET_HANDLER
coll*: pointer # was ^MY_COLLATION_HANDLER; coll*: pointer # was ^MY_COLLATION_HANDLER;
TCHARSET_INFO* = Tcharset_info_st CHARSET_INFO* = Charset_info_st
Pcharset_info_st* = ptr Tcharset_info_st Pcharset_info_st* = ptr Charset_info_st
Pcharacter_set* = ptr Tcharacter_set Pcharacter_set* = ptr Character_set
Tcharacter_set*{.final.} = object Character_set*{.final.} = object
number*: cuint number*: cuint
state*: cuint state*: cuint
csname*: cstring csname*: cstring
@ -605,12 +622,12 @@ type
mbminlen*: cuint mbminlen*: cuint
mbmaxlen*: cuint mbmaxlen*: cuint
TMY_CHARSET_INFO* = Tcharacter_set MY_CHARSET_INFO* = Character_set
PMY_CHARSET_INFO* = ptr TMY_CHARSET_INFO PMY_CHARSET_INFO* = ptr MY_CHARSET_INFO
Pst_mysql_methods* = ptr Tst_mysql_methods Pst_mysql_methods* = ptr St_mysql_methods
Pst_mysql* = ptr Tst_mysql Pst_mysql* = ptr St_mysql
Tst_mysql*{.final.} = object St_mysql*{.final.} = object
net*: TNET # Communication parameters net*: NET # Communication parameters
connector_fd*: gptr # ConnectorFd for SSL connector_fd*: gptr # ConnectorFd for SSL
host*: cstring host*: cstring
user*: cstring user*: cstring
@ -622,7 +639,7 @@ type
db*: cstring db*: cstring
charset*: Pcharset_info_st charset*: Pcharset_info_st
fields*: PFIELD fields*: PFIELD
field_alloc*: TMEM_ROOT field_alloc*: MEM_ROOT
affected_rows*: my_ulonglong affected_rows*: my_ulonglong
insert_id*: my_ulonglong # id if insert on table with NEXTNR insert_id*: my_ulonglong # id if insert on table with NEXTNR
extra_info*: my_ulonglong # Used by mysqlshow, not used by mysql 5.0 and up extra_info*: my_ulonglong # Used by mysqlshow, not used by mysql 5.0 and up
@ -636,8 +653,8 @@ type
server_status*: cuint server_status*: cuint
server_language*: cuint server_language*: cuint
warning_count*: cuint warning_count*: cuint
options*: Tst_mysql_options options*: St_mysql_options
status*: Tstatus status*: Status
free_me*: my_bool # If free in mysql_close free_me*: my_bool # If free in mysql_close
reconnect*: my_bool # set to 1 if automatic reconnect reconnect*: my_bool # set to 1 if automatic reconnect
scramble*: array[0..(SCRAMBLE_LENGTH + 1) - 1, char] # session-wide random string scramble*: array[0..(SCRAMBLE_LENGTH + 1) - 1, char] # session-wide random string
@ -655,37 +672,37 @@ type
# from mysql_stmt_close if close had to cancel result set of this object. # from mysql_stmt_close if close had to cancel result set of this object.
unbuffered_fetch_owner*: Pmy_bool unbuffered_fetch_owner*: Pmy_bool
TMySQL* = Tst_mysql MySQL* = St_mysql
PMySQL* = ptr TMySQL PMySQL* = ptr MySQL
Pst_mysql_res* = ptr Tst_mysql_res Pst_mysql_res* = ptr St_mysql_res
Tst_mysql_res*{.final.} = object St_mysql_res*{.final.} = object
row_count*: my_ulonglong row_count*: my_ulonglong
fields*: PFIELD fields*: PFIELD
data*: PDATA data*: PDATA
data_cursor*: PROWS data_cursor*: PROWS
lengths*: ptr int # column lengths of current row lengths*: ptr int # column lengths of current row
handle*: PMySQL # for unbuffered reads handle*: PMySQL # for unbuffered reads
field_alloc*: TMEM_ROOT field_alloc*: MEM_ROOT
field_count*: cuint field_count*: cuint
current_field*: cuint current_field*: cuint
row*: TROW # If unbuffered read row*: ROW # If unbuffered read
current_row*: TROW # buffer to current row current_row*: ROW # buffer to current row
eof*: my_bool # Used by mysql_fetch_row eof*: my_bool # Used by mysql_fetch_row
unbuffered_fetch_cancelled*: my_bool # mysql_stmt_close() had to cancel this result unbuffered_fetch_cancelled*: my_bool # mysql_stmt_close() had to cancel this result
methods*: Pst_mysql_methods methods*: Pst_mysql_methods
TRES* = Tst_mysql_res RES* = St_mysql_res
PRES* = ptr TRES PRES* = ptr RES
Pst_mysql_stmt* = ptr Tst_mysql_stmt Pst_mysql_stmt* = ptr St_mysql_stmt
PSTMT* = ptr TSTMT PSTMT* = ptr STMT
Tst_mysql_methods*{.final.} = object St_mysql_methods*{.final.} = object
read_query_result*: proc (MySQL: PMySQL): my_bool{.cdecl.} read_query_result*: proc (MySQL: PMySQL): my_bool{.cdecl.}
advanced_command*: proc (MySQL: PMySQL, command: Tenum_server_command, header: cstring, advanced_command*: proc (MySQL: PMySQL, command: Enum_server_command, header: cstring,
header_length: int, arg: cstring, arg_length: int, header_length: int, arg: cstring, arg_length: int,
skip_check: my_bool): my_bool skip_check: my_bool): my_bool
read_rows*: proc (MySQL: PMySQL, fields: PFIELD, fields_count: cuint): PDATA read_rows*: proc (MySQL: PMySQL, fields: PFIELD, fields_count: cuint): PDATA
use_result*: proc (MySQL: PMySQL): PRES use_result*: proc (MySQL: PMySQL): PRES
fetch_lengths*: proc (fto: ptr int, column: TROW, field_count: cuint) fetch_lengths*: proc (fto: ptr int, column: ROW, field_count: cuint)
flush_use_result*: proc (MySQL: PMySQL) flush_use_result*: proc (MySQL: PMySQL)
list_fields*: proc (MySQL: PMySQL): PFIELD list_fields*: proc (MySQL: PMySQL): PFIELD
read_prepare_result*: proc (MySQL: PMySQL, stmt: PSTMT): my_bool read_prepare_result*: proc (MySQL: PMySQL, stmt: PSTMT): my_bool
@ -698,11 +715,11 @@ type
read_change_user_result*: proc (MySQL: PMySQL, buff: cstring, passwd: cstring): cint read_change_user_result*: proc (MySQL: PMySQL, buff: cstring, passwd: cstring): cint
read_rowsfrom_cursor*: proc (stmt: PSTMT): cint read_rowsfrom_cursor*: proc (stmt: PSTMT): cint
TMETHODS* = Tst_mysql_methods METHODS* = St_mysql_methods
PMETHODS* = ptr TMETHODS PMETHODS* = ptr METHODS
Pst_mysql_manager* = ptr Tst_mysql_manager Pst_mysql_manager* = ptr St_mysql_manager
Tst_mysql_manager*{.final.} = object St_mysql_manager*{.final.} = object
net*: TNET net*: NET
host*: cstring host*: cstring
user*: cstring user*: cstring
passwd*: cstring passwd*: cstring
@ -717,24 +734,24 @@ type
net_buf_size*: cint net_buf_size*: cint
last_error*: array[0..(MAX_MYSQL_MANAGER_ERR) - 1, char] last_error*: array[0..(MAX_MYSQL_MANAGER_ERR) - 1, char]
TMANAGER* = Tst_mysql_manager MANAGER* = St_mysql_manager
PMANAGER* = ptr TMANAGER PMANAGER* = ptr MANAGER
Pst_mysql_parameters* = ptr Tst_mysql_parameters Pst_mysql_parameters* = ptr St_mysql_parameters
Tst_mysql_parameters*{.final.} = object St_mysql_parameters*{.final.} = object
p_max_allowed_packet*: ptr int p_max_allowed_packet*: ptr int
p_net_buffer_length*: ptr int p_net_buffer_length*: ptr int
TPARAMETERS* = Tst_mysql_parameters PARAMETERS* = St_mysql_parameters
PPARAMETERS* = ptr TPARAMETERS PPARAMETERS* = ptr PARAMETERS
Tenum_mysql_stmt_state* = enum Enum_mysql_stmt_state* = enum
STMT_INIT_DONE = 1, STMT_PREPARE_DONE, STMT_EXECUTE_DONE, STMT_FETCH_DONE STMT_INIT_DONE = 1, STMT_PREPARE_DONE, STMT_EXECUTE_DONE, STMT_FETCH_DONE
Pst_mysql_bind* = ptr Tst_mysql_bind Pst_mysql_bind* = ptr St_mysql_bind
Tst_mysql_bind*{.final.} = object St_mysql_bind*{.final.} = object
len*: int # output length pointer len*: int # output length pointer
is_null*: Pmy_bool # Pointer to null indicator is_null*: Pmy_bool # Pointer to null indicator
buffer*: pointer # buffer to get/put data buffer*: pointer # buffer to get/put data
error*: PMy_bool # set this if you want to track data truncations happened during fetch error*: PMy_bool # set this if you want to track data truncations happened during fetch
buffer_type*: Tenum_field_types # buffer type buffer_type*: Enum_field_types # buffer type
buffer_length*: int # buffer length, must be set for str/binary buffer_length*: int # buffer length, must be set for str/binary
# Following are for internal use. Set by mysql_stmt_bind_param # Following are for internal use. Set by mysql_stmt_bind_param
row_ptr*: ptr byte # for the current data position row_ptr*: ptr byte # for the current data position
@ -750,15 +767,15 @@ type
fetch_result*: proc (para1: Pst_mysql_bind, para2: PFIELD, row: PPbyte) fetch_result*: proc (para1: Pst_mysql_bind, para2: PFIELD, row: PPbyte)
skip_result*: proc (para1: Pst_mysql_bind, para2: PFIELD, row: PPbyte) skip_result*: proc (para1: Pst_mysql_bind, para2: PFIELD, row: PPbyte)
TBIND* = Tst_mysql_bind BIND* = St_mysql_bind
PBIND* = ptr TBIND # statement handler PBIND* = ptr BIND # statement handler
Tst_mysql_stmt*{.final.} = object St_mysql_stmt*{.final.} = object
mem_root*: TMEM_ROOT # root allocations mem_root*: MEM_ROOT # root allocations
mysql*: PMySQL # connection handle mysql*: PMySQL # connection handle
params*: PBIND # input parameters params*: PBIND # input parameters
`bind`*: PBIND # input parameters `bind`*: PBIND # input parameters
fields*: PFIELD # result set metadata fields*: PFIELD # result set metadata
result*: TDATA # cached result set result*: DATA # cached result set
data_cursor*: PROWS # current row in cached result data_cursor*: PROWS # current row in cached result
affected_rows*: my_ulonglong # copy of mysql->affected_rows after statement execution affected_rows*: my_ulonglong # copy of mysql->affected_rows after statement execution
insert_id*: my_ulonglong insert_id*: my_ulonglong
@ -771,7 +788,7 @@ type
last_errno*: cuint # error code last_errno*: cuint # error code
param_count*: cuint # input parameter count param_count*: cuint # input parameter count
field_count*: cuint # number of columns in result set field_count*: cuint # number of columns in result set
state*: Tenum_mysql_stmt_state # statement state state*: Enum_mysql_stmt_state # statement state
last_error*: array[0..(ERRMSG_SIZE) - 1, char] # error message last_error*: array[0..(ERRMSG_SIZE) - 1, char] # error message
sqlstate*: array[0..(SQLSTATE_LENGTH + 1) - 1, char] sqlstate*: array[0..(SQLSTATE_LENGTH + 1) - 1, char]
send_types_to_server*: my_bool # Types of input parameters should be sent to server send_types_to_server*: my_bool # Types of input parameters should be sent to server
@ -780,10 +797,23 @@ type
unbuffered_fetch_cancelled*: my_bool unbuffered_fetch_cancelled*: my_bool
update_max_length*: my_bool update_max_length*: my_bool
TSTMT* = Tst_mysql_stmt STMT* = St_mysql_stmt
Tenum_stmt_attr_type* = enum Enum_stmt_attr_type* = enum
STMT_ATTR_UPDATE_MAX_LENGTH, STMT_ATTR_CURSOR_TYPE, STMT_ATTR_PREFETCH_ROWS STMT_ATTR_UPDATE_MAX_LENGTH, STMT_ATTR_CURSOR_TYPE, STMT_ATTR_PREFETCH_ROWS
{.deprecated: [Tst_dynamic_array: St_dynamic_array, Tst_mysql_options: St_mysql_options,
TDYNAMIC_ARRAY: DYNAMIC_ARRAY, Tprotocol_type: Protocol_type,
Trpl_type: Rpl_type, Tcharset_info_st: Charset_info_st,
TCHARSET_INFO: CHARSET_INFO, Tcharacter_set: Character_set,
TMY_CHARSET_INFO: MY_CHARSET_INFO, Tst_mysql: St_mysql,
Tst_mysql_methods: St_mysql_methods, TMySql: MySql,
Tst_mysql_res: St_mysql_res, TMETHODS: METHODS, TRES: RES,
Tst_mysql_manager: St_mysql_manager, TMANAGER: MANAGER,
Tst_mysql_parameters: St_mysql_parameters, TPARAMETERS: PARAMETERS,
Tenum_mysql_stmt_state: Enum_mysql_stmt_state,
Tst_mysql_bind: St_mysql_bind, TBIND: BIND, Tst_mysql_stmt: St_mysql_stmt,
TSTMT: STMT, Tenum_stmt_attr_type: Enum_stmt_attr_type,
Tstatus: Status].}
proc server_init*(argc: cint, argv: cstringArray, groups: cstringArray): cint{. proc server_init*(argc: cint, argv: cstringArray, groups: cstringArray): cint{.
cdecl, dynlib: lib, importc: "mysql_server_init".} cdecl, dynlib: lib, importc: "mysql_server_init".}
@ -817,9 +847,9 @@ proc fetch_field_direct*(res: PRES, fieldnr: cuint): PFIELD{.stdcall,
dynlib: lib, importc: "mysql_fetch_field_direct".} dynlib: lib, importc: "mysql_fetch_field_direct".}
proc fetch_fields*(res: PRES): PFIELD{.stdcall, dynlib: lib, proc fetch_fields*(res: PRES): PFIELD{.stdcall, dynlib: lib,
importc: "mysql_fetch_fields".} importc: "mysql_fetch_fields".}
proc row_tell*(res: PRES): TROW_OFFSET{.stdcall, dynlib: lib, proc row_tell*(res: PRES): ROW_OFFSET{.stdcall, dynlib: lib,
importc: "mysql_row_tell".} importc: "mysql_row_tell".}
proc field_tell*(res: PRES): TFIELD_OFFSET{.stdcall, dynlib: lib, proc field_tell*(res: PRES): FIELD_OFFSET{.stdcall, dynlib: lib,
importc: "mysql_field_tell".} importc: "mysql_field_tell".}
proc field_count*(MySQL: PMySQL): cuint{.stdcall, dynlib: lib, proc field_count*(MySQL: PMySQL): cuint{.stdcall, dynlib: lib,
importc: "mysql_field_count".} importc: "mysql_field_count".}
@ -895,7 +925,7 @@ proc disable_reads_from_master*(MySQL: PMySQL){.stdcall, dynlib: lib, importc: "
# get the value of the master read flag # get the value of the master read flag
proc reads_from_master_enabled*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib, proc reads_from_master_enabled*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib,
importc: "mysql_reads_from_master_enabled".} importc: "mysql_reads_from_master_enabled".}
proc rpl_query_type*(q: cstring, length: cint): Trpl_type{.stdcall, dynlib: lib, proc rpl_query_type*(q: cstring, length: cint): Rpl_type{.stdcall, dynlib: lib,
importc: "mysql_rpl_query_type".} importc: "mysql_rpl_query_type".}
# discover the master and its slaves # discover the master and its slaves
proc rpl_probe*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib, importc: "mysql_rpl_probe".} proc rpl_probe*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib, importc: "mysql_rpl_probe".}
@ -904,14 +934,14 @@ proc set_master*(MySQL: PMySQL, host: cstring, port: cuint, user: cstring, passw
stdcall, dynlib: lib, importc: "mysql_set_master".} stdcall, dynlib: lib, importc: "mysql_set_master".}
proc add_slave*(MySQL: PMySQL, host: cstring, port: cuint, user: cstring, passwd: cstring): cint{. proc add_slave*(MySQL: PMySQL, host: cstring, port: cuint, user: cstring, passwd: cstring): cint{.
stdcall, dynlib: lib, importc: "mysql_add_slave".} stdcall, dynlib: lib, importc: "mysql_add_slave".}
proc shutdown*(MySQL: PMySQL, shutdown_level: Tenum_shutdown_level): cint{.stdcall, proc shutdown*(MySQL: PMySQL, shutdown_level: Enum_shutdown_level): cint{.stdcall,
dynlib: lib, importc: "mysql_shutdown".} dynlib: lib, importc: "mysql_shutdown".}
proc dump_debug_info*(MySQL: PMySQL): cint{.stdcall, dynlib: lib, proc dump_debug_info*(MySQL: PMySQL): cint{.stdcall, dynlib: lib,
importc: "mysql_dump_debug_info".} importc: "mysql_dump_debug_info".}
proc refresh*(sql: PMySQL, refresh_options: cuint): cint{.stdcall, dynlib: lib, proc refresh*(sql: PMySQL, refresh_options: cuint): cint{.stdcall, dynlib: lib,
importc: "mysql_refresh".} importc: "mysql_refresh".}
proc kill*(MySQL: PMySQL, pid: int): cint{.stdcall, dynlib: lib, importc: "mysql_kill".} proc kill*(MySQL: PMySQL, pid: int): cint{.stdcall, dynlib: lib, importc: "mysql_kill".}
proc set_server_option*(MySQL: PMySQL, option: Tenum_mysql_set_option): cint{.stdcall, proc set_server_option*(MySQL: PMySQL, option: Enum_mysql_set_option): cint{.stdcall,
dynlib: lib, importc: "mysql_set_server_option".} dynlib: lib, importc: "mysql_set_server_option".}
proc ping*(MySQL: PMySQL): cint{.stdcall, dynlib: lib, importc: "mysql_ping".} proc ping*(MySQL: PMySQL): cint{.stdcall, dynlib: lib, importc: "mysql_ping".}
proc stat*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, importc: "mysql_stat".} proc stat*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, importc: "mysql_stat".}
@ -933,17 +963,17 @@ proc list_tables*(MySQL: PMySQL, wild: cstring): PRES{.stdcall, dynlib: lib,
importc: "mysql_list_tables".} importc: "mysql_list_tables".}
proc list_processes*(MySQL: PMySQL): PRES{.stdcall, dynlib: lib, proc list_processes*(MySQL: PMySQL): PRES{.stdcall, dynlib: lib,
importc: "mysql_list_processes".} importc: "mysql_list_processes".}
proc options*(MySQL: PMySQL, option: Toption, arg: cstring): cint{.stdcall, dynlib: lib, proc options*(MySQL: PMySQL, option: Option, arg: cstring): cint{.stdcall, dynlib: lib,
importc: "mysql_options".} importc: "mysql_options".}
proc free_result*(result: PRES){.stdcall, dynlib: lib, proc free_result*(result: PRES){.stdcall, dynlib: lib,
importc: "mysql_free_result".} importc: "mysql_free_result".}
proc data_seek*(result: PRES, offset: my_ulonglong){.stdcall, dynlib: lib, proc data_seek*(result: PRES, offset: my_ulonglong){.stdcall, dynlib: lib,
importc: "mysql_data_seek".} importc: "mysql_data_seek".}
proc row_seek*(result: PRES, offset: TROW_OFFSET): TROW_OFFSET{.stdcall, proc row_seek*(result: PRES, offset: ROW_OFFSET): ROW_OFFSET{.stdcall,
dynlib: lib, importc: "mysql_row_seek".} dynlib: lib, importc: "mysql_row_seek".}
proc field_seek*(result: PRES, offset: TFIELD_OFFSET): TFIELD_OFFSET{.stdcall, proc field_seek*(result: PRES, offset: FIELD_OFFSET): FIELD_OFFSET{.stdcall,
dynlib: lib, importc: "mysql_field_seek".} dynlib: lib, importc: "mysql_field_seek".}
proc fetch_row*(result: PRES): TROW{.stdcall, dynlib: lib, proc fetch_row*(result: PRES): ROW{.stdcall, dynlib: lib,
importc: "mysql_fetch_row".} importc: "mysql_fetch_row".}
proc fetch_lengths*(result: PRES): ptr int{.stdcall, dynlib: lib, proc fetch_lengths*(result: PRES): ptr int{.stdcall, dynlib: lib,
importc: "mysql_fetch_lengths".} importc: "mysql_fetch_lengths".}
@ -990,9 +1020,9 @@ proc stmt_store_result*(stmt: PSTMT): cint{.stdcall, dynlib: lib,
importc: "mysql_stmt_store_result".} importc: "mysql_stmt_store_result".}
proc stmt_param_count*(stmt: PSTMT): int{.stdcall, dynlib: lib, proc stmt_param_count*(stmt: PSTMT): int{.stdcall, dynlib: lib,
importc: "mysql_stmt_param_count".} importc: "mysql_stmt_param_count".}
proc stmt_attr_set*(stmt: PSTMT, attr_type: Tenum_stmt_attr_type, attr: pointer): my_bool{. proc stmt_attr_set*(stmt: PSTMT, attr_type: Enum_stmt_attr_type, attr: pointer): my_bool{.
stdcall, dynlib: lib, importc: "mysql_stmt_attr_set".} stdcall, dynlib: lib, importc: "mysql_stmt_attr_set".}
proc stmt_attr_get*(stmt: PSTMT, attr_type: Tenum_stmt_attr_type, attr: pointer): my_bool{. proc stmt_attr_get*(stmt: PSTMT, attr_type: Enum_stmt_attr_type, attr: pointer): my_bool{.
stdcall, dynlib: lib, importc: "mysql_stmt_attr_get".} stdcall, dynlib: lib, importc: "mysql_stmt_attr_get".}
proc stmt_bind_param*(stmt: PSTMT, bnd: PBIND): my_bool{.stdcall, dynlib: lib, proc stmt_bind_param*(stmt: PSTMT, bnd: PBIND): my_bool{.stdcall, dynlib: lib,
importc: "mysql_stmt_bind_param".} importc: "mysql_stmt_bind_param".}
@ -1017,9 +1047,9 @@ proc stmt_error*(stmt: PSTMT): cstring{.stdcall, dynlib: lib,
importc: "mysql_stmt_error".} importc: "mysql_stmt_error".}
proc stmt_sqlstate*(stmt: PSTMT): cstring{.stdcall, dynlib: lib, proc stmt_sqlstate*(stmt: PSTMT): cstring{.stdcall, dynlib: lib,
importc: "mysql_stmt_sqlstate".} importc: "mysql_stmt_sqlstate".}
proc stmt_row_seek*(stmt: PSTMT, offset: TROW_OFFSET): TROW_OFFSET{.stdcall, proc stmt_row_seek*(stmt: PSTMT, offset: ROW_OFFSET): ROW_OFFSET{.stdcall,
dynlib: lib, importc: "mysql_stmt_row_seek".} dynlib: lib, importc: "mysql_stmt_row_seek".}
proc stmt_row_tell*(stmt: PSTMT): TROW_OFFSET{.stdcall, dynlib: lib, proc stmt_row_tell*(stmt: PSTMT): ROW_OFFSET{.stdcall, dynlib: lib,
importc: "mysql_stmt_row_tell".} importc: "mysql_stmt_row_tell".}
proc stmt_data_seek*(stmt: PSTMT, offset: my_ulonglong){.stdcall, dynlib: lib, proc stmt_data_seek*(stmt: PSTMT, offset: my_ulonglong){.stdcall, dynlib: lib,
importc: "mysql_stmt_data_seek".} importc: "mysql_stmt_data_seek".}
@ -1066,7 +1096,7 @@ proc IS_BLOB(n: int32): bool =
proc IS_NUM_FIELD(f: Pst_mysql_field): bool = proc IS_NUM_FIELD(f: Pst_mysql_field): bool =
result = (f.flags and NUM_FLAG) != 0 result = (f.flags and NUM_FLAG) != 0
proc IS_NUM(t: Tenum_field_types): bool = proc IS_NUM(t: Enum_field_types): bool =
result = (t <= FIELD_TYPE_INT24) or (t == FIELD_TYPE_YEAR) or result = (t <= FIELD_TYPE_INT24) or (t == FIELD_TYPE_YEAR) or
(t == FIELD_TYPE_NEWDECIMAL) (t == FIELD_TYPE_NEWDECIMAL)

199
lib/wrappers/odbcsql.nim
View file

@ -30,28 +30,39 @@ else:
type type
TSqlChar* = char TSqlChar* = char
TSqlSmallInt* = int16 TSqlSmallInt* = int16
TSqlUSmallInt* = int16 SqlUSmallInt* = int16
TSqlHandle* = pointer SqlHandle* = pointer
TSqlHEnv* = TSqlHandle SqlHEnv* = SqlHandle
TSqlHDBC* = TSqlHandle SqlHDBC* = SqlHandle
TSqlHStmt* = TSqlHandle SqlHStmt* = SqlHandle
TSqlHDesc* = TSqlHandle SqlHDesc* = SqlHandle
TSqlInteger* = int TSqlInteger* = int
TSqlUInteger* = int SqlUInteger* = int
TSqlPointer* = pointer SqlPointer* = pointer
TSqlReal* = cfloat TSqlReal* = cfloat
TSqlDouble* = cdouble TSqlDouble* = cdouble
TSqlFloat* = cdouble TSqlFloat* = cdouble
TSqlHWND* = pointer SqlHWND* = pointer
PSQLCHAR* = cstring PSQLCHAR* = cstring
PSQLINTEGER* = ptr TSqlInteger PSQLINTEGER* = ptr TSqlInteger
PSQLUINTEGER* = ptr TSqlUInteger PSQLUINTEGER* = ptr SqlUInteger
PSQLSMALLINT* = ptr TSqlSmallInt PSQLSMALLINT* = ptr TSqlSmallInt
PSQLUSMALLINT* = ptr TSqlUSmallInt PSQLUSMALLINT* = ptr SqlUSmallInt
PSQLREAL* = ptr TSqlReal PSQLREAL* = ptr TSqlReal
PSQLDOUBLE* = ptr TSqlDouble PSQLDOUBLE* = ptr TSqlDouble
PSQLFLOAT* = ptr TSqlFloat PSQLFLOAT* = ptr TSqlFloat
PSQLHANDLE* = ptr TSqlHandle PSQLHANDLE* = ptr SqlHandle
{.deprecated: [
# TSqlChar: TSqlChar, # Name conflict if we drop`T`
# TSqlSmallInt: TSqlSmallInt, # Name conflict if we drop`T`
TSqlUSmallInt: SqlUSmallInt, TSqlHandle: SqlHandle, TSqlHEnv: SqlHEnv,
TSqlHDBC: SqlHDBC, TSqlHStmt: SqlHStmt, TSqlHDesc: SqlHDesc,
# TSqlInteger: TSqlInteger, # Name conflict if we drop `T`
TSqlUInteger: SqlUInteger, TSqlPointer: SqlPointer,
# TSqlReal: TSqlReal, # Name conflict if we drop`T`
# TSqlDouble: TSqlDouble, # Name conflict if we drop`T`
# TSqlFloat: TSqlFloat, # Name conflict if we drop `T`
TSqlHWND: SqlHWND].}
const # SQL data type codes const # SQL data type codes
SQL_UNKNOWN_TYPE* = 0 SQL_UNKNOWN_TYPE* = 0
@ -199,24 +210,24 @@ const
type type
SQL_DATE_STRUCT* {.final, pure.} = object SQL_DATE_STRUCT* {.final, pure.} = object
Year*: TSqlSmallInt Year*: TSqlSmallInt
Month*: TSqlUSmallInt Month*: SqlUSmallInt
Day*: TSqlUSmallInt Day*: SqlUSmallInt
PSQL_DATE_STRUCT* = ptr SQL_DATE_STRUCT PSQL_DATE_STRUCT* = ptr SQL_DATE_STRUCT
SQL_TIME_STRUCT* {.final, pure.} = object SQL_TIME_STRUCT* {.final, pure.} = object
Hour*: TSqlUSmallInt Hour*: SqlUSmallInt
Minute*: TSqlUSmallInt Minute*: SqlUSmallInt
Second*: TSqlUSmallInt Second*: SqlUSmallInt
PSQL_TIME_STRUCT* = ptr SQL_TIME_STRUCT PSQL_TIME_STRUCT* = ptr SQL_TIME_STRUCT
SQL_TIMESTAMP_STRUCT* {.final, pure.} = object SQL_TIMESTAMP_STRUCT* {.final, pure.} = object
Year*: TSqlUSmallInt Year*: SqlUSmallInt
Month*: TSqlUSmallInt Month*: SqlUSmallInt
Day*: TSqlUSmallInt Day*: SqlUSmallInt
Hour*: TSqlUSmallInt Hour*: SqlUSmallInt
Minute*: TSqlUSmallInt Minute*: SqlUSmallInt
Second*: TSqlUSmallInt Second*: SqlUSmallInt
Fraction*: TSqlUInteger Fraction*: SqlUInteger
PSQL_TIMESTAMP_STRUCT* = ptr SQL_TIMESTAMP_STRUCT PSQL_TIMESTAMP_STRUCT* = ptr SQL_TIMESTAMP_STRUCT
@ -509,11 +520,11 @@ const
SQL_FETCH_PRIOR* = 4 SQL_FETCH_PRIOR* = 4
SQL_FETCH_ABSOLUTE* = 5 SQL_FETCH_ABSOLUTE* = 5
SQL_FETCH_RELATIVE* = 6 SQL_FETCH_RELATIVE* = 6
SQL_NULL_HENV* = TSqlHEnv(nil) SQL_NULL_HENV* = SqlHEnv(nil)
SQL_NULL_HDBC* = TSqlHDBC(nil) SQL_NULL_HDBC* = SqlHDBC(nil)
SQL_NULL_HSTMT* = TSqlHStmt(nil) SQL_NULL_HSTMT* = SqlHStmt(nil)
SQL_NULL_HDESC* = TSqlHDesc(nil) #* null handle used in place of parent handle when allocating HENV */ SQL_NULL_HDESC* = SqlHDesc(nil) #* null handle used in place of parent handle when allocating HENV */
SQL_NULL_HANDLE* = TSqlHandle(nil) #* Values that may appear in the result set of SQLSpecialColumns() */ SQL_NULL_HANDLE* = SqlHandle(nil) #* Values that may appear in the result set of SQLSpecialColumns() */
SQL_SCOPE_CURROW* = 0 SQL_SCOPE_CURROW* = 0
SQL_SCOPE_TRANSACTION* = 1 SQL_SCOPE_TRANSACTION* = 1
SQL_SCOPE_SESSION* = 2 #* Column types and scopes in SQLSpecialColumns. */ SQL_SCOPE_SESSION* = 2 #* Column types and scopes in SQLSpecialColumns. */
@ -622,167 +633,167 @@ const
ODBC_CONFIG_SYS_DSN* = 5 ODBC_CONFIG_SYS_DSN* = 5
ODBC_REMOVE_SYS_DSN* = 6 ODBC_REMOVE_SYS_DSN* = 6
proc SQLAllocHandle*(HandleType: TSqlSmallInt, InputHandle: TSqlHandle, proc SQLAllocHandle*(HandleType: TSqlSmallInt, InputHandle: SqlHandle,
OutputHandlePtr: var TSqlHandle): TSqlSmallInt{. OutputHandlePtr: var SqlHandle): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLSetEnvAttr*(EnvironmentHandle: TSqlHEnv, Attribute: TSqlInteger, proc SQLSetEnvAttr*(EnvironmentHandle: SqlHEnv, Attribute: TSqlInteger,
Value: TSqlPointer, StringLength: TSqlInteger): TSqlSmallInt{. Value: SqlPointer, StringLength: TSqlInteger): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLGetEnvAttr*(EnvironmentHandle: TSqlHEnv, Attribute: TSqlInteger, proc SQLGetEnvAttr*(EnvironmentHandle: SqlHEnv, Attribute: TSqlInteger,
Value: TSqlPointer, BufferLength: TSqlInteger, Value: SqlPointer, BufferLength: TSqlInteger,
StringLength: PSQLINTEGER): TSqlSmallInt{.dynlib: odbclib, StringLength: PSQLINTEGER): TSqlSmallInt{.dynlib: odbclib,
importc.} importc.}
proc SQLFreeHandle*(HandleType: TSqlSmallInt, Handle: TSqlHandle): TSqlSmallInt{. proc SQLFreeHandle*(HandleType: TSqlSmallInt, Handle: SqlHandle): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLGetDiagRec*(HandleType: TSqlSmallInt, Handle: TSqlHandle, proc SQLGetDiagRec*(HandleType: TSqlSmallInt, Handle: SqlHandle,
RecNumber: TSqlSmallInt, Sqlstate: PSQLCHAR, RecNumber: TSqlSmallInt, Sqlstate: PSQLCHAR,
NativeError: var TSqlInteger, MessageText: PSQLCHAR, NativeError: var TSqlInteger, MessageText: PSQLCHAR,
BufferLength: TSqlSmallInt, TextLength: var TSqlSmallInt): TSqlSmallInt{. BufferLength: TSqlSmallInt, TextLength: var TSqlSmallInt): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLGetDiagField*(HandleType: TSqlSmallInt, Handle: TSqlHandle, proc SQLGetDiagField*(HandleType: TSqlSmallInt, Handle: SqlHandle,
RecNumber: TSqlSmallInt, DiagIdentifier: TSqlSmallInt, RecNumber: TSqlSmallInt, DiagIdentifier: TSqlSmallInt,
DiagInfoPtr: TSqlPointer, BufferLength: TSqlSmallInt, DiagInfoPtr: SqlPointer, BufferLength: TSqlSmallInt,
StringLengthPtr: var TSqlSmallInt): TSqlSmallInt{. StringLengthPtr: var TSqlSmallInt): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLConnect*(ConnectionHandle: TSqlHDBC, ServerName: PSQLCHAR, proc SQLConnect*(ConnectionHandle: SqlHDBC, ServerName: PSQLCHAR,
NameLength1: TSqlSmallInt, UserName: PSQLCHAR, NameLength1: TSqlSmallInt, UserName: PSQLCHAR,
NameLength2: TSqlSmallInt, Authentication: PSQLCHAR, NameLength2: TSqlSmallInt, Authentication: PSQLCHAR,
NameLength3: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib, importc.} NameLength3: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib, importc.}
proc SQLDisconnect*(ConnectionHandle: TSqlHDBC): TSqlSmallInt{.dynlib: odbclib, proc SQLDisconnect*(ConnectionHandle: SqlHDBC): TSqlSmallInt{.dynlib: odbclib,
importc.} importc.}
proc SQLDriverConnect*(hdbc: TSqlHDBC, hwnd: TSqlHWND, szCsin: cstring, proc SQLDriverConnect*(hdbc: SqlHDBC, hwnd: SqlHWND, szCsin: cstring,
szCLen: TSqlSmallInt, szCsout: cstring, szCLen: TSqlSmallInt, szCsout: cstring,
cbCSMax: TSqlSmallInt, cbCsOut: var TSqlSmallInt, cbCSMax: TSqlSmallInt, cbCsOut: var TSqlSmallInt,
f: TSqlUSmallInt): TSqlSmallInt{.dynlib: odbclib, importc.} f: SqlUSmallInt): TSqlSmallInt{.dynlib: odbclib, importc.}
proc SQLBrowseConnect*(hdbc: TSqlHDBC, szConnStrIn: PSQLCHAR, proc SQLBrowseConnect*(hdbc: SqlHDBC, szConnStrIn: PSQLCHAR,
cbConnStrIn: TSqlSmallInt, szConnStrOut: PSQLCHAR, cbConnStrIn: TSqlSmallInt, szConnStrOut: PSQLCHAR,
cbConnStrOutMax: TSqlSmallInt, cbConnStrOutMax: TSqlSmallInt,
cbConnStrOut: var TSqlSmallInt): TSqlSmallInt{. cbConnStrOut: var TSqlSmallInt): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLExecDirect*(StatementHandle: TSqlHStmt, StatementText: PSQLCHAR, proc SQLExecDirect*(StatementHandle: SqlHStmt, StatementText: PSQLCHAR,
TextLength: TSqlInteger): TSqlSmallInt{.dynlib: odbclib, importc.} TextLength: TSqlInteger): TSqlSmallInt{.dynlib: odbclib, importc.}
proc SQLPrepare*(StatementHandle: TSqlHStmt, StatementText: PSQLCHAR, proc SQLPrepare*(StatementHandle: SqlHStmt, StatementText: PSQLCHAR,
TextLength: TSqlInteger): TSqlSmallInt{.dynlib: odbclib, importc.} TextLength: TSqlInteger): TSqlSmallInt{.dynlib: odbclib, importc.}
proc SQLCloseCursor*(StatementHandle: TSqlHStmt): TSqlSmallInt{.dynlib: odbclib, proc SQLCloseCursor*(StatementHandle: SqlHStmt): TSqlSmallInt{.dynlib: odbclib,
importc.} importc.}
proc SQLExecute*(StatementHandle: TSqlHStmt): TSqlSmallInt{.dynlib: odbclib, importc.} proc SQLExecute*(StatementHandle: SqlHStmt): TSqlSmallInt{.dynlib: odbclib, importc.}
proc SQLFetch*(StatementHandle: TSqlHStmt): TSqlSmallInt{.dynlib: odbclib, importc.} proc SQLFetch*(StatementHandle: SqlHStmt): TSqlSmallInt{.dynlib: odbclib, importc.}
proc SQLNumResultCols*(StatementHandle: TSqlHStmt, ColumnCount: var TSqlSmallInt): TSqlSmallInt{. proc SQLNumResultCols*(StatementHandle: SqlHStmt, ColumnCount: var TSqlSmallInt): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLDescribeCol*(StatementHandle: TSqlHStmt, ColumnNumber: TSqlUSmallInt, proc SQLDescribeCol*(StatementHandle: SqlHStmt, ColumnNumber: SqlUSmallInt,
ColumnName: PSQLCHAR, BufferLength: TSqlSmallInt, ColumnName: PSQLCHAR, BufferLength: TSqlSmallInt,
NameLength: var TSqlSmallInt, DataType: var TSqlSmallInt, NameLength: var TSqlSmallInt, DataType: var TSqlSmallInt,
ColumnSize: var TSqlUInteger, ColumnSize: var SqlUInteger,
DecimalDigits: var TSqlSmallInt, Nullable: var TSqlSmallInt): TSqlSmallInt{. DecimalDigits: var TSqlSmallInt, Nullable: var TSqlSmallInt): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLFetchScroll*(StatementHandle: TSqlHStmt, FetchOrientation: TSqlSmallInt, proc SQLFetchScroll*(StatementHandle: SqlHStmt, FetchOrientation: TSqlSmallInt,
FetchOffset: TSqlInteger): TSqlSmallInt{.dynlib: odbclib, FetchOffset: TSqlInteger): TSqlSmallInt{.dynlib: odbclib,
importc.} importc.}
proc SQLExtendedFetch*(hstmt: TSqlHStmt, fFetchType: TSqlUSmallInt, proc SQLExtendedFetch*(hstmt: SqlHStmt, fFetchType: SqlUSmallInt,
irow: TSqlInteger, pcrow: PSQLUINTEGER, irow: TSqlInteger, pcrow: PSQLUINTEGER,
rgfRowStatus: PSQLUSMALLINT): TSqlSmallInt{.dynlib: odbclib, rgfRowStatus: PSQLUSMALLINT): TSqlSmallInt{.dynlib: odbclib,
importc.} importc.}
proc SQLGetData*(StatementHandle: TSqlHStmt, ColumnNumber: TSqlUSmallInt, proc SQLGetData*(StatementHandle: SqlHStmt, ColumnNumber: SqlUSmallInt,
TargetType: TSqlSmallInt, TargetValue: TSqlPointer, TargetType: TSqlSmallInt, TargetValue: SqlPointer,
BufferLength: TSqlInteger, StrLen_or_Ind: PSQLINTEGER): TSqlSmallInt{. BufferLength: TSqlInteger, StrLen_or_Ind: PSQLINTEGER): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLSetStmtAttr*(StatementHandle: TSqlHStmt, Attribute: TSqlInteger, proc SQLSetStmtAttr*(StatementHandle: SqlHStmt, Attribute: TSqlInteger,
Value: TSqlPointer, StringLength: TSqlInteger): TSqlSmallInt{. Value: SqlPointer, StringLength: TSqlInteger): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLGetStmtAttr*(StatementHandle: TSqlHStmt, Attribute: TSqlInteger, proc SQLGetStmtAttr*(StatementHandle: SqlHStmt, Attribute: TSqlInteger,
Value: TSqlPointer, BufferLength: TSqlInteger, Value: SqlPointer, BufferLength: TSqlInteger,
StringLength: PSQLINTEGER): TSqlSmallInt{.dynlib: odbclib, StringLength: PSQLINTEGER): TSqlSmallInt{.dynlib: odbclib,
importc.} importc.}
proc SQLGetInfo*(ConnectionHandle: TSqlHDBC, InfoType: TSqlUSmallInt, proc SQLGetInfo*(ConnectionHandle: SqlHDBC, InfoType: SqlUSmallInt,
InfoValue: TSqlPointer, BufferLength: TSqlSmallInt, InfoValue: SqlPointer, BufferLength: TSqlSmallInt,
StringLength: PSQLSMALLINT): TSqlSmallInt{.dynlib: odbclib, StringLength: PSQLSMALLINT): TSqlSmallInt{.dynlib: odbclib,
importc.} importc.}
proc SQLBulkOperations*(StatementHandle: TSqlHStmt, Operation: TSqlSmallInt): TSqlSmallInt{. proc SQLBulkOperations*(StatementHandle: SqlHStmt, Operation: TSqlSmallInt): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLPutData*(StatementHandle: TSqlHStmt, Data: TSqlPointer, proc SQLPutData*(StatementHandle: SqlHStmt, Data: SqlPointer,
StrLen_or_Ind: TSqlInteger): TSqlSmallInt{.dynlib: odbclib, importc.} StrLen_or_Ind: TSqlInteger): TSqlSmallInt{.dynlib: odbclib, importc.}
proc SQLBindCol*(StatementHandle: TSqlHStmt, ColumnNumber: TSqlUSmallInt, proc SQLBindCol*(StatementHandle: SqlHStmt, ColumnNumber: SqlUSmallInt,
TargetType: TSqlSmallInt, TargetValue: TSqlPointer, TargetType: TSqlSmallInt, TargetValue: SqlPointer,
BufferLength: TSqlInteger, StrLen_or_Ind: PSQLINTEGER): TSqlSmallInt{. BufferLength: TSqlInteger, StrLen_or_Ind: PSQLINTEGER): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLSetPos*(hstmt: TSqlHStmt, irow: TSqlUSmallInt, fOption: TSqlUSmallInt, proc SQLSetPos*(hstmt: SqlHStmt, irow: SqlUSmallInt, fOption: SqlUSmallInt,
fLock: TSqlUSmallInt): TSqlSmallInt{.dynlib: odbclib, importc.} fLock: SqlUSmallInt): TSqlSmallInt{.dynlib: odbclib, importc.}
proc SQLDataSources*(EnvironmentHandle: TSqlHEnv, Direction: TSqlUSmallInt, proc SQLDataSources*(EnvironmentHandle: SqlHEnv, Direction: SqlUSmallInt,
ServerName: PSQLCHAR, BufferLength1: TSqlSmallInt, ServerName: PSQLCHAR, BufferLength1: TSqlSmallInt,
NameLength1: PSQLSMALLINT, Description: PSQLCHAR, NameLength1: PSQLSMALLINT, Description: PSQLCHAR,
BufferLength2: TSqlSmallInt, NameLength2: PSQLSMALLINT): TSqlSmallInt{. BufferLength2: TSqlSmallInt, NameLength2: PSQLSMALLINT): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLDrivers*(EnvironmentHandle: TSqlHEnv, Direction: TSqlUSmallInt, proc SQLDrivers*(EnvironmentHandle: SqlHEnv, Direction: SqlUSmallInt,
DriverDescription: PSQLCHAR, BufferLength1: TSqlSmallInt, DriverDescription: PSQLCHAR, BufferLength1: TSqlSmallInt,
DescriptionLength1: PSQLSMALLINT, DriverAttributes: PSQLCHAR, DescriptionLength1: PSQLSMALLINT, DriverAttributes: PSQLCHAR,
BufferLength2: TSqlSmallInt, AttributesLength2: PSQLSMALLINT): TSqlSmallInt{. BufferLength2: TSqlSmallInt, AttributesLength2: PSQLSMALLINT): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLSetConnectAttr*(ConnectionHandle: TSqlHDBC, Attribute: TSqlInteger, proc SQLSetConnectAttr*(ConnectionHandle: SqlHDBC, Attribute: TSqlInteger,
Value: TSqlPointer, StringLength: TSqlInteger): TSqlSmallInt{. Value: SqlPointer, StringLength: TSqlInteger): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLGetCursorName*(StatementHandle: TSqlHStmt, CursorName: PSQLCHAR, proc SQLGetCursorName*(StatementHandle: SqlHStmt, CursorName: PSQLCHAR,
BufferLength: TSqlSmallInt, NameLength: PSQLSMALLINT): TSqlSmallInt{. BufferLength: TSqlSmallInt, NameLength: PSQLSMALLINT): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLSetCursorName*(StatementHandle: TSqlHStmt, CursorName: PSQLCHAR, proc SQLSetCursorName*(StatementHandle: SqlHStmt, CursorName: PSQLCHAR,
NameLength: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib, NameLength: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib,
importc.} importc.}
proc SQLRowCount*(StatementHandle: TSqlHStmt, RowCount: var TSqlInteger): TSqlSmallInt{. proc SQLRowCount*(StatementHandle: SqlHStmt, RowCount: var TSqlInteger): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLBindParameter*(hstmt: TSqlHStmt, ipar: TSqlUSmallInt, proc SQLBindParameter*(hstmt: SqlHStmt, ipar: SqlUSmallInt,
fParamType: TSqlSmallInt, fCType: TSqlSmallInt, fParamType: TSqlSmallInt, fCType: TSqlSmallInt,
fSqlType: TSqlSmallInt, cbColDef: TSqlUInteger, fSqlType: TSqlSmallInt, cbColDef: SqlUInteger,
ibScale: TSqlSmallInt, rgbValue: TSqlPointer, ibScale: TSqlSmallInt, rgbValue: SqlPointer,
cbValueMax: TSqlInteger, pcbValue: PSQLINTEGER): TSqlSmallInt{. cbValueMax: TSqlInteger, pcbValue: PSQLINTEGER): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLFreeStmt*(StatementHandle: TSqlHStmt, Option: TSqlUSmallInt): TSqlSmallInt{. proc SQLFreeStmt*(StatementHandle: SqlHStmt, Option: SqlUSmallInt): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLColAttribute*(StatementHandle: TSqlHStmt, ColumnNumber: TSqlUSmallInt, proc SQLColAttribute*(StatementHandle: SqlHStmt, ColumnNumber: SqlUSmallInt,
FieldIdentifier: TSqlUSmallInt, FieldIdentifier: SqlUSmallInt,
CharacterAttribute: PSQLCHAR, BufferLength: TSqlSmallInt, CharacterAttribute: PSQLCHAR, BufferLength: TSqlSmallInt,
StringLength: PSQLSMALLINT, StringLength: PSQLSMALLINT,
NumericAttribute: TSqlPointer): TSqlSmallInt{. NumericAttribute: SqlPointer): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLEndTran*(HandleType: TSqlSmallInt, Handle: TSqlHandle, proc SQLEndTran*(HandleType: TSqlSmallInt, Handle: SqlHandle,
CompletionType: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib, CompletionType: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib,
importc.} importc.}
proc SQLTables*(hstmt: TSqlHStmt, szTableQualifier: PSQLCHAR, proc SQLTables*(hstmt: SqlHStmt, szTableQualifier: PSQLCHAR,
cbTableQualifier: TSqlSmallInt, szTableOwner: PSQLCHAR, cbTableQualifier: TSqlSmallInt, szTableOwner: PSQLCHAR,
cbTableOwner: TSqlSmallInt, szTableName: PSQLCHAR, cbTableOwner: TSqlSmallInt, szTableName: PSQLCHAR,
cbTableName: TSqlSmallInt, szTableType: PSQLCHAR, cbTableName: TSqlSmallInt, szTableType: PSQLCHAR,
cbTableType: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib, importc.} cbTableType: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib, importc.}
proc SQLColumns*(hstmt: TSqlHStmt, szTableQualifier: PSQLCHAR, proc SQLColumns*(hstmt: SqlHStmt, szTableQualifier: PSQLCHAR,
cbTableQualifier: TSqlSmallInt, szTableOwner: PSQLCHAR, cbTableQualifier: TSqlSmallInt, szTableOwner: PSQLCHAR,
cbTableOwner: TSqlSmallInt, szTableName: PSQLCHAR, cbTableOwner: TSqlSmallInt, szTableName: PSQLCHAR,
cbTableName: TSqlSmallInt, szColumnName: PSQLCHAR, cbTableName: TSqlSmallInt, szColumnName: PSQLCHAR,
cbColumnName: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib, importc.} cbColumnName: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib, importc.}
proc SQLSpecialColumns*(StatementHandle: TSqlHStmt, IdentifierType: TSqlUSmallInt, proc SQLSpecialColumns*(StatementHandle: SqlHStmt, IdentifierType: SqlUSmallInt,
CatalogName: PSQLCHAR, NameLength1: TSqlSmallInt, CatalogName: PSQLCHAR, NameLength1: TSqlSmallInt,
SchemaName: PSQLCHAR, NameLength2: TSqlSmallInt, SchemaName: PSQLCHAR, NameLength2: TSqlSmallInt,
TableName: PSQLCHAR, NameLength3: TSqlSmallInt, TableName: PSQLCHAR, NameLength3: TSqlSmallInt,
Scope: TSqlUSmallInt, Scope: SqlUSmallInt,
Nullable: TSqlUSmallInt): TSqlSmallInt{. Nullable: SqlUSmallInt): TSqlSmallInt{.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
proc SQLProcedures*(hstmt: TSqlHStmt, szTableQualifier: PSQLCHAR, proc SQLProcedures*(hstmt: SqlHStmt, szTableQualifier: PSQLCHAR,
cbTableQualifier: TSqlSmallInt, szTableOwner: PSQLCHAR, cbTableQualifier: TSqlSmallInt, szTableOwner: PSQLCHAR,
cbTableOwner: TSqlSmallInt, szTableName: PSQLCHAR, cbTableOwner: TSqlSmallInt, szTableName: PSQLCHAR,
cbTableName: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib, cbTableName: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib,
importc.} importc.}
proc SQLPrimaryKeys*(hstmt: TSqlHStmt, CatalogName: PSQLCHAR, proc SQLPrimaryKeys*(hstmt: SqlHStmt, CatalogName: PSQLCHAR,
NameLength1: TSqlSmallInt, SchemaName: PSQLCHAR, NameLength1: TSqlSmallInt, SchemaName: PSQLCHAR,
NameLength2: TSqlSmallInt, TableName: PSQLCHAR, NameLength2: TSqlSmallInt, TableName: PSQLCHAR,
NameLength3: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib, NameLength3: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib,
importc.} importc.}
proc SQLProcedureColumns*(hstmt: TSqlHStmt, CatalogName: PSQLCHAR, proc SQLProcedureColumns*(hstmt: SqlHStmt, CatalogName: PSQLCHAR,
NameLength1: TSqlSmallInt, SchemaName: PSQLCHAR, NameLength1: TSqlSmallInt, SchemaName: PSQLCHAR,
NameLength2: TSqlSmallInt, ProcName: PSQLCHAR, NameLength2: TSqlSmallInt, ProcName: PSQLCHAR,
NameLength3: TSqlSmallInt, ColumnName: PSQLCHAR, NameLength3: TSqlSmallInt, ColumnName: PSQLCHAR,
NameLength4: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib, NameLength4: TSqlSmallInt): TSqlSmallInt{.dynlib: odbclib,
importc.} importc.}
proc SQLStatistics*(hstmt: TSqlHStmt, CatalogName: PSQLCHAR, proc SQLStatistics*(hstmt: SqlHStmt, CatalogName: PSQLCHAR,
NameLength1: TSqlSmallInt, SchemaName: PSQLCHAR, NameLength1: TSqlSmallInt, SchemaName: PSQLCHAR,
NameLength2: TSqlSmallInt, TableName: PSQLCHAR, NameLength2: TSqlSmallInt, TableName: PSQLCHAR,
NameLength3: TSqlSmallInt, Unique: TSqlUSmallInt, NameLength3: TSqlSmallInt, Unique: SqlUSmallInt,
Reserved: TSqlUSmallInt): TSqlSmallInt {. Reserved: SqlUSmallInt): TSqlSmallInt {.
dynlib: odbclib, importc.} dynlib: odbclib, importc.}
{.pop.} {.pop.}

452
lib/wrappers/pdcurses.nim
View file

@ -406,15 +406,15 @@ type
button*: array[0..3 - 1, cshort] # state of each button button*: array[0..3 - 1, cshort] # state of each button
changes*: cint # flags indicating what has changed with the mouse changes*: cint # flags indicating what has changed with the mouse
TMEVENT*{.pure, final.} = object MEVENT*{.pure, final.} = object
id*: cshort # unused, always 0 id*: cshort # unused, always 0
x*: cint x*: cint
y*: cint y*: cint
z*: cint # x, y same as MOUSE_STATUS; z unused z*: cint # x, y same as TMOUSE_STATUS; z unused
bstate*: cunsignedlong # equivalent to changes + button[], but bstate*: cunsignedlong # equivalent to changes + button[], but
# in the same format as used for mousemask() # in the same format as used for mousemask()
TWINDOW*{.pure, final.} = object WINDOW*{.pure, final.} = object
cury*: cint # current pseudo-cursor cury*: cint # current pseudo-cursor
curx*: cint curx*: cint
maxy*: cint # max window coordinates maxy*: cint # max window coordinates
@ -439,26 +439,30 @@ type
delayms*: cint # milliseconds of delay for getch() delayms*: cint # milliseconds of delay for getch()
parx*: cint parx*: cint
pary*: cint # coords relative to parent (0,0) pary*: cint # coords relative to parent (0,0)
parent*: ptr TWINDOW # subwin's pointer to parent win parent*: ptr WINDOW # subwin's pointer to parent win
TPANELOBS*{.pure, final.} = object PANELOBS*{.pure, final.} = object
above*: ptr TPANELOBS above*: ptr PANELOBS
pan*: ptr TPANEL pan*: ptr PANEL
TPANEL*{.pure, final.} = object PANEL*{.pure, final.} = object
win*: ptr TWINDOW win*: ptr WINDOW
wstarty*: cint wstarty*: cint
wendy*: cint wendy*: cint
wstartx*: cint wstartx*: cint
wendx*: cint wendx*: cint
below*: ptr TPANEL below*: ptr PANEL
above*: ptr TPANEL above*: ptr PANEL
user*: pointer user*: pointer
obscure*: ptr TPANELOBS obscure*: ptr PANELOBS
{.deprecated: [
#TMOUSE_STATUS: MOUSE_STATUS, # Name conflict when we drop the `T`
TMEVENT: MEVENT, TWINDOW: WINDOW,
TPANELOBS: PANELOBS, TPANEL:PANEL].}
when unixOS: when unixOS:
type type
TSCREEN*{.pure, final.} = object SCREEN*{.pure, final.} = object
alive*: cunsignedchar # if initscr() called, and not endwin() alive*: cunsignedchar # if initscr() called, and not endwin()
autocr*: cunsignedchar # if cr -> lf autocr*: cunsignedchar # if cr -> lf
cbreak*: cunsignedchar # if terminal unbuffered cbreak*: cunsignedchar # if terminal unbuffered
@ -481,7 +485,7 @@ when unixOS:
map_mbe_to_key*: cunsignedlong # map mouse buttons to slk map_mbe_to_key*: cunsignedlong # map mouse buttons to slk
mouse_wait*: cint # time to wait (in ms) for a button release after a press mouse_wait*: cint # time to wait (in ms) for a button release after a press
slklines*: cint # lines in use by slk_init() slklines*: cint # lines in use by slk_init()
slk_winptr*: ptr TWINDOW # window for slk slk_winptr*: ptr WINDOW # window for slk
linesrippedoff*: cint # lines ripped off via ripoffline() linesrippedoff*: cint # lines ripped off via ripoffline()
linesrippedoffontop*: cint # lines ripped off on top via ripoffline() linesrippedoffontop*: cint # lines ripped off on top via ripoffline()
delaytenths*: cint # 1/10ths second to wait block getch() for delaytenths*: cint # 1/10ths second to wait block getch() for
@ -499,9 +503,10 @@ when unixOS:
sb_cur_y*: cint sb_cur_y*: cint
sb_cur_x*: cint sb_cur_x*: cint
line_color*: cshort # color of line attributes - default -1 line_color*: cshort # color of line attributes - default -1
{.deprecated: [TSCREEN: SCREEN].}
else: else:
type type
TSCREEN*{.pure, final.} = object SCREEN*{.pure, final.} = object
alive*: cunsignedchar # if initscr() called, and not endwin() alive*: cunsignedchar # if initscr() called, and not endwin()
autocr*: cunsignedchar # if cr -> lf autocr*: cunsignedchar # if cr -> lf
cbreak*: cunsignedchar # if terminal unbuffered cbreak*: cunsignedchar # if terminal unbuffered
@ -524,7 +529,7 @@ else:
map_mbe_to_key*: cunsignedlong # map mouse buttons to slk map_mbe_to_key*: cunsignedlong # map mouse buttons to slk
mouse_wait*: cint # time to wait (in ms) for a button release after a press mouse_wait*: cint # time to wait (in ms) for a button release after a press
slklines*: cint # lines in use by slk_init() slklines*: cint # lines in use by slk_init()
slk_winptr*: ptr TWINDOW # window for slk slk_winptr*: ptr WINDOW # window for slk
linesrippedoff*: cint # lines ripped off via ripoffline() linesrippedoff*: cint # lines ripped off via ripoffline()
linesrippedoffontop*: cint # lines ripped off on top via ripoffline() linesrippedoffontop*: cint # lines ripped off on top via ripoffline()
delaytenths*: cint # 1/10ths second to wait block getch() for delaytenths*: cint # 1/10ths second to wait block getch() for
@ -534,14 +539,15 @@ else:
return_key_modifiers*: cunsignedchar # TRUE if modifier keys are returned as "real" keys return_key_modifiers*: cunsignedchar # TRUE if modifier keys are returned as "real" keys
key_code*: cunsignedchar # TRUE if last key is a special key; key_code*: cunsignedchar # TRUE if last key is a special key;
line_color*: cshort # color of line attributes - default -1 line_color*: cshort # color of line attributes - default -1
{.deprecated: [TSCREEN: SCREEN].}
var var
LINES*{.importc: "LINES", dynlib: pdcursesdll.}: cint LINES*{.importc: "LINES", dynlib: pdcursesdll.}: cint
COLS*{.importc: "COLS", dynlib: pdcursesdll.}: cint COLS*{.importc: "COLS", dynlib: pdcursesdll.}: cint
stdscr*{.importc: "stdscr", dynlib: pdcursesdll.}: ptr TWINDOW stdscr*{.importc: "stdscr", dynlib: pdcursesdll.}: ptr WINDOW
curscr*{.importc: "curscr", dynlib: pdcursesdll.}: ptr TWINDOW curscr*{.importc: "curscr", dynlib: pdcursesdll.}: ptr WINDOW
SP*{.importc: "SP", dynlib: pdcursesdll.}: ptr TSCREEN SP*{.importc: "SP", dynlib: pdcursesdll.}: ptr SCREEN
Mouse_status*{.importc: "Mouse_status", dynlib: pdcursesdll.}: TMOUSE_STATUS Mouse_status*{.importc: "Mouse_status", dynlib: pdcursesdll.}: MOUSE_STATUS
COLORS*{.importc: "COLORS", dynlib: pdcursesdll.}: cint COLORS*{.importc: "COLORS", dynlib: pdcursesdll.}: cint
COLOR_PAIRS*{.importc: "COLOR_PAIRS", dynlib: pdcursesdll.}: cint COLOR_PAIRS*{.importc: "COLOR_PAIRS", dynlib: pdcursesdll.}: cint
TABSIZE*{.importc: "TABSIZE", dynlib: pdcursesdll.}: cint TABSIZE*{.importc: "TABSIZE", dynlib: pdcursesdll.}: cint
@ -690,14 +696,14 @@ proc border*(a2: cunsignedlong; a3: cunsignedlong; a4: cunsignedlong;
a5: cunsignedlong; a6: cunsignedlong; a7: cunsignedlong; a5: cunsignedlong; a6: cunsignedlong; a7: cunsignedlong;
a8: cunsignedlong; a9: cunsignedlong): cint{.extdecl, a8: cunsignedlong; a9: cunsignedlong): cint{.extdecl,
importc: "border", dynlib: pdcursesdll.} importc: "border", dynlib: pdcursesdll.}
proc box*(a2: ptr TWINDOW; a3: cunsignedlong; a4: cunsignedlong): cint{.extdecl, proc box*(a2: ptr WINDOW; a3: cunsignedlong; a4: cunsignedlong): cint{.extdecl,
importc: "box", dynlib: pdcursesdll.} importc: "box", dynlib: pdcursesdll.}
proc can_change_color*(): cunsignedchar{.extdecl, importc: "can_change_color", proc can_change_color*(): cunsignedchar{.extdecl, importc: "can_change_color",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc cbreak*(): cint{.extdecl, importc: "cbreak", dynlib: pdcursesdll.} proc cbreak*(): cint{.extdecl, importc: "cbreak", dynlib: pdcursesdll.}
proc chgat*(a2: cint; a3: cunsignedlong; a4: cshort; a5: pointer): cint{.extdecl, proc chgat*(a2: cint; a3: cunsignedlong; a4: cshort; a5: pointer): cint{.extdecl,
importc: "chgat", dynlib: pdcursesdll.} importc: "chgat", dynlib: pdcursesdll.}
proc clearok*(a2: ptr TWINDOW; a3: cunsignedchar): cint{.extdecl, proc clearok*(a2: ptr WINDOW; a3: cunsignedchar): cint{.extdecl,
importc: "clearok", dynlib: pdcursesdll.} importc: "clearok", dynlib: pdcursesdll.}
proc clear*(): cint{.extdecl, importc: "clear", dynlib: pdcursesdll.} proc clear*(): cint{.extdecl, importc: "clear", dynlib: pdcursesdll.}
proc clrtobot*(): cint{.extdecl, importc: "clrtobot", dynlib: pdcursesdll.} proc clrtobot*(): cint{.extdecl, importc: "clrtobot", dynlib: pdcursesdll.}
@ -706,7 +712,7 @@ proc color_content*(a2: cshort; a3: ptr cshort; a4: ptr cshort; a5: ptr cshort):
extdecl, importc: "color_content", dynlib: pdcursesdll.} extdecl, importc: "color_content", dynlib: pdcursesdll.}
proc color_set*(a2: cshort; a3: pointer): cint{.extdecl, importc: "color_set", proc color_set*(a2: cshort; a3: pointer): cint{.extdecl, importc: "color_set",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc copywin*(a2: ptr TWINDOW; a3: ptr TWINDOW; a4: cint; a5: cint; a6: cint; proc copywin*(a2: ptr WINDOW; a3: ptr WINDOW; a4: cint; a5: cint; a6: cint;
a7: cint; a8: cint; a9: cint; a10: cint): cint{.extdecl, a7: cint; a8: cint; a9: cint; a10: cint): cint{.extdecl,
importc: "copywin", dynlib: pdcursesdll.} importc: "copywin", dynlib: pdcursesdll.}
proc curs_set*(a2: cint): cint{.extdecl, importc: "curs_set", dynlib: pdcursesdll.} proc curs_set*(a2: cint): cint{.extdecl, importc: "curs_set", dynlib: pdcursesdll.}
@ -718,14 +724,14 @@ proc delay_output*(a2: cint): cint{.extdecl, importc: "delay_output",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc delch*(): cint{.extdecl, importc: "delch", dynlib: pdcursesdll.} proc delch*(): cint{.extdecl, importc: "delch", dynlib: pdcursesdll.}
proc deleteln*(): cint{.extdecl, importc: "deleteln", dynlib: pdcursesdll.} proc deleteln*(): cint{.extdecl, importc: "deleteln", dynlib: pdcursesdll.}
proc delscreen*(a2: ptr TSCREEN){.extdecl, importc: "delscreen", proc delscreen*(a2: ptr SCREEN){.extdecl, importc: "delscreen",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc delwin*(a2: ptr TWINDOW): cint{.extdecl, importc: "delwin", proc delwin*(a2: ptr WINDOW): cint{.extdecl, importc: "delwin",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc derwin*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cint; a6: cint): ptr TWINDOW{. proc derwin*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cint; a6: cint): ptr WINDOW{.
extdecl, importc: "derwin", dynlib: pdcursesdll.} extdecl, importc: "derwin", dynlib: pdcursesdll.}
proc doupdate*(): cint{.extdecl, importc: "doupdate", dynlib: pdcursesdll.} proc doupdate*(): cint{.extdecl, importc: "doupdate", dynlib: pdcursesdll.}
proc dupwin*(a2: ptr TWINDOW): ptr TWINDOW{.extdecl, importc: "dupwin", proc dupwin*(a2: ptr WINDOW): ptr WINDOW{.extdecl, importc: "dupwin",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc echochar*(a2: cunsignedlong): cint{.extdecl, importc: "echochar", proc echochar*(a2: cunsignedlong): cint{.extdecl, importc: "echochar",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
@ -736,12 +742,12 @@ proc erase*(): cint{.extdecl, importc: "erase", dynlib: pdcursesdll.}
proc filter*(){.extdecl, importc: "filter", dynlib: pdcursesdll.} proc filter*(){.extdecl, importc: "filter", dynlib: pdcursesdll.}
proc flash*(): cint{.extdecl, importc: "flash", dynlib: pdcursesdll.} proc flash*(): cint{.extdecl, importc: "flash", dynlib: pdcursesdll.}
proc flushinp*(): cint{.extdecl, importc: "flushinp", dynlib: pdcursesdll.} proc flushinp*(): cint{.extdecl, importc: "flushinp", dynlib: pdcursesdll.}
proc getbkgd*(a2: ptr TWINDOW): cunsignedlong{.extdecl, importc: "getbkgd", proc getbkgd*(a2: ptr WINDOW): cunsignedlong{.extdecl, importc: "getbkgd",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc getnstr*(a2: cstring; a3: cint): cint{.extdecl, importc: "getnstr", proc getnstr*(a2: cstring; a3: cint): cint{.extdecl, importc: "getnstr",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc getstr*(a2: cstring): cint{.extdecl, importc: "getstr", dynlib: pdcursesdll.} proc getstr*(a2: cstring): cint{.extdecl, importc: "getstr", dynlib: pdcursesdll.}
proc getwin*(a2: File): ptr TWINDOW{.extdecl, importc: "getwin", proc getwin*(a2: File): ptr WINDOW{.extdecl, importc: "getwin",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc halfdelay*(a2: cint): cint{.extdecl, importc: "halfdelay", proc halfdelay*(a2: cint): cint{.extdecl, importc: "halfdelay",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
@ -751,11 +757,11 @@ proc has_ic*(): cunsignedchar{.extdecl, importc: "has_ic", dynlib: pdcursesdll.}
proc has_il*(): cunsignedchar{.extdecl, importc: "has_il", dynlib: pdcursesdll.} proc has_il*(): cunsignedchar{.extdecl, importc: "has_il", dynlib: pdcursesdll.}
proc hline*(a2: cunsignedlong; a3: cint): cint{.extdecl, importc: "hline", proc hline*(a2: cunsignedlong; a3: cint): cint{.extdecl, importc: "hline",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc idcok*(a2: ptr TWINDOW; a3: cunsignedchar){.extdecl, importc: "idcok", proc idcok*(a2: ptr WINDOW; a3: cunsignedchar){.extdecl, importc: "idcok",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc idlok*(a2: ptr TWINDOW; a3: cunsignedchar): cint{.extdecl, importc: "idlok", proc idlok*(a2: ptr WINDOW; a3: cunsignedchar): cint{.extdecl, importc: "idlok",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc immedok*(a2: ptr TWINDOW; a3: cunsignedchar){.extdecl, importc: "immedok", proc immedok*(a2: ptr WINDOW; a3: cunsignedchar){.extdecl, importc: "immedok",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc inchnstr*(a2: ptr cunsignedlong; a3: cint): cint{.extdecl, proc inchnstr*(a2: ptr cunsignedlong; a3: cint): cint{.extdecl,
importc: "inchnstr", dynlib: pdcursesdll.} importc: "inchnstr", dynlib: pdcursesdll.}
@ -766,7 +772,7 @@ proc init_color*(a2: cshort; a3: cshort; a4: cshort; a5: cshort): cint{.extdecl,
importc: "init_color", dynlib: pdcursesdll.} importc: "init_color", dynlib: pdcursesdll.}
proc init_pair*(a2: cshort; a3: cshort; a4: cshort): cint{.extdecl, proc init_pair*(a2: cshort; a3: cshort; a4: cshort): cint{.extdecl,
importc: "init_pair", dynlib: pdcursesdll.} importc: "init_pair", dynlib: pdcursesdll.}
proc initscr*(): ptr TWINDOW{.extdecl, importc: "initscr", dynlib: pdcursesdll.} proc initscr*(): ptr WINDOW{.extdecl, importc: "initscr", dynlib: pdcursesdll.}
proc innstr*(a2: cstring; a3: cint): cint{.extdecl, importc: "innstr", proc innstr*(a2: cstring; a3: cint): cint{.extdecl, importc: "innstr",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc insch*(a2: cunsignedlong): cint{.extdecl, importc: "insch", proc insch*(a2: cunsignedlong): cint{.extdecl, importc: "insch",
@ -777,21 +783,21 @@ proc insnstr*(a2: cstring; a3: cint): cint{.extdecl, importc: "insnstr",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc insstr*(a2: cstring): cint{.extdecl, importc: "insstr", dynlib: pdcursesdll.} proc insstr*(a2: cstring): cint{.extdecl, importc: "insstr", dynlib: pdcursesdll.}
proc instr*(a2: cstring): cint{.extdecl, importc: "instr", dynlib: pdcursesdll.} proc instr*(a2: cstring): cint{.extdecl, importc: "instr", dynlib: pdcursesdll.}
proc intrflush*(a2: ptr TWINDOW; a3: cunsignedchar): cint{.extdecl, proc intrflush*(a2: ptr WINDOW; a3: cunsignedchar): cint{.extdecl,
importc: "intrflush", dynlib: pdcursesdll.} importc: "intrflush", dynlib: pdcursesdll.}
proc isendwin*(): cunsignedchar{.extdecl, importc: "isendwin", dynlib: pdcursesdll.} proc isendwin*(): cunsignedchar{.extdecl, importc: "isendwin", dynlib: pdcursesdll.}
proc is_linetouched*(a2: ptr TWINDOW; a3: cint): cunsignedchar{.extdecl, proc is_linetouched*(a2: ptr WINDOW; a3: cint): cunsignedchar{.extdecl,
importc: "is_linetouched", dynlib: pdcursesdll.} importc: "is_linetouched", dynlib: pdcursesdll.}
proc is_wintouched*(a2: ptr TWINDOW): cunsignedchar{.extdecl, proc is_wintouched*(a2: ptr WINDOW): cunsignedchar{.extdecl,
importc: "is_wintouched", dynlib: pdcursesdll.} importc: "is_wintouched", dynlib: pdcursesdll.}
proc keyname*(a2: cint): cstring{.extdecl, importc: "keyname", dynlib: pdcursesdll.} proc keyname*(a2: cint): cstring{.extdecl, importc: "keyname", dynlib: pdcursesdll.}
proc keypad*(a2: ptr TWINDOW; a3: cunsignedchar): cint{.extdecl, importc: "keypad", proc keypad*(a2: ptr WINDOW; a3: cunsignedchar): cint{.extdecl, importc: "keypad",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc killchar*(): char{.extdecl, importc: "killchar", dynlib: pdcursesdll.} proc killchar*(): char{.extdecl, importc: "killchar", dynlib: pdcursesdll.}
proc leaveok*(a2: ptr TWINDOW; a3: cunsignedchar): cint{.extdecl, proc leaveok*(a2: ptr WINDOW; a3: cunsignedchar): cint{.extdecl,
importc: "leaveok", dynlib: pdcursesdll.} importc: "leaveok", dynlib: pdcursesdll.}
proc longname*(): cstring{.extdecl, importc: "longname", dynlib: pdcursesdll.} proc longname*(): cstring{.extdecl, importc: "longname", dynlib: pdcursesdll.}
proc meta*(a2: ptr TWINDOW; a3: cunsignedchar): cint{.extdecl, importc: "meta", proc meta*(a2: ptr WINDOW; a3: cunsignedchar): cint{.extdecl, importc: "meta",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc move*(a2: cint; a3: cint): cint{.extdecl, importc: "move", proc move*(a2: cint; a3: cint): cint{.extdecl, importc: "move",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
@ -811,7 +817,7 @@ proc mvcur*(a2: cint; a3: cint; a4: cint; a5: cint): cint{.extdecl,
importc: "mvcur", dynlib: pdcursesdll.} importc: "mvcur", dynlib: pdcursesdll.}
proc mvdelch*(a2: cint; a3: cint): cint{.extdecl, importc: "mvdelch", proc mvdelch*(a2: cint; a3: cint): cint{.extdecl, importc: "mvdelch",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc mvderwin*(a2: ptr TWINDOW; a3: cint; a4: cint): cint{.extdecl, proc mvderwin*(a2: ptr WINDOW; a3: cint; a4: cint): cint{.extdecl,
importc: "mvderwin", dynlib: pdcursesdll.} importc: "mvderwin", dynlib: pdcursesdll.}
proc mvgetch*(a2: cint; a3: cint): cint{.extdecl, importc: "mvgetch", proc mvgetch*(a2: cint; a3: cint): cint{.extdecl, importc: "mvgetch",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
@ -843,92 +849,92 @@ proc mvscanw*(a2: cint; a3: cint; a4: cstring): cint{.varargs, extdecl,
importc: "mvscanw", dynlib: pdcursesdll.} importc: "mvscanw", dynlib: pdcursesdll.}
proc mvvline*(a2: cint; a3: cint; a4: cunsignedlong; a5: cint): cint{.extdecl, proc mvvline*(a2: cint; a3: cint; a4: cunsignedlong; a5: cint): cint{.extdecl,
importc: "mvvline", dynlib: pdcursesdll.} importc: "mvvline", dynlib: pdcursesdll.}
proc mvwaddchnstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong; proc mvwaddchnstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong;
a6: cint): cint{.extdecl, importc: "mvwaddchnstr", a6: cint): cint{.extdecl, importc: "mvwaddchnstr",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc mvwaddchstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong): cint{. proc mvwaddchstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong): cint{.
extdecl, importc: "mvwaddchstr", dynlib: pdcursesdll.} extdecl, importc: "mvwaddchstr", dynlib: pdcursesdll.}
proc mvwaddch*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cunsignedlong): cint{. proc mvwaddch*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cunsignedlong): cint{.
extdecl, importc: "mvwaddch", dynlib: pdcursesdll.} extdecl, importc: "mvwaddch", dynlib: pdcursesdll.}
proc mvwaddnstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cstring; a6: cint): cint{. proc mvwaddnstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cstring; a6: cint): cint{.
extdecl, importc: "mvwaddnstr", dynlib: pdcursesdll.} extdecl, importc: "mvwaddnstr", dynlib: pdcursesdll.}
proc mvwaddstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cstring): cint{.extdecl, proc mvwaddstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cstring): cint{.extdecl,
importc: "mvwaddstr", dynlib: pdcursesdll.} importc: "mvwaddstr", dynlib: pdcursesdll.}
proc mvwchgat*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cint; a6: cunsignedlong; proc mvwchgat*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cint; a6: cunsignedlong;
a7: cshort; a8: pointer): cint{.extdecl, importc: "mvwchgat", a7: cshort; a8: pointer): cint{.extdecl, importc: "mvwchgat",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc mvwdelch*(a2: ptr TWINDOW; a3: cint; a4: cint): cint{.extdecl, proc mvwdelch*(a2: ptr WINDOW; a3: cint; a4: cint): cint{.extdecl,
importc: "mvwdelch", dynlib: pdcursesdll.} importc: "mvwdelch", dynlib: pdcursesdll.}
proc mvwgetch*(a2: ptr TWINDOW; a3: cint; a4: cint): cint{.extdecl, proc mvwgetch*(a2: ptr WINDOW; a3: cint; a4: cint): cint{.extdecl,
importc: "mvwgetch", dynlib: pdcursesdll.} importc: "mvwgetch", dynlib: pdcursesdll.}
proc mvwgetnstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cstring; a6: cint): cint{. proc mvwgetnstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cstring; a6: cint): cint{.
extdecl, importc: "mvwgetnstr", dynlib: pdcursesdll.} extdecl, importc: "mvwgetnstr", dynlib: pdcursesdll.}
proc mvwgetstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cstring): cint{.extdecl, proc mvwgetstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cstring): cint{.extdecl,
importc: "mvwgetstr", dynlib: pdcursesdll.} importc: "mvwgetstr", dynlib: pdcursesdll.}
proc mvwhline*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cunsignedlong; a6: cint): cint{. proc mvwhline*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cunsignedlong; a6: cint): cint{.
extdecl, importc: "mvwhline", dynlib: pdcursesdll.} extdecl, importc: "mvwhline", dynlib: pdcursesdll.}
proc mvwinchnstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong; proc mvwinchnstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong;
a6: cint): cint{.extdecl, importc: "mvwinchnstr", a6: cint): cint{.extdecl, importc: "mvwinchnstr",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc mvwinchstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong): cint{. proc mvwinchstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong): cint{.
extdecl, importc: "mvwinchstr", dynlib: pdcursesdll.} extdecl, importc: "mvwinchstr", dynlib: pdcursesdll.}
proc mvwinch*(a2: ptr TWINDOW; a3: cint; a4: cint): cunsignedlong{.extdecl, proc mvwinch*(a2: ptr WINDOW; a3: cint; a4: cint): cunsignedlong{.extdecl,
importc: "mvwinch", dynlib: pdcursesdll.} importc: "mvwinch", dynlib: pdcursesdll.}
proc mvwinnstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cstring; a6: cint): cint{. proc mvwinnstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cstring; a6: cint): cint{.
extdecl, importc: "mvwinnstr", dynlib: pdcursesdll.} extdecl, importc: "mvwinnstr", dynlib: pdcursesdll.}
proc mvwinsch*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cunsignedlong): cint{. proc mvwinsch*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cunsignedlong): cint{.
extdecl, importc: "mvwinsch", dynlib: pdcursesdll.} extdecl, importc: "mvwinsch", dynlib: pdcursesdll.}
proc mvwinsnstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cstring; a6: cint): cint{. proc mvwinsnstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cstring; a6: cint): cint{.
extdecl, importc: "mvwinsnstr", dynlib: pdcursesdll.} extdecl, importc: "mvwinsnstr", dynlib: pdcursesdll.}
proc mvwinsstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cstring): cint{.extdecl, proc mvwinsstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cstring): cint{.extdecl,
importc: "mvwinsstr", dynlib: pdcursesdll.} importc: "mvwinsstr", dynlib: pdcursesdll.}
proc mvwinstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cstring): cint{.extdecl, proc mvwinstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cstring): cint{.extdecl,
importc: "mvwinstr", dynlib: pdcursesdll.} importc: "mvwinstr", dynlib: pdcursesdll.}
proc mvwin*(a2: ptr TWINDOW; a3: cint; a4: cint): cint{.extdecl, importc: "mvwin", proc mvwin*(a2: ptr WINDOW; a3: cint; a4: cint): cint{.extdecl, importc: "mvwin",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc mvwprintw*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cstring): cint{.varargs, proc mvwprintw*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cstring): cint{.varargs,
extdecl, importc: "mvwprintw", dynlib: pdcursesdll.} extdecl, importc: "mvwprintw", dynlib: pdcursesdll.}
proc mvwscanw*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cstring): cint{.varargs, proc mvwscanw*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cstring): cint{.varargs,
extdecl, importc: "mvwscanw", dynlib: pdcursesdll.} extdecl, importc: "mvwscanw", dynlib: pdcursesdll.}
proc mvwvline*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cunsignedlong; a6: cint): cint{. proc mvwvline*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cunsignedlong; a6: cint): cint{.
extdecl, importc: "mvwvline", dynlib: pdcursesdll.} extdecl, importc: "mvwvline", dynlib: pdcursesdll.}
proc napms*(a2: cint): cint{.extdecl, importc: "napms", dynlib: pdcursesdll.} proc napms*(a2: cint): cint{.extdecl, importc: "napms", dynlib: pdcursesdll.}
proc newpad*(a2: cint; a3: cint): ptr TWINDOW{.extdecl, importc: "newpad", proc newpad*(a2: cint; a3: cint): ptr WINDOW{.extdecl, importc: "newpad",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc newterm*(a2: cstring; a3: File; a4: File): ptr TSCREEN{.extdecl, proc newterm*(a2: cstring; a3: File; a4: File): ptr SCREEN{.extdecl,
importc: "newterm", dynlib: pdcursesdll.} importc: "newterm", dynlib: pdcursesdll.}
proc newwin*(a2: cint; a3: cint; a4: cint; a5: cint): ptr TWINDOW{.extdecl, proc newwin*(a2: cint; a3: cint; a4: cint; a5: cint): ptr WINDOW{.extdecl,
importc: "newwin", dynlib: pdcursesdll.} importc: "newwin", dynlib: pdcursesdll.}
proc nl*(): cint{.extdecl, importc: "nl", dynlib: pdcursesdll.} proc nl*(): cint{.extdecl, importc: "nl", dynlib: pdcursesdll.}
proc nocbreak*(): cint{.extdecl, importc: "nocbreak", dynlib: pdcursesdll.} proc nocbreak*(): cint{.extdecl, importc: "nocbreak", dynlib: pdcursesdll.}
proc nodelay*(a2: ptr TWINDOW; a3: cunsignedchar): cint{.extdecl, proc nodelay*(a2: ptr WINDOW; a3: cunsignedchar): cint{.extdecl,
importc: "nodelay", dynlib: pdcursesdll.} importc: "nodelay", dynlib: pdcursesdll.}
proc noecho*(): cint{.extdecl, importc: "noecho", dynlib: pdcursesdll.} proc noecho*(): cint{.extdecl, importc: "noecho", dynlib: pdcursesdll.}
proc nonl*(): cint{.extdecl, importc: "nonl", dynlib: pdcursesdll.} proc nonl*(): cint{.extdecl, importc: "nonl", dynlib: pdcursesdll.}
proc noqiflush*(){.extdecl, importc: "noqiflush", dynlib: pdcursesdll.} proc noqiflush*(){.extdecl, importc: "noqiflush", dynlib: pdcursesdll.}
proc noraw*(): cint{.extdecl, importc: "noraw", dynlib: pdcursesdll.} proc noraw*(): cint{.extdecl, importc: "noraw", dynlib: pdcursesdll.}
proc notimeout*(a2: ptr TWINDOW; a3: cunsignedchar): cint{.extdecl, proc notimeout*(a2: ptr WINDOW; a3: cunsignedchar): cint{.extdecl,
importc: "notimeout", dynlib: pdcursesdll.} importc: "notimeout", dynlib: pdcursesdll.}
proc overlay*(a2: ptr TWINDOW; a3: ptr TWINDOW): cint{.extdecl, importc: "overlay", proc overlay*(a2: ptr WINDOW; a3: ptr WINDOW): cint{.extdecl, importc: "overlay",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc overwrite*(a2: ptr TWINDOW; a3: ptr TWINDOW): cint{.extdecl, proc overwrite*(a2: ptr WINDOW; a3: ptr WINDOW): cint{.extdecl,
importc: "overwrite", dynlib: pdcursesdll.} importc: "overwrite", dynlib: pdcursesdll.}
proc pair_content*(a2: cshort; a3: ptr cshort; a4: ptr cshort): cint{.extdecl, proc pair_content*(a2: cshort; a3: ptr cshort; a4: ptr cshort): cint{.extdecl,
importc: "pair_content", dynlib: pdcursesdll.} importc: "pair_content", dynlib: pdcursesdll.}
proc pechochar*(a2: ptr TWINDOW; a3: cunsignedlong): cint{.extdecl, proc pechochar*(a2: ptr WINDOW; a3: cunsignedlong): cint{.extdecl,
importc: "pechochar", dynlib: pdcursesdll.} importc: "pechochar", dynlib: pdcursesdll.}
proc pnoutrefresh*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cint; a6: cint; proc pnoutrefresh*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cint; a6: cint;
a7: cint; a8: cint): cint{.extdecl, importc: "pnoutrefresh", a7: cint; a8: cint): cint{.extdecl, importc: "pnoutrefresh",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc prefresh*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cint; a6: cint; a7: cint; proc prefresh*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cint; a6: cint; a7: cint;
a8: cint): cint{.extdecl, importc: "prefresh", dynlib: pdcursesdll.} a8: cint): cint{.extdecl, importc: "prefresh", dynlib: pdcursesdll.}
proc printw*(a2: cstring): cint{.varargs, extdecl, importc: "printw", proc printw*(a2: cstring): cint{.varargs, extdecl, importc: "printw",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc putwin*(a2: ptr TWINDOW; a3: File): cint{.extdecl, importc: "putwin", proc putwin*(a2: ptr WINDOW; a3: File): cint{.extdecl, importc: "putwin",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc qiflush*(){.extdecl, importc: "qiflush", dynlib: pdcursesdll.} proc qiflush*(){.extdecl, importc: "qiflush", dynlib: pdcursesdll.}
proc raw*(): cint{.extdecl, importc: "raw", dynlib: pdcursesdll.} proc raw*(): cint{.extdecl, importc: "raw", dynlib: pdcursesdll.}
proc redrawwin*(a2: ptr TWINDOW): cint{.extdecl, importc: "redrawwin", proc redrawwin*(a2: ptr WINDOW): cint{.extdecl, importc: "redrawwin",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc refresh*(): cint{.extdecl, importc: "refresh", dynlib: pdcursesdll.} proc refresh*(): cint{.extdecl, importc: "refresh", dynlib: pdcursesdll.}
proc reset_prog_mode*(): cint{.extdecl, importc: "reset_prog_mode", proc reset_prog_mode*(): cint{.extdecl, importc: "reset_prog_mode",
@ -936,7 +942,7 @@ proc reset_prog_mode*(): cint{.extdecl, importc: "reset_prog_mode",
proc reset_shell_mode*(): cint{.extdecl, importc: "reset_shell_mode", proc reset_shell_mode*(): cint{.extdecl, importc: "reset_shell_mode",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc resetty*(): cint{.extdecl, importc: "resetty", dynlib: pdcursesdll.} proc resetty*(): cint{.extdecl, importc: "resetty", dynlib: pdcursesdll.}
#int ripoffline(int, int (*)(TWINDOW *, int)); #int ripoffline(int, int (*)(WINDOW *, int));
proc savetty*(): cint{.extdecl, importc: "savetty", dynlib: pdcursesdll.} proc savetty*(): cint{.extdecl, importc: "savetty", dynlib: pdcursesdll.}
proc scanw*(a2: cstring): cint{.varargs, extdecl, importc: "scanw", proc scanw*(a2: cstring): cint{.varargs, extdecl, importc: "scanw",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
@ -948,11 +954,11 @@ proc scr_restore*(a2: cstring): cint{.extdecl, importc: "scr_restore",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc scr_set*(a2: cstring): cint{.extdecl, importc: "scr_set", dynlib: pdcursesdll.} proc scr_set*(a2: cstring): cint{.extdecl, importc: "scr_set", dynlib: pdcursesdll.}
proc scrl*(a2: cint): cint{.extdecl, importc: "scrl", dynlib: pdcursesdll.} proc scrl*(a2: cint): cint{.extdecl, importc: "scrl", dynlib: pdcursesdll.}
proc scroll*(a2: ptr TWINDOW): cint{.extdecl, importc: "scroll", proc scroll*(a2: ptr WINDOW): cint{.extdecl, importc: "scroll",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc scrollok*(a2: ptr TWINDOW; a3: cunsignedchar): cint{.extdecl, proc scrollok*(a2: ptr WINDOW; a3: cunsignedchar): cint{.extdecl,
importc: "scrollok", dynlib: pdcursesdll.} importc: "scrollok", dynlib: pdcursesdll.}
proc set_term*(a2: ptr TSCREEN): ptr TSCREEN{.extdecl, importc: "set_term", proc set_term*(a2: ptr SCREEN): ptr SCREEN{.extdecl, importc: "set_term",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc setscrreg*(a2: cint; a3: cint): cint{.extdecl, importc: "setscrreg", proc setscrreg*(a2: cint; a3: cint): cint{.extdecl, importc: "setscrreg",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
@ -984,11 +990,11 @@ proc slk_touch*(): cint{.extdecl, importc: "slk_touch", dynlib: pdcursesdll.}
proc standend*(): cint{.extdecl, importc: "standend", dynlib: pdcursesdll.} proc standend*(): cint{.extdecl, importc: "standend", dynlib: pdcursesdll.}
proc standout*(): cint{.extdecl, importc: "standout", dynlib: pdcursesdll.} proc standout*(): cint{.extdecl, importc: "standout", dynlib: pdcursesdll.}
proc start_color*(): cint{.extdecl, importc: "start_color", dynlib: pdcursesdll.} proc start_color*(): cint{.extdecl, importc: "start_color", dynlib: pdcursesdll.}
proc subpad*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cint; a6: cint): ptr TWINDOW{. proc subpad*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cint; a6: cint): ptr WINDOW{.
extdecl, importc: "subpad", dynlib: pdcursesdll.} extdecl, importc: "subpad", dynlib: pdcursesdll.}
proc subwin*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cint; a6: cint): ptr TWINDOW{. proc subwin*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cint; a6: cint): ptr WINDOW{.
extdecl, importc: "subwin", dynlib: pdcursesdll.} extdecl, importc: "subwin", dynlib: pdcursesdll.}
proc syncok*(a2: ptr TWINDOW; a3: cunsignedchar): cint{.extdecl, importc: "syncok", proc syncok*(a2: ptr WINDOW; a3: cunsignedchar): cint{.extdecl, importc: "syncok",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc termattrs*(): cunsignedlong{.extdecl, importc: "termattrs", proc termattrs*(): cunsignedlong{.extdecl, importc: "termattrs",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
@ -996,13 +1002,13 @@ proc termattrs2*(): cunsignedlong{.extdecl, importc: "term_attrs",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc termname*(): cstring{.extdecl, importc: "termname", dynlib: pdcursesdll.} proc termname*(): cstring{.extdecl, importc: "termname", dynlib: pdcursesdll.}
proc timeout*(a2: cint){.extdecl, importc: "timeout", dynlib: pdcursesdll.} proc timeout*(a2: cint){.extdecl, importc: "timeout", dynlib: pdcursesdll.}
proc touchline*(a2: ptr TWINDOW; a3: cint; a4: cint): cint{.extdecl, proc touchline*(a2: ptr WINDOW; a3: cint; a4: cint): cint{.extdecl,
importc: "touchline", dynlib: pdcursesdll.} importc: "touchline", dynlib: pdcursesdll.}
proc touchwin*(a2: ptr TWINDOW): cint{.extdecl, importc: "touchwin", proc touchwin*(a2: ptr WINDOW): cint{.extdecl, importc: "touchwin",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc typeahead*(a2: cint): cint{.extdecl, importc: "typeahead", proc typeahead*(a2: cint): cint{.extdecl, importc: "typeahead",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc untouchwin*(a2: ptr TWINDOW): cint{.extdecl, importc: "untouchwin", proc untouchwin*(a2: ptr WINDOW): cint{.extdecl, importc: "untouchwin",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc use_env*(a2: cunsignedchar){.extdecl, importc: "use_env", dynlib: pdcursesdll.} proc use_env*(a2: cunsignedchar){.extdecl, importc: "use_env", dynlib: pdcursesdll.}
proc vidattr*(a2: cunsignedlong): cint{.extdecl, importc: "vidattr", proc vidattr*(a2: cunsignedlong): cint{.extdecl, importc: "vidattr",
@ -1013,123 +1019,123 @@ proc vid_attr*(a2: cunsignedlong; a3: cshort; a4: pointer): cint{.extdecl,
#int vid_puts(attr_t, short, void *, int (*)(int)); #int vid_puts(attr_t, short, void *, int (*)(int));
proc vline*(a2: cunsignedlong; a3: cint): cint{.extdecl, importc: "vline", proc vline*(a2: cunsignedlong; a3: cint): cint{.extdecl, importc: "vline",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc vwprintw*(a2: ptr TWINDOW; a3: cstring): cint{.extdecl, varargs, proc vwprintw*(a2: ptr WINDOW; a3: cstring): cint{.extdecl, varargs,
importc: "vw_printw", dynlib: pdcursesdll.} importc: "vw_printw", dynlib: pdcursesdll.}
proc vwprintw2*(a2: ptr TWINDOW; a3: cstring): cint{.extdecl, varargs, proc vwprintw2*(a2: ptr WINDOW; a3: cstring): cint{.extdecl, varargs,
importc: "vwprintw", dynlib: pdcursesdll.} importc: "vwprintw", dynlib: pdcursesdll.}
proc vwscanw*(a2: ptr TWINDOW; a3: cstring): cint{.extdecl, varargs, proc vwscanw*(a2: ptr WINDOW; a3: cstring): cint{.extdecl, varargs,
importc: "vw_scanw", dynlib: pdcursesdll.} importc: "vw_scanw", dynlib: pdcursesdll.}
proc vwscanw2*(a2: ptr TWINDOW; a3: cstring): cint{.extdecl, varargs, proc vwscanw2*(a2: ptr WINDOW; a3: cstring): cint{.extdecl, varargs,
importc: "vwscanw", dynlib: pdcursesdll.} importc: "vwscanw", dynlib: pdcursesdll.}
proc waddchnstr*(a2: ptr TWINDOW; a3: ptr cunsignedlong; a4: cint): cint{.extdecl, proc waddchnstr*(a2: ptr WINDOW; a3: ptr cunsignedlong; a4: cint): cint{.extdecl,
importc: "waddchnstr", dynlib: pdcursesdll.} importc: "waddchnstr", dynlib: pdcursesdll.}
proc waddchstr*(a2: ptr TWINDOW; a3: ptr cunsignedlong): cint{.extdecl, proc waddchstr*(a2: ptr WINDOW; a3: ptr cunsignedlong): cint{.extdecl,
importc: "waddchstr", dynlib: pdcursesdll.} importc: "waddchstr", dynlib: pdcursesdll.}
proc waddch*(a2: ptr TWINDOW; a3: cunsignedlong): cint{.extdecl, importc: "waddch", proc waddch*(a2: ptr WINDOW; a3: cunsignedlong): cint{.extdecl, importc: "waddch",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc waddnstr*(a2: ptr TWINDOW; a3: cstring; a4: cint): cint{.extdecl, proc waddnstr*(a2: ptr WINDOW; a3: cstring; a4: cint): cint{.extdecl,
importc: "waddnstr", dynlib: pdcursesdll.} importc: "waddnstr", dynlib: pdcursesdll.}
proc waddstr*(a2: ptr TWINDOW; a3: cstring): cint{.extdecl, importc: "waddstr", proc waddstr*(a2: ptr WINDOW; a3: cstring): cint{.extdecl, importc: "waddstr",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wattroff*(a2: ptr TWINDOW; a3: cunsignedlong): cint{.extdecl, proc wattroff*(a2: ptr WINDOW; a3: cunsignedlong): cint{.extdecl,
importc: "wattroff", dynlib: pdcursesdll.} importc: "wattroff", dynlib: pdcursesdll.}
proc wattron*(a2: ptr TWINDOW; a3: cunsignedlong): cint{.extdecl, proc wattron*(a2: ptr WINDOW; a3: cunsignedlong): cint{.extdecl,
importc: "wattron", dynlib: pdcursesdll.} importc: "wattron", dynlib: pdcursesdll.}
proc wattrset*(a2: ptr TWINDOW; a3: cunsignedlong): cint{.extdecl, proc wattrset*(a2: ptr WINDOW; a3: cunsignedlong): cint{.extdecl,
importc: "wattrset", dynlib: pdcursesdll.} importc: "wattrset", dynlib: pdcursesdll.}
proc wattr_get*(a2: ptr TWINDOW; a3: ptr cunsignedlong; a4: ptr cshort; proc wattr_get*(a2: ptr WINDOW; a3: ptr cunsignedlong; a4: ptr cshort;
a5: pointer): cint{.extdecl, importc: "wattr_get", a5: pointer): cint{.extdecl, importc: "wattr_get",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wattr_off*(a2: ptr TWINDOW; a3: cunsignedlong; a4: pointer): cint{.extdecl, proc wattr_off*(a2: ptr WINDOW; a3: cunsignedlong; a4: pointer): cint{.extdecl,
importc: "wattr_off", dynlib: pdcursesdll.} importc: "wattr_off", dynlib: pdcursesdll.}
proc wattr_on*(a2: ptr TWINDOW; a3: cunsignedlong; a4: pointer): cint{.extdecl, proc wattr_on*(a2: ptr WINDOW; a3: cunsignedlong; a4: pointer): cint{.extdecl,
importc: "wattr_on", dynlib: pdcursesdll.} importc: "wattr_on", dynlib: pdcursesdll.}
proc wattr_set*(a2: ptr TWINDOW; a3: cunsignedlong; a4: cshort; a5: pointer): cint{. proc wattr_set*(a2: ptr WINDOW; a3: cunsignedlong; a4: cshort; a5: pointer): cint{.
extdecl, importc: "wattr_set", dynlib: pdcursesdll.} extdecl, importc: "wattr_set", dynlib: pdcursesdll.}
proc wbkgdset*(a2: ptr TWINDOW; a3: cunsignedlong){.extdecl, importc: "wbkgdset", proc wbkgdset*(a2: ptr WINDOW; a3: cunsignedlong){.extdecl, importc: "wbkgdset",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wbkgd*(a2: ptr TWINDOW; a3: cunsignedlong): cint{.extdecl, importc: "wbkgd", proc wbkgd*(a2: ptr WINDOW; a3: cunsignedlong): cint{.extdecl, importc: "wbkgd",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wborder*(a2: ptr TWINDOW; a3: cunsignedlong; a4: cunsignedlong; proc wborder*(a2: ptr WINDOW; a3: cunsignedlong; a4: cunsignedlong;
a5: cunsignedlong; a6: cunsignedlong; a7: cunsignedlong; a5: cunsignedlong; a6: cunsignedlong; a7: cunsignedlong;
a8: cunsignedlong; a9: cunsignedlong; a10: cunsignedlong): cint{. a8: cunsignedlong; a9: cunsignedlong; a10: cunsignedlong): cint{.
extdecl, importc: "wborder", dynlib: pdcursesdll.} extdecl, importc: "wborder", dynlib: pdcursesdll.}
proc wchgat*(a2: ptr TWINDOW; a3: cint; a4: cunsignedlong; a5: cshort; proc wchgat*(a2: ptr WINDOW; a3: cint; a4: cunsignedlong; a5: cshort;
a6: pointer): cint{.extdecl, importc: "wchgat", dynlib: pdcursesdll.} a6: pointer): cint{.extdecl, importc: "wchgat", dynlib: pdcursesdll.}
proc wclear*(a2: ptr TWINDOW): cint{.extdecl, importc: "wclear", proc wclear*(a2: ptr WINDOW): cint{.extdecl, importc: "wclear",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wclrtobot*(a2: ptr TWINDOW): cint{.extdecl, importc: "wclrtobot", proc wclrtobot*(a2: ptr WINDOW): cint{.extdecl, importc: "wclrtobot",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wclrtoeol*(a2: ptr TWINDOW): cint{.extdecl, importc: "wclrtoeol", proc wclrtoeol*(a2: ptr WINDOW): cint{.extdecl, importc: "wclrtoeol",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wcolor_set*(a2: ptr TWINDOW; a3: cshort; a4: pointer): cint{.extdecl, proc wcolor_set*(a2: ptr WINDOW; a3: cshort; a4: pointer): cint{.extdecl,
importc: "wcolor_set", dynlib: pdcursesdll.} importc: "wcolor_set", dynlib: pdcursesdll.}
proc wcursyncup*(a2: ptr TWINDOW){.extdecl, importc: "wcursyncup", proc wcursyncup*(a2: ptr WINDOW){.extdecl, importc: "wcursyncup",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wdelch*(a2: ptr TWINDOW): cint{.extdecl, importc: "wdelch", proc wdelch*(a2: ptr WINDOW): cint{.extdecl, importc: "wdelch",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wdeleteln*(a2: ptr TWINDOW): cint{.extdecl, importc: "wdeleteln", proc wdeleteln*(a2: ptr WINDOW): cint{.extdecl, importc: "wdeleteln",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wechochar*(a2: ptr TWINDOW; a3: cunsignedlong): cint{.extdecl, proc wechochar*(a2: ptr WINDOW; a3: cunsignedlong): cint{.extdecl,
importc: "wechochar", dynlib: pdcursesdll.} importc: "wechochar", dynlib: pdcursesdll.}
proc werase*(a2: ptr TWINDOW): cint{.extdecl, importc: "werase", proc werase*(a2: ptr WINDOW): cint{.extdecl, importc: "werase",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wgetch*(a2: ptr TWINDOW): cint{.extdecl, importc: "wgetch", proc wgetch*(a2: ptr WINDOW): cint{.extdecl, importc: "wgetch",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wgetnstr*(a2: ptr TWINDOW; a3: cstring; a4: cint): cint{.extdecl, proc wgetnstr*(a2: ptr WINDOW; a3: cstring; a4: cint): cint{.extdecl,
importc: "wgetnstr", dynlib: pdcursesdll.} importc: "wgetnstr", dynlib: pdcursesdll.}
proc wgetstr*(a2: ptr TWINDOW; a3: cstring): cint{.extdecl, importc: "wgetstr", proc wgetstr*(a2: ptr WINDOW; a3: cstring): cint{.extdecl, importc: "wgetstr",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc whline*(a2: ptr TWINDOW; a3: cunsignedlong; a4: cint): cint{.extdecl, proc whline*(a2: ptr WINDOW; a3: cunsignedlong; a4: cint): cint{.extdecl,
importc: "whline", dynlib: pdcursesdll.} importc: "whline", dynlib: pdcursesdll.}
proc winchnstr*(a2: ptr TWINDOW; a3: ptr cunsignedlong; a4: cint): cint{.extdecl, proc winchnstr*(a2: ptr WINDOW; a3: ptr cunsignedlong; a4: cint): cint{.extdecl,
importc: "winchnstr", dynlib: pdcursesdll.} importc: "winchnstr", dynlib: pdcursesdll.}
proc winchstr*(a2: ptr TWINDOW; a3: ptr cunsignedlong): cint{.extdecl, proc winchstr*(a2: ptr WINDOW; a3: ptr cunsignedlong): cint{.extdecl,
importc: "winchstr", dynlib: pdcursesdll.} importc: "winchstr", dynlib: pdcursesdll.}
proc winch*(a2: ptr TWINDOW): cunsignedlong{.extdecl, importc: "winch", proc winch*(a2: ptr WINDOW): cunsignedlong{.extdecl, importc: "winch",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc winnstr*(a2: ptr TWINDOW; a3: cstring; a4: cint): cint{.extdecl, proc winnstr*(a2: ptr WINDOW; a3: cstring; a4: cint): cint{.extdecl,
importc: "winnstr", dynlib: pdcursesdll.} importc: "winnstr", dynlib: pdcursesdll.}
proc winsch*(a2: ptr TWINDOW; a3: cunsignedlong): cint{.extdecl, importc: "winsch", proc winsch*(a2: ptr WINDOW; a3: cunsignedlong): cint{.extdecl, importc: "winsch",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc winsdelln*(a2: ptr TWINDOW; a3: cint): cint{.extdecl, importc: "winsdelln", proc winsdelln*(a2: ptr WINDOW; a3: cint): cint{.extdecl, importc: "winsdelln",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc winsertln*(a2: ptr TWINDOW): cint{.extdecl, importc: "winsertln", proc winsertln*(a2: ptr WINDOW): cint{.extdecl, importc: "winsertln",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc winsnstr*(a2: ptr TWINDOW; a3: cstring; a4: cint): cint{.extdecl, proc winsnstr*(a2: ptr WINDOW; a3: cstring; a4: cint): cint{.extdecl,
importc: "winsnstr", dynlib: pdcursesdll.} importc: "winsnstr", dynlib: pdcursesdll.}
proc winsstr*(a2: ptr TWINDOW; a3: cstring): cint{.extdecl, importc: "winsstr", proc winsstr*(a2: ptr WINDOW; a3: cstring): cint{.extdecl, importc: "winsstr",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc winstr*(a2: ptr TWINDOW; a3: cstring): cint{.extdecl, importc: "winstr", proc winstr*(a2: ptr WINDOW; a3: cstring): cint{.extdecl, importc: "winstr",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wmove*(a2: ptr TWINDOW; a3: cint; a4: cint): cint{.extdecl, importc: "wmove", proc wmove*(a2: ptr WINDOW; a3: cint; a4: cint): cint{.extdecl, importc: "wmove",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wnoutrefresh*(a2: ptr TWINDOW): cint{.extdecl, importc: "wnoutrefresh", proc wnoutrefresh*(a2: ptr WINDOW): cint{.extdecl, importc: "wnoutrefresh",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wprintw*(a2: ptr TWINDOW; a3: cstring): cint{.varargs, extdecl, proc wprintw*(a2: ptr WINDOW; a3: cstring): cint{.varargs, extdecl,
importc: "wprintw", dynlib: pdcursesdll.} importc: "wprintw", dynlib: pdcursesdll.}
proc wredrawln*(a2: ptr TWINDOW; a3: cint; a4: cint): cint{.extdecl, proc wredrawln*(a2: ptr WINDOW; a3: cint; a4: cint): cint{.extdecl,
importc: "wredrawln", dynlib: pdcursesdll.} importc: "wredrawln", dynlib: pdcursesdll.}
proc wrefresh*(a2: ptr TWINDOW): cint{.extdecl, importc: "wrefresh", proc wrefresh*(a2: ptr WINDOW): cint{.extdecl, importc: "wrefresh",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wscanw*(a2: ptr TWINDOW; a3: cstring): cint{.varargs, extdecl, proc wscanw*(a2: ptr WINDOW; a3: cstring): cint{.varargs, extdecl,
importc: "wscanw", dynlib: pdcursesdll.} importc: "wscanw", dynlib: pdcursesdll.}
proc wscrl*(a2: ptr TWINDOW; a3: cint): cint{.extdecl, importc: "wscrl", proc wscrl*(a2: ptr WINDOW; a3: cint): cint{.extdecl, importc: "wscrl",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wsetscrreg*(a2: ptr TWINDOW; a3: cint; a4: cint): cint{.extdecl, proc wsetscrreg*(a2: ptr WINDOW; a3: cint; a4: cint): cint{.extdecl,
importc: "wsetscrreg", dynlib: pdcursesdll.} importc: "wsetscrreg", dynlib: pdcursesdll.}
proc wstandend*(a2: ptr TWINDOW): cint{.extdecl, importc: "wstandend", proc wstandend*(a2: ptr WINDOW): cint{.extdecl, importc: "wstandend",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wstandout*(a2: ptr TWINDOW): cint{.extdecl, importc: "wstandout", proc wstandout*(a2: ptr WINDOW): cint{.extdecl, importc: "wstandout",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wsyncdown*(a2: ptr TWINDOW){.extdecl, importc: "wsyncdown", proc wsyncdown*(a2: ptr WINDOW){.extdecl, importc: "wsyncdown",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wsyncup*(a2: ptr TWINDOW){.extdecl, importc: "wsyncup", dynlib: pdcursesdll.} proc wsyncup*(a2: ptr WINDOW){.extdecl, importc: "wsyncup", dynlib: pdcursesdll.}
proc wtimeout*(a2: ptr TWINDOW; a3: cint){.extdecl, importc: "wtimeout", proc wtimeout*(a2: ptr WINDOW; a3: cint){.extdecl, importc: "wtimeout",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wtouchln*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cint): cint{.extdecl, proc wtouchln*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cint): cint{.extdecl,
importc: "wtouchln", dynlib: pdcursesdll.} importc: "wtouchln", dynlib: pdcursesdll.}
proc wvline*(a2: ptr TWINDOW; a3: cunsignedlong; a4: cint): cint{.extdecl, proc wvline*(a2: ptr WINDOW; a3: cunsignedlong; a4: cint): cint{.extdecl,
importc: "wvline", dynlib: pdcursesdll.} importc: "wvline", dynlib: pdcursesdll.}
proc addnwstr*(a2: cstring; a3: cint): cint{.extdecl, importc: "addnwstr", proc addnwstr*(a2: cstring; a3: cint): cint{.extdecl, importc: "addnwstr",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
@ -1146,7 +1152,7 @@ proc border_set*(a2: ptr cunsignedlong; a3: ptr cunsignedlong;
a6: ptr cunsignedlong; a7: ptr cunsignedlong; a6: ptr cunsignedlong; a7: ptr cunsignedlong;
a8: ptr cunsignedlong; a9: ptr cunsignedlong): cint{.extdecl, a8: ptr cunsignedlong; a9: ptr cunsignedlong): cint{.extdecl,
importc: "border_set", dynlib: pdcursesdll.} importc: "border_set", dynlib: pdcursesdll.}
proc box_set*(a2: ptr TWINDOW; a3: ptr cunsignedlong; a4: ptr cunsignedlong): cint{. proc box_set*(a2: ptr WINDOW; a3: ptr cunsignedlong; a4: ptr cunsignedlong): cint{.
extdecl, importc: "box_set", dynlib: pdcursesdll.} extdecl, importc: "box_set", dynlib: pdcursesdll.}
proc echo_wchar*(a2: ptr cunsignedlong): cint{.extdecl, importc: "echo_wchar", proc echo_wchar*(a2: ptr cunsignedlong): cint{.extdecl, importc: "echo_wchar",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
@ -1221,47 +1227,47 @@ proc mvin_wchstr*(a2: cint; a3: cint; a4: ptr cunsignedlong): cint{.extdecl,
importc: "mvin_wchstr", dynlib: pdcursesdll.} importc: "mvin_wchstr", dynlib: pdcursesdll.}
proc mvvline_set*(a2: cint; a3: cint; a4: ptr cunsignedlong; a5: cint): cint{. proc mvvline_set*(a2: cint; a3: cint; a4: ptr cunsignedlong; a5: cint): cint{.
extdecl, importc: "mvvline_set", dynlib: pdcursesdll.} extdecl, importc: "mvvline_set", dynlib: pdcursesdll.}
proc mvwaddnwstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cstring; a6: cint): cint{. proc mvwaddnwstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cstring; a6: cint): cint{.
extdecl, importc: "mvwaddnwstr", dynlib: pdcursesdll.} extdecl, importc: "mvwaddnwstr", dynlib: pdcursesdll.}
proc mvwaddwstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cstring): cint{. proc mvwaddwstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cstring): cint{.
extdecl, importc: "mvwaddwstr", dynlib: pdcursesdll.} extdecl, importc: "mvwaddwstr", dynlib: pdcursesdll.}
proc mvwadd_wch*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong): cint{. proc mvwadd_wch*(a2: ptr WINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong): cint{.
extdecl, importc: "mvwadd_wch", dynlib: pdcursesdll.} extdecl, importc: "mvwadd_wch", dynlib: pdcursesdll.}
proc mvwadd_wchnstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong; proc mvwadd_wchnstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong;
a6: cint): cint{.extdecl, importc: "mvwadd_wchnstr", a6: cint): cint{.extdecl, importc: "mvwadd_wchnstr",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc mvwadd_wchstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong): cint{. proc mvwadd_wchstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong): cint{.
extdecl, importc: "mvwadd_wchstr", dynlib: pdcursesdll.} extdecl, importc: "mvwadd_wchstr", dynlib: pdcursesdll.}
proc mvwgetn_wstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: ptr cint; a6: cint): cint{. proc mvwgetn_wstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: ptr cint; a6: cint): cint{.
extdecl, importc: "mvwgetn_wstr", dynlib: pdcursesdll.} extdecl, importc: "mvwgetn_wstr", dynlib: pdcursesdll.}
proc mvwget_wch*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: ptr cint): cint{. proc mvwget_wch*(a2: ptr WINDOW; a3: cint; a4: cint; a5: ptr cint): cint{.
extdecl, importc: "mvwget_wch", dynlib: pdcursesdll.} extdecl, importc: "mvwget_wch", dynlib: pdcursesdll.}
proc mvwget_wstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: ptr cint): cint{. proc mvwget_wstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: ptr cint): cint{.
extdecl, importc: "mvwget_wstr", dynlib: pdcursesdll.} extdecl, importc: "mvwget_wstr", dynlib: pdcursesdll.}
proc mvwhline_set*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong; proc mvwhline_set*(a2: ptr WINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong;
a6: cint): cint{.extdecl, importc: "mvwhline_set", a6: cint): cint{.extdecl, importc: "mvwhline_set",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc mvwinnwstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cstring; a6: cint): cint{. proc mvwinnwstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cstring; a6: cint): cint{.
extdecl, importc: "mvwinnwstr", dynlib: pdcursesdll.} extdecl, importc: "mvwinnwstr", dynlib: pdcursesdll.}
proc mvwins_nwstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cstring; a6: cint): cint{. proc mvwins_nwstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cstring; a6: cint): cint{.
extdecl, importc: "mvwins_nwstr", dynlib: pdcursesdll.} extdecl, importc: "mvwins_nwstr", dynlib: pdcursesdll.}
proc mvwins_wch*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong): cint{. proc mvwins_wch*(a2: ptr WINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong): cint{.
extdecl, importc: "mvwins_wch", dynlib: pdcursesdll.} extdecl, importc: "mvwins_wch", dynlib: pdcursesdll.}
proc mvwins_wstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cstring): cint{. proc mvwins_wstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cstring): cint{.
extdecl, importc: "mvwins_wstr", dynlib: pdcursesdll.} extdecl, importc: "mvwins_wstr", dynlib: pdcursesdll.}
proc mvwin_wch*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong): cint{. proc mvwin_wch*(a2: ptr WINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong): cint{.
extdecl, importc: "mvwin_wch", dynlib: pdcursesdll.} extdecl, importc: "mvwin_wch", dynlib: pdcursesdll.}
proc mvwin_wchnstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong; proc mvwin_wchnstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong;
a6: cint): cint{.extdecl, importc: "mvwin_wchnstr", a6: cint): cint{.extdecl, importc: "mvwin_wchnstr",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc mvwin_wchstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong): cint{. proc mvwin_wchstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong): cint{.
extdecl, importc: "mvwin_wchstr", dynlib: pdcursesdll.} extdecl, importc: "mvwin_wchstr", dynlib: pdcursesdll.}
proc mvwinwstr*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cstring): cint{. proc mvwinwstr*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cstring): cint{.
extdecl, importc: "mvwinwstr", dynlib: pdcursesdll.} extdecl, importc: "mvwinwstr", dynlib: pdcursesdll.}
proc mvwvline_set*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong; proc mvwvline_set*(a2: ptr WINDOW; a3: cint; a4: cint; a5: ptr cunsignedlong;
a6: cint): cint{.extdecl, importc: "mvwvline_set", a6: cint): cint{.extdecl, importc: "mvwvline_set",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc pecho_wchar*(a2: ptr TWINDOW; a3: ptr cunsignedlong): cint{.extdecl, proc pecho_wchar*(a2: ptr WINDOW; a3: ptr cunsignedlong): cint{.extdecl,
importc: "pecho_wchar", dynlib: pdcursesdll.} importc: "pecho_wchar", dynlib: pdcursesdll.}
proc setcchar*(a2: ptr cunsignedlong; a3: cstring; a4: cunsignedlong; proc setcchar*(a2: ptr cunsignedlong; a3: cstring; a4: cunsignedlong;
a5: cshort; a6: pointer): cint{.extdecl, importc: "setcchar", a5: cshort; a6: pointer): cint{.extdecl, importc: "setcchar",
@ -1272,74 +1278,74 @@ proc unget_wch*(a2: char): cint{.extdecl, importc: "unget_wch",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc vline_set*(a2: ptr cunsignedlong; a3: cint): cint{.extdecl, proc vline_set*(a2: ptr cunsignedlong; a3: cint): cint{.extdecl,
importc: "vline_set", dynlib: pdcursesdll.} importc: "vline_set", dynlib: pdcursesdll.}
proc waddnwstr*(a2: ptr TWINDOW; a3: cstring; a4: cint): cint{.extdecl, proc waddnwstr*(a2: ptr WINDOW; a3: cstring; a4: cint): cint{.extdecl,
importc: "waddnwstr", dynlib: pdcursesdll.} importc: "waddnwstr", dynlib: pdcursesdll.}
proc waddwstr*(a2: ptr TWINDOW; a3: cstring): cint{.extdecl, proc waddwstr*(a2: ptr WINDOW; a3: cstring): cint{.extdecl,
importc: "waddwstr", dynlib: pdcursesdll.} importc: "waddwstr", dynlib: pdcursesdll.}
proc wadd_wch*(a2: ptr TWINDOW; a3: ptr cunsignedlong): cint{.extdecl, proc wadd_wch*(a2: ptr WINDOW; a3: ptr cunsignedlong): cint{.extdecl,
importc: "wadd_wch", dynlib: pdcursesdll.} importc: "wadd_wch", dynlib: pdcursesdll.}
proc wadd_wchnstr*(a2: ptr TWINDOW; a3: ptr cunsignedlong; a4: cint): cint{. proc wadd_wchnstr*(a2: ptr WINDOW; a3: ptr cunsignedlong; a4: cint): cint{.
extdecl, importc: "wadd_wchnstr", dynlib: pdcursesdll.} extdecl, importc: "wadd_wchnstr", dynlib: pdcursesdll.}
proc wadd_wchstr*(a2: ptr TWINDOW; a3: ptr cunsignedlong): cint{.extdecl, proc wadd_wchstr*(a2: ptr WINDOW; a3: ptr cunsignedlong): cint{.extdecl,
importc: "wadd_wchstr", dynlib: pdcursesdll.} importc: "wadd_wchstr", dynlib: pdcursesdll.}
proc wbkgrnd*(a2: ptr TWINDOW; a3: ptr cunsignedlong): cint{.extdecl, proc wbkgrnd*(a2: ptr WINDOW; a3: ptr cunsignedlong): cint{.extdecl,
importc: "wbkgrnd", dynlib: pdcursesdll.} importc: "wbkgrnd", dynlib: pdcursesdll.}
proc wbkgrndset*(a2: ptr TWINDOW; a3: ptr cunsignedlong){.extdecl, proc wbkgrndset*(a2: ptr WINDOW; a3: ptr cunsignedlong){.extdecl,
importc: "wbkgrndset", dynlib: pdcursesdll.} importc: "wbkgrndset", dynlib: pdcursesdll.}
proc wborder_set*(a2: ptr TWINDOW; a3: ptr cunsignedlong; a4: ptr cunsignedlong; proc wborder_set*(a2: ptr WINDOW; a3: ptr cunsignedlong; a4: ptr cunsignedlong;
a5: ptr cunsignedlong; a6: ptr cunsignedlong; a5: ptr cunsignedlong; a6: ptr cunsignedlong;
a7: ptr cunsignedlong; a8: ptr cunsignedlong; a7: ptr cunsignedlong; a8: ptr cunsignedlong;
a9: ptr cunsignedlong; a10: ptr cunsignedlong): cint{.extdecl, a9: ptr cunsignedlong; a10: ptr cunsignedlong): cint{.extdecl,
importc: "wborder_set", dynlib: pdcursesdll.} importc: "wborder_set", dynlib: pdcursesdll.}
proc wecho_wchar*(a2: ptr TWINDOW; a3: ptr cunsignedlong): cint{.extdecl, proc wecho_wchar*(a2: ptr WINDOW; a3: ptr cunsignedlong): cint{.extdecl,
importc: "wecho_wchar", dynlib: pdcursesdll.} importc: "wecho_wchar", dynlib: pdcursesdll.}
proc wgetbkgrnd*(a2: ptr TWINDOW; a3: ptr cunsignedlong): cint{.extdecl, proc wgetbkgrnd*(a2: ptr WINDOW; a3: ptr cunsignedlong): cint{.extdecl,
importc: "wgetbkgrnd", dynlib: pdcursesdll.} importc: "wgetbkgrnd", dynlib: pdcursesdll.}
proc wgetn_wstr*(a2: ptr TWINDOW; a3: ptr cint; a4: cint): cint{.extdecl, proc wgetn_wstr*(a2: ptr WINDOW; a3: ptr cint; a4: cint): cint{.extdecl,
importc: "wgetn_wstr", dynlib: pdcursesdll.} importc: "wgetn_wstr", dynlib: pdcursesdll.}
proc wget_wch*(a2: ptr TWINDOW; a3: ptr cint): cint{.extdecl, proc wget_wch*(a2: ptr WINDOW; a3: ptr cint): cint{.extdecl,
importc: "wget_wch", dynlib: pdcursesdll.} importc: "wget_wch", dynlib: pdcursesdll.}
proc wget_wstr*(a2: ptr TWINDOW; a3: ptr cint): cint{.extdecl, proc wget_wstr*(a2: ptr WINDOW; a3: ptr cint): cint{.extdecl,
importc: "wget_wstr", dynlib: pdcursesdll.} importc: "wget_wstr", dynlib: pdcursesdll.}
proc whline_set*(a2: ptr TWINDOW; a3: ptr cunsignedlong; a4: cint): cint{.extdecl, proc whline_set*(a2: ptr WINDOW; a3: ptr cunsignedlong; a4: cint): cint{.extdecl,
importc: "whline_set", dynlib: pdcursesdll.} importc: "whline_set", dynlib: pdcursesdll.}
proc winnwstr*(a2: ptr TWINDOW; a3: cstring; a4: cint): cint{.extdecl, proc winnwstr*(a2: ptr WINDOW; a3: cstring; a4: cint): cint{.extdecl,
importc: "winnwstr", dynlib: pdcursesdll.} importc: "winnwstr", dynlib: pdcursesdll.}
proc wins_nwstr*(a2: ptr TWINDOW; a3: cstring; a4: cint): cint{.extdecl, proc wins_nwstr*(a2: ptr WINDOW; a3: cstring; a4: cint): cint{.extdecl,
importc: "wins_nwstr", dynlib: pdcursesdll.} importc: "wins_nwstr", dynlib: pdcursesdll.}
proc wins_wch*(a2: ptr TWINDOW; a3: ptr cunsignedlong): cint{.extdecl, proc wins_wch*(a2: ptr WINDOW; a3: ptr cunsignedlong): cint{.extdecl,
importc: "wins_wch", dynlib: pdcursesdll.} importc: "wins_wch", dynlib: pdcursesdll.}
proc wins_wstr*(a2: ptr TWINDOW; a3: cstring): cint{.extdecl, proc wins_wstr*(a2: ptr WINDOW; a3: cstring): cint{.extdecl,
importc: "wins_wstr", dynlib: pdcursesdll.} importc: "wins_wstr", dynlib: pdcursesdll.}
proc winwstr*(a2: ptr TWINDOW; a3: cstring): cint{.extdecl, importc: "winwstr", proc winwstr*(a2: ptr WINDOW; a3: cstring): cint{.extdecl, importc: "winwstr",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc win_wch*(a2: ptr TWINDOW; a3: ptr cunsignedlong): cint{.extdecl, proc win_wch*(a2: ptr WINDOW; a3: ptr cunsignedlong): cint{.extdecl,
importc: "win_wch", dynlib: pdcursesdll.} importc: "win_wch", dynlib: pdcursesdll.}
proc win_wchnstr*(a2: ptr TWINDOW; a3: ptr cunsignedlong; a4: cint): cint{.extdecl, proc win_wchnstr*(a2: ptr WINDOW; a3: ptr cunsignedlong; a4: cint): cint{.extdecl,
importc: "win_wchnstr", dynlib: pdcursesdll.} importc: "win_wchnstr", dynlib: pdcursesdll.}
proc win_wchstr*(a2: ptr TWINDOW; a3: ptr cunsignedlong): cint{.extdecl, proc win_wchstr*(a2: ptr WINDOW; a3: ptr cunsignedlong): cint{.extdecl,
importc: "win_wchstr", dynlib: pdcursesdll.} importc: "win_wchstr", dynlib: pdcursesdll.}
proc wunctrl*(a2: ptr cunsignedlong): cstring{.extdecl, importc: "wunctrl", proc wunctrl*(a2: ptr cunsignedlong): cstring{.extdecl, importc: "wunctrl",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wvline_set*(a2: ptr TWINDOW; a3: ptr cunsignedlong; a4: cint): cint{.extdecl, proc wvline_set*(a2: ptr WINDOW; a3: ptr cunsignedlong; a4: cint): cint{.extdecl,
importc: "wvline_set", dynlib: pdcursesdll.} importc: "wvline_set", dynlib: pdcursesdll.}
proc getattrs*(a2: ptr TWINDOW): cunsignedlong{.extdecl, importc: "getattrs", proc getattrs*(a2: ptr WINDOW): cunsignedlong{.extdecl, importc: "getattrs",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc getbegx*(a2: ptr TWINDOW): cint{.extdecl, importc: "getbegx", proc getbegx*(a2: ptr WINDOW): cint{.extdecl, importc: "getbegx",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc getbegy*(a2: ptr TWINDOW): cint{.extdecl, importc: "getbegy", proc getbegy*(a2: ptr WINDOW): cint{.extdecl, importc: "getbegy",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc getmaxx*(a2: ptr TWINDOW): cint{.extdecl, importc: "getmaxx", proc getmaxx*(a2: ptr WINDOW): cint{.extdecl, importc: "getmaxx",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc getmaxy*(a2: ptr TWINDOW): cint{.extdecl, importc: "getmaxy", proc getmaxy*(a2: ptr WINDOW): cint{.extdecl, importc: "getmaxy",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc getparx*(a2: ptr TWINDOW): cint{.extdecl, importc: "getparx", proc getparx*(a2: ptr WINDOW): cint{.extdecl, importc: "getparx",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc getpary*(a2: ptr TWINDOW): cint{.extdecl, importc: "getpary", proc getpary*(a2: ptr WINDOW): cint{.extdecl, importc: "getpary",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc getcurx*(a2: ptr TWINDOW): cint{.extdecl, importc: "getcurx", proc getcurx*(a2: ptr WINDOW): cint{.extdecl, importc: "getcurx",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc getcury*(a2: ptr TWINDOW): cint{.extdecl, importc: "getcury", proc getcury*(a2: ptr WINDOW): cint{.extdecl, importc: "getcury",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc traceoff*(){.extdecl, importc: "traceoff", dynlib: pdcursesdll.} proc traceoff*(){.extdecl, importc: "traceoff", dynlib: pdcursesdll.}
proc traceon*(){.extdecl, importc: "traceon", dynlib: pdcursesdll.} proc traceon*(){.extdecl, importc: "traceon", dynlib: pdcursesdll.}
@ -1363,7 +1369,7 @@ proc request_mouse_pos*(): cint{.extdecl, importc: "request_mouse_pos",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc map_button*(a2: cunsignedlong): cint{.extdecl, importc: "map_button", proc map_button*(a2: cunsignedlong): cint{.extdecl, importc: "map_button",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wmouse_position*(a2: ptr TWINDOW; a3: ptr cint; a4: ptr cint){.extdecl, proc wmouse_position*(a2: ptr WINDOW; a3: ptr cint; a4: ptr cint){.extdecl,
importc: "wmouse_position", dynlib: pdcursesdll.} importc: "wmouse_position", dynlib: pdcursesdll.}
proc getmouse*(): cunsignedlong{.extdecl, importc: "getmouse", dynlib: pdcursesdll.} proc getmouse*(): cunsignedlong{.extdecl, importc: "getmouse", dynlib: pdcursesdll.}
proc getbmap*(): cunsignedlong{.extdecl, importc: "getbmap", dynlib: pdcursesdll.} proc getbmap*(): cunsignedlong{.extdecl, importc: "getbmap", dynlib: pdcursesdll.}
@ -1375,7 +1381,7 @@ proc has_key*(a2: cint): cunsignedchar{.extdecl, importc: "has_key",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc use_default_colors*(): cint{.extdecl, importc: "use_default_colors", proc use_default_colors*(): cint{.extdecl, importc: "use_default_colors",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wresize*(a2: ptr TWINDOW; a3: cint; a4: cint): cint{.extdecl, proc wresize*(a2: ptr WINDOW; a3: cint; a4: cint): cint{.extdecl,
importc: "wresize", dynlib: pdcursesdll.} importc: "wresize", dynlib: pdcursesdll.}
proc mouseinterval*(a2: cint): cint{.extdecl, importc: "mouseinterval", proc mouseinterval*(a2: cint): cint{.extdecl, importc: "mouseinterval",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
@ -1383,13 +1389,13 @@ proc mousemask*(a2: cunsignedlong; a3: ptr cunsignedlong): cunsignedlong{.extdec
importc: "mousemask", dynlib: pdcursesdll.} importc: "mousemask", dynlib: pdcursesdll.}
proc mouse_trafo*(a2: ptr cint; a3: ptr cint; a4: cunsignedchar): cunsignedchar{. proc mouse_trafo*(a2: ptr cint; a3: ptr cint; a4: cunsignedchar): cunsignedchar{.
extdecl, importc: "mouse_trafo", dynlib: pdcursesdll.} extdecl, importc: "mouse_trafo", dynlib: pdcursesdll.}
proc nc_getmouse*(a2: ptr TMEVENT): cint{.extdecl, importc: "nc_getmouse", proc nc_getmouse*(a2: ptr MEVENT): cint{.extdecl, importc: "nc_getmouse",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc ungetmouse*(a2: ptr TMEVENT): cint{.extdecl, importc: "ungetmouse", proc ungetmouse*(a2: ptr MEVENT): cint{.extdecl, importc: "ungetmouse",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc wenclose*(a2: ptr TWINDOW; a3: cint; a4: cint): cunsignedchar{.extdecl, proc wenclose*(a2: ptr WINDOW; a3: cint; a4: cint): cunsignedchar{.extdecl,
importc: "wenclose", dynlib: pdcursesdll.} importc: "wenclose", dynlib: pdcursesdll.}
proc wmouse_trafo*(a2: ptr TWINDOW; a3: ptr cint; a4: ptr cint; a5: cunsignedchar): cunsignedchar{. proc wmouse_trafo*(a2: ptr WINDOW; a3: ptr cint; a4: ptr cint; a5: cunsignedchar): cunsignedchar{.
extdecl, importc: "wmouse_trafo", dynlib: pdcursesdll.} extdecl, importc: "wmouse_trafo", dynlib: pdcursesdll.}
proc addrawch*(a2: cunsignedlong): cint{.extdecl, importc: "addrawch", proc addrawch*(a2: cunsignedlong): cint{.extdecl, importc: "addrawch",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
@ -1405,23 +1411,23 @@ proc mvinsertln*(a2: cint; a3: cint): cint{.extdecl, importc: "mvinsertln",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc mvinsrawch*(a2: cint; a3: cint; a4: cunsignedlong): cint{.extdecl, proc mvinsrawch*(a2: cint; a3: cint; a4: cunsignedlong): cint{.extdecl,
importc: "mvinsrawch", dynlib: pdcursesdll.} importc: "mvinsrawch", dynlib: pdcursesdll.}
proc mvwaddrawch*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cunsignedlong): cint{. proc mvwaddrawch*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cunsignedlong): cint{.
extdecl, importc: "mvwaddrawch", dynlib: pdcursesdll.} extdecl, importc: "mvwaddrawch", dynlib: pdcursesdll.}
proc mvwdeleteln*(a2: ptr TWINDOW; a3: cint; a4: cint): cint{.extdecl, proc mvwdeleteln*(a2: ptr WINDOW; a3: cint; a4: cint): cint{.extdecl,
importc: "mvwdeleteln", dynlib: pdcursesdll.} importc: "mvwdeleteln", dynlib: pdcursesdll.}
proc mvwinsertln*(a2: ptr TWINDOW; a3: cint; a4: cint): cint{.extdecl, proc mvwinsertln*(a2: ptr WINDOW; a3: cint; a4: cint): cint{.extdecl,
importc: "mvwinsertln", dynlib: pdcursesdll.} importc: "mvwinsertln", dynlib: pdcursesdll.}
proc mvwinsrawch*(a2: ptr TWINDOW; a3: cint; a4: cint; a5: cunsignedlong): cint{. proc mvwinsrawch*(a2: ptr WINDOW; a3: cint; a4: cint; a5: cunsignedlong): cint{.
extdecl, importc: "mvwinsrawch", dynlib: pdcursesdll.} extdecl, importc: "mvwinsrawch", dynlib: pdcursesdll.}
proc raw_output*(a2: cunsignedchar): cint{.extdecl, importc: "raw_output", proc raw_output*(a2: cunsignedchar): cint{.extdecl, importc: "raw_output",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc resize_term*(a2: cint; a3: cint): cint{.extdecl, importc: "resize_term", proc resize_term*(a2: cint; a3: cint): cint{.extdecl, importc: "resize_term",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc resize_window*(a2: ptr TWINDOW; a3: cint; a4: cint): ptr TWINDOW{.extdecl, proc resize_window*(a2: ptr WINDOW; a3: cint; a4: cint): ptr WINDOW{.extdecl,
importc: "resize_window", dynlib: pdcursesdll.} importc: "resize_window", dynlib: pdcursesdll.}
proc waddrawch*(a2: ptr TWINDOW; a3: cunsignedlong): cint{.extdecl, proc waddrawch*(a2: ptr WINDOW; a3: cunsignedlong): cint{.extdecl,
importc: "waddrawch", dynlib: pdcursesdll.} importc: "waddrawch", dynlib: pdcursesdll.}
proc winsrawch*(a2: ptr TWINDOW; a3: cunsignedlong): cint{.extdecl, proc winsrawch*(a2: ptr WINDOW; a3: cunsignedlong): cint{.extdecl,
importc: "winsrawch", dynlib: pdcursesdll.} importc: "winsrawch", dynlib: pdcursesdll.}
proc wordchar*(): char{.extdecl, importc: "wordchar", dynlib: pdcursesdll.} proc wordchar*(): char{.extdecl, importc: "wordchar", dynlib: pdcursesdll.}
proc slk_wlabel*(a2: cint): cstring{.extdecl, importc: "slk_wlabel", proc slk_wlabel*(a2: cint): cstring{.extdecl, importc: "slk_wlabel",
@ -1452,38 +1458,38 @@ proc return_key_modifiers*(a2: cunsignedchar): cint{.extdecl,
importc: "PDC_return_key_modifiers", dynlib: pdcursesdll.} importc: "PDC_return_key_modifiers", dynlib: pdcursesdll.}
proc save_key_modifiers*(a2: cunsignedchar): cint{.extdecl, proc save_key_modifiers*(a2: cunsignedchar): cint{.extdecl,
importc: "PDC_save_key_modifiers", dynlib: pdcursesdll.} importc: "PDC_save_key_modifiers", dynlib: pdcursesdll.}
proc bottom_panel*(pan: ptr TPANEL): cint{.extdecl, importc: "bottom_panel", proc bottom_panel*(pan: ptr PANEL): cint{.extdecl, importc: "bottom_panel",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc del_panel*(pan: ptr TPANEL): cint{.extdecl, importc: "del_panel", proc del_panel*(pan: ptr PANEL): cint{.extdecl, importc: "del_panel",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc hide_panel*(pan: ptr TPANEL): cint{.extdecl, importc: "hide_panel", proc hide_panel*(pan: ptr PANEL): cint{.extdecl, importc: "hide_panel",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc move_panel*(pan: ptr TPANEL; starty: cint; startx: cint): cint{.extdecl, proc move_panel*(pan: ptr PANEL; starty: cint; startx: cint): cint{.extdecl,
importc: "move_panel", dynlib: pdcursesdll.} importc: "move_panel", dynlib: pdcursesdll.}
proc new_panel*(win: ptr TWINDOW): ptr TPANEL{.extdecl, importc: "new_panel", proc new_panel*(win: ptr WINDOW): ptr PANEL{.extdecl, importc: "new_panel",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc panel_above*(pan: ptr TPANEL): ptr TPANEL{.extdecl, importc: "panel_above", proc panel_above*(pan: ptr PANEL): ptr PANEL{.extdecl, importc: "panel_above",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc panel_below*(pan: ptr TPANEL): ptr TPANEL{.extdecl, importc: "panel_below", proc panel_below*(pan: ptr PANEL): ptr PANEL{.extdecl, importc: "panel_below",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc panel_hidden*(pan: ptr TPANEL): cint{.extdecl, importc: "panel_hidden", proc panel_hidden*(pan: ptr PANEL): cint{.extdecl, importc: "panel_hidden",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc panel_userptr*(pan: ptr TPANEL): pointer{.extdecl, importc: "panel_userptr", proc panel_userptr*(pan: ptr PANEL): pointer{.extdecl, importc: "panel_userptr",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc panel_window*(pan: ptr TPANEL): ptr TWINDOW{.extdecl, importc: "panel_window", proc panel_window*(pan: ptr PANEL): ptr WINDOW{.extdecl, importc: "panel_window",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc replace_panel*(pan: ptr TPANEL; win: ptr TWINDOW): cint{.extdecl, proc replace_panel*(pan: ptr PANEL; win: ptr WINDOW): cint{.extdecl,
importc: "replace_panel", dynlib: pdcursesdll.} importc: "replace_panel", dynlib: pdcursesdll.}
proc set_panel_userptr*(pan: ptr TPANEL; uptr: pointer): cint{.extdecl, proc set_panel_userptr*(pan: ptr PANEL; uptr: pointer): cint{.extdecl,
importc: "set_panel_userptr", dynlib: pdcursesdll.} importc: "set_panel_userptr", dynlib: pdcursesdll.}
proc show_panel*(pan: ptr TPANEL): cint{.extdecl, importc: "show_panel", proc show_panel*(pan: ptr PANEL): cint{.extdecl, importc: "show_panel",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc top_panel*(pan: ptr TPANEL): cint{.extdecl, importc: "top_panel", proc top_panel*(pan: ptr PANEL): cint{.extdecl, importc: "top_panel",
dynlib: pdcursesdll.} dynlib: pdcursesdll.}
proc update_panels*(){.extdecl, importc: "update_panels", dynlib: pdcursesdll.} proc update_panels*(){.extdecl, importc: "update_panels", dynlib: pdcursesdll.}
when unixOS: when unixOS:
proc Xinitscr*(a2: cint; a3: cstringArray): ptr TWINDOW{.extdecl, proc Xinitscr*(a2: cint; a3: cstringArray): ptr WINDOW{.extdecl,
importc: "Xinitscr", dynlib: pdcursesdll.} importc: "Xinitscr", dynlib: pdcursesdll.}
proc XCursesExit*(){.extdecl, importc: "XCursesExit", dynlib: pdcursesdll.} proc XCursesExit*(){.extdecl, importc: "XCursesExit", dynlib: pdcursesdll.}
proc sb_init*(): cint{.extdecl, importc: "sb_init", dynlib: pdcursesdll.} proc sb_init*(): cint{.extdecl, importc: "sb_init", dynlib: pdcursesdll.}

51
lib/wrappers/postgres.nim
View file

@ -26,25 +26,25 @@ const
CMDSTATUS_LEN* = 40 CMDSTATUS_LEN* = 40
type type
TSockAddr* = array[1..112, int8] SockAddr* = array[1..112, int8]
TPGresAttDesc*{.pure, final.} = object PGresAttDesc*{.pure, final.} = object
name*: cstring name*: cstring
adtid*: Oid adtid*: Oid
adtsize*: int adtsize*: int
PPGresAttDesc* = ptr TPGresAttDesc PPGresAttDesc* = ptr PGresAttDesc
PPPGresAttDesc* = ptr PPGresAttDesc PPPGresAttDesc* = ptr PPGresAttDesc
TPGresAttValue*{.pure, final.} = object PGresAttValue*{.pure, final.} = object
length*: int32 length*: int32
value*: cstring value*: cstring
PPGresAttValue* = ptr TPGresAttValue PPGresAttValue* = ptr PGresAttValue
PPPGresAttValue* = ptr PPGresAttValue PPPGresAttValue* = ptr PPGresAttValue
PExecStatusType* = ptr TExecStatusType PExecStatusType* = ptr ExecStatusType
TExecStatusType* = enum ExecStatusType* = enum
PGRES_EMPTY_QUERY = 0, PGRES_COMMAND_OK, PGRES_TUPLES_OK, PGRES_COPY_OUT, PGRES_EMPTY_QUERY = 0, PGRES_COMMAND_OK, PGRES_TUPLES_OK, PGRES_COPY_OUT,
PGRES_COPY_IN, PGRES_BAD_RESPONSE, PGRES_NONFATAL_ERROR, PGRES_FATAL_ERROR PGRES_COPY_IN, PGRES_BAD_RESPONSE, PGRES_NONFATAL_ERROR, PGRES_FATAL_ERROR
TPGlobjfuncs*{.pure, final.} = object PGlobjfuncs*{.pure, final.} = object
fn_lo_open*: Oid fn_lo_open*: Oid
fn_lo_close*: Oid fn_lo_close*: Oid
fn_lo_creat*: Oid fn_lo_creat*: Oid
@ -54,26 +54,26 @@ type
fn_lo_read*: Oid fn_lo_read*: Oid
fn_lo_write*: Oid fn_lo_write*: Oid
PPGlobjfuncs* = ptr TPGlobjfuncs PPGlobjfuncs* = ptr PGlobjfuncs
PConnStatusType* = ptr TConnStatusType PConnStatusType* = ptr ConnStatusType
TConnStatusType* = enum ConnStatusType* = enum
CONNECTION_OK, CONNECTION_BAD, CONNECTION_STARTED, CONNECTION_MADE, CONNECTION_OK, CONNECTION_BAD, CONNECTION_STARTED, CONNECTION_MADE,
CONNECTION_AWAITING_RESPONSE, CONNECTION_AUTH_OK, CONNECTION_SETENV, CONNECTION_AWAITING_RESPONSE, CONNECTION_AUTH_OK, CONNECTION_SETENV,
CONNECTION_SSL_STARTUP, CONNECTION_NEEDED CONNECTION_SSL_STARTUP, CONNECTION_NEEDED
TPGconn*{.pure, final.} = object PGconn*{.pure, final.} = object
pghost*: cstring pghost*: cstring
pgtty*: cstring pgtty*: cstring
pgport*: cstring pgport*: cstring
pgoptions*: cstring pgoptions*: cstring
dbName*: cstring dbName*: cstring
status*: TConnStatusType status*: ConnStatusType
errorMessage*: array[0..(ERROR_MSG_LENGTH) - 1, char] errorMessage*: array[0..(ERROR_MSG_LENGTH) - 1, char]
Pfin*: File Pfin*: File
Pfout*: File Pfout*: File
Pfdebug*: File Pfdebug*: File
sock*: int32 sock*: int32
laddr*: TSockAddr laddr*: SockAddr
raddr*: TSockAddr raddr*: SockAddr
salt*: array[0..(2) - 1, char] salt*: array[0..(2) - 1, char]
asyncNotifyWaiting*: int32 asyncNotifyWaiting*: int32
notifyList*: pointer notifyList*: pointer
@ -81,19 +81,19 @@ type
pgpass*: cstring pgpass*: cstring
lobjfuncs*: PPGlobjfuncs lobjfuncs*: PPGlobjfuncs
PPGconn* = ptr TPGconn PPGconn* = ptr PGconn
TPGresult*{.pure, final.} = object PGresult*{.pure, final.} = object
ntups*: int32 ntups*: int32
numAttributes*: int32 numAttributes*: int32
attDescs*: PPGresAttDesc attDescs*: PPGresAttDesc
tuples*: PPPGresAttValue tuples*: PPPGresAttValue
tupArrSize*: int32 tupArrSize*: int32
resultStatus*: TExecStatusType resultStatus*: ExecStatusType
cmdStatus*: array[0..(CMDSTATUS_LEN) - 1, char] cmdStatus*: array[0..(CMDSTATUS_LEN) - 1, char]
binary*: int32 binary*: int32
conn*: PPGconn conn*: PPGconn
PPGresult* = ptr TPGresult PPGresult* = ptr PGresult
PPostgresPollingStatusType* = ptr PostgresPollingStatusType PPostgresPollingStatusType* = ptr PostgresPollingStatusType
PostgresPollingStatusType* = enum PostgresPollingStatusType* = enum
PGRES_POLLING_FAILED = 0, PGRES_POLLING_READING, PGRES_POLLING_WRITING, PGRES_POLLING_FAILED = 0, PGRES_POLLING_READING, PGRES_POLLING_WRITING,
@ -143,7 +143,10 @@ type
length*: int32 length*: int32
isint*: int32 isint*: int32
p*: pointer p*: pointer
{.deprecated: [TSockAddr: SockAddr, TPGresAttDesc: PgresAttDesc,
TPGresAttValue: PgresAttValue, TExecStatusType: ExecStatusType,
TPGlobjfuncs: Pglobjfuncs, TConnStatusType: ConnStatusType, TPGconn: Pgconn,
TPGresult: PGresult].}
proc pqconnectStart*(conninfo: cstring): PPGconn{.cdecl, dynlib: dllName, proc pqconnectStart*(conninfo: cstring): PPGconn{.cdecl, dynlib: dllName,
importc: "PQconnectStart".} importc: "PQconnectStart".}
@ -175,7 +178,7 @@ proc pqport*(conn: PPGconn): cstring{.cdecl, dynlib: dllName, importc: "PQport".
proc pqtty*(conn: PPGconn): cstring{.cdecl, dynlib: dllName, importc: "PQtty".} proc pqtty*(conn: PPGconn): cstring{.cdecl, dynlib: dllName, importc: "PQtty".}
proc pqoptions*(conn: PPGconn): cstring{.cdecl, dynlib: dllName, proc pqoptions*(conn: PPGconn): cstring{.cdecl, dynlib: dllName,
importc: "PQoptions".} importc: "PQoptions".}
proc pqstatus*(conn: PPGconn): TConnStatusType{.cdecl, dynlib: dllName, proc pqstatus*(conn: PPGconn): ConnStatusType{.cdecl, dynlib: dllName,
importc: "PQstatus".} importc: "PQstatus".}
proc pqtransactionStatus*(conn: PPGconn): PGTransactionStatusType{.cdecl, proc pqtransactionStatus*(conn: PPGconn): PGTransactionStatusType{.cdecl,
dynlib: dllName, importc: "PQtransactionStatus".} dynlib: dllName, importc: "PQtransactionStatus".}
@ -263,9 +266,9 @@ proc pqflush*(conn: PPGconn): int32{.cdecl, dynlib: dllName, importc: "PQflush".
proc pqfn*(conn: PPGconn, fnid: int32, result_buf, result_len: ptr int32, proc pqfn*(conn: PPGconn, fnid: int32, result_buf, result_len: ptr int32,
result_is_int: int32, args: PPQArgBlock, nargs: int32): PPGresult{. result_is_int: int32, args: PPQArgBlock, nargs: int32): PPGresult{.
cdecl, dynlib: dllName, importc: "PQfn".} cdecl, dynlib: dllName, importc: "PQfn".}
proc pqresultStatus*(res: PPGresult): TExecStatusType{.cdecl, dynlib: dllName, proc pqresultStatus*(res: PPGresult): ExecStatusType{.cdecl, dynlib: dllName,
importc: "PQresultStatus".} importc: "PQresultStatus".}
proc pqresStatus*(status: TExecStatusType): cstring{.cdecl, dynlib: dllName, proc pqresStatus*(status: ExecStatusType): cstring{.cdecl, dynlib: dllName,
importc: "PQresStatus".} importc: "PQresStatus".}
proc pqresultErrorMessage*(res: PPGresult): cstring{.cdecl, dynlib: dllName, proc pqresultErrorMessage*(res: PPGresult): cstring{.cdecl, dynlib: dllName,
importc: "PQresultErrorMessage".} importc: "PQresultErrorMessage".}
@ -309,7 +312,7 @@ proc pqgetisnull*(res: PPGresult, tup_num: int32, field_num: int32): int32{.
cdecl, dynlib: dllName, importc: "PQgetisnull".} cdecl, dynlib: dllName, importc: "PQgetisnull".}
proc pqclear*(res: PPGresult){.cdecl, dynlib: dllName, importc: "PQclear".} proc pqclear*(res: PPGresult){.cdecl, dynlib: dllName, importc: "PQclear".}
proc pqfreemem*(p: pointer){.cdecl, dynlib: dllName, importc: "PQfreemem".} proc pqfreemem*(p: pointer){.cdecl, dynlib: dllName, importc: "PQfreemem".}
proc pqmakeEmptyPGresult*(conn: PPGconn, status: TExecStatusType): PPGresult{. proc pqmakeEmptyPGresult*(conn: PPGconn, status: ExecStatusType): PPGresult{.
cdecl, dynlib: dllName, importc: "PQmakeEmptyPGresult".} cdecl, dynlib: dllName, importc: "PQmakeEmptyPGresult".}
proc pqescapeString*(till, `from`: cstring, len: int): int{.cdecl, proc pqescapeString*(till, `from`: cstring, len: int): int{.cdecl,
dynlib: dllName, importc: "PQescapeString".} dynlib: dllName, importc: "PQescapeString".}

36
lib/wrappers/readline/history.nim
View file

@ -28,16 +28,17 @@ const
import times, rltypedefs import times, rltypedefs
type type
Thistdata* = pointer Histdata* = pointer
{.deprecated: [Thistdata: Histdata].}
# The structure used to store a history entry. # The structure used to store a history entry.
type type
THIST_ENTRY*{.pure, final.} = object HIST_ENTRY*{.pure, final.} = object
line*: cstring line*: cstring
timestamp*: cstring # char * rather than time_t for read/write timestamp*: cstring # char * rather than time_t for read/write
data*: Thistdata data*: Histdata
{.deprecated: [THIST_ENTRY: HIST_ENTRY].}
# Size of the history-library-managed space in history entry HS. # Size of the history-library-managed space in history entry HS.
@ -47,12 +48,13 @@ template HISTENT_BYTES*(hs: expr): expr =
# A structure used to pass the current state of the history stuff around. # A structure used to pass the current state of the history stuff around.
type type
THISTORY_STATE*{.pure, final.} = object HISTORY_STATE*{.pure, final.} = object
entries*: ptr ptr THIST_ENTRY # Pointer to the entries themselves. entries*: ptr ptr HIST_ENTRY # Pointer to the entries themselves.
offset*: cint # The location pointer within this array. offset*: cint # The location pointer within this array.
length*: cint # Number of elements within this array. length*: cint # Number of elements within this array.
size*: cint # Number of slots allocated to this array. size*: cint # Number of slots allocated to this array.
flags*: cint flags*: cint
{.deprecated: [THISTORY_STATE: HISTORY_STATE].}
# Flag values for the `flags' member of HISTORY_STATE. # Flag values for the `flags' member of HISTORY_STATE.
@ -67,11 +69,11 @@ const
proc using_history*(){.cdecl, importc: "using_history", dynlib: historyDll.} proc using_history*(){.cdecl, importc: "using_history", dynlib: historyDll.}
# Return the current HISTORY_STATE of the history. # Return the current HISTORY_STATE of the history.
proc history_get_history_state*(): ptr THISTORY_STATE{.cdecl, proc history_get_history_state*(): ptr HISTORY_STATE{.cdecl,
importc: "history_get_history_state", dynlib: historyDll.} importc: "history_get_history_state", dynlib: historyDll.}
# Set the state of the current history array to STATE. # Set the state of the current history array to STATE.
proc history_set_history_state*(a2: ptr THISTORY_STATE){.cdecl, proc history_set_history_state*(a2: ptr HISTORY_STATE){.cdecl,
importc: "history_set_history_state", dynlib: historyDll.} importc: "history_set_history_state", dynlib: historyDll.}
# Manage the history list. # Manage the history list.
# Place STRING at the end of the history list. # Place STRING at the end of the history list.
@ -88,18 +90,18 @@ proc add_history_time*(a2: cstring){.cdecl, importc: "add_history_time",
# is the magic number that tells us which element to delete. The # is the magic number that tells us which element to delete. The
# elements are numbered from 0. # elements are numbered from 0.
proc remove_history*(a2: cint): ptr THIST_ENTRY{.cdecl, proc remove_history*(a2: cint): ptr HIST_ENTRY{.cdecl,
importc: "remove_history", dynlib: historyDll.} importc: "remove_history", dynlib: historyDll.}
# Free the history entry H and return any application-specific data # Free the history entry H and return any application-specific data
# associated with it. # associated with it.
proc free_history_entry*(a2: ptr THIST_ENTRY): Thistdata{.cdecl, proc free_history_entry*(a2: ptr HIST_ENTRY): Histdata{.cdecl,
importc: "free_history_entry", dynlib: historyDll.} importc: "free_history_entry", dynlib: historyDll.}
# Make the history entry at WHICH have LINE and DATA. This returns # Make the history entry at WHICH have LINE and DATA. This returns
# the old entry so you can dispose of the data. In the case of an # the old entry so you can dispose of the data. In the case of an
# invalid WHICH, a NULL pointer is returned. # invalid WHICH, a NULL pointer is returned.
proc replace_history_entry*(a2: cint, a3: cstring, a4: Thistdata): ptr THIST_ENTRY{. proc replace_history_entry*(a2: cint, a3: cstring, a4: Histdata): ptr HIST_ENTRY{.
cdecl, importc: "replace_history_entry", dynlib: historyDll.} cdecl, importc: "replace_history_entry", dynlib: historyDll.}
# Clear the history list and start over. # Clear the history list and start over.
@ -123,7 +125,7 @@ proc history_is_stifled*(): cint{.cdecl, importc: "history_is_stifled",
# history. Element 0 of this list is the beginning of time. If there # history. Element 0 of this list is the beginning of time. If there
# is no history, return NULL. # is no history, return NULL.
proc history_list*(): ptr ptr THIST_ENTRY{.cdecl, importc: "history_list", proc history_list*(): ptr ptr HIST_ENTRY{.cdecl, importc: "history_list",
dynlib: historyDll.} dynlib: historyDll.}
# Returns the number which says what history element we are now # Returns the number which says what history element we are now
# looking at. # looking at.
@ -132,17 +134,17 @@ proc where_history*(): cint{.cdecl, importc: "where_history", dynlib: historyDll
# Return the history entry at the current position, as determined by # Return the history entry at the current position, as determined by
# history_offset. If there is no entry there, return a NULL pointer. # history_offset. If there is no entry there, return a NULL pointer.
proc current_history*(): ptr THIST_ENTRY{.cdecl, importc: "current_history", proc current_history*(): ptr HIST_ENTRY{.cdecl, importc: "current_history",
dynlib: historyDll.} dynlib: historyDll.}
# Return the history entry which is logically at OFFSET in the history # Return the history entry which is logically at OFFSET in the history
# array. OFFSET is relative to history_base. # array. OFFSET is relative to history_base.
proc history_get*(a2: cint): ptr THIST_ENTRY{.cdecl, importc: "history_get", proc history_get*(a2: cint): ptr HIST_ENTRY{.cdecl, importc: "history_get",
dynlib: historyDll.} dynlib: historyDll.}
# Return the timestamp associated with the HIST_ENTRY * passed as an # Return the timestamp associated with the HIST_ENTRY * passed as an
# argument # argument
proc history_get_time*(a2: ptr THIST_ENTRY): Time{.cdecl, proc history_get_time*(a2: ptr HIST_ENTRY): Time{.cdecl,
importc: "history_get_time", dynlib: historyDll.} importc: "history_get_time", dynlib: historyDll.}
# Return the number of bytes that the primary history entries are using. # Return the number of bytes that the primary history entries are using.
# This just adds up the lengths of the_history->lines. # This just adds up the lengths of the_history->lines.
@ -158,13 +160,13 @@ proc history_set_pos*(a2: cint): cint{.cdecl, importc: "history_set_pos",
# a pointer to that entry. If there is no previous entry, return # a pointer to that entry. If there is no previous entry, return
# a NULL pointer. # a NULL pointer.
proc previous_history*(): ptr THIST_ENTRY{.cdecl, importc: "previous_history", proc previous_history*(): ptr HIST_ENTRY{.cdecl, importc: "previous_history",
dynlib: historyDll.} dynlib: historyDll.}
# Move history_offset forward to the next item in the input_history, # Move history_offset forward to the next item in the input_history,
# and return the a pointer to that entry. If there is no next entry, # and return the a pointer to that entry. If there is no next entry,
# return a NULL pointer. # return a NULL pointer.
proc next_history*(): ptr THIST_ENTRY{.cdecl, importc: "next_history", proc next_history*(): ptr HIST_ENTRY{.cdecl, importc: "next_history",
dynlib: historyDll.} dynlib: historyDll.}
# Searching the history list. # Searching the history list.
# Search the history for STRING, starting at history_offset. # Search the history for STRING, starting at history_offset.

55
lib/wrappers/readline/readline.nim
View file

@ -78,9 +78,10 @@ const
# TYPE says which kind of thing FUNCTION is. # TYPE says which kind of thing FUNCTION is.
type type
TKEYMAP_ENTRY*{.pure, final.} = object KEYMAP_ENTRY*{.pure, final.} = object
typ*: char typ*: char
function*: TCommandFunc function*: TCommandFunc
{.deprecated: [TKEYMAP_ENTRY: KEYMAP_ENTRY].}
# This must be large enough to hold bindings for all of the characters # This must be large enough to hold bindings for all of the characters
@ -97,8 +98,9 @@ const
# Maybe I need C lessons. # Maybe I need C lessons.
type type
TKEYMAP_ENTRY_ARRAY* = array[0..KEYMAP_SIZE - 1, TKEYMAP_ENTRY] KEYMAP_ENTRY_ARRAY* = array[0..KEYMAP_SIZE - 1, KEYMAP_ENTRY]
PKeymap* = ptr TKEYMAP_ENTRY PKeymap* = ptr KEYMAP_ENTRY
{.deprecated: [TKEYMAP_ENTRY_ARRAY: KEYMAP_ENTRY_ARRAY].}
# The values that TYPE can have in a keymap entry. # The values that TYPE can have in a keymap entry.
@ -110,12 +112,12 @@ const
when false: when false:
var var
emacs_standard_keymap*{.importc: "emacs_standard_keymap", emacs_standard_keymap*{.importc: "emacs_standard_keymap",
dynlib: readlineDll.}: TKEYMAP_ENTRY_ARRAY dynlib: readlineDll.}: KEYMAP_ENTRY_ARRAY
emacs_meta_keymap*{.importc: "emacs_meta_keymap", dynlib: readlineDll.}: TKEYMAP_ENTRY_ARRAY emacs_meta_keymap*{.importc: "emacs_meta_keymap", dynlib: readlineDll.}: KEYMAP_ENTRY_ARRAY
emacs_ctlx_keymap*{.importc: "emacs_ctlx_keymap", dynlib: readlineDll.}: TKEYMAP_ENTRY_ARRAY emacs_ctlx_keymap*{.importc: "emacs_ctlx_keymap", dynlib: readlineDll.}: KEYMAP_ENTRY_ARRAY
var var
vi_insertion_keymap*{.importc: "vi_insertion_keymap", dynlib: readlineDll.}: TKEYMAP_ENTRY_ARRAY vi_insertion_keymap*{.importc: "vi_insertion_keymap", dynlib: readlineDll.}: KEYMAP_ENTRY_ARRAY
vi_movement_keymap*{.importc: "vi_movement_keymap", dynlib: readlineDll.}: TKEYMAP_ENTRY_ARRAY vi_movement_keymap*{.importc: "vi_movement_keymap", dynlib: readlineDll.}: KEYMAP_ENTRY_ARRAY
# Return a new, empty keymap. # Return a new, empty keymap.
# Free it with free() when you are done. # Free it with free() when you are done.
@ -154,7 +156,8 @@ const
tildeDll = readlineDll tildeDll = readlineDll
type type
Thook_func* = proc (a2: cstring): cstring{.cdecl.} Hook_func* = proc (a2: cstring): cstring{.cdecl.}
{.deprecated: [Thook_func: Hook_func].}
when not defined(macosx): when not defined(macosx):
# If non-null, this contains the address of a function that the application # If non-null, this contains the address of a function that the application
@ -163,7 +166,7 @@ when not defined(macosx):
# which is the expansion, or a NULL pointer if the expansion fails. # which is the expansion, or a NULL pointer if the expansion fails.
var expansion_preexpansion_hook*{.importc: "tilde_expansion_preexpansion_hook", var expansion_preexpansion_hook*{.importc: "tilde_expansion_preexpansion_hook",
dynlib: tildeDll.}: Thook_func dynlib: tildeDll.}: Hook_func
# If non-null, this contains the address of a function to call if the # If non-null, this contains the address of a function to call if the
# standard meaning for expanding a tilde fails. The function is called # standard meaning for expanding a tilde fails. The function is called
@ -171,7 +174,7 @@ when not defined(macosx):
# which is the expansion, or a NULL pointer if there is no expansion. # which is the expansion, or a NULL pointer if there is no expansion.
var expansion_failure_hook*{.importc: "tilde_expansion_failure_hook", var expansion_failure_hook*{.importc: "tilde_expansion_failure_hook",
dynlib: tildeDll.}: Thook_func dynlib: tildeDll.}: Hook_func
# When non-null, this is a NULL terminated array of strings which # When non-null, this is a NULL terminated array of strings which
# are duplicates for a tilde prefix. Bash uses this to expand # are duplicates for a tilde prefix. Bash uses this to expand
@ -214,35 +217,38 @@ const
# the code tells undo what to undo, not how to undo it. # the code tells undo what to undo, not how to undo it.
type type
Tundo_code* = enum Undo_code* = enum
UNDO_DELETE, UNDO_INSERT, UNDO_BEGIN, UNDO_END UNDO_DELETE, UNDO_INSERT, UNDO_BEGIN, UNDO_END
{.deprecated: [Tundo_code: Undo_code].}
# What an element of THE_UNDO_LIST looks like. # What an element of THE_UNDO_LIST looks like.
type type
TUNDO_LIST*{.pure, final.} = object UNDO_LIST*{.pure, final.} = object
next*: ptr Tundo_list next*: ptr UNDO_LIST
start*: cint start*: cint
theEnd*: cint # Where the change took place. theEnd*: cint # Where the change took place.
text*: cstring # The text to insert, if undoing a delete. text*: cstring # The text to insert, if undoing a delete.
what*: Tundo_code # Delete, Insert, Begin, End. what*: Undo_code # Delete, Insert, Begin, End.
{.deprecated: [TUNDO_LIST: UNDO_LIST].}
# The current undo list for RL_LINE_BUFFER. # The current undo list for RL_LINE_BUFFER.
when not defined(macosx): when not defined(macosx):
var undo_list*{.importc: "rl_undo_list", dynlib: readlineDll.}: ptr TUNDO_LIST var undo_list*{.importc: "rl_undo_list", dynlib: readlineDll.}: ptr UNDO_LIST
# The data structure for mapping textual names to code addresses. # The data structure for mapping textual names to code addresses.
type type
TFUNMAP*{.pure, final.} = object FUNMAP*{.pure, final.} = object
name*: cstring name*: cstring
function*: TCommandFunc function*: TCommandFunc
{.deprecated: [TFUNMAP: FUNMAP].}
when not defined(macosx): when not defined(macosx):
var funmap*{.importc: "funmap", dynlib: readlineDll.}: ptr ptr TFUNMAP var funmap*{.importc: "funmap", dynlib: readlineDll.}: ptr ptr FUNMAP
# **************************************************************** # ****************************************************************
# #
@ -697,7 +703,7 @@ proc push_macro_input*(a2: cstring){.cdecl, importc: "rl_push_macro_input",
dynlib: readlineDll.} dynlib: readlineDll.}
# Functions for undoing, from undo.c # Functions for undoing, from undo.c
proc add_undo*(a2: Tundo_code, a3: cint, a4: cint, a5: cstring){.cdecl, proc add_undo*(a2: Undo_code, a3: cint, a4: cint, a5: cstring){.cdecl,
importc: "rl_add_undo", dynlib: readlineDll.} importc: "rl_add_undo", dynlib: readlineDll.}
proc free_undo_list*(){.cdecl, importc: "rl_free_undo_list", dynlib: readlineDll.} proc free_undo_list*(){.cdecl, importc: "rl_free_undo_list", dynlib: readlineDll.}
proc do_undo*(): cint{.cdecl, importc: "rl_do_undo", dynlib: readlineDll.} proc do_undo*(): cint{.cdecl, importc: "rl_do_undo", dynlib: readlineDll.}
@ -816,7 +822,7 @@ proc complete_internal*(a2: cint): cint{.cdecl, importc: "rl_complete_internal",
dynlib: readlineDll.} dynlib: readlineDll.}
proc display_match_list*(a2: cstringArray, a3: cint, a4: cint){.cdecl, proc display_match_list*(a2: cstringArray, a3: cint, a4: cint){.cdecl,
importc: "rl_display_match_list", dynlib: readlineDll.} importc: "rl_display_match_list", dynlib: readlineDll.}
proc completion_matches*(a2: cstring, a3: Tcompentry_func): cstringArray{. proc completion_matches*(a2: cstring, a3: Compentry_func): cstringArray{.
cdecl, importc: "rl_completion_matches", dynlib: readlineDll.} cdecl, importc: "rl_completion_matches", dynlib: readlineDll.}
proc username_completion_function*(a2: cstring, a3: cint): cstring{.cdecl, proc username_completion_function*(a2: cstring, a3: cint): cstring{.cdecl,
importc: "rl_username_completion_function", dynlib: readlineDll.} importc: "rl_username_completion_function", dynlib: readlineDll.}
@ -1169,13 +1175,13 @@ template ISSTATE*(x: expr): expr =
(readline_state and x) != 0 (readline_state and x) != 0
type type
Treadline_state*{.pure, final.} = object Readline_state*{.pure, final.} = object
point*: cint # line state point*: cint # line state
theEnd*: cint theEnd*: cint
mark*: cint mark*: cint
buffer*: cstring buffer*: cstring
buflen*: cint buflen*: cint
ul*: ptr TUNDO_LIST ul*: ptr UNDO_LIST
prompt*: cstring # global state prompt*: cstring # global state
rlstate*: cint rlstate*: cint
done*: cint done*: cint
@ -1194,9 +1200,10 @@ type
# options state # options state
# reserved for future expansion, so the struct size doesn't change # reserved for future expansion, so the struct size doesn't change
reserved*: array[0..64 - 1, char] reserved*: array[0..64 - 1, char]
{.deprecated: [Treadline_state: Readline_state].}
proc save_state*(a2: ptr Treadline_state): cint{.cdecl, proc save_state*(a2: ptr Readline_state): cint{.cdecl,
importc: "rl_save_state", dynlib: readlineDll.} importc: "rl_save_state", dynlib: readlineDll.}
proc restore_state*(a2: ptr Treadline_state): cint{.cdecl, proc restore_state*(a2: ptr Readline_state): cint{.cdecl,
importc: "rl_restore_state", dynlib: readlineDll.} importc: "rl_restore_state", dynlib: readlineDll.}

29
lib/wrappers/readline/rltypedefs.nim
View file

@ -19,27 +19,32 @@
# #
type type
TFunction* = proc (): cint{.cdecl.} Function* = proc (): cint{.cdecl.}
TVFunction* = proc (){.cdecl.} VFunction* = proc (){.cdecl.}
TCPFunction* = proc (): cstring{.cdecl.} CPFunction* = proc (): cstring{.cdecl.}
TCPPFunction* = proc (): cstringArray{.cdecl.} CPPFunction* = proc (): cstringArray{.cdecl.}
{.deprecated: [TFunction: Function, TVFunction: VFunction,
TCPFunction: CPFunction, TCPPFunction: CPPFunction].}
# Bindable functions # Bindable functions
type type
Tcommand_func* = proc (a2: cint, a3: cint): cint{.cdecl.} Command_func* = proc (a2: cint, a3: cint): cint{.cdecl.}
{.deprecated: [Tcommand_func: Command_func].}
# Typedefs for the completion system # Typedefs for the completion system
type type
Tcompentry_func* = proc (a2: cstring, a3: cint): cstring{.cdecl.} Compentry_func* = proc (a2: cstring, a3: cint): cstring{.cdecl.}
Tcompletion_func* = proc (a2: cstring, a3: cint, a4: cint): cstringArray{. Completion_func* = proc (a2: cstring, a3: cint, a4: cint): cstringArray{.
cdecl.} cdecl.}
Tquote_func* = proc (a2: cstring, a3: cint, a4: cstring): cstring{.cdecl.} Quote_func* = proc (a2: cstring, a3: cint, a4: cstring): cstring{.cdecl.}
Tdequote_func* = proc (a2: cstring, a3: cint): cstring{.cdecl.} Dequote_func* = proc (a2: cstring, a3: cint): cstring{.cdecl.}
Tcompignore_func* = proc (a2: cstringArray): cint{.cdecl.} Compignore_func* = proc (a2: cstringArray): cint{.cdecl.}
Tcompdisp_func* = proc (a2: cstringArray, a3: cint, a4: cint){.cdecl.} Compdisp_func* = proc (a2: cstringArray, a3: cint, a4: cint){.cdecl.}
{.deprecated: [Tcompentry_func: Compentry_func,Tcompletion_func: Completion_func,
Tquote_func: Quote_func, Tdequote_func: Dequote_func,
Tcompignore_func: Compignore_func, Tcompdisp_func: Compdisp_func].}
# Type for input and pre-read hook functions like rl_event_hook # Type for input and pre-read hook functions like rl_event_hook
type type