REPL improvements

24 files changed, 3098 insertions, 51 deletions

diff --git a/config/nimrod.cfg b/config/nimrod.cfg
index 03963b330..6ae5049d0 100755
--- a/config/nimrod.cfg
+++ b/config/nimrod.cfg
@@ -23,6 +23,7 @@ path="$lib/wrappers/gtk"
 path="$lib/wrappers/lua"
 path="$lib/wrappers/opengl"
 path="$lib/wrappers/pcre"
+path="$lib/wrappers/readline"
 path="$lib/wrappers/sdl"
 path="$lib/wrappers/x11"
 path="$lib/wrappers/zip"
diff --git a/doc/advopt.txt b/doc/advopt.txt
index fd624d93e..2d0080b72 100755
--- a/doc/advopt.txt
+++ b/doc/advopt.txt
@@ -1,5 +1,8 @@
 Advanced commands:
+  //compileToC, cc          compile project with C code generator
   //compileToOC, oc         compile project to Objective C code
+  //rst2html                converts a reStructuredText file to HTML
+  //rst2tex                 converts a reStructuredText file to TeX
   //run                     run the project (with Tiny C backend; Linux only!)
   //pretty                  pretty print the inputfile
   //genDepend               generate a DOT file containing the
diff --git a/doc/basicopt.txt b/doc/basicopt.txt
index 45efff4d0..bd311e993 100755
--- a/doc/basicopt.txt
+++ b/doc/basicopt.txt
@@ -3,11 +3,9 @@ Usage::
 
 Command:
   //compile, c              compile project with default code generator (C)
-  //compileToC, cc          compile project with C code generator
   //doc                     generate the documentation for inputfile
-  //rst2html                converts a reStructuredText file to HTML
-  //rst2tex                 converts a reStructuredText file to TeX
-
+  //i                       start Nimrod in interactive mode (limited)
+  
 Arguments:
   arguments are passed to the program being run (if --run option is selected)
 Options:
diff --git a/doc/nimrodc.txt b/doc/nimrodc.txt
index c4b61a14f..a712d109b 100755
--- a/doc/nimrodc.txt
+++ b/doc/nimrodc.txt
@@ -57,7 +57,12 @@ configuration file that is read automatically. This specific file has to
 be in the same directory as the project and be of the same name, except

 that its extension should be ``.cfg``.

 

-Command line settings have priority over configuration file settings.

+Command line settings have priority over configuration file settings.
+
+The default build of a project is a `debug build`:idx:. To compile a 
+`release build`:idx: define the ``release`` symbol::
+  
+  nimrod c -d:release myproject.nim

 

 

 Generated C code directory

@@ -224,6 +229,22 @@ The `volatile`:idx: pragma is for variables only. It declares the variable as
 ``volatile``, whatever that means in C/C++.

 

 **Note**: This pragma will not exist for the LLVM backend.

+
+
+Nimrod interactive mode
+=======================
+
+The Nimrod compiler supports an `interactive mode`:idx:. This is also known as
+a `REPL`:idx: (*read eval print loop*). If Nimrod has been built with the 
+``-d:useGnuReadline`` switch, it uses the GNU readline library for terminal
+input management. To start Nimrod in interactive mode use the command 
+``nimrod i``. To quit use the ``quit()` command. To determine whether an input
+line is an incomplete statement to be continued these rules are used:
+
+1. The line ends with ``[-+*/\\<>!\?\|%&$@~,;:=#^]\s*$``.
+2. The line starts with a space (indentation).
+3. The line is within a triple quoted string literal. However, the detection 
+   does not work if the line contains more than one ``"""``.
 

 

 Debugging with Nimrod

diff --git a/doc/tut1.txt b/doc/tut1.txt
index dfd6bd1d5..4fc8c8955 100755
--- a/doc/tut1.txt
+++ b/doc/tut1.txt
@@ -50,10 +50,13 @@ Commonly used commands and switches have abbreviations, so you can also use::
 
   nimrod c -r greetings.nim
 
-To compile a `release`:idx: version use::
+To compile a release version use::
   
   nimrod c -d:release greetings.nim
 
+By default the Nimrod compiler generates a large amount of runtime checks 
+aiming for your debugging pleasure. With ``-d:release`` these checks are 
+turned off and optimizations are turned on.
 
 Though it should be pretty obvious what the program does, I will explain the
 syntax: statements which are not indented are executed when the program
diff --git a/koch.nim b/koch.nim
index 273f0b79f..7458a747b 100755
--- a/koch.nim
+++ b/koch.nim
@@ -36,8 +36,10 @@ Possible Commands:
 Boot options:
   -d:release               produce a release version of the compiler
   -d:tinyc                 include the Tiny C backend (not supported on Windows)
+  -d:useGnuReadline        use the GNU readline library for interactive mode
+                           (not supported on Windows)
 """
-  
+
 proc exe(f: string): string = return addFileExt(f, ExeExt)
 
 proc exec(cmd: string) =
diff --git a/lib/impure/rdstdin.nim b/lib/impure/rdstdin.nim
new file mode 100644
index 000000000..21e580f73
--- /dev/null
+++ b/lib/impure/rdstdin.nim
@@ -0,0 +1,37 @@
+#
+#
+#            Nimrod's Runtime Library
+#        (c) Copyright 2011 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## This module contains code for reading from `stdin`:idx:. On UNIX the GNU
+## readline library is wrapped and set up to provide default key bindings 
+## (e.g. you can navigate with the arrow keys). On Windows ``system.readLine``
+## is used. This suffices because Windows' console already provides the 
+## wanted functionality.
+
+when defined(Windows):
+  proc ReadLineFromStdin*(prompt: string): string = 
+    ## Reads a line from stdin.
+    stdout.write(prompt)
+    result = readLine(stdin)
+
+else:
+  import readline, history
+    
+  proc ReadLineFromStdin*(prompt: string): string = 
+    var buffer = readline.readLine(prompt)
+    if isNil(buffer): quit(0)
+    result = $buffer
+    if result.len > 0:
+      add_history(buffer)
+    readline.free(buffer)
+
+  # initialization:
+  # disable auto-complete: 
+  discard readline.bind_key('\t'.ord, readline.abort) 
+
+
diff --git a/lib/wrappers/readline/history.nim b/lib/wrappers/readline/history.nim
new file mode 100644
index 000000000..48e71e434
--- /dev/null
+++ b/lib/wrappers/readline/history.nim
@@ -0,0 +1,281 @@
+# history.h -- the names of functions that you can call in history. 
+# Copyright (C) 1989-2009 Free Software Foundation, Inc.
+#
+#   This file contains the GNU History Library (History), a set of
+#   routines for managing the text of previously typed lines.
+#
+#   History 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 3 of the License, or
+#   (at your option) any later version.
+#
+#   History 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 History.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+{.deadCodeElim: on.}
+when defined(windows): 
+  const 
+    historyDll = "history.dll"
+elif defined(macosx): 
+  const 
+    historyDll = "libhistory.dynlib"
+else: 
+  const 
+    historyDll = "libhistory.so.6(|.0)"
+
+import times, rltypedefs
+
+type 
+  Thistdata* = pointer
+
+# The structure used to store a history entry. 
+
+type 
+  THIST_ENTRY*{.pure, final.} = object 
+    line*: cstring
+    timestamp*: cstring       # char * rather than time_t for read/write 
+    data*: Thistdata
+
+
+# Size of the history-library-managed space in history entry HS. 
+
+template HISTENT_BYTES*(hs: expr): expr = 
+  (strlen(hs.line) + strlen(hs.timestamp))
+
+# A structure used to pass the current state of the history stuff around. 
+
+type 
+  THISTORY_STATE*{.pure, final.} = object 
+    entries*: ptr ptr THIST_ENTRY # Pointer to the entries themselves. 
+    offset*: cint             # The location pointer within this array. 
+    length*: cint             # Number of elements within this array. 
+    size*: cint               # Number of slots allocated to this array. 
+    flags*: cint
+
+
+# Flag values for the `flags' member of HISTORY_STATE. 
+
+const 
+  HS_STIFLED* = 0x00000001
+
+# Initialization and state management. 
+# Begin a session in which the history functions might be used.  This
+#   just initializes the interactive variables. 
+
+proc using_history*(){.cdecl, importc: "using_history", dynlib: historyDll.}
+# Return the current HISTORY_STATE of the history. 
+
+proc history_get_history_state*(): ptr THISTORY_STATE{.cdecl, 
+    importc: "history_get_history_state", dynlib: historyDll.}
+# Set the state of the current history array to STATE. 
+
+proc history_set_history_state*(a2: ptr THISTORY_STATE){.cdecl, 
+    importc: "history_set_history_state", dynlib: historyDll.}
+# Manage the history list. 
+# Place STRING at the end of the history list.
+#   The associated data field (if any) is set to NULL. 
+
+proc add_history*(a2: cstring){.cdecl, importc: "add_history", 
+                                dynlib: historyDll.}
+# Change the timestamp associated with the most recent history entry to
+#   STRING. 
+
+proc add_history_time*(a2: cstring){.cdecl, importc: "add_history_time", 
+                                     dynlib: historyDll.}
+# A reasonably useless function, only here for completeness.  WHICH
+#   is the magic number that tells us which element to delete.  The
+#   elements are numbered from 0. 
+
+proc remove_history*(a2: cint): ptr THIST_ENTRY{.cdecl, 
+    importc: "remove_history", dynlib: historyDll.}
+# Free the history entry H and return any application-specific data
+#   associated with it. 
+
+proc free_history_entry*(a2: ptr THIST_ENTRY): Thistdata{.cdecl, 
+    importc: "free_history_entry", dynlib: historyDll.}
+# Make the history entry at WHICH have LINE and DATA.  This returns
+#   the old entry so you can dispose of the data.  In the case of an
+#   invalid WHICH, a NULL pointer is returned. 
+
+proc replace_history_entry*(a2: cint, a3: cstring, a4: Thistdata): ptr THIST_ENTRY{.
+    cdecl, importc: "replace_history_entry", dynlib: historyDll.}
+# Clear the history list and start over. 
+
+proc clear_history*(){.cdecl, importc: "clear_history", dynlib: historyDll.}
+# Stifle the history list, remembering only MAX number of entries. 
+
+proc stifle_history*(a2: cint){.cdecl, importc: "stifle_history", 
+                                dynlib: historyDll.}
+# Stop stifling the history.  This returns the previous amount the
+#   history was stifled by.  The value is positive if the history was
+#   stifled, negative if it wasn't. 
+
+proc unstifle_history*(): cint{.cdecl, importc: "unstifle_history", 
+                                dynlib: historyDll.}
+# Return 1 if the history is stifled, 0 if it is not. 
+
+proc history_is_stifled*(): cint{.cdecl, importc: "history_is_stifled", 
+                                  dynlib: historyDll.}
+# Information about the history list. 
+# Return a NULL terminated array of HIST_ENTRY which is the current input
+#   history.  Element 0 of this list is the beginning of time.  If there
+#   is no history, return NULL. 
+
+proc history_list*(): ptr ptr THIST_ENTRY{.cdecl, importc: "history_list", 
+    dynlib: historyDll.}
+# Returns the number which says what history element we are now
+#   looking at.  
+
+proc where_history*(): cint{.cdecl, importc: "where_history", dynlib: historyDll.}
+# Return the history entry at the current position, as determined by
+#   history_offset.  If there is no entry there, return a NULL pointer. 
+
+proc current_history*(): ptr THIST_ENTRY{.cdecl, importc: "current_history", 
+    dynlib: historyDll.}
+# Return the history entry which is logically at OFFSET in the history
+#   array.  OFFSET is relative to history_base. 
+
+proc history_get*(a2: cint): ptr THIST_ENTRY{.cdecl, importc: "history_get", 
+    dynlib: historyDll.}
+# Return the timestamp associated with the HIST_ENTRY * passed as an
+#   argument 
+
+proc history_get_time*(a2: ptr THIST_ENTRY): TTime{.cdecl, 
+    importc: "history_get_time", dynlib: historyDll.}
+# Return the number of bytes that the primary history entries are using.
+#   This just adds up the lengths of the_history->lines. 
+
+proc history_total_bytes*(): cint{.cdecl, importc: "history_total_bytes", 
+                                   dynlib: historyDll.}
+# Moving around the history list. 
+# Set the position in the history list to POS. 
+
+proc history_set_pos*(a2: cint): cint{.cdecl, importc: "history_set_pos", 
+                                       dynlib: historyDll.}
+# Back up history_offset to the previous history entry, and return
+#   a pointer to that entry.  If there is no previous entry, return
+#   a NULL pointer. 
+
+proc previous_history*(): ptr THIST_ENTRY{.cdecl, importc: "previous_history", 
+    dynlib: historyDll.}
+# Move history_offset forward to the next item in the input_history,
+#   and return the a pointer to that entry.  If there is no next entry,
+#   return a NULL pointer. 
+
+proc next_history*(): ptr THIST_ENTRY{.cdecl, importc: "next_history", 
+                                       dynlib: historyDll.}
+# Searching the history list. 
+# Search the history for STRING, starting at history_offset.
+#   If DIRECTION < 0, then the search is through previous entries,
+#   else through subsequent.  If the string is found, then
+#   current_history () is the history entry, and the value of this function
+#   is the offset in the line of that history entry that the string was
+#   found in.  Otherwise, nothing is changed, and a -1 is returned. 
+
+proc history_search*(a2: cstring, a3: cint): cint{.cdecl, 
+    importc: "history_search", dynlib: historyDll.}
+# Search the history for STRING, starting at history_offset.
+#   The search is anchored: matching lines must begin with string.
+#   DIRECTION is as in history_search(). 
+
+proc history_search_prefix*(a2: cstring, a3: cint): cint{.cdecl, 
+    importc: "history_search_prefix", dynlib: historyDll.}
+# Search for STRING in the history list, starting at POS, an
+#   absolute index into the list.  DIR, if negative, says to search
+#   backwards from POS, else forwards.
+#   Returns the absolute index of the history element where STRING
+#   was found, or -1 otherwise. 
+
+proc history_search_pos*(a2: cstring, a3: cint, a4: cint): cint{.cdecl, 
+    importc: "history_search_pos", dynlib: historyDll.}
+# Managing the history file. 
+# Add the contents of FILENAME to the history list, a line at a time.
+#   If FILENAME is NULL, then read from ~/.history.  Returns 0 if
+#   successful, or errno if not. 
+
+proc read_history*(a2: cstring): cint{.cdecl, importc: "read_history", 
+                                       dynlib: historyDll.}
+# Read a range of lines from FILENAME, adding them to the history list.
+#   Start reading at the FROM'th line and end at the TO'th.  If FROM
+#   is zero, start at the beginning.  If TO is less than FROM, read
+#   until the end of the file.  If FILENAME is NULL, then read from
+#   ~/.history.  Returns 0 if successful, or errno if not. 
+
+proc read_history_range*(a2: cstring, a3: cint, a4: cint): cint{.cdecl, 
+    importc: "read_history_range", dynlib: historyDll.}
+# Write the current history to FILENAME.  If FILENAME is NULL,
+#   then write the history list to ~/.history.  Values returned
+#   are as in read_history ().  
+
+proc write_history*(a2: cstring): cint{.cdecl, importc: "write_history", 
+                                        dynlib: historyDll.}
+# Append NELEMENT entries to FILENAME.  The entries appended are from
+#   the end of the list minus NELEMENTs up to the end of the list. 
+
+proc append_history*(a2: cint, a3: cstring): cint{.cdecl, 
+    importc: "append_history", dynlib: historyDll.}
+# Truncate the history file, leaving only the last NLINES lines. 
+
+proc history_truncate_file*(a2: cstring, a3: cint): cint{.cdecl, 
+    importc: "history_truncate_file", dynlib: historyDll.}
+# History expansion. 
+# Expand the string STRING, placing the result into OUTPUT, a pointer
+#   to a string.  Returns:
+#
+#   0) If no expansions took place (or, if the only change in
+#      the text was the de-slashifying of the history expansion
+#      character)
+#   1) If expansions did take place
+#  -1) If there was an error in expansion.
+#   2) If the returned line should just be printed.
+#
+#  If an error ocurred in expansion, then OUTPUT contains a descriptive
+#  error message. 
+
+proc history_expand*(a2: cstring, a3: cstringArray): cint{.cdecl, 
+    importc: "history_expand", dynlib: historyDll.}
+# Extract a string segment consisting of the FIRST through LAST
+#   arguments present in STRING.  Arguments are broken up as in
+#   the shell. 
+
+proc history_arg_extract*(a2: cint, a3: cint, a4: cstring): cstring{.cdecl, 
+    importc: "history_arg_extract", dynlib: historyDll.}
+# Return the text of the history event beginning at the current
+#   offset into STRING.  Pass STRING with *INDEX equal to the
+#   history_expansion_char that begins this specification.
+#   DELIMITING_QUOTE is a character that is allowed to end the string
+#   specification for what to search for in addition to the normal
+#   characters `:', ` ', `\t', `\n', and sometimes `?'. 
+
+proc get_history_event*(a2: cstring, a3: ptr cint, a4: cint): cstring{.cdecl, 
+    importc: "get_history_event", dynlib: historyDll.}
+# Return an array of tokens, much as the shell might.  The tokens are
+#   parsed out of STRING. 
+
+proc history_tokenize*(a2: cstring): cstringArray{.cdecl, 
+    importc: "history_tokenize", dynlib: historyDll.}
+when false: 
+  # Exported history variables. 
+  var history_base*{.importc: "history_base", dynlib: historyDll.}: cint
+  var history_length*{.importc: "history_length", dynlib: historyDll.}: cint
+  var history_max_entries*{.importc: "history_max_entries", dynlib: historyDll.}: cint
+  var history_expansion_char*{.importc: "history_expansion_char", 
+                               dynlib: historyDll.}: char
+  var history_subst_char*{.importc: "history_subst_char", dynlib: historyDll.}: char
+  var history_word_delimiters*{.importc: "history_word_delimiters", 
+                                dynlib: historyDll.}: cstring
+  var history_comment_char*{.importc: "history_comment_char", dynlib: historyDll.}: char
+  var history_no_expand_chars*{.importc: "history_no_expand_chars", 
+                                dynlib: historyDll.}: cstring
+  var history_search_delimiter_chars*{.importc: "history_search_delimiter_chars", 
+                                       dynlib: historyDll.}: cstring
+  var history_quotes_inhibit_expansion*{.
+      importc: "history_quotes_inhibit_expansion", dynlib: historyDll.}: cint
+  var history_write_timestamps*{.importc: "history_write_timestamps", 
+                                 dynlib: historyDll.}: cint
diff --git a/lib/wrappers/readline/readline.nim b/lib/wrappers/readline/readline.nim
new file mode 100644
index 000000000..96dab2049
--- /dev/null
+++ b/lib/wrappers/readline/readline.nim
@@ -0,0 +1,1198 @@
+# Readline.h -- the names of functions callable from within readline. 
+# Copyright (C) 1987-2009 Free Software Foundation, Inc.
+#
+#   This file is part of the GNU Readline Library (Readline), a library
+#   for reading lines of text with interactive input and history editing.      
+#
+#   Readline 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 3 of the License, or
+#   (at your option) any later version.
+#
+#   Readline 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 Readline.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+{.deadCodeElim: on.}
+when defined(windows): 
+  const 
+    readlineDll = "readline.dll"
+elif defined(macosx): 
+  const 
+    readlineDll = "libreadline.dynlib"
+else: 
+  const 
+    readlineDll = "libreadline.so.6(|.0)"
+##  mangle "'TCommandFunc'" TCommandFunc
+##  mangle TvcpFunc TvcpFunc
+
+import rltypedefs
+
+# Some character stuff. 
+
+const 
+  control_character_threshold* = 0x00000020 # Smaller than this is control. 
+  control_character_mask* = 0x0000001F # 0x20 - 1 
+  meta_character_threshold* = 0x0000007F # Larger than this is Meta. 
+  control_character_bit* = 0x00000040 # 0x000000, must be off. 
+  meta_character_bit* = 0x00000080 # x0000000, must be on. 
+  largest_char* = 255         # Largest character value. 
+
+template CTRL_CHAR*(c: expr): expr = 
+  (c < control_character_threshold and ((c and 0x00000080) == 0))
+
+template META_CHAR*(c: expr): expr = 
+  (c > meta_character_threshold and c <= largest_char)
+
+template CTRL*(c: expr): expr = 
+  (c and control_character_mask)
+
+template META*(c: expr): expr = 
+  (c or meta_character_bit)
+
+template UNMETA*(c: expr): expr = 
+  (c and not meta_character_bit)
+
+template UNCTRL*(c: expr): expr = 
+  (c or 32 or control_character_bit)
+
+# Beware:  these only work with single-byte ASCII characters. 
+
+const 
+  RETURN_CHAR* = CTRL('M'.ord)
+  RUBOUT_CHAR* = 0x0000007F
+  ABORT_CHAR* = CTRL('G'.ord)
+  PAGE_CHAR* = CTRL('L'.ord)
+  ESC_CHAR* = CTRL('['.ord)
+
+# A keymap contains one entry for each key in the ASCII set.
+#   Each entry consists of a type and a pointer.
+#   FUNCTION is the address of a function to run, or the
+#   address of a keymap to indirect through.
+#   TYPE says which kind of thing FUNCTION is. 
+
+type 
+  TKEYMAP_ENTRY*{.pure, final.} = object 
+    typ*: char
+    function*: TCommandFunc
+
+
+# This must be large enough to hold bindings for all of the characters
+#   in a desired character set (e.g, 128 for ASCII, 256 for ISO Latin-x,
+#   and so on) plus one for subsequence matching. 
+
+const 
+  KEYMAP_SIZE* = 257
+  ANYOTHERKEY* = KEYMAP_SIZE - 1
+
+# I wanted to make the above structure contain a union of:
+#   union { rl_TCommandFunc_t *function; struct _keymap_entry *keymap; } value;
+#   but this made it impossible for me to create a static array.
+#   Maybe I need C lessons. 
+
+type 
+  TKEYMAP_ENTRY_ARRAY* = array[0..KEYMAP_SIZE - 1, TKEYMAP_ENTRY]
+  PKeymap* = ptr TKEYMAP_ENTRY
+
+# The values that TYPE can have in a keymap entry. 
+
+const 
+  ISFUNC* = 0
+  ISKMAP* = 1
+  ISMACR* = 2
+
+when false: 
+  var 
+    emacs_standard_keymap*{.importc: "emacs_standard_keymap", 
+                            dynlib: readlineDll.}: TKEYMAP_ENTRY_ARRAY
+    emacs_meta_keymap*{.importc: "emacs_meta_keymap", dynlib: readlineDll.}: TKEYMAP_ENTRY_ARRAY
+    emacs_ctlx_keymap*{.importc: "emacs_ctlx_keymap", dynlib: readlineDll.}: TKEYMAP_ENTRY_ARRAY
+  var 
+    vi_insertion_keymap*{.importc: "vi_insertion_keymap", dynlib: readlineDll.}: TKEYMAP_ENTRY_ARRAY
+    vi_movement_keymap*{.importc: "vi_movement_keymap", dynlib: readlineDll.}: TKEYMAP_ENTRY_ARRAY
+# Return a new, empty keymap.
+#   Free it with free() when you are done. 
+
+proc make_bare_keymap*(): PKeymap{.cdecl, importc: "rl_make_bare_keymap", 
+                                   dynlib: readlineDll.}
+# Return a new keymap which is a copy of MAP. 
+
+proc copy_keymap*(a2: PKeymap): PKeymap{.cdecl, importc: "rl_copy_keymap", 
+    dynlib: readlineDll.}
+# Return a new keymap with the printing characters bound to rl_insert,
+#   the lowercase Meta characters bound to run their equivalents, and
+#   the Meta digits bound to produce numeric arguments. 
+
+proc make_keymap*(): PKeymap{.cdecl, importc: "rl_make_keymap", 
+                              dynlib: readlineDll.}
+# Free the storage associated with a keymap. 
+
+proc discard_keymap*(a2: PKeymap){.cdecl, importc: "rl_discard_keymap", 
+                                   dynlib: readlineDll.}
+# These functions actually appear in bind.c 
+# Return the keymap corresponding to a given name.  Names look like
+#   `emacs' or `emacs-meta' or `vi-insert'.  
+
+proc get_keymap_by_name*(a2: cstring): PKeymap{.cdecl, 
+    importc: "rl_get_keymap_by_name", dynlib: readlineDll.}
+# Return the current keymap. 
+
+proc get_keymap*(): PKeymap{.cdecl, importc: "rl_get_keymap", 
+                             dynlib: readlineDll.}
+# Set the current keymap to MAP. 
+
+proc set_keymap*(a2: PKeymap){.cdecl, importc: "rl_set_keymap", 
+                               dynlib: readlineDll.}
+
+const 
+  tildeDll = readlineDll
+
+type 
+  Thook_func* = proc (a2: cstring): cstring{.cdecl.}
+
+# If non-null, this contains the address of a function that the application
+#   wants called before trying the standard tilde expansions.  The function
+#   is called with the text sans tilde, and returns a malloc()'ed string
+#   which is the expansion, or a NULL pointer if the expansion fails. 
+
+var expansion_preexpansion_hook*{.importc: "tilde_expansion_preexpansion_hook", 
+                                  dynlib: tildeDll.}: Thook_func
+
+# If non-null, this contains the address of a function to call if the
+#   standard meaning for expanding a tilde fails.  The function is called
+#   with the text (sans tilde, as in "foo"), and returns a malloc()'ed string
+#   which is the expansion, or a NULL pointer if there is no expansion. 
+
+var expansion_failure_hook*{.importc: "tilde_expansion_failure_hook", 
+                             dynlib: tildeDll.}: Thook_func
+
+# When non-null, this is a NULL terminated array of strings which
+#   are duplicates for a tilde prefix.  Bash uses this to expand
+#   `=~' and `:~'. 
+
+var additional_prefixes*{.importc: "tilde_additional_prefixes", dynlib: tildeDll.}: cstringArray
+
+# When non-null, this is a NULL terminated array of strings which match
+#   the end of a username, instead of just "/".  Bash sets this to
+#   `:' and `=~'. 
+
+var additional_suffixes*{.importc: "tilde_additional_suffixes", dynlib: tildeDll.}: cstringArray
+
+# Return a new string which is the result of tilde expanding STRING. 
+
+proc expand*(a2: cstring): cstring{.cdecl, importc: "tilde_expand", 
+                                    dynlib: tildeDll.}
+# Do the work of tilde expansion on FILENAME.  FILENAME starts with a
+#   tilde.  If there is no expansion, call tilde_expansion_failure_hook. 
+
+proc expand_word*(a2: cstring): cstring{.cdecl, importc: "tilde_expand_word", 
+    dynlib: tildeDll.}
+# Find the portion of the string beginning with ~ that should be expanded. 
+
+proc find_word*(a2: cstring, a3: cint, a4: ptr cint): cstring{.cdecl, 
+    importc: "tilde_find_word", dynlib: tildeDll.}
+
+# Hex-encoded Readline version number. 
+
+const 
+  READLINE_VERSION* = 0x00000600 # Readline 6.0 
+  VERSION_MAJOR* = 6
+  VERSION_MINOR* = 0
+
+# Readline data structures. 
+# Maintaining the state of undo.  We remember individual deletes and inserts
+#   on a chain of things to do. 
+# The actions that undo knows how to undo.  Notice that UNDO_DELETE means
+#   to insert some text, and UNDO_INSERT means to delete some text.   I.e.,
+#   the code tells undo what to undo, not how to undo it. 
+
+type 
+  Tundo_code* = enum 
+    UNDO_DELETE, UNDO_INSERT, UNDO_BEGIN, UNDO_END
+
+# What an element of THE_UNDO_LIST looks like. 
+
+type 
+  TUNDO_LIST*{.pure, final.} = object 
+    next*: ptr Tundo_list
+    start*: cint
+    theEnd*: cint             # Where the change took place. 
+    text*: cstring            # The text to insert, if undoing a delete. 
+    what*: Tundo_code         # Delete, Insert, Begin, End. 
+  
+
+# The current undo list for RL_LINE_BUFFER. 
+
+var undo_list*{.importc: "rl_undo_list", dynlib: readlineDll.}: ptr TUNDO_LIST
+
+# The data structure for mapping textual names to code addresses. 
+
+type 
+  TFUNMAP*{.pure, final.} = object 
+    name*: cstring
+    function*: TCommandFunc
+
+
+var funmap*{.importc: "funmap", dynlib: readlineDll.}: ptr ptr TFUNMAP
+
+# **************************************************************** 
+#								    
+#	     Functions available to bind to key sequences	    
+#								    
+# **************************************************************** 
+# Bindable commands for numeric arguments. 
+
+proc digit_argument*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_digit_argument", dynlib: readlineDll.}
+proc universal_argument*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_universal_argument", dynlib: readlineDll.}
+# Bindable commands for moving the cursor. 
+
+proc forward_byte*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_forward_byte", 
+    dynlib: readlineDll.}
+proc forward_char*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_forward_char", 
+    dynlib: readlineDll.}
+proc forward*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_forward", 
+    dynlib: readlineDll.}
+proc backward_byte*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_backward_byte", dynlib: readlineDll.}
+proc backward_char*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_backward_char", dynlib: readlineDll.}
+proc backward*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_backward", 
+    dynlib: readlineDll.}
+proc beg_of_line*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_beg_of_line", 
+    dynlib: readlineDll.}
+proc end_of_line*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_end_of_line", 
+    dynlib: readlineDll.}
+proc forward_word*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_forward_word", 
+    dynlib: readlineDll.}
+proc backward_word*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_backward_word", dynlib: readlineDll.}
+proc refresh_line*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_refresh_line", 
+    dynlib: readlineDll.}
+proc clear_screen*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_clear_screen", 
+    dynlib: readlineDll.}
+proc skip_csi_sequence*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_skip_csi_sequence", dynlib: readlineDll.}
+proc arrow_keys*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_arrow_keys", 
+    dynlib: readlineDll.}
+# Bindable commands for inserting and deleting text. 
+
+proc insert*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_insert", 
+                                        dynlib: readlineDll.}
+proc quoted_insert*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_quoted_insert", dynlib: readlineDll.}
+proc tab_insert*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_tab_insert", 
+    dynlib: readlineDll.}
+proc newline*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_newline", 
+    dynlib: readlineDll.}
+proc do_lowercase_version*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_do_lowercase_version", dynlib: readlineDll.}
+proc rubout*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_rubout", 
+                                        dynlib: readlineDll.}
+proc delete*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_delete", 
+                                        dynlib: readlineDll.}
+proc rubout_or_delete*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_rubout_or_delete", dynlib: readlineDll.}
+proc delete_horizontal_space*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_delete_horizontal_space", dynlib: readlineDll.}
+proc delete_or_show_completions*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_delete_or_show_completions", dynlib: readlineDll.}
+proc insert_comment*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_insert_comment", dynlib: readlineDll.}
+# Bindable commands for changing case. 
+
+proc upcase_word*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_upcase_word", 
+    dynlib: readlineDll.}
+proc downcase_word*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_downcase_word", dynlib: readlineDll.}
+proc capitalize_word*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_capitalize_word", dynlib: readlineDll.}
+# Bindable commands for transposing characters and words. 
+
+proc transpose_words*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_transpose_words", dynlib: readlineDll.}
+proc transpose_chars*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_transpose_chars", dynlib: readlineDll.}
+# Bindable commands for searching within a line. 
+
+proc char_search*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_char_search", 
+    dynlib: readlineDll.}
+proc backward_char_search*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_backward_char_search", dynlib: readlineDll.}
+# Bindable commands for readline's interface to the command history. 
+
+proc beginning_of_history*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_beginning_of_history", dynlib: readlineDll.}
+proc end_of_history*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_end_of_history", dynlib: readlineDll.}
+proc get_next_history*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_get_next_history", dynlib: readlineDll.}
+proc get_previous_history*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_get_previous_history", dynlib: readlineDll.}
+# Bindable commands for managing the mark and region. 
+
+proc set_mark*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_set_mark", 
+    dynlib: readlineDll.}
+proc exchange_point_and_mark*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_exchange_point_and_mark", dynlib: readlineDll.}
+# Bindable commands to set the editing mode (emacs or vi). 
+
+proc vi_editing_mode*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_vi_editing_mode", dynlib: readlineDll.}
+proc emacs_editing_mode*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_emacs_editing_mode", dynlib: readlineDll.}
+# Bindable commands to change the insert mode (insert or overwrite) 
+
+proc overwrite_mode*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_overwrite_mode", dynlib: readlineDll.}
+# Bindable commands for managing key bindings. 
+
+proc re_read_init_file*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_re_read_init_file", dynlib: readlineDll.}
+proc dump_functions*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_dump_functions", dynlib: readlineDll.}
+proc dump_macros*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_dump_macros", 
+    dynlib: readlineDll.}
+proc dump_variables*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_dump_variables", dynlib: readlineDll.}
+# Bindable commands for word completion. 
+
+proc complete*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_complete", 
+    dynlib: readlineDll.}
+proc possible_completions*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_possible_completions", dynlib: readlineDll.}
+proc insert_completions*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_insert_completions", dynlib: readlineDll.}
+proc old_menu_complete*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_old_menu_complete", dynlib: readlineDll.}
+proc menu_complete*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_menu_complete", dynlib: readlineDll.}
+proc backward_menu_complete*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_backward_menu_complete", dynlib: readlineDll.}
+# Bindable commands for killing and yanking text, and managing the kill ring. 
+
+proc kill_word*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_kill_word", 
+    dynlib: readlineDll.}
+proc backward_kill_word*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_backward_kill_word", dynlib: readlineDll.}
+proc kill_line*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_kill_line", 
+    dynlib: readlineDll.}
+proc backward_kill_line*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_backward_kill_line", dynlib: readlineDll.}
+proc kill_full_line*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_kill_full_line", dynlib: readlineDll.}
+proc unix_word_rubout*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_unix_word_rubout", dynlib: readlineDll.}
+proc unix_filename_rubout*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_unix_filename_rubout", dynlib: readlineDll.}
+proc unix_line_discard*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_unix_line_discard", dynlib: readlineDll.}
+proc copy_region_to_kill*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_copy_region_to_kill", dynlib: readlineDll.}
+proc kill_region*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_kill_region", 
+    dynlib: readlineDll.}
+proc copy_forward_word*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_copy_forward_word", dynlib: readlineDll.}
+proc copy_backward_word*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_copy_backward_word", dynlib: readlineDll.}
+proc yank*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_yank", 
+                                      dynlib: readlineDll.}
+proc yank_pop*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_yank_pop", 
+    dynlib: readlineDll.}
+proc yank_nth_arg*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_yank_nth_arg", 
+    dynlib: readlineDll.}
+proc yank_last_arg*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_yank_last_arg", dynlib: readlineDll.}
+when defined(Windows): 
+  proc paste_from_clipboard*(a2: cint, a3: cint): cint{.cdecl, 
+      importc: "rl_paste_from_clipboard", dynlib: readlineDll.}
+# Bindable commands for incremental searching. 
+
+proc reverse_search_history*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_reverse_search_history", dynlib: readlineDll.}
+proc forward_search_history*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_forward_search_history", dynlib: readlineDll.}
+# Bindable keyboard macro commands. 
+
+proc start_kbd_macro*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_start_kbd_macro", dynlib: readlineDll.}
+proc end_kbd_macro*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_end_kbd_macro", dynlib: readlineDll.}
+proc call_last_kbd_macro*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_call_last_kbd_macro", dynlib: readlineDll.}
+# Bindable undo commands. 
+
+proc revert_line*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_revert_line", 
+    dynlib: readlineDll.}
+proc undo_command*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_undo_command", 
+    dynlib: readlineDll.}
+# Bindable tilde expansion commands. 
+
+proc tilde_expand*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_tilde_expand", 
+    dynlib: readlineDll.}
+# Bindable terminal control commands. 
+
+proc restart_output*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_restart_output", dynlib: readlineDll.}
+proc stop_output*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_stop_output", 
+    dynlib: readlineDll.}
+# Miscellaneous bindable commands. 
+
+proc abort*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_abort", 
+                                       dynlib: readlineDll.}
+proc tty_status*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_tty_status", 
+    dynlib: readlineDll.}
+# Bindable commands for incremental and non-incremental history searching. 
+
+proc history_search_forward*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_history_search_forward", dynlib: readlineDll.}
+proc history_search_backward*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_history_search_backward", dynlib: readlineDll.}
+proc noninc_forward_search*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_noninc_forward_search", dynlib: readlineDll.}
+proc noninc_reverse_search*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_noninc_reverse_search", dynlib: readlineDll.}
+proc noninc_forward_search_again*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_noninc_forward_search_again", dynlib: readlineDll.}
+proc noninc_reverse_search_again*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_noninc_reverse_search_again", dynlib: readlineDll.}
+# Bindable command used when inserting a matching close character. 
+
+proc insert_close*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_insert_close", 
+    dynlib: readlineDll.}
+# Not available unless READLINE_CALLBACKS is defined. 
+
+proc callback_handler_install*(a2: cstring, a3: TvcpFunc){.cdecl, 
+    importc: "rl_callback_handler_install", dynlib: readlineDll.}
+proc callback_read_char*(){.cdecl, importc: "rl_callback_read_char", 
+                            dynlib: readlineDll.}
+proc callback_handler_remove*(){.cdecl, importc: "rl_callback_handler_remove", 
+                                 dynlib: readlineDll.}
+# Things for vi mode. Not available unless readline is compiled -DVI_MODE. 
+# VI-mode bindable commands. 
+
+proc vi_redo*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_redo", 
+    dynlib: readlineDll.}
+proc vi_undo*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_undo", 
+    dynlib: readlineDll.}
+proc vi_yank_arg*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_yank_arg", 
+    dynlib: readlineDll.}
+proc vi_fetch_history*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_vi_fetch_history", dynlib: readlineDll.}
+proc vi_search_again*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_vi_search_again", dynlib: readlineDll.}
+proc vi_search*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_search", 
+    dynlib: readlineDll.}
+proc vi_complete*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_complete", 
+    dynlib: readlineDll.}
+proc vi_tilde_expand*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_vi_tilde_expand", dynlib: readlineDll.}
+proc vi_prev_word*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_prev_word", 
+    dynlib: readlineDll.}
+proc vi_next_word*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_next_word", 
+    dynlib: readlineDll.}
+proc vi_end_word*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_end_word", 
+    dynlib: readlineDll.}
+proc vi_insert_beg*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_vi_insert_beg", dynlib: readlineDll.}
+proc vi_append_mode*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_vi_append_mode", dynlib: readlineDll.}
+proc vi_append_eol*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_vi_append_eol", dynlib: readlineDll.}
+proc vi_eof_maybe*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_eof_maybe", 
+    dynlib: readlineDll.}
+proc vi_insertion_mode*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_vi_insertion_mode", dynlib: readlineDll.}
+proc vi_insert_mode*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_vi_insert_mode", dynlib: readlineDll.}
+proc vi_movement_mode*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_vi_movement_mode", dynlib: readlineDll.}
+proc vi_arg_digit*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_arg_digit", 
+    dynlib: readlineDll.}
+proc vi_change_case*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_vi_change_case", dynlib: readlineDll.}
+proc vi_put*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_put", 
+                                        dynlib: readlineDll.}
+proc vi_column*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_column", 
+    dynlib: readlineDll.}
+proc vi_delete_to*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_delete_to", 
+    dynlib: readlineDll.}
+proc vi_change_to*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_change_to", 
+    dynlib: readlineDll.}
+proc vi_yank_to*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_yank_to", 
+    dynlib: readlineDll.}
+proc vi_rubout*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_rubout", 
+    dynlib: readlineDll.}
+proc vi_delete*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_delete", 
+    dynlib: readlineDll.}
+proc vi_back_to_indent*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_vi_back_to_indent", dynlib: readlineDll.}
+proc vi_first_print*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_vi_first_print", dynlib: readlineDll.}
+proc vi_char_search*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_vi_char_search", dynlib: readlineDll.}
+proc vi_match*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_match", 
+    dynlib: readlineDll.}
+proc vi_change_char*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_vi_change_char", dynlib: readlineDll.}
+proc vi_subst*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_subst", 
+    dynlib: readlineDll.}
+proc vi_overstrike*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_vi_overstrike", dynlib: readlineDll.}
+proc vi_overstrike_delete*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_vi_overstrike_delete", dynlib: readlineDll.}
+proc vi_replace*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_replace", 
+    dynlib: readlineDll.}
+proc vi_set_mark*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_set_mark", 
+    dynlib: readlineDll.}
+proc vi_goto_mark*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_goto_mark", 
+    dynlib: readlineDll.}
+# VI-mode utility functions. 
+
+proc vi_check*(): cint{.cdecl, importc: "rl_vi_check", dynlib: readlineDll.}
+proc vi_domove*(a2: cint, a3: ptr cint): cint{.cdecl, importc: "rl_vi_domove", 
+    dynlib: readlineDll.}
+proc vi_bracktype*(a2: cint): cint{.cdecl, importc: "rl_vi_bracktype", 
+                                    dynlib: readlineDll.}
+proc vi_start_inserting*(a2: cint, a3: cint, a4: cint){.cdecl, 
+    importc: "rl_vi_start_inserting", dynlib: readlineDll.}
+# VI-mode pseudo-bindable commands, used as utility functions. 
+
+proc vi_fXWord*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_fWord", 
+    dynlib: readlineDll.}
+proc vi_bXWord*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_bWord", 
+    dynlib: readlineDll.}
+proc vi_eXWord*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_eWord", 
+    dynlib: readlineDll.}
+proc vi_fword*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_fword", 
+    dynlib: readlineDll.}
+proc vi_bword*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_bword", 
+    dynlib: readlineDll.}
+proc vi_eword*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_vi_eword", 
+    dynlib: readlineDll.}
+# **************************************************************** 
+#								    
+#			Well Published Functions		    
+#								    
+# **************************************************************** 
+# Readline functions. 
+# Read a line of input.  Prompt with PROMPT.  A NULL PROMPT means none. 
+
+proc readline*(a2: cstring): cstring{.cdecl, importc: "readline", 
+                                      dynlib: readlineDll.}
+proc free*(mem: cstring) {.importc: "free", nodecl.}
+  ## free the buffer that `readline` returned.
+
+proc set_prompt*(a2: cstring): cint{.cdecl, importc: "rl_set_prompt", 
+                                     dynlib: readlineDll.}
+proc expand_prompt*(a2: cstring): cint{.cdecl, importc: "rl_expand_prompt", 
+                                        dynlib: readlineDll.}
+proc initialize*(): cint{.cdecl, importc: "rl_initialize", dynlib: readlineDll.}
+# Undocumented; unused by readline 
+
+proc discard_argument*(): cint{.cdecl, importc: "rl_discard_argument", 
+                                dynlib: readlineDll.}
+# Utility functions to bind keys to readline commands. 
+
+proc add_defun*(a2: cstring, a3: TCommandFunc, a4: cint): cint{.cdecl, 
+    importc: "rl_add_defun", dynlib: readlineDll.}
+proc bind_key*(a2: cint, a3: TCommandFunc): cint{.cdecl, 
+    importc: "rl_bind_key", dynlib: readlineDll.}
+proc bind_key_in_map*(a2: cint, a3: TCommandFunc, a4: PKeymap): cint{.cdecl, 
+    importc: "rl_bind_key_in_map", dynlib: readlineDll.}
+proc unbind_key*(a2: cint): cint{.cdecl, importc: "rl_unbind_key", 
+                                  dynlib: readlineDll.}
+proc unbind_key_in_map*(a2: cint, a3: PKeymap): cint{.cdecl, 
+    importc: "rl_unbind_key_in_map", dynlib: readlineDll.}
+proc bind_key_if_unbound*(a2: cint, a3: TCommandFunc): cint{.cdecl, 
+    importc: "rl_bind_key_if_unbound", dynlib: readlineDll.}
+proc bind_key_if_unbound_in_map*(a2: cint, a3: TCommandFunc, a4: PKeymap): cint{.
+    cdecl, importc: "rl_bind_key_if_unbound_in_map", dynlib: readlineDll.}
+proc unbind_function_in_map*(a2: TCommandFunc, a3: PKeymap): cint{.cdecl, 
+    importc: "rl_unbind_function_in_map", dynlib: readlineDll.}
+proc unbind_command_in_map*(a2: cstring, a3: PKeymap): cint{.cdecl, 
+    importc: "rl_unbind_command_in_map", dynlib: readlineDll.}
+proc bind_keyseq*(a2: cstring, a3: TCommandFunc): cint{.cdecl, 
+    importc: "rl_bind_keyseq", dynlib: readlineDll.}
+proc bind_keyseq_in_map*(a2: cstring, a3: TCommandFunc, a4: PKeymap): cint{.
+    cdecl, importc: "rl_bind_keyseq_in_map", dynlib: readlineDll.}
+proc bind_keyseq_if_unbound*(a2: cstring, a3: TCommandFunc): cint{.cdecl, 
+    importc: "rl_bind_keyseq_if_unbound", dynlib: readlineDll.}
+proc bind_keyseq_if_unbound_in_map*(a2: cstring, a3: TCommandFunc, 
+                                    a4: PKeymap): cint{.cdecl, 
+    importc: "rl_bind_keyseq_if_unbound_in_map", dynlib: readlineDll.}
+proc generic_bind*(a2: cint, a3: cstring, a4: cstring, a5: PKeymap): cint{.
+    cdecl, importc: "rl_generic_bind", dynlib: readlineDll.}
+proc variable_value*(a2: cstring): cstring{.cdecl, importc: "rl_variable_value", 
+    dynlib: readlineDll.}
+proc variable_bind*(a2: cstring, a3: cstring): cint{.cdecl, 
+    importc: "rl_variable_bind", dynlib: readlineDll.}
+# Backwards compatibility, use rl_bind_keyseq_in_map instead. 
+
+proc set_key*(a2: cstring, a3: TCommandFunc, a4: PKeymap): cint{.cdecl, 
+    importc: "rl_set_key", dynlib: readlineDll.}
+# Backwards compatibility, use rl_generic_bind instead. 
+
+proc macro_bind*(a2: cstring, a3: cstring, a4: PKeymap): cint{.cdecl, 
+    importc: "rl_macro_bind", dynlib: readlineDll.}
+# Undocumented in the texinfo manual; not really useful to programs. 
+
+proc translate_keyseq*(a2: cstring, a3: cstring, a4: ptr cint): cint{.cdecl, 
+    importc: "rl_translate_keyseq", dynlib: readlineDll.}
+proc untranslate_keyseq*(a2: cint): cstring{.cdecl, 
+    importc: "rl_untranslate_keyseq", dynlib: readlineDll.}
+proc named_function*(a2: cstring): TCommandFunc{.cdecl, 
+    importc: "rl_named_function", dynlib: readlineDll.}
+proc function_of_keyseq*(a2: cstring, a3: PKeymap, a4: ptr cint): TCommandFunc{.
+    cdecl, importc: "rl_function_of_keyseq", dynlib: readlineDll.}
+proc list_funmap_names*(){.cdecl, importc: "rl_list_funmap_names", 
+                           dynlib: readlineDll.}
+proc invoking_keyseqs_in_map*(a2: TCommandFunc, a3: PKeymap): cstringArray{.
+    cdecl, importc: "rl_invoking_keyseqs_in_map", dynlib: readlineDll.}
+proc invoking_keyseqs*(a2: TCommandFunc): cstringArray{.cdecl, 
+    importc: "rl_invoking_keyseqs", dynlib: readlineDll.}
+proc function_dumper*(a2: cint){.cdecl, importc: "rl_function_dumper", 
+                                 dynlib: readlineDll.}
+proc macro_dumper*(a2: cint){.cdecl, importc: "rl_macro_dumper", 
+                              dynlib: readlineDll.}
+proc variable_dumper*(a2: cint){.cdecl, importc: "rl_variable_dumper", 
+                                 dynlib: readlineDll.}
+proc read_init_file*(a2: cstring): cint{.cdecl, importc: "rl_read_init_file", 
+    dynlib: readlineDll.}
+proc parse_and_bind*(a2: cstring): cint{.cdecl, importc: "rl_parse_and_bind", 
+    dynlib: readlineDll.}
+
+proc get_keymap_name*(a2: PKeymap): cstring{.cdecl, 
+    importc: "rl_get_keymap_name", dynlib: readlineDll.}
+
+proc set_keymap_from_edit_mode*(){.cdecl, 
+                                   importc: "rl_set_keymap_from_edit_mode", 
+                                   dynlib: readlineDll.}
+proc get_keymap_name_from_edit_mode*(): cstring{.cdecl, 
+    importc: "rl_get_keymap_name_from_edit_mode", dynlib: readlineDll.}
+# Functions for manipulating the funmap, which maps command names to functions. 
+
+proc add_funmap_entry*(a2: cstring, a3: TCommandFunc): cint{.cdecl, 
+    importc: "rl_add_funmap_entry", dynlib: readlineDll.}
+proc funmap_names*(): cstringArray{.cdecl, importc: "rl_funmap_names", 
+                                    dynlib: readlineDll.}
+# Undocumented, only used internally -- there is only one funmap, and this
+#   function may be called only once. 
+
+proc initialize_funmap*(){.cdecl, importc: "rl_initialize_funmap", 
+                           dynlib: readlineDll.}
+# Utility functions for managing keyboard macros. 
+
+proc push_macro_input*(a2: cstring){.cdecl, importc: "rl_push_macro_input", 
+                                     dynlib: readlineDll.}
+# Functions for undoing, from undo.c 
+
+proc add_undo*(a2: Tundo_code, a3: cint, a4: cint, a5: cstring){.cdecl, 
+    importc: "rl_add_undo", dynlib: readlineDll.}
+proc free_undo_list*(){.cdecl, importc: "rl_free_undo_list", dynlib: readlineDll.}
+proc do_undo*(): cint{.cdecl, importc: "rl_do_undo", dynlib: readlineDll.}
+proc begin_undo_group*(): cint{.cdecl, importc: "rl_begin_undo_group", 
+                                dynlib: readlineDll.}
+proc end_undo_group*(): cint{.cdecl, importc: "rl_end_undo_group", 
+                              dynlib: readlineDll.}
+proc modifying*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_modifying", 
+    dynlib: readlineDll.}
+# Functions for redisplay. 
+
+proc redisplay*(){.cdecl, importc: "rl_redisplay", dynlib: readlineDll.}
+proc on_new_line*(): cint{.cdecl, importc: "rl_on_new_line", dynlib: readlineDll.}
+proc on_new_line_with_prompt*(): cint{.cdecl, 
+                                       importc: "rl_on_new_line_with_prompt", 
+                                       dynlib: readlineDll.}
+proc forced_update_display*(): cint{.cdecl, importc: "rl_forced_update_display", 
+                                     dynlib: readlineDll.}
+proc clear_message*(): cint{.cdecl, importc: "rl_clear_message", 
+                             dynlib: readlineDll.}
+proc reset_line_state*(): cint{.cdecl, importc: "rl_reset_line_state", 
+                                dynlib: readlineDll.}
+proc crlf*(): cint{.cdecl, importc: "rl_crlf", dynlib: readlineDll.}
+proc message*(a2: cstring): cint{.varargs, cdecl, importc: "rl_message", 
+                                  dynlib: readlineDll.}
+proc show_char*(a2: cint): cint{.cdecl, importc: "rl_show_char", 
+                                 dynlib: readlineDll.}
+# Undocumented in texinfo manual. 
+
+proc character_len*(a2: cint, a3: cint): cint{.cdecl, 
+    importc: "rl_character_len", dynlib: readlineDll.}
+# Save and restore internal prompt redisplay information. 
+
+proc save_prompt*(){.cdecl, importc: "rl_save_prompt", dynlib: readlineDll.}
+proc restore_prompt*(){.cdecl, importc: "rl_restore_prompt", dynlib: readlineDll.}
+# Modifying text. 
+
+proc replace_line*(a2: cstring, a3: cint){.cdecl, importc: "rl_replace_line", 
+    dynlib: readlineDll.}
+proc insert_text*(a2: cstring): cint{.cdecl, importc: "rl_insert_text", 
+                                      dynlib: readlineDll.}
+proc delete_text*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_delete_text", 
+    dynlib: readlineDll.}
+proc kill_text*(a2: cint, a3: cint): cint{.cdecl, importc: "rl_kill_text", 
+    dynlib: readlineDll.}
+proc copy_text*(a2: cint, a3: cint): cstring{.cdecl, importc: "rl_copy_text", 
+    dynlib: readlineDll.}
+# Terminal and tty mode management. 
+
+proc prep_terminal*(a2: cint){.cdecl, importc: "rl_prep_terminal", 
+                               dynlib: readlineDll.}
+proc deprep_terminal*(){.cdecl, importc: "rl_deprep_terminal", 
+                         dynlib: readlineDll.}
+proc tty_set_default_bindings*(a2: PKeymap){.cdecl, 
+    importc: "rl_tty_set_default_bindings", dynlib: readlineDll.}
+proc tty_unset_default_bindings*(a2: PKeymap){.cdecl, 
+    importc: "rl_tty_unset_default_bindings", dynlib: readlineDll.}
+proc reset_terminal*(a2: cstring): cint{.cdecl, importc: "rl_reset_terminal", 
+    dynlib: readlineDll.}
+proc resize_terminal*(){.cdecl, importc: "rl_resize_terminal", 
+                         dynlib: readlineDll.}
+proc set_screen_size*(a2: cint, a3: cint){.cdecl, importc: "rl_set_screen_size", 
+    dynlib: readlineDll.}
+proc get_screen_size*(a2: ptr cint, a3: ptr cint){.cdecl, 
+    importc: "rl_get_screen_size", dynlib: readlineDll.}
+proc reset_screen_size*(){.cdecl, importc: "rl_reset_screen_size", 
+                           dynlib: readlineDll.}
+proc get_termcap*(a2: cstring): cstring{.cdecl, importc: "rl_get_termcap", 
+    dynlib: readlineDll.}
+# Functions for character input. 
+
+proc stuff_char*(a2: cint): cint{.cdecl, importc: "rl_stuff_char", 
+                                  dynlib: readlineDll.}
+proc execute_next*(a2: cint): cint{.cdecl, importc: "rl_execute_next", 
+                                    dynlib: readlineDll.}
+proc clear_pending_input*(): cint{.cdecl, importc: "rl_clear_pending_input", 
+                                   dynlib: readlineDll.}
+proc read_key*(): cint{.cdecl, importc: "rl_read_key", dynlib: readlineDll.}
+proc getc*(a2: TFile): cint{.cdecl, importc: "rl_getc", dynlib: readlineDll.}
+proc set_keyboard_input_timeout*(a2: cint): cint{.cdecl, 
+    importc: "rl_set_keyboard_input_timeout", dynlib: readlineDll.}
+# `Public' utility functions . 
+
+proc extend_line_buffer*(a2: cint){.cdecl, importc: "rl_extend_line_buffer", 
+                                    dynlib: readlineDll.}
+proc ding*(): cint{.cdecl, importc: "rl_ding", dynlib: readlineDll.}
+proc alphabetic*(a2: cint): cint{.cdecl, importc: "rl_alphabetic", 
+                                  dynlib: readlineDll.}
+proc free*(a2: pointer){.cdecl, importc: "rl_free", dynlib: readlineDll.}
+# Readline signal handling, from signals.c 
+
+proc set_signals*(): cint{.cdecl, importc: "rl_set_signals", dynlib: readlineDll.}
+proc clear_signals*(): cint{.cdecl, importc: "rl_clear_signals", 
+                             dynlib: readlineDll.}
+proc cleanup_after_signal*(){.cdecl, importc: "rl_cleanup_after_signal", 
+                              dynlib: readlineDll.}
+proc reset_after_signal*(){.cdecl, importc: "rl_reset_after_signal", 
+                            dynlib: readlineDll.}
+proc free_line_state*(){.cdecl, importc: "rl_free_line_state", 
+                         dynlib: readlineDll.}
+proc echo_signal_char*(a2: cint){.cdecl, importc: "rl_echo_signal_char", 
+                                  dynlib: readlineDll.}
+proc set_paren_blink_timeout*(a2: cint): cint{.cdecl, 
+    importc: "rl_set_paren_blink_timeout", dynlib: readlineDll.}
+# Undocumented. 
+
+proc maybe_save_line*(): cint{.cdecl, importc: "rl_maybe_save_line", 
+                               dynlib: readlineDll.}
+proc maybe_unsave_line*(): cint{.cdecl, importc: "rl_maybe_unsave_line", 
+                                 dynlib: readlineDll.}
+proc maybe_replace_line*(): cint{.cdecl, importc: "rl_maybe_replace_line", 
+                                  dynlib: readlineDll.}
+# Completion functions. 
+
+proc complete_internal*(a2: cint): cint{.cdecl, importc: "rl_complete_internal", 
+    dynlib: readlineDll.}
+proc display_match_list*(a2: cstringArray, a3: cint, a4: cint){.cdecl, 
+    importc: "rl_display_match_list", dynlib: readlineDll.}
+proc completion_matches*(a2: cstring, a3: Tcompentry_func): cstringArray{.
+    cdecl, importc: "rl_completion_matches", dynlib: readlineDll.}
+proc username_completion_function*(a2: cstring, a3: cint): cstring{.cdecl, 
+    importc: "rl_username_completion_function", dynlib: readlineDll.}
+proc filename_completion_function*(a2: cstring, a3: cint): cstring{.cdecl, 
+    importc: "rl_filename_completion_function", dynlib: readlineDll.}
+proc completion_mode*(a2: TCommandFunc): cint{.cdecl, 
+    importc: "rl_completion_mode", dynlib: readlineDll.}
+# **************************************************************** 
+#								    
+#			Well Published Variables		    
+#								    
+# **************************************************************** 
+
+when false: 
+  # The version of this incarnation of the readline library. 
+  var library_version*{.importc: "rl_library_version", dynlib: readlineDll.}: cstring
+  # e.g., "4.2" 
+  var readline_version*{.importc: "rl_readline_version", dynlib: readlineDll.}: cint
+  # e.g., 0x0402 
+  # True if this is real GNU readline. 
+  var gnu_readline_p*{.importc: "rl_gnu_readline_p", dynlib: readlineDll.}: cint
+  # Flags word encapsulating the current readline state. 
+  var readline_state*{.importc: "rl_readline_state", dynlib: readlineDll.}: cint
+  # Says which editing mode readline is currently using.  1 means emacs mode;
+  #   0 means vi mode. 
+  var editing_mode*{.importc: "rl_editing_mode", dynlib: readlineDll.}: cint
+  # Insert or overwrite mode for emacs mode.  1 means insert mode; 0 means
+  #   overwrite mode.  Reset to insert mode on each input line. 
+  var insert_mode*{.importc: "rl_insert_mode", dynlib: readlineDll.}: cint
+  # The name of the calling program.  You should initialize this to
+  #   whatever was in argv[0].  It is used when parsing conditionals. 
+  var readline_name*{.importc: "rl_readline_name", dynlib: readlineDll.}: cstring
+  # The prompt readline uses.  This is set from the argument to
+  #   readline (), and should not be assigned to directly. 
+  var prompt*{.importc: "rl_prompt", dynlib: readlineDll.}: cstring
+  # The prompt string that is actually displayed by rl_redisplay.  Public so
+  #   applications can more easily supply their own redisplay functions. 
+  var display_prompt*{.importc: "rl_display_prompt", dynlib: readlineDll.}: cstring
+  # The line buffer that is in use. 
+  var line_buffer*{.importc: "rl_line_buffer", dynlib: readlineDll.}: cstring
+  # The location of point, and end. 
+  var point*{.importc: "rl_point", dynlib: readlineDll.}: cint
+  var theEnd*{.importc: "rl_end", dynlib: readlineDll.}: cint
+  # The mark, or saved cursor position. 
+  var mark*{.importc: "rl_mark", dynlib: readlineDll.}: cint
+  # Flag to indicate that readline has finished with the current input
+  #   line and should return it. 
+  var done*{.importc: "rl_done", dynlib: readlineDll.}: cint
+  # If set to a character value, that will be the next keystroke read. 
+  var pending_input*{.importc: "rl_pending_input", dynlib: readlineDll.}: cint
+  # Non-zero if we called this function from _rl_dispatch().  It's present
+  #   so functions can find out whether they were called from a key binding
+  #   or directly from an application. 
+  var dispatching*{.importc: "rl_dispatching", dynlib: readlineDll.}: cint
+  # Non-zero if the user typed a numeric argument before executing the
+  #   current function. 
+  var explicit_arg*{.importc: "rl_explicit_arg", dynlib: readlineDll.}: cint
+  # The current value of the numeric argument specified by the user. 
+  var numeric_arg*{.importc: "rl_numeric_arg", dynlib: readlineDll.}: cint
+  # The address of the last command function Readline executed. 
+  var last_func*{.importc: "rl_last_func", dynlib: readlineDll.}: TCommandFunc
+  # The name of the terminal to use. 
+  var terminal_name*{.importc: "rl_terminal_name", dynlib: readlineDll.}: cstring
+  # The input and output streams. 
+  var instream*{.importc: "rl_instream", dynlib: readlineDll.}: TFile
+  var outstream*{.importc: "rl_outstream", dynlib: readlineDll.}: TFile
+  # If non-zero, Readline gives values of LINES and COLUMNS from the environment
+  #   greater precedence than values fetched from the kernel when computing the
+  #   screen dimensions. 
+  var prefer_env_winsize*{.importc: "rl_prefer_env_winsize", dynlib: readlineDll.}: cint
+  # If non-zero, then this is the address of a function to call just
+  #   before readline_internal () prints the first prompt. 
+  var startup_hook*{.importc: "rl_startup_hook", dynlib: readlineDll.}:  hook_func
+  # If non-zero, this is the address of a function to call just before
+  #   readline_internal_setup () returns and readline_internal starts
+  #   reading input characters. 
+  var pre_input_hook*{.importc: "rl_pre_input_hook", dynlib: readlineDll.}: hook_func
+  # The address of a function to call periodically while Readline is
+  #   awaiting character input, or NULL, for no event handling. 
+  var event_hook*{.importc: "rl_event_hook", dynlib: readlineDll.}: hook_func
+  # The address of the function to call to fetch a character from the current
+  #   Readline input stream 
+  var getc_function*{.importc: "rl_getc_function", dynlib: readlineDll.}: getc_func
+  var redisplay_function*{.importc: "rl_redisplay_function", dynlib: readlineDll.}: voidfunc
+  var prep_term_function*{.importc: "rl_prep_term_function", dynlib: readlineDll.}: vintfunc
+  var deprep_term_function*{.importc: "rl_deprep_term_function", 
+                             dynlib: readlineDll.}: voidfunc
+  # Dispatch variables. 
+  var executing_keymap*{.importc: "rl_executing_keymap", dynlib: readlineDll.}: PKeymap
+  var binding_keymap*{.importc: "rl_binding_keymap", dynlib: readlineDll.}: PKeymap
+  # Display variables. 
+  # If non-zero, readline will erase the entire line, including any prompt,
+  #   if the only thing typed on an otherwise-blank line is something bound to
+  #   rl_newline. 
+  var erase_empty_line*{.importc: "rl_erase_empty_line", dynlib: readlineDll.}: cint
+  # If non-zero, the application has already printed the prompt (rl_prompt)
+  #   before calling readline, so readline should not output it the first time
+  #   redisplay is done. 
+  var already_prompted*{.importc: "rl_already_prompted", dynlib: readlineDll.}: cint
+  # A non-zero value means to read only this many characters rather than
+  #   up to a character bound to accept-line. 
+  var num_chars_to_read*{.importc: "rl_num_chars_to_read", dynlib: readlineDll.}: cint
+  # The text of a currently-executing keyboard macro. 
+  var executing_macro*{.importc: "rl_executing_macro", dynlib: readlineDll.}: cstring
+  # Variables to control readline signal handling. 
+  # If non-zero, readline will install its own signal handlers for
+  #   SIGINT, SIGTERM, SIGQUIT, SIGALRM, SIGTSTP, SIGTTIN, and SIGTTOU. 
+  var catch_signals*{.importc: "rl_catch_signals", dynlib: readlineDll.}: cint
+  # If non-zero, readline will install a signal handler for SIGWINCH
+  #   that also attempts to call any calling application's SIGWINCH signal
+  #   handler.  Note that the terminal is not cleaned up before the
+  #   application's signal handler is called; use rl_cleanup_after_signal()
+  #   to do that. 
+  var catch_sigwinch*{.importc: "rl_catch_sigwinch", dynlib: readlineDll.}: cint
+  # Completion variables. 
+  # Pointer to the generator function for completion_matches ().
+  #   NULL means to use rl_filename_completion_function (), the default
+  #   filename completer. 
+  var completion_entry_function*{.importc: "rl_completion_entry_function", 
+                                  dynlib: readlineDll.}: compentry_func
+  # Optional generator for menu completion.  Default is
+  #   rl_completion_entry_function (rl_filename_completion_function). 
+  var menu_completion_entry_function*{.importc: "rl_menu_completion_entry_function", 
+                                       dynlib: readlineDll.}: compentry_func
+  # If rl_ignore_some_completions_function is non-NULL it is the address
+  #   of a function to call after all of the possible matches have been
+  #   generated, but before the actual completion is done to the input line.
+  #   The function is called with one argument; a NULL terminated array
+  #   of (char *).  If your function removes any of the elements, they
+  #   must be free()'ed. 
+  var ignore_some_completions_function*{.
+      importc: "rl_ignore_some_completions_function", dynlib: readlineDll.}: compignore_func
+  # Pointer to alternative function to create matches.
+  #   Function is called with TEXT, START, and END.
+  #   START and END are indices in RL_LINE_BUFFER saying what the boundaries
+  #   of TEXT are.
+  #   If this function exists and returns NULL then call the value of
+  #   rl_completion_entry_function to try to match, otherwise use the
+  #   array of strings returned. 
+  var attempted_completion_function*{.importc: "rl_attempted_completion_function", 
+                                      dynlib: readlineDll.}: completion_func
+  # The basic list of characters that signal a break between words for the
+  #   completer routine.  The initial contents of this variable is what
+  #   breaks words in the shell, i.e. "n\"\\'`@$>". 
+  var basic_word_break_characters*{.importc: "rl_basic_word_break_characters", 
+                                    dynlib: readlineDll.}: cstring
+  # The list of characters that signal a break between words for
+  #   rl_complete_internal.  The default list is the contents of
+  #   rl_basic_word_break_characters.  
+  var completer_word_break_characters*{.importc: "rl_completer_word_break_characters", 
+                                        dynlib: readlineDll.}: cstring
+  # Hook function to allow an application to set the completion word
+  #   break characters before readline breaks up the line.  Allows
+  #   position-dependent word break characters. 
+  var completion_word_break_hook*{.importc: "rl_completion_word_break_hook", 
+                                   dynlib: readlineDll.}: cpvfunc
+  # List of characters which can be used to quote a substring of the line.
+  #   Completion occurs on the entire substring, and within the substring   
+  #   rl_completer_word_break_characters are treated as any other character,
+  #   unless they also appear within this list. 
+  var completer_quote_characters*{.importc: "rl_completer_quote_characters", 
+                                   dynlib: readlineDll.}: cstring
+  # List of quote characters which cause a word break. 
+  var basic_quote_characters*{.importc: "rl_basic_quote_characters", 
+                               dynlib: readlineDll.}: cstring
+  # List of characters that need to be quoted in filenames by the completer. 
+  var filename_quote_characters*{.importc: "rl_filename_quote_characters", 
+                                  dynlib: readlineDll.}: cstring
+  # List of characters that are word break characters, but should be left
+  #   in TEXT when it is passed to the completion function.  The shell uses
+  #   this to help determine what kind of completing to do. 
+  var special_prefixes*{.importc: "rl_special_prefixes", dynlib: readlineDll.}: cstring
+  # If non-zero, then this is the address of a function to call when
+  #   completing on a directory name.  The function is called with
+  #   the address of a string (the current directory name) as an arg.  It
+  #   changes what is displayed when the possible completions are printed
+  #   or inserted. 
+  var directory_completion_hook*{.importc: "rl_directory_completion_hook", 
+                                  dynlib: readlineDll.}: icppfunc
+  # If non-zero, this is the address of a function to call when completing
+  #   a directory name.  This function takes the address of the directory name
+  #   to be modified as an argument.  Unlike rl_directory_completion_hook, it
+  #   only modifies the directory name used in opendir(2), not what is displayed
+  #   when the possible completions are printed or inserted.  It is called
+  #   before rl_directory_completion_hook.  I'm not happy with how this works
+  #   yet, so it's undocumented. 
+  var directory_rewrite_hook*{.importc: "rl_directory_rewrite_hook", 
+                               dynlib: readlineDll.}: icppfunc
+  # If non-zero, this is the address of a function to call when reading
+  #   directory entries from the filesystem for completion and comparing
+  #   them to the partial word to be completed.  The function should
+  #   either return its first argument (if no conversion takes place) or
+  #   newly-allocated memory.  This can, for instance, convert filenames
+  #   between character sets for comparison against what's typed at the
+  #   keyboard.  The returned value is what is added to the list of
+  #   matches.  The second argument is the length of the filename to be
+  #   converted. 
+  var filename_rewrite_hook*{.importc: "rl_filename_rewrite_hook", 
+                              dynlib: readlineDll.}: dequote_func
+  # If non-zero, then this is the address of a function to call when
+  #   completing a word would normally display the list of possible matches.
+  #   This function is called instead of actually doing the display.
+  #   It takes three arguments: (char **matches, int num_matches, int max_length)
+  #   where MATCHES is the array of strings that matched, NUM_MATCHES is the
+  #   number of strings in that array, and MAX_LENGTH is the length of the
+  #   longest string in that array. 
+  var completion_display_matches_hook*{.importc: "rl_completion_display_matches_hook", 
+                                        dynlib: readlineDll.}: compdisp_func
+  # Non-zero means that the results of the matches are to be treated
+  #   as filenames.  This is ALWAYS zero on entry, and can only be changed
+  #   within a completion entry finder function. 
+  var filename_completion_desired*{.importc: "rl_filename_completion_desired", 
+                                    dynlib: readlineDll.}: cint
+  # Non-zero means that the results of the matches are to be quoted using
+  #   double quotes (or an application-specific quoting mechanism) if the
+  #   filename contains any characters in rl_word_break_chars.  This is
+  #   ALWAYS non-zero on entry, and can only be changed within a completion
+  #   entry finder function. 
+  var filename_quoting_desired*{.importc: "rl_filename_quoting_desired", 
+                                 dynlib: readlineDll.}: cint
+  # Set to a function to quote a filename in an application-specific fashion.
+  #   Called with the text to quote, the type of match found (single or multiple)
+  #   and a pointer to the quoting character to be used, which the function can
+  #   reset if desired. 
+  var filename_quoting_function*{.importc: "rl_filename_quoting_function", 
+                                  dynlib: readlineDll.}: quote_func
+  # Function to call to remove quoting characters from a filename.  Called
+  #   before completion is attempted, so the embedded quotes do not interfere
+  #   with matching names in the file system. 
+  var filename_dequoting_function*{.importc: "rl_filename_dequoting_function", 
+                                    dynlib: readlineDll.}: dequote_func
+  # Function to call to decide whether or not a word break character is
+  #   quoted.  If a character is quoted, it does not break words for the
+  #   completer. 
+  var char_is_quoted_p*{.importc: "rl_char_is_quoted_p", dynlib: readlineDll.}: linebuf_func
+  # Non-zero means to suppress normal filename completion after the
+  #   user-specified completion function has been called. 
+  var attempted_completion_over*{.importc: "rl_attempted_completion_over", 
+                                  dynlib: readlineDll.}: cint
+  # Set to a character describing the type of completion being attempted by
+  #   rl_complete_internal; available for use by application completion
+  #   functions. 
+  var completion_type*{.importc: "rl_completion_type", dynlib: readlineDll.}: cint
+  # Set to the last key used to invoke one of the completion functions 
+  var completion_invoking_key*{.importc: "rl_completion_invoking_key", 
+                                dynlib: readlineDll.}: cint
+  # Up to this many items will be displayed in response to a
+  #   possible-completions call.  After that, we ask the user if she
+  #   is sure she wants to see them all.  The default value is 100. 
+  var completion_query_items*{.importc: "rl_completion_query_items", 
+                               dynlib: readlineDll.}: cint
+  # Character appended to completed words when at the end of the line.  The
+  #   default is a space.  Nothing is added if this is '\0'. 
+  var completion_append_character*{.importc: "rl_completion_append_character", 
+                                    dynlib: readlineDll.}: cint
+  # If set to non-zero by an application completion function,
+  #   rl_completion_append_character will not be appended. 
+  var completion_suppress_append*{.importc: "rl_completion_suppress_append", 
+                                   dynlib: readlineDll.}: cint
+  # Set to any quote character readline thinks it finds before any application
+  #   completion function is called. 
+  var completion_quote_character*{.importc: "rl_completion_quote_character", 
+                                   dynlib: readlineDll.}: cint
+  # Set to a non-zero value if readline found quoting anywhere in the word to
+  #   be completed; set before any application completion function is called. 
+  var completion_found_quote*{.importc: "rl_completion_found_quote", 
+                               dynlib: readlineDll.}: cint
+  # If non-zero, the completion functions don't append any closing quote.
+  #   This is set to 0 by rl_complete_internal and may be changed by an
+  #   application-specific completion function. 
+  var completion_suppress_quote*{.importc: "rl_completion_suppress_quote", 
+                                  dynlib: readlineDll.}: cint
+  # If non-zero, readline will sort the completion matches.  On by default. 
+  var sort_completion_matches*{.importc: "rl_sort_completion_matches", 
+                                dynlib: readlineDll.}: cint
+  # If non-zero, a slash will be appended to completed filenames that are
+  #   symbolic links to directory names, subject to the value of the
+  #   mark-directories variable (which is user-settable).  This exists so
+  #   that application completion functions can override the user's preference
+  #   (set via the mark-symlinked-directories variable) if appropriate.
+  #   It's set to the value of _rl_complete_mark_symlink_dirs in
+  #   rl_complete_internal before any application-specific completion
+  #   function is called, so without that function doing anything, the user's
+  #   preferences are honored. 
+  var completion_mark_symlink_dirs*{.importc: "rl_completion_mark_symlink_dirs", 
+                                     dynlib: readlineDll.}: cint
+  # If non-zero, then disallow duplicates in the matches. 
+  var ignore_completion_duplicates*{.importc: "rl_ignore_completion_duplicates", 
+                                     dynlib: readlineDll.}: cint
+  # If this is non-zero, completion is (temporarily) inhibited, and the
+  #   completion character will be inserted as any other. 
+  var inhibit_completion*{.importc: "rl_inhibit_completion", dynlib: readlineDll.}: cint
+# Input error; can be returned by (*rl_getc_function) if readline is reading
+#   a top-level command (RL_ISSTATE (RL_STATE_READCMD)). 
+
+const 
+  READERR* = (- 2)
+
+# Definitions available for use by readline clients. 
+
+const 
+  PROMPT_START_IGNORE* = '\x01'
+  PROMPT_END_IGNORE* = '\x02'
+
+# Possible values for do_replace argument to rl_filename_quoting_function,
+#   called by rl_complete_internal. 
+
+const 
+  NO_MATCH* = 0
+  SINGLE_MATCH* = 1
+  MULT_MATCH* = 2
+
+# Possible state values for rl_readline_state 
+
+const 
+  STATE_NONE* = 0x00000000    # no state; before first call 
+  STATE_INITIALIZING* = 0x00000001 # initializing 
+  STATE_INITIALIZED* = 0x00000002 # initialization done 
+  STATE_TERMPREPPED* = 0x00000004 # terminal is prepped 
+  STATE_READCMD* = 0x00000008 # reading a command key 
+  STATE_METANEXT* = 0x00000010 # reading input after ESC 
+  STATE_DISPATCHING* = 0x00000020 # dispatching to a command 
+  STATE_MOREINPUT* = 0x00000040 # reading more input in a command function 
+  STATE_ISEARCH* = 0x00000080 # doing incremental search 
+  STATE_NSEARCH* = 0x00000100 # doing non-inc search 
+  STATE_SEARCH* = 0x00000200  # doing a history search 
+  STATE_NUMERICARG* = 0x00000400 # reading numeric argument 
+  STATE_MACROINPUT* = 0x00000800 # getting input from a macro 
+  STATE_MACRODEF* = 0x00001000 # defining keyboard macro 
+  STATE_OVERWRITE* = 0x00002000 # overwrite mode 
+  STATE_COMPLETING* = 0x00004000 # doing completion 
+  STATE_SIGHANDLER* = 0x00008000 # in readline sighandler 
+  STATE_UNDOING* = 0x00010000 # doing an undo 
+  STATE_INPUTPENDING* = 0x00020000 # rl_execute_next called 
+  STATE_TTYCSAVED* = 0x00040000 # tty special chars saved 
+  STATE_CALLBACK* = 0x00080000 # using the callback interface 
+  STATE_VIMOTION* = 0x00100000 # reading vi motion arg 
+  STATE_MULTIKEY* = 0x00200000 # reading multiple-key command 
+  STATE_VICMDONCE* = 0x00400000 # entered vi command mode at least once 
+  STATE_REDISPLAYING* = 0x00800000 # updating terminal display 
+  STATE_DONE* = 0x01000000    # done; accepted line 
+
+template SETSTATE*(x: expr): stmt = 
+  readline_state = readline_state or (x)
+
+template UNSETSTATE*(x: expr): stmt = 
+  readline_state = readline_state and not (x)
+
+template ISSTATE*(x: expr): expr = 
+  (readline_state and x) != 0
+
+type 
+  Treadline_state*{.pure, final.} = object 
+    point*: cint              # line state 
+    theEnd*: cint
+    mark*: cint
+    buffer*: cstring
+    buflen*: cint
+    ul*: ptr TUNDO_LIST
+    prompt*: cstring          # global state 
+    rlstate*: cint
+    done*: cint
+    kmap*: PKeymap            # input state 
+    lastfunc*: TCommandFunc
+    insmode*: cint
+    edmode*: cint
+    kseqlen*: cint
+    inf*: TFile
+    outf*: TFile
+    pendingin*: cint
+    theMacro*: cstring        # signal state 
+    catchsigs*: cint
+    catchsigwinch*: cint      # search state 
+                              # completion state 
+                              # options state 
+                              # reserved for future expansion, so the struct size doesn't change 
+    reserved*: array[0..64 - 1, char]
+
+
+proc save_state*(a2: ptr Treadline_state): cint{.cdecl, 
+    importc: "rl_save_state", dynlib: readlineDll.}
+proc restore_state*(a2: ptr Treadline_state): cint{.cdecl, 
+    importc: "rl_restore_state", dynlib: readlineDll.}
diff --git a/lib/wrappers/readline/rltypedefs.nim b/lib/wrappers/readline/rltypedefs.nim
new file mode 100644
index 000000000..202cf925d
--- /dev/null
+++ b/lib/wrappers/readline/rltypedefs.nim
@@ -0,0 +1,74 @@
+# rltypedefs.h -- Type declarations for readline functions. 
+# Copyright (C) 2000-2009 Free Software Foundation, Inc.
+#
+#   This file is part of the GNU Readline Library (Readline), a library
+#   for reading lines of text with interactive input and history editing.      
+#
+#   Readline 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 3 of the License, or
+#   (at your option) any later version.
+#
+#   Readline 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 Readline.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+type 
+  TFunction* = proc (): cint{.cdecl.}
+  TVFunction* = proc (){.cdecl.}
+  TCPFunction* = proc (): cstring{.cdecl.}
+  TCPPFunction* = proc (): cstringArray{.cdecl.}
+
+# Bindable functions 
+
+type 
+  Tcommand_func* = proc (a2: cint, a3: cint): cint{.cdecl.}
+
+# Typedefs for the completion system 
+
+type 
+  Tcompentry_func* = proc (a2: cstring, a3: cint): cstring{.cdecl.}
+  Tcompletion_func* = proc (a2: cstring, a3: cint, a4: cint): cstringArray{.
+      cdecl.}
+  Tquote_func* = proc (a2: cstring, a3: cint, a4: cstring): cstring{.cdecl.}
+  Tdequote_func* = proc (a2: cstring, a3: cint): cstring{.cdecl.}
+  Tcompignore_func* = proc (a2: cstringArray): cint{.cdecl.}
+  Tcompdisp_func* = proc (a2: cstringArray, a3: cint, a4: cint){.cdecl.}
+
+# Type for input and pre-read hook functions like rl_event_hook 
+
+type 
+  Thook_func* = proc (): cint{.cdecl.}
+
+# Input function type 
+
+type 
+  Tgetc_func* = proc (a2: TFile): cint{.cdecl.}
+
+# Generic function that takes a character buffer (which could be the readline
+#   line buffer) and an index into it (which could be rl_point) and returns
+#   an int. 
+
+type 
+  Tlinebuf_func* = proc (a2: cstring, a3: cint): cint{.cdecl.}
+
+# `Generic' function pointer typedefs 
+
+type 
+  Tintfunc* = proc (a2: cint): cint{.cdecl.}
+  Tivoidfunc* = proc (): cint{.cdecl.}
+  Ticpfunc* = proc (a2: cstring): cint{.cdecl.}
+  Ticppfunc* = proc (a2: cstringArray): cint{.cdecl.}
+  Tvoidfunc* = proc (){.cdecl.}
+  Tvintfunc* = proc (a2: cint){.cdecl.}
+  Tvcpfunc* = proc (a2: cstring){.cdecl.}
+  Tvcppfunc* = proc (a2: cstringArray){.cdecl.}
+  Tcpvfunc* = proc (): cstring{.cdecl.}
+  Tcpifunc* = proc (a2: cint): cstring{.cdecl.}
+  Tcpcpfunc* = proc (a2: cstring): cstring{.cdecl.}
+  Tcpcppfunc* = proc (a2: cstringArray): cstring{.cdecl.}
diff --git a/lib/wrappers/readline/tweaked/history.h b/lib/wrappers/readline/tweaked/history.h
new file mode 100644
index 000000000..53bd642b1
--- /dev/null
+++ b/lib/wrappers/readline/tweaked/history.h
@@ -0,0 +1,257 @@
+/* history.h -- the names of functions that you can call in history. */
+
+/* Copyright (C) 1989-2009 Free Software Foundation, Inc.
+
+   This file contains the GNU History Library (History), a set of
+   routines for managing the text of previously typed lines.
+
+   History 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 3 of the License, or
+   (at your option) any later version.
+
+   History 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 History.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifdef C2NIM
+#  private historyDll
+#  dynlib historyDll
+#  cdecl
+#  if defined(windows)
+#    define historyDll "history.dll"
+#  elif defined(macosx)
+#    define historyDll "libhistory.dynlib"
+#  else
+#    define historyDll "libhistory.so.6(|.0)"
+#  endif
+#  prefix rl_
+#  prefix RL_
+#  suffix _t
+#  typeprefixes
+#  def PARAMS(x) x
+#  def time_t TTime
+#endif
+
+#  include "times"
+#  include "rltypedefs.h"
+
+typedef void *histdata_t;
+
+/* The structure used to store a history entry. */
+typedef struct _hist_entry {
+  char *line;
+  char *timestamp;		/* char * rather than time_t for read/write */
+  histdata_t data;
+} HIST_ENTRY;
+
+/* Size of the history-library-managed space in history entry HS. */
+#define HISTENT_BYTES(hs)	(strlen(hs.line) + strlen(hs.timestamp))
+
+/* A structure used to pass the current state of the history stuff around. */
+typedef struct _hist_state {
+  HIST_ENTRY **entries;		/* Pointer to the entries themselves. */
+  int offset;			/* The location pointer within this array. */
+  int length;			/* Number of elements within this array. */
+  int size;			/* Number of slots allocated to this array. */
+  int flags;
+} HISTORY_STATE;
+
+/* Flag values for the `flags' member of HISTORY_STATE. */
+#define HS_STIFLED	0x01
+
+/* Initialization and state management. */
+
+/* Begin a session in which the history functions might be used.  This
+   just initializes the interactive variables. */
+extern void using_history PARAMS((void));
+
+/* Return the current HISTORY_STATE of the history. */
+extern HISTORY_STATE *history_get_history_state PARAMS((void));
+
+/* Set the state of the current history array to STATE. */
+extern void history_set_history_state PARAMS((HISTORY_STATE *));
+
+/* Manage the history list. */
+
+/* Place STRING at the end of the history list.
+   The associated data field (if any) is set to NULL. */
+extern void add_history PARAMS((const char *));
+
+/* Change the timestamp associated with the most recent history entry to
+   STRING. */
+extern void add_history_time PARAMS((const char *));
+
+/* A reasonably useless function, only here for completeness.  WHICH
+   is the magic number that tells us which element to delete.  The
+   elements are numbered from 0. */
+extern HIST_ENTRY *remove_history PARAMS((int));
+
+/* Free the history entry H and return any application-specific data
+   associated with it. */
+extern histdata_t free_history_entry PARAMS((HIST_ENTRY *));
+
+/* Make the history entry at WHICH have LINE and DATA.  This returns
+   the old entry so you can dispose of the data.  In the case of an
+   invalid WHICH, a NULL pointer is returned. */
+extern HIST_ENTRY *replace_history_entry PARAMS((int, const char *, histdata_t));
+
+/* Clear the history list and start over. */
+extern void clear_history PARAMS((void));
+
+/* Stifle the history list, remembering only MAX number of entries. */
+extern void stifle_history PARAMS((int));
+
+/* Stop stifling the history.  This returns the previous amount the
+   history was stifled by.  The value is positive if the history was
+   stifled, negative if it wasn't. */
+extern int unstifle_history PARAMS((void));
+
+/* Return 1 if the history is stifled, 0 if it is not. */
+extern int history_is_stifled PARAMS((void));
+
+/* Information about the history list. */
+
+/* Return a NULL terminated array of HIST_ENTRY which is the current input
+   history.  Element 0 of this list is the beginning of time.  If there
+   is no history, return NULL. */
+extern HIST_ENTRY **history_list PARAMS((void));
+
+/* Returns the number which says what history element we are now
+   looking at.  */
+extern int where_history PARAMS((void));
+  
+/* Return the history entry at the current position, as determined by
+   history_offset.  If there is no entry there, return a NULL pointer. */
+extern HIST_ENTRY *current_history PARAMS((void));
+
+/* Return the history entry which is logically at OFFSET in the history
+   array.  OFFSET is relative to history_base. */
+extern HIST_ENTRY *history_get PARAMS((int));
+
+/* Return the timestamp associated with the HIST_ENTRY * passed as an
+   argument */
+extern time_t history_get_time PARAMS((HIST_ENTRY *));
+
+/* Return the number of bytes that the primary history entries are using.
+   This just adds up the lengths of the_history->lines. */
+extern int history_total_bytes PARAMS((void));
+
+/* Moving around the history list. */
+
+/* Set the position in the history list to POS. */
+extern int history_set_pos PARAMS((int));
+
+/* Back up history_offset to the previous history entry, and return
+   a pointer to that entry.  If there is no previous entry, return
+   a NULL pointer. */
+extern HIST_ENTRY *previous_history PARAMS((void));
+
+/* Move history_offset forward to the next item in the input_history,
+   and return the a pointer to that entry.  If there is no next entry,
+   return a NULL pointer. */
+extern HIST_ENTRY *next_history PARAMS((void));
+
+/* Searching the history list. */
+
+/* Search the history for STRING, starting at history_offset.
+   If DIRECTION < 0, then the search is through previous entries,
+   else through subsequent.  If the string is found, then
+   current_history () is the history entry, and the value of this function
+   is the offset in the line of that history entry that the string was
+   found in.  Otherwise, nothing is changed, and a -1 is returned. */
+extern int history_search PARAMS((const char *, int));
+
+/* Search the history for STRING, starting at history_offset.
+   The search is anchored: matching lines must begin with string.
+   DIRECTION is as in history_search(). */
+extern int history_search_prefix PARAMS((const char *, int));
+
+/* Search for STRING in the history list, starting at POS, an
+   absolute index into the list.  DIR, if negative, says to search
+   backwards from POS, else forwards.
+   Returns the absolute index of the history element where STRING
+   was found, or -1 otherwise. */
+extern int history_search_pos PARAMS((const char *, int, int));
+
+/* Managing the history file. */
+
+/* Add the contents of FILENAME to the history list, a line at a time.
+   If FILENAME is NULL, then read from ~/.history.  Returns 0 if
+   successful, or errno if not. */
+extern int read_history PARAMS((const char *));
+
+/* Read a range of lines from FILENAME, adding them to the history list.
+   Start reading at the FROM'th line and end at the TO'th.  If FROM
+   is zero, start at the beginning.  If TO is less than FROM, read
+   until the end of the file.  If FILENAME is NULL, then read from
+   ~/.history.  Returns 0 if successful, or errno if not. */
+extern int read_history_range PARAMS((const char *, int, int));
+
+/* Write the current history to FILENAME.  If FILENAME is NULL,
+   then write the history list to ~/.history.  Values returned
+   are as in read_history ().  */
+extern int write_history PARAMS((const char *));
+
+/* Append NELEMENT entries to FILENAME.  The entries appended are from
+   the end of the list minus NELEMENTs up to the end of the list. */
+extern int append_history PARAMS((int, const char *));
+
+/* Truncate the history file, leaving only the last NLINES lines. */
+extern int history_truncate_file PARAMS((const char *, int));
+
+/* History expansion. */
+
+/* Expand the string STRING, placing the result into OUTPUT, a pointer
+   to a string.  Returns:
+
+   0) If no expansions took place (or, if the only change in
+      the text was the de-slashifying of the history expansion
+      character)
+   1) If expansions did take place
+  -1) If there was an error in expansion.
+   2) If the returned line should just be printed.
+
+  If an error ocurred in expansion, then OUTPUT contains a descriptive
+  error message. */
+extern int history_expand PARAMS((char *, char **));
+
+/* Extract a string segment consisting of the FIRST through LAST
+   arguments present in STRING.  Arguments are broken up as in
+   the shell. */
+extern char *history_arg_extract PARAMS((int, int, const char *));
+
+/* Return the text of the history event beginning at the current
+   offset into STRING.  Pass STRING with *INDEX equal to the
+   history_expansion_char that begins this specification.
+   DELIMITING_QUOTE is a character that is allowed to end the string
+   specification for what to search for in addition to the normal
+   characters `:', ` ', `\t', `\n', and sometimes `?'. */
+extern char *get_history_event PARAMS((const char *, int *, int));
+
+/* Return an array of tokens, much as the shell might.  The tokens are
+   parsed out of STRING. */
+extern char **history_tokenize PARAMS((const char *));
+
+#if false
+/* Exported history variables. */
+extern int history_base;
+extern int history_length;
+extern int history_max_entries;
+extern char history_expansion_char;
+extern char history_subst_char;
+extern char *history_word_delimiters;
+extern char history_comment_char;
+extern char *history_no_expand_chars;
+extern char *history_search_delimiter_chars;
+extern int history_quotes_inhibit_expansion;
+
+extern int history_write_timestamps;
+
+#endif
+
diff --git a/lib/wrappers/readline/tweaked/readline.h b/lib/wrappers/readline/tweaked/readline.h
new file mode 100644
index 000000000..b13fbdbbe
--- /dev/null
+++ b/lib/wrappers/readline/tweaked/readline.h
@@ -0,0 +1,956 @@
+/* Readline.h -- the names of functions callable from within readline. */
+
+/* Copyright (C) 1987-2009 Free Software Foundation, Inc.
+
+   This file is part of the GNU Readline Library (Readline), a library
+   for reading lines of text with interactive input and history editing.      
+
+   Readline 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 3 of the License, or
+   (at your option) any later version.
+
+   Readline 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 Readline.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifdef C2NIM
+#  private readlineDll
+#  dynlib readlineDll
+#  cdecl
+#  if defined(windows)
+#    define readlineDll "readline.dll"
+#  elif defined(macosx)
+#    define readlineDll "libreadline.dynlib"
+#  else
+#    define readlineDll "libreadline.so.6(|.0)"
+#  endif
+#  prefix rl_
+#  prefix RL_
+#  suffix _t
+#  typeprefixes
+#  def PARAMS(x) x
+#  mangle end theEnd
+#  mangle type typ
+#  mangle macro theMacro
+/*#  mangle "'command_func'" TCommandFunc
+#  mangle vcpfunc TvcpFunc*/
+#endif
+
+#  include "rltypedefs.h"
+
+
+/* Some character stuff. */
+#define control_character_threshold 0x020   /* Smaller than this is control. */
+#define control_character_mask 0x1f	    /* 0x20 - 1 */
+#define meta_character_threshold 0x07f	    /* Larger than this is Meta. */
+#define control_character_bit 0x40	    /* 0x000000, must be off. */
+#define meta_character_bit 0x080	    /* x0000000, must be on. */
+#define largest_char 255		    /* Largest character value. */
+
+#define CTRL_CHAR(c) (c < control_character_threshold && ((c & 0x80) == 0))
+#define META_CHAR(c) (c > meta_character_threshold && c <= largest_char)
+
+#define CTRL(c) (c & control_character_mask)
+#define META(c) (c | meta_character_bit)
+
+#define UNMETA(c) (c & ~meta_character_bit)
+#define UNCTRL(c) (c|32|control_character_bit)
+
+/* Beware:  these only work with single-byte ASCII characters. */
+
+#define RETURN_CHAR CTRL('M'.ord)
+#define RUBOUT_CHAR 0x7f
+#define ABORT_CHAR CTRL('G'.ord)
+#define PAGE_CHAR CTRL('L'.ord)
+#define ESC_CHAR CTRL('['.ord)
+
+/* A keymap contains one entry for each key in the ASCII set.
+   Each entry consists of a type and a pointer.
+   FUNCTION is the address of a function to run, or the
+   address of a keymap to indirect through.
+   TYPE says which kind of thing FUNCTION is. */
+typedef struct _keymap_entry {
+  char type;
+  rl_command_func_t *function;
+} KEYMAP_ENTRY;
+
+/* This must be large enough to hold bindings for all of the characters
+   in a desired character set (e.g, 128 for ASCII, 256 for ISO Latin-x,
+   and so on) plus one for subsequence matching. */
+#define KEYMAP_SIZE 257
+#define ANYOTHERKEY KEYMAP_SIZE-1
+
+/* I wanted to make the above structure contain a union of:
+   union { rl_command_func_t *function; struct _keymap_entry *keymap; } value;
+   but this made it impossible for me to create a static array.
+   Maybe I need C lessons. */
+
+typedef KEYMAP_ENTRY KEYMAP_ENTRY_ARRAY[KEYMAP_SIZE];
+typedef KEYMAP_ENTRY *Keymap;
+
+/* The values that TYPE can have in a keymap entry. */
+#define ISFUNC 0
+#define ISKMAP 1
+#define ISMACR 2
+
+#if false
+extern KEYMAP_ENTRY_ARRAY emacs_standard_keymap, emacs_meta_keymap, emacs_ctlx_keymap;
+extern KEYMAP_ENTRY_ARRAY vi_insertion_keymap, vi_movement_keymap;
+#endif
+
+/* Return a new, empty keymap.
+   Free it with free() when you are done. */
+extern Keymap rl_make_bare_keymap PARAMS((void));
+
+/* Return a new keymap which is a copy of MAP. */
+extern Keymap rl_copy_keymap PARAMS((Keymap));
+
+/* Return a new keymap with the printing characters bound to rl_insert,
+   the lowercase Meta characters bound to run their equivalents, and
+   the Meta digits bound to produce numeric arguments. */
+extern Keymap rl_make_keymap PARAMS((void));
+
+/* Free the storage associated with a keymap. */
+extern void rl_discard_keymap PARAMS((Keymap));
+
+/* These functions actually appear in bind.c */
+
+/* Return the keymap corresponding to a given name.  Names look like
+   `emacs' or `emacs-meta' or `vi-insert'.  */
+extern Keymap rl_get_keymap_by_name PARAMS((const char *));
+
+/* Return the current keymap. */
+extern Keymap rl_get_keymap PARAMS((void));
+
+/* Set the current keymap to MAP. */
+extern void rl_set_keymap PARAMS((Keymap));
+
+#  include "tilde.h"
+
+/* Hex-encoded Readline version number. */
+#define RL_READLINE_VERSION	0x0600		/* Readline 6.0 */
+#define RL_VERSION_MAJOR	6
+#define RL_VERSION_MINOR	0
+
+/* Readline data structures. */
+
+/* Maintaining the state of undo.  We remember individual deletes and inserts
+   on a chain of things to do. */
+
+/* The actions that undo knows how to undo.  Notice that UNDO_DELETE means
+   to insert some text, and UNDO_INSERT means to delete some text.   I.e.,
+   the code tells undo what to undo, not how to undo it. */
+enum undo_code { UNDO_DELETE, UNDO_INSERT, UNDO_BEGIN, UNDO_END };
+
+/* What an element of THE_UNDO_LIST looks like. */
+typedef struct undo_list {
+  struct undo_list *next;
+  int start, end;		/* Where the change took place. */
+  char *text;			/* The text to insert, if undoing a delete. */
+  enum undo_code what;		/* Delete, Insert, Begin, End. */
+} UNDO_LIST;
+
+/* The current undo list for RL_LINE_BUFFER. */
+extern UNDO_LIST *rl_undo_list;
+
+/* The data structure for mapping textual names to code addresses. */
+typedef struct _funmap {
+  const char *name;
+  rl_command_func_t *function;
+} FUNMAP;
+
+extern FUNMAP **funmap;
+
+/* **************************************************************** */
+/*								    */
+/*	     Functions available to bind to key sequences	    */
+/*								    */
+/* **************************************************************** */
+
+/* Bindable commands for numeric arguments. */
+extern int rl_digit_argument PARAMS((int, int));
+extern int rl_universal_argument PARAMS((int, int));
+
+/* Bindable commands for moving the cursor. */
+extern int rl_forward_byte PARAMS((int, int));
+extern int rl_forward_char PARAMS((int, int));
+extern int rl_forward PARAMS((int, int));
+extern int rl_backward_byte PARAMS((int, int));
+extern int rl_backward_char PARAMS((int, int));
+extern int rl_backward PARAMS((int, int));
+extern int rl_beg_of_line PARAMS((int, int));
+extern int rl_end_of_line PARAMS((int, int));
+extern int rl_forward_word PARAMS((int, int));
+extern int rl_backward_word PARAMS((int, int));
+extern int rl_refresh_line PARAMS((int, int));
+extern int rl_clear_screen PARAMS((int, int));
+extern int rl_skip_csi_sequence PARAMS((int, int));
+extern int rl_arrow_keys PARAMS((int, int));
+
+/* Bindable commands for inserting and deleting text. */
+extern int rl_insert PARAMS((int, int));
+extern int rl_quoted_insert PARAMS((int, int));
+extern int rl_tab_insert PARAMS((int, int));
+extern int rl_newline PARAMS((int, int));
+extern int rl_do_lowercase_version PARAMS((int, int));
+extern int rl_rubout PARAMS((int, int));
+extern int rl_delete PARAMS((int, int));
+extern int rl_rubout_or_delete PARAMS((int, int));
+extern int rl_delete_horizontal_space PARAMS((int, int));
+extern int rl_delete_or_show_completions PARAMS((int, int));
+extern int rl_insert_comment PARAMS((int, int));
+
+/* Bindable commands for changing case. */
+extern int rl_upcase_word PARAMS((int, int));
+extern int rl_downcase_word PARAMS((int, int));
+extern int rl_capitalize_word PARAMS((int, int));
+
+/* Bindable commands for transposing characters and words. */
+extern int rl_transpose_words PARAMS((int, int));
+extern int rl_transpose_chars PARAMS((int, int));
+
+/* Bindable commands for searching within a line. */
+extern int rl_char_search PARAMS((int, int));
+extern int rl_backward_char_search PARAMS((int, int));
+
+/* Bindable commands for readline's interface to the command history. */
+extern int rl_beginning_of_history PARAMS((int, int));
+extern int rl_end_of_history PARAMS((int, int));
+extern int rl_get_next_history PARAMS((int, int));
+extern int rl_get_previous_history PARAMS((int, int));
+
+/* Bindable commands for managing the mark and region. */
+extern int rl_set_mark PARAMS((int, int));
+extern int rl_exchange_point_and_mark PARAMS((int, int));
+
+/* Bindable commands to set the editing mode (emacs or vi). */
+extern int rl_vi_editing_mode PARAMS((int, int));
+extern int rl_emacs_editing_mode PARAMS((int, int));
+
+/* Bindable commands to change the insert mode (insert or overwrite) */
+extern int rl_overwrite_mode PARAMS((int, int));
+
+/* Bindable commands for managing key bindings. */
+extern int rl_re_read_init_file PARAMS((int, int));
+extern int rl_dump_functions PARAMS((int, int));
+extern int rl_dump_macros PARAMS((int, int));
+extern int rl_dump_variables PARAMS((int, int));
+
+/* Bindable commands for word completion. */
+extern int rl_complete PARAMS((int, int));
+extern int rl_possible_completions PARAMS((int, int));
+extern int rl_insert_completions PARAMS((int, int));
+extern int rl_old_menu_complete PARAMS((int, int));
+extern int rl_menu_complete PARAMS((int, int));
+extern int rl_backward_menu_complete PARAMS((int, int));
+
+/* Bindable commands for killing and yanking text, and managing the kill ring. */
+extern int rl_kill_word PARAMS((int, int));
+extern int rl_backward_kill_word PARAMS((int, int));
+extern int rl_kill_line PARAMS((int, int));
+extern int rl_backward_kill_line PARAMS((int, int));
+extern int rl_kill_full_line PARAMS((int, int));
+extern int rl_unix_word_rubout PARAMS((int, int));
+extern int rl_unix_filename_rubout PARAMS((int, int));
+extern int rl_unix_line_discard PARAMS((int, int));
+extern int rl_copy_region_to_kill PARAMS((int, int));
+extern int rl_kill_region PARAMS((int, int));
+extern int rl_copy_forward_word PARAMS((int, int));
+extern int rl_copy_backward_word PARAMS((int, int));
+extern int rl_yank PARAMS((int, int));
+extern int rl_yank_pop PARAMS((int, int));
+extern int rl_yank_nth_arg PARAMS((int, int));
+extern int rl_yank_last_arg PARAMS((int, int));
+
+#ifdef Windows
+extern int rl_paste_from_clipboard PARAMS((int, int));
+#endif
+
+/* Bindable commands for incremental searching. */
+extern int rl_reverse_search_history PARAMS((int, int));
+extern int rl_forward_search_history PARAMS((int, int));
+
+/* Bindable keyboard macro commands. */
+extern int rl_start_kbd_macro PARAMS((int, int));
+extern int rl_end_kbd_macro PARAMS((int, int));
+extern int rl_call_last_kbd_macro PARAMS((int, int));
+
+/* Bindable undo commands. */
+extern int rl_revert_line PARAMS((int, int));
+extern int rl_undo_command PARAMS((int, int));
+
+/* Bindable tilde expansion commands. */
+extern int rl_tilde_expand PARAMS((int, int));
+
+/* Bindable terminal control commands. */
+extern int rl_restart_output PARAMS((int, int));
+extern int rl_stop_output PARAMS((int, int));
+
+/* Miscellaneous bindable commands. */
+extern int rl_abort PARAMS((int, int));
+extern int rl_tty_status PARAMS((int, int));
+
+/* Bindable commands for incremental and non-incremental history searching. */
+extern int rl_history_search_forward PARAMS((int, int));
+extern int rl_history_search_backward PARAMS((int, int));
+extern int rl_noninc_forward_search PARAMS((int, int));
+extern int rl_noninc_reverse_search PARAMS((int, int));
+extern int rl_noninc_forward_search_again PARAMS((int, int));
+extern int rl_noninc_reverse_search_again PARAMS((int, int));
+
+/* Bindable command used when inserting a matching close character. */
+extern int rl_insert_close PARAMS((int, int));
+
+/* Not available unless READLINE_CALLBACKS is defined. */
+extern void rl_callback_handler_install PARAMS((const char *, rl_vcpfunc_t *));
+extern void rl_callback_read_char PARAMS((void));
+extern void rl_callback_handler_remove PARAMS((void));
+
+/* Things for vi mode. Not available unless readline is compiled -DVI_MODE. */
+/* VI-mode bindable commands. */
+extern int rl_vi_redo PARAMS((int, int));
+extern int rl_vi_undo PARAMS((int, int));
+extern int rl_vi_yank_arg PARAMS((int, int));
+extern int rl_vi_fetch_history PARAMS((int, int));
+extern int rl_vi_search_again PARAMS((int, int));
+extern int rl_vi_search PARAMS((int, int));
+extern int rl_vi_complete PARAMS((int, int));
+extern int rl_vi_tilde_expand PARAMS((int, int));
+extern int rl_vi_prev_word PARAMS((int, int));
+extern int rl_vi_next_word PARAMS((int, int));
+extern int rl_vi_end_word PARAMS((int, int));
+extern int rl_vi_insert_beg PARAMS((int, int));
+extern int rl_vi_append_mode PARAMS((int, int));
+extern int rl_vi_append_eol PARAMS((int, int));
+extern int rl_vi_eof_maybe PARAMS((int, int));
+extern int rl_vi_insertion_mode PARAMS((int, int));
+extern int rl_vi_insert_mode PARAMS((int, int));
+extern int rl_vi_movement_mode PARAMS((int, int));
+extern int rl_vi_arg_digit PARAMS((int, int));
+extern int rl_vi_change_case PARAMS((int, int));
+extern int rl_vi_put PARAMS((int, int));
+extern int rl_vi_column PARAMS((int, int));
+extern int rl_vi_delete_to PARAMS((int, int));
+extern int rl_vi_change_to PARAMS((int, int));
+extern int rl_vi_yank_to PARAMS((int, int));
+extern int rl_vi_rubout PARAMS((int, int));
+extern int rl_vi_delete PARAMS((int, int));
+extern int rl_vi_back_to_indent PARAMS((int, int));
+extern int rl_vi_first_print PARAMS((int, int));
+extern int rl_vi_char_search PARAMS((int, int));
+extern int rl_vi_match PARAMS((int, int));
+extern int rl_vi_change_char PARAMS((int, int));
+extern int rl_vi_subst PARAMS((int, int));
+extern int rl_vi_overstrike PARAMS((int, int));
+extern int rl_vi_overstrike_delete PARAMS((int, int));
+extern int rl_vi_replace PARAMS((int, int));
+extern int rl_vi_set_mark PARAMS((int, int));
+extern int rl_vi_goto_mark PARAMS((int, int));
+
+/* VI-mode utility functions. */
+extern int rl_vi_check PARAMS((void));
+extern int rl_vi_domove PARAMS((int, int *));
+extern int rl_vi_bracktype PARAMS((int));
+
+extern void rl_vi_start_inserting PARAMS((int, int, int));
+
+/* VI-mode pseudo-bindable commands, used as utility functions. */
+extern int rl_vi_fWord PARAMS((int, int));
+extern int rl_vi_bWord PARAMS((int, int));
+extern int rl_vi_eWord PARAMS((int, int));
+extern int rl_vi_fword PARAMS((int, int));
+extern int rl_vi_bword PARAMS((int, int));
+extern int rl_vi_eword PARAMS((int, int));
+
+/* **************************************************************** */
+/*								    */
+/*			Well Published Functions		    */
+/*								    */
+/* **************************************************************** */
+
+/* Readline functions. */
+/* Read a line of input.  Prompt with PROMPT.  A NULL PROMPT means none. */
+extern char *readline PARAMS((const char *));
+
+extern int rl_set_prompt PARAMS((const char *));
+extern int rl_expand_prompt PARAMS((char *));
+
+extern int rl_initialize PARAMS((void));
+
+/* Undocumented; unused by readline */
+extern int rl_discard_argument PARAMS((void));
+
+/* Utility functions to bind keys to readline commands. */
+extern int rl_add_defun PARAMS((const char *, rl_command_func_t *, int));
+extern int rl_bind_key PARAMS((int, rl_command_func_t *));
+extern int rl_bind_key_in_map PARAMS((int, rl_command_func_t *, Keymap));
+extern int rl_unbind_key PARAMS((int));
+extern int rl_unbind_key_in_map PARAMS((int, Keymap));
+extern int rl_bind_key_if_unbound PARAMS((int, rl_command_func_t *));
+extern int rl_bind_key_if_unbound_in_map PARAMS((int, rl_command_func_t *, Keymap));
+extern int rl_unbind_function_in_map PARAMS((rl_command_func_t *, Keymap));
+extern int rl_unbind_command_in_map PARAMS((const char *, Keymap));
+extern int rl_bind_keyseq PARAMS((const char *, rl_command_func_t *));
+extern int rl_bind_keyseq_in_map PARAMS((const char *, rl_command_func_t *, Keymap));
+extern int rl_bind_keyseq_if_unbound PARAMS((const char *, rl_command_func_t *));
+extern int rl_bind_keyseq_if_unbound_in_map PARAMS((const char *, rl_command_func_t *, Keymap));
+extern int rl_generic_bind PARAMS((int, const char *, char *, Keymap));
+
+extern char *rl_variable_value PARAMS((const char *));
+extern int rl_variable_bind PARAMS((const char *, const char *));
+
+/* Backwards compatibility, use rl_bind_keyseq_in_map instead. */
+extern int rl_set_key PARAMS((const char *, rl_command_func_t *, Keymap));
+
+/* Backwards compatibility, use rl_generic_bind instead. */
+extern int rl_macro_bind PARAMS((const char *, const char *, Keymap));
+
+/* Undocumented in the texinfo manual; not really useful to programs. */
+extern int rl_translate_keyseq PARAMS((const char *, char *, int *));
+extern char *rl_untranslate_keyseq PARAMS((int));
+
+extern rl_command_func_t *rl_named_function PARAMS((const char *));
+extern rl_command_func_t *rl_function_of_keyseq PARAMS((const char *, Keymap, int *));
+
+extern void rl_list_funmap_names PARAMS((void));
+extern char **rl_invoking_keyseqs_in_map PARAMS((rl_command_func_t *, Keymap));
+extern char **rl_invoking_keyseqs PARAMS((rl_command_func_t *));
+ 
+extern void rl_function_dumper PARAMS((int));
+extern void rl_macro_dumper PARAMS((int));
+extern void rl_variable_dumper PARAMS((int));
+
+extern int rl_read_init_file PARAMS((const char *));
+extern int rl_parse_and_bind PARAMS((char *));
+
+/* Functions for manipulating keymaps. */
+extern Keymap rl_make_bare_keymap PARAMS((void));
+extern Keymap rl_copy_keymap PARAMS((Keymap));
+extern Keymap rl_make_keymap PARAMS((void));
+extern void rl_discard_keymap PARAMS((Keymap));
+
+extern Keymap rl_get_keymap_by_name PARAMS((const char *));
+extern char *rl_get_keymap_name PARAMS((Keymap));
+extern void rl_set_keymap PARAMS((Keymap));
+extern Keymap rl_get_keymap PARAMS((void));
+/* Undocumented; used internally only. */
+extern void rl_set_keymap_from_edit_mode PARAMS((void));
+extern char *rl_get_keymap_name_from_edit_mode PARAMS((void));
+
+/* Functions for manipulating the funmap, which maps command names to functions. */
+extern int rl_add_funmap_entry PARAMS((const char *, rl_command_func_t *));
+extern const char **rl_funmap_names PARAMS((void));
+/* Undocumented, only used internally -- there is only one funmap, and this
+   function may be called only once. */
+extern void rl_initialize_funmap PARAMS((void));
+
+/* Utility functions for managing keyboard macros. */
+extern void rl_push_macro_input PARAMS((char *));
+
+/* Functions for undoing, from undo.c */
+extern void rl_add_undo PARAMS((enum undo_code, int, int, char *));
+extern void rl_free_undo_list PARAMS((void));
+extern int rl_do_undo PARAMS((void));
+extern int rl_begin_undo_group PARAMS((void));
+extern int rl_end_undo_group PARAMS((void));
+extern int rl_modifying PARAMS((int, int));
+
+/* Functions for redisplay. */
+extern void rl_redisplay PARAMS((void));
+extern int rl_on_new_line PARAMS((void));
+extern int rl_on_new_line_with_prompt PARAMS((void));
+extern int rl_forced_update_display PARAMS((void));
+extern int rl_clear_message PARAMS((void));
+extern int rl_reset_line_state PARAMS((void));
+extern int rl_crlf PARAMS((void));
+
+extern int rl_message (const char *, ...);
+
+extern int rl_show_char PARAMS((int));
+
+/* Undocumented in texinfo manual. */
+extern int rl_character_len PARAMS((int, int));
+
+/* Save and restore internal prompt redisplay information. */
+extern void rl_save_prompt PARAMS((void));
+extern void rl_restore_prompt PARAMS((void));
+
+/* Modifying text. */
+extern void rl_replace_line PARAMS((const char *, int));
+extern int rl_insert_text PARAMS((const char *));
+extern int rl_delete_text PARAMS((int, int));
+extern int rl_kill_text PARAMS((int, int));
+extern char *rl_copy_text PARAMS((int, int));
+
+/* Terminal and tty mode management. */
+extern void rl_prep_terminal PARAMS((int));
+extern void rl_deprep_terminal PARAMS((void));
+extern void rl_tty_set_default_bindings PARAMS((Keymap));
+extern void rl_tty_unset_default_bindings PARAMS((Keymap));
+
+extern int rl_reset_terminal PARAMS((const char *));
+extern void rl_resize_terminal PARAMS((void));
+extern void rl_set_screen_size PARAMS((int, int));
+extern void rl_get_screen_size PARAMS((int *, int *));
+extern void rl_reset_screen_size PARAMS((void));
+
+extern char *rl_get_termcap PARAMS((const char *));
+
+/* Functions for character input. */
+extern int rl_stuff_char PARAMS((int));
+extern int rl_execute_next PARAMS((int));
+extern int rl_clear_pending_input PARAMS((void));
+extern int rl_read_key PARAMS((void));
+extern int rl_getc PARAMS((TFile));
+extern int rl_set_keyboard_input_timeout PARAMS((int));
+
+/* `Public' utility functions . */
+extern void rl_extend_line_buffer PARAMS((int));
+extern int rl_ding PARAMS((void));
+extern int rl_alphabetic PARAMS((int));
+extern void rl_free PARAMS((void *));
+
+/* Readline signal handling, from signals.c */
+extern int rl_set_signals PARAMS((void));
+extern int rl_clear_signals PARAMS((void));
+extern void rl_cleanup_after_signal PARAMS((void));
+extern void rl_reset_after_signal PARAMS((void));
+extern void rl_free_line_state PARAMS((void));
+
+extern void rl_echo_signal_char PARAMS((int)); 
+
+extern int rl_set_paren_blink_timeout PARAMS((int));
+
+/* Undocumented. */
+extern int rl_maybe_save_line PARAMS((void));
+extern int rl_maybe_unsave_line PARAMS((void));
+extern int rl_maybe_replace_line PARAMS((void));
+
+/* Completion functions. */
+extern int rl_complete_internal PARAMS((int));
+extern void rl_display_match_list PARAMS((char **, int, int));
+
+extern char **rl_completion_matches PARAMS((const char *, rl_compentry_func_t *));
+extern char *rl_username_completion_function PARAMS((const char *, int));
+extern char *rl_filename_completion_function PARAMS((const char *, int));
+
+extern int rl_completion_mode PARAMS((rl_command_func_t *));
+
+/* **************************************************************** */
+/*								    */
+/*			Well Published Variables		    */
+/*								    */
+/* **************************************************************** */
+
+#if false
+
+/* The version of this incarnation of the readline library. */
+extern const char *rl_library_version;		/* e.g., "4.2" */
+extern int rl_readline_version;			/* e.g., 0x0402 */
+
+/* True if this is real GNU readline. */
+extern int rl_gnu_readline_p;
+
+/* Flags word encapsulating the current readline state. */
+extern int rl_readline_state;
+
+/* Says which editing mode readline is currently using.  1 means emacs mode;
+   0 means vi mode. */
+extern int rl_editing_mode;
+
+/* Insert or overwrite mode for emacs mode.  1 means insert mode; 0 means
+   overwrite mode.  Reset to insert mode on each input line. */
+extern int rl_insert_mode;
+
+/* The name of the calling program.  You should initialize this to
+   whatever was in argv[0].  It is used when parsing conditionals. */
+extern const char *rl_readline_name;
+
+/* The prompt readline uses.  This is set from the argument to
+   readline (), and should not be assigned to directly. */
+extern char *rl_prompt;
+
+/* The prompt string that is actually displayed by rl_redisplay.  Public so
+   applications can more easily supply their own redisplay functions. */
+extern char *rl_display_prompt;
+
+/* The line buffer that is in use. */
+extern char *rl_line_buffer;
+
+/* The location of point, and end. */
+extern int rl_point;
+extern int rl_end;
+
+/* The mark, or saved cursor position. */
+extern int rl_mark;
+
+/* Flag to indicate that readline has finished with the current input
+   line and should return it. */
+extern int rl_done;
+
+/* If set to a character value, that will be the next keystroke read. */
+extern int rl_pending_input;
+
+/* Non-zero if we called this function from _rl_dispatch().  It's present
+   so functions can find out whether they were called from a key binding
+   or directly from an application. */
+extern int rl_dispatching;
+
+/* Non-zero if the user typed a numeric argument before executing the
+   current function. */
+extern int rl_explicit_arg;
+
+/* The current value of the numeric argument specified by the user. */
+extern int rl_numeric_arg;
+
+/* The address of the last command function Readline executed. */
+extern rl_command_func_t *rl_last_func;
+
+/* The name of the terminal to use. */
+extern const char *rl_terminal_name;
+
+/* The input and output streams. */
+extern FILE *rl_instream;
+extern FILE *rl_outstream;
+
+/* If non-zero, Readline gives values of LINES and COLUMNS from the environment
+   greater precedence than values fetched from the kernel when computing the
+   screen dimensions. */
+extern int rl_prefer_env_winsize;
+
+/* If non-zero, then this is the address of a function to call just
+   before readline_internal () prints the first prompt. */
+extern rl_hook_func_t *rl_startup_hook;
+
+/* If non-zero, this is the address of a function to call just before
+   readline_internal_setup () returns and readline_internal starts
+   reading input characters. */
+extern rl_hook_func_t *rl_pre_input_hook;
+      
+/* The address of a function to call periodically while Readline is
+   awaiting character input, or NULL, for no event handling. */
+extern rl_hook_func_t *rl_event_hook;
+
+/* The address of the function to call to fetch a character from the current
+   Readline input stream */
+extern rl_getc_func_t *rl_getc_function;
+
+extern rl_voidfunc_t *rl_redisplay_function;
+
+extern rl_vintfunc_t *rl_prep_term_function;
+extern rl_voidfunc_t *rl_deprep_term_function;
+
+/* Dispatch variables. */
+extern Keymap rl_executing_keymap;
+extern Keymap rl_binding_keymap;
+
+/* Display variables. */
+/* If non-zero, readline will erase the entire line, including any prompt,
+   if the only thing typed on an otherwise-blank line is something bound to
+   rl_newline. */
+extern int rl_erase_empty_line;
+
+/* If non-zero, the application has already printed the prompt (rl_prompt)
+   before calling readline, so readline should not output it the first time
+   redisplay is done. */
+extern int rl_already_prompted;
+
+/* A non-zero value means to read only this many characters rather than
+   up to a character bound to accept-line. */
+extern int rl_num_chars_to_read;
+
+/* The text of a currently-executing keyboard macro. */
+extern char *rl_executing_macro;
+
+/* Variables to control readline signal handling. */
+/* If non-zero, readline will install its own signal handlers for
+   SIGINT, SIGTERM, SIGQUIT, SIGALRM, SIGTSTP, SIGTTIN, and SIGTTOU. */
+extern int rl_catch_signals;
+
+/* If non-zero, readline will install a signal handler for SIGWINCH
+   that also attempts to call any calling application's SIGWINCH signal
+   handler.  Note that the terminal is not cleaned up before the
+   application's signal handler is called; use rl_cleanup_after_signal()
+   to do that. */
+extern int rl_catch_sigwinch;
+
+/* Completion variables. */
+/* Pointer to the generator function for completion_matches ().
+   NULL means to use rl_filename_completion_function (), the default
+   filename completer. */
+extern rl_compentry_func_t *rl_completion_entry_function;
+
+/* Optional generator for menu completion.  Default is
+   rl_completion_entry_function (rl_filename_completion_function). */
+ extern rl_compentry_func_t *rl_menu_completion_entry_function;
+
+/* If rl_ignore_some_completions_function is non-NULL it is the address
+   of a function to call after all of the possible matches have been
+   generated, but before the actual completion is done to the input line.
+   The function is called with one argument; a NULL terminated array
+   of (char *).  If your function removes any of the elements, they
+   must be free()'ed. */
+extern rl_compignore_func_t *rl_ignore_some_completions_function;
+
+/* Pointer to alternative function to create matches.
+   Function is called with TEXT, START, and END.
+   START and END are indices in RL_LINE_BUFFER saying what the boundaries
+   of TEXT are.
+   If this function exists and returns NULL then call the value of
+   rl_completion_entry_function to try to match, otherwise use the
+   array of strings returned. */
+extern rl_completion_func_t *rl_attempted_completion_function;
+
+/* The basic list of characters that signal a break between words for the
+   completer routine.  The initial contents of this variable is what
+   breaks words in the shell, i.e. "n\"\\'`@$>". */
+extern const char *rl_basic_word_break_characters;
+
+/* The list of characters that signal a break between words for
+   rl_complete_internal.  The default list is the contents of
+   rl_basic_word_break_characters.  */
+extern /*const*/ char *rl_completer_word_break_characters;
+
+/* Hook function to allow an application to set the completion word
+   break characters before readline breaks up the line.  Allows
+   position-dependent word break characters. */
+extern rl_cpvfunc_t *rl_completion_word_break_hook;
+
+/* List of characters which can be used to quote a substring of the line.
+   Completion occurs on the entire substring, and within the substring   
+   rl_completer_word_break_characters are treated as any other character,
+   unless they also appear within this list. */
+extern const char *rl_completer_quote_characters;
+
+/* List of quote characters which cause a word break. */
+extern const char *rl_basic_quote_characters;
+
+/* List of characters that need to be quoted in filenames by the completer. */
+extern const char *rl_filename_quote_characters;
+
+/* List of characters that are word break characters, but should be left
+   in TEXT when it is passed to the completion function.  The shell uses
+   this to help determine what kind of completing to do. */
+extern const char *rl_special_prefixes;
+
+/* If non-zero, then this is the address of a function to call when
+   completing on a directory name.  The function is called with
+   the address of a string (the current directory name) as an arg.  It
+   changes what is displayed when the possible completions are printed
+   or inserted. */
+extern rl_icppfunc_t *rl_directory_completion_hook;
+
+/* If non-zero, this is the address of a function to call when completing
+   a directory name.  This function takes the address of the directory name
+   to be modified as an argument.  Unlike rl_directory_completion_hook, it
+   only modifies the directory name used in opendir(2), not what is displayed
+   when the possible completions are printed or inserted.  It is called
+   before rl_directory_completion_hook.  I'm not happy with how this works
+   yet, so it's undocumented. */
+extern rl_icppfunc_t *rl_directory_rewrite_hook;
+
+/* If non-zero, this is the address of a function to call when reading
+   directory entries from the filesystem for completion and comparing
+   them to the partial word to be completed.  The function should
+   either return its first argument (if no conversion takes place) or
+   newly-allocated memory.  This can, for instance, convert filenames
+   between character sets for comparison against what's typed at the
+   keyboard.  The returned value is what is added to the list of
+   matches.  The second argument is the length of the filename to be
+   converted. */
+extern rl_dequote_func_t *rl_filename_rewrite_hook;
+
+/* If non-zero, then this is the address of a function to call when
+   completing a word would normally display the list of possible matches.
+   This function is called instead of actually doing the display.
+   It takes three arguments: (char **matches, int num_matches, int max_length)
+   where MATCHES is the array of strings that matched, NUM_MATCHES is the
+   number of strings in that array, and MAX_LENGTH is the length of the
+   longest string in that array. */
+extern rl_compdisp_func_t *rl_completion_display_matches_hook;
+
+/* Non-zero means that the results of the matches are to be treated
+   as filenames.  This is ALWAYS zero on entry, and can only be changed
+   within a completion entry finder function. */
+extern int rl_filename_completion_desired;
+
+/* Non-zero means that the results of the matches are to be quoted using
+   double quotes (or an application-specific quoting mechanism) if the
+   filename contains any characters in rl_word_break_chars.  This is
+   ALWAYS non-zero on entry, and can only be changed within a completion
+   entry finder function. */
+extern int rl_filename_quoting_desired;
+
+/* Set to a function to quote a filename in an application-specific fashion.
+   Called with the text to quote, the type of match found (single or multiple)
+   and a pointer to the quoting character to be used, which the function can
+   reset if desired. */
+extern rl_quote_func_t *rl_filename_quoting_function;
+
+/* Function to call to remove quoting characters from a filename.  Called
+   before completion is attempted, so the embedded quotes do not interfere
+   with matching names in the file system. */
+extern rl_dequote_func_t *rl_filename_dequoting_function;
+
+/* Function to call to decide whether or not a word break character is
+   quoted.  If a character is quoted, it does not break words for the
+   completer. */
+extern rl_linebuf_func_t *rl_char_is_quoted_p;
+
+/* Non-zero means to suppress normal filename completion after the
+   user-specified completion function has been called. */
+extern int rl_attempted_completion_over;
+
+/* Set to a character describing the type of completion being attempted by
+   rl_complete_internal; available for use by application completion
+   functions. */
+extern int rl_completion_type;
+
+/* Set to the last key used to invoke one of the completion functions */
+extern int rl_completion_invoking_key;
+
+/* Up to this many items will be displayed in response to a
+   possible-completions call.  After that, we ask the user if she
+   is sure she wants to see them all.  The default value is 100. */
+extern int rl_completion_query_items;
+
+/* Character appended to completed words when at the end of the line.  The
+   default is a space.  Nothing is added if this is '\0'. */
+extern int rl_completion_append_character;
+
+/* If set to non-zero by an application completion function,
+   rl_completion_append_character will not be appended. */
+extern int rl_completion_suppress_append;
+
+/* Set to any quote character readline thinks it finds before any application
+   completion function is called. */
+extern int rl_completion_quote_character;
+
+/* Set to a non-zero value if readline found quoting anywhere in the word to
+   be completed; set before any application completion function is called. */
+extern int rl_completion_found_quote;
+
+/* If non-zero, the completion functions don't append any closing quote.
+   This is set to 0 by rl_complete_internal and may be changed by an
+   application-specific completion function. */
+extern int rl_completion_suppress_quote;
+
+/* If non-zero, readline will sort the completion matches.  On by default. */
+extern int rl_sort_completion_matches;
+
+/* If non-zero, a slash will be appended to completed filenames that are
+   symbolic links to directory names, subject to the value of the
+   mark-directories variable (which is user-settable).  This exists so
+   that application completion functions can override the user's preference
+   (set via the mark-symlinked-directories variable) if appropriate.
+   It's set to the value of _rl_complete_mark_symlink_dirs in
+   rl_complete_internal before any application-specific completion
+   function is called, so without that function doing anything, the user's
+   preferences are honored. */
+extern int rl_completion_mark_symlink_dirs;
+
+/* If non-zero, then disallow duplicates in the matches. */
+extern int rl_ignore_completion_duplicates;
+
+/* If this is non-zero, completion is (temporarily) inhibited, and the
+   completion character will be inserted as any other. */
+extern int rl_inhibit_completion;
+
+#endif
+
+/* Input error; can be returned by (*rl_getc_function) if readline is reading
+   a top-level command (RL_ISSTATE (RL_STATE_READCMD)). */
+#define READERR			(-2)
+
+/* Definitions available for use by readline clients. */
+#define RL_PROMPT_START_IGNORE	'\001'
+#define RL_PROMPT_END_IGNORE	'\002'
+
+/* Possible values for do_replace argument to rl_filename_quoting_function,
+   called by rl_complete_internal. */
+#define NO_MATCH        0
+#define SINGLE_MATCH    1
+#define MULT_MATCH      2
+
+/* Possible state values for rl_readline_state */
+#define RL_STATE_NONE		0x000000		/* no state; before first call */
+
+#define RL_STATE_INITIALIZING	0x000001	/* initializing */
+#define RL_STATE_INITIALIZED	0x000002	/* initialization done */
+#define RL_STATE_TERMPREPPED	0x000004	/* terminal is prepped */
+#define RL_STATE_READCMD	0x000008	/* reading a command key */
+#define RL_STATE_METANEXT	0x000010	/* reading input after ESC */
+#define RL_STATE_DISPATCHING	0x000020	/* dispatching to a command */
+#define RL_STATE_MOREINPUT	0x000040	/* reading more input in a command function */
+#define RL_STATE_ISEARCH	0x000080	/* doing incremental search */
+#define RL_STATE_NSEARCH	0x000100	/* doing non-inc search */
+#define RL_STATE_SEARCH		0x000200	/* doing a history search */
+#define RL_STATE_NUMERICARG	0x000400	/* reading numeric argument */
+#define RL_STATE_MACROINPUT	0x000800	/* getting input from a macro */
+#define RL_STATE_MACRODEF	0x001000	/* defining keyboard macro */
+#define RL_STATE_OVERWRITE	0x002000	/* overwrite mode */
+#define RL_STATE_COMPLETING	0x004000	/* doing completion */
+#define RL_STATE_SIGHANDLER	0x008000	/* in readline sighandler */
+#define RL_STATE_UNDOING	0x010000	/* doing an undo */
+#define RL_STATE_INPUTPENDING	0x020000	/* rl_execute_next called */
+#define RL_STATE_TTYCSAVED	0x040000	/* tty special chars saved */
+#define RL_STATE_CALLBACK	0x080000	/* using the callback interface */
+#define RL_STATE_VIMOTION	0x100000	/* reading vi motion arg */
+#define RL_STATE_MULTIKEY	0x200000	/* reading multiple-key command */
+#define RL_STATE_VICMDONCE	0x400000	/* entered vi command mode at least once */
+#define RL_STATE_REDISPLAYING	0x800000	/* updating terminal display */
+
+#define RL_STATE_DONE		0x1000000	/* done; accepted line */
+
+#define RL_SETSTATE(x)		(rl_readline_state |= (x))
+#define RL_UNSETSTATE(x)	(rl_readline_state &= ~(x))
+#define RL_ISSTATE(x)		(rl_readline_state & (x))
+
+struct readline_state {
+  /* line state */
+  int point;
+  int end;
+  int mark;
+  char *buffer;
+  int buflen;
+  UNDO_LIST *ul;
+  char *prompt;
+
+  /* global state */
+  int rlstate;
+  int done;
+  Keymap kmap;
+
+  /* input state */
+  rl_command_func_t *lastfunc;
+  int insmode;
+  int edmode;
+  int kseqlen;
+  FILE *inf;
+  FILE *outf;
+  int pendingin;
+  char *macro;
+
+  /* signal state */
+  int catchsigs;
+  int catchsigwinch;
+
+  /* search state */
+
+  /* completion state */
+
+  /* options state */
+
+  /* reserved for future expansion, so the struct size doesn't change */
+  char reserved[64];
+};
+
+extern int rl_save_state PARAMS((struct readline_state *));
+extern int rl_restore_state PARAMS((struct readline_state *));
+
diff --git a/lib/wrappers/readline/tweaked/rltypedefs.h b/lib/wrappers/readline/tweaked/rltypedefs.h
new file mode 100644
index 000000000..46bb42567
--- /dev/null
+++ b/lib/wrappers/readline/tweaked/rltypedefs.h
@@ -0,0 +1,78 @@
+/* rltypedefs.h -- Type declarations for readline functions. */
+
+/* Copyright (C) 2000-2009 Free Software Foundation, Inc.
+
+   This file is part of the GNU Readline Library (Readline), a library
+   for reading lines of text with interactive input and history editing.      
+
+   Readline 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 3 of the License, or
+   (at your option) any later version.
+
+   Readline 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 Readline.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifdef C2NIM
+#  cdecl
+#  prefix rl_
+#  prefix RL_
+#  suffix _t
+#  typeprefixes
+#  def PARAMS(x) x
+#endif
+
+typedef int (*Function) ();
+typedef void VFunction ();
+typedef char *CPFunction ();
+typedef char **CPPFunction ();
+
+/* Bindable functions */
+typedef int rl_command_func_t PARAMS((int, int));
+
+/* Typedefs for the completion system */
+typedef char *rl_compentry_func_t PARAMS((const char *, int));
+typedef char **rl_completion_func_t PARAMS((const char *, int, int));
+
+typedef char *rl_quote_func_t PARAMS((char *, int, char *));
+typedef char *rl_dequote_func_t PARAMS((char *, int));
+
+typedef int rl_compignore_func_t PARAMS((char **));
+
+typedef void rl_compdisp_func_t PARAMS((char **, int, int));
+
+/* Type for input and pre-read hook functions like rl_event_hook */
+typedef int rl_hook_func_t PARAMS((void));
+
+/* Input function type */
+typedef int rl_getc_func_t PARAMS((TFile));
+
+/* Generic function that takes a character buffer (which could be the readline
+   line buffer) and an index into it (which could be rl_point) and returns
+   an int. */
+typedef int rl_linebuf_func_t PARAMS((char *, int));
+
+/* `Generic' function pointer typedefs */
+typedef int rl_intfunc_t PARAMS((int));
+typedef int rl_ivoidfunc_t PARAMS((void));
+
+typedef int rl_icpfunc_t PARAMS((char *));
+typedef int rl_icppfunc_t PARAMS((char **));
+
+typedef void rl_voidfunc_t PARAMS((void));
+typedef void rl_vintfunc_t PARAMS((int));
+typedef void rl_vcpfunc_t PARAMS((char *));
+typedef void rl_vcppfunc_t PARAMS((char **));
+
+typedef char *rl_cpvfunc_t PARAMS((void));
+typedef char *rl_cpifunc_t PARAMS((int));
+typedef char *rl_cpcpfunc_t PARAMS((char  *));
+typedef char *rl_cpcppfunc_t PARAMS((char  **));
+
+
diff --git a/lib/wrappers/readline/tweaked/tilde.h b/lib/wrappers/readline/tweaked/tilde.h
new file mode 100644
index 000000000..d91d0418d
--- /dev/null
+++ b/lib/wrappers/readline/tweaked/tilde.h
@@ -0,0 +1,77 @@
+/* tilde.h: Externally available variables and function in libtilde.a. */
+
+/* Copyright (C) 1992-2009 Free Software Foundation, Inc.
+
+   This file contains the Readline Library (Readline), a set of
+   routines for providing Emacs style line input to programs that ask
+   for it.
+
+   Readline 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 3 of the License, or
+   (at your option) any later version.
+
+   Readline 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 Readline.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifdef C2NIM
+#  private tildeDll
+#  dynlib tildeDll
+#  cdecl
+#  if defined(windows)
+#    define tildeDll "tilde.dll"
+#  elif defined(macosx)
+#    define tildeDll "libtilde.dynlib"
+#  else
+#    define tildeDll "libtilde.so.6(|.0)"
+#  endif
+#  prefix tilde_
+#  suffix _t
+#  typeprefixes
+#  def PARAMS(x) x
+#endif
+
+typedef char *tilde_hook_func_t PARAMS((char *));
+
+#if false
+
+/* If non-null, this contains the address of a function that the application
+   wants called before trying the standard tilde expansions.  The function
+   is called with the text sans tilde, and returns a malloc()'ed string
+   which is the expansion, or a NULL pointer if the expansion fails. */
+extern tilde_hook_func_t *tilde_expansion_preexpansion_hook;
+
+/* If non-null, this contains the address of a function to call if the
+   standard meaning for expanding a tilde fails.  The function is called
+   with the text (sans tilde, as in "foo"), and returns a malloc()'ed string
+   which is the expansion, or a NULL pointer if there is no expansion. */
+extern tilde_hook_func_t *tilde_expansion_failure_hook;
+
+/* When non-null, this is a NULL terminated array of strings which
+   are duplicates for a tilde prefix.  Bash uses this to expand
+   `=~' and `:~'. */
+extern char **tilde_additional_prefixes;
+
+/* When non-null, this is a NULL terminated array of strings which match
+   the end of a username, instead of just "/".  Bash sets this to
+   `:' and `=~'. */
+extern char **tilde_additional_suffixes;
+
+/* Return a new string which is the result of tilde expanding STRING. */
+extern char *tilde_expand PARAMS((const char *));
+
+/* Do the work of tilde expansion on FILENAME.  FILENAME starts with a
+   tilde.  If there is no expansion, call tilde_expansion_failure_hook. */
+extern char *tilde_expand_word PARAMS((const char *));
+
+/* Find the portion of the string beginning with ~ that should be expanded. */
+extern char *tilde_find_word PARAMS((const char *, int, int *));
+
+#endif
+
diff --git a/lib/wrappers/tcl.nim b/lib/wrappers/tcl.nim
index f2ecf558d..0134abad7 100755
--- a/lib/wrappers/tcl.nim
+++ b/lib/wrappers/tcl.nim
@@ -377,7 +377,6 @@ type
     result*: cstring # Do not access this directly. Use
                      # Tcl_GetStringResult since result
                      # may be pointing to an object
-                     #
     freeProc*: TFreeProc
     errorLine*: int
 
diff --git a/rod/c2nim/cparse.nim b/rod/c2nim/cparse.nim
index da96de1f4..704e132f0 100755
--- a/rod/c2nim/cparse.nim
+++ b/rod/c2nim/cparse.nim
@@ -1,7 +1,7 @@
 #
 #
 #      c2nim - C to Nimrod source converter
-#        (c) Copyright 2010 Andreas Rumpf
+#        (c) Copyright 2011 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
 #    distribution, for details about the copyright.
@@ -48,6 +48,7 @@ type
     backtrack: seq[ref TToken]
     inTypeDef: int
     scopeCounter: int
+    hasDeadCodeElimPragma: bool
   
   TReplaceTuple* = array[0..1, string]
 
@@ -289,7 +290,7 @@ proc mangleName(s: string, p: TParser): string =
 
 proc isPrivate(s: string, p: TParser): bool = 
   for pattern in items(p.options.privateRules): 
-     if s.match(pattern): return true
+    if s.match(pattern): return true
 
 proc mangledIdent(ident: string, p: TParser): PNode = 
   result = newNodeP(nkIdent, p)
@@ -381,6 +382,7 @@ proc markTypeIdent(p: var TParser, typ: PNode) =
       while t != nil and t.kind in {nkVarTy, nkPtrTy, nkRefTy}: 
         prefix.add('P')
         t = t.sons[0]
+      if prefix.len == 0: prefix.add('T')
     expectIdent(p)
     p.options.toMangle[p.tok.s] = prefix & mangleRules(p.tok.s, p)
   
diff --git a/rod/c2nim/cpp.nim b/rod/c2nim/cpp.nim
index e7c7e86b0..61b91e4de 100755
--- a/rod/c2nim/cpp.nim
+++ b/rod/c2nim/cpp.nim
@@ -1,7 +1,7 @@
 #
 #
 #      c2nim - C to Nimrod source converter
-#        (c) Copyright 2010 Andreas Rumpf
+#        (c) Copyright 2011 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
 #    distribution, for details about the copyright.
@@ -297,6 +297,16 @@ proc parseMangleDir(p: var TParser) =
   getTok(p)
   eatNewLine(p, nil)
 
+proc modulePragmas(p: var TParser): PNode = 
+  if p.options.dynlibSym.len > 0 and not p.hasDeadCodeElimPragma:
+    p.hasDeadCodeElimPragma = true
+    result = newNodeP(nkPragma, p)
+    var e = newNodeP(nkExprColonExpr, p)
+    addSon(e, newIdentNodeP("deadCodeElim", p), newIdentNodeP("on", p))
+    addSon(result, e)
+  else:
+    result = ast.emptyNode
+
 proc parseDir(p: var TParser): PNode = 
   result = ast.emptyNode
   assert(p.tok.xkind in {pxDirective, pxDirectiveParLe})
@@ -317,6 +327,7 @@ proc parseDir(p: var TParser): PNode =
     discard setOption(p.options, key, p.tok.s)
     getTok(p)
     eatNewLine(p, nil)
+    result = modulePragmas(p)
   of "mangle":
     parseMangleDir(p)
   of "def":
diff --git a/rod/commands.nim b/rod/commands.nim
index 2be58e8c8..3ecf8f0e3 100755
--- a/rod/commands.nim
+++ b/rod/commands.nim
@@ -32,13 +32,11 @@ const
 const 
   Usage = """
 Usage:
-  nimrod command [options] inputfile [arguments]
+  nimrod command [options] [projectfile] [arguments]
 Command:
   compile, c                compile project with default code generator (C)
-  compileToC, cc            compile project with C code generator
   doc                       generate the documentation for inputfile
-  rst2html                  converts a reStructuredText file to HTML
-  rst2tex                   converts a reStructuredText file to TeX
+  i                         start Nimrod in interactive mode (limited)
 Arguments:
   arguments are passed to the program being run (if --run option is selected)
 Options:
@@ -67,10 +65,13 @@ Options:
   --advanced                show advanced command line switches
   -h, --help                show this help
 """
-        
+
   AdvancedUsage = """
 Advanced commands:
+  compileToC, cc            compile project with C code generator
   compileToOC, oc           compile project to Objective C code
+  rst2html                  converts a reStructuredText file to HTML
+  rst2tex                   converts a reStructuredText file to TeX
   run                       run the project (with Tiny C backend; buggy!)
   pretty                    pretty print the inputfile
   genDepend                 generate a DOT file containing the
diff --git a/rod/llstream.nim b/rod/llstream.nim
index 2ec13826f..8dfa1e78e 100755
--- a/rod/llstream.nim
+++ b/rod/llstream.nim
@@ -1,17 +1,20 @@
 #
 #
 #           The Nimrod Compiler
-#        (c) Copyright 2009 Andreas Rumpf
+#        (c) Copyright 2011 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
 #    distribution, for details about the copyright.
 #
 
-# Low-level streams for high performance.
+## Low-level streams for high performance.
 
 import 
   strutils
 
+when not defined(windows) and defined(useGnuReadline):
+  import rdstdin
+
 type 
   TLLStreamKind* = enum       # stream encapsulates stdin
     llsNone,                  # null stream: reading and writing has no effect
@@ -19,7 +22,7 @@ type
     llsFile,                  # stream encapsulates a file
     llsStdIn
   TLLStream* = object of TObject
-    kind*: TLLStreamKind      # accessible for low-level access (lexbase uses this)
+    kind*: TLLStreamKind # accessible for low-level access (lexbase uses this)
     f*: tfile
     s*: string
     rd*, wr*: int             # for string streams
@@ -74,24 +77,52 @@ proc LLStreamClose(s: PLLStream) =
     nil
   of llsFile: 
     close(s.f)
-  
+
+when not defined(ReadLineFromStdin): 
+  # fallback implementation:
+  proc ReadLineFromStdin(prompt: string): string = 
+    stdout.write(prompt)
+    result = readLine(stdin)
+
+proc endsWith*(x: string, s: set[char]): bool =
+  var i = x.len-1
+  while i >= 0 and x[i] == ' ': dec(i)
+  if i >= 0 and x[i] in s:
+    result = true
+
+const 
+  LineContinuationOprs = {'+', '-', '*', '/', '\\', '<', '>', '!', '?', '^',
+                          '|', '%', '&', '$', '@', '~', ','}
+  AdditionalLineContinuationOprs = {'#', ':', '='}
+
+proc endsWithOpr*(x: string): bool = 
+  # also used be the standard template filter:
+  result = x.endsWith(LineContinuationOprs)
+
+proc continueLine(line: string, inTripleString: bool): bool {.inline.} =
+  result = inTriplestring or
+      line[0] == ' ' or
+      line.endsWith(LineContinuationOprs+AdditionalLineContinuationOprs)
+
 proc LLreadFromStdin(s: PLLStream, buf: pointer, bufLen: int): int = 
   var 
     line: string
     L: int
+    inTripleString = false
   s.s = ""
   s.rd = 0
   while true: 
-    write(stdout, "Nimrod> ")
-    line = readLine(stdin)
+    line = ReadLineFromStdin(if s.s.len == 0: ">>> " else: "... ")
     L = len(line)
     add(s.s, line)
     add(s.s, "\n")
-    if (L > 0) and (line[L - 1 + 0] == '#'): break
+    if line.contains("\"\"\""):
+      inTripleString = not inTripleString
+    if not continueLine(line, inTripleString): break
   inc(s.lineOffset)
   result = min(bufLen, len(s.s) - s.rd)
   if result > 0: 
-    copyMem(buf, addr(s.s[0 + s.rd]), result)
+    copyMem(buf, addr(s.s[s.rd]), result)
     inc(s.rd, result)
 
 proc LLStreamRead(s: PLLStream, buf: pointer, bufLen: int): int = 
diff --git a/rod/msgs.nim b/rod/msgs.nim
index 0c1ca2137..a34542c8d 100755
--- a/rod/msgs.nim
+++ b/rod/msgs.nim
@@ -45,7 +45,7 @@ type
     errExprXCannotBeCalled, errExprHasNoType, errExprXHasNoType, 
     errCastNotInSafeMode, errExprCannotBeCastedToX, errCommaOrParRiExpected, 
     errCurlyLeOrParLeExpected, errSectionExpected, errRangeExpected, 
-    errAttemptToRedefineX, errMagicOnlyInSystem, errPowerOfTwoExpected, 
+    errMagicOnlyInSystem, errPowerOfTwoExpected, 
     errStringMayNotBeEmpty, errCallConvExpected, errProcOnlyOneCallConv, 
     errSymbolMustBeImported, errExprMustBeBool, errConstExprExpected, 
     errDuplicateCaseLabel, errRangeIsEmpty, errSelectorMustBeOfCertainTypes, 
@@ -134,7 +134,7 @@ const
     errYieldNotAllowedHere: "\'yield\' only allowed in a loop of an iterator", 
     errInvalidNumberOfYieldExpr: "invalid number of \'yield\' expresions", 
     errCannotReturnExpr: "current routine cannot return an expression", 
-    errAttemptToRedefine: "attempt to redefine \'$1\'", 
+    errAttemptToRedefine: "redefinition of \'$1\'", 
     errStmtInvalidAfterReturn: "statement not allowed after \'return\', \'break\' or \'raise\'", 
     errStmtExpected: "statement expected", 
     errInvalidLabel: "\'$1\' is no label", 
@@ -191,7 +191,6 @@ const
     errCurlyLeOrParLeExpected: "\'{\' or \'(\' expected", 
     errSectionExpected: "section (\'type\', \'proc\', etc.) expected", 
     errRangeExpected: "range expected", 
-    errAttemptToRedefineX: "attempt to redefine \'$1\'", 
     errMagicOnlyInSystem: "\'magic\' only allowed in system module", 
     errPowerOfTwoExpected: "power of two expected",
     errStringMayNotBeEmpty: "string literal may not be empty", 
diff --git a/rod/ptmplsyn.nim b/rod/ptmplsyn.nim
index f428c6df8..9699f1c58 100755
--- a/rod/ptmplsyn.nim
+++ b/rod/ptmplsyn.nim
@@ -57,14 +57,7 @@ proc scanPar(p: var TTmplParser, d: int) =
     of '}': dec(p.curly)
     else: nil
     inc(i)
-  
-proc endsWithOpr(p: TTmplParser): bool = 
-  var i = p.x.len-1
-  while i >= 0 and p.x[i] == ' ': dec(i)
-  if i >= 0 and p.x[i] in {'+', '-', '*', '/', '\\', '<', '>', '!', '?', '^',
-                           '|', '%', '&', '$', '@', '~', ','}:
-    result = true
-  
+
 proc withInExpr(p: TTmplParser): bool {.inline.} = 
   result = p.par > 0 or p.bracket > 0 or p.curly > 0
   
@@ -87,7 +80,7 @@ proc parseLine(p: var TTmplParser) =
       inc(j)
     
     scanPar(p, j)
-    p.pendingExprLine = withInExpr(p) or endsWithOpr(p)
+    p.pendingExprLine = withInExpr(p) or llstream.endsWithOpr(p.x)
     case whichKeyword(keyw)
     of wEnd: 
       if p.indent >= 2: 
diff --git a/rod/semexprs.nim b/rod/semexprs.nim
index 3d5e393a5..064df0ded 100755
--- a/rod/semexprs.nim
+++ b/rod/semexprs.nim
@@ -487,15 +487,20 @@ proc semDirectOp(c: PContext, n: PNode, flags: TExprFlags): PNode =
   fixAbstractType(c, result)
   analyseIfAddressTakenInCall(c, result)
 
+proc buildStringify(c: PContext, arg: PNode): PNode = 
+  if arg.typ != nil and skipTypes(arg.typ, abstractInst).kind == tyString:
+    result = arg
+  else:
+    result = newNodeI(nkCall, arg.info)
+    addSon(result, newIdentNode(getIdent"$", arg.info))
+    addSon(result, arg)
+
 proc semEcho(c: PContext, n: PNode): PNode = 
   # this really is a macro
   checkMinSonsLen(n, 1)
   for i in countup(1, sonsLen(n) - 1): 
     var arg = semExprWithType(c, n.sons[i])
-    var call = newNodeI(nkCall, arg.info)
-    addSon(call, newIdentNode(getIdent("$"), n.info))
-    addSon(call, arg)
-    n.sons[i] = semExpr(c, call)
+    n.sons[i] = semExpr(c, buildStringify(c, arg))
   result = n
 
 proc LookUpForDefined(c: PContext, n: PNode, onlyCurrentScope: bool): PSym = 
diff --git a/rod/semstmts.nim b/rod/semstmts.nim
index ad095d4f8..c931c8102 100755
--- a/rod/semstmts.nim
+++ b/rod/semstmts.nim
@@ -7,12 +7,29 @@
 #    distribution, for details about the copyright.
 #
 
-# this module does the semantic checking of statements
+## this module does the semantic checking of statements
+  
+proc buildEchoStmt(c: PContext, n: PNode): PNode = 
+  # we MUST not check 'n' for semantics again here!
+  result = newNodeI(nkCall, n.info)
+  var e = StrTableGet(magicsys.systemModule.Tab, getIdent"echo")
+  if e == nil: GlobalError(n.info, errSystemNeeds, "echo")
+  addSon(result, newSymNode(e))
+  var arg = buildStringify(c, n)
+  # problem is: implicit '$' is not checked for semantics yet. So we give up
+  # and check 'arg' for semantics again:
+  addSon(result, semExpr(c, arg))
 
 proc semExprNoType(c: PContext, n: PNode): PNode =
   result = semExpr(c, n)
   if result.typ != nil and result.typ.kind != tyStmt:
-    localError(n.info, errDiscardValue)
+    if gCmd == cmdInteractive:
+      result = buildEchoStmt(c, result)
+    else:
+      localError(n.info, errDiscardValue)
+
+proc semCommand(c: PContext, n: PNode): PNode =
+  result = semExprNoType(c, n)
 
 proc semWhen(c: PContext, n: PNode): PNode = 
   result = nil
@@ -660,7 +677,7 @@ proc semProcAux(c: PContext, n: PNode, kind: TSymKind,
     if n.sons[pragmasPos].kind != nkEmpty: 
       LocalError(n.sons[pragmasPos].info, errPragmaOnlyInHeaderOfProc)
     if sfForward notin proto.flags: 
-      LocalError(n.info, errAttemptToRedefineX, proto.name.s)
+      LocalError(n.info, errAttemptToRedefine, proto.name.s)
     excl(proto.flags, sfForward)
     closeScope(c.tab)         # close scope with wrong parameter symbols
     openScope(c.tab)          # open scope for old (correct) parameter symbols
@@ -770,9 +787,6 @@ proc evalInclude(c: PContext, n: PNode): PNode =
       GlobalError(n.info, errRecursiveDependencyX, f)
     addSon(result, semStmt(c, gIncludeFile(f)))
     IntSetExcl(c.includedFiles, fileIndex)
-
-proc semCommand(c: PContext, n: PNode): PNode =
-  result = semExprNoType(c, n)
   
 proc SemStmt(c: PContext, n: PNode): PNode = 
   const                       # must be last statements in a block:
@@ -825,7 +839,13 @@ proc SemStmt(c: PContext, n: PNode): PNode =
   of nkIncludeStmt: 
     if not isTopLevel(c): LocalError(n.info, errXOnlyAtModuleScope, "include")
     result = evalInclude(c, n)
-  else: LocalError(n.info, errStmtExpected)
+  else: 
+    # in interactive mode, we embed the expression in an 'echo':
+    if gCmd == cmdInteractive:
+      result = buildEchoStmt(c, semExpr(c, n))
+    else:
+      LocalError(n.info, errStmtExpected)
+      result = ast.emptyNode
   if result == nil: InternalError(n.info, "SemStmt: result = nil")
   incl(result.flags, nfSem)
 
diff --git a/web/news.txt b/web/news.txt
index 68f0fb190..7ba934bd0 100755
--- a/web/news.txt
+++ b/web/news.txt
@@ -28,10 +28,8 @@ Changes affecting backwards compatibility
 
 - Operators starting with ``^`` are now right-associative and have the highest 
   priority.
-- Deprecated ``os.getApplicationFilename``: Use ``os.getAppFilename`` 
-  instead.
-- Deprecated ``os.getApplicationDir``: Use ``os.getAppDir`` 
-  instead.
+- Deprecated ``os.getApplicationFilename``: Use ``os.getAppFilename`` instead.
+- Deprecated ``os.getApplicationDir``: Use ``os.getAppDir`` instead.
 - Changed and documented how generalized string literals work: The syntax
   ``module.re"abc"`` is now supported.
 
@@ -62,6 +60,8 @@ Additions
   the ``--threads:on`` command line switch.
 - Added unary ``<`` for nice looking excluding upper bounds in ranges.
 - Added ``math.floor``.
+- The *interactive mode* (REPL) has been improved and documented for the 
+  first time.
 
 
 2010-10-20 Version 0.8.10 released