version 0.7.6

29 files changed, 5926 insertions, 0 deletions

diff --git a/boot.nim b/boot.nim
new file mode 100644
index 000000000..7b1745391
--- /dev/null
+++ b/boot.nim
@@ -0,0 +1,67 @@
+#
+#
+#             Nimrod Bootstrap Program
+#        (c) Copyright 2009 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+import
+  os, strutils
+
+const
+  BootCmd = "nimrod cc --compile:build/platdef.c $1 rod/nimrod.nim"
+  PlatdefCTmpl = """
+/* Generated by boot.nim */
+char* nimOS(void) { return "$1"; }
+char* nimCPU(void) { return "$2"; }
+"""
+
+proc exec(cmd: string) =
+  echo(cmd)
+  if executeShellCommand(cmd) != 0: quit("FAILURE")
+
+proc writePlatdefC =
+  var f: TFile
+  if openFile(f, "build/platdef.c", fmWrite): 
+    write(f, PlatdefcTmpl % [system.hostOS, system.hostCPU])
+    closeFile(f)
+  else:
+    quit("Cannot write 'build/platdef.c'\n")
+  
+proc rodsrc = 
+  const
+    blacklist = ["nsystem", "nmath", "nos", "ntime", "strutils"]
+    cmd = "nimrod boot --skip_proj_cfg -o:rod/$1.nim nim/$1"
+  for fi in walkFiles("nim/*.pas"):
+    var f = extractFileTrunk(fi)
+    if find(blacklist, f) >= 0: continue
+    var r = "rod" / appendFileExt(f, "nim")
+    if not existsFile(r) or fileNewer(fi, r):
+      Exec(cmd % f)
+  
+proc boot(args: string) =
+  writePlatdefC()
+  rodsrc()
+  var newExe = appendFileExt("rod/nimrod", ExeExt)
+  var oldExe = appendFileExt("bin/nimrod", ExeExt)
+  for i in 1..2:
+    Echo("iteration: ", $i)
+    # use the new executable to compile the files in the bootstrap directory:
+    Exec(Bootcmd % args)
+    if sameFileContent(newExe, oldExe): 
+      Echo("executables are equal: SUCCESS!")
+      return
+    else:
+      Echo("executables are not equal: compile once again...")
+      # move the new executable to bin directory:
+      os.moveFile(oldExe, newExe)
+  Echo("[Warning] executables are still not equal")
+
+var a = ""
+for i in 1 .. paramCount():
+  add(a, ' ')
+  add(a, paramStr(i))
+boot(a)
+
diff --git a/examples/hallo.nim b/examples/hallo.nim
new file mode 100644
index 000000000..73ef2cb95
--- /dev/null
+++ b/examples/hallo.nim
@@ -0,0 +1,7 @@
+# Hallo world program
+
+import strutils
+
+echo($(parseFloat("0.5")* toFloat(5000) / toFloat(parseInt("5000"))))
+
+echo("Hallo world!")
diff --git a/examples/htmlrefs.nim b/examples/htmlrefs.nim
new file mode 100644
index 000000000..cf1b3be28
--- /dev/null
+++ b/examples/htmlrefs.nim
@@ -0,0 +1,58 @@
+# Example program to show the new parsexml module
+# This program reads an HTML file and writes all its used links to stdout.
+# Errors and whitespace are ignored.
+# (c) 2009 Andreas Rumpf
+
+import os, streams, parsexml, strutils
+
+proc `=?=` (a, b: string): bool = 
+  # little trick: define our own comparator that ignores case
+  return cmpIgnoreCase(a, b) == 0
+
+if paramCount() < 1: 
+  quit("Usage: htmlrefs filename[.html]")
+
+var links = 0 # count the number of links
+var filename = appendFileExt(ParamStr(1), "html")
+var s = newFileStream(filename, fmRead)
+if s == nil: quit("cannot open the file" & filename)
+var x: TXmlParser
+open(x, s, filename)
+next(x) # get first event
+block mainLoop:
+  while true:
+    case x.kind
+    of xmlElementOpen: 
+      # the <a href = "xyz"> tag we are interested in always has an attribute,
+      # thus we search for ``xmlElementOpen`` and not for ``xmlElementStart``
+      if x.elementName =?= "a": 
+        x.next()
+        if x.kind == xmlAttribute: 
+          if x.attrKey =?= "href":
+            var link = x.attrValue
+            inc(links)
+            # skip until we have an ``xmlElementClose`` event
+            while true: 
+              x.next()
+              case x.kind
+              of xmlEof: break mainLoop
+              of xmlElementClose: break
+              else: nil
+            x.next() # skip ``xmlElementClose``
+            # now we have the description for the ``a`` element
+            var desc = ""
+            while x.kind == xmlCharData: 
+              desc.add(x.charData)
+              x.next()
+            Echo(desc & ": " & link)
+      else:
+        x.next()      
+    of xmlEof: break # end of file reached
+    of xmlError: 
+      Echo(errorMsg(x))
+      x.next()
+    else: x.next() # skip other events
+
+echo($links & " link(s) found!")
+x.close()
+
diff --git a/examples/htmltitle.nim b/examples/htmltitle.nim
new file mode 100644
index 000000000..6cdfd90eb
--- /dev/null
+++ b/examples/htmltitle.nim
@@ -0,0 +1,37 @@
+# Example program to show the new parsexml module
+# This program reads an HTML file and writes its title to stdout.
+# Errors and whitespace are ignored.
+# (c) 2009 Andreas Rumpf
+
+import os, streams, parsexml, strutils
+
+if paramCount() < 1: 
+  quit("Usage: htmltitle filename[.html]")
+
+var filename = appendFileExt(ParamStr(1), "html")
+var s = newFileStream(filename, fmRead)
+if s == nil: quit("cannot open the file" & filename)
+var x: TXmlParser
+open(x, s, filename)
+while true:
+  x.next()
+  case x.kind
+  of xmlElementStart: 
+    if cmpIgnoreCase(x.elementName, "title") == 0: 
+      var title = ""
+      x.next()  # skip "<title>"
+      while x.kind == xmlCharData: 
+        title.add(x.charData)
+        x.next()
+      if x.kind == xmlElementEnd and cmpIgnoreCase(x.elementName, "title") == 0:
+        Echo("Title: " & title)
+        quit(0) # Success!
+      else:
+        echo(x.errorMsgExpected("/title"))
+  
+  of xmlEof: break # end of file reached
+  else: nil # ignore other events
+
+quit("Could not determine title!")
+x.close()
+
diff --git a/examples/readme.txt b/examples/readme.txt
new file mode 100644
index 000000000..e6e47c1d1
--- /dev/null
+++ b/examples/readme.txt
@@ -0,0 +1,5 @@
+In this directory you will find several examples for how to use the Nimrod 
+library. 
+

+Copyright (c) 2004-2009 Andreas Rumpf.

+All rights reserved.

diff --git a/lib/base/libcurl.nim b/lib/base/libcurl.nim
new file mode 100644
index 000000000..5d54a2640
--- /dev/null
+++ b/lib/base/libcurl.nim
@@ -0,0 +1,642 @@
+#
+#    $Id: header,v 1.1 2000/07/13 06:33:45 michael Exp $
+#    This file is part of the Free Pascal packages
+#    Copyright (c) 1999-2000 by the Free Pascal development team
+#
+#    See the file COPYING.FPC, included in this distribution,
+#    for details about the copyright.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# **********************************************************************
+#
+#   the curl library is governed by its own copyright, see the curl
+#   website for this. 
+# 
+
+import times
+
+when defined(windows):
+  const libname = "libcurl.dll"
+elif defined(macosx):
+  const libname = "libcurl-7.19.3.dylib"
+elif defined(unix):
+  const libname = "libcurl.so.4"
+
+type 
+  Pcurl_calloc_callback* = ptr Tcurl_calloc_callback
+  Pcurl_closepolicy* = ptr Tcurl_closepolicy
+  Pcurl_forms* = ptr Tcurl_forms
+  Pcurl_ftpauth* = ptr Tcurl_ftpauth
+  Pcurl_ftpmethod* = ptr Tcurl_ftpmethod
+  Pcurl_ftpssl* = ptr Tcurl_ftpssl
+  PCURL_HTTP_VERSION* = ptr TCURL_HTTP_VERSION
+  Pcurl_httppost* = ptr Tcurl_httppost
+  PPcurl_httppost* = ptr Pcurl_httppost
+  Pcurl_infotype* = ptr Tcurl_infotype
+  Pcurl_lock_access* = ptr Tcurl_lock_access
+  Pcurl_lock_data* = ptr Tcurl_lock_data
+  Pcurl_malloc_callback* = ptr tcurl_malloc_callback
+  PCURL_NETRC_OPTION* = ptr TCURL_NETRC_OPTION
+  Pcurl_proxytype* = ptr Tcurl_proxytype
+  Pcurl_realloc_callback* = ptr tcurl_realloc_callback
+  Pcurl_slist* = ptr Tcurl_slist
+  Pcurl_socket* = ptr Tcurl_socket
+  PCURL_SSL_VERSION* = ptr TCURL_SSL_VERSION
+  Pcurl_strdup_callback* = ptr Tcurl_strdup_callback
+  PCURL_TIMECOND* = ptr TCURL_TIMECOND
+  Pcurl_version_info_data* = ptr Tcurl_version_info_data
+  PCURLcode* = ptr TCURLcode
+  PCURLFORMcode* = ptr TCURLFORMcode
+  PCURLformoption* = ptr TCURLformoption
+  PCURLINFO* = ptr TCURLINFO
+  Pcurliocmd* = ptr Tcurliocmd
+  Pcurlioerr* = ptr Tcurlioerr
+  PCURLM* = ptr TCURLM
+  PCURLMcode* = ptr TCURLMcode
+  PCURLMoption* = ptr TCURLMoption
+  PCURLMSG* = ptr TCURLMSG
+  PCURLoption* = ptr TCURLoption
+  PCURLSH* = ptr TCURLSH
+  PCURLSHcode* = ptr TCURLSHcode
+  PCURLSHoption* = ptr TCURLSHoption
+  PCURLversion* = ptr TCURLversion
+  Pfd_set* = pointer
+  PCURL* = ptr TCurl
+  TCurl* = pointer
+  Tcurl_httppost* {.final, pure.} = object 
+    next*: Pcurl_httppost
+    name*: cstring
+    namelength*: int32
+    contents*: cstring
+    contentslength*: int32
+    buffer*: cstring
+    bufferlength*: int32
+    contenttype*: cstring
+    contentheader*: Pcurl_slist
+    more*: Pcurl_httppost
+    flags*: int32
+    showfilename*: cstring
+
+  Tcurl_progress_callback* = proc (clientp: pointer, dltotal: float64, 
+                                   dlnow: float64, ultotal: float64, 
+                                   ulnow: float64): int32{.cdecl.}
+  Tcurl_write_callback* = proc (buffer: cstring, size: int, nitems: int, 
+                                outstream: pointer): int{.cdecl.}
+  Tcurl_read_callback* = proc (buffer: cstring, size: int, nitems: int, 
+                               instream: pointer): int{.cdecl.}
+  Tcurl_passwd_callback* = proc (clientp: pointer, prompt: cstring, 
+                                 buffer: cstring, buflen: int32): int32{.cdecl.}
+  Tcurlioerr* = enum 
+    CURLIOE_OK, CURLIOE_UNKNOWNCMD, CURLIOE_FAILRESTART, CURLIOE_LAST
+  Tcurliocmd* = enum 
+    CURLIOCMD_NOP, CURLIOCMD_RESTARTREAD, CURLIOCMD_LAST
+  Tcurl_ioctl_callback* = proc (handle: PCURL, cmd: int32, 
+                                clientp: pointer): Tcurlioerr {.cdecl.}
+  Tcurl_malloc_callback* = proc (size: int): pointer {.cdecl.}
+  Tcurl_free_callback* = proc (p: pointer) {.cdecl.}
+  Tcurl_realloc_callback* = proc (p: pointer, size: int): pointer {.cdecl.}
+  Tcurl_strdup_callback* = proc (str: cstring): cstring {.cdecl.}
+  Tcurl_calloc_callback* = proc (nmemb: int, size: int): pointer
+  Tcurl_infotype* = enum 
+    CURLINFO_TEXT = 0, CURLINFO_HEADER_IN, CURLINFO_HEADER_OUT, 
+    CURLINFO_DATA_IN, CURLINFO_DATA_OUT, CURLINFO_SSL_DATA_IN, 
+    CURLINFO_SSL_DATA_OUT, CURLINFO_END
+  Tcurl_debug_callback* = proc (handle: PCURL, theType: Tcurl_infotype, 
+                                data: cstring, size: int, 
+                                userptr: pointer): int32 {.cdecl.}
+  TCURLcode* = enum 
+    CURLE_OK = 0, CURLE_UNSUPPORTED_PROTOCOL, CURLE_FAILED_INIT, 
+    CURLE_URL_MALFORMAT, CURLE_URL_MALFORMAT_USER, CURLE_COULDNT_RESOLVE_PROXY, 
+    CURLE_COULDNT_RESOLVE_HOST, CURLE_COULDNT_CONNECT, 
+    CURLE_FTP_WEIRD_SERVER_REPLY, CURLE_FTP_ACCESS_DENIED, 
+    CURLE_FTP_USER_PASSWORD_INCORRECT, CURLE_FTP_WEIRD_PASS_REPLY, 
+    CURLE_FTP_WEIRD_USER_REPLY, CURLE_FTP_WEIRD_PASV_REPLY, 
+    CURLE_FTP_WEIRD_227_FORMAT, CURLE_FTP_CANT_GET_HOST, 
+    CURLE_FTP_CANT_RECONNECT, CURLE_FTP_COULDNT_SET_BINARY, CURLE_PARTIAL_FILE, 
+    CURLE_FTP_COULDNT_RETR_FILE, CURLE_FTP_WRITE_ERROR, CURLE_FTP_QUOTE_ERROR, 
+    CURLE_HTTP_RETURNED_ERROR, CURLE_WRITE_ERROR, CURLE_MALFORMAT_USER, 
+    CURLE_FTP_COULDNT_STOR_FILE, CURLE_READ_ERROR, CURLE_OUT_OF_MEMORY, 
+    CURLE_OPERATION_TIMEOUTED, CURLE_FTP_COULDNT_SET_ASCII, 
+    CURLE_FTP_PORT_FAILED, CURLE_FTP_COULDNT_USE_REST, 
+    CURLE_FTP_COULDNT_GET_SIZE, CURLE_HTTP_RANGE_ERROR, CURLE_HTTP_POST_ERROR, 
+    CURLE_SSL_CONNECT_ERROR, CURLE_BAD_DOWNLOAD_RESUME, 
+    CURLE_FILE_COULDNT_READ_FILE, CURLE_LDAP_CANNOT_BIND, 
+    CURLE_LDAP_SEARCH_FAILED, CURLE_LIBRARY_NOT_FOUND, CURLE_FUNCTION_NOT_FOUND, 
+    CURLE_ABORTED_BY_CALLBACK, CURLE_BAD_FUNCTION_ARGUMENT, 
+    CURLE_BAD_CALLING_ORDER, CURLE_INTERFACE_FAILED, CURLE_BAD_PASSWORD_ENTERED, 
+    CURLE_TOO_MANY_REDIRECTS, CURLE_UNKNOWN_TELNET_OPTION, 
+    CURLE_TELNET_OPTION_SYNTAX, CURLE_OBSOLETE, CURLE_SSL_PEER_CERTIFICATE, 
+    CURLE_GOT_NOTHING, CURLE_SSL_ENGINE_NOTFOUND, CURLE_SSL_ENGINE_SETFAILED, 
+    CURLE_SEND_ERROR, CURLE_RECV_ERROR, CURLE_SHARE_IN_USE, 
+    CURLE_SSL_CERTPROBLEM, CURLE_SSL_CIPHER, CURLE_SSL_CACERT, 
+    CURLE_BAD_CONTENT_ENCODING, CURLE_LDAP_INVALID_URL, CURLE_FILESIZE_EXCEEDED, 
+    CURLE_FTP_SSL_FAILED, CURLE_SEND_FAIL_REWIND, CURLE_SSL_ENGINE_INITFAILED, 
+    CURLE_LOGIN_DENIED, CURLE_TFTP_NOTFOUND, CURLE_TFTP_PERM, 
+    CURLE_TFTP_DISKFULL, CURLE_TFTP_ILLEGAL, CURLE_TFTP_UNKNOWNID, 
+    CURLE_TFTP_EXISTS, CURLE_TFTP_NOSUCHUSER, CURLE_CONV_FAILED, 
+    CURLE_CONV_REQD, CURL_LAST
+  Tcurl_conv_callback* = proc (buffer: cstring, len: int): TCURLcode {.cdecl.}
+  Tcurl_ssl_ctx_callback* = proc (curl: PCURL, 
+                                 ssl_ctx, userptr: pointer): TCURLcode {.cdecl.}
+  Tcurl_proxytype* = enum 
+    CURLPROXY_HTTP = 0, CURLPROXY_SOCKS4 = 4, CURLPROXY_SOCKS5 = 5
+  Tcurl_ftpssl* = enum 
+    CURLFTPSSL_NONE, CURLFTPSSL_TRY, CURLFTPSSL_CONTROL, CURLFTPSSL_ALL, 
+    CURLFTPSSL_LAST
+  Tcurl_ftpauth* = enum 
+    CURLFTPAUTH_DEFAULT, CURLFTPAUTH_SSL, CURLFTPAUTH_TLS, CURLFTPAUTH_LAST
+  Tcurl_ftpmethod* = enum 
+    CURLFTPMETHOD_DEFAULT, CURLFTPMETHOD_MULTICWD, CURLFTPMETHOD_NOCWD, 
+    CURLFTPMETHOD_SINGLECWD, CURLFTPMETHOD_LAST
+  TCURLoption* = enum 
+    CURLOPT_PORT = 0 + 3,
+    CURLOPT_TIMEOUT = 0 + 13, 
+    CURLOPT_INFILESIZE = 0 + 14, 
+    CURLOPT_LOW_SPEED_LIMIT = 0 + 19, 
+    CURLOPT_LOW_SPEED_TIME = 0 + 20, 
+    CURLOPT_RESUME_FROM = 0 + 21,
+    CURLOPT_CRLF = 0 + 27, 
+    CURLOPT_SSLVERSION = 0 + 32, 
+    CURLOPT_TIMECONDITION = 0 + 33, 
+    CURLOPT_TIMEVALUE = 0 + 34, 
+    CURLOPT_VERBOSE = 0 + 41, 
+    CURLOPT_HEADER = 0 + 42, 
+    CURLOPT_NOPROGRESS = 0 + 43, 
+    CURLOPT_NOBODY = 0 + 44, 
+    CURLOPT_FAILONERROR = 0 + 45, 
+    CURLOPT_UPLOAD = 0 + 46, 
+    CURLOPT_POST = 0 + 47, 
+    CURLOPT_FTPLISTONLY = 0 + 48, 
+    CURLOPT_FTPAPPEND = 0 + 50, 
+    CURLOPT_NETRC = 0 + 51, 
+    CURLOPT_FOLLOWLOCATION = 0 + 52, 
+    CURLOPT_TRANSFERTEXT = 0 + 53, 
+    CURLOPT_PUT = 0 + 54, 
+    CURLOPT_AUTOREFERER = 0 + 58, 
+    CURLOPT_PROXYPORT = 0 + 59, 
+    CURLOPT_POSTFIELDSIZE = 0 + 60, 
+    CURLOPT_HTTPPROXYTUNNEL = 0 + 61, 
+    CURLOPT_SSL_VERIFYPEER = 0 + 64, 
+    CURLOPT_MAXREDIRS = 0 + 68, 
+    CURLOPT_FILETIME = 0 + 69, 
+    CURLOPT_MAXCONNECTS = 0 + 71, 
+    CURLOPT_CLOSEPOLICY = 0 + 72, 
+    CURLOPT_FRESH_CONNECT = 0 + 74, 
+    CURLOPT_FORBID_REUSE = 0 + 75, 
+    CURLOPT_CONNECTTIMEOUT = 0 + 78, 
+    CURLOPT_HTTPGET = 0 + 80, 
+    CURLOPT_SSL_VERIFYHOST = 0 + 81, 
+    CURLOPT_HTTP_VERSION = 0 + 84, 
+    CURLOPT_FTP_USE_EPSV = 0 + 85, 
+    CURLOPT_SSLENGINE_DEFAULT = 0 + 90, 
+    CURLOPT_DNS_USE_GLOBAL_CACHE = 0 + 91, 
+    CURLOPT_DNS_CACHE_TIMEOUT = 0 + 92, 
+    CURLOPT_COOKIESESSION = 0 + 96, 
+    CURLOPT_BUFFERSIZE = 0 + 98, 
+    CURLOPT_NOSIGNAL = 0 + 99, 
+    CURLOPT_PROXYTYPE = 0 + 101, 
+    CURLOPT_UNRESTRICTED_AUTH = 0 + 105, 
+    CURLOPT_FTP_USE_EPRT = 0 + 106, 
+    CURLOPT_HTTPAUTH = 0 + 107, 
+    CURLOPT_FTP_CREATE_MISSING_DIRS = 0 + 110, 
+    CURLOPT_PROXYAUTH = 0 + 111, 
+    CURLOPT_FTP_RESPONSE_TIMEOUT = 0 + 112, 
+    CURLOPT_IPRESOLVE = 0 + 113, 
+    CURLOPT_MAXFILESIZE = 0 + 114, 
+    CURLOPT_FTP_SSL = 0 + 119, 
+    CURLOPT_TCP_NODELAY = 0 + 121, 
+    CURLOPT_FTPSSLAUTH = 0 + 129, 
+    CURLOPT_IGNORE_CONTENT_LENGTH = 0 + 136, 
+    CURLOPT_FTP_SKIP_PASV_IP = 0 + 137, 
+    CURLOPT_FTP_FILEMETHOD = 0 + 138, 
+    CURLOPT_LOCALPORT = 0 + 139, 
+    CURLOPT_LOCALPORTRANGE = 0 + 140, 
+    CURLOPT_CONNECT_ONLY = 0 + 141, 
+
+    CURLOPT_FILE = 10000 + 1, 
+    CURLOPT_URL = 10000 + 2,  
+    CURLOPT_PROXY = 10000 + 4, 
+    CURLOPT_USERPWD = 10000 + 5, 
+    CURLOPT_PROXYUSERPWD = 10000 + 6, 
+    CURLOPT_RANGE = 10000 + 7, 
+    CURLOPT_INFILE = 10000 + 9, 
+    CURLOPT_ERRORBUFFER = 10000 + 10, 
+    CURLOPT_POSTFIELDS = 10000 + 15, 
+    CURLOPT_REFERER = 10000 + 16, 
+    CURLOPT_FTPPORT = 10000 + 17, 
+    CURLOPT_USERAGENT = 10000 + 18, 
+    CURLOPT_COOKIE = 10000 + 22, 
+    CURLOPT_HTTPHEADER = 10000 + 23, 
+    CURLOPT_HTTPPOST = 10000 + 24, 
+    CURLOPT_SSLCERT = 10000 + 25, 
+    CURLOPT_SSLCERTPASSWD = 10000 + 26, 
+    CURLOPT_QUOTE = 10000 + 28, 
+    CURLOPT_WRITEHEADER = 10000 + 29, 
+    CURLOPT_COOKIEFILE = 10000 + 31, 
+    CURLOPT_CUSTOMREQUEST = 10000 + 36, 
+    CURLOPT_STDERR = 10000 + 37, 
+    CURLOPT_POSTQUOTE = 10000 + 39, 
+    CURLOPT_WRITEINFO = 10000 + 40, 
+    CURLOPT_PROGRESSDATA = 10000 + 57, 
+    CURLOPT_INTERFACE = 10000 + 62, 
+    CURLOPT_KRB4LEVEL = 10000 + 63,
+    CURLOPT_CAINFO = 10000 + 65, 
+    CURLOPT_TELNETOPTIONS = 10000 + 70, 
+    CURLOPT_RANDOM_FILE = 10000 + 76, 
+    CURLOPT_EGDSOCKET = 10000 + 77, 
+    CURLOPT_COOKIEJAR = 10000 + 82, 
+    CURLOPT_SSL_CIPHER_LIST = 10000 + 83, 
+    CURLOPT_SSLCERTTYPE = 10000 + 86, 
+    CURLOPT_SSLKEY = 10000 + 87, 
+    CURLOPT_SSLKEYTYPE = 10000 + 88, 
+    CURLOPT_SSLENGINE = 10000 + 89, 
+    CURLOPT_PREQUOTE = 10000 + 93, 
+    CURLOPT_DEBUGDATA = 10000 + 95, 
+    CURLOPT_CAPATH = 10000 + 97, 
+    CURLOPT_SHARE = 10000 + 100, 
+    CURLOPT_ENCODING = 10000 + 102, 
+    CURLOPT_PRIVATE = 10000 + 103, 
+    CURLOPT_HTTP200ALIASES = 10000 + 104, 
+    CURLOPT_SSL_CTX_DATA = 10000 + 109, 
+    CURLOPT_NETRC_FILE = 10000 + 118, 
+    CURLOPT_SOURCE_USERPWD = 10000 + 123, 
+    CURLOPT_SOURCE_PREQUOTE = 10000 + 127, 
+    CURLOPT_SOURCE_POSTQUOTE = 10000 + 128, 
+    CURLOPT_IOCTLDATA = 10000 + 131, 
+    CURLOPT_SOURCE_URL = 10000 + 132, 
+    CURLOPT_SOURCE_QUOTE = 10000 + 133, 
+    CURLOPT_FTP_ACCOUNT = 10000 + 134, 
+    CURLOPT_COOKIELIST = 10000 + 135, 
+    CURLOPT_FTP_ALTERNATIVE_TO_USER = 10000 + 147, 
+    CURLOPT_LASTENTRY = 10000 + 148,
+    
+    CURLOPT_WRITEFUNCTION = 20000 + 11, 
+    CURLOPT_READFUNCTION = 20000 + 12, 
+    CURLOPT_PROGRESSFUNCTION = 20000 + 56, 
+    CURLOPT_HEADERFUNCTION = 20000 + 79, 
+    CURLOPT_DEBUGFUNCTION = 20000 + 94, 
+    CURLOPT_SSL_CTX_FUNCTION = 20000 + 108, 
+    CURLOPT_IOCTLFUNCTION = 20000 + 130, 
+    CURLOPT_CONV_FROM_NETWORK_FUNCTION = 20000 + 142, 
+    CURLOPT_CONV_TO_NETWORK_FUNCTION = 20000 + 143, 
+    CURLOPT_CONV_FROM_UTF8_FUNCTION = 20000 + 144, 
+
+    CURLOPT_INFILESIZE_LARGE = 30000 + 115, 
+    CURLOPT_RESUME_FROM_LARGE = 30000 + 116, 
+    CURLOPT_MAXFILESIZE_LARGE = 30000 + 117, 
+    CURLOPT_POSTFIELDSIZE_LARGE = 30000 + 120, 
+    CURLOPT_MAX_SEND_SPEED_LARGE = 30000 + 145, 
+    CURLOPT_MAX_RECV_SPEED_LARGE = 30000 + 146
+
+    
+  TCURL_HTTP_VERSION* = enum 
+    CURL_HTTP_VERSION_NONE, CURL_HTTP_VERSION_1_0, CURL_HTTP_VERSION_1_1, 
+    CURL_HTTP_VERSION_LAST
+    
+  TCURL_NETRC_OPTION* = enum 
+    CURL_NETRC_IGNORED, CURL_NETRC_OPTIONAL, CURL_NETRC_REQUIRED, 
+    CURL_NETRC_LAST
+    
+  TCURL_SSL_VERSION* = enum 
+    CURL_SSLVERSION_DEFAULT, CURL_SSLVERSION_TLSv1, CURL_SSLVERSION_SSLv2, 
+    CURL_SSLVERSION_SSLv3, CURL_SSLVERSION_LAST
+  
+  TCURL_TIMECOND* = enum 
+    CURL_TIMECOND_NONE, CURL_TIMECOND_IFMODSINCE, CURL_TIMECOND_IFUNMODSINCE, 
+    CURL_TIMECOND_LASTMOD, CURL_TIMECOND_LAST
+  
+  TCURLformoption* = enum 
+    CURLFORM_NOTHING, CURLFORM_COPYNAME, CURLFORM_PTRNAME, CURLFORM_NAMELENGTH, 
+    CURLFORM_COPYCONTENTS, CURLFORM_PTRCONTENTS, CURLFORM_CONTENTSLENGTH, 
+    CURLFORM_FILECONTENT, CURLFORM_ARRAY, CURLFORM_OBSOLETE, CURLFORM_FILE, 
+    CURLFORM_BUFFER, CURLFORM_BUFFERPTR, CURLFORM_BUFFERLENGTH, 
+    CURLFORM_CONTENTTYPE, CURLFORM_CONTENTHEADER, CURLFORM_FILENAME, 
+    CURLFORM_END, CURLFORM_OBSOLETE2, CURLFORM_LASTENTRY
+  
+  Tcurl_forms* {.pure, final.} = object 
+    option*: TCURLformoption
+    value*: cstring
+
+  TCURLFORMcode* = enum 
+    CURL_FORMADD_OK, CURL_FORMADD_MEMORY, CURL_FORMADD_OPTION_TWICE, 
+    CURL_FORMADD_NULL, CURL_FORMADD_UNKNOWN_OPTION, CURL_FORMADD_INCOMPLETE, 
+    CURL_FORMADD_ILLEGAL_ARRAY, CURL_FORMADD_DISABLED, CURL_FORMADD_LAST
+
+  Tcurl_formget_callback* = proc (arg: pointer, buf: cstring, 
+                                 length: int): int {.cdecl.}
+  Tcurl_slist* {.pure, final.} = object 
+    data*: cstring
+    next*: Pcurl_slist
+
+  TCURLINFO* = enum 
+    CURLINFO_NONE = 0, 
+    CURLINFO_LASTONE = 30,
+    CURLINFO_EFFECTIVE_URL = 0x00100000 + 1, 
+    CURLINFO_CONTENT_TYPE = 0x00100000 + 18, 
+    CURLINFO_PRIVATE = 0x00100000 + 21, 
+    CURLINFO_FTP_ENTRY_PATH = 0x00100000 + 30,
+
+    CURLINFO_RESPONSE_CODE = 0x00200000 + 2, 
+    CURLINFO_HEADER_SIZE = 0x00200000 + 11, 
+    CURLINFO_REQUEST_SIZE = 0x00200000 + 12, 
+    CURLINFO_SSL_VERIFYRESULT = 0x00200000 + 13, 
+    CURLINFO_FILETIME = 0x00200000 + 14, 
+    CURLINFO_REDIRECT_COUNT = 0x00200000 + 20, 
+    CURLINFO_HTTP_CONNECTCODE = 0x00200000 + 22, 
+    CURLINFO_HTTPAUTH_AVAIL = 0x00200000 + 23, 
+    CURLINFO_PROXYAUTH_AVAIL = 0x00200000 + 24, 
+    CURLINFO_OS_ERRNO = 0x00200000 + 25, 
+    CURLINFO_NUM_CONNECTS = 0x00200000 + 26, 
+    CURLINFO_LASTSOCKET = 0x00200000 + 29, 
+    
+    CURLINFO_TOTAL_TIME = 0x00300000 + 3, 
+    CURLINFO_NAMELOOKUP_TIME = 0x00300000 + 4, 
+    CURLINFO_CONNECT_TIME = 0x00300000 + 5, 
+    CURLINFO_PRETRANSFER_TIME = 0x00300000 + 6, 
+    CURLINFO_SIZE_UPLOAD = 0x00300000 + 7, 
+    CURLINFO_SIZE_DOWNLOAD = 0x00300000 + 8, 
+    CURLINFO_SPEED_DOWNLOAD = 0x00300000 + 9, 
+    CURLINFO_SPEED_UPLOAD = 0x00300000 + 10, 
+    CURLINFO_CONTENT_LENGTH_DOWNLOAD = 0x00300000 + 15, 
+    CURLINFO_CONTENT_LENGTH_UPLOAD = 0x00300000 + 16, 
+    CURLINFO_STARTTRANSFER_TIME = 0x00300000 + 17, 
+    CURLINFO_REDIRECT_TIME = 0x00300000 + 19, 
+
+    CURLINFO_SSL_ENGINES = 0x00400000 + 27, 
+    CURLINFO_COOKIELIST = 0x00400000 + 28
+
+  Tcurl_closepolicy* = enum 
+    CURLCLOSEPOLICY_NONE, CURLCLOSEPOLICY_OLDEST, 
+    CURLCLOSEPOLICY_LEAST_RECENTLY_USED, CURLCLOSEPOLICY_LEAST_TRAFFIC, 
+    CURLCLOSEPOLICY_SLOWEST, CURLCLOSEPOLICY_CALLBACK, CURLCLOSEPOLICY_LAST
+  Tcurl_lock_data* = enum 
+    CURL_LOCK_DATA_NONE = 0, CURL_LOCK_DATA_SHARE, CURL_LOCK_DATA_COOKIE, 
+    CURL_LOCK_DATA_DNS, CURL_LOCK_DATA_SSL_SESSION, CURL_LOCK_DATA_CONNECT, 
+    CURL_LOCK_DATA_LAST
+  Tcurl_lock_access* = enum 
+    CURL_LOCK_ACCESS_NONE = 0, CURL_LOCK_ACCESS_SHARED = 1, 
+    CURL_LOCK_ACCESS_SINGLE = 2, CURL_LOCK_ACCESS_LAST
+  
+  Tcurl_lock_function* = proc (handle: PCURL, data: Tcurl_lock_data, 
+                              locktype: Tcurl_lock_access, 
+                              userptr: pointer) {.cdecl.}
+  Tcurl_unlock_function* = proc (handle: PCURL, data: Tcurl_lock_data, 
+                                userptr: pointer) {.cdecl.}
+  TCURLSH* = pointer
+  TCURLSHcode* = enum 
+    CURLSHE_OK, CURLSHE_BAD_OPTION, CURLSHE_IN_USE, CURLSHE_INVALID, 
+    CURLSHE_NOMEM, CURLSHE_LAST
+  
+  TCURLSHoption* = enum 
+    CURLSHOPT_NONE, CURLSHOPT_SHARE, CURLSHOPT_UNSHARE, CURLSHOPT_LOCKFUNC, 
+    CURLSHOPT_UNLOCKFUNC, CURLSHOPT_USERDATA, CURLSHOPT_LAST
+  
+  TCURLversion* = enum 
+    CURLVERSION_FIRST, CURLVERSION_SECOND, CURLVERSION_THIRD, CURLVERSION_LAST
+  
+  Tcurl_version_info_data* {.pure, final.} = object 
+    age*: TCURLversion
+    version*: cstring
+    version_num*: int32
+    host*: cstring
+    features*: int32
+    ssl_version*: cstring
+    ssl_version_num*: int32
+    libz_version*: cstring
+    protocols*: cstringArray
+    ares*: cstring
+    ares_num*: int32
+    libidn*: cstring
+    iconv_ver_num*: int32
+
+  TCURLM* = pointer
+  Tcurl_socket* = int32
+  TCURLMcode* = enum 
+    CURLM_CALL_MULTI_PERFORM = -1, 
+    CURLM_OK = 0, 
+    CURLM_BAD_HANDLE, 
+    CURLM_BAD_EASY_HANDLE, 
+    CURLM_OUT_OF_MEMORY, 
+    CURLM_INTERNAL_ERROR, 
+    CURLM_BAD_SOCKET, 
+    CURLM_UNKNOWN_OPTION, 
+    CURLM_LAST
+    
+  TCURLMSGEnum* = enum 
+    CURLMSG_NONE, CURLMSG_DONE, CURLMSG_LAST
+  TCURLMsg* {.pure, final.} = object 
+    msg*: TCURLMSGEnum
+    easy_handle*: PCURL
+    whatever*: Pointer        #data : record
+                              #      case longint of
+                              #        0 : ( whatever : pointer );
+                              #        1 : ( result : CURLcode );
+                              #    end;
+  
+  Tcurl_socket_callback* = proc (easy: PCURL, s: Tcurl_socket, what: int32, 
+                                 userp, socketp: pointer): int32 {.cdecl.}
+  TCURLMoption* = enum 
+    CURLMOPT_SOCKETDATA = 10000 + 2, 
+    CURLMOPT_LASTENTRY = 10000 + 3,
+    CURLMOPT_SOCKETFUNCTION = 20000 + 1
+    
+const 
+  CURLOPT_SSLKEYPASSWD* = CURLOPT_SSLCERTPASSWD
+
+  CURLAUTH_ANY* = not (0)
+  CURLAUTH_BASIC* = 1 shl 0
+  CURLAUTH_ANYSAFE* = not (CURLAUTH_BASIC)
+  CURLAUTH_DIGEST* = 1 shl 1
+  CURLAUTH_GSSNEGOTIATE* = 1 shl 2
+  CURLAUTH_NONE* = 0
+  CURLAUTH_NTLM* = 1 shl 3
+  CURLE_ALREADY_COMPLETE* = 99999
+  CURLE_FTP_BAD_DOWNLOAD_RESUME* = CURLE_BAD_DOWNLOAD_RESUME
+  CURLE_FTP_PARTIAL_FILE* = CURLE_PARTIAL_FILE
+  CURLE_HTTP_NOT_FOUND* = CURLE_HTTP_RETURNED_ERROR
+  CURLE_HTTP_PORT_FAILED* = CURLE_INTERFACE_FAILED
+  CURLE_OPERATION_TIMEDOUT* = CURLE_OPERATION_TIMEOUTED
+  CURL_ERROR_SIZE* = 256
+  CURL_FORMAT_OFF_T* = "%ld"
+  CURL_GLOBAL_NOTHING* = 0
+  CURL_GLOBAL_SSL* = 1 shl 0
+  CURL_GLOBAL_WIN32* = 1 shl 1
+  CURL_GLOBAL_ALL* = CURL_GLOBAL_SSL or CURL_GLOBAL_WIN32
+  CURL_GLOBAL_DEFAULT* = CURL_GLOBAL_ALL
+  CURLINFO_DOUBLE* = 0x00300000
+  CURLINFO_HTTP_CODE* = CURLINFO_RESPONSE_CODE
+  CURLINFO_LONG* = 0x00200000
+  CURLINFO_MASK* = 0x000FFFFF
+  CURLINFO_SLIST* = 0x00400000
+  CURLINFO_STRING* = 0x00100000
+  CURLINFO_TYPEMASK* = 0x00F00000
+  CURL_IPRESOLVE_V4* = 1
+  CURL_IPRESOLVE_V6* = 2
+  CURL_IPRESOLVE_WHATEVER* = 0
+  CURL_MAX_WRITE_SIZE* = 16384
+  CURLM_CALL_MULTI_SOCKET* = CURLM_CALL_MULTI_PERFORM
+  CURLOPT_CLOSEFUNCTION* = - (5)
+  CURLOPT_FTPASCII* = CURLOPT_TRANSFERTEXT
+  CURLOPT_HEADERDATA* = CURLOPT_WRITEHEADER
+  CURLOPT_HTTPREQUEST* = - (1)
+  CURLOPT_MUTE* = - (2)
+  CURLOPT_PASSWDDATA* = - (4)
+  CURLOPT_PASSWDFUNCTION* = - (3)
+  CURLOPT_PASV_HOST* = - (9)
+  CURLOPT_READDATA* = CURLOPT_INFILE
+  CURLOPT_SOURCE_HOST* = - (6)
+  CURLOPT_SOURCE_PATH* = - (7)
+  CURLOPT_SOURCE_PORT* = - (8)
+  CURLOPTTYPE_FUNCTIONPOINT* = 20000
+  CURLOPTTYPE_LONG* = 0
+  CURLOPTTYPE_OBJECTPOINT* = 10000
+  CURLOPTTYPE_OFF_T* = 30000
+  CURLOPT_WRITEDATA* = CURLOPT_FILE
+  CURL_POLL_IN* = 1
+  CURL_POLL_INOUT* = 3
+  CURL_POLL_NONE* = 0
+  CURL_POLL_OUT* = 2
+  CURL_POLL_REMOVE* = 4
+  CURL_READFUNC_ABORT* = 0x10000000
+  CURL_SOCKET_BAD* = - (1)
+  CURL_SOCKET_TIMEOUT* = CURL_SOCKET_BAD
+  CURL_VERSION_ASYNCHDNS* = 1 shl 7
+  CURL_VERSION_CONV* = 1 shl 12
+  CURL_VERSION_DEBUG* = 1 shl 6
+  CURL_VERSION_GSSNEGOTIATE* = 1 shl 5
+  CURL_VERSION_IDN* = 1 shl 10
+  CURL_VERSION_IPV6* = 1 shl 0
+  CURL_VERSION_KERBEROS4* = 1 shl 1
+  CURL_VERSION_LARGEFILE* = 1 shl 9
+  CURL_VERSION_LIBZ* = 1 shl 3
+  CURLVERSION_NOW* = CURLVERSION_THIRD
+  CURL_VERSION_NTLM* = 1 shl 4
+  CURL_VERSION_SPNEGO* = 1 shl 8
+  CURL_VERSION_SSL* = 1 shl 2
+  CURL_VERSION_SSPI* = 1 shl 11
+  FILE_OFFSET_BITS* = 0
+  FILESIZEBITS* = 0
+  FUNCTIONPOINT* = CURLOPTTYPE_FUNCTIONPOINT
+  HTTPPOST_BUFFER* = 1 shl 4
+  HTTPPOST_FILENAME* = 1 shl 0
+  HTTPPOST_PTRBUFFER* = 1 shl 5
+  HTTPPOST_PTRCONTENTS* = 1 shl 3
+  HTTPPOST_PTRNAME* = 1 shl 2
+  HTTPPOST_READFILE* = 1 shl 1
+  LIBCURL_VERSION* = "7.15.5"
+  LIBCURL_VERSION_MAJOR* = 7
+  LIBCURL_VERSION_MINOR* = 15
+  LIBCURL_VERSION_NUM* = 0x00070F05
+  LIBCURL_VERSION_PATCH* = 5
+
+proc curl_strequal*(s1, s2: cstring): int32{.cdecl, 
+    dynlib: libname, importc: "curl_strequal".}
+proc curl_strnequal*(s1, s2: cstring, n: int): int32 {.cdecl, 
+    dynlib: libname, importc: "curl_strnequal".}
+proc curl_formadd*(httppost, last_post: PPcurl_httppost): TCURLFORMcode {.
+    cdecl, varargs, dynlib: libname, importc: "curl_formadd".}
+
+proc curl_formget*(form: Pcurl_httppost, arg: pointer, 
+                   append: Tcurl_formget_callback): int32 {.cdecl, 
+    dynlib: libname, importc: "curl_formget".}
+proc curl_formfree*(form: Pcurl_httppost){.cdecl, dynlib: libname, 
+    importc: "curl_formfree".}
+proc curl_getenv*(variable: cstring): cstring{.cdecl, dynlib: libname, 
+    importc: "curl_getenv".}
+proc curl_version*(): cstring{.cdecl, dynlib: libname, importc: "curl_version".}
+proc curl_easy_escape*(handle: PCURL, str: cstring, len: int32): cstring{.cdecl, 
+    dynlib: libname, importc: "curl_easy_escape".}
+proc curl_escape*(str: cstring, len: int32): cstring{.cdecl, 
+    dynlib: libname, importc: "curl_escape".}
+proc curl_easy_unescape*(handle: PCURL, str: cstring, len: int32, 
+                         outlength: var int32): cstring{.cdecl, 
+    dynlib: libname, importc: "curl_easy_unescape".}
+proc curl_unescape*(str: cstring, len: int32): cstring{.cdecl, 
+    dynlib: libname, importc: "curl_unescape".}
+proc curl_free*(p: pointer){.cdecl, dynlib: libname, 
+                             importc: "curl_free".}
+proc curl_global_init*(flags: int32): TCURLcode {.cdecl, dynlib: libname, 
+    importc: "curl_global_init".}
+proc curl_global_init_mem*(flags: int32, m: Tcurl_malloc_callback, 
+                           f: Tcurl_free_callback, r: Tcurl_realloc_callback, 
+                           s: Tcurl_strdup_callback, 
+                           c: Tcurl_calloc_callback): TCURLcode {.
+    cdecl, dynlib: libname, importc: "curl_global_init_mem".}
+proc curl_global_cleanup*() {.cdecl, dynlib: libname, 
+                              importc: "curl_global_cleanup".}
+proc curl_slist_append*(curl_slist: Pcurl_slist, P: cstring): Pcurl_slist {.
+    cdecl, dynlib: libname, importc: "curl_slist_append".}
+proc curl_slist_free_all*(para1: Pcurl_slist) {.cdecl, dynlib: libname, 
+    importc: "curl_slist_free_all".}
+proc curl_getdate*(p: cstring, unused: ptr TTime): TTime {.cdecl, 
+    dynlib: libname, importc: "curl_getdate".}
+proc curl_share_init*(): PCURLSH{.cdecl, dynlib: libname, 
+                                  importc: "curl_share_init".}
+proc curl_share_setopt*(para1: PCURLSH, option: TCURLSHoption): TCURLSHcode {.
+    cdecl, varargs, dynlib: libname, importc: "curl_share_setopt".}
+
+proc curl_share_cleanup*(para1: PCURLSH): TCURLSHcode {.cdecl, 
+    dynlib: libname, importc: "curl_share_cleanup".}
+proc curl_version_info*(para1: TCURLversion): Pcurl_version_info_data{.cdecl, 
+    dynlib: libname, importc: "curl_version_info".}
+proc curl_easy_strerror*(para1: TCURLcode): cstring {.cdecl, 
+    dynlib: libname, importc: "curl_easy_strerror".}
+proc curl_share_strerror*(para1: TCURLSHcode): cstring {.cdecl, 
+    dynlib: libname, importc: "curl_share_strerror".}
+proc curl_easy_init*(): PCURL {.cdecl, dynlib: libname, 
+                               importc: "curl_easy_init".}
+proc curl_easy_setopt*(curl: PCURL, option: TCURLoption): TCURLcode {.cdecl, 
+    varargs, dynlib: libname, importc: "curl_easy_setopt".}
+
+proc curl_easy_perform*(curl: PCURL): TCURLcode {.cdecl, dynlib: libname, 
+    importc: "curl_easy_perform".}
+proc curl_easy_cleanup*(curl: PCURL) {.cdecl, dynlib: libname, 
+                                       importc: "curl_easy_cleanup".}
+proc curl_easy_getinfo*(curl: PCURL, info: TCURLINFO): TCURLcode {.
+    cdecl, varargs, dynlib: libname, importc: "curl_easy_getinfo".}
+
+proc curl_easy_duphandle*(curl: PCURL): PCURL {.cdecl, dynlib: libname, 
+    importc: "curl_easy_duphandle".}
+proc curl_easy_reset*(curl: PCURL) {.cdecl, dynlib: libname, 
+                                     importc: "curl_easy_reset".}
+proc curl_multi_init*(): PCURLM {.cdecl, dynlib: libname, 
+                                  importc: "curl_multi_init".}
+proc curl_multi_add_handle*(multi_handle: PCURLM, 
+                            curl_handle: PCURL): TCURLMcode {.
+    cdecl, dynlib: libname, importc: "curl_multi_add_handle".}
+proc curl_multi_remove_handle*(multi_handle: PCURLM, 
+                               curl_handle: PCURL): TCURLMcode {.
+    cdecl, dynlib: libname, importc: "curl_multi_remove_handle".}
+proc curl_multi_fdset*(multi_handle: PCURLM, read_fd_set: Pfd_set, 
+                       write_fd_set: Pfd_set, exc_fd_set: Pfd_set, 
+                       max_fd: var int32): TCURLMcode {.cdecl, 
+    dynlib: libname, importc: "curl_multi_fdset".}
+proc curl_multi_perform*(multi_handle: PCURLM, 
+                         running_handles: var int32): TCURLMcode {.
+    cdecl, dynlib: libname, importc: "curl_multi_perform".}
+proc curl_multi_cleanup*(multi_handle: PCURLM): TCURLMcode {.cdecl, 
+    dynlib: libname, importc: "curl_multi_cleanup".}
+proc curl_multi_info_read*(multi_handle: PCURLM, 
+                           msgs_in_queue: var int32): PCURLMsg {.
+    cdecl, dynlib: libname, importc: "curl_multi_info_read".}
+proc curl_multi_strerror*(para1: TCURLMcode): cstring {.cdecl, 
+    dynlib: libname, importc: "curl_multi_strerror".}
+proc curl_multi_socket*(multi_handle: PCURLM, s: Tcurl_socket, 
+                        running_handles: var int32): TCURLMcode {.cdecl, 
+    dynlib: libname, importc: "curl_multi_socket".}
+proc curl_multi_socket_all*(multi_handle: PCURLM, 
+                            running_handles: var int32): TCURLMcode {.
+    cdecl, dynlib: libname, importc: "curl_multi_socket_all".}
+proc curl_multi_timeout*(multi_handle: PCURLM, milliseconds: var int32): TCURLMcode{.
+    cdecl, dynlib: libname, importc: "curl_multi_timeout".}
+proc curl_multi_setopt*(multi_handle: PCURLM, option: TCURLMoption): TCURLMcode{.
+    cdecl, varargs, dynlib: libname, importc: "curl_multi_setopt".}
+
+proc curl_multi_assign*(multi_handle: PCURLM, sockfd: Tcurl_socket, 
+                        sockp: pointer): TCURLMcode {.cdecl, 
+    dynlib: libname, importc: "curl_multi_assign".}
+
+
diff --git a/lib/base/mysql.nim b/lib/base/mysql.nim
new file mode 100644
index 000000000..60c6bd80c
--- /dev/null
+++ b/lib/base/mysql.nim
@@ -0,0 +1,1155 @@
+#
+#
+#            Nimrod's Runtime Library
+#        (c) Copyright 2009 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+{.deadCodeElim: on.}
+
+when defined(Unix): 
+  const 
+    mysqllib = "libmysqlclient.so.15"
+
+# mysqllib = "libmysqlclient.so.15"
+when defined(Windows): 
+  const
+    mysqllib = "libmysql.dll"
+    
+# Copyright (C) 2000-2003 MySQL AB
+#  
+#     This program is free software; you can redistribute it and/or modify
+#     it under the terms of the GNU General Public License as published by
+#     the Free Software Foundation; either version 2 of the License, or
+#     (at your option) any later version.
+#  
+#     This program is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#     GNU General Public License for more details.
+#  
+#     You should have received a copy of the GNU General Public License
+#     along with this program; if not, write to the Free Software
+#     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  
+
+type 
+  my_bool* = bool
+  Pmy_bool* = ptr my_bool
+  PVIO* = Pointer
+  Pgptr* = ptr gptr
+  gptr* = cstring
+  Pmy_socket* = ptr my_socket
+  my_socket* = cint
+  PPByte* = pointer 
+  cuint* = cint
+  
+#  ------------ Start of declaration in "mysql_com.h"   ---------------------  
+#
+#  ** Common definition between mysql server & client
+#   
+# Field/table name length
+
+const 
+  NAME_LEN* = 64
+  HOSTNAME_LENGTH* = 60
+  USERNAME_LENGTH* = 16
+  SERVER_VERSION_LENGTH* = 60
+  SQLSTATE_LENGTH* = 5
+  LOCAL_HOST* = "localhost"
+  LOCAL_HOST_NAMEDPIPE* = '.'
+
+const 
+  MYSQL_NAMEDPIPE* = "MySQL"
+  MYSQL_SERVICENAME* = "MySQL"
+
+type 
+  enum_server_command* = enum     
+    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_CONNECT, COM_PROCESS_KILL, COM_DEBUG, COM_PING, COM_TIME, 
+    COM_DELAYED_INSERT, COM_CHANGE_USER, COM_BINLOG_DUMP, COM_TABLE_DUMP, 
+    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_FETCH, COM_END
+
+const 
+  SCRAMBLE_LENGTH* = 20 # Length of random string sent by server on handshake; 
+                        # this is also length of obfuscated password, 
+                        # recieved from client
+  SCRAMBLE_LENGTH_323* = 8 # length of password stored in the db: 
+                           # new passwords are preceeded with '*'  
+  SCRAMBLED_PASSWORD_CHAR_LENGTH* = SCRAMBLE_LENGTH * 2 + 1
+  SCRAMBLED_PASSWORD_CHAR_LENGTH_323* = SCRAMBLE_LENGTH_323 * 2
+  NOT_NULL_FLAG* = 1          #  Field can't be NULL
+  PRI_KEY_FLAG* = 2           #  Field is part of a primary key
+  UNIQUE_KEY_FLAG* = 4        #  Field is part of a unique key
+  MULTIPLE_KEY_FLAG* = 8      #  Field is part of a key
+  BLOB_FLAG* = 16             #  Field is a blob
+  UNSIGNED_FLAG* = 32         #  Field is unsigned
+  ZEROFILL_FLAG* = 64         #  Field is zerofill
+  BINARY_FLAG* = 128          #  Field is binary
+                              # The following are only sent to new clients  
+  ENUM_FLAG* = 256            # field is an enum
+  AUTO_INCREMENT_FLAG* = 512  # field is a autoincrement field
+  TIMESTAMP_FLAG* = 1024      # Field is a timestamp
+  SET_FLAG* = 2048            # field is a set
+  NO_DEFAULT_VALUE_FLAG* = 4096 # Field doesn't have default value
+  NUM_FLAG* = 32768           # Field is num (for clients)
+  PART_KEY_FLAG* = 16384      # Intern; Part of some key
+  GROUP_FLAG* = 32768         # Intern: Group field
+  UNIQUE_FLAG* = 65536        # Intern: Used by sql_yacc
+  BINCMP_FLAG* = 131072       # Intern: Used by sql_yacc
+  REFRESH_GRANT* = 1          # Refresh grant tables
+  REFRESH_LOG* = 2            # Start on new log file
+  REFRESH_TABLES* = 4         # close all tables
+  REFRESH_HOSTS* = 8          # Flush host cache
+  REFRESH_STATUS* = 16        # Flush status variables
+  REFRESH_THREADS* = 32       # Flush thread cache
+  REFRESH_SLAVE* = 64         # Reset master info and restart slave thread
+  REFRESH_MASTER* = 128 # Remove all bin logs in the index and truncate the index
+                        # The following can't be set with mysql_refresh()  
+  REFRESH_READ_LOCK* = 16384  # Lock tables for read
+  REFRESH_FAST* = 32768       # Intern flag
+  REFRESH_QUERY_CACHE* = 65536 # RESET (remove all queries) from query cache
+  REFRESH_QUERY_CACHE_FREE* = 0x00020000 # pack query cache
+  REFRESH_DES_KEY_FILE* = 0x00040000
+  REFRESH_USER_RESOURCES* = 0x00080000
+  CLIENT_LONG_PASSWORD* = 1   # new more secure passwords
+  CLIENT_FOUND_ROWS* = 2      # Found instead of affected rows
+  CLIENT_LONG_FLAG* = 4       # Get all column flags
+  CLIENT_CONNECT_WITH_DB* = 8 # One can specify db on connect
+  CLIENT_NO_SCHEMA* = 16      # Don't allow database.table.column
+  CLIENT_COMPRESS* = 32       # Can use compression protocol
+  CLIENT_ODBC* = 64           # Odbc client
+  CLIENT_LOCAL_FILES* = 128   # Can use LOAD DATA LOCAL
+  CLIENT_IGNORE_SPACE* = 256  # Ignore spaces before '('
+  CLIENT_PROTOCOL_41* = 512   # New 4.1 protocol
+  CLIENT_INTERACTIVE* = 1024  # This is an interactive client
+  CLIENT_SSL* = 2048          # Switch to SSL after handshake
+  CLIENT_IGNORE_SIGPIPE* = 4096 # IGNORE sigpipes
+  CLIENT_TRANSACTIONS* = 8192 # Client knows about transactions
+  CLIENT_RESERVED* = 16384    # Old flag for 4.1 protocol
+  CLIENT_SECURE_CONNECTION* = 32768 # New 4.1 authentication
+  CLIENT_MULTI_STATEMENTS* = 65536 # Enable/disable multi-stmt support
+  CLIENT_MULTI_RESULTS* = 131072 # Enable/disable multi-results
+  CLIENT_REMEMBER_OPTIONS*: int = 1 shl 31
+  SERVER_STATUS_IN_TRANS* = 1 # Transaction has started
+  SERVER_STATUS_AUTOCOMMIT* = 2 # Server in auto_commit mode
+  SERVER_STATUS_MORE_RESULTS* = 4 # More results on server
+  SERVER_MORE_RESULTS_EXISTS* = 8 # Multi query - next query exists
+  SERVER_QUERY_NO_GOOD_INDEX_USED* = 16
+  SERVER_QUERY_NO_INDEX_USED* = 32 # The server was able to fulfill the clients request and opened a
+                                   #      read-only non-scrollable cursor for a query. This flag comes
+                                   #      in reply to COM_STMT_EXECUTE and COM_STMT_FETCH commands. 
+  SERVER_STATUS_CURSOR_EXISTS* = 64 # This flag is sent when a read-only cursor is exhausted, in reply to
+                                    #      COM_STMT_FETCH command. 
+  SERVER_STATUS_LAST_ROW_SENT* = 128
+  SERVER_STATUS_DB_DROPPED* = 256 # A database was dropped
+  SERVER_STATUS_NO_BACKSLASH_ESCAPES* = 512
+  MYSQL_ERRMSG_SIZE* = 200
+  NET_READ_TIMEOUT* = 30      # Timeout on read
+  NET_WRITE_TIMEOUT* = 60     # Timeout on write
+  NET_WAIT_TIMEOUT* = 8 * 60 * 60 # Wait for new query
+  ONLY_KILL_QUERY* = 1
+
+const 
+  MAX_TINYINT_WIDTH* = 3      # Max width for a TINY w.o. sign
+  MAX_SMALLINT_WIDTH* = 5     # Max width for a SHORT w.o. sign
+  MAX_MEDIUMINT_WIDTH* = 8    # Max width for a INT24 w.o. sign
+  MAX_INT_WIDTH* = 10         # Max width for a LONG w.o. sign
+  MAX_BIGINT_WIDTH* = 20      # Max width for a LONGLONG
+  MAX_CHAR_WIDTH* = 255       # Max length for a CHAR colum
+  MAX_BLOB_WIDTH* = 8192      # Default width for blob
+
+type 
+  Pst_net* = ptr st_net
+  st_net*{.final.} = object
+    vio*: PVio
+    buff*: cstring
+    buff_end*: cstring
+    write_pos*: cstring
+    read_pos*: cstring
+    fd*: my_socket            # For Perl DBI/dbd
+    max_packet*: int
+    max_packet_size*: int
+    pkt_nr*: cuint
+    compress_pkt_nr*: cuint
+    write_timeout*: cuint
+    read_timeout*: cuint
+    retry_count*: cuint
+    fcntl*: cint
+    compress*: my_bool #   The following variable is set if we are doing several queries in one
+                       #        command ( as in LOAD TABLE ... FROM MASTER ),
+                       #        and do not want to confuse the client with OK at the wrong time 
+    remain_in_buf*: int
+    len*: int
+    buf_length*: int
+    where_b*: int
+    return_status*: ptr cint
+    reading_or_writing*: char
+    save_char*: cchar
+    no_send_ok*: my_bool      # For SPs and other things that do multiple stmts
+    no_send_eof*: my_bool     # For SPs' first version read-only cursors
+    no_send_error*: my_bool # Set if OK packet is already sent, and
+                            # we do not need to send error messages
+                            #   Pointer to query object in query cache, do not equal NULL (0) for
+                            #        queries in cache that have not stored its results yet 
+                            # $endif
+    last_error*: array[0..(MYSQL_ERRMSG_SIZE) - 1, char]
+    sqlstate*: array[0..(SQLSTATE_LENGTH + 1) - 1, char]
+    last_errno*: cuint
+    error*: char
+    query_cache_query*: gptr
+    report_error*: my_bool    # We should report error (we have unreported error)
+    return_errno*: my_bool
+
+  NET* = st_net
+  PNET* = ptr NET
+
+const 
+  packet_error* = -1
+
+type 
+  enum_field_types* = enum    # For backward compatibility  
+    MYSQL_TYPE_DECIMAL, MYSQL_TYPE_TINY, MYSQL_TYPE_SHORT, MYSQL_TYPE_LONG, 
+    MYSQL_TYPE_FLOAT, MYSQL_TYPE_DOUBLE, MYSQL_TYPE_NULL, MYSQL_TYPE_TIMESTAMP, 
+    MYSQL_TYPE_LONGLONG, MYSQL_TYPE_INT24, MYSQL_TYPE_DATE, MYSQL_TYPE_TIME, 
+    MYSQL_TYPE_DATETIME, MYSQL_TYPE_YEAR, MYSQL_TYPE_NEWDATE, 
+    MYSQL_TYPE_VARCHAR, MYSQL_TYPE_BIT, MYSQL_TYPE_NEWDECIMAL = 246, 
+    MYSQL_TYPE_ENUM = 247, MYSQL_TYPE_SET = 248, MYSQL_TYPE_TINY_BLOB = 249, 
+    MYSQL_TYPE_MEDIUM_BLOB = 250, MYSQL_TYPE_LONG_BLOB = 251, 
+    MYSQL_TYPE_BLOB = 252, MYSQL_TYPE_VAR_STRING = 253, MYSQL_TYPE_STRING = 254, 
+    MYSQL_TYPE_GEOMETRY = 255
+
+const 
+  CLIENT_MULTI_QUERIES* = CLIENT_MULTI_STATEMENTS
+  FIELD_TYPE_DECIMAL* = MYSQL_TYPE_DECIMAL
+  FIELD_TYPE_NEWDECIMAL* = MYSQL_TYPE_NEWDECIMAL
+  FIELD_TYPE_TINY* = MYSQL_TYPE_TINY
+  FIELD_TYPE_SHORT* = MYSQL_TYPE_SHORT
+  FIELD_TYPE_LONG* = MYSQL_TYPE_LONG
+  FIELD_TYPE_FLOAT* = MYSQL_TYPE_FLOAT
+  FIELD_TYPE_DOUBLE* = MYSQL_TYPE_DOUBLE
+  FIELD_TYPE_NULL* = MYSQL_TYPE_NULL
+  FIELD_TYPE_TIMESTAMP* = MYSQL_TYPE_TIMESTAMP
+  FIELD_TYPE_LONGLONG* = MYSQL_TYPE_LONGLONG
+  FIELD_TYPE_INT24* = MYSQL_TYPE_INT24
+  FIELD_TYPE_DATE* = MYSQL_TYPE_DATE
+  FIELD_TYPE_TIME* = MYSQL_TYPE_TIME
+  FIELD_TYPE_DATETIME* = MYSQL_TYPE_DATETIME
+  FIELD_TYPE_YEAR* = MYSQL_TYPE_YEAR
+  FIELD_TYPE_NEWDATE* = MYSQL_TYPE_NEWDATE
+  FIELD_TYPE_ENUM* = MYSQL_TYPE_ENUM
+  FIELD_TYPE_SET* = MYSQL_TYPE_SET
+  FIELD_TYPE_TINY_BLOB* = MYSQL_TYPE_TINY_BLOB
+  FIELD_TYPE_MEDIUM_BLOB* = MYSQL_TYPE_MEDIUM_BLOB
+  FIELD_TYPE_LONG_BLOB* = MYSQL_TYPE_LONG_BLOB
+  FIELD_TYPE_BLOB* = MYSQL_TYPE_BLOB
+  FIELD_TYPE_VAR_STRING* = MYSQL_TYPE_VAR_STRING
+  FIELD_TYPE_STRING* = MYSQL_TYPE_STRING
+  FIELD_TYPE_CHAR* = MYSQL_TYPE_TINY
+  FIELD_TYPE_INTERVAL* = MYSQL_TYPE_ENUM
+  FIELD_TYPE_GEOMETRY* = MYSQL_TYPE_GEOMETRY
+  FIELD_TYPE_BIT* = MYSQL_TYPE_BIT # Shutdown/kill enums and constants  
+                                   # Bits for THD::killable.  
+  MYSQL_SHUTDOWN_KILLABLE_CONNECT* = chr(1 shl 0)
+  MYSQL_SHUTDOWN_KILLABLE_TRANS* = chr(1 shl 1)
+  MYSQL_SHUTDOWN_KILLABLE_LOCK_TABLE* = chr(1 shl 2)
+  MYSQL_SHUTDOWN_KILLABLE_UPDATE* = chr(1 shl 3)
+  
+type 
+  mysql_enum_shutdown_level* = enum 
+    SHUTDOWN_DEFAULT = 0, SHUTDOWN_WAIT_CONNECTIONS = 1,  
+    SHUTDOWN_WAIT_TRANSACTIONS = 2,  
+    SHUTDOWN_WAIT_UPDATES = 8,  
+    SHUTDOWN_WAIT_ALL_BUFFERS = 16, 
+    SHUTDOWN_WAIT_CRITICAL_BUFFERS = 17,  
+    KILL_QUERY = 254,        
+    KILL_CONNECTION = 255
+  enum_cursor_type* = enum    # options for mysql_set_option  
+    CURSOR_TYPE_NO_CURSOR = 0, CURSOR_TYPE_READ_ONLY = 1, 
+    CURSOR_TYPE_FOR_UPDATE = 2, CURSOR_TYPE_SCROLLABLE = 4
+  enum_mysql_set_option* = enum 
+    MYSQL_OPTION_MULTI_STATEMENTS_ON, MYSQL_OPTION_MULTI_STATEMENTS_OFF
+
+proc net_new_transaction*(net: st_net): st_net
+proc my_net_init*(net: PNET, vio: PVio): my_bool{.cdecl, dynlib: mysqllib, 
+    importc: "my_net_init".}
+proc my_net_local_init*(net: PNET){.cdecl, dynlib: mysqllib, 
+                                    importc: "my_net_local_init".}
+proc net_end*(net: PNET){.cdecl, dynlib: mysqllib, importc: "net_end".}
+proc net_clear*(net: PNET){.cdecl, dynlib: mysqllib, importc: "net_clear".}
+proc net_realloc*(net: PNET, len: int): my_bool{.cdecl, dynlib: mysqllib, 
+    importc: "net_realloc".}
+proc net_flush*(net: PNET): my_bool{.cdecl, dynlib: mysqllib, 
+                                     importc: "net_flush".}
+proc my_net_write*(net: PNET, packet: cstring, length: int): my_bool{.cdecl, 
+    dynlib: mysqllib, importc: "my_net_write".}
+proc net_write_command*(net: PNET, command: char, header: cstring, 
+                        head_len: int, packet: cstring, length: int): my_bool{.
+    cdecl, dynlib: mysqllib, importc: "net_write_command".}
+proc net_real_write*(net: PNET, packet: cstring, length: int): cint{.cdecl, 
+    dynlib: mysqllib, importc: "net_real_write".}
+proc my_net_read*(net: PNET): int{.cdecl, dynlib: mysqllib, 
+                                      importc: "my_net_read".}
+  # The following function is not meant for normal usage
+  #      Currently it's used internally by manager.c  
+type 
+  Psockaddr* = ptr sockaddr
+  sockaddr*{.final.} = object  # undefined structure
+
+proc my_connect*(s: my_socket, name: Psockaddr, namelen: cuint, timeout: cuint): cint{.
+    cdecl, dynlib: mysqllib, importc: "my_connect".}
+type 
+  Prand_struct* = ptr rand_struct
+  rand_struct*{.final.} = object  # The following is for user defined functions  
+    seed1*: int
+    seed2*: int
+    max_value*: int
+    max_value_dbl*: cdouble
+
+  Item_result* = enum 
+    STRING_RESULT, REAL_RESULT, INT_RESULT, ROW_RESULT, DECIMAL_RESULT
+  PItem_result* = ptr Item_result
+  Pst_udf_args* = ptr st_udf_args
+  st_udf_args*{.final.} = object 
+    arg_count*: cuint         # Number of arguments
+    arg_type*: PItem_result   # Pointer to item_results
+    args*: cstringArray             # Pointer to item_results
+    lengths*: ptr int         # Length of string arguments
+    maybe_null*: cstring      # Length of string arguments
+    attributes*: cstringArray       # Pointer to attribute name
+    attribute_lengths*: ptr int # Length of attribute arguments
+  
+  UDF_ARGS* = st_udf_args
+  PUDF_ARGS* = ptr UDF_ARGS   # This holds information about the result  
+  Pst_udf_init* = ptr st_udf_init
+  st_udf_init*{.final.} = object 
+    maybe_null*: my_bool      # 1 if function can return NULL
+    decimals*: cuint          # for real functions
+    max_length*: int          # For string functions
+    theptr*: cstring          # free pointer for function data
+    const_item*: my_bool      # free pointer for function data
+  
+  UDF_INIT* = st_udf_init
+  PUDF_INIT* = ptr UDF_INIT   # Constants when using compression  
+
+const 
+  NET_HEADER_SIZE* = 4        # standard header size
+  COMP_HEADER_SIZE* = 3 # compression header extra size
+                        # Prototypes to password functions  
+                        # These functions are used for authentication by client and server and
+                        #      implemented in sql/password.c     
+
+proc randominit*(para1: Prand_struct, seed1: int, seed2: int){.cdecl, 
+    dynlib: mysqllib, importc: "randominit".}
+proc my_rnd*(para1: Prand_struct): cdouble{.cdecl, dynlib: mysqllib, 
+    importc: "my_rnd".}
+proc create_random_string*(fto: cstring, len: cuint, rand_st: Prand_struct){.
+    cdecl, dynlib: mysqllib, importc: "create_random_string".}
+proc hash_password*(fto: int, password: cstring, password_len: cuint){.cdecl, 
+    dynlib: mysqllib, importc: "hash_password".}
+proc make_scrambled_password_323*(fto: cstring, password: cstring){.cdecl, 
+    dynlib: mysqllib, importc: "make_scrambled_password_323".}
+proc scramble_323*(fto: cstring, message: cstring, password: cstring){.cdecl, 
+    dynlib: mysqllib, importc: "scramble_323".}
+proc check_scramble_323*(para1: cstring, message: cstring, salt: int): my_bool{.
+    cdecl, dynlib: mysqllib, importc: "check_scramble_323".}
+proc get_salt_from_password_323*(res: ptr int, password: cstring){.cdecl, 
+    dynlib: mysqllib, importc: "get_salt_from_password_323".}
+proc make_password_from_salt_323*(fto: cstring, salt: ptr int){.cdecl, 
+    dynlib: mysqllib, importc: "make_password_from_salt_323".}
+proc octet2hex*(fto: cstring, str: cstring, length: cuint): cstring{.cdecl, 
+    dynlib: mysqllib, importc: "octet2hex".}
+proc make_scrambled_password*(fto: cstring, password: cstring){.cdecl, 
+    dynlib: mysqllib, importc: "make_scrambled_password".}
+proc scramble*(fto: cstring, message: cstring, password: cstring){.cdecl, 
+    dynlib: mysqllib, importc: "scramble".}
+proc check_scramble*(reply: cstring, message: cstring, hash_stage2: pointer): my_bool{.
+    cdecl, dynlib: mysqllib, importc: "check_scramble".}
+proc get_salt_from_password*(res: pointer, password: cstring){.cdecl, 
+    dynlib: mysqllib, importc: "get_salt_from_password".}
+proc make_password_from_salt*(fto: cstring, hash_stage2: pointer){.cdecl, 
+    dynlib: mysqllib, importc: "make_password_from_salt".}
+  # end of password.c  
+proc get_tty_password*(opt_message: cstring): cstring{.cdecl, dynlib: mysqllib, 
+    importc: "get_tty_password".}
+proc mysql_errno_to_sqlstate*(mysql_errno: cuint): cstring{.cdecl, 
+    dynlib: mysqllib, importc: "mysql_errno_to_sqlstate".}
+  # Some other useful functions  
+proc modify_defaults_file*(file_location: cstring, option: cstring, 
+                           option_value: cstring, section_name: cstring, 
+                           remove_option: cint): cint{.cdecl, dynlib: mysqllib, 
+    importc: "load_defaults".}
+proc load_defaults*(conf_file: cstring, groups: cstringArray, argc: ptr cint, 
+                    argv: ptr cstringArray): cint{.cdecl, dynlib: mysqllib, 
+    importc: "load_defaults".}
+proc my_init*(): my_bool{.cdecl, dynlib: mysqllib, importc: "my_init".}
+proc my_thread_init*(): my_bool{.cdecl, dynlib: mysqllib, 
+                                 importc: "my_thread_init".}
+proc my_thread_end*(){.cdecl, dynlib: mysqllib, importc: "my_thread_end".}
+const 
+  NULL_LENGTH*: int = int(not (0)) # For net_store_length
+
+const 
+  MYSQL_STMT_HEADER* = 4
+  MYSQL_LONG_DATA_HEADER* = 6 #  ------------ Stop of declaration in "mysql_com.h"   -----------------------  
+                              # $include "mysql_time.h"
+                              # $include "mysql_version.h"
+                              # $include "typelib.h"
+                              # $include "my_list.h" /* for LISTs used in 'MYSQL' and 'MYSQL_STMT' */
+                              #      var
+                              #         mysql_port : cuint;cvar;external;
+                              #         mysql_unix_port : Pchar;cvar;external;
+
+const 
+  CLIENT_NET_READ_TIMEOUT* = 365 * 24 * 3600 # Timeout on read
+  CLIENT_NET_WRITE_TIMEOUT* = 365 * 24 * 3600 # Timeout on write
+
+type 
+  Pst_mysql_field* = ptr st_mysql_field
+  st_mysql_field*{.final.} = object 
+    name*: cstring            # Name of column
+    org_name*: cstring        # Original column name, if an alias
+    table*: cstring           # Table of column if column was a field
+    org_table*: cstring       # Org table name, if table was an alias
+    db*: cstring              # Database for table
+    catalog*: cstring         # Catalog for table
+    def*: cstring             # Default value (set by mysql_list_fields)
+    len*: int              # Width of column (create length)
+    max_length*: int       # Max width for selected set
+    name_length*: cuint
+    org_name_length*: cuint
+    table_length*: cuint
+    org_table_length*: cuint
+    db_length*: cuint
+    catalog_length*: cuint
+    def_length*: cuint
+    flags*: cuint             # Div flags
+    decimals*: cuint          # Number of decimals in field
+    charsetnr*: cuint         # Character set
+    ftype*: enum_field_types  # Type of field. See mysql_com.h for types
+  
+  MYSQL_FIELD* = st_mysql_field
+  PMYSQL_FIELD* = ptr MYSQL_FIELD
+  PMYSQL_ROW* = ptr MYSQL_ROW # return data as array of strings
+  MYSQL_ROW* = cstringArray
+  PMYSQL_FIELD_OFFSET* = ptr MYSQL_FIELD_OFFSET # offset to current field
+  MYSQL_FIELD_OFFSET* = cuint
+
+proc IS_PRI_KEY*(n: int32): bool
+proc IS_NOT_NULL*(n: int32): bool
+proc IS_BLOB*(n: int32): bool
+proc IS_NUM*(t: enum_field_types): bool
+proc INTERNAL_NUM_FIELD*(f: Pst_mysql_field): bool
+proc IS_NUM_FIELD*(f: Pst_mysql_field): bool
+
+type 
+  my_ulonglong* = int64
+  Pmy_ulonglong* = ptr my_ulonglong
+
+const 
+  MYSQL_COUNT_ERROR* = not (my_ulonglong(0))
+
+type 
+  Pst_mysql_rows* = ptr st_mysql_rows
+  st_mysql_rows*{.final.} = object 
+    next*: Pst_mysql_rows     # list of rows
+    data*: MYSQL_ROW
+    len*: int
+
+  MYSQL_ROWS* = st_mysql_rows
+  PMYSQL_ROWS* = ptr MYSQL_ROWS
+  PMYSQL_ROW_OFFSET* = ptr MYSQL_ROW_OFFSET # offset to current row
+  MYSQL_ROW_OFFSET* = MYSQL_ROWS #  ------------ Start of declaration in "my_alloc.h"     --------------------  
+                                 # $include "my_alloc.h"
+
+const 
+  ALLOC_MAX_BLOCK_TO_DROP* = 4096
+  ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP* = 10 # struct for once_alloc (block)  
+
+type 
+  Pst_used_mem* = ptr st_used_mem
+  st_used_mem*{.final.} = object 
+    next*: Pst_used_mem       # Next block in use
+    left*: cuint              # memory left in block
+    size*: cuint              # size of block
+  
+  USED_MEM* = st_used_mem
+  PUSED_MEM* = ptr USED_MEM
+  Pst_mem_root* = ptr st_mem_root
+  st_mem_root*{.final.} = object 
+    free*: PUSED_MEM          # blocks with free memory in it
+    used*: PUSED_MEM          # blocks almost without free memory
+    pre_alloc*: PUSED_MEM     # preallocated block
+    min_malloc*: cuint        # if block have less memory it will be put in 'used' list
+    block_size*: cuint        # initial block size
+    block_num*: cuint # allocated blocks counter
+                      #    first free block in queue test counter (if it exceed
+                      #       MAX_BLOCK_USAGE_BEFORE_DROP block will be dropped in 'used' list)     
+    first_block_usage*: cuint
+    error_handler*: proc (){.cdecl.}
+
+  MEM_ROOT* = st_mem_root
+  PMEM_ROOT* = ptr MEM_ROOT   #  ------------ Stop of declaration in "my_alloc.h"    ----------------------  
+
+type 
+  Pst_mysql_data* = ptr st_mysql_data
+  st_mysql_data*{.final.} = object 
+    rows*: my_ulonglong
+    fields*: cuint
+    data*: PMYSQL_ROWS
+    alloc*: MEM_ROOT
+    prev_ptr*: ptr PMYSQL_ROWS
+
+  MYSQL_DATA* = st_mysql_data
+  PMYSQL_DATA* = ptr MYSQL_DATA
+  mysql_option* = enum 
+    MYSQL_OPT_CONNECT_TIMEOUT, MYSQL_OPT_COMPRESS, MYSQL_OPT_NAMED_PIPE, 
+    MYSQL_INIT_COMMAND, MYSQL_READ_DEFAULT_FILE, MYSQL_READ_DEFAULT_GROUP, 
+    MYSQL_SET_CHARSET_DIR, MYSQL_SET_CHARSET_NAME, MYSQL_OPT_LOCAL_INFILE, 
+    MYSQL_OPT_PROTOCOL, MYSQL_SHARED_MEMORY_BASE_NAME, MYSQL_OPT_READ_TIMEOUT, 
+    MYSQL_OPT_WRITE_TIMEOUT, MYSQL_OPT_USE_RESULT, 
+    MYSQL_OPT_USE_REMOTE_CONNECTION, MYSQL_OPT_USE_EMBEDDED_CONNECTION, 
+    MYSQL_OPT_GUESS_CONNECTION, MYSQL_SET_CLIENT_IP, MYSQL_SECURE_AUTH, 
+    MYSQL_REPORT_DATA_TRUNCATION, MYSQL_OPT_RECONNECT
+
+const 
+  MAX_MYSQL_MANAGER_ERR* = 256
+  MAX_MYSQL_MANAGER_MSG* = 256
+  MANAGER_OK* = 200
+  MANAGER_INFO* = 250
+  MANAGER_ACCESS* = 401
+  MANAGER_CLIENT_ERR* = 450
+  MANAGER_INTERNAL_ERR* = 500
+
+type 
+  st_dynamic_array*{.final.} = object 
+    buffer*: cstring
+    elements*: cuint
+    max_element*: cuint
+    alloc_increment*: cuint
+    size_of_element*: cuint
+
+  DYNAMIC_ARRAY* = st_dynamic_array
+  Pst_dynamic_array* = ptr st_dynamic_array
+  Pst_mysql_options* = ptr st_mysql_options
+  st_mysql_options*{.final.} = object 
+    connect_timeout*: cuint
+    read_timeout*: cuint
+    write_timeout*: cuint
+    port*: cuint
+    protocol*: cuint
+    client_flag*: int
+    host*: cstring
+    user*: cstring
+    password*: cstring
+    unix_socket*: cstring
+    db*: cstring
+    init_commands*: Pst_dynamic_array
+    my_cnf_file*: cstring
+    my_cnf_group*: cstring
+    charset_dir*: cstring
+    charset_name*: cstring
+    ssl_key*: cstring         # PEM key file
+    ssl_cert*: cstring        # PEM cert file
+    ssl_ca*: cstring          # PEM CA file
+    ssl_capath*: cstring      # PEM directory of CA-s?
+    ssl_cipher*: cstring      # cipher to use
+    shared_memory_base_name*: cstring
+    max_allowed_packet*: int
+    use_ssl*: my_bool         # if to use SSL or not
+    compress*: my_bool
+    named_pipe*: my_bool #  On connect, find out the replication role of the server, and
+                         #       establish connections to all the peers  
+    rpl_probe*: my_bool #  Each call to mysql_real_query() will parse it to tell if it is a read
+                        #       or a write, and direct it to the slave or the master      
+    rpl_parse*: my_bool #  If set, never read from a master, only from slave, when doing
+                        #       a read that is replication-aware    
+    no_master_reads*: my_bool
+    separate_thread*: my_bool
+    methods_to_use*: mysql_option
+    client_ip*: cstring
+    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)
+                                     # function pointers for local infile support  
+    local_infile_init*: proc (para1: var pointer, para2: cstring, para3: pointer): cint{.
+        cdecl.}
+    local_infile_read*: proc (para1: pointer, para2: cstring, para3: cuint): cint
+    local_infile_end*: proc (para1: pointer)
+    local_infile_error*: proc (para1: pointer, para2: cstring, para3: cuint): cint
+    local_infile_userdata*: pointer
+
+  mysql_status* = enum 
+    MYSQL_STATUS_READY, MYSQL_STATUS_GET_RESULT, MYSQL_STATUS_USE_RESULT
+  mysql_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 adminstrative
+                               #      type which must happen on the pivot connectioin 
+    MYSQL_PROTOCOL_DEFAULT, MYSQL_PROTOCOL_TCP, MYSQL_PROTOCOL_SOCKET, 
+    MYSQL_PROTOCOL_PIPE, MYSQL_PROTOCOL_MEMORY
+  mysql_rpl_type* = enum 
+    MYSQL_RPL_MASTER, MYSQL_RPL_SLAVE, MYSQL_RPL_ADMIN
+  charset_info_st*{.final.} = object 
+    number*: cuint
+    primary_number*: cuint
+    binary_number*: cuint
+    state*: cuint
+    csname*: cstring
+    name*: cstring
+    comment*: cstring
+    tailoring*: cstring
+    ftype*: cstring
+    to_lower*: cstring
+    to_upper*: cstring
+    sort_order*: cstring
+    contractions*: ptr int16
+    sort_order_big*: ptr ptr int16
+    tab_to_uni*: ptr int16
+    tab_from_uni*: pointer    # was ^MY_UNI_IDX
+    state_map*: cstring
+    ident_map*: cstring
+    strxfrm_multiply*: cuint
+    mbminlen*: cuint
+    mbmaxlen*: cuint
+    min_sort_char*: int16
+    max_sort_char*: int16
+    escape_with_backslash_is_dangerous*: my_bool
+    cset*: pointer            # was ^MY_CHARSET_HANDLER
+    coll*: pointer            # was ^MY_COLLATION_HANDLER;
+  
+  CHARSET_INFO* = charset_info_st
+  Pcharset_info_st* = ptr charset_info_st
+  Pcharacter_set* = ptr character_set
+  character_set*{.final.} = object 
+    number*: cuint
+    state*: cuint
+    csname*: cstring
+    name*: cstring
+    comment*: cstring
+    dir*: cstring
+    mbminlen*: cuint
+    mbmaxlen*: cuint
+
+  MY_CHARSET_INFO* = character_set
+  PMY_CHARSET_INFO* = ptr MY_CHARSET_INFO
+  Pst_mysql_methods* = ptr st_mysql_methods
+  Pst_mysql* = ptr st_mysql
+  st_mysql*{.final.} = object 
+    net*: NET                 # Communication parameters
+    connector_fd*: gptr       # ConnectorFd for SSL
+    host*: cstring
+    user*: cstring
+    passwd*: cstring
+    unix_socket*: cstring
+    server_version*: cstring
+    host_info*: cstring
+    info*: cstring
+    db*: cstring
+    charset*: Pcharset_info_st
+    fields*: PMYSQL_FIELD
+    field_alloc*: MEM_ROOT
+    affected_rows*: my_ulonglong
+    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
+    thread_id*: int        # Id for connection in server
+    packet_length*: int
+    port*: cuint
+    client_flag*: int
+    server_capabilities*: int
+    protocol_version*: cuint
+    field_count*: cuint
+    server_status*: cuint
+    server_language*: cuint
+    warning_count*: cuint
+    options*: st_mysql_options
+    status*: mysql_status
+    free_me*: my_bool         # If free in mysql_close
+    reconnect*: my_bool       # set to 1 if automatic reconnect
+    scramble*: array[0..(SCRAMBLE_LENGTH + 1) - 1, char] # session-wide random string
+                                                         #  Set if this is the original connection, not a master or a slave we have
+                                                         #       added though mysql_rpl_probe() or mysql_set_master()/ mysql_add_slave()      
+    rpl_pivot*: my_bool #   Pointers to the master, and the next slave connections, points to
+                        #        itself if lone connection.       
+    master*: Pst_mysql
+    next_slave*: Pst_mysql
+    last_used_slave*: Pst_mysql # needed for round-robin slave pick
+    last_used_con*: Pst_mysql # needed for send/read/store/use result to work correctly with replication
+    stmts*: Pointer           # was PList, list of all statements
+    methods*: Pst_mysql_methods
+    thd*: pointer #   Points to boolean flag in MYSQL_RES  or MYSQL_STMT. We set this flag
+                  #        from mysql_stmt_close if close had to cancel result set of this object.       
+    unbuffered_fetch_owner*: Pmy_bool
+
+  MYSQL* = st_mysql
+  PMYSQL* = ptr MYSQL
+  Pst_mysql_res* = ptr st_mysql_res
+  st_mysql_res*{.final.} = object 
+    row_count*: my_ulonglong
+    fields*: PMYSQL_FIELD
+    data*: PMYSQL_DATA
+    data_cursor*: PMYSQL_ROWS
+    lengths*: ptr int         # column lengths of current row
+    handle*: PMYSQL           # for unbuffered reads
+    field_alloc*: MEM_ROOT
+    field_count*: cuint
+    current_field*: cuint
+    row*: MYSQL_ROW           # If unbuffered read
+    current_row*: MYSQL_ROW   # buffer to current row
+    eof*: my_bool             # Used by mysql_fetch_row
+    unbuffered_fetch_cancelled*: my_bool # mysql_stmt_close() had to cancel this result
+    methods*: Pst_mysql_methods
+
+  MYSQL_RES* = st_mysql_res
+  PMYSQL_RES* = ptr MYSQL_RES
+  Pst_mysql_stmt* = ptr st_mysql_stmt
+  PMYSQL_STMT* = ptr MYSQL_STMT
+  st_mysql_methods*{.final.} = object 
+    read_query_result*: proc (mysql: PMYSQL): my_bool{.cdecl.}
+    advanced_command*: proc (mysql: PMYSQL, command: enum_server_command, 
+                             header: cstring, header_length: int, 
+                             arg: cstring, arg_length: int, 
+                             skip_check: my_bool): my_bool
+    read_rows*: proc (mysql: PMYSQL, mysql_fields: PMYSQL_FIELD, fields: cuint): PMYSQL_DATA
+    use_result*: proc (mysql: PMYSQL): PMYSQL_RES
+    fetch_lengths*: proc (fto: ptr int, column: MYSQL_ROW, field_count: cuint)
+    flush_use_result*: proc (mysql: PMYSQL)
+    list_fields*: proc (mysql: PMYSQL): PMYSQL_FIELD
+    read_prepare_result*: proc (mysql: PMYSQL, stmt: PMYSQL_STMT): my_bool
+    stmt_execute*: proc (stmt: PMYSQL_STMT): cint
+    read_binary_rows*: proc (stmt: PMYSQL_STMT): cint
+    unbuffered_fetch*: proc (mysql: PMYSQL, row: cstringArray): cint
+    free_embedded_thd*: proc (mysql: PMYSQL)
+    read_statistics*: proc (mysql: PMYSQL): cstring
+    next_result*: proc (mysql: PMYSQL): my_bool
+    read_change_user_result*: proc (mysql: PMYSQL, buff: cstring, 
+                                    passwd: cstring): cint
+    read_rowsfrom_cursor*: proc (stmt: PMYSQL_STMT): cint
+
+  MYSQL_METHODS* = st_mysql_methods
+  PMYSQL_METHODS* = ptr MYSQL_METHODS
+  Pst_mysql_manager* = ptr st_mysql_manager
+  st_mysql_manager*{.final.} = object 
+    net*: NET
+    host*: cstring
+    user*: cstring
+    passwd*: cstring
+    port*: cuint
+    free_me*: my_bool
+    eof*: my_bool
+    cmd_status*: cint
+    last_errno*: cint
+    net_buf*: cstring
+    net_buf_pos*: cstring
+    net_data_end*: cstring
+    net_buf_size*: cint
+    last_error*: array[0..(MAX_MYSQL_MANAGER_ERR) - 1, char]
+
+  MYSQL_MANAGER* = st_mysql_manager
+  PMYSQL_MANAGER* = ptr MYSQL_MANAGER
+  Pst_mysql_parameters* = ptr st_mysql_parameters
+  st_mysql_parameters*{.final.} = object 
+    p_max_allowed_packet*: ptr int
+    p_net_buffer_length*: ptr int
+
+  MYSQL_PARAMETERS* = st_mysql_parameters
+  PMYSQL_PARAMETERS* = ptr MYSQL_PARAMETERS
+  enum_mysql_stmt_state* = enum     
+    MYSQL_STMT_INIT_DONE = 1, MYSQL_STMT_PREPARE_DONE, MYSQL_STMT_EXECUTE_DONE, 
+    MYSQL_STMT_FETCH_DONE
+  Pst_mysql_bind* = ptr st_mysql_bind
+  st_mysql_bind*{.final.} = object 
+    len*: int              # output length pointer
+    is_null*: Pmy_bool        # Pointer to null indicator
+    buffer*: pointer          # buffer to get/put data
+    error*: pmy_bool          # set this if you want to track data truncations happened during fetch
+    buffer_type*: enum_field_types # buffer type
+    buffer_length*: int    # buffer length, must be set for str/binary
+                           # Following are for internal use. Set by mysql_stmt_bind_param  
+    row_ptr*: ptr byte        # for the current data position
+    offset*: int           # offset position for char/binary fetch
+    length_value*: int     #  Used if length is 0
+    param_number*: cuint      # For null count and error messages
+    pack_length*: cuint       # Internal length for packed data
+    error_value*: my_bool     # used if error is 0
+    is_unsigned*: my_bool     # set if integer type is unsigned
+    long_data_used*: my_bool  # If used with mysql_send_long_data
+    is_null_value*: my_bool   # Used if is_null is 0
+    store_param_func*: proc (net: PNET, param: Pst_mysql_bind){.cdecl.}
+    fetch_result*: proc (para1: Pst_mysql_bind, para2: PMYSQL_FIELD, row: PPbyte)
+    skip_result*: proc (para1: Pst_mysql_bind, para2: PMYSQL_FIELD, row: PPbyte)
+
+  MYSQL_BIND* = st_mysql_bind
+  PMYSQL_BIND* = ptr MYSQL_BIND # statement handler  
+  st_mysql_stmt*{.final.} = object 
+    mem_root*: MEM_ROOT       # root allocations
+    mysql*: PMYSQL            # connection handle
+    params*: PMYSQL_BIND      # input parameters
+    bind*: PMYSQL_BIND        # input parameters
+    fields*: PMYSQL_FIELD     # result set metadata
+    result*: MYSQL_DATA       # cached result set
+    data_cursor*: PMYSQL_ROWS # current row in cached result
+    affected_rows*: my_ulonglong # copy of mysql->affected_rows after statement execution
+    insert_id*: my_ulonglong 
+    read_row_func*: proc (stmt: Pst_mysql_stmt, row: PPbyte): cint{.cdecl.}
+    stmt_id*: int          # Id for prepared statement
+    flags*: int            # i.e. type of cursor to open
+    prefetch_rows*: int    # number of rows per one COM_FETCH
+    server_status*: cuint # Copied from mysql->server_status after execute/fetch to know
+                          # server-side cursor status for this statement.
+    last_errno*: cuint        # error code
+    param_count*: cuint       # input parameter count
+    field_count*: cuint       # number of columns in result set
+    state*: enum_mysql_stmt_state # statement state
+    last_error*: array[0..(MYSQL_ERRMSG_SIZE) - 1, char] # error message
+    sqlstate*: array[0..(SQLSTATE_LENGTH + 1) - 1, char]
+    send_types_to_server*: my_bool # Types of input parameters should be sent to server
+    bind_param_done*: my_bool # input buffers were supplied
+    bind_result_done*: char # output buffers were supplied
+    unbuffered_fetch_cancelled*: my_bool        
+    update_max_length*: my_bool
+
+  MYSQL_STMT* = st_mysql_stmt # When doing mysql_stmt_store_result calculate max_length attribute
+                              # of statement metadata. This is to be consistent with the old API,
+                              # where this was done automatically.
+                              # In the new API we do that only by request because it slows down
+                              # mysql_stmt_store_result sufficiently.       
+  enum_stmt_attr_type* = enum
+    STMT_ATTR_UPDATE_MAX_LENGTH, STMT_ATTR_CURSOR_TYPE,  
+    STMT_ATTR_PREFETCH_ROWS 
+    
+proc mysql_server_init*(argc: cint, argv: cstringArray, groups: cstringArray): cint{.cdecl, 
+    dynlib: mysqllib, importc: "mysql_server_init".}
+proc mysql_server_end*(){.cdecl, dynlib: mysqllib, importc: "mysql_server_end".}
+  # mysql_server_init/end need to be called when using libmysqld or
+  #      libmysqlclient (exactly, mysql_server_init() is called by mysql_init() so
+  #      you don't need to call it explicitely; but you need to call
+  #      mysql_server_end() to free memory). The names are a bit misleading
+  #      (mysql_SERVER* to be used when using libmysqlCLIENT). So we add more general
+  #      names which suit well whether you're using libmysqld or libmysqlclient. We
+  #      intend to promote these aliases over the mysql_server* ones.     
+proc mysql_library_init*(argc: cint, argv: cstringArray, groups: cstringArray): cint{.cdecl, 
+    dynlib: mysqllib, importc: "mysql_server_init".}
+proc mysql_library_end*(){.cdecl, dynlib: mysqllib, importc: "mysql_server_end".}
+proc mysql_get_parameters*(): PMYSQL_PARAMETERS{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_get_parameters".}
+  # Set up and bring down a thread; these function should be called
+  #      for each thread in an application which opens at least one MySQL
+  #      connection.  All uses of the connection(s) should be between these
+  #      function calls.     
+proc mysql_thread_init*(): my_bool{.stdcall, dynlib: mysqllib, 
+                                    importc: "mysql_thread_init".}
+proc mysql_thread_end*(){.stdcall, dynlib: mysqllib, importc: "mysql_thread_end".}
+  # Functions to get information from the MYSQL and MYSQL_RES structures
+  #      Should definitely be used if one uses shared libraries.     
+proc mysql_num_rows*(res: PMYSQL_RES): my_ulonglong{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_num_rows".}
+proc mysql_num_fields*(res: PMYSQL_RES): cuint{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_num_fields".}
+proc mysql_eof*(res: PMYSQL_RES): my_bool{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_eof".}
+proc mysql_fetch_field_direct*(res: PMYSQL_RES, fieldnr: cuint): PMYSQL_FIELD{.
+    stdcall, dynlib: mysqllib, importc: "mysql_fetch_field_direct".}
+proc mysql_fetch_fields*(res: PMYSQL_RES): PMYSQL_FIELD{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_fetch_fields".}
+proc mysql_row_tell*(res: PMYSQL_RES): MYSQL_ROW_OFFSET{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_row_tell".}
+proc mysql_field_tell*(res: PMYSQL_RES): MYSQL_FIELD_OFFSET{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_field_tell".}
+proc mysql_field_count*(mysql: PMYSQL): cuint{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_field_count".}
+proc mysql_affected_rows*(mysql: PMYSQL): my_ulonglong{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_affected_rows".}
+proc mysql_insert_id*(mysql: PMYSQL): my_ulonglong{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_insert_id".}
+proc mysql_errno*(mysql: PMYSQL): cuint{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_errno".}
+proc mysql_error*(mysql: PMYSQL): cstring{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_error".}
+proc mysql_sqlstate*(mysql: PMYSQL): cstring{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_sqlstate".}
+proc mysql_warning_count*(mysql: PMYSQL): cuint{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_warning_count".}
+proc mysql_info*(mysql: PMYSQL): cstring{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_info".}
+proc mysql_thread_id*(mysql: PMYSQL): int{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_thread_id".}
+proc mysql_character_set_name*(mysql: PMYSQL): cstring{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_character_set_name".}
+proc mysql_set_character_set*(mysql: PMYSQL, csname: cstring): int32{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_set_character_set".}
+proc mysql_init*(mysql: PMYSQL): PMYSQL{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_init".}
+proc mysql_ssl_set*(mysql: PMYSQL, key: cstring, cert: cstring, ca: cstring, 
+                    capath: cstring, cipher: cstring): my_bool{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_ssl_set".}
+proc mysql_change_user*(mysql: PMYSQL, user: cstring, passwd: cstring, 
+                        db: cstring): my_bool{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_change_user".}
+proc mysql_real_connect*(mysql: PMYSQL, host: cstring, user: cstring, 
+                         passwd: cstring, db: cstring, port: cuint, 
+                         unix_socket: cstring, clientflag: int): PMYSQL{.
+    stdcall, dynlib: mysqllib, importc: "mysql_real_connect".}
+proc mysql_select_db*(mysql: PMYSQL, db: cstring): cint{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_select_db".}
+proc mysql_query*(mysql: PMYSQL, q: cstring): cint{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_query".}
+proc mysql_send_query*(mysql: PMYSQL, q: cstring, len: int): cint{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_send_query".}
+proc mysql_real_query*(mysql: PMYSQL, q: cstring, len: int): cint{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_real_query".}
+proc mysql_store_result*(mysql: PMYSQL): PMYSQL_RES{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_store_result".}
+proc mysql_use_result*(mysql: PMYSQL): PMYSQL_RES{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_use_result".}
+  # perform query on master  
+proc mysql_master_query*(mysql: PMYSQL, q: cstring, len: int): my_bool{.
+    stdcall, dynlib: mysqllib, importc: "mysql_master_query".}
+proc mysql_master_send_query*(mysql: PMYSQL, q: cstring, len: int): my_bool{.
+    stdcall, dynlib: mysqllib, importc: "mysql_master_send_query".}
+  # perform query on slave  
+proc mysql_slave_query*(mysql: PMYSQL, q: cstring, len: int): my_bool{.
+    stdcall, dynlib: mysqllib, importc: "mysql_slave_query".}
+proc mysql_slave_send_query*(mysql: PMYSQL, q: cstring, len: int): my_bool{.
+    stdcall, dynlib: mysqllib, importc: "mysql_slave_send_query".}
+proc mysql_get_character_set_info*(mysql: PMYSQL, charset: PMY_CHARSET_INFO){.
+    stdcall, dynlib: mysqllib, importc: "mysql_get_character_set_info".}
+  # local infile support  
+const 
+  LOCAL_INFILE_ERROR_LEN* = 512 
+  
+# procedure mysql_set_local_infile_handler(mysql:PMYSQL; local_infile_init:function (para1:Ppointer; para2:Pchar; para3:pointer):longint; local_infile_read:function (para1:pointer; para2:Pchar; para3:dword):longint; local_infile_end:procedure (_pa
+# para6:pointer);cdecl;external mysqllib name 'mysql_set_local_infile_handler';
+
+proc mysql_set_local_infile_default*(mysql: PMYSQL){.cdecl, dynlib: mysqllib, 
+    importc: "mysql_set_local_infile_default".}
+  # enable/disable parsing of all queries to decide if they go on master or
+  #      slave     
+proc mysql_enable_rpl_parse*(mysql: PMYSQL){.stdcall, dynlib: mysqllib, 
+    importc: "mysql_enable_rpl_parse".}
+proc mysql_disable_rpl_parse*(mysql: PMYSQL){.stdcall, dynlib: mysqllib, 
+    importc: "mysql_disable_rpl_parse".}
+  # get the value of the parse flag  
+proc mysql_rpl_parse_enabled*(mysql: PMYSQL): cint{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_rpl_parse_enabled".}
+  #  enable/disable reads from master  
+proc mysql_enable_reads_from_master*(mysql: PMYSQL){.stdcall, dynlib: mysqllib, 
+    importc: "mysql_enable_reads_from_master".}
+proc mysql_disable_reads_from_master*(mysql: PMYSQL){.stdcall, dynlib: mysqllib, 
+    importc: "mysql_disable_reads_from_master".}
+  # get the value of the master read flag  
+proc mysql_reads_from_master_enabled*(mysql: PMYSQL): my_bool{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_reads_from_master_enabled".}
+proc mysql_rpl_query_type*(q: cstring, length: cint): mysql_rpl_type{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_rpl_query_type".}
+  # discover the master and its slaves  
+proc mysql_rpl_probe*(mysql: PMYSQL): my_bool{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_rpl_probe".}
+  # set the master, close/free the old one, if it is not a pivot  
+proc mysql_set_master*(mysql: PMYSQL, host: cstring, port: cuint, user: cstring, 
+                       passwd: cstring): cint{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_set_master".}
+proc mysql_add_slave*(mysql: PMYSQL, host: cstring, port: cuint, user: cstring, 
+                      passwd: cstring): cint{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_add_slave".}
+proc mysql_shutdown*(mysql: PMYSQL, shutdown_level: mysql_enum_shutdown_level): cint{.
+    stdcall, dynlib: mysqllib, importc: "mysql_shutdown".}
+proc mysql_dump_debug_info*(mysql: PMYSQL): cint{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_dump_debug_info".}
+proc mysql_refresh*(mysql: PMYSQL, refresh_options: cuint): cint{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_refresh".}
+proc mysql_kill*(mysql: PMYSQL, pid: int): cint{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_kill".}
+proc mysql_set_server_option*(mysql: PMYSQL, option: enum_mysql_set_option): cint{.
+    stdcall, dynlib: mysqllib, importc: "mysql_set_server_option".}
+proc mysql_ping*(mysql: PMYSQL): cint{.stdcall, dynlib: mysqllib, 
+                                       importc: "mysql_ping".}
+proc mysql_stat*(mysql: PMYSQL): cstring{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_stat".}
+proc mysql_get_server_info*(mysql: PMYSQL): cstring{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_get_server_info".}
+proc mysql_get_client_info*(): cstring{.stdcall, dynlib: mysqllib, 
+                                        importc: "mysql_get_client_info".}
+proc mysql_get_client_version*(): int{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_get_client_version".}
+proc mysql_get_host_info*(mysql: PMYSQL): cstring{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_get_host_info".}
+proc mysql_get_server_version*(mysql: PMYSQL): int{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_get_server_version".}
+proc mysql_get_proto_info*(mysql: PMYSQL): cuint{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_get_proto_info".}
+proc mysql_list_dbs*(mysql: PMYSQL, wild: cstring): PMYSQL_RES{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_list_dbs".}
+proc mysql_list_tables*(mysql: PMYSQL, wild: cstring): PMYSQL_RES{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_list_tables".}
+proc mysql_list_processes*(mysql: PMYSQL): PMYSQL_RES{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_list_processes".}
+proc mysql_options*(mysql: PMYSQL, option: mysql_option, arg: cstring): cint{.
+    stdcall, dynlib: mysqllib, importc: "mysql_options".}
+proc mysql_free_result*(result: PMYSQL_RES){.stdcall, dynlib: mysqllib, 
+    importc: "mysql_free_result".}
+proc mysql_data_seek*(result: PMYSQL_RES, offset: my_ulonglong){.stdcall, 
+    dynlib: mysqllib, importc: "mysql_data_seek".}
+proc mysql_row_seek*(result: PMYSQL_RES, offset: MYSQL_ROW_OFFSET): MYSQL_ROW_OFFSET{.
+    stdcall, dynlib: mysqllib, importc: "mysql_row_seek".}
+proc mysql_field_seek*(result: PMYSQL_RES, offset: MYSQL_FIELD_OFFSET): MYSQL_FIELD_OFFSET{.
+    stdcall, dynlib: mysqllib, importc: "mysql_field_seek".}
+proc mysql_fetch_row*(result: PMYSQL_RES): MYSQL_ROW{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_fetch_row".}
+proc mysql_fetch_lengths*(result: PMYSQL_RES): ptr int{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_fetch_lengths".}
+proc mysql_fetch_field*(result: PMYSQL_RES): PMYSQL_FIELD{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_fetch_field".}
+proc mysql_list_fields*(mysql: PMYSQL, table: cstring, wild: cstring): PMYSQL_RES{.
+    stdcall, dynlib: mysqllib, importc: "mysql_list_fields".}
+proc mysql_escape_string*(fto: cstring, `from`: cstring, from_length: int): int{.
+    stdcall, dynlib: mysqllib, importc: "mysql_escape_string".}
+proc mysql_hex_string*(fto: cstring, `from`: cstring, from_length: int): int{.
+    stdcall, dynlib: mysqllib, importc: "mysql_hex_string".}
+proc mysql_real_escape_string*(mysql: PMYSQL, fto: cstring, `from`: cstring, 
+                               len: int): int{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_real_escape_string".}
+proc mysql_debug*(debug: cstring){.stdcall, dynlib: mysqllib, 
+                                   importc: "mysql_debug".}
+  #    function mysql_odbc_escape_string(mysql:PMYSQL; fto:Pchar; to_length:dword; from:Pchar; from_length:dword;
+  #               param:pointer; extend_buffer:function (para1:pointer; to:Pchar; length:Pdword):Pchar):Pchar;stdcall;external mysqllib name 'mysql_odbc_escape_string';
+proc myodbc_remove_escape*(mysql: PMYSQL, name: cstring){.stdcall, 
+    dynlib: mysqllib, importc: "myodbc_remove_escape".}
+proc mysql_thread_safe*(): cuint{.stdcall, dynlib: mysqllib, 
+                                  importc: "mysql_thread_safe".}
+proc mysql_embedded*(): my_bool{.stdcall, dynlib: mysqllib, 
+                                 importc: "mysql_embedded".}
+proc mysql_manager_init*(con: PMYSQL_MANAGER): PMYSQL_MANAGER{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_manager_init".}
+proc mysql_manager_connect*(con: PMYSQL_MANAGER, host: cstring, user: cstring, 
+                            passwd: cstring, port: cuint): PMYSQL_MANAGER{.
+    stdcall, dynlib: mysqllib, importc: "mysql_manager_connect".}
+proc mysql_manager_close*(con: PMYSQL_MANAGER){.stdcall, dynlib: mysqllib, 
+    importc: "mysql_manager_close".}
+proc mysql_manager_command*(con: PMYSQL_MANAGER, cmd: cstring, cmd_len: cint): cint{.
+    stdcall, dynlib: mysqllib, importc: "mysql_manager_command".}
+proc mysql_manager_fetch_line*(con: PMYSQL_MANAGER, res_buf: cstring, 
+                               res_buf_size: cint): cint{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_manager_fetch_line".}
+proc mysql_read_query_result*(mysql: PMYSQL): my_bool{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_read_query_result".}
+proc mysql_stmt_init*(mysql: PMYSQL): PMYSQL_STMT{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_stmt_init".}
+proc mysql_stmt_prepare*(stmt: PMYSQL_STMT, query: cstring, len: int): cint{.
+    stdcall, dynlib: mysqllib, importc: "mysql_stmt_prepare".}
+proc mysql_stmt_execute*(stmt: PMYSQL_STMT): cint{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_stmt_execute".}
+proc mysql_stmt_fetch*(stmt: PMYSQL_STMT): cint{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_stmt_fetch".}
+proc mysql_stmt_fetch_column*(stmt: PMYSQL_STMT, bind: PMYSQL_BIND, 
+                              column: cuint, offset: int): cint{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_stmt_fetch_column".}
+proc mysql_stmt_store_result*(stmt: PMYSQL_STMT): cint{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_stmt_store_result".}
+proc mysql_stmt_param_count*(stmt: PMYSQL_STMT): int{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_stmt_param_count".}
+proc mysql_stmt_attr_set*(stmt: PMYSQL_STMT, attr_type: enum_stmt_attr_type, 
+                          attr: pointer): my_bool{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_stmt_attr_set".}
+proc mysql_stmt_attr_get*(stmt: PMYSQL_STMT, attr_type: enum_stmt_attr_type, 
+                          attr: pointer): my_bool{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_stmt_attr_get".}
+proc mysql_stmt_bind_param*(stmt: PMYSQL_STMT, bnd: PMYSQL_BIND): my_bool{.
+    stdcall, dynlib: mysqllib, importc: "mysql_stmt_bind_param".}
+proc mysql_stmt_bind_result*(stmt: PMYSQL_STMT, bnd: PMYSQL_BIND): my_bool{.
+    stdcall, dynlib: mysqllib, importc: "mysql_stmt_bind_result".}
+proc mysql_stmt_close*(stmt: PMYSQL_STMT): my_bool{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_stmt_close".}
+proc mysql_stmt_reset*(stmt: PMYSQL_STMT): my_bool{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_stmt_reset".}
+proc mysql_stmt_free_result*(stmt: PMYSQL_STMT): my_bool{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_stmt_free_result".}
+proc mysql_stmt_send_long_data*(stmt: PMYSQL_STMT, param_number: cuint, 
+                                data: cstring, len: int): my_bool{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_stmt_send_long_data".}
+proc mysql_stmt_result_metadata*(stmt: PMYSQL_STMT): PMYSQL_RES{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_stmt_result_metadata".}
+proc mysql_stmt_param_metadata*(stmt: PMYSQL_STMT): PMYSQL_RES{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_stmt_param_metadata".}
+proc mysql_stmt_errno*(stmt: PMYSQL_STMT): cuint{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_stmt_errno".}
+proc mysql_stmt_error*(stmt: PMYSQL_STMT): cstring{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_stmt_error".}
+proc mysql_stmt_sqlstate*(stmt: PMYSQL_STMT): cstring{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_stmt_sqlstate".}
+proc mysql_stmt_row_seek*(stmt: PMYSQL_STMT, offset: MYSQL_ROW_OFFSET): MYSQL_ROW_OFFSET{.
+    stdcall, dynlib: mysqllib, importc: "mysql_stmt_row_seek".}
+proc mysql_stmt_row_tell*(stmt: PMYSQL_STMT): MYSQL_ROW_OFFSET{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_stmt_row_tell".}
+proc mysql_stmt_data_seek*(stmt: PMYSQL_STMT, offset: my_ulonglong){.stdcall, 
+    dynlib: mysqllib, importc: "mysql_stmt_data_seek".}
+proc mysql_stmt_num_rows*(stmt: PMYSQL_STMT): my_ulonglong{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_stmt_num_rows".}
+proc mysql_stmt_affected_rows*(stmt: PMYSQL_STMT): my_ulonglong{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_stmt_affected_rows".}
+proc mysql_stmt_insert_id*(stmt: PMYSQL_STMT): my_ulonglong{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_stmt_insert_id".}
+proc mysql_stmt_field_count*(stmt: PMYSQL_STMT): cuint{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_stmt_field_count".}
+proc mysql_commit*(mysql: PMYSQL): my_bool{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_commit".}
+proc mysql_rollback*(mysql: PMYSQL): my_bool{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_rollback".}
+proc mysql_autocommit*(mysql: PMYSQL, auto_mode: my_bool): my_bool{.stdcall, 
+    dynlib: mysqllib, importc: "mysql_autocommit".}
+proc mysql_more_results*(mysql: PMYSQL): my_bool{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_more_results".}
+proc mysql_next_result*(mysql: PMYSQL): cint{.stdcall, dynlib: mysqllib, 
+    importc: "mysql_next_result".}
+proc mysql_close*(sock: PMYSQL){.stdcall, dynlib: mysqllib, 
+                                 importc: "mysql_close".}
+  # status return codes  
+const 
+  MYSQL_NO_DATA* = 100
+  MYSQL_DATA_TRUNCATED* = 101
+
+proc mysql_reload*(mysql: PMySQL): cint
+
+when defined(USE_OLD_FUNCTIONS): 
+  proc mysql_connect*(mysql: PMYSQL, host: cstring, user: cstring, 
+                      passwd: cstring): PMYSQL{.stdcall, 
+      dynlib: External_library, importc: "mysql_connect".}
+  proc mysql_create_db*(mysql: PMYSQL, DB: cstring): cint{.stdcall, 
+      dynlib: External_library, importc: "mysql_create_db".}
+  proc mysql_drop_db*(mysql: PMYSQL, DB: cstring): cint{.stdcall, 
+      dynlib: External_library, importc: "mysql_drop_db".}
+  proc mysql_reload*(mysql: PMySQL): cint
+
+proc net_safe_read*(mysql: PMYSQL): cuint{.cdecl, dynlib: mysqllib, 
+    importc: "net_safe_read".}
+
+proc net_new_transaction(net: st_net): st_net = 
+  assert false
+  #net.pkt_nr = 0
+  result = net
+
+proc IS_PRI_KEY(n: int32): bool = 
+  result = (n and PRI_KEY_FLAG) != 0
+
+proc IS_NOT_NULL(n: int32): bool = 
+  result = (n and NOT_NULL_FLAG) != 0
+
+proc IS_BLOB(n: int32): bool = 
+  result = (n and BLOB_FLAG) != 0
+
+proc IS_NUM_FIELD(f: pst_mysql_field): bool = 
+  result = (f.flags and NUM_FLAG) != 0
+
+proc IS_NUM(t: enum_field_types): bool = 
+  result = (t <= FIELD_TYPE_INT24) or (t == FIELD_TYPE_YEAR) or
+      (t == FIELD_TYPE_NEWDECIMAL)
+
+proc INTERNAL_NUM_FIELD(f: Pst_mysql_field): bool = 
+  result = (f.ftype <= FIELD_TYPE_INT24) and
+      ((f.ftype != FIELD_TYPE_TIMESTAMP) or (f.len == 14) or (f.len == 8)) or
+      (f.ftype == FIELD_TYPE_YEAR)
+
+proc mysql_reload(mysql: PMySQL): cint = 
+  result = mysql_refresh(mysql, REFRESH_GRANT)
+
diff --git a/lib/base/sqlite3.nim b/lib/base/sqlite3.nim
new file mode 100644
index 000000000..9a97330ec
--- /dev/null
+++ b/lib/base/sqlite3.nim
@@ -0,0 +1,376 @@
+#
+#
+#            Nimrod's Runtime Library
+#        (c) Copyright 2009 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+{.deadCodeElim: on.}
+
+when defined(windows): 
+  const Sqlite3Lib = "sqlite3.dll"
+elif defined(macosx):
+  const Sqlite3Lib = "sqlite-3.6.13.dylib"
+else: 
+  const Sqlite3Lib = "libsqlite3.so"
+
+const 
+  SQLITE_INTEGER* = 1
+  SQLITE_FLOAT* = 2
+  SQLITE_BLOB* = 4
+  SQLITE_NULL* = 5
+  SQLITE_TEXT* = 3
+  SQLITE3_TEXT* = 3
+  SQLITE_UTF8* = 1
+  SQLITE_UTF16LE* = 2
+  SQLITE_UTF16BE* = 3         # Use native byte order  
+  SQLITE_UTF16* = 4           # sqlite3_create_function only  
+  SQLITE_ANY* = 5             #sqlite_exec return values
+  SQLITE_OK* = 0
+  SQLITE_ERROR* = 1           # SQL error or missing database  
+  SQLITE_INTERNAL* = 2        # An internal logic error in SQLite  
+  SQLITE_PERM* = 3            # Access permission denied  
+  SQLITE_ABORT* = 4           # Callback routine requested an abort  
+  SQLITE_BUSY* = 5            # The database file is locked  
+  SQLITE_LOCKED* = 6          # A table in the database is locked  
+  SQLITE_NOMEM* = 7           # A malloc() failed  
+  SQLITE_READONLY* = 8        # Attempt to write a readonly database  
+  SQLITE_INTERRUPT* = 9       # Operation terminated by sqlite3_interrupt() 
+  SQLITE_IOERR* = 10          # Some kind of disk I/O error occurred  
+  SQLITE_CORRUPT* = 11        # The database disk image is malformed  
+  SQLITE_NOTFOUND* = 12       # (Internal Only) Table or record not found  
+  SQLITE_FULL* = 13           # Insertion failed because database is full  
+  SQLITE_CANTOPEN* = 14       # Unable to open the database file  
+  SQLITE_PROTOCOL* = 15       # Database lock protocol error  
+  SQLITE_EMPTY* = 16          # Database is empty  
+  SQLITE_SCHEMA* = 17         # The database schema changed  
+  SQLITE_TOOBIG* = 18         # Too much data for one row of a table  
+  SQLITE_CONSTRAINT* = 19     # Abort due to contraint violation  
+  SQLITE_MISMATCH* = 20       # Data type mismatch  
+  SQLITE_MISUSE* = 21         # Library used incorrectly  
+  SQLITE_NOLFS* = 22          # Uses OS features not supported on host  
+  SQLITE_AUTH* = 23           # Authorization denied  
+  SQLITE_FORMAT* = 24         # Auxiliary database format error  
+  SQLITE_RANGE* = 25          # 2nd parameter to sqlite3_bind out of range  
+  SQLITE_NOTADB* = 26         # File opened that is not a database file  
+  SQLITE_ROW* = 100           # sqlite3_step() has another row ready  
+  SQLITE_DONE* = 101          # sqlite3_step() has finished executing  
+  SQLITE_COPY* = 0
+  SQLITE_CREATE_INDEX* = 1
+  SQLITE_CREATE_TABLE* = 2
+  SQLITE_CREATE_TEMP_INDEX* = 3
+  SQLITE_CREATE_TEMP_TABLE* = 4
+  SQLITE_CREATE_TEMP_TRIGGER* = 5
+  SQLITE_CREATE_TEMP_VIEW* = 6
+  SQLITE_CREATE_TRIGGER* = 7
+  SQLITE_CREATE_VIEW* = 8
+  SQLITE_DELETE* = 9
+  SQLITE_DROP_INDEX* = 10
+  SQLITE_DROP_TABLE* = 11
+  SQLITE_DROP_TEMP_INDEX* = 12
+  SQLITE_DROP_TEMP_TABLE* = 13
+  SQLITE_DROP_TEMP_TRIGGER* = 14
+  SQLITE_DROP_TEMP_VIEW* = 15
+  SQLITE_DROP_TRIGGER* = 16
+  SQLITE_DROP_VIEW* = 17
+  SQLITE_INSERT* = 18
+  SQLITE_PRAGMA* = 19
+  SQLITE_READ* = 20
+  SQLITE_SELECT* = 21
+  SQLITE_TRANSACTION* = 22
+  SQLITE_UPDATE* = 23
+  SQLITE_ATTACH* = 24
+  SQLITE_DETACH* = 25
+  SQLITE_ALTER_TABLE* = 26
+  SQLITE_REINDEX* = 27
+  SQLITE_DENY* = 1
+  SQLITE_IGNORE* = 2          # Original from sqlite3.h: 
+                              ##define SQLITE_STATIC      ((void(*)(void *))0)
+                              ##define SQLITE_TRANSIENT   ((void(*)(void *))-1)
+
+const 
+  SQLITE_STATIC* = nil
+  SQLITE_TRANSIENT* = cast[pointer](-1)
+
+type 
+  sqlite_int64* = int64
+  PPPChar* = ptr ptr cstring
+  TSqlite3 {.pure, final.} = object
+  Psqlite3* = ptr TSqlite3
+  PPSqlite3* = ptr PSqlite3
+  TSqlLite3Context {.pure, final.} = object
+  Psqlite3_context* = ptr TSqlLite3Context
+  Tsqlite3_stmt {.pure, final.} = object
+  Psqlite3_stmt* = ptr TSqlite3_stmt
+  PPsqlite3_stmt* = ptr Psqlite3_stmt
+  Tsqlite3_value {.pure, final.} = object
+  Psqlite3_value* = ptr Tsqlite3_value
+  PPsqlite3_value* = ptr Psqlite3_value #Callback function types
+                                        #Notice that most functions 
+                                        #were named using as prefix the 
+                                        #function name that uses them,
+                                        #rather than describing their functions  
+  Tsqlite3_callback* = proc (para1: pointer, para2: int32, para3: var cstring, 
+                             para4: var cstring): int32{.cdecl.}
+  Tbind_destructor_func* = proc (para1: pointer){.cdecl.}
+  Tcreate_function_step_func* = proc (para1: Psqlite3_context, para2: int32, 
+                                     para3: PPsqlite3_value){.cdecl.}
+  Tcreate_function_func_func* = proc (para1: Psqlite3_context, para2: int32, 
+                                     para3: PPsqlite3_value){.cdecl.}
+  Tcreate_function_final_func* = proc (para1: Psqlite3_context){.cdecl.}
+  Tsqlite3_result_func* = proc (para1: pointer){.cdecl.}
+  Tsqlite3_create_collation_func* = proc (para1: pointer, para2: int32, 
+      para3: pointer, para4: int32, para5: pointer): int32{.cdecl.}
+  Tsqlite3_collation_needed_func* = proc (para1: pointer, para2: Psqlite3, 
+      eTextRep: int32, para4: cstring){.cdecl.}
+
+proc sqlite3_close*(para1: Psqlite3): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_close".}
+proc sqlite3_exec*(para1: Psqlite3, sql: cstring, para3: Tsqlite3_callback, 
+                   para4: pointer, errmsg: var cstring): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_exec".}
+proc sqlite3_last_insert_rowid*(para1: Psqlite3): sqlite_int64{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_last_insert_rowid".}
+proc sqlite3_changes*(para1: Psqlite3): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_changes".}
+proc sqlite3_total_changes*(para1: Psqlite3): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_total_changes".}
+proc sqlite3_interrupt*(para1: Psqlite3){.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_interrupt".}
+proc sqlite3_complete*(sql: cstring): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_complete".}
+proc sqlite3_complete16*(sql: pointer): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_complete16".}
+proc sqlite3_busy_handler*(para1: Psqlite3, 
+    para2: proc (para1: pointer, para2: int32): int32 {.cdecl.}, 
+    para3: pointer): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_busy_handler".}
+proc sqlite3_busy_timeout*(para1: Psqlite3, ms: int32): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_busy_timeout".}
+proc sqlite3_get_table*(para1: Psqlite3, sql: cstring, resultp: var cstringArray, 
+                        nrow, ncolumn: var cint, errmsg: ptr cstring): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_get_table".}
+proc sqlite3_free_table*(result: cstringArray){.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_free_table".}
+  # Todo: see how translate sqlite3_mprintf, sqlite3_vmprintf, sqlite3_snprintf
+  # function sqlite3_mprintf(_para1:Pchar; args:array of const):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_mprintf';
+proc sqlite3_mprintf*(para1: cstring): cstring{.cdecl, varargs, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_mprintf".}
+  #function sqlite3_vmprintf(_para1:Pchar; _para2:va_list):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_vmprintf';
+proc sqlite3_free*(z: cstring){.cdecl, dynlib: Sqlite3Lib, 
+                                importc: "sqlite3_free".}
+  #function sqlite3_snprintf(_para1:longint; _para2:Pchar; _para3:Pchar; args:array of const):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_snprintf';
+proc sqlite3_snprintf*(para1: int32, para2: cstring, para3: cstring): cstring{.
+    cdecl, dynlib: Sqlite3Lib, varargs, importc: "sqlite3_snprintf".}
+proc sqlite3_set_authorizer*(para1: Psqlite3, 
+                             xAuth: proc (para1: pointer, para2: int32, 
+                                      para3: cstring, para4: cstring, 
+                                      para5: cstring, 
+                                      para6: cstring): int32{.cdecl.}, 
+                             pUserData: pointer): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_set_authorizer".}
+proc sqlite3_trace*(para1: Psqlite3, 
+                    xTrace: proc (para1: pointer, para2: cstring){.cdecl.}, 
+                    para3: pointer): pointer{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_trace".}
+proc sqlite3_progress_handler*(para1: Psqlite3, para2: int32, 
+                               para3: proc (para1: pointer): int32 {.cdecl.}, 
+                               para4: pointer){.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_progress_handler".}
+proc sqlite3_commit_hook*(para1: Psqlite3, 
+                          para2: proc (para1: pointer): int32{.cdecl.}, 
+                          para3: pointer): pointer{.cdecl, dynlib: Sqlite3Lib,
+    importc: "sqlite3_commit_hook".}
+proc sqlite3_open*(filename: cstring, ppDb: var Psqlite3): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_open".}
+proc sqlite3_open16*(filename: pointer, ppDb: var Psqlite3): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_open16".}
+proc sqlite3_errcode*(db: Psqlite3): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_errcode".}
+proc sqlite3_errmsg*(para1: Psqlite3): cstring{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_errmsg".}
+proc sqlite3_errmsg16*(para1: Psqlite3): pointer{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_errmsg16".}
+proc sqlite3_prepare*(db: Psqlite3, zSql: cstring, nBytes: int32, 
+                      ppStmt: PPsqlite3_stmt, pzTail: ptr cstring): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_prepare".}
+proc sqlite3_prepare16*(db: Psqlite3, zSql: pointer, nBytes: int32, 
+                        ppStmt: PPsqlite3_stmt, pzTail: var pointer): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_prepare16".}
+proc sqlite3_bind_blob*(para1: Psqlite3_stmt, para2: int32, para3: pointer, 
+                        n: int32, para5: Tbind_destructor_func): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_bind_blob".}
+proc sqlite3_bind_double*(para1: Psqlite3_stmt, para2: int32, para3: float64): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_bind_double".}
+proc sqlite3_bind_int*(para1: Psqlite3_stmt, para2: int32, para3: int32): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_bind_int".}
+proc sqlite3_bind_int64*(para1: Psqlite3_stmt, para2: int32, para3: sqlite_int64): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_bind_int64".}
+proc sqlite3_bind_null*(para1: Psqlite3_stmt, para2: int32): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_bind_null".}
+proc sqlite3_bind_text*(para1: Psqlite3_stmt, para2: int32, para3: cstring, 
+                        n: int32, para5: Tbind_destructor_func): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_bind_text".}
+proc sqlite3_bind_text16*(para1: Psqlite3_stmt, para2: int32, para3: pointer, 
+                          para4: int32, para5: Tbind_destructor_func): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_bind_text16".}
+  #function sqlite3_bind_value(_para1:Psqlite3_stmt; _para2:longint; _para3:Psqlite3_value):longint;cdecl; external Sqlite3Lib name 'sqlite3_bind_value';
+  #These overloaded functions were introduced to allow the use of SQLITE_STATIC and SQLITE_TRANSIENT
+  #It's the c world man ;-)
+proc sqlite3_bind_blob*(para1: Psqlite3_stmt, para2: int32, para3: pointer, 
+                        n: int32, para5: int32): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_bind_blob".}
+proc sqlite3_bind_text*(para1: Psqlite3_stmt, para2: int32, para3: cstring, 
+                        n: int32, para5: int32): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_bind_text".}
+proc sqlite3_bind_text16*(para1: Psqlite3_stmt, para2: int32, para3: pointer, 
+                          para4: int32, para5: int32): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_bind_text16".}
+proc sqlite3_bind_parameter_count*(para1: Psqlite3_stmt): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_bind_parameter_count".}
+proc sqlite3_bind_parameter_name*(para1: Psqlite3_stmt, para2: int32): cstring{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_bind_parameter_name".}
+proc sqlite3_bind_parameter_index*(para1: Psqlite3_stmt, zName: cstring): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_bind_parameter_index".}
+  #function sqlite3_clear_bindings(_para1:Psqlite3_stmt):longint;cdecl; external Sqlite3Lib name 'sqlite3_clear_bindings';
+proc sqlite3_column_count*(pStmt: Psqlite3_stmt): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_count".}
+proc sqlite3_column_name*(para1: Psqlite3_stmt, para2: int32): cstring{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_name".}
+proc sqlite3_column_name16*(para1: Psqlite3_stmt, para2: int32): pointer{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_name16".}
+proc sqlite3_column_decltype*(para1: Psqlite3_stmt, i: int32): cstring{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_decltype".}
+proc sqlite3_column_decltype16*(para1: Psqlite3_stmt, para2: int32): pointer{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_column_decltype16".}
+proc sqlite3_step*(para1: Psqlite3_stmt): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_step".}
+proc sqlite3_data_count*(pStmt: Psqlite3_stmt): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_data_count".}
+proc sqlite3_column_blob*(para1: Psqlite3_stmt, iCol: int32): pointer{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_blob".}
+proc sqlite3_column_bytes*(para1: Psqlite3_stmt, iCol: int32): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_bytes".}
+proc sqlite3_column_bytes16*(para1: Psqlite3_stmt, iCol: int32): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_bytes16".}
+proc sqlite3_column_double*(para1: Psqlite3_stmt, iCol: int32): float64{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_double".}
+proc sqlite3_column_int*(para1: Psqlite3_stmt, iCol: int32): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_int".}
+proc sqlite3_column_int64*(para1: Psqlite3_stmt, iCol: int32): sqlite_int64{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_column_int64".}
+proc sqlite3_column_text*(para1: Psqlite3_stmt, iCol: int32): cstring{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_text".}
+proc sqlite3_column_text16*(para1: Psqlite3_stmt, iCol: int32): pointer{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_text16".}
+proc sqlite3_column_type*(para1: Psqlite3_stmt, iCol: int32): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_column_type".}
+proc sqlite3_finalize*(pStmt: Psqlite3_stmt): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_finalize".}
+proc sqlite3_reset*(pStmt: Psqlite3_stmt): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_reset".}
+proc sqlite3_create_function*(para1: Psqlite3, zFunctionName: cstring, 
+                              nArg: int32, eTextRep: int32, para5: pointer, 
+                              xFunc: Tcreate_function_func_func, 
+                              xStep: Tcreate_function_step_func, 
+                              xFinal: Tcreate_function_final_func): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_create_function".}
+proc sqlite3_create_function16*(para1: Psqlite3, zFunctionName: pointer, 
+                                nArg: int32, eTextRep: int32, para5: pointer, 
+                                xFunc: Tcreate_function_func_func, 
+                                xStep: Tcreate_function_step_func, 
+                                xFinal: Tcreate_function_final_func): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_create_function16".}
+proc sqlite3_aggregate_count*(para1: Psqlite3_context): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_aggregate_count".}
+proc sqlite3_value_blob*(para1: Psqlite3_value): pointer{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_blob".}
+proc sqlite3_value_bytes*(para1: Psqlite3_value): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_bytes".}
+proc sqlite3_value_bytes16*(para1: Psqlite3_value): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_bytes16".}
+proc sqlite3_value_double*(para1: Psqlite3_value): float64{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_double".}
+proc sqlite3_value_int*(para1: Psqlite3_value): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_int".}
+proc sqlite3_value_int64*(para1: Psqlite3_value): sqlite_int64{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_int64".}
+proc sqlite3_value_text*(para1: Psqlite3_value): cstring{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_text".}
+proc sqlite3_value_text16*(para1: Psqlite3_value): pointer{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_text16".}
+proc sqlite3_value_text16le*(para1: Psqlite3_value): pointer{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_text16le".}
+proc sqlite3_value_text16be*(para1: Psqlite3_value): pointer{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_text16be".}
+proc sqlite3_value_type*(para1: Psqlite3_value): int32{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_value_type".}
+proc sqlite3_aggregate_context*(para1: Psqlite3_context, nBytes: int32): pointer{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_aggregate_context".}
+proc sqlite3_user_data*(para1: Psqlite3_context): pointer{.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_user_data".}
+proc sqlite3_get_auxdata*(para1: Psqlite3_context, para2: int32): pointer{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_get_auxdata".}
+proc sqlite3_set_auxdata*(para1: Psqlite3_context, para2: int32, para3: pointer, 
+                          para4: proc (para1: pointer) {.cdecl.}){.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_set_auxdata".}
+proc sqlite3_result_blob*(para1: Psqlite3_context, para2: pointer, para3: int32, 
+                          para4: Tsqlite3_result_func){.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_result_blob".}
+proc sqlite3_result_double*(para1: Psqlite3_context, para2: float64){.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_result_double".}
+proc sqlite3_result_error*(para1: Psqlite3_context, para2: cstring, para3: int32){.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_result_error".}
+proc sqlite3_result_error16*(para1: Psqlite3_context, para2: pointer, 
+                             para3: int32){.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_result_error16".}
+proc sqlite3_result_int*(para1: Psqlite3_context, para2: int32){.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_result_int".}
+proc sqlite3_result_int64*(para1: Psqlite3_context, para2: sqlite_int64){.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_result_int64".}
+proc sqlite3_result_null*(para1: Psqlite3_context){.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_result_null".}
+proc sqlite3_result_text*(para1: Psqlite3_context, para2: cstring, para3: int32, 
+                          para4: Tsqlite3_result_func){.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_result_text".}
+proc sqlite3_result_text16*(para1: Psqlite3_context, para2: pointer, 
+                            para3: int32, para4: Tsqlite3_result_func){.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_result_text16".}
+proc sqlite3_result_text16le*(para1: Psqlite3_context, para2: pointer, 
+                              para3: int32, para4: Tsqlite3_result_func){.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_result_text16le".}
+proc sqlite3_result_text16be*(para1: Psqlite3_context, para2: pointer, 
+                              para3: int32, para4: Tsqlite3_result_func){.cdecl, 
+    dynlib: Sqlite3Lib, importc: "sqlite3_result_text16be".}
+proc sqlite3_result_value*(para1: Psqlite3_context, para2: Psqlite3_value){.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_result_value".}
+proc sqlite3_create_collation*(para1: Psqlite3, zName: cstring, eTextRep: int32, 
+                               para4: pointer, 
+                               xCompare: Tsqlite3_create_collation_func): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_create_collation".}
+proc sqlite3_create_collation16*(para1: Psqlite3, zName: cstring, 
+                                 eTextRep: int32, para4: pointer, 
+                                 xCompare: Tsqlite3_create_collation_func): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_create_collation16".}
+proc sqlite3_collation_needed*(para1: Psqlite3, para2: pointer, 
+                               para3: Tsqlite3_collation_needed_func): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_collation_needed".}
+proc sqlite3_collation_needed16*(para1: Psqlite3, para2: pointer, 
+                                 para3: Tsqlite3_collation_needed_func): int32{.
+    cdecl, dynlib: Sqlite3Lib, importc: "sqlite3_collation_needed16".}
+proc sqlite3_libversion*(): cstring{.cdecl, dynlib: Sqlite3Lib, 
+                                     importc: "sqlite3_libversion".}
+  #Alias for allowing better code portability (win32 is not working with external variables) 
+proc sqlite3_version*(): cstring{.cdecl, dynlib: Sqlite3Lib, 
+                                  importc: "sqlite3_libversion".}
+  # Not published functions
+proc sqlite3_libversion_number*(): int32{.cdecl, dynlib: Sqlite3Lib, 
+    importc: "sqlite3_libversion_number".}
+  #function sqlite3_key(db:Psqlite3; pKey:pointer; nKey:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_key';
+  #function sqlite3_rekey(db:Psqlite3; pKey:pointer; nKey:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_rekey';
+  #function sqlite3_sleep(_para1:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_sleep';
+  #function sqlite3_expired(_para1:Psqlite3_stmt):longint;cdecl; external Sqlite3Lib name 'sqlite3_expired';
+  #function sqlite3_global_recover:longint;cdecl; external Sqlite3Lib name 'sqlite3_global_recover';
+# implementation
diff --git a/lib/base/terminal.nim b/lib/base/terminal.nim
new file mode 100644
index 000000000..42bd80cb4
--- /dev/null
+++ b/lib/base/terminal.nim
@@ -0,0 +1,310 @@
+#

+#

+#            Nimrod's Runtime Library

+#        (c) Copyright 2009 Andreas Rumpf

+#

+#    See the file "copying.txt", included in this

+#    distribution, for details about the copyright.

+#

+

+## This module contains a few procedures to control the *terminal* 

+## (also called *console*). On UNIX, the implementation simply uses ANSI escape 

+## sequences and does not depend on any other module, on Windows it uses the

+## Windows API.

+## Changing the style is permanent even after program termination! Use the

+## code ``system.addQuitProc(resetAttributes)`` to restore the defaults.

+

+when defined(windows):

+  import windows, os

+  

+  var 

+    conHandle: THandle

+  # = createFile("CONOUT$", GENERIC_WRITE, 0, nil, OPEN_ALWAYS, 0, 0)

+    

+  block:

+    var hTemp = GetStdHandle(STD_OUTPUT_HANDLE())

+    if DuplicateHandle(GetCurrentProcess(), hTemp, GetCurrentProcess(),

+                       addr(conHandle), 0, 1, DUPLICATE_SAME_ACCESS) == 0:

+      OSError()

+    

+  proc getCursorPos(): tuple [x,y: int] = 

+    var c: TCONSOLE_SCREEN_BUFFER_INFO

+    if GetConsoleScreenBufferInfo(conHandle, addr(c)) == 0: OSError()

+    return (int(c.dwCursorPosition.x), int(c.dwCursorPosition.y))

+    

+  proc getAttributes(): int16 = 

+    var c: TCONSOLE_SCREEN_BUFFER_INFO

+    # workaround Windows bugs: try several times

+    if GetConsoleScreenBufferInfo(conHandle, addr(c)) != 0: 

+      return c.wAttributes

+    else:

+      OSError()

+    return 0x70'i16 # ERROR: return white background, black text

+    

+  var

+    oldAttr = getAttributes()

+

+proc setCursorPos*(x, y: int) =

+  ## sets the terminal's cursor to the (x,y) position. (0,0) is the 

+  ## upper left of the screen. 

+  when defined(windows):

+    var c: TCoord

+    c.x = int16(x)

+    c.y = int16(y)

+    if SetConsoleCursorPosition(conHandle, c) == 0: OSError()

+  else:

+    stdout.write("\e[" & $y & ';' & $x & 'f')

+
+proc setCursorXPos*(x: int) =

+  ## sets the terminal's cursor to the x position. The y position is
+  ## not changed.

+  when defined(windows):

+    var scrbuf: TCONSOLE_SCREEN_BUFFER_INFO

+    var hStdout = conHandle

+    if GetConsoleScreenBufferInfo(hStdout, addr(scrbuf)) == 0: OSError()

+    var origin = scrbuf.dwCursorPosition

+    origin.x = int16(x)

+    if SetConsoleCursorPosition(conHandle, origin) == 0: OSError()
+  else:

+    stdout.write("\e[" & $x & 'G')

+
+when defined(windows):
+  proc setCursorYPos*(y: int) =

+    ## sets the terminal's cursor to the y position. The x position is
+    ## not changed. **Warning**: This is not supported on UNIX!

+    when defined(windows):

+      var scrbuf: TCONSOLE_SCREEN_BUFFER_INFO

+      var hStdout = conHandle

+      if GetConsoleScreenBufferInfo(hStdout, addr(scrbuf)) == 0: OSError()

+      var origin = scrbuf.dwCursorPosition

+      origin.y = int16(y)

+      if SetConsoleCursorPosition(conHandle, origin) == 0: OSError()
+    else:

+      nil

+

+proc CursorUp*(count=1) = 

+  ## Moves the cursor up by `count` rows.

+  when defined(windows):

+    var p = getCursorPos()

+    dec(p.y, count)

+    setCursorPos(p.x, p.y)

+  else:

+    stdout.write("\e[" & $count & 'A')

+

+proc CursorDown*(count=1) = 

+  ## Moves the cursor down by `count` rows.

+  when defined(windows):

+    var p = getCursorPos()

+    inc(p.y, count)

+    setCursorPos(p.x, p.y)

+  else:

+    stdout.write("\e[" & $count & 'B')

+

+proc CursorForward*(count=1) = 

+  ## Moves the cursor forward by `count` columns.

+  when defined(windows):

+    var p = getCursorPos()

+    inc(p.x, count)

+    setCursorPos(p.x, p.y)

+  else:

+    stdout.write("\e[" & $count & 'C')

+

+proc CursorBackward*(count=1) = 

+  ## Moves the cursor backward by `count` columns.

+  when defined(windows):

+    var p = getCursorPos()

+    dec(p.x, count)

+    setCursorPos(p.x, p.y)

+  else:

+    stdout.write("\e[" & $count & 'D')

+  

+when true:

+  nil

+else:

+  proc EraseLineEnd* =

+    ## Erases from the current cursor position to the end of the current line.

+    when defined(windows):

+      nil

+    else:

+      stdout.write("\e[K")

+  

+  proc EraseLineStart* =

+    ## Erases from the current cursor position to the start of the current line.

+    when defined(windows):

+      nil

+    else:

+      stdout.write("\e[1K")

+  

+  proc EraseDown* =

+    ## Erases the screen from the current line down to the bottom of the screen.

+    when defined(windows):

+      nil

+    else:

+      stdout.write("\e[J")

+  

+  proc EraseUp* =

+    ## Erases the screen from the current line up to the top of the screen.

+    when defined(windows):

+      nil

+    else:

+      stdout.write("\e[1J")

+  

+proc EraseLine* =

+  ## Erases the entire current line.

+  when defined(windows):

+    var scrbuf: TCONSOLE_SCREEN_BUFFER_INFO

+    var numwrote: DWORD

+    var hStdout = conHandle

+    if GetConsoleScreenBufferInfo(hStdout, addr(scrbuf)) == 0: OSError()

+    var origin = scrbuf.dwCursorPosition

+    origin.x = 0'i16

+    if SetConsoleCursorPosition(conHandle, origin) == 0: OSError()

+    var ht = scrbuf.dwSize.Y - origin.Y

+    var wt = scrbuf.dwSize.X - origin.X

+    if FillConsoleOutputCharacter(hStdout,' ', ht*wt, 

+                                  origin, addr(numwrote)) == 0:

+      OSError()

+    if FillConsoleOutputAttribute(hStdout, scrbuf.wAttributes, ht * wt,

+                                  scrbuf.dwCursorPosition, addr(numwrote)) == 0:

+      OSError()

+  else:

+    stdout.write("\e[2K")
+    setCursorXPos(0)

+

+proc EraseScreen* =

+  ## Erases the screen with the background colour and moves the cursor to home.

+  when defined(windows):

+    var scrbuf: TCONSOLE_SCREEN_BUFFER_INFO

+    var numwrote: DWORD

+    var origin: TCoord # is inititalized to 0, 0 

+    var hStdout = conHandle

+    if GetConsoleScreenBufferInfo(hStdout, addr(scrbuf)) == 0: OSError()

+    if FillConsoleOutputCharacter(hStdout, ' ', scrbuf.dwSize.X*scrbuf.dwSize.Y,

+                                  origin, addr(numwrote)) == 0:

+      OSError()

+    if FillConsoleOutputAttribute(hStdout, scrbuf.wAttributes,

+                                  scrbuf.dwSize.X * scrbuf.dwSize.Y, 

+                                  origin, addr(numwrote)) == 0:

+      OSError()

+    setCursorXPos(0)

+  else:

+    stdout.write("\e[2J")

+

+proc ResetAttributes* {.noconv.} = 

+  ## resets all attributes; it is advisable to register this as a quit proc

+  ## with ``system.addQuitProc(resetAttributes)``. 

+  when defined(windows):

+    discard SetConsoleTextAttribute(conHandle, oldAttr)

+  else:

+    stdout.write("\e[0m")

+

+type

+  TStyle* = enum         ## different styles for text output

+    styleBright = 1,     ## bright text

+    styleDim,            ## dim text

+    styleUnknown,        ## unknown

+    styleUnderscore = 4, ## underscored text

+    styleBlink,          ## blinking/bold text

+    styleReverse,        ## unknown

+    styleHidden          ## hidden text

+

+when not defined(windows):

+  var

+    gFG = 0

+    gBG = 0

+

+proc WriteStyled*(txt: string, style: set[TStyle] = {styleBright}) = 

+  ## writes the text `txt` in a given `style`.

+  when defined(windows):

+    var a = 0'i16

+    if styleBright in style: a = a or int16(FOREGROUND_INTENSITY)

+    if styleBlink in style: a = a or int16(BACKGROUND_INTENSITY)

+    if styleReverse in style: a = a or 0x4000'i16 # COMMON_LVB_REVERSE_VIDEO

+    if styleUnderscore in style: a = a or 0x8000'i16 # COMMON_LVB_UNDERSCORE

+    var old = getAttributes()

+    discard SetConsoleTextAttribute(conHandle, old or a)

+    stdout.write(txt)

+    discard SetConsoleTextAttribute(conHandle, old)

+  else:

+    for s in items(style):

+      stdout.write("\e[" & $ord(s) & 'm')

+    stdout.write(txt)

+    resetAttributes()

+    if gFG != 0: 

+      stdout.write("\e[" & $ord(gFG) & 'm')  

+    if gBG != 0:

+      stdout.write("\e[" & $ord(gBG) & 'm')

+

+type

+  TForegroundColor* = enum ## terminal's foreground colors

+    fgBlack = 30,          ## black

+    fgRed,                 ## red

+    fgGreen,               ## green

+    fgYellow,              ## yellow

+    fgBlue,                ## blue

+    fgMagenta,             ## magenta

+    fgCyan,                ## cyan

+    fgWhite                ## white

+

+  TBackgroundColor* = enum ## terminal's background colors

+    bgBlack = 40,          ## black

+    bgRed,                 ## red

+    bgGreen,               ## green

+    bgYellow,              ## yellow

+    bgBlue,                ## blue

+    bgMagenta,             ## magenta

+    bgCyan,                ## cyan

+    bgWhite                ## white

+  

+proc setForegroundColor*(fg: TForegroundColor, bright=false) = 

+  ## sets the terminal's foreground color

+  when defined(windows):

+    var old = getAttributes() and not 0x0007 

+    if bright: 

+      old = old or FOREGROUND_INTENSITY

+    const lookup: array [TForegroundColor, int] = [

+      0,

+      (FOREGROUND_RED),

+      (FOREGROUND_GREEN),

+      (FOREGROUND_RED or FOREGROUND_GREEN),

+      (FOREGROUND_BLUE),

+      (FOREGROUND_RED or FOREGROUND_BLUE),

+      (FOREGROUND_BLUE or FOREGROUND_GREEN),

+      (FOREGROUND_BLUE or FOREGROUND_GREEN or FOREGROUND_RED)]

+    discard SetConsoleTextAttribute(conHandle, toU16(old or lookup[fg]))

+  else:

+    gFG = ord(fg)

+    if bright: inc(gFG, 60)

+    stdout.write("\e[" & $gFG & 'm')

+

+proc setBackgroundColor*(bg: TBackgroundColor, bright=false) = 

+  ## sets the terminal's background color

+  when defined(windows):

+    var old = getAttributes() and not 0x0070

+    if bright: 

+      old = old or BACKGROUND_INTENSITY

+    const lookup: array [TBackgroundColor, int] = [

+      0,

+      (BACKGROUND_RED),

+      (BACKGROUND_GREEN),

+      (BACKGROUND_RED or BACKGROUND_GREEN),

+      (BACKGROUND_BLUE),

+      (BACKGROUND_RED or BACKGROUND_BLUE),

+      (BACKGROUND_BLUE or BACKGROUND_GREEN),

+      (BACKGROUND_BLUE or BACKGROUND_GREEN or BACKGROUND_RED)]

+    discard SetConsoleTextAttribute(conHandle, toU16(old or lookup[bg]))

+  else:

+    gBG = ord(bg)

+    if bright: inc(gBG, 60)

+    stdout.write("\e[" & $gBG & 'm')

+

+when isMainModule:

+  system.addQuitProc(resetAttributes)

+  write(stdout, "never mind")

+  eraseLine()

+  #setCursorPos(2, 2)

+  writeStyled("styled text ", {styleBright, styleBlink, styleUnderscore})

+  setBackGroundColor(bgCyan, true)

+  setForeGroundColor(fgBlue)

+  writeln(stdout, "ordinary text")

+

diff --git a/lib/base/web.nim b/lib/base/web.nim
new file mode 100644
index 000000000..83d1406af
--- /dev/null
+++ b/lib/base/web.nim
@@ -0,0 +1,57 @@
+#

+#

+#            Nimrod's Runtime Library

+#        (c) Copyright 2009 Andreas Rumpf

+#

+#    See the file "copying.txt", included in this

+#    distribution, for details about the copyright.

+#

+

+## This module contains simple high-level procedures for dealing with the
+## web. Use cases: 
+##
+## * requesting URLs
+## * sending and retrieving emails
+## * sending and retrieving files from an FTP server
+##
+## Currently only requesting URLs is implemented. The implementation depends
+## on the libcurl library!
+
+import libcurl, streams
+
+proc curlwrapperWrite(p: pointer, size, nmemb: int, 
+                      data: pointer): int {.cdecl.} = 
+  var stream = cast[PStream](data)
+  stream.writeData(stream, p, size*nmemb)
+  return size*nmemb
+
+proc URLretrieveStream*(url: string): PStream = 
+  ## retrieves the given `url` and returns a stream which one can read from to
+  ## obtain the contents. Returns nil if an error occurs.
+  result = newStringStream()
+  var hCurl = curl_easy_init() 
+  if hCurl == nil: return nil
+  if curl_easy_setopt(hCurl, CURLOPT_URL, url) != CURLE_OK: return nil
+  if curl_easy_setopt(hCurl, CURLOPT_WRITEFUNCTION, 
+                      curlwrapperWrite) != CURLE_OK: return nil
+  if curl_easy_setopt(hCurl, CURLOPT_WRITEDATA, result) != CURLE_OK: return nil
+  if curl_easy_perform(hCurl) != CURLE_OK: return nil
+  curl_easy_cleanup(hCurl)
+  
+proc URLretrieveString*(url: string): string = 
+  ## retrieves the given `url` and returns the contents. Returns nil if an
+  ## error occurs.
+  var stream = newStringStream()
+  var hCurl = curl_easy_init()
+  if hCurl == nil: return nil
+  if curl_easy_setopt(hCurl, CURLOPT_URL, url) != CURLE_OK: return nil
+  if curl_easy_setopt(hCurl, CURLOPT_WRITEFUNCTION, 
+                      curlwrapperWrite) != CURLE_OK: return nil
+  if curl_easy_setopt(hCurl, CURLOPT_WRITEDATA, stream) != CURLE_OK: return nil
+  if curl_easy_perform(hCurl) != CURLE_OK: return nil
+  curl_easy_cleanup(hCurl)
+  result = stream.data
+
+when isMainModule:
+  echo URLretrieveString("http://nimrod.ethexor.com/")
+
diff --git a/lib/parsexml.nim b/lib/parsexml.nim
new file mode 100644
index 000000000..81b6da1de
--- /dev/null
+++ b/lib/parsexml.nim
@@ -0,0 +1,621 @@
+#
+#
+#            Nimrod's Runtime Library
+#        (c) Copyright 2009 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## This module implements a simple high performance `XML`:idx: / `HTML`:idx:
+## parser. 
+## The only encoding that is supported is UTF-8. The parser has been designed
+## to be somewhat error correcting, so that even most "wild HTML" found on the 
+## web can be parsed with it. **Note:** This parser does not check that each
+## ``<tag>`` has a corresponding ``</tag>``! These checks have do be 
+## implemented by the client code for various reasons: 
+##
+## * Old HTML contains tags that have no end tag: ``<br>`` for example.
+## * HTML tags are case insensitive, XML tags are case sensitive. Since this
+##   library can parse both, only the client knows which comparison is to be
+##   used.
+## * Thus the checks would have been very difficult to implement properly with
+##   little benefit, especially since they are simple to implement in the 
+##   client. The client should use the `errorMsgExpected` proc to generate
+##   a nice error message that fits to the other error messages this library
+##   creates.
+##
+##
+## Example 1: Retrieve HTML title
+## ==============================
+##
+## The file ``examples/htmltitle.nim`` demonstrates how to use the 
+## XML parser to accomplish a simple task: To determine the title of an HTML
+## document.
+##
+## .. code-block:: nimrod
+##     :file: examples/htmltitle.nim
+##
+##
+## Example 2: Retrieve all HTML links
+## ==================================
+##
+## The file ``examples/htmlrefs.nim`` demonstrates how to use the 
+## XML parser to accomplish another simple task: To determine all the links 
+## an HTML document contains.
+##
+## .. code-block:: nimrod
+##     :file: examples/htmlrefs.nim
+##
+
+import 
+  hashes, strutils, lexbase, streams, unicode
+
+# the parser treats ``<br />`` as ``<br></br>``
+
+type 
+  TXmlEventKind* = enum ## enumation of all events that may occur when parsing
+    xmlError,           ## an error ocurred during parsing
+    xmlEof,             ## end of file reached
+    xmlCharData,        ## character data
+    xmlWhitespace,      ## whitespace has been parsed
+    xmlComment,         ## a comment has been parsed
+    xmlPI,              ## processing instruction (``<?name something ?>``)
+    xmlElementStart,    ## ``<elem>``
+    xmlElementEnd,      ## ``</elem>``
+    xmlElementOpen,     ## ``<elem 
+    xmlAttribute,       ## ``key = "value"`` pair
+    xmlElementClose,    ## ``>`` 
+    xmlCData,           ## ``<![CDATA[`` ... data ... ``]]>``
+    xmlEntity,          ## &entity;
+    xmlSpecial          ## ``<! ... data ... >``
+    
+  TXmlError* = enum          ## enumeration that lists all errors that can occur
+    errNone,                 ## no error
+    errEndOfCDataExpected,   ## ``]]>`` expected
+    errNameExpected,         ## name expected
+    errSemicolonExpected,    ## ``;`` expected
+    errQmGtExpected,         ## ``?>`` expected
+    errGtExpected,           ## ``>`` expected
+    errEqExpected,           ## ``=`` expected
+    errQuoteExpected,        ## ``"`` or ``'`` expected
+    errEndOfCommentExpected  ## ``-->`` expected
+    
+  TParserState = enum 
+    stateStart, stateNormal, stateAttr, stateEmptyElementTag, stateError
+
+  TXmlParseOption* = enum  ## options for the XML parser
+    reportWhitespace,      ## report whitespace
+    reportComments         ## report comments
+
+  TXmlParser* = object of TBaseLexer ## the parser object.
+    a, b: string
+    kind: TXmlEventKind
+    err: TXmlError
+    state: TParserState
+    filename: string
+    options: set[TXmlParseOption]
+ 
+const
+  errorMessages: array [TXmlError, string] = [
+    "no error",
+    "']]>' expected",
+    "name expected",
+    "';' expected",
+    "'?>' expected",
+    "'>' expected",
+    "'=' expected",
+    "'\"' or \"'\" expected",
+    "'-->' expected"
+  ]
+
+proc open*(my: var TXmlParser, input: PStream, filename: string,
+           options: set[TXmlParseOption] = {}) =
+  ## initializes the parser with an input stream. `Filename` is only used
+  ## for nice error messages. The parser's behaviour can be controlled by
+  ## the `options` parameter: If `options` contains ``reportWhitespace``
+  ## a whitespace token is reported as an ``xmlWhitespace`` event.
+  ## If `options` contains ``reportComments`` a comment token is reported as an
+  ## ``xmlComment`` event. 
+  lexbase.open(my, input)
+  my.filename = filename
+  my.state = stateStart
+  my.kind = xmlError
+  my.a = ""
+  my.b = ""
+  my.options = options
+  
+proc close*(my: var TXmlParser) {.inline.} = 
+  ## closes the parser `my` and its associated input stream.
+  lexbase.close(my)
+
+proc charData*(my: TXmlParser): string {.inline.} = 
+  ## returns the character data for the events: ``xmlCharData``, 
+  ## ``xmlWhitespace``, ``xmlComment``, ``xmlCData``, ``xmlSpecial``
+  assert(my.kind in {xmlCharData, xmlWhitespace, xmlComment, xmlCData, 
+                     xmlSpecial})
+  return my.a
+
+proc kind*(my: TXmlParser): TXmlEventKind {.inline.} = 
+  ## returns the current event type for the XML parser
+  return my.kind
+
+proc elementName*(my: TXmlParser): string {.inline.} = 
+  ## returns the element name for the events: ``xmlElementStart``, 
+  ## ``xmlElementEnd``, ``xmlElementOpen``
+  assert(my.kind in {xmlElementStart, xmlElementEnd, xmlElementOpen})
+  return my.a
+
+proc entityName*(my: TXmlParser): string {.inline.} = 
+  ## returns the entity name for the event: ``xmlEntity``
+  assert(my.kind == xmlEntity)
+  return my.a
+  
+proc attrKey*(my: TXmlParser): string {.inline.} = 
+  ## returns the attribute key for the event ``xmlAttribute``
+  assert(my.kind == xmlAttribute)
+  return my.a
+  
+proc attrValue*(my: TXmlParser): string {.inline.} = 
+  ## returns the attribute value for the event ``xmlAttribute``
+  assert(my.kind == xmlAttribute)
+  return my.b
+
+proc PIName*(my: TXmlParser): string {.inline.} = 
+  ## returns the processing instruction name for the event ``xmlPI``
+  assert(my.kind == xmlPI)
+  return my.a
+
+proc PIRest*(my: TXmlParser): string {.inline.} = 
+  ## returns the rest of the processing instruction for the event ``xmlPI``
+  assert(my.kind == xmlPI)
+  return my.b
+
+proc getColumn*(my: TXmlParser): int {.inline.} = 
+  ## get the current column the parser has arrived at.
+  result = getColNumber(my, my.bufPos)
+
+proc getLine*(my: TXmlParser): int {.inline.} = 
+  ## get the current line the parser has arrived at.
+  result = my.linenumber
+
+proc getFilename*(my: TXmlParser): string {.inline.} = 
+  ## get the filename of the file that the parser processes.
+  result = my.filename
+  
+proc errorMsg*(my: TXmlParser): string = 
+  ## returns a helpful error message for the event ``xmlError``
+  assert(my.kind == xmlError)
+  result = "$1($2, $3) Error: $4" % [
+    my.filename, $getLine(my), $getColumn(my), errorMessages[my.err]]
+
+proc errorMsgExpected*(my: TXmlParser, tag: string): string = 
+  ## returns an error message "<tag> expected" in the same format as the
+  ## other error messages 
+  result = "$1($2, $3) Error: $4" % [
+    my.filename, $getLine(my), $getColumn(my), "<$1> expected" % tag]
+    
+proc markError(my: var TXmlParser, kind: TXmlError) {.inline.} = 
+  my.err = kind
+  my.state = stateError
+
+proc parseCDATA(my: var TXMLParser) = 
+  var pos = my.bufpos + len("<![CDATA[")
+  var buf = my.buf
+  while true:
+    case buf[pos] 
+    of ']':
+      if buf[pos+1] == ']' and buf[pos+2] == '>':
+        inc(pos, 3)
+        break
+      add(my.a, ']')
+      inc(pos)
+    of '\0': 
+      markError(my, errEndOfCDataExpected)
+      break
+    of '\c': 
+      pos = lexbase.HandleCR(my, pos)
+      add(my.a, '\L')
+    of '\L': 
+      pos = lexbase.HandleLF(my, pos)
+      add(my.a, '\L')
+    else:
+      add(my.a, buf[pos])
+      inc(pos)    
+  my.bufpos = pos # store back
+  my.kind = xmlCDATA
+
+proc parseComment(my: var TXMLParser) = 
+  var pos = my.bufpos + len("<!--")
+  var buf = my.buf
+  while true:
+    case buf[pos] 
+    of '-':
+      if buf[pos+1] == '-' and buf[pos+2] == '>':
+        inc(pos, 3)
+        break
+      if my.options.contains(reportComments): add(my.a, '-')
+      inc(pos)
+    of '\0': 
+      markError(my, errEndOfCommentExpected)
+      break
+    of '\c': 
+      pos = lexbase.HandleCR(my, pos)
+      if my.options.contains(reportComments): add(my.a, '\L')
+    of '\L': 
+      pos = lexbase.HandleLF(my, pos)
+      if my.options.contains(reportComments): add(my.a, '\L')
+    else:
+      if my.options.contains(reportComments): add(my.a, buf[pos])
+      inc(pos)
+  my.bufpos = pos
+  my.kind = xmlComment
+
+proc parseWhitespace(my: var TXmlParser, skip=False) = 
+  var pos = my.bufpos
+  var buf = my.buf
+  while true: 
+    case buf[pos]
+    of ' ', '\t': 
+      if not skip: add(my.a, buf[pos])
+      Inc(pos)
+    of '\c':  
+      # the specification says that CR-LF, CR are to be transformed to LF
+      pos = lexbase.HandleCR(my, pos)
+      if not skip: add(my.a, '\L')
+    of '\L': 
+      pos = lexbase.HandleLF(my, pos)
+      if not skip: add(my.a, '\L')
+    else:
+      break
+  my.bufpos = pos
+
+const
+  NameStartChar = {'A'..'Z', 'a'..'z', '_', ':', '\128'..'\255'}
+  NameChar = {'A'..'Z', 'a'..'z', '0'..'9', '.', '-', '_', ':', '\128'..'\255'}
+
+proc parseName(my: var TXmlParser, dest: var string) = 
+  var pos = my.bufpos
+  var buf = my.buf
+  if buf[pos] in nameStartChar: 
+    while true:
+      add(dest, buf[pos])
+      inc(pos)
+      if buf[pos] notin NameChar: break
+    my.bufpos = pos
+  else:
+    markError(my, errNameExpected)
+
+proc parseEntity(my: var TXmlParser, dest: var string) = 
+  var pos = my.bufpos+1
+  var buf = my.buf
+  my.kind = xmlCharData
+  if buf[pos] == '#':
+    var r: TRune
+    inc(pos)
+    if buf[pos] == 'x': 
+      inc(pos)
+      while true:
+        case buf[pos]
+        of '0'..'9': r = (r shl 4) or (ord(buf[pos]) - ord('0'))
+        of 'a'..'f': r = (r shl 4) or (ord(buf[pos]) - ord('a') + 10)
+        of 'A'..'F': r = (r shl 4) or (ord(buf[pos]) - ord('A') + 10)
+        else: break
+        inc(pos)
+    else:
+      while buf[pos] in {'0'..'9'}: 
+        r = r * 10 + (ord(buf[pos]) - ord('0'))
+        inc(pos)
+    add(dest, toUTF8(r))
+  elif buf[pos] == 'l' and buf[pos+1] == 't':
+    add(dest, '<')
+    inc(pos, 2)
+  elif buf[pos] == 'g' and buf[pos+1] == 't':
+    add(dest, '>')
+    inc(pos, 2)
+  elif buf[pos] == 'a' and buf[pos+1] == 'm' and buf[pos+2] == 'p':
+    add(dest, '&')
+    inc(pos, 3)
+  elif buf[pos] == 'a' and buf[pos+1] == 'p' and buf[pos+2] == 'o' and 
+      buf[pos+3] == 's':
+    add(dest, '\'')
+    inc(pos, 4)
+  elif buf[pos] == 'q' and buf[pos+1] == 'u' and buf[pos+2] == 'o' and 
+      buf[pos+3] == 't':
+    add(dest, '"')
+    inc(pos, 4)
+  else:
+    my.bufpos = pos
+    parseName(my, dest)
+    pos = my.bufpos
+    if my.err != errNameExpected: 
+      my.kind = xmlEntity
+    else:
+      add(dest, '&')
+  if buf[pos] == ';': 
+    inc(pos)
+  else:
+    markError(my, errSemiColonExpected)
+  my.bufpos = pos
+
+proc parsePI(my: var TXmlParser) = 
+  inc(my.bufpos, "<?".len)
+  parseName(my, my.a)
+  var pos = my.bufpos
+  var buf = my.buf
+  setLen(my.b, 0)
+  while true: 
+    case buf[pos]
+    of '\0':
+      markError(my, errQmGtExpected)
+      break
+    of '?':
+      if buf[pos+1] == '>':
+        inc(pos, 2)
+        break
+      add(my.b, '?')
+      inc(pos)
+    of '\c':  
+      # the specification says that CR-LF, CR are to be transformed to LF
+      pos = lexbase.HandleCR(my, pos)
+      add(my.b, '\L')
+    of '\L': 
+      pos = lexbase.HandleLF(my, pos)
+      add(my.b, '\L')
+    else:
+      add(my.b, buf[pos])
+      inc(pos)
+  my.bufpos = pos
+  my.kind = xmlPI
+
+proc parseSpecial(my: var TXmlParser) = 
+  # things that start with <!
+  var pos = my.bufpos + 2
+  var buf = my.buf
+  var opentags = 0
+  while true: 
+    case buf[pos]
+    of '\0':
+      markError(my, errGtExpected)
+      break
+    of '<': 
+      inc(opentags)
+      inc(pos)
+      add(my.a, '<')
+    of '>':
+      if opentags <= 0:
+        inc(pos)
+        break
+      dec(opentags)
+      inc(pos)
+      add(my.a, '>')
+    of '\c':  
+      pos = lexbase.HandleCR(my, pos)
+      add(my.a, '\L')
+    of '\L': 
+      pos = lexbase.HandleLF(my, pos)
+      add(my.a, '\L')
+    else:
+      add(my.a, buf[pos])
+      inc(pos)
+  my.bufpos = pos
+  my.kind = xmlSpecial
+
+proc parseTag(my: var TXmlParser) = 
+  inc(my.bufpos)
+  parseName(my, my.a)
+  # if we have no name, do not interpret the '<':
+  if my.a.len == 0: 
+    my.kind = xmlCharData
+    add(my.a, '<')
+    return
+  parseWhitespace(my, skip=True)
+  if my.buf[my.bufpos] in NameStartChar: 
+    # an attribute follows:
+    my.kind = xmlElementOpen
+    my.state = stateAttr
+  else:
+    my.kind = xmlElementStart
+    if my.buf[my.bufpos] == '/' and my.buf[my.bufpos+1] == '>':
+      inc(my.bufpos, 2)
+      my.state = stateEmptyElementTag
+    elif my.buf[my.bufpos] == '>':
+      inc(my.bufpos)  
+    else:
+      markError(my, errGtExpected)
+  
+proc parseEndTag(my: var TXmlParser) = 
+  inc(my.bufpos, 2)
+  parseName(my, my.a)
+  parseWhitespace(my, skip=True)
+  if my.buf[my.bufpos] == '>':
+    inc(my.bufpos)
+  else:
+    markError(my, errGtExpected)
+  my.kind = xmlElementEnd
+
+proc parseAttribute(my: var TXmlParser) = 
+  my.kind = xmlAttribute
+  setLen(my.a, 0)
+  setLen(my.b, 0)
+  parseName(my, my.a)
+  # if we have no name, we have '<tag attr= key %&$$%':
+  if my.a.len == 0: 
+    markError(my, errGtExpected)
+    return
+  parseWhitespace(my, skip=True)
+  if my.buf[my.bufpos] != '=':
+    markError(my, errEqExpected)
+    return
+  inc(my.bufpos)
+  parseWhitespace(my, skip=True)
+
+  var pos = my.bufpos
+  var buf = my.buf
+  if buf[pos] in {'\'', '"'}:
+    var quote = buf[pos]
+    var pendingSpace = false
+    inc(pos)
+    while true: 
+      case buf[pos]
+      of '\0':
+        markError(my, errQuoteExpected)
+        break
+      of '&': 
+        if pendingSpace: 
+          add(my.b, ' ')
+          pendingSpace = false
+        my.bufpos = pos
+        parseEntity(my, my.b)
+        my.kind = xmlAttribute # parseEntity overwrites my.kind!
+        pos = my.bufpos
+      of ' ', '\t': 
+        pendingSpace = true
+        inc(pos)
+      of '\c':  
+        pos = lexbase.HandleCR(my, pos)
+        pendingSpace = true
+      of '\L': 
+        pos = lexbase.HandleLF(my, pos)
+        pendingSpace = true
+      else:
+        if buf[pos] == quote:
+          inc(pos)
+          break
+        else:
+          if pendingSpace: 
+            add(my.b, ' ')
+            pendingSpace = false
+          add(my.b, buf[pos])
+          inc(pos)
+  else:
+    markError(my, errQuoteExpected)  
+  my.bufpos = pos
+  parseWhitespace(my, skip=True)
+  
+proc parseCharData(my: var TXmlParser) = 
+  var pos = my.bufpos
+  var buf = my.buf
+  while true: 
+    case buf[pos]
+    of '\0', '<', '&': break
+    of '\c':  
+      # the specification says that CR-LF, CR are to be transformed to LF
+      pos = lexbase.HandleCR(my, pos)
+      add(my.a, '\L')
+    of '\L': 
+      pos = lexbase.HandleLF(my, pos)
+      add(my.a, '\L')
+    else:
+      add(my.a, buf[pos])
+      inc(pos)
+  my.bufpos = pos
+  my.kind = xmlCharData
+
+proc rawGetTok(my: var TXmlParser) = 
+  my.kind = xmlError
+  setLen(my.a, 0)
+  var pos = my.bufpos
+  var buf = my.buf
+  case buf[pos]
+  of '<': 
+    case buf[pos+1]
+    of '/':
+      parseEndTag(my)
+    of '!':
+      if buf[pos+2] == '[' and buf[pos+3] == 'C' and buf[pos+4] == 'D' and
+          buf[pos+5] == 'A' and buf[pos+6] == 'T' and buf[pos+7] == 'A' and
+          buf[pos+8] == '[':
+        parseCDATA(my)
+      elif buf[pos+2] == '-' and buf[pos+3] == '-': 
+        parseComment(my)
+      else: 
+        parseSpecial(my)
+    of '?':
+      parsePI(my)
+    else: 
+      parseTag(my)
+  of ' ', '\t', '\c', '\l': 
+    parseWhiteSpace(my)
+    my.kind = xmlWhitespace
+  of '\0': 
+    my.kind = xmlEof
+  of '&':
+    parseEntity(my, my.a)
+  else: 
+    parseCharData(my)
+  assert my.kind != xmlError
+    
+proc getTok(my: var TXmlParser) = 
+  while true:
+    rawGetTok(my)
+    case my.kind
+    of xmlComment: 
+      if my.options.contains(reportComments): break
+    of xmlWhitespace: 
+      if my.options.contains(reportWhitespace): break
+    else: break
+    
+proc next*(my: var TXmlParser) = 
+  ## retrieves the first/next event. This controls the parser.
+  case my.state
+  of stateNormal:
+    getTok(my)  
+  of stateStart:
+    getTok(my)
+    if my.kind == xmlPI and my.a == "xml": 
+      # just skip the first ``<?xml >`` processing instruction
+      getTok(my)
+    my.state = stateNormal
+  of stateAttr:
+    # parse an attribute key-value pair:
+    if my.buf[my.bufpos] == '>':
+      my.kind = xmlElementClose
+      inc(my.bufpos)
+      my.state = stateNormal
+    elif my.buf[my.bufpos] == '/' and my.buf[my.bufpos+1] == '>': 
+      my.kind = xmlElementClose
+      inc(my.bufpos, 2)
+      my.state = stateEmptyElementTag
+    else:
+      parseAttribute(my)
+      # state remains the same
+  of stateEmptyElementTag:
+    my.state = stateNormal
+    my.kind = xmlElementEnd
+  of stateError: 
+    my.kind = xmlError
+    my.state = stateNormal
+  
+when isMainModule:
+  import os
+  var s = newFileStream(ParamStr(1), fmRead)
+  if s == nil: quit("cannot open the file" & ParamStr(1))
+  var x: TXmlParser
+  open(x, s, ParamStr(1))
+  while true:
+    next(x)
+    case x.kind
+    of xmlError: Echo(x.errorMsg())
+    of xmlEof: break
+    of xmlCharData: echo(x.charData)
+    of xmlWhitespace: echo("|$1|" % x.charData)
+    of xmlComment: echo("<!-- $1 -->" % x.charData)
+    of xmlPI: echo("<? $1 ## $2 ?>" % [x.PIName, x.PIRest])
+    of xmlElementStart: echo("<$1>" % x.elementName)
+    of xmlElementEnd: echo("</$1>" % x.elementName)
+    
+    of xmlElementOpen: echo("<$1" % x.elementName) 
+    of xmlAttribute:   
+      echo("Key: " & x.attrKey)
+      echo("Value: " & x.attrValue)
+    
+    of xmlElementClose: echo(">") 
+    of xmlCData:
+      echo("<![CDATA[$1]]>" % x.charData)
+    of xmlEntity:
+      echo("&$1;" % x.entityName)
+    of xmlSpecial:
+      echo("SPECIAL: " & x.charData)
+  close(x)
+
diff --git a/lib/posix/detect.nim b/lib/posix/detect.nim
new file mode 100644
index 000000000..d92269707
--- /dev/null
+++ b/lib/posix/detect.nim
@@ -0,0 +1,824 @@
+# Posix detect program
+# (c) 2009 Andreas Rumpf
+
+# This program produces a C program that produces a Nimrod include file.
+# The Nimrod include file lists the values of each POSIX constant.
+# This is needed because POSIX is brain-dead: It only cares for C, any other
+# language is ignored. It would have been easier had they specified the
+# concrete values of the constants. Sigh.
+
+import os, strutils
+
+const
+  cc = "gcc -o $1 $1.c"
+
+  cfile = """
+/* Generated by detect.nim */
+
+#include <stdlib.h>
+#include <stdio.h>
+$1
+
+int main() {
+  FILE* f;
+  f = fopen("$3_$4_consts.nim", "w+");
+  fputs("# Generated by detect.nim\nconst\n", f);
+  $2
+  fclose(f);
+}
+"""
+
+type
+  TTypeKind = enum 
+    cint, cshort, clong, cstring, pointer
+
+var
+  hd = ""
+  tl = ""
+
+proc myExec(cmd: string): bool = 
+  return executeShellCommand(cmd) == 0
+
+proc header(s: string): bool = 
+  const testh = "testh"
+  var f: TFile
+  if openFile(f, appendFileExt(testh, "c"), fmWrite):
+    f.write("#include $1\n" % s)
+    f.write("int main() { return 0; }\n")
+    closeFile(f)
+    result = myExec(cc % testh)
+    removeFile(appendFileExt(testh, "c"))
+  if result:
+    addf(hd, "#include $1\n", s)
+    echo("Found: ", s)
+  else:
+    echo("Not found: ", s)
+
+proc main = 
+  const gen = "genconsts"
+  var f: TFile
+  if openFile(f, appendFileExt(gen, "c"), fmWrite): 
+    f.write(cfile % [hd, tl, system.hostOS, system.hostCPU])
+    closeFile(f)
+  if not myExec(cc % gen): quit(1)
+  if not myExec("./" & gen): quit(1)
+  removeFile(appendFileExt(gen, "c"))
+  echo("Success")
+
+proc v(name: string, typ: TTypeKind=cint) = 
+  var n = if name[0] == '_': copy(name, 1) else: name
+  var t = $typ
+  case typ
+  of pointer: 
+    addf(tl, 
+      "#ifdef $3\n  fprintf(f, \"  $1* = cast[$2](%p)\\n\", $3);\n#endif\n", 
+      n, t, name)
+  
+  of cstring:
+    addf(tl, 
+      "#ifdef $3\n  fprintf(f, \"  $1* = $2(\\\"%s\\\")\\n\", $3);\n#endif\n",
+      n, t, name)
+  of clong:
+    addf(tl, 
+      "#ifdef $3\n  fprintf(f, \"  $1* = $2(%ld)\\n\", $3);\n#endif\n", 
+      n, t, name)  
+  else:  
+    addf(tl, 
+      "#ifdef $3\n  fprintf(f, \"  $1* = $2(%d)\\n\", $3);\n#endif\n", 
+      n, t, name)
+
+if header("<aio.h>"):
+  v("AIO_ALLDONE")
+  v("AIO_CANCELED")
+  v("AIO_NOTCANCELED")
+  v("LIO_NOP")
+  v("LIO_NOWAIT")
+  v("LIO_READ")
+  v("LIO_WAIT")
+  v("LIO_WRITE")
+
+if header("<dlfcn.h>"):
+  v("RTLD_LAZY")
+  v("RTLD_NOW")

+  v("RTLD_GLOBAL")

+  v("RTLD_LOCAL")

+
+if header("<errno.h>"):

+  v("E2BIG")

+  v("EACCES")

+  v("EADDRINUSE")

+  v("EADDRNOTAVAIL")

+  v("EAFNOSUPPORT")

+  v("EAGAIN")

+  v("EALREADY")

+  v("EBADF")

+  v("EBADMSG")

+  v("EBUSY")

+  v("ECANCELED")

+  v("ECHILD")

+  v("ECONNABORTED")

+  v("ECONNREFUSED")

+  v("ECONNRESET")

+  v("EDEADLK")

+  v("EDESTADDRREQ")

+  v("EDOM")

+  v("EDQUOT")

+  v("EEXIST")

+  v("EFAULT")

+  v("EFBIG")

+  v("EHOSTUNREACH")

+  v("EIDRM")

+  v("EILSEQ")

+  v("EINPROGRESS")

+  v("EINTR")

+  v("EINVAL")

+  v("EIO")

+  v("EISCONN")

+  v("EISDIR")

+  v("ELOOP")

+  v("EMFILE")

+  v("EMLINK")

+  v("EMSGSIZE")

+  v("EMULTIHOP")

+  v("ENAMETOOLONG")

+  v("ENETDOWN")

+  v("ENETRESET")

+  v("ENETUNREACH")

+  v("ENFILE")

+  v("ENOBUFS")

+  v("ENODATA")

+  v("ENODEV")

+  v("ENOENT")

+  v("ENOEXEC")

+  v("ENOLCK")

+  v("ENOLINK")

+  v("ENOMEM")

+  v("ENOMSG")

+  v("ENOPROTOOPT")

+  v("ENOSPC")

+  v("ENOSR")

+  v("ENOSTR")

+  v("ENOSYS")

+  v("ENOTCONN")

+  v("ENOTDIR")

+  v("ENOTEMPTY")

+  v("ENOTSOCK")

+  v("ENOTSUP")

+  v("ENOTTY")

+  v("ENXIO")

+  v("EOPNOTSUPP")

+  v("EOVERFLOW")

+  v("EPERM")

+  v("EPIPE")

+  v("EPROTO")

+  v("EPROTONOSUPPORT")

+  v("EPROTOTYPE")

+  v("ERANGE")

+  v("EROFS")

+  v("ESPIPE")

+  v("ESRCH")

+  v("ESTALE")

+  v("ETIME")

+  v("ETIMEDOUT")

+  v("ETXTBSY")

+  v("EWOULDBLOCK")

+  v("EXDEV")

+  
+if header("<fcntl.h>"):
+  v("F_DUPFD")

+  v("F_GETFD")

+  v("F_SETFD")

+  v("F_GETFL")

+  v("F_SETFL")

+  v("F_GETLK")

+  v("F_SETLK")

+  v("F_SETLKW")

+  v("F_GETOWN")

+  v("F_SETOWN")

+  v("FD_CLOEXEC")

+  v("F_RDLCK")

+  v("F_UNLCK")

+  v("F_WRLCK")

+  v("O_CREAT")

+  v("O_EXCL")

+  v("O_NOCTTY")

+  v("O_TRUNC")

+  v("O_APPEND")

+  v("O_DSYNC")

+  v("O_NONBLOCK")

+  v("O_RSYNC")

+  v("O_SYNC")

+  v("O_ACCMODE")

+  v("O_RDONLY")

+  v("O_RDWR")

+  v("O_WRONLY")

+  v("POSIX_FADV_NORMAL")

+  v("POSIX_FADV_SEQUENTIAL")

+  v("POSIX_FADV_RANDOM")

+  v("POSIX_FADV_WILLNEED")

+  v("POSIX_FADV_DONTNEED")

+  v("POSIX_FADV_NOREUSE")

+
+if header("<fenv.h>"):

+  v("FE_DIVBYZERO")

+  v("FE_INEXACT")

+  v("FE_INVALID")

+  v("FE_OVERFLOW")

+  v("FE_UNDERFLOW")

+  v("FE_ALL_EXCEPT")

+  v("FE_DOWNWARD")

+  v("FE_TONEAREST")

+  v("FE_TOWARDZERO")

+  v("FE_UPWARD")

+  v("FE_DFL_ENV", pointer)

+
+if header("<fmtmsg.h>"):

+  v("MM_HARD")

+  v("MM_SOFT")

+  v("MM_FIRM")

+  v("MM_APPL")

+  v("MM_UTIL")

+  v("MM_OPSYS")

+  v("MM_RECOVER")

+  v("MM_NRECOV")

+  v("MM_HALT")

+  v("MM_ERROR")

+  v("MM_WARNING")

+  v("MM_INFO")

+  v("MM_NOSEV")

+  v("MM_PRINT")

+  v("MM_CONSOLE")

+  v("MM_OK")

+  v("MM_NOTOK")

+  v("MM_NOMSG")

+  v("MM_NOCON")

+
+if header("<fnmatch.h>"):

+  v("FNM_NOMATCH")

+  v("FNM_PATHNAME")

+  v("FNM_PERIOD")

+  v("FNM_NOESCAPE")

+  v("FNM_NOSYS")

+
+if header("<ftw.h>"):

+  v("FTW_F")

+  v("FTW_D")

+  v("FTW_DNR")

+  v("FTW_DP")

+  v("FTW_NS")

+  v("FTW_SL")

+  v("FTW_SLN")

+  v("FTW_PHYS")

+  v("FTW_MOUNT")

+  v("FTW_DEPTH")

+  v("FTW_CHDIR")

+
+if header("<glob.h>"):
+  v("GLOB_APPEND")

+  v("GLOB_DOOFFS")

+  v("GLOB_ERR")

+  v("GLOB_MARK")

+  v("GLOB_NOCHECK")

+  v("GLOB_NOESCAPE")

+  v("GLOB_NOSORT")

+  v("GLOB_ABORTED")

+  v("GLOB_NOMATCH")

+  v("GLOB_NOSPACE")

+  v("GLOB_NOSYS")

+

+if header("<langinfo.h>"):
+  v("CODESET")

+  v("D_T_FMT")

+  v("D_FMT")

+  v("T_FMT")

+  v("T_FMT_AMPM")

+  v("AM_STR")

+  v("PM_STR")

+  v("DAY_1")

+  v("DAY_2")

+  v("DAY_3")

+  v("DAY_4")

+  v("DAY_5")

+  v("DAY_6")

+  v("DAY_7")

+  v("ABDAY_1")

+  v("ABDAY_2")

+  v("ABDAY_3")

+  v("ABDAY_4")

+  v("ABDAY_5")

+  v("ABDAY_6")

+  v("ABDAY_7")

+  v("MON_1")

+  v("MON_2")

+  v("MON_3")

+  v("MON_4")

+  v("MON_5")

+  v("MON_6")

+  v("MON_7")

+  v("MON_8")

+  v("MON_9")

+  v("MON_10")

+  v("MON_11")

+  v("MON_12")

+  v("ABMON_1")

+  v("ABMON_2")

+  v("ABMON_3")

+  v("ABMON_4")

+  v("ABMON_5")

+  v("ABMON_6")

+  v("ABMON_7")

+  v("ABMON_8")

+  v("ABMON_9")

+  v("ABMON_10")

+  v("ABMON_11")

+  v("ABMON_12")

+  v("ERA")

+  v("ERA_D_FMT")

+  v("ERA_D_T_FMT")

+  v("ERA_T_FMT")

+  v("ALT_DIGITS")

+  v("RADIXCHAR")

+  v("THOUSEP")

+  v("YESEXPR")

+  v("NOEXPR")

+  v("CRNCYSTR")

+    
+if header("<locale.h>"):

+  v("LC_ALL") #{.importc, header: .}: cint

+  v("LC_COLLATE") #{.importc, header: "<locale.h>".}: cint

+  v("LC_CTYPE") #{.importc, header: "<locale.h>".}: cint

+  v("LC_MESSAGES") #{.importc, header: "<locale.h>".}: cint

+  v("LC_MONETARY") #{.importc, header: "<locale.h>".}: cint

+  v("LC_NUMERIC") #{.importc, header: "<locale.h>".}: cint

+  v("LC_TIME") #{.importc, header: "<locale.h>".}: cint

+
+if header("<pthread.h>"):

+  v("PTHREAD_BARRIER_SERIAL_THREAD")

+  v("PTHREAD_CANCEL_ASYNCHRONOUS") 

+  v("PTHREAD_CANCEL_ENABLE") 

+  v("PTHREAD_CANCEL_DEFERRED")

+  v("PTHREAD_CANCEL_DISABLE") 

+  #v("PTHREAD_CANCELED")

+  #v("PTHREAD_COND_INITIALIZER") 

+  v("PTHREAD_CREATE_DETACHED")

+  v("PTHREAD_CREATE_JOINABLE")

+  v("PTHREAD_EXPLICIT_SCHED")

+  v("PTHREAD_INHERIT_SCHED") 

+  v("PTHREAD_MUTEX_DEFAULT") 

+  v("PTHREAD_MUTEX_ERRORCHECK")

+  #v("PTHREAD_MUTEX_INITIALIZER") 

+  v("PTHREAD_MUTEX_NORMAL") 

+  v("PTHREAD_MUTEX_RECURSIVE") #{.importc, header: "<pthread.h>".}: cint

+  v("PTHREAD_ONCE_INIT") #{.importc, header: "<pthread.h>".}: cint

+  v("PTHREAD_PRIO_INHERIT") #{.importc, header: "<pthread.h>".}: cint

+  v("PTHREAD_PRIO_NONE") #{.importc, header: "<pthread.h>".}: cint

+  v("PTHREAD_PRIO_PROTECT") #{.importc, header: "<pthread.h>".}: cint

+  v("PTHREAD_PROCESS_SHARED") #{.importc, header: "<pthread.h>".}: cint

+  v("PTHREAD_PROCESS_PRIVATE") #{.importc, header: "<pthread.h>".}: cint

+  v("PTHREAD_SCOPE_PROCESS") #{.importc, header: "<pthread.h>".}: cint

+  v("PTHREAD_SCOPE_SYSTEM") #{.importc, header: "<pthread.h>".}: cint

+
+if header("<unistd.h>"):

+  v("_POSIX_ASYNC_IO")

+  v("_POSIX_PRIO_IO")

+  v("_POSIX_SYNC_IO")

+  v("F_OK")

+  v("R_OK")

+  v("W_OK")

+  v("X_OK")

+

+  v("_CS_PATH")

+  v("_CS_POSIX_V6_ILP32_OFF32_CFLAGS") 

+  v("_CS_POSIX_V6_ILP32_OFF32_LDFLAGS") 

+  v("_CS_POSIX_V6_ILP32_OFF32_LIBS") 

+  v("_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS") 

+  v("_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS") 

+  v("_CS_POSIX_V6_ILP32_OFFBIG_LIBS") 

+  v("_CS_POSIX_V6_LP64_OFF64_CFLAGS") 

+  v("_CS_POSIX_V6_LP64_OFF64_LDFLAGS")

+  v("_CS_POSIX_V6_LP64_OFF64_LIBS") 

+  v("_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS") 

+  v("_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS") 

+  v("_CS_POSIX_V6_LPBIG_OFFBIG_LIBS") 

+  v("_CS_POSIX_V6_WIDTH_RESTRICTED_ENVS")
+
+  v("F_LOCK") 

+  v("F_TEST") #{.importc: "F_TEST", header: "<unistd.h>".}: cint

+  v("F_TLOCK") #{.importc: "F_TLOCK", header: "<unistd.h>".}: cint

+  v("F_ULOCK") #{.importc: "F_ULOCK", header: "<unistd.h>".}: cint

+  v("_PC_2_SYMLINKS") #{.importc: "_PC_2_SYMLINKS", header: "<unistd.h>".}: cint

+  v("_PC_ALLOC_SIZE_MIN") 

+  v("_PC_ASYNC_IO") #{.importc: "_PC_ASYNC_IO", header: "<unistd.h>".}: cint

+  v("_PC_CHOWN_RESTRICTED") 

+  v("_PC_FILESIZEBITS") #{.importc: "_PC_FILESIZEBITS", header: "<unistd.h>".}: cint

+  v("_PC_LINK_MAX") #{.importc: "_PC_LINK_MAX", header: "<unistd.h>".}: cint

+  v("_PC_MAX_CANON") #{.importc: "_PC_MAX_CANON", header: "<unistd.h>".}: cint

+  v("_PC_MAX_INPUT") #{.importc: "_PC_MAX_INPUT", header: "<unistd.h>".}: cint

+  v("_PC_NAME_MAX") #{.importc: "_PC_NAME_MAX", header: "<unistd.h>".}: cint

+  v("_PC_NO_TRUNC") #{.importc: "_PC_NO_TRUNC", header: "<unistd.h>".}: cint

+  v("_PC_PATH_MAX") #{.importc: "_PC_PATH_MAX", header: "<unistd.h>".}: cint

+  v("_PC_PIPE_BUF") #{.importc: "_PC_PIPE_BUF", header: "<unistd.h>".}: cint

+  v("_PC_PRIO_IO") #{.importc: "_PC_PRIO_IO", header: "<unistd.h>".}: cint

+  v("_PC_REC_INCR_XFER_SIZE") 

+  v("_PC_REC_MIN_XFER_SIZE") 

+  v("_PC_REC_XFER_ALIGN") 

+  v("_PC_SYMLINK_MAX") #{.importc: "_PC_SYMLINK_MAX", header: "<unistd.h>".}: cint

+  v("_PC_SYNC_IO") #{.importc: "_PC_SYNC_IO", header: "<unistd.h>".}: cint

+  v("_PC_VDISABLE") #{.importc: "_PC_VDISABLE", header: "<unistd.h>".}: cint

+  v("_SC_2_C_BIND") #{.importc: "_SC_2_C_BIND", header: "<unistd.h>".}: cint

+  v("_SC_2_C_DEV") #{.importc: "_SC_2_C_DEV", header: "<unistd.h>".}: cint

+  v("_SC_2_CHAR_TERM") #{.importc: "_SC_2_CHAR_TERM", header: "<unistd.h>".}: cint

+  v("_SC_2_FORT_DEV") #{.importc: "_SC_2_FORT_DEV", header: "<unistd.h>".}: cint

+  v("_SC_2_FORT_RUN") #{.importc: "_SC_2_FORT_RUN", header: "<unistd.h>".}: cint

+  v("_SC_2_LOCALEDEF") #{.importc: "_SC_2_LOCALEDEF", header: "<unistd.h>".}: cint

+  v("_SC_2_PBS") #{.importc: "_SC_2_PBS", header: "<unistd.h>".}: cint

+  v("_SC_2_PBS_ACCOUNTING") 

+  v("_SC_2_PBS_CHECKPOINT") 

+  v("_SC_2_PBS_LOCATE") #{.importc: "_SC_2_PBS_LOCATE", header: "<unistd.h>".}: cint

+  v("_SC_2_PBS_MESSAGE") #{.importc: "_SC_2_PBS_MESSAGE", header: "<unistd.h>".}: cint

+  v("_SC_2_PBS_TRACK") #{.importc: "_SC_2_PBS_TRACK", header: "<unistd.h>".}: cint

+  v("_SC_2_SW_DEV") #{.importc: "_SC_2_SW_DEV", header: "<unistd.h>".}: cint

+  v("_SC_2_UPE") #{.importc: "_SC_2_UPE", header: "<unistd.h>".}: cint

+  v("_SC_2_VERSION") #{.importc: "_SC_2_VERSION", header: "<unistd.h>".}: cint

+  v("_SC_ADVISORY_INFO") #{.importc: "_SC_ADVISORY_INFO", header: "<unistd.h>".}: cint

+  v("_SC_AIO_LISTIO_MAX") 

+  v("_SC_AIO_MAX") #{.importc: "_SC_AIO_MAX", header: "<unistd.h>".}: cint

+  v("_SC_AIO_PRIO_DELTA_MAX") 

+  v("_SC_ARG_MAX") #{.importc: "_SC_ARG_MAX", header: "<unistd.h>".}: cint

+  v("_SC_ASYNCHRONOUS_IO") 

+  v("_SC_ATEXIT_MAX") #{.importc: "_SC_ATEXIT_MAX", header: "<unistd.h>".}: cint

+  v("_SC_BARRIERS") #{.importc: "_SC_BARRIERS", header: "<unistd.h>".}: cint

+  v("_SC_BC_BASE_MAX") #{.importc: "_SC_BC_BASE_MAX", header: "<unistd.h>".}: cint

+  v("_SC_BC_DIM_MAX") #{.importc: "_SC_BC_DIM_MAX", header: "<unistd.h>".}: cint

+  v("_SC_BC_SCALE_MAX") #{.importc: "_SC_BC_SCALE_MAX", header: "<unistd.h>".}: cint

+  v("_SC_BC_STRING_MAX") #{.importc: "_SC_BC_STRING_MAX", header: "<unistd.h>".}: cint

+  v("_SC_CHILD_MAX") #{.importc: "_SC_CHILD_MAX", header: "<unistd.h>".}: cint

+  v("_SC_CLK_TCK") #{.importc: "_SC_CLK_TCK", header: "<unistd.h>".}: cint

+  v("_SC_CLOCK_SELECTION") 

+  v("_SC_COLL_WEIGHTS_MAX")

+  v("_SC_CPUTIME") #{.importc: "_SC_CPUTIME", header: "<unistd.h>".}: cint

+  v("_SC_DELAYTIMER_MAX") 

+  v("_SC_EXPR_NEST_MAX") #{.importc: "_SC_EXPR_NEST_MAX", header: "<unistd.h>".}: cint

+  v("_SC_FSYNC") #{.importc: "_SC_FSYNC", header: "<unistd.h>".}: cint

+  v("_SC_GETGR_R_SIZE_MAX")

+  v("_SC_GETPW_R_SIZE_MAX")

+  v("_SC_HOST_NAME_MAX") #{.importc: "_SC_HOST_NAME_MAX", header: "<unistd.h>".}: cint

+  v("_SC_IOV_MAX") #{.importc: "_SC_IOV_MAX", header: "<unistd.h>".}: cint

+  v("_SC_IPV6") #{.importc: "_SC_IPV6", header: "<unistd.h>".}: cint

+  v("_SC_JOB_CONTROL") #{.importc: "_SC_JOB_CONTROL", header: "<unistd.h>".}: cint

+  v("_SC_LINE_MAX") #{.importc: "_SC_LINE_MAX", header: "<unistd.h>".}: cint

+  v("_SC_LOGIN_NAME_MAX") 

+  v("_SC_MAPPED_FILES") #{.importc: "_SC_MAPPED_FILES", header: "<unistd.h>".}: cint

+  v("_SC_MEMLOCK") #{.importc: "_SC_MEMLOCK", header: "<unistd.h>".}: cint

+  v("_SC_MEMLOCK_RANGE") #{.importc: "_SC_MEMLOCK_RANGE", header: "<unistd.h>".}: cint

+  v("_SC_MEMORY_PROTECTION")

+  v("_SC_MESSAGE_PASSING") 

+  v("_SC_MONOTONIC_CLOCK") 

+  v("_SC_MQ_OPEN_MAX") #{.importc: "_SC_MQ_OPEN_MAX", header: "<unistd.h>".}: cint

+  v("_SC_MQ_PRIO_MAX") #{.importc: "_SC_MQ_PRIO_MAX", header: "<unistd.h>".}: cint

+  v("_SC_NGROUPS_MAX") #{.importc: "_SC_NGROUPS_MAX", header: "<unistd.h>".}: cint

+  v("_SC_OPEN_MAX") #{.importc: "_SC_OPEN_MAX", header: "<unistd.h>".}: cint

+  v("_SC_PAGE_SIZE") #{.importc: "_SC_PAGE_SIZE", header: "<unistd.h>".}: cint

+  v("_SC_PRIORITIZED_IO") 

+  v("_SC_PRIORITY_SCHEDULING") 

+  v("_SC_RAW_SOCKETS") #{.importc: "_SC_RAW_SOCKETS", header: "<unistd.h>".}: cint

+  v("_SC_RE_DUP_MAX") #{.importc: "_SC_RE_DUP_MAX", header: "<unistd.h>".}: cint

+  v("_SC_READER_WRITER_LOCKS") 

+  v("_SC_REALTIME_SIGNALS") 

+  v("_SC_REGEXP") #{.importc: "_SC_REGEXP", header: "<unistd.h>".}: cint

+  v("_SC_RTSIG_MAX") #{.importc: "_SC_RTSIG_MAX", header: "<unistd.h>".}: cint

+  v("_SC_SAVED_IDS") #{.importc: "_SC_SAVED_IDS", header: "<unistd.h>".}: cint

+  v("_SC_SEM_NSEMS_MAX") #{.importc: "_SC_SEM_NSEMS_MAX", header: "<unistd.h>".}: cint

+  v("_SC_SEM_VALUE_MAX") #{.importc: "_SC_SEM_VALUE_MAX", header: "<unistd.h>".}: cint

+  v("_SC_SEMAPHORES") #{.importc: "_SC_SEMAPHORES", header: "<unistd.h>".}: cint

+  v("_SC_SHARED_MEMORY_OBJECTS") 

+  v("_SC_SHELL") #{.importc: "_SC_SHELL", header: "<unistd.h>".}: cint

+  v("_SC_SIGQUEUE_MAX") #{.importc: "_SC_SIGQUEUE_MAX", header: "<unistd.h>".}: cint

+  v("_SC_SPAWN") #{.importc: "_SC_SPAWN", header: "<unistd.h>".}: cint

+  v("_SC_SPIN_LOCKS") #{.importc: "_SC_SPIN_LOCKS", header: "<unistd.h>".}: cint

+  v("_SC_SPORADIC_SERVER") 

+  v("_SC_SS_REPL_MAX") #{.importc: "_SC_SS_REPL_MAX", header: "<unistd.h>".}: cint

+  v("_SC_STREAM_MAX") #{.importc: "_SC_STREAM_MAX", header: "<unistd.h>".}: cint

+  v("_SC_SYMLOOP_MAX") #{.importc: "_SC_SYMLOOP_MAX", header: "<unistd.h>".}: cint

+  v("_SC_SYNCHRONIZED_IO") 

+  v("_SC_THREAD_ATTR_STACKADDR") 

+  v("_SC_THREAD_ATTR_STACKSIZE") 

+  v("_SC_THREAD_CPUTIME") 

+  v("_SC_THREAD_DESTRUCTOR_ITERATIONS") 

+  v("_SC_THREAD_KEYS_MAX") 

+  v("_SC_THREAD_PRIO_INHERIT") 

+  v("_SC_THREAD_PRIO_PROTECT") 

+  v("_SC_THREAD_PRIORITY_SCHEDULING") 

+  v("_SC_THREAD_PROCESS_SHARED") 

+  v("_SC_THREAD_SAFE_FUNCTIONS") 

+  v("_SC_THREAD_SPORADIC_SERVER")

+  v("_SC_THREAD_STACK_MIN") 

+  v("_SC_THREAD_THREADS_MAX") 

+  v("_SC_THREADS") #{.importc: "_SC_THREADS", header: "<unistd.h>".}: cint

+  v("_SC_TIMEOUTS") #{.importc: "_SC_TIMEOUTS", header: "<unistd.h>".}: cint

+  v("_SC_TIMER_MAX") #{.importc: "_SC_TIMER_MAX", header: "<unistd.h>".}: cint

+  v("_SC_TIMERS") #{.importc: "_SC_TIMERS", header: "<unistd.h>".}: cint

+  v("_SC_TRACE") #{.importc: "_SC_TRACE", header: "<unistd.h>".}: cint

+  v("_SC_TRACE_EVENT_FILTER") 

+  v("_SC_TRACE_EVENT_NAME_MAX")

+  v("_SC_TRACE_INHERIT") #{.importc: "_SC_TRACE_INHERIT", header: "<unistd.h>".}: cint

+  v("_SC_TRACE_LOG") #{.importc: "_SC_TRACE_LOG", header: "<unistd.h>".}: cint

+  v("_SC_TRACE_NAME_MAX") 

+  v("_SC_TRACE_SYS_MAX") #{.importc: "_SC_TRACE_SYS_MAX", header: "<unistd.h>".}: cint

+  v("_SC_TRACE_USER_EVENT_MAX") 

+  v("_SC_TTY_NAME_MAX") #{.importc: "_SC_TTY_NAME_MAX", header: "<unistd.h>".}: cint

+  v("_SC_TYPED_MEMORY_OBJECTS") 

+  v("_SC_TZNAME_MAX") #{.importc: "_SC_TZNAME_MAX", header: "<unistd.h>".}: cint

+  v("_SC_V6_ILP32_OFF32") 

+  v("_SC_V6_ILP32_OFFBIG") 

+  v("_SC_V6_LP64_OFF64") #{.importc: "_SC_V6_LP64_OFF64", header: "<unistd.h>".}: cint

+  v("_SC_V6_LPBIG_OFFBIG") 

+  v("_SC_VERSION") #{.importc: "_SC_VERSION", header: "<unistd.h>".}: cint

+  v("_SC_XBS5_ILP32_OFF32") 

+  v("_SC_XBS5_ILP32_OFFBIG") 

+  v("_SC_XBS5_LP64_OFF64") 

+  v("_SC_XBS5_LPBIG_OFFBIG") 

+  v("_SC_XOPEN_CRYPT") #{.importc: "_SC_XOPEN_CRYPT", header: "<unistd.h>".}: cint

+  v("_SC_XOPEN_ENH_I18N") 

+  v("_SC_XOPEN_LEGACY") #{.importc: "_SC_XOPEN_LEGACY", header: "<unistd.h>".}: cint

+  v("_SC_XOPEN_REALTIME") 

+  v("_SC_XOPEN_REALTIME_THREADS") 

+  v("_SC_XOPEN_SHM") #{.importc: "_SC_XOPEN_SHM", header: "<unistd.h>".}: cint

+  v("_SC_XOPEN_STREAMS") #{.importc: "_SC_XOPEN_STREAMS", header: "<unistd.h>".}: cint

+  v("_SC_XOPEN_UNIX") #{.importc: "_SC_XOPEN_UNIX", header: "<unistd.h>".}: cint

+  v("_SC_XOPEN_VERSION") #{.importc: "_SC_XOPEN_VERSION", header: "<unistd.h>".}: cint

+
+  v("SEEK_SET") #{.importc, header: "<unistd.h>".}: cint

+  v("SEEK_CUR") #{.importc, header: "<unistd.h>".}: cint

+  v("SEEK_END") #{.importc, header: "<unistd.h>".}: cint

+
+
+if header("<semaphore.h>"):

+  v("SEM_FAILED", pointer)
+
+if header("<sys/ipc.h>"):

+  v("IPC_CREAT") #{.importc, header: .}: cint

+  v("IPC_EXCL") #{.importc, header: "<sys/ipc.h>".}: cint

+  v("IPC_NOWAIT") #{.importc, header: "<sys/ipc.h>".}: cint

+  v("IPC_PRIVATE") #{.importc, header: "<sys/ipc.h>".}: cint

+  v("IPC_RMID") #{.importc, header: "<sys/ipc.h>".}: cint

+  v("IPC_SET") #{.importc, header: "<sys/ipc.h>".}: cint

+  v("IPC_STAT") #{.importc, header: "<sys/ipc.h>".}: cint
+
+if header("<sys/stat.h>"):

+  v("S_IFMT") #{.importc, header: .}: cint

+  v("S_IFBLK") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_IFCHR") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_IFIFO") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_IFREG") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_IFDIR") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_IFLNK") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_IFSOCK") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_IRWXU") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_IRUSR") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_IWUSR") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_IXUSR") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_IRWXG") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_IRGRP") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_IWGRP") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_IXGRP") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_IRWXO") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_IROTH") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_IWOTH") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_IXOTH") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_ISUID") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_ISGID") #{.importc, header: "<sys/stat.h>".}: cint

+  v("S_ISVTX") #{.importc, header: "<sys/stat.h>".}: cint

+
+if header("<sys/statvfs.h>"):

+  v("ST_RDONLY") #{.importc, header: .}: cint

+  v("ST_NOSUID") #{.importc, header: "<sys/statvfs.h>".}: cint

+       
+if header("<sys/mman.h>"):

+  v("PROT_READ") #{.importc, header: .}: cint

+  v("PROT_WRITE") #{.importc, header: "<sys/mman.h>".}: cint

+  v("PROT_EXEC") #{.importc, header: "<sys/mman.h>".}: cint

+  v("PROT_NONE") #{.importc, header: "<sys/mman.h>".}: cint

+  v("MAP_SHARED") #{.importc, header: "<sys/mman.h>".}: cint

+  v("MAP_PRIVATE") #{.importc, header: "<sys/mman.h>".}: cint

+  v("MAP_FIXED") #{.importc, header: "<sys/mman.h>".}: cint

+  v("MS_ASYNC") #{.importc, header: "<sys/mman.h>".}: cint

+  v("MS_SYNC") #{.importc, header: "<sys/mman.h>".}: cint

+  v("MS_INVALIDATE") #{.importc, header: "<sys/mman.h>".}: cint

+  v("MCL_CURRENT") #{.importc, header: "<sys/mman.h>".}: cint

+  v("MCL_FUTURE") #{.importc, header: "<sys/mman.h>".}: cint

+
+  v("MAP_FAILED", pointer)

+  v("POSIX_MADV_NORMAL") #{.importc, header: "<sys/mman.h>".}: cint

+  v("POSIX_MADV_SEQUENTIAL") #{.importc, header: "<sys/mman.h>".}: cint

+  v("POSIX_MADV_RANDOM") #{.importc, header: "<sys/mman.h>".}: cint

+  v("POSIX_MADV_WILLNEED") #{.importc, header: "<sys/mman.h>".}: cint

+  v("POSIX_MADV_DONTNEED") #{.importc, header: "<sys/mman.h>".}: cint

+  v("POSIX_TYPED_MEM_ALLOCATE") #{.importc, header: "<sys/mman.h>".}: cint

+  v("POSIX_TYPED_MEM_ALLOCATE_CONTIG") #{.importc, header: "<sys/mman.h>".}: cint

+  v("POSIX_TYPED_MEM_MAP_ALLOCATABLE") #{.importc, header: "<sys/mman.h>".}: cint

+

+if header("<time.h>"):

+  v("CLOCKS_PER_SEC", clong) 

+  v("CLOCK_PROCESS_CPUTIME_ID")

+  v("CLOCK_THREAD_CPUTIME_ID")

+  v("CLOCK_REALTIME")

+  v("TIMER_ABSTIME") 

+  v("CLOCK_MONOTONIC") 

+
+if header("<sys/wait.h>"):

+  v("WNOHANG") #{.importc, header: .}: cint

+  v("WUNTRACED") #{.importc, header: "<sys/wait.h>".}: cint

+  #v("WEXITSTATUS") 

+  #v("WIFCONTINUED") 

+  #v("WIFEXITED") 

+  #v("WIFSIGNALED")

+  #v("WIFSTOPPED") 

+  #v("WSTOPSIG") 

+  #v("WTERMSIG") 

+  v("WEXITED") #{.importc, header: "<sys/wait.h>".}: cint

+  v("WSTOPPED") #{.importc, header: "<sys/wait.h>".}: cint

+  v("WCONTINUED") #{.importc, header: "<sys/wait.h>".}: cint

+  v("WNOWAIT") #{.importc, header: "<sys/wait.h>".}: cint

+  v("P_ALL") #{.importc, header: "<sys/wait.h>".}: cint 

+  v("P_PID") #{.importc, header: "<sys/wait.h>".}: cint 

+  v("P_PGID") #{.importc, header: "<sys/wait.h>".}: cint

+         
+if header("<signal.h>"):

+  v("SIGEV_NONE") #{.importc, header: "<signal.h>".}: cint

+  v("SIGEV_SIGNAL") #{.importc, header: "<signal.h>".}: cint

+  v("SIGEV_THREAD") #{.importc, header: "<signal.h>".}: cint

+  v("SIGABRT") #{.importc, header: "<signal.h>".}: cint

+  v("SIGALRM") #{.importc, header: "<signal.h>".}: cint

+  v("SIGBUS") #{.importc, header: "<signal.h>".}: cint

+  v("SIGCHLD") #{.importc, header: "<signal.h>".}: cint

+  v("SIGCONT") #{.importc, header: "<signal.h>".}: cint

+  v("SIGFPE") #{.importc, header: "<signal.h>".}: cint

+  v("SIGHUP") #{.importc, header: "<signal.h>".}: cint

+  v("SIGILL") #{.importc, header: "<signal.h>".}: cint

+  v("SIGINT") #{.importc, header: "<signal.h>".}: cint

+  v("SIGKILL") #{.importc, header: "<signal.h>".}: cint

+  v("SIGPIPE") #{.importc, header: "<signal.h>".}: cint

+  v("SIGQUIT") #{.importc, header: "<signal.h>".}: cint

+  v("SIGSEGV") #{.importc, header: "<signal.h>".}: cint

+  v("SIGSTOP") #{.importc, header: "<signal.h>".}: cint

+  v("SIGTERM") #{.importc, header: "<signal.h>".}: cint

+  v("SIGTSTP") #{.importc, header: "<signal.h>".}: cint

+  v("SIGTTIN") #{.importc, header: "<signal.h>".}: cint

+  v("SIGTTOU") #{.importc, header: "<signal.h>".}: cint

+  v("SIGUSR1") #{.importc, header: "<signal.h>".}: cint

+  v("SIGUSR2") #{.importc, header: "<signal.h>".}: cint

+  v("SIGPOLL") #{.importc, header: "<signal.h>".}: cint

+  v("SIGPROF") #{.importc, header: "<signal.h>".}: cint

+  v("SIGSYS") #{.importc, header: "<signal.h>".}: cint

+  v("SIGTRAP") #{.importc, header: "<signal.h>".}: cint

+  v("SIGURG") #{.importc, header: "<signal.h>".}: cint

+  v("SIGVTALRM") #{.importc, header: "<signal.h>".}: cint

+  v("SIGXCPU") #{.importc, header: "<signal.h>".}: cint

+  v("SIGXFSZ") #{.importc, header: "<signal.h>".}: cint

+  v("SA_NOCLDSTOP") #{.importc, header: "<signal.h>".}: cint

+  v("SIG_BLOCK") #{.importc, header: "<signal.h>".}: cint

+  v("SIG_UNBLOCK") #{.importc, header: "<signal.h>".}: cint

+  v("SIG_SETMASK") #{.importc, header: "<signal.h>".}: cint

+  v("SA_ONSTACK") #{.importc, header: "<signal.h>".}: cint

+  v("SA_RESETHAND") #{.importc, header: "<signal.h>".}: cint

+  v("SA_RESTART") #{.importc, header: "<signal.h>".}: cint

+  v("SA_SIGINFO") #{.importc, header: "<signal.h>".}: cint

+  v("SA_NOCLDWAIT") #{.importc, header: "<signal.h>".}: cint

+  v("SA_NODEFER") #{.importc, header: "<signal.h>".}: cint

+  v("SS_ONSTACK") #{.importc, header: "<signal.h>".}: cint

+  v("SS_DISABLE") #{.importc, header: "<signal.h>".}: cint

+  v("MINSIGSTKSZ") #{.importc, header: "<signal.h>".}: cint

+  v("SIGSTKSZ") #{.importc, header: "<signal.h>".}: cint

+
+if header("<nl_types.h>"):

+  v("NL_SETD") #{.importc, header: .}: cint

+  v("NL_CAT_LOCALE") #{.importc, header: "<nl_types.h>".}: cint

+
+if header("<sched.h>"):

+  v("SCHED_FIFO")

+  v("SCHED_RR")

+  v("SCHED_SPORADIC")

+  v("SCHED_OTHER")

+
+if header("<sys/select.h>"):
+  v("FD_SETSIZE")

+

+if header("<net/if.h>"):
+  v("IF_NAMESIZE")
+
+if header("<sys/socket.h>"):
+  v("SCM_RIGHTS") #{.importc, header: .}: cint
+  v("SOCK_DGRAM") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SOCK_RAW") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SOCK_SEQPACKET") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SOCK_STREAM") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SOL_SOCKET") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SO_ACCEPTCONN") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SO_BROADCAST") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SO_DEBUG") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SO_DONTROUTE") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SO_ERROR") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SO_KEEPALIVE") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SO_LINGER") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SO_OOBINLINE") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SO_RCVBUF") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SO_RCVLOWAT") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SO_RCVTIMEO") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SO_REUSEADDR") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SO_SNDBUF") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SO_SNDLOWAT") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SO_SNDTIMEO") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SO_TYPE") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SOMAXCONN") #{.importc, header: "<sys/socket.h>".}: cint
+  v("MSG_CTRUNC") #{.importc, header: "<sys/socket.h>".}: cint
+  v("MSG_DONTROUTE") #{.importc, header: "<sys/socket.h>".}: cint
+  v("MSG_EOR") #{.importc, header: "<sys/socket.h>".}: cint
+  v("MSG_OOB") #{.importc, header: "<sys/socket.h>".}: cint
+  v("MSG_PEEK") #{.importc, header: "<sys/socket.h>".}: cint
+  v("MSG_TRUNC") #{.importc, header: "<sys/socket.h>".}: cint
+  v("MSG_WAITALL") #{.importc, header: "<sys/socket.h>".}: cint
+  v("AF_INET") #{.importc, header: "<sys/socket.h>".}: cint
+  v("AF_INET6") #{.importc, header: "<sys/socket.h>".}: cint
+  v("AF_UNIX") #{.importc, header: "<sys/socket.h>".}: cint
+  v("AF_UNSPEC") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SHUT_RD") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SHUT_RDWR") #{.importc, header: "<sys/socket.h>".}: cint
+  v("SHUT_WR") #{.importc, header: "<sys/socket.h>".}: cint
+
+if header("<netinet/in.h>"):
+  v("IPPROTO_IP") #{.importc, header: .}: cint
+  v("IPPROTO_IPV6") #{.importc, header: "<netinet/in.h>".}: cint
+  v("IPPROTO_ICMP") #{.importc, header: "<netinet/in.h>".}: cint
+  v("IPPROTO_RAW") #{.importc, header: "<netinet/in.h>".}: cint
+  v("IPPROTO_TCP") #{.importc, header: "<netinet/in.h>".}: cint
+  v("IPPROTO_UDP") #{.importc, header: "<netinet/in.h>".}: cint
+  v("INADDR_ANY") #{.importc, header: "<netinet/in.h>".}: TinAddrScalar
+  v("INADDR_BROADCAST") #{.importc, header: "<netinet/in.h>".}: TinAddrScalar
+  v("INET_ADDRSTRLEN") #{.importc, header: "<netinet/in.h>".}: cint
+
+  v("IPV6_JOIN_GROUP") #{.importc, header: "<netinet/in.h>".}: cint
+  v("IPV6_LEAVE_GROUP") #{.importc, header: "<netinet/in.h>".}: cint
+  v("IPV6_MULTICAST_HOPS") #{.importc, header: "<netinet/in.h>".}: cint
+  v("IPV6_MULTICAST_IF") #{.importc, header: "<netinet/in.h>".}: cint
+  v("IPV6_MULTICAST_LOOP") #{.importc, header: "<netinet/in.h>".}: cint
+  v("IPV6_UNICAST_HOPS") #{.importc, header: "<netinet/in.h>".}: cint
+  v("IPV6_V6ONLY") #{.importc, header: "<netinet/in.h>".}: cint
+
+  v("TCP_NODELAY") #{.importc, header: "<netinet/tcp.h>".}: cint
+
+if header("<netdb.h>"):
+  v("IPPORT_RESERVED")
+
+  v("HOST_NOT_FOUND")
+  v("NO_DATA")
+  v("NO_RECOVERY") 
+  v("TRY_AGAIN") 
+
+  v("AI_PASSIVE") 
+  v("AI_CANONNAME") 
+  v("AI_NUMERICHOST") 
+  v("AI_NUMERICSERV") 
+  v("AI_V4MAPPED") 
+  v("AI_ALL") 
+  v("AI_ADDRCONFIG") 
+
+  v("NI_NOFQDN") 
+  v("NI_NUMERICHOST") 
+  v("NI_NAMEREQD") 
+  v("NI_NUMERICSERV") 
+  v("NI_NUMERICSCOPE") 
+  v("NI_DGRAM") 
+  v("EAI_AGAIN")
+  v("EAI_BADFLAGS")
+  v("EAI_FAIL")
+  v("EAI_FAMILY")
+  v("EAI_MEMORY")
+  v("EAI_NONAME")
+  v("EAI_SERVICE")
+  v("EAI_SOCKTYPE")
+  v("EAI_SYSTEM")
+  v("EAI_OVERFLOW")
+
+if header("<poll.h>"):
+  v("POLLIN", cshort)
+  v("POLLRDNORM", cshort)
+  v("POLLRDBAND", cshort)
+  v("POLLPRI", cshort)
+  v("POLLOUT", cshort)
+  v("POLLWRNORM", cshort)
+  v("POLLWRBAND", cshort)
+  v("POLLERR", cshort)
+  v("POLLHUP", cshort)
+  v("POLLNVAL", cshort)
+
+if header("<spawn.h>"):
+  v("POSIX_SPAWN_RESETIDS")

+  v("POSIX_SPAWN_SETPGROUP")

+  v("POSIX_SPAWN_SETSCHEDPARAM")

+  v("POSIX_SPAWN_SETSCHEDULER")

+  v("POSIX_SPAWN_SETSIGDEF")

+  v("POSIX_SPAWN_SETSIGMASK")

+
+main()
+
diff --git a/lib/posix/linux_amd64_consts.nim b/lib/posix/linux_amd64_consts.nim
new file mode 100644
index 000000000..2fadcd83b
--- /dev/null
+++ b/lib/posix/linux_amd64_consts.nim
@@ -0,0 +1,620 @@
+# Generated by detect.nim
+const
+  AIO_ALLDONE* = cint(2)
+  AIO_CANCELED* = cint(0)
+  AIO_NOTCANCELED* = cint(1)
+  LIO_NOP* = cint(2)
+  LIO_NOWAIT* = cint(1)
+  LIO_READ* = cint(0)
+  LIO_WAIT* = cint(0)
+  LIO_WRITE* = cint(1)
+  RTLD_LAZY* = cint(1)
+  RTLD_NOW* = cint(2)
+  RTLD_GLOBAL* = cint(256)
+  RTLD_LOCAL* = cint(0)
+  E2BIG* = cint(7)
+  EACCES* = cint(13)
+  EADDRINUSE* = cint(98)
+  EADDRNOTAVAIL* = cint(99)
+  EAFNOSUPPORT* = cint(97)
+  EAGAIN* = cint(11)
+  EALREADY* = cint(114)
+  EBADF* = cint(9)
+  EBADMSG* = cint(74)
+  EBUSY* = cint(16)
+  ECANCELED* = cint(125)
+  ECHILD* = cint(10)
+  ECONNABORTED* = cint(103)
+  ECONNREFUSED* = cint(111)
+  ECONNRESET* = cint(104)
+  EDEADLK* = cint(35)
+  EDESTADDRREQ* = cint(89)
+  EDOM* = cint(33)
+  EDQUOT* = cint(122)
+  EEXIST* = cint(17)
+  EFAULT* = cint(14)
+  EFBIG* = cint(27)
+  EHOSTUNREACH* = cint(113)
+  EIDRM* = cint(43)
+  EILSEQ* = cint(84)
+  EINPROGRESS* = cint(115)
+  EINTR* = cint(4)
+  EINVAL* = cint(22)
+  EIO* = cint(5)
+  EISCONN* = cint(106)
+  EISDIR* = cint(21)
+  ELOOP* = cint(40)
+  EMFILE* = cint(24)
+  EMLINK* = cint(31)
+  EMSGSIZE* = cint(90)
+  EMULTIHOP* = cint(72)
+  ENAMETOOLONG* = cint(36)
+  ENETDOWN* = cint(100)
+  ENETRESET* = cint(102)
+  ENETUNREACH* = cint(101)
+  ENFILE* = cint(23)
+  ENOBUFS* = cint(105)
+  ENODATA* = cint(61)
+  ENODEV* = cint(19)
+  ENOENT* = cint(2)
+  ENOEXEC* = cint(8)
+  ENOLCK* = cint(37)
+  ENOLINK* = cint(67)
+  ENOMEM* = cint(12)
+  ENOMSG* = cint(42)
+  ENOPROTOOPT* = cint(92)
+  ENOSPC* = cint(28)
+  ENOSR* = cint(63)
+  ENOSTR* = cint(60)
+  ENOSYS* = cint(38)
+  ENOTCONN* = cint(107)
+  ENOTDIR* = cint(20)
+  ENOTEMPTY* = cint(39)
+  ENOTSOCK* = cint(88)
+  ENOTSUP* = cint(95)
+  ENOTTY* = cint(25)
+  ENXIO* = cint(6)
+  EOPNOTSUPP* = cint(95)
+  EOVERFLOW* = cint(75)
+  EPERM* = cint(1)
+  EPIPE* = cint(32)
+  EPROTO* = cint(71)
+  EPROTONOSUPPORT* = cint(93)
+  EPROTOTYPE* = cint(91)
+  ERANGE* = cint(34)
+  EROFS* = cint(30)
+  ESPIPE* = cint(29)
+  ESRCH* = cint(3)
+  ESTALE* = cint(116)
+  ETIME* = cint(62)
+  ETIMEDOUT* = cint(110)
+  ETXTBSY* = cint(26)
+  EWOULDBLOCK* = cint(11)
+  EXDEV* = cint(18)
+  F_DUPFD* = cint(0)
+  F_GETFD* = cint(1)
+  F_SETFD* = cint(2)
+  F_GETFL* = cint(3)
+  F_SETFL* = cint(4)
+  F_GETLK* = cint(5)
+  F_SETLK* = cint(6)
+  F_SETLKW* = cint(7)
+  F_GETOWN* = cint(9)
+  F_SETOWN* = cint(8)
+  FD_CLOEXEC* = cint(1)
+  F_RDLCK* = cint(0)
+  F_UNLCK* = cint(2)
+  F_WRLCK* = cint(1)
+  O_CREAT* = cint(64)
+  O_EXCL* = cint(128)
+  O_NOCTTY* = cint(256)
+  O_TRUNC* = cint(512)
+  O_APPEND* = cint(1024)
+  O_DSYNC* = cint(4096)
+  O_NONBLOCK* = cint(2048)
+  O_RSYNC* = cint(4096)
+  O_SYNC* = cint(4096)
+  O_ACCMODE* = cint(3)
+  O_RDONLY* = cint(0)
+  O_RDWR* = cint(2)
+  O_WRONLY* = cint(1)
+  POSIX_FADV_NORMAL* = cint(0)
+  POSIX_FADV_SEQUENTIAL* = cint(2)
+  POSIX_FADV_RANDOM* = cint(1)
+  POSIX_FADV_WILLNEED* = cint(3)
+  POSIX_FADV_DONTNEED* = cint(4)
+  POSIX_FADV_NOREUSE* = cint(5)
+  FE_DIVBYZERO* = cint(4)
+  FE_INEXACT* = cint(32)
+  FE_INVALID* = cint(1)
+  FE_OVERFLOW* = cint(8)
+  FE_UNDERFLOW* = cint(16)
+  FE_ALL_EXCEPT* = cint(61)
+  FE_DOWNWARD* = cint(1024)
+  FE_TONEAREST* = cint(0)
+  FE_TOWARDZERO* = cint(3072)
+  FE_UPWARD* = cint(2048)
+  FE_DFL_ENV* = cast[pointer](0xffffffffffffffff)
+  MM_HARD* = cint(1)
+  MM_SOFT* = cint(2)
+  MM_FIRM* = cint(4)
+  MM_APPL* = cint(8)
+  MM_UTIL* = cint(16)
+  MM_OPSYS* = cint(32)
+  MM_RECOVER* = cint(64)
+  MM_NRECOV* = cint(128)
+  MM_HALT* = cint(1)
+  MM_ERROR* = cint(2)
+  MM_WARNING* = cint(3)
+  MM_INFO* = cint(4)
+  MM_NOSEV* = cint(0)
+  MM_PRINT* = cint(256)
+  MM_CONSOLE* = cint(512)
+  MM_OK* = cint(0)
+  MM_NOTOK* = cint(-1)
+  MM_NOMSG* = cint(1)
+  MM_NOCON* = cint(4)
+  FNM_NOMATCH* = cint(1)
+  FNM_PATHNAME* = cint(1)
+  FNM_PERIOD* = cint(4)
+  FNM_NOESCAPE* = cint(2)
+  FTW_F* = cint(0)
+  FTW_D* = cint(1)
+  FTW_DNR* = cint(2)
+  FTW_NS* = cint(3)
+  FTW_SL* = cint(4)
+  GLOB_APPEND* = cint(32)
+  GLOB_DOOFFS* = cint(8)
+  GLOB_ERR* = cint(1)
+  GLOB_MARK* = cint(2)
+  GLOB_NOCHECK* = cint(16)
+  GLOB_NOESCAPE* = cint(64)
+  GLOB_NOSORT* = cint(4)
+  GLOB_ABORTED* = cint(2)
+  GLOB_NOMATCH* = cint(3)
+  GLOB_NOSPACE* = cint(1)
+  GLOB_NOSYS* = cint(4)
+  CODESET* = cint(14)
+  D_T_FMT* = cint(131112)
+  D_FMT* = cint(131113)
+  T_FMT* = cint(131114)
+  T_FMT_AMPM* = cint(131115)
+  AM_STR* = cint(131110)
+  PM_STR* = cint(131111)
+  DAY_1* = cint(131079)
+  DAY_2* = cint(131080)
+  DAY_3* = cint(131081)
+  DAY_4* = cint(131082)
+  DAY_5* = cint(131083)
+  DAY_6* = cint(131084)
+  DAY_7* = cint(131085)
+  ABDAY_1* = cint(131072)
+  ABDAY_2* = cint(131073)
+  ABDAY_3* = cint(131074)
+  ABDAY_4* = cint(131075)
+  ABDAY_5* = cint(131076)
+  ABDAY_6* = cint(131077)
+  ABDAY_7* = cint(131078)
+  MON_1* = cint(131098)
+  MON_2* = cint(131099)
+  MON_3* = cint(131100)
+  MON_4* = cint(131101)
+  MON_5* = cint(131102)
+  MON_6* = cint(131103)
+  MON_7* = cint(131104)
+  MON_8* = cint(131105)
+  MON_9* = cint(131106)
+  MON_10* = cint(131107)
+  MON_11* = cint(131108)
+  MON_12* = cint(131109)
+  ABMON_1* = cint(131086)
+  ABMON_2* = cint(131087)
+  ABMON_3* = cint(131088)
+  ABMON_4* = cint(131089)
+  ABMON_5* = cint(131090)
+  ABMON_6* = cint(131091)
+  ABMON_7* = cint(131092)
+  ABMON_8* = cint(131093)
+  ABMON_9* = cint(131094)
+  ABMON_10* = cint(131095)
+  ABMON_11* = cint(131096)
+  ABMON_12* = cint(131097)
+  ERA* = cint(131116)
+  ERA_D_FMT* = cint(131118)
+  ERA_D_T_FMT* = cint(131120)
+  ERA_T_FMT* = cint(131121)
+  ALT_DIGITS* = cint(131119)
+  RADIXCHAR* = cint(65536)
+  THOUSEP* = cint(65537)
+  YESEXPR* = cint(327680)
+  NOEXPR* = cint(327681)
+  CRNCYSTR* = cint(262159)
+  LC_ALL* = cint(6)
+  LC_COLLATE* = cint(3)
+  LC_CTYPE* = cint(0)
+  LC_MESSAGES* = cint(5)
+  LC_MONETARY* = cint(4)
+  LC_NUMERIC* = cint(1)
+  LC_TIME* = cint(2)
+  PTHREAD_BARRIER_SERIAL_THREAD* = cint(-1)
+  PTHREAD_CANCEL_ASYNCHRONOUS* = cint(1)
+  PTHREAD_CANCEL_ENABLE* = cint(0)
+  PTHREAD_CANCEL_DEFERRED* = cint(0)
+  PTHREAD_CANCEL_DISABLE* = cint(1)
+  PTHREAD_CREATE_DETACHED* = cint(1)
+  PTHREAD_CREATE_JOINABLE* = cint(0)
+  PTHREAD_EXPLICIT_SCHED* = cint(1)
+  PTHREAD_INHERIT_SCHED* = cint(0)
+  PTHREAD_ONCE_INIT* = cint(0)
+  PTHREAD_PROCESS_SHARED* = cint(1)
+  PTHREAD_PROCESS_PRIVATE* = cint(0)
+  PTHREAD_SCOPE_PROCESS* = cint(1)
+  PTHREAD_SCOPE_SYSTEM* = cint(0)
+  POSIX_ASYNC_IO* = cint(1)
+  F_OK* = cint(0)
+  R_OK* = cint(4)
+  W_OK* = cint(2)
+  X_OK* = cint(1)
+  CS_PATH* = cint(0)
+  CS_POSIX_V6_ILP32_OFF32_CFLAGS* = cint(1116)
+  CS_POSIX_V6_ILP32_OFF32_LDFLAGS* = cint(1117)
+  CS_POSIX_V6_ILP32_OFF32_LIBS* = cint(1118)
+  CS_POSIX_V6_ILP32_OFFBIG_CFLAGS* = cint(1120)
+  CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS* = cint(1121)
+  CS_POSIX_V6_ILP32_OFFBIG_LIBS* = cint(1122)
+  CS_POSIX_V6_LP64_OFF64_CFLAGS* = cint(1124)
+  CS_POSIX_V6_LP64_OFF64_LDFLAGS* = cint(1125)
+  CS_POSIX_V6_LP64_OFF64_LIBS* = cint(1126)
+  CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS* = cint(1128)
+  CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS* = cint(1129)
+  CS_POSIX_V6_LPBIG_OFFBIG_LIBS* = cint(1130)
+  CS_POSIX_V6_WIDTH_RESTRICTED_ENVS* = cint(1)
+  F_LOCK* = cint(1)
+  F_TEST* = cint(3)
+  F_TLOCK* = cint(2)
+  F_ULOCK* = cint(0)
+  PC_2_SYMLINKS* = cint(20)
+  PC_ALLOC_SIZE_MIN* = cint(18)
+  PC_ASYNC_IO* = cint(10)
+  PC_CHOWN_RESTRICTED* = cint(6)
+  PC_FILESIZEBITS* = cint(13)
+  PC_LINK_MAX* = cint(0)
+  PC_MAX_CANON* = cint(1)
+  PC_MAX_INPUT* = cint(2)
+  PC_NAME_MAX* = cint(3)
+  PC_NO_TRUNC* = cint(7)
+  PC_PATH_MAX* = cint(4)
+  PC_PIPE_BUF* = cint(5)
+  PC_PRIO_IO* = cint(11)
+  PC_REC_INCR_XFER_SIZE* = cint(14)
+  PC_REC_MIN_XFER_SIZE* = cint(16)
+  PC_REC_XFER_ALIGN* = cint(17)
+  PC_SYMLINK_MAX* = cint(19)
+  PC_SYNC_IO* = cint(9)
+  PC_VDISABLE* = cint(8)
+  SC_2_C_BIND* = cint(47)
+  SC_2_C_DEV* = cint(48)
+  SC_2_CHAR_TERM* = cint(95)
+  SC_2_FORT_DEV* = cint(49)
+  SC_2_FORT_RUN* = cint(50)
+  SC_2_LOCALEDEF* = cint(52)
+  SC_2_PBS* = cint(168)
+  SC_2_PBS_ACCOUNTING* = cint(169)
+  SC_2_PBS_CHECKPOINT* = cint(175)
+  SC_2_PBS_LOCATE* = cint(170)
+  SC_2_PBS_MESSAGE* = cint(171)
+  SC_2_PBS_TRACK* = cint(172)
+  SC_2_SW_DEV* = cint(51)
+  SC_2_UPE* = cint(97)
+  SC_2_VERSION* = cint(46)
+  SC_ADVISORY_INFO* = cint(132)
+  SC_AIO_LISTIO_MAX* = cint(23)
+  SC_AIO_MAX* = cint(24)
+  SC_AIO_PRIO_DELTA_MAX* = cint(25)
+  SC_ARG_MAX* = cint(0)
+  SC_ASYNCHRONOUS_IO* = cint(12)
+  SC_ATEXIT_MAX* = cint(87)
+  SC_BARRIERS* = cint(133)
+  SC_BC_BASE_MAX* = cint(36)
+  SC_BC_DIM_MAX* = cint(37)
+  SC_BC_SCALE_MAX* = cint(38)
+  SC_BC_STRING_MAX* = cint(39)
+  SC_CHILD_MAX* = cint(1)
+  SC_CLK_TCK* = cint(2)
+  SC_CLOCK_SELECTION* = cint(137)
+  SC_COLL_WEIGHTS_MAX* = cint(40)
+  SC_CPUTIME* = cint(138)
+  SC_DELAYTIMER_MAX* = cint(26)
+  SC_EXPR_NEST_MAX* = cint(42)
+  SC_FSYNC* = cint(15)
+  SC_GETGR_R_SIZE_MAX* = cint(69)
+  SC_GETPW_R_SIZE_MAX* = cint(70)
+  SC_HOST_NAME_MAX* = cint(180)
+  SC_IOV_MAX* = cint(60)
+  SC_IPV6* = cint(235)
+  SC_JOB_CONTROL* = cint(7)
+  SC_LINE_MAX* = cint(43)
+  SC_LOGIN_NAME_MAX* = cint(71)
+  SC_MAPPED_FILES* = cint(16)
+  SC_MEMLOCK* = cint(17)
+  SC_MEMLOCK_RANGE* = cint(18)
+  SC_MEMORY_PROTECTION* = cint(19)
+  SC_MESSAGE_PASSING* = cint(20)
+  SC_MONOTONIC_CLOCK* = cint(149)
+  SC_MQ_OPEN_MAX* = cint(27)
+  SC_MQ_PRIO_MAX* = cint(28)
+  SC_NGROUPS_MAX* = cint(3)
+  SC_OPEN_MAX* = cint(4)
+  SC_PAGE_SIZE* = cint(30)
+  SC_PRIORITIZED_IO* = cint(13)
+  SC_PRIORITY_SCHEDULING* = cint(10)
+  SC_RAW_SOCKETS* = cint(236)
+  SC_RE_DUP_MAX* = cint(44)
+  SC_READER_WRITER_LOCKS* = cint(153)
+  SC_REALTIME_SIGNALS* = cint(9)
+  SC_REGEXP* = cint(155)
+  SC_RTSIG_MAX* = cint(31)
+  SC_SAVED_IDS* = cint(8)
+  SC_SEM_NSEMS_MAX* = cint(32)
+  SC_SEM_VALUE_MAX* = cint(33)
+  SC_SEMAPHORES* = cint(21)
+  SC_SHARED_MEMORY_OBJECTS* = cint(22)
+  SC_SHELL* = cint(157)
+  SC_SIGQUEUE_MAX* = cint(34)
+  SC_SPAWN* = cint(159)
+  SC_SPIN_LOCKS* = cint(154)
+  SC_SPORADIC_SERVER* = cint(160)
+  SC_STREAM_MAX* = cint(5)
+  SC_SYMLOOP_MAX* = cint(173)
+  SC_SYNCHRONIZED_IO* = cint(14)
+  SC_THREAD_ATTR_STACKADDR* = cint(77)
+  SC_THREAD_ATTR_STACKSIZE* = cint(78)
+  SC_THREAD_CPUTIME* = cint(139)
+  SC_THREAD_DESTRUCTOR_ITERATIONS* = cint(73)
+  SC_THREAD_KEYS_MAX* = cint(74)
+  SC_THREAD_PRIO_INHERIT* = cint(80)
+  SC_THREAD_PRIO_PROTECT* = cint(81)
+  SC_THREAD_PRIORITY_SCHEDULING* = cint(79)
+  SC_THREAD_PROCESS_SHARED* = cint(82)
+  SC_THREAD_SAFE_FUNCTIONS* = cint(68)
+  SC_THREAD_SPORADIC_SERVER* = cint(161)
+  SC_THREAD_STACK_MIN* = cint(75)
+  SC_THREAD_THREADS_MAX* = cint(76)
+  SC_THREADS* = cint(67)
+  SC_TIMEOUTS* = cint(164)
+  SC_TIMER_MAX* = cint(35)
+  SC_TIMERS* = cint(11)
+  SC_TRACE* = cint(181)
+  SC_TRACE_EVENT_FILTER* = cint(182)
+  SC_TRACE_INHERIT* = cint(183)
+  SC_TRACE_LOG* = cint(184)
+  SC_TTY_NAME_MAX* = cint(72)
+  SC_TYPED_MEMORY_OBJECTS* = cint(165)
+  SC_TZNAME_MAX* = cint(6)
+  SC_V6_ILP32_OFF32* = cint(176)
+  SC_V6_ILP32_OFFBIG* = cint(177)
+  SC_V6_LP64_OFF64* = cint(178)
+  SC_V6_LPBIG_OFFBIG* = cint(179)
+  SC_VERSION* = cint(29)
+  SC_XBS5_ILP32_OFF32* = cint(125)
+  SC_XBS5_ILP32_OFFBIG* = cint(126)
+  SC_XBS5_LP64_OFF64* = cint(127)
+  SC_XBS5_LPBIG_OFFBIG* = cint(128)
+  SC_XOPEN_CRYPT* = cint(92)
+  SC_XOPEN_ENH_I18N* = cint(93)
+  SC_XOPEN_LEGACY* = cint(129)
+  SC_XOPEN_REALTIME* = cint(130)
+  SC_XOPEN_REALTIME_THREADS* = cint(131)
+  SC_XOPEN_SHM* = cint(94)
+  SC_XOPEN_UNIX* = cint(91)
+  SC_XOPEN_VERSION* = cint(89)
+  SEEK_SET* = cint(0)
+  SEEK_CUR* = cint(1)
+  SEEK_END* = cint(2)
+  SEM_FAILED* = cast[pointer]((nil))
+  IPC_CREAT* = cint(512)
+  IPC_EXCL* = cint(1024)
+  IPC_NOWAIT* = cint(2048)
+  IPC_PRIVATE* = cint(0)
+  IPC_RMID* = cint(0)
+  IPC_SET* = cint(1)
+  IPC_STAT* = cint(2)
+  S_IFMT* = cint(61440)
+  S_IFBLK* = cint(24576)
+  S_IFCHR* = cint(8192)
+  S_IFIFO* = cint(4096)
+  S_IFREG* = cint(32768)
+  S_IFDIR* = cint(16384)
+  S_IFLNK* = cint(40960)
+  S_IFSOCK* = cint(49152)
+  S_IRWXU* = cint(448)
+  S_IRUSR* = cint(256)
+  S_IWUSR* = cint(128)
+  S_IXUSR* = cint(64)
+  S_IRWXG* = cint(56)
+  S_IRGRP* = cint(32)
+  S_IWGRP* = cint(16)
+  S_IXGRP* = cint(8)
+  S_IRWXO* = cint(7)
+  S_IROTH* = cint(4)
+  S_IWOTH* = cint(2)
+  S_IXOTH* = cint(1)
+  S_ISUID* = cint(2048)
+  S_ISGID* = cint(1024)
+  S_ISVTX* = cint(512)
+  ST_RDONLY* = cint(1)
+  ST_NOSUID* = cint(2)
+  PROT_READ* = cint(1)
+  PROT_WRITE* = cint(2)
+  PROT_EXEC* = cint(4)
+  PROT_NONE* = cint(0)
+  MAP_SHARED* = cint(1)
+  MAP_PRIVATE* = cint(2)
+  MAP_FIXED* = cint(16)
+  MS_ASYNC* = cint(1)
+  MS_SYNC* = cint(4)
+  MS_INVALIDATE* = cint(2)
+  MCL_CURRENT* = cint(1)
+  MCL_FUTURE* = cint(2)
+  MAP_FAILED* = cast[pointer](0xffffffffffffffff)
+  POSIX_MADV_NORMAL* = cint(0)
+  POSIX_MADV_SEQUENTIAL* = cint(2)
+  POSIX_MADV_RANDOM* = cint(1)
+  POSIX_MADV_WILLNEED* = cint(3)
+  POSIX_MADV_DONTNEED* = cint(4)
+  CLOCKS_PER_SEC* = clong(1000000)
+  CLOCK_PROCESS_CPUTIME_ID* = cint(2)
+  CLOCK_THREAD_CPUTIME_ID* = cint(3)
+  CLOCK_REALTIME* = cint(0)
+  TIMER_ABSTIME* = cint(1)
+  CLOCK_MONOTONIC* = cint(1)
+  WNOHANG* = cint(1)
+  WUNTRACED* = cint(2)
+  WEXITED* = cint(4)
+  WSTOPPED* = cint(2)
+  WCONTINUED* = cint(8)
+  WNOWAIT* = cint(16777216)
+  SIGEV_NONE* = cint(1)
+  SIGEV_SIGNAL* = cint(0)
+  SIGEV_THREAD* = cint(2)
+  SIGABRT* = cint(6)
+  SIGALRM* = cint(14)
+  SIGBUS* = cint(7)
+  SIGCHLD* = cint(17)
+  SIGCONT* = cint(18)
+  SIGFPE* = cint(8)
+  SIGHUP* = cint(1)
+  SIGILL* = cint(4)
+  SIGINT* = cint(2)
+  SIGKILL* = cint(9)
+  SIGPIPE* = cint(13)
+  SIGQUIT* = cint(3)
+  SIGSEGV* = cint(11)
+  SIGSTOP* = cint(19)
+  SIGTERM* = cint(15)
+  SIGTSTP* = cint(20)
+  SIGTTIN* = cint(21)
+  SIGTTOU* = cint(22)
+  SIGUSR1* = cint(10)
+  SIGUSR2* = cint(12)
+  SIGPOLL* = cint(29)
+  SIGPROF* = cint(27)
+  SIGSYS* = cint(31)
+  SIGTRAP* = cint(5)
+  SIGURG* = cint(23)
+  SIGVTALRM* = cint(26)
+  SIGXCPU* = cint(24)
+  SIGXFSZ* = cint(25)
+  SA_NOCLDSTOP* = cint(1)
+  SIG_BLOCK* = cint(0)
+  SIG_UNBLOCK* = cint(1)
+  SIG_SETMASK* = cint(2)
+  SA_ONSTACK* = cint(134217728)
+  SA_RESETHAND* = cint(-2147483648)
+  SA_RESTART* = cint(268435456)
+  SA_SIGINFO* = cint(4)
+  SA_NOCLDWAIT* = cint(2)
+  SA_NODEFER* = cint(1073741824)
+  SS_ONSTACK* = cint(1)
+  SS_DISABLE* = cint(2)
+  MINSIGSTKSZ* = cint(2048)
+  SIGSTKSZ* = cint(8192)
+  NL_SETD* = cint(1)
+  NL_CAT_LOCALE* = cint(1)
+  SCHED_FIFO* = cint(1)
+  SCHED_RR* = cint(2)
+  SCHED_OTHER* = cint(0)
+  FD_SETSIZE* = cint(1024)
+  IF_NAMESIZE* = cint(16)
+  SCM_RIGHTS* = cint(1)
+  SOCK_DGRAM* = cint(2)
+  SOCK_RAW* = cint(3)
+  SOCK_SEQPACKET* = cint(5)
+  SOCK_STREAM* = cint(1)
+  SOL_SOCKET* = cint(1)
+  SO_ACCEPTCONN* = cint(30)
+  SO_BROADCAST* = cint(6)
+  SO_DEBUG* = cint(1)
+  SO_DONTROUTE* = cint(5)
+  SO_ERROR* = cint(4)
+  SO_KEEPALIVE* = cint(9)
+  SO_LINGER* = cint(13)
+  SO_OOBINLINE* = cint(10)
+  SO_RCVBUF* = cint(8)
+  SO_RCVLOWAT* = cint(18)
+  SO_RCVTIMEO* = cint(20)
+  SO_REUSEADDR* = cint(2)
+  SO_SNDBUF* = cint(7)
+  SO_SNDLOWAT* = cint(19)
+  SO_SNDTIMEO* = cint(21)
+  SO_TYPE* = cint(3)
+  SOMAXCONN* = cint(128)
+  MSG_CTRUNC* = cint(8)
+  MSG_DONTROUTE* = cint(4)
+  MSG_EOR* = cint(128)
+  MSG_OOB* = cint(1)
+  MSG_PEEK* = cint(2)
+  MSG_TRUNC* = cint(32)
+  MSG_WAITALL* = cint(256)
+  AF_INET* = cint(2)
+  AF_INET6* = cint(10)
+  AF_UNIX* = cint(1)
+  AF_UNSPEC* = cint(0)
+  SHUT_RD* = cint(0)
+  SHUT_RDWR* = cint(2)
+  SHUT_WR* = cint(1)
+  IPPROTO_IP* = cint(0)
+  IPPROTO_IPV6* = cint(41)
+  IPPROTO_ICMP* = cint(1)
+  IPPROTO_RAW* = cint(255)
+  IPPROTO_TCP* = cint(6)
+  IPPROTO_UDP* = cint(17)
+  INADDR_ANY* = cint(0)
+  INADDR_BROADCAST* = cint(-1)
+  INET_ADDRSTRLEN* = cint(16)
+  IPV6_JOIN_GROUP* = cint(20)
+  IPV6_LEAVE_GROUP* = cint(21)
+  IPV6_MULTICAST_HOPS* = cint(18)
+  IPV6_MULTICAST_IF* = cint(17)
+  IPV6_MULTICAST_LOOP* = cint(19)
+  IPV6_UNICAST_HOPS* = cint(16)
+  IPV6_V6ONLY* = cint(26)
+  IPPORT_RESERVED* = cint(1024)
+  HOST_NOT_FOUND* = cint(1)
+  NO_DATA* = cint(4)
+  NO_RECOVERY* = cint(3)
+  TRY_AGAIN* = cint(2)
+  AI_PASSIVE* = cint(1)
+  AI_CANONNAME* = cint(2)
+  AI_NUMERICHOST* = cint(4)
+  AI_NUMERICSERV* = cint(1024)
+  AI_V4MAPPED* = cint(8)
+  AI_ALL* = cint(16)
+  AI_ADDRCONFIG* = cint(32)
+  NI_NOFQDN* = cint(4)
+  NI_NUMERICHOST* = cint(1)
+  NI_NAMEREQD* = cint(8)
+  NI_NUMERICSERV* = cint(2)
+  NI_DGRAM* = cint(16)
+  EAI_AGAIN* = cint(-3)
+  EAI_BADFLAGS* = cint(-1)
+  EAI_FAIL* = cint(-4)
+  EAI_FAMILY* = cint(-6)
+  EAI_MEMORY* = cint(-10)
+  EAI_NONAME* = cint(-2)
+  EAI_SERVICE* = cint(-8)
+  EAI_SOCKTYPE* = cint(-7)
+  EAI_SYSTEM* = cint(-11)
+  EAI_OVERFLOW* = cint(-12)
+  POLLIN* = cshort(1)
+  POLLPRI* = cshort(2)
+  POLLOUT* = cshort(4)
+  POLLERR* = cshort(8)
+  POLLHUP* = cshort(16)
+  POLLNVAL* = cshort(32)
+  POSIX_SPAWN_RESETIDS* = cint(1)
+  POSIX_SPAWN_SETPGROUP* = cint(2)
+  POSIX_SPAWN_SETSCHEDPARAM* = cint(16)
+  POSIX_SPAWN_SETSCHEDULER* = cint(32)
+  POSIX_SPAWN_SETSIGDEF* = cint(4)
+  POSIX_SPAWN_SETSIGMASK* = cint(8)
diff --git a/lib/posix/linux_consts.nim b/lib/posix/linux_consts.nim
new file mode 100644
index 000000000..2fadcd83b
--- /dev/null
+++ b/lib/posix/linux_consts.nim
@@ -0,0 +1,620 @@
+# Generated by detect.nim
+const
+  AIO_ALLDONE* = cint(2)
+  AIO_CANCELED* = cint(0)
+  AIO_NOTCANCELED* = cint(1)
+  LIO_NOP* = cint(2)
+  LIO_NOWAIT* = cint(1)
+  LIO_READ* = cint(0)
+  LIO_WAIT* = cint(0)
+  LIO_WRITE* = cint(1)
+  RTLD_LAZY* = cint(1)
+  RTLD_NOW* = cint(2)
+  RTLD_GLOBAL* = cint(256)
+  RTLD_LOCAL* = cint(0)
+  E2BIG* = cint(7)
+  EACCES* = cint(13)
+  EADDRINUSE* = cint(98)
+  EADDRNOTAVAIL* = cint(99)
+  EAFNOSUPPORT* = cint(97)
+  EAGAIN* = cint(11)
+  EALREADY* = cint(114)
+  EBADF* = cint(9)
+  EBADMSG* = cint(74)
+  EBUSY* = cint(16)
+  ECANCELED* = cint(125)
+  ECHILD* = cint(10)
+  ECONNABORTED* = cint(103)
+  ECONNREFUSED* = cint(111)
+  ECONNRESET* = cint(104)
+  EDEADLK* = cint(35)
+  EDESTADDRREQ* = cint(89)
+  EDOM* = cint(33)
+  EDQUOT* = cint(122)
+  EEXIST* = cint(17)
+  EFAULT* = cint(14)
+  EFBIG* = cint(27)
+  EHOSTUNREACH* = cint(113)
+  EIDRM* = cint(43)
+  EILSEQ* = cint(84)
+  EINPROGRESS* = cint(115)
+  EINTR* = cint(4)
+  EINVAL* = cint(22)
+  EIO* = cint(5)
+  EISCONN* = cint(106)
+  EISDIR* = cint(21)
+  ELOOP* = cint(40)
+  EMFILE* = cint(24)
+  EMLINK* = cint(31)
+  EMSGSIZE* = cint(90)
+  EMULTIHOP* = cint(72)
+  ENAMETOOLONG* = cint(36)
+  ENETDOWN* = cint(100)
+  ENETRESET* = cint(102)
+  ENETUNREACH* = cint(101)
+  ENFILE* = cint(23)
+  ENOBUFS* = cint(105)
+  ENODATA* = cint(61)
+  ENODEV* = cint(19)
+  ENOENT* = cint(2)
+  ENOEXEC* = cint(8)
+  ENOLCK* = cint(37)
+  ENOLINK* = cint(67)
+  ENOMEM* = cint(12)
+  ENOMSG* = cint(42)
+  ENOPROTOOPT* = cint(92)
+  ENOSPC* = cint(28)
+  ENOSR* = cint(63)
+  ENOSTR* = cint(60)
+  ENOSYS* = cint(38)
+  ENOTCONN* = cint(107)
+  ENOTDIR* = cint(20)
+  ENOTEMPTY* = cint(39)
+  ENOTSOCK* = cint(88)
+  ENOTSUP* = cint(95)
+  ENOTTY* = cint(25)
+  ENXIO* = cint(6)
+  EOPNOTSUPP* = cint(95)
+  EOVERFLOW* = cint(75)
+  EPERM* = cint(1)
+  EPIPE* = cint(32)
+  EPROTO* = cint(71)
+  EPROTONOSUPPORT* = cint(93)
+  EPROTOTYPE* = cint(91)
+  ERANGE* = cint(34)
+  EROFS* = cint(30)
+  ESPIPE* = cint(29)
+  ESRCH* = cint(3)
+  ESTALE* = cint(116)
+  ETIME* = cint(62)
+  ETIMEDOUT* = cint(110)
+  ETXTBSY* = cint(26)
+  EWOULDBLOCK* = cint(11)
+  EXDEV* = cint(18)
+  F_DUPFD* = cint(0)
+  F_GETFD* = cint(1)
+  F_SETFD* = cint(2)
+  F_GETFL* = cint(3)
+  F_SETFL* = cint(4)
+  F_GETLK* = cint(5)
+  F_SETLK* = cint(6)
+  F_SETLKW* = cint(7)
+  F_GETOWN* = cint(9)
+  F_SETOWN* = cint(8)
+  FD_CLOEXEC* = cint(1)
+  F_RDLCK* = cint(0)
+  F_UNLCK* = cint(2)
+  F_WRLCK* = cint(1)
+  O_CREAT* = cint(64)
+  O_EXCL* = cint(128)
+  O_NOCTTY* = cint(256)
+  O_TRUNC* = cint(512)
+  O_APPEND* = cint(1024)
+  O_DSYNC* = cint(4096)
+  O_NONBLOCK* = cint(2048)
+  O_RSYNC* = cint(4096)
+  O_SYNC* = cint(4096)
+  O_ACCMODE* = cint(3)
+  O_RDONLY* = cint(0)
+  O_RDWR* = cint(2)
+  O_WRONLY* = cint(1)
+  POSIX_FADV_NORMAL* = cint(0)
+  POSIX_FADV_SEQUENTIAL* = cint(2)
+  POSIX_FADV_RANDOM* = cint(1)
+  POSIX_FADV_WILLNEED* = cint(3)
+  POSIX_FADV_DONTNEED* = cint(4)
+  POSIX_FADV_NOREUSE* = cint(5)
+  FE_DIVBYZERO* = cint(4)
+  FE_INEXACT* = cint(32)
+  FE_INVALID* = cint(1)
+  FE_OVERFLOW* = cint(8)
+  FE_UNDERFLOW* = cint(16)
+  FE_ALL_EXCEPT* = cint(61)
+  FE_DOWNWARD* = cint(1024)
+  FE_TONEAREST* = cint(0)
+  FE_TOWARDZERO* = cint(3072)
+  FE_UPWARD* = cint(2048)
+  FE_DFL_ENV* = cast[pointer](0xffffffffffffffff)
+  MM_HARD* = cint(1)
+  MM_SOFT* = cint(2)
+  MM_FIRM* = cint(4)
+  MM_APPL* = cint(8)
+  MM_UTIL* = cint(16)
+  MM_OPSYS* = cint(32)
+  MM_RECOVER* = cint(64)
+  MM_NRECOV* = cint(128)
+  MM_HALT* = cint(1)
+  MM_ERROR* = cint(2)
+  MM_WARNING* = cint(3)
+  MM_INFO* = cint(4)
+  MM_NOSEV* = cint(0)
+  MM_PRINT* = cint(256)
+  MM_CONSOLE* = cint(512)
+  MM_OK* = cint(0)
+  MM_NOTOK* = cint(-1)
+  MM_NOMSG* = cint(1)
+  MM_NOCON* = cint(4)
+  FNM_NOMATCH* = cint(1)
+  FNM_PATHNAME* = cint(1)
+  FNM_PERIOD* = cint(4)
+  FNM_NOESCAPE* = cint(2)
+  FTW_F* = cint(0)
+  FTW_D* = cint(1)
+  FTW_DNR* = cint(2)
+  FTW_NS* = cint(3)
+  FTW_SL* = cint(4)
+  GLOB_APPEND* = cint(32)
+  GLOB_DOOFFS* = cint(8)
+  GLOB_ERR* = cint(1)
+  GLOB_MARK* = cint(2)
+  GLOB_NOCHECK* = cint(16)
+  GLOB_NOESCAPE* = cint(64)
+  GLOB_NOSORT* = cint(4)
+  GLOB_ABORTED* = cint(2)
+  GLOB_NOMATCH* = cint(3)
+  GLOB_NOSPACE* = cint(1)
+  GLOB_NOSYS* = cint(4)
+  CODESET* = cint(14)
+  D_T_FMT* = cint(131112)
+  D_FMT* = cint(131113)
+  T_FMT* = cint(131114)
+  T_FMT_AMPM* = cint(131115)
+  AM_STR* = cint(131110)
+  PM_STR* = cint(131111)
+  DAY_1* = cint(131079)
+  DAY_2* = cint(131080)
+  DAY_3* = cint(131081)
+  DAY_4* = cint(131082)
+  DAY_5* = cint(131083)
+  DAY_6* = cint(131084)
+  DAY_7* = cint(131085)
+  ABDAY_1* = cint(131072)
+  ABDAY_2* = cint(131073)
+  ABDAY_3* = cint(131074)
+  ABDAY_4* = cint(131075)
+  ABDAY_5* = cint(131076)
+  ABDAY_6* = cint(131077)
+  ABDAY_7* = cint(131078)
+  MON_1* = cint(131098)
+  MON_2* = cint(131099)
+  MON_3* = cint(131100)
+  MON_4* = cint(131101)
+  MON_5* = cint(131102)
+  MON_6* = cint(131103)
+  MON_7* = cint(131104)
+  MON_8* = cint(131105)
+  MON_9* = cint(131106)
+  MON_10* = cint(131107)
+  MON_11* = cint(131108)
+  MON_12* = cint(131109)
+  ABMON_1* = cint(131086)
+  ABMON_2* = cint(131087)
+  ABMON_3* = cint(131088)
+  ABMON_4* = cint(131089)
+  ABMON_5* = cint(131090)
+  ABMON_6* = cint(131091)
+  ABMON_7* = cint(131092)
+  ABMON_8* = cint(131093)
+  ABMON_9* = cint(131094)
+  ABMON_10* = cint(131095)
+  ABMON_11* = cint(131096)
+  ABMON_12* = cint(131097)
+  ERA* = cint(131116)
+  ERA_D_FMT* = cint(131118)
+  ERA_D_T_FMT* = cint(131120)
+  ERA_T_FMT* = cint(131121)
+  ALT_DIGITS* = cint(131119)
+  RADIXCHAR* = cint(65536)
+  THOUSEP* = cint(65537)
+  YESEXPR* = cint(327680)
+  NOEXPR* = cint(327681)
+  CRNCYSTR* = cint(262159)
+  LC_ALL* = cint(6)
+  LC_COLLATE* = cint(3)
+  LC_CTYPE* = cint(0)
+  LC_MESSAGES* = cint(5)
+  LC_MONETARY* = cint(4)
+  LC_NUMERIC* = cint(1)
+  LC_TIME* = cint(2)
+  PTHREAD_BARRIER_SERIAL_THREAD* = cint(-1)
+  PTHREAD_CANCEL_ASYNCHRONOUS* = cint(1)
+  PTHREAD_CANCEL_ENABLE* = cint(0)
+  PTHREAD_CANCEL_DEFERRED* = cint(0)
+  PTHREAD_CANCEL_DISABLE* = cint(1)
+  PTHREAD_CREATE_DETACHED* = cint(1)
+  PTHREAD_CREATE_JOINABLE* = cint(0)
+  PTHREAD_EXPLICIT_SCHED* = cint(1)
+  PTHREAD_INHERIT_SCHED* = cint(0)
+  PTHREAD_ONCE_INIT* = cint(0)
+  PTHREAD_PROCESS_SHARED* = cint(1)
+  PTHREAD_PROCESS_PRIVATE* = cint(0)
+  PTHREAD_SCOPE_PROCESS* = cint(1)
+  PTHREAD_SCOPE_SYSTEM* = cint(0)
+  POSIX_ASYNC_IO* = cint(1)
+  F_OK* = cint(0)
+  R_OK* = cint(4)
+  W_OK* = cint(2)
+  X_OK* = cint(1)
+  CS_PATH* = cint(0)
+  CS_POSIX_V6_ILP32_OFF32_CFLAGS* = cint(1116)
+  CS_POSIX_V6_ILP32_OFF32_LDFLAGS* = cint(1117)
+  CS_POSIX_V6_ILP32_OFF32_LIBS* = cint(1118)
+  CS_POSIX_V6_ILP32_OFFBIG_CFLAGS* = cint(1120)
+  CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS* = cint(1121)
+  CS_POSIX_V6_ILP32_OFFBIG_LIBS* = cint(1122)
+  CS_POSIX_V6_LP64_OFF64_CFLAGS* = cint(1124)
+  CS_POSIX_V6_LP64_OFF64_LDFLAGS* = cint(1125)
+  CS_POSIX_V6_LP64_OFF64_LIBS* = cint(1126)
+  CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS* = cint(1128)
+  CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS* = cint(1129)
+  CS_POSIX_V6_LPBIG_OFFBIG_LIBS* = cint(1130)
+  CS_POSIX_V6_WIDTH_RESTRICTED_ENVS* = cint(1)
+  F_LOCK* = cint(1)
+  F_TEST* = cint(3)
+  F_TLOCK* = cint(2)
+  F_ULOCK* = cint(0)
+  PC_2_SYMLINKS* = cint(20)
+  PC_ALLOC_SIZE_MIN* = cint(18)
+  PC_ASYNC_IO* = cint(10)
+  PC_CHOWN_RESTRICTED* = cint(6)
+  PC_FILESIZEBITS* = cint(13)
+  PC_LINK_MAX* = cint(0)
+  PC_MAX_CANON* = cint(1)
+  PC_MAX_INPUT* = cint(2)
+  PC_NAME_MAX* = cint(3)
+  PC_NO_TRUNC* = cint(7)
+  PC_PATH_MAX* = cint(4)
+  PC_PIPE_BUF* = cint(5)
+  PC_PRIO_IO* = cint(11)
+  PC_REC_INCR_XFER_SIZE* = cint(14)
+  PC_REC_MIN_XFER_SIZE* = cint(16)
+  PC_REC_XFER_ALIGN* = cint(17)
+  PC_SYMLINK_MAX* = cint(19)
+  PC_SYNC_IO* = cint(9)
+  PC_VDISABLE* = cint(8)
+  SC_2_C_BIND* = cint(47)
+  SC_2_C_DEV* = cint(48)
+  SC_2_CHAR_TERM* = cint(95)
+  SC_2_FORT_DEV* = cint(49)
+  SC_2_FORT_RUN* = cint(50)
+  SC_2_LOCALEDEF* = cint(52)
+  SC_2_PBS* = cint(168)
+  SC_2_PBS_ACCOUNTING* = cint(169)
+  SC_2_PBS_CHECKPOINT* = cint(175)
+  SC_2_PBS_LOCATE* = cint(170)
+  SC_2_PBS_MESSAGE* = cint(171)
+  SC_2_PBS_TRACK* = cint(172)
+  SC_2_SW_DEV* = cint(51)
+  SC_2_UPE* = cint(97)
+  SC_2_VERSION* = cint(46)
+  SC_ADVISORY_INFO* = cint(132)
+  SC_AIO_LISTIO_MAX* = cint(23)
+  SC_AIO_MAX* = cint(24)
+  SC_AIO_PRIO_DELTA_MAX* = cint(25)
+  SC_ARG_MAX* = cint(0)
+  SC_ASYNCHRONOUS_IO* = cint(12)
+  SC_ATEXIT_MAX* = cint(87)
+  SC_BARRIERS* = cint(133)
+  SC_BC_BASE_MAX* = cint(36)
+  SC_BC_DIM_MAX* = cint(37)
+  SC_BC_SCALE_MAX* = cint(38)
+  SC_BC_STRING_MAX* = cint(39)
+  SC_CHILD_MAX* = cint(1)
+  SC_CLK_TCK* = cint(2)
+  SC_CLOCK_SELECTION* = cint(137)
+  SC_COLL_WEIGHTS_MAX* = cint(40)
+  SC_CPUTIME* = cint(138)
+  SC_DELAYTIMER_MAX* = cint(26)
+  SC_EXPR_NEST_MAX* = cint(42)
+  SC_FSYNC* = cint(15)
+  SC_GETGR_R_SIZE_MAX* = cint(69)
+  SC_GETPW_R_SIZE_MAX* = cint(70)
+  SC_HOST_NAME_MAX* = cint(180)
+  SC_IOV_MAX* = cint(60)
+  SC_IPV6* = cint(235)
+  SC_JOB_CONTROL* = cint(7)
+  SC_LINE_MAX* = cint(43)
+  SC_LOGIN_NAME_MAX* = cint(71)
+  SC_MAPPED_FILES* = cint(16)
+  SC_MEMLOCK* = cint(17)
+  SC_MEMLOCK_RANGE* = cint(18)
+  SC_MEMORY_PROTECTION* = cint(19)
+  SC_MESSAGE_PASSING* = cint(20)
+  SC_MONOTONIC_CLOCK* = cint(149)
+  SC_MQ_OPEN_MAX* = cint(27)
+  SC_MQ_PRIO_MAX* = cint(28)
+  SC_NGROUPS_MAX* = cint(3)
+  SC_OPEN_MAX* = cint(4)
+  SC_PAGE_SIZE* = cint(30)
+  SC_PRIORITIZED_IO* = cint(13)
+  SC_PRIORITY_SCHEDULING* = cint(10)
+  SC_RAW_SOCKETS* = cint(236)
+  SC_RE_DUP_MAX* = cint(44)
+  SC_READER_WRITER_LOCKS* = cint(153)
+  SC_REALTIME_SIGNALS* = cint(9)
+  SC_REGEXP* = cint(155)
+  SC_RTSIG_MAX* = cint(31)
+  SC_SAVED_IDS* = cint(8)
+  SC_SEM_NSEMS_MAX* = cint(32)
+  SC_SEM_VALUE_MAX* = cint(33)
+  SC_SEMAPHORES* = cint(21)
+  SC_SHARED_MEMORY_OBJECTS* = cint(22)
+  SC_SHELL* = cint(157)
+  SC_SIGQUEUE_MAX* = cint(34)
+  SC_SPAWN* = cint(159)
+  SC_SPIN_LOCKS* = cint(154)
+  SC_SPORADIC_SERVER* = cint(160)
+  SC_STREAM_MAX* = cint(5)
+  SC_SYMLOOP_MAX* = cint(173)
+  SC_SYNCHRONIZED_IO* = cint(14)
+  SC_THREAD_ATTR_STACKADDR* = cint(77)
+  SC_THREAD_ATTR_STACKSIZE* = cint(78)
+  SC_THREAD_CPUTIME* = cint(139)
+  SC_THREAD_DESTRUCTOR_ITERATIONS* = cint(73)
+  SC_THREAD_KEYS_MAX* = cint(74)
+  SC_THREAD_PRIO_INHERIT* = cint(80)
+  SC_THREAD_PRIO_PROTECT* = cint(81)
+  SC_THREAD_PRIORITY_SCHEDULING* = cint(79)
+  SC_THREAD_PROCESS_SHARED* = cint(82)
+  SC_THREAD_SAFE_FUNCTIONS* = cint(68)
+  SC_THREAD_SPORADIC_SERVER* = cint(161)
+  SC_THREAD_STACK_MIN* = cint(75)
+  SC_THREAD_THREADS_MAX* = cint(76)
+  SC_THREADS* = cint(67)
+  SC_TIMEOUTS* = cint(164)
+  SC_TIMER_MAX* = cint(35)
+  SC_TIMERS* = cint(11)
+  SC_TRACE* = cint(181)
+  SC_TRACE_EVENT_FILTER* = cint(182)
+  SC_TRACE_INHERIT* = cint(183)
+  SC_TRACE_LOG* = cint(184)
+  SC_TTY_NAME_MAX* = cint(72)
+  SC_TYPED_MEMORY_OBJECTS* = cint(165)
+  SC_TZNAME_MAX* = cint(6)
+  SC_V6_ILP32_OFF32* = cint(176)
+  SC_V6_ILP32_OFFBIG* = cint(177)
+  SC_V6_LP64_OFF64* = cint(178)
+  SC_V6_LPBIG_OFFBIG* = cint(179)
+  SC_VERSION* = cint(29)
+  SC_XBS5_ILP32_OFF32* = cint(125)
+  SC_XBS5_ILP32_OFFBIG* = cint(126)
+  SC_XBS5_LP64_OFF64* = cint(127)
+  SC_XBS5_LPBIG_OFFBIG* = cint(128)
+  SC_XOPEN_CRYPT* = cint(92)
+  SC_XOPEN_ENH_I18N* = cint(93)
+  SC_XOPEN_LEGACY* = cint(129)
+  SC_XOPEN_REALTIME* = cint(130)
+  SC_XOPEN_REALTIME_THREADS* = cint(131)
+  SC_XOPEN_SHM* = cint(94)
+  SC_XOPEN_UNIX* = cint(91)
+  SC_XOPEN_VERSION* = cint(89)
+  SEEK_SET* = cint(0)
+  SEEK_CUR* = cint(1)
+  SEEK_END* = cint(2)
+  SEM_FAILED* = cast[pointer]((nil))
+  IPC_CREAT* = cint(512)
+  IPC_EXCL* = cint(1024)
+  IPC_NOWAIT* = cint(2048)
+  IPC_PRIVATE* = cint(0)
+  IPC_RMID* = cint(0)
+  IPC_SET* = cint(1)
+  IPC_STAT* = cint(2)
+  S_IFMT* = cint(61440)
+  S_IFBLK* = cint(24576)
+  S_IFCHR* = cint(8192)
+  S_IFIFO* = cint(4096)
+  S_IFREG* = cint(32768)
+  S_IFDIR* = cint(16384)
+  S_IFLNK* = cint(40960)
+  S_IFSOCK* = cint(49152)
+  S_IRWXU* = cint(448)
+  S_IRUSR* = cint(256)
+  S_IWUSR* = cint(128)
+  S_IXUSR* = cint(64)
+  S_IRWXG* = cint(56)
+  S_IRGRP* = cint(32)
+  S_IWGRP* = cint(16)
+  S_IXGRP* = cint(8)
+  S_IRWXO* = cint(7)
+  S_IROTH* = cint(4)
+  S_IWOTH* = cint(2)
+  S_IXOTH* = cint(1)
+  S_ISUID* = cint(2048)
+  S_ISGID* = cint(1024)
+  S_ISVTX* = cint(512)
+  ST_RDONLY* = cint(1)
+  ST_NOSUID* = cint(2)
+  PROT_READ* = cint(1)
+  PROT_WRITE* = cint(2)
+  PROT_EXEC* = cint(4)
+  PROT_NONE* = cint(0)
+  MAP_SHARED* = cint(1)
+  MAP_PRIVATE* = cint(2)
+  MAP_FIXED* = cint(16)
+  MS_ASYNC* = cint(1)
+  MS_SYNC* = cint(4)
+  MS_INVALIDATE* = cint(2)
+  MCL_CURRENT* = cint(1)
+  MCL_FUTURE* = cint(2)
+  MAP_FAILED* = cast[pointer](0xffffffffffffffff)
+  POSIX_MADV_NORMAL* = cint(0)
+  POSIX_MADV_SEQUENTIAL* = cint(2)
+  POSIX_MADV_RANDOM* = cint(1)
+  POSIX_MADV_WILLNEED* = cint(3)
+  POSIX_MADV_DONTNEED* = cint(4)
+  CLOCKS_PER_SEC* = clong(1000000)
+  CLOCK_PROCESS_CPUTIME_ID* = cint(2)
+  CLOCK_THREAD_CPUTIME_ID* = cint(3)
+  CLOCK_REALTIME* = cint(0)
+  TIMER_ABSTIME* = cint(1)
+  CLOCK_MONOTONIC* = cint(1)
+  WNOHANG* = cint(1)
+  WUNTRACED* = cint(2)
+  WEXITED* = cint(4)
+  WSTOPPED* = cint(2)
+  WCONTINUED* = cint(8)
+  WNOWAIT* = cint(16777216)
+  SIGEV_NONE* = cint(1)
+  SIGEV_SIGNAL* = cint(0)
+  SIGEV_THREAD* = cint(2)
+  SIGABRT* = cint(6)
+  SIGALRM* = cint(14)
+  SIGBUS* = cint(7)
+  SIGCHLD* = cint(17)
+  SIGCONT* = cint(18)
+  SIGFPE* = cint(8)
+  SIGHUP* = cint(1)
+  SIGILL* = cint(4)
+  SIGINT* = cint(2)
+  SIGKILL* = cint(9)
+  SIGPIPE* = cint(13)
+  SIGQUIT* = cint(3)
+  SIGSEGV* = cint(11)
+  SIGSTOP* = cint(19)
+  SIGTERM* = cint(15)
+  SIGTSTP* = cint(20)
+  SIGTTIN* = cint(21)
+  SIGTTOU* = cint(22)
+  SIGUSR1* = cint(10)
+  SIGUSR2* = cint(12)
+  SIGPOLL* = cint(29)
+  SIGPROF* = cint(27)
+  SIGSYS* = cint(31)
+  SIGTRAP* = cint(5)
+  SIGURG* = cint(23)
+  SIGVTALRM* = cint(26)
+  SIGXCPU* = cint(24)
+  SIGXFSZ* = cint(25)
+  SA_NOCLDSTOP* = cint(1)
+  SIG_BLOCK* = cint(0)
+  SIG_UNBLOCK* = cint(1)
+  SIG_SETMASK* = cint(2)
+  SA_ONSTACK* = cint(134217728)
+  SA_RESETHAND* = cint(-2147483648)
+  SA_RESTART* = cint(268435456)
+  SA_SIGINFO* = cint(4)
+  SA_NOCLDWAIT* = cint(2)
+  SA_NODEFER* = cint(1073741824)
+  SS_ONSTACK* = cint(1)
+  SS_DISABLE* = cint(2)
+  MINSIGSTKSZ* = cint(2048)
+  SIGSTKSZ* = cint(8192)
+  NL_SETD* = cint(1)
+  NL_CAT_LOCALE* = cint(1)
+  SCHED_FIFO* = cint(1)
+  SCHED_RR* = cint(2)
+  SCHED_OTHER* = cint(0)
+  FD_SETSIZE* = cint(1024)
+  IF_NAMESIZE* = cint(16)
+  SCM_RIGHTS* = cint(1)
+  SOCK_DGRAM* = cint(2)
+  SOCK_RAW* = cint(3)
+  SOCK_SEQPACKET* = cint(5)
+  SOCK_STREAM* = cint(1)
+  SOL_SOCKET* = cint(1)
+  SO_ACCEPTCONN* = cint(30)
+  SO_BROADCAST* = cint(6)
+  SO_DEBUG* = cint(1)
+  SO_DONTROUTE* = cint(5)
+  SO_ERROR* = cint(4)
+  SO_KEEPALIVE* = cint(9)
+  SO_LINGER* = cint(13)
+  SO_OOBINLINE* = cint(10)
+  SO_RCVBUF* = cint(8)
+  SO_RCVLOWAT* = cint(18)
+  SO_RCVTIMEO* = cint(20)
+  SO_REUSEADDR* = cint(2)
+  SO_SNDBUF* = cint(7)
+  SO_SNDLOWAT* = cint(19)
+  SO_SNDTIMEO* = cint(21)
+  SO_TYPE* = cint(3)
+  SOMAXCONN* = cint(128)
+  MSG_CTRUNC* = cint(8)
+  MSG_DONTROUTE* = cint(4)
+  MSG_EOR* = cint(128)
+  MSG_OOB* = cint(1)
+  MSG_PEEK* = cint(2)
+  MSG_TRUNC* = cint(32)
+  MSG_WAITALL* = cint(256)
+  AF_INET* = cint(2)
+  AF_INET6* = cint(10)
+  AF_UNIX* = cint(1)
+  AF_UNSPEC* = cint(0)
+  SHUT_RD* = cint(0)
+  SHUT_RDWR* = cint(2)
+  SHUT_WR* = cint(1)
+  IPPROTO_IP* = cint(0)
+  IPPROTO_IPV6* = cint(41)
+  IPPROTO_ICMP* = cint(1)
+  IPPROTO_RAW* = cint(255)
+  IPPROTO_TCP* = cint(6)
+  IPPROTO_UDP* = cint(17)
+  INADDR_ANY* = cint(0)
+  INADDR_BROADCAST* = cint(-1)
+  INET_ADDRSTRLEN* = cint(16)
+  IPV6_JOIN_GROUP* = cint(20)
+  IPV6_LEAVE_GROUP* = cint(21)
+  IPV6_MULTICAST_HOPS* = cint(18)
+  IPV6_MULTICAST_IF* = cint(17)
+  IPV6_MULTICAST_LOOP* = cint(19)
+  IPV6_UNICAST_HOPS* = cint(16)
+  IPV6_V6ONLY* = cint(26)
+  IPPORT_RESERVED* = cint(1024)
+  HOST_NOT_FOUND* = cint(1)
+  NO_DATA* = cint(4)
+  NO_RECOVERY* = cint(3)
+  TRY_AGAIN* = cint(2)
+  AI_PASSIVE* = cint(1)
+  AI_CANONNAME* = cint(2)
+  AI_NUMERICHOST* = cint(4)
+  AI_NUMERICSERV* = cint(1024)
+  AI_V4MAPPED* = cint(8)
+  AI_ALL* = cint(16)
+  AI_ADDRCONFIG* = cint(32)
+  NI_NOFQDN* = cint(4)
+  NI_NUMERICHOST* = cint(1)
+  NI_NAMEREQD* = cint(8)
+  NI_NUMERICSERV* = cint(2)
+  NI_DGRAM* = cint(16)
+  EAI_AGAIN* = cint(-3)
+  EAI_BADFLAGS* = cint(-1)
+  EAI_FAIL* = cint(-4)
+  EAI_FAMILY* = cint(-6)
+  EAI_MEMORY* = cint(-10)
+  EAI_NONAME* = cint(-2)
+  EAI_SERVICE* = cint(-8)
+  EAI_SOCKTYPE* = cint(-7)
+  EAI_SYSTEM* = cint(-11)
+  EAI_OVERFLOW* = cint(-12)
+  POLLIN* = cshort(1)
+  POLLPRI* = cshort(2)
+  POLLOUT* = cshort(4)
+  POLLERR* = cshort(8)
+  POLLHUP* = cshort(16)
+  POLLNVAL* = cshort(32)
+  POSIX_SPAWN_RESETIDS* = cint(1)
+  POSIX_SPAWN_SETPGROUP* = cint(2)
+  POSIX_SPAWN_SETSCHEDPARAM* = cint(16)
+  POSIX_SPAWN_SETSCHEDULER* = cint(32)
+  POSIX_SPAWN_SETSIGDEF* = cint(4)
+  POSIX_SPAWN_SETSIGMASK* = cint(8)
diff --git a/tests/curltest.nim b/tests/curltest.nim
new file mode 100644
index 000000000..7b040c20a
--- /dev/null
+++ b/tests/curltest.nim
@@ -0,0 +1,10 @@
+import 
+  libcurl
+
+var hCurl = curl_easy_init()
+if hCurl != nil: 
+  discard curl_easy_setopt(hCurl, CURLOPT_VERBOSE, True)
+  discard curl_easy_setopt(hCurl, CURLOPT_URL, "http://nimrod.ethexor.com")
+  discard curl_easy_perform(hCurl)
+  curl_easy_cleanup(hCurl)
+
diff --git a/tests/md5.nim b/tests/md5.nim
new file mode 100644
index 000000000..003014043
--- /dev/null
+++ b/tests/md5.nim
@@ -0,0 +1,249 @@
+#
+#
+#            Nimrod's Runtime Library
+#        (c) Copyright 2009 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## Module for computing MD5 checksums.
+
+type 
+  MD5State = array[0..3, int32]
+  MD5Block = array[0..15, int32]
+  MD5CBits = array[0..7, int8]
+  MD5Digest* = array[0..15, int8]
+  MD5Buffer = array[0..63, int8]
+  MD5Context* {.final.} = object 
+    State: MD5State
+    Count: array[0..1, int32]
+    Buffer: MD5Buffer
+
+const 
+  padding: cstring = "\x80\0\0\0" &
+                     "\0\0\0\0\0\0\0\0" &
+                     "\0\0\0\0\0\0\0\0" &
+                     "\0\0\0\0\0\0\0\0" &
+                     "\0\0\0\0\0\0\0\0" &
+                     "\0\0\0\0\0\0\0\0" &
+                     "\0\0\0\0\0\0\0\0" &
+                     "\0\0\0\0\0\0\0\0" &
+                     "\0\0\0\0"
+
+proc F(x, y, z: int32): int32 {.inline.} = 
+  Result = (x and y) or ((not x) and z)
+
+proc G(x, y, z: int32): int32 {.inline.} = 
+  Result = (x and z) or (y and (not z))
+
+proc H(x, y, z: int32): int32 {.inline.} = 
+  Result = x xor y xor z
+
+proc I(x, y, z: int32): int32 {.inline.} = 
+  Result = y xor (x or (not z))
+
+proc rot(x: var int32, n: int8) {.inline.} = 
+  x = toU32(x shl ze(n)) or (x shr toU32(32 -% ze(n)))
+
+proc FF(a: var int32, b, c, d, x: int32, s: int8, ac: int32) = 
+  a = a +% F(b, c, d) +% x +% ac
+  rot(a, s)
+  a = a +% b
+
+proc GG(a: var int32, b, c, d, x: int32, s: int8, ac: int32) = 
+  a = a +% G(b, c, d) +% x +% ac
+  rot(a, s)
+  a = a +% b
+
+proc HH(a: var int32, b, c, d, x: int32, s: int8, ac: int32) = 
+  a = a +% H(b, c, d) +% x +% ac
+  rot(a, s)
+  a = a +% b
+
+proc II(a: var int32, b, c, d, x: int32, s: int8, ac: int32) = 
+  a = a +% I(b, c, d) +% x +% ac
+  rot(a, s)
+  a = a +% b
+
+proc encode(dest: var MD5Block, src: cstring) = 
+  var j = 0
+  for i in 0..high(dest):
+    dest[i] = toU32(ord(src[j]) or 
+                ord(src[j+1]) shl 8 or
+                ord(src[j+2]) shl 16 or
+                ord(src[j+3]) shl 24)
+    inc(j, 4)
+
+proc decode(dest: var openarray[int8], src: openarray[int32]) = 
+  var i = 0
+  for j in 0..high(src):
+    dest[i] = toU8(src[j] and 0xff'i32)
+    dest[i+1] = toU8(src[j] shr 8'i32 and 0xff'i32)
+    dest[i+2] = toU8(src[j] shr 16'i32 and 0xff'i32)
+    dest[i+3] = toU8(src[j] shr 24'i32 and 0xff'i32)
+    inc(i, 4)
+
+proc transform(Buffer: pointer, State: var MD5State) = 
+  var
+    myBlock: MD5Block
+  encode(myBlock, cast[cstring](buffer))
+  var a = State[0]
+  var b = State[1]
+  var c = State[2]
+  var d = State[3]
+  FF(a, b, c, d, myBlock[0], 7'i8, 0xD76AA478'i32)
+  FF(d, a, b, c, myBlock[1], 12'i8, 0xE8C7B756'i32)
+  FF(c, d, a, b, myBlock[2], 17'i8, 0x242070DB'i32)
+  FF(b, c, d, a, myBlock[3], 22'i8, 0xC1BDCEEE'i32)
+  FF(a, b, c, d, myBlock[4], 7'i8, 0xF57C0FAF'i32)
+  FF(d, a, b, c, myBlock[5], 12'i8, 0x4787C62A'i32)
+  FF(c, d, a, b, myBlock[6], 17'i8, 0xA8304613'i32)
+  FF(b, c, d, a, myBlock[7], 22'i8, 0xFD469501'i32)
+  FF(a, b, c, d, myBlock[8], 7'i8, 0x698098D8'i32)
+  FF(d, a, b, c, myBlock[9], 12'i8, 0x8B44F7AF'i32)
+  FF(c, d, a, b, myBlock[10], 17'i8, 0xFFFF5BB1'i32)
+  FF(b, c, d, a, myBlock[11], 22'i8, 0x895CD7BE'i32)
+  FF(a, b, c, d, myBlock[12], 7'i8, 0x6B901122'i32)
+  FF(d, a, b, c, myBlock[13], 12'i8, 0xFD987193'i32)
+  FF(c, d, a, b, myBlock[14], 17'i8, 0xA679438E'i32)
+  FF(b, c, d, a, myBlock[15], 22'i8, 0x49B40821'i32)
+  GG(a, b, c, d, myBlock[1], 5'i8, 0xF61E2562'i32)
+  GG(d, a, b, c, myBlock[6], 9'i8, 0xC040B340'i32)
+  GG(c, d, a, b, myBlock[11], 14'i8, 0x265E5A51'i32)
+  GG(b, c, d, a, myBlock[0], 20'i8, 0xE9B6C7AA'i32)
+  GG(a, b, c, d, myBlock[5], 5'i8, 0xD62F105D'i32)
+  GG(d, a, b, c, myBlock[10], 9'i8, 0x02441453'i32)
+  GG(c, d, a, b, myBlock[15], 14'i8, 0xD8A1E681'i32)
+  GG(b, c, d, a, myBlock[4], 20'i8, 0xE7D3FBC8'i32)
+  GG(a, b, c, d, myBlock[9], 5'i8, 0x21E1CDE6'i32)
+  GG(d, a, b, c, myBlock[14], 9'i8, 0xC33707D6'i32)
+  GG(c, d, a, b, myBlock[3], 14'i8, 0xF4D50D87'i32)
+  GG(b, c, d, a, myBlock[8], 20'i8, 0x455A14ED'i32)
+  GG(a, b, c, d, myBlock[13], 5'i8, 0xA9E3E905'i32)
+  GG(d, a, b, c, myBlock[2], 9'i8, 0xFCEFA3F8'i32)
+  GG(c, d, a, b, myBlock[7], 14'i8, 0x676F02D9'i32)
+  GG(b, c, d, a, myBlock[12], 20'i8, 0x8D2A4C8A'i32)
+  HH(a, b, c, d, myBlock[5], 4'i8, 0xFFFA3942'i32)
+  HH(d, a, b, c, myBlock[8], 11'i8, 0x8771F681'i32)
+  HH(c, d, a, b, myBlock[11], 16'i8, 0x6D9D6122'i32)
+  HH(b, c, d, a, myBlock[14], 23'i8, 0xFDE5380C'i32)
+  HH(a, b, c, d, myBlock[1], 4'i8, 0xA4BEEA44'i32)
+  HH(d, a, b, c, myBlock[4], 11'i8, 0x4BDECFA9'i32)
+  HH(c, d, a, b, myBlock[7], 16'i8, 0xF6BB4B60'i32)
+  HH(b, c, d, a, myBlock[10], 23'i8, 0xBEBFBC70'i32)
+  HH(a, b, c, d, myBlock[13], 4'i8, 0x289B7EC6'i32)
+  HH(d, a, b, c, myBlock[0], 11'i8, 0xEAA127FA'i32)
+  HH(c, d, a, b, myBlock[3], 16'i8, 0xD4EF3085'i32)
+  HH(b, c, d, a, myBlock[6], 23'i8, 0x04881D05'i32)
+  HH(a, b, c, d, myBlock[9], 4'i8, 0xD9D4D039'i32)
+  HH(d, a, b, c, myBlock[12], 11'i8, 0xE6DB99E5'i32)
+  HH(c, d, a, b, myBlock[15], 16'i8, 0x1FA27CF8'i32)
+  HH(b, c, d, a, myBlock[2], 23'i8, 0xC4AC5665'i32)
+  II(a, b, c, d, myBlock[0], 6'i8, 0xF4292244'i32)
+  II(d, a, b, c, myBlock[7], 10'i8, 0x432AFF97'i32)
+  II(c, d, a, b, myBlock[14], 15'i8, 0xAB9423A7'i32)
+  II(b, c, d, a, myBlock[5], 21'i8, 0xFC93A039'i32)
+  II(a, b, c, d, myBlock[12], 6'i8, 0x655B59C3'i32)
+  II(d, a, b, c, myBlock[3], 10'i8, 0x8F0CCC92'i32)
+  II(c, d, a, b, myBlock[10], 15'i8, 0xFFEFF47D'i32)
+  II(b, c, d, a, myBlock[1], 21'i8, 0x85845DD1'i32)
+  II(a, b, c, d, myBlock[8], 6'i8, 0x6FA87E4F'i32)
+  II(d, a, b, c, myBlock[15], 10'i8, 0xFE2CE6E0'i32)
+  II(c, d, a, b, myBlock[6], 15'i8, 0xA3014314'i32)
+  II(b, c, d, a, myBlock[13], 21'i8, 0x4E0811A1'i32)
+  II(a, b, c, d, myBlock[4], 6'i8, 0xF7537E82'i32)
+  II(d, a, b, c, myBlock[11], 10'i8, 0xBD3AF235'i32)
+  II(c, d, a, b, myBlock[2], 15'i8, 0x2AD7D2BB'i32)
+  II(b, c, d, a, myBlock[9], 21'i8, 0xEB86D391'i32)
+  State[0] = State[0] +% a
+  State[1] = State[1] +% b
+  State[2] = State[2] +% c
+  State[3] = State[3] +% d
+  
+proc MD5Init*(c: var MD5Context) = 
+  ## initializes a MD5Context  
+  c.State[0] = 0x67452301'i32
+  c.State[1] = 0xEFCDAB89'i32
+  c.State[2] = 0x98BADCFE'i32
+  c.State[3] = 0x10325476'i32
+  c.Count[0] = 0'i32
+  c.Count[1] = 0'i32
+  ZeroMem(addr(c.Buffer), SizeOf(MD5Buffer))
+
+proc MD5Update*(c: var MD5Context, input: cstring, len: int) = 
+  ## updates the MD5Context with the `input` data of length `len`
+  var input = input
+  var Index = (c.Count[0] shr 3) and 0x3F
+  c.Count[0] = c.count[0] +% toU32(len shl 3)
+  if c.Count[0] < (len shl 3): c.Count[1] = c.count[1] +% 1'i32
+  c.Count[1] = c.count[1] +% toU32(len shr 29)
+  var PartLen = 64 - Index
+  if len >= PartLen: 
+    CopyMem(addr(c.Buffer[Index]), Input, PartLen)
+    transform(addr(c.Buffer), c.State)
+    var i = PartLen
+    while i + 63 < len: 
+      Transform(addr(Input[I]), c.State)
+      inc(i, 64)
+    CopyMem(addr(c.Buffer[0]), addr(Input[i]), len-i)
+  else:
+    CopyMem(addr(c.Buffer[Index]), addr(Input[0]), len)
+
+proc MD5Final*(c: var MD5Context, digest: var MD5Digest) = 
+  ## finishes the MD5Context and stores the result in `digest`
+  var
+    Bits: MD5CBits
+    PadLen: int
+  decode(bits, c.Count)
+  var Index = (c.Count[0] shr 3) and 0x3F
+  if Index < 56: PadLen = 56 - Index
+  else: PadLen = 120 - Index
+  MD5Update(c, padding, PadLen)
+  MD5Update(c, cast[cstring](addr(Bits)), 8)
+  decode(digest, c.State)
+  ZeroMem(addr(c), SizeOf(MD5Context))
+
+proc toMD5*(s: string): MD5Digest = 
+  ## computes the MD5Digest value for a string `s`
+  var c: MD5Context
+  MD5Init(c)
+  MD5Update(c, cstring(s), len(s))
+  MD5Final(c, result)
+  
+proc `$`*(D: MD5Digest): string = 
+  ## converts a MD5Digest value into its string representation
+  const digits = "0123456789abcdef"
+  result = ""
+  for i in 0..15: 
+    add(result, Digits[(D[I] shr 4) and 0xF])
+    add(result, Digits[D[I] and 0xF])
+
+proc myMD5*(s: string): string =  
+  var 
+    c: MD5Context
+    d: MD5Digest
+  MD5Init(c)
+  MD5Update(c, cstring(s), len(s))
+  MD5Final(c, d)
+  result = $d
+  
+proc `==`*(D1, D2: MD5Digest): bool =  
+  ## checks if two MD5Digest values are identical
+  for i in 0..15: 
+    if D1[i] != D2[i]: return false
+  return true
+
+var x = myMD5("Franz jagt im komplett verwahrlosten Taxi quer durch Bayern")
+assert(x == "a3cca2b2aa1e3b5b3b5aad99a8529074")
+
+md5("Frank jagt im komplett verwahrlosten Taxi quer durch Bayern") =
+7e716d0e702df0505fc72e2b89467910
+
+Der Hash einer Zeichenfolge der Länge Null ist:
+
+md5("") = d41d8cd98f00b204e9800998ecf8427e
+
+
+echo x
+
diff --git a/tests/mrecmod2.nim b/tests/mrecmod2.nim
new file mode 100644
index 000000000..9557ce729
--- /dev/null
+++ b/tests/mrecmod2.nim
@@ -0,0 +1,9 @@
+# Module B
+import trecmod2  
+
+proc p*(x: trecmod2.T1): trecmod2.T1 =
+  # this works because the compiler has already
+  # added T1 to trecmod2's interface symbol table
+  return x + 1
+  
+
diff --git a/tests/tbintree.nim b/tests/tbintree.nim
new file mode 100644
index 000000000..e0373355f
--- /dev/null
+++ b/tests/tbintree.nim
@@ -0,0 +1,59 @@
+type
+  TBinaryTree[T] = object      # TBinaryTree is a generic type with
+                               # with generic param ``T``
+    le, ri: ref TBinaryTree[T] # left and right subtrees; may be nil
+    data: T                    # the data stored in a node
+  PBinaryTree*[T] = ref TBinaryTree[T] # type that is exported
+
+proc newNode*[T](data: T): PBinaryTree[T] =
+  # constructor for a node
+  new(result)
+  result.dat = data
+
+proc add*[T](root: var PBinaryTree[T], n: PBinaryTree[T]) =
+  # insert a node into the tree
+  if root == nil:
+    root = n
+  else:
+    var it = root
+    while it != nil:
+      # compare the data items; uses the generic ``cmd`` proc that works for
+      # any type that has a ``==`` and ``<`` operator
+      var c = cmp(it.data, n.data)
+      if c < 0:
+        if it.le == nil:
+          it.le = n
+          return
+        it = it.le
+      else:
+        if it.ri == nil:
+          it.ri = n
+          return
+        it = it.ri
+
+proc add*[T](root: var PBinaryTree[T], data: T) =
+  # convenience proc:
+  add(root, newNode(data))
+
+iterator preorder*[T](root: PBinaryTree[T]): T =
+  # Preorder traversal of a binary tree.
+  # Since recursive iterators are not yet implemented,
+  # this uses an explicit stack:
+  var stack: seq[PBinaryTree[T]] = @[root]
+  while stack.len > 0:
+    var n = stack[stack.len-1]
+    setLen(stack, stack.len-1) # pop `n` of the stack
+    while n != nil:
+      yield n
+      add(stack, n.ri)  # push right subtree onto the stack
+      n = n.le          # and follow the left pointer
+
+var
+  root: PBinaryTree[string] # instantiate a PBinaryTree with the type string
+add(root, newNode("hallo")) # instantiates generic procs ``newNode`` and ``add``
+#add(root, "world")          # instantiates the second ``add`` proc
+#for str in preorder(root):
+#  stdout.writeln(str)
+
+#OUT halloworld
+
diff --git a/tests/tclosure.nim b/tests/tclosure.nim
new file mode 100644
index 000000000..7242c4892
--- /dev/null
+++ b/tests/tclosure.nim
@@ -0,0 +1,25 @@
+# Test the closure implementation
+
+proc map(n: var openarray[int], fn: proc (x: int): int {.closure}) =
+  for i in 0..n.len-1:
+    n[i] = fn(n[i])
+
+proc foldr(n: openarray[int], fn: proc (x, y: int): int {.closure}): int =
+  result = 0
+  for i in 0..n.len-1:
+    result = fn(result, n[i])
+
+var
+  myData: array[0..9, int] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+proc testA() =
+  var p = 0
+  map(myData, lambda (x: int): int =
+                result = x + 1 shl (lambda (y: int): int =
+                  return y + 1
+                )(0)
+                inc(p), 88)
+
+testA()
+for x in items(myData):
+  echo x
diff --git a/tests/techo.nim b/tests/techo.nim
new file mode 100644
index 000000000..beb21fa16
--- /dev/null
+++ b/tests/techo.nim
@@ -0,0 +1,3 @@
+# Simplest Nimrod program
+
+echo "Hallo, World!"
diff --git a/tests/titer2.nim b/tests/titer2.nim
new file mode 100644
index 000000000..b9cdb53fe
--- /dev/null
+++ b/tests/titer2.nim
@@ -0,0 +1,10 @@
+# Try to break the transformation pass:
+iterator iterAndZero(a: var openArray[int]): int =
+  for i in 0..len(a)-1:
+    yield a[i]
+    a[i] = 0
+
+var x = [[1, 2, 3], [4, 5, 6]]
+for y in iterAndZero(x[0]): write(stdout, $y)
+#OUT 123
+
diff --git a/tests/tnot.nim b/tests/tnot.nim
new file mode 100644
index 000000000..f5046849d
--- /dev/null
+++ b/tests/tnot.nim
@@ -0,0 +1,15 @@
+# BUG: following compiles, but should not:
+
+proc nodeOfDegree(x: Int): bool = 
+  result = false
+
+proc main = 
+  for j in 0..2:
+    for i in 0..10:
+      if not nodeOfDegree(1) >= 0: #ERROR
+        Echo "Yes"
+      else:
+        Echo "No"
+
+main()
+
diff --git a/tests/toop1.nim b/tests/toop1.nim
new file mode 100644
index 000000000..bf3d2021d
--- /dev/null
+++ b/tests/toop1.nim
@@ -0,0 +1,82 @@
+# Test the stuff in the tutorial
+import macros
+
+type
+  TFigure = object of TObject    # abstract base class:
+    draw: proc (my: var TFigure) # concrete classes implement this proc
+  
+proc init(f: var TFigure) = 
+  f.draw = nil
+
+type
+  TCircle = object of TFigure
+    radius: int
+  
+proc drawCircle(my: var TCircle) = stdout.writeln("o " & $my.radius)
+
+proc init(my: var TCircle) = 
+  init(TFigure(my)) # call base constructor
+  my.radius = 5
+  my.draw = drawCircle
+
+type
+  TRectangle = object of TFigure
+    width, height: int
+
+proc drawRectangle(my: var TRectangle) = stdout.write("[]")
+
+proc init(my: var TRectangle) = 
+  init(TFigure(my)) # call base constructor
+  my.width = 5
+  my.height = 10
+  my.draw = drawRectangle
+
+macro `!` (n: expr): expr = 
+  result = newNimNode(nnkCall, n)
+  var dot = newNimNode(nnkDotExpr, n)
+  dot.add(n[1])    # obj
+  if n[2].kind == nnkCall:
+    # transforms ``obj!method(arg1, arg2, ...)`` to
+    # ``(obj.method)(obj, arg1, arg2, ...)``
+    dot.add(n[2][0]) # method
+    result.add(dot)
+    result.add(n[1]) # obj
+    for i in 1..n[2].len-1:
+      result.add(n[2][i])
+  else:
+    # transforms ``obj!method`` to
+    # ``(obj.method)(obj)``
+    dot.add(n[2]) # method
+    result.add(dot)
+    result.add(n[1]) # obj
+
+type
+  TSocket* = object of TObject
+    FHost: int # cannot be accessed from the outside of the module
+               # the `F` prefix is a convention to avoid clashes since
+               # the accessors are named `host`
+               
+proc `host=`*(s: var TSocket, value: int) {.inline.} = 
+  ## setter of hostAddr
+  s.FHost = value
+
+proc host*(s: TSocket): int {.inline.} =
+  ## getter of hostAddr
+  return s.FHost
+  
+var 
+  s: TSocket
+s.host = 34  # same as `host=`(s, 34)
+stdout.write(s.host)
+
+# now use these classes:
+var
+  r: TRectangle
+  c: TCircle
+init(r)
+init(c)
+r!draw
+c!draw() 
+
+#OUT 34[]o 5
+
diff --git a/tests/topena1.nim b/tests/topena1.nim
new file mode 100644
index 000000000..7351edf55
--- /dev/null
+++ b/tests/topena1.nim
@@ -0,0 +1,5 @@
+# Tests a special bug
+
+var
+  x: ref openarray[string] #ERROR_MSG invalid type
+
diff --git a/tests/trecmod2.nim b/tests/trecmod2.nim
new file mode 100644
index 000000000..85fe2215f
--- /dev/null
+++ b/tests/trecmod2.nim
@@ -0,0 +1,10 @@
+type
+  T1* = int  # Module A exports the type ``T1``
+
+import mrecmod2   # the compiler starts parsing B
+
+proc main() =
+  var i = p(3) # works because B has been parsed completely here
+
+main()
+
diff --git a/tests/tseq2.nim b/tests/tseq2.nim
new file mode 100644
index 000000000..03bdb3fab
--- /dev/null
+++ b/tests/tseq2.nim
@@ -0,0 +1,13 @@
+
+  
+proc `*` *(a, b: seq[int]): seq[int] = 
+  # allocate a new sequence:
+  newSeq(result, len(a))
+  # multiply two int sequences:
+  for i in 0..len(a)-1: result[i] = a[i] * b[i]
+
+when isMainModule: 
+  # test the new ``*`` operator for sequences:
+  assert(@[1, 2, 3] * @[1, 2, 3] == @[1, 4, 9])
+
+
diff --git a/tests/tsimmeth.nim b/tests/tsimmeth.nim
new file mode 100644
index 000000000..3f5f810e6
--- /dev/null
+++ b/tests/tsimmeth.nim
@@ -0,0 +1,8 @@
+# Test method simulation
+
+import strutils
+
+var x = "hallo world!".toLower.toUpper
+x.echo()
+#OUT HALLO WORLD!
+
diff --git a/tests/ttempl2.nim b/tests/ttempl2.nim
new file mode 100644
index 000000000..fba6bd0cb
--- /dev/null
+++ b/tests/ttempl2.nim
@@ -0,0 +1,14 @@
+template declareInScope(x: expr, t: typeDesc): stmt = 
+  var x: t
+  
+template declareInNewScope(x: expr, t: typeDesc): stmt = 
+  # open a new scope:
+  block: 
+    var x: t
+
+declareInScope(a, int)
+a = 42  # works, `a` is known here
+
+declareInNewScope(b, int)
+b = 42  #ERROR_MSG undeclared identifier: 'b'
+
diff --git a/tests/ttempl3.nim b/tests/ttempl3.nim
new file mode 100644
index 000000000..4ae3e16d2
--- /dev/null
+++ b/tests/ttempl3.nim
@@ -0,0 +1,15 @@
+
+template withOpenFile(f, filename, mode: expr, actions: stmt): stmt =
+  block:
+    var f: TFile
+    if openFile(f, filename, mode):
+      try:
+        actions
+      finally:
+        closeFile(f)
+    else:
+      quit("cannot open for writing: " & filename)
+    
+withOpenFile(txt, "ttempl3.txt", fmWrite):
+  writeln(txt, "line 1")
+  txt.writeln("line 2")