@@ -89,8 +89,8 @@ echo "MiNiM v"&version&" - REPL initialized."
   i.eval prelude
   echo "Prelude loaded."
   echo "-> Type 'exit' or 'quit' to exit."
-  if USE_LINENOISE:
-    discard linenoiseSetCompletionCallback completionCallback
+  when USE_LINENOISE:
+    linenoiseSetCompletionCallback completionCallback
   var line: string
   while true:
     line = prompt(": ")

@@ -1,127 +1,89 @@ 
-# linenoise.h -- guerrilla line editing library against the idea that a
-#  line editing lib needs to be 20,000 lines of C code.
+{.compile: "linenoise/liblinenoise.c".}
+{.push importc.}
+type 
+  linenoiseCompletions* = object 
+    len*: csize
+    cvec*: cstringArray
+  linenoiseCompletionCallback* = proc (a: cstring, b: ptr linenoiseCompletions)
+
+const 
+  LN_HIDDEN_NO* = (0)       # Fully visible entry.           
+  LN_HIDDEN_ALL* = (1)      # Fully hidden, no echo at all   
+  LN_HIDDEN_STAR* = (2)     # Hidden entry, echoing *'s back 
+
+{.push cdecl.}
+#
+#  The callback type for tab completion handlers.
 # 
-#  See linenoise.c for more information.
+#typedef void(linenoiseCompletionCallback)(const char *, linenoiseCompletions *);
+#
+#  Sets the current tab completion handler and returns the previous one, or NULL
+#  if no prior one has been set.
 # 
-#  ------------------------------------------------------------------------
+proc linenoiseSetCompletionCallback*(a: linenoiseCompletionCallback);
+#
+#  Adds a copy of the given string to the given completion list. The copy is owned
+#  by the linenoiseCompletions object.
 # 
-#  Copyright (c) 2010, Salvatore Sanfilippo <antirez at gmail dot com>
-#  Copyright (c) 2010, Pieter Noordhuis <pcnoordhuis at gmail dot com>
+proc linenoiseAddCompletion*(a2: ptr linenoiseCompletions; a3: cstring)
+#
+#  Prompts for input using the given string as the input
+#  prompt. Returns when the user has tapped ENTER or (on an empty
+#  line) EOF (Ctrl-D on Unix, Ctrl-Z on Windows). Returns either
+#  a copy of the entered string (for ENTER) or NULL (on EOF).  The
+#  caller owns the returned string and must eventually free() it.
 # 
-#  All rights reserved.
+proc linenoise*(prompt: cstring): cstring
+#
+#  Activates password entry in future calls of linenoise(), i.e. user
+#  input will not be echoed back to the terminal during entry.
 # 
-#  Redistribution and use in source and binary forms, with or without
-#  modification, are permitted provided that the following conditions are
-#  met:
+proc linenoiseSetHidden*(enable: cint)
+#
+#  Activates normal entry in future calls of linenoise(), i.e. user
+#  input will again be echoed back to the terminal during entry.
 # 
-#   *  Redistributions of source code must retain the above copyright
-#      notice, this list of conditions and the following disclaimer.
+proc linenoiseGetHidden*(): cint
+#
+#  Adds a copy of the given line of the command history.
 # 
-#   *  Redistributions in binary form must reproduce the above copyright
-#      notice, this list of conditions and the following disclaimer in the
-#      documentation and/or other materials provided with the distribution.
+proc linenoiseHistoryAdd*(line: cstring): cint
+#
+#  Sets the maximum length of the command history, in lines.
+#  If the history is currently longer, it will be trimmed,
+#  retaining only the most recent entries. If len is 0 or less
+#  then this function does nothing.
 # 
-#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-#  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-#  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-#  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-#  HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-#  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-#  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-#  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-#  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-#  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+proc linenoiseHistorySetMaxLen*(len: cint): cint
+#
+#  Returns the current maximum length of the history, in lines.
 # 
-
-{.compile: "vendor/linenoise/liblinenoise.c".}
-{.push importc.}
-when not(defined(LINENOISE_H)): 
-  const 
-    LINENOISE_H* = true
-  when not(defined(NO_COMPLETION)): 
-    type 
-      linenoiseCompletions* = object 
-        len*: csize
-        cvec*: cstringArray
-      linenoiseCompletionCallback* = proc (a: cstring, b: ptr linenoiseCompletions)
-
-    #
-    #  The callback type for tab completion handlers.
-    # 
-    #typedef void(linenoiseCompletionCallback)(const char *, linenoiseCompletions *);
-    #
-    #  Sets the current tab completion handler and returns the previous one, or NULL
-    #  if no prior one has been set.
-    # 
-    proc linenoiseSetCompletionCallback*(a: linenoiseCompletionCallback): linenoiseCompletions;
-    #
-    #  Adds a copy of the given string to the given completion list. The copy is owned
-    #  by the linenoiseCompletions object.
-    # 
-    proc linenoiseAddCompletion*(a2: ptr linenoiseCompletions; a3: cstring)
-  #
-  #  Prompts for input using the given string as the input
-  #  prompt. Returns when the user has tapped ENTER or (on an empty
-  #  line) EOF (Ctrl-D on Unix, Ctrl-Z on Windows). Returns either
-  #  a copy of the entered string (for ENTER) or NULL (on EOF).  The
-  #  caller owns the returned string and must eventually free() it.
-  # 
-  proc linenoise*(prompt: cstring): cstring
-  #
-  #  Activates password entry in future calls of linenoise(), i.e. user
-  #  input will not be echoed back to the terminal during entry.
-  # 
-  const 
-    LN_HIDDEN_NO* = (0)       # Fully visible entry.           
-    LN_HIDDEN_ALL* = (1)      # Fully hidden, no echo at all   
-    LN_HIDDEN_STAR* = (2)     # Hidden entry, echoing *'s back 
-  proc linenoiseSetHidden*(enable: cint)
-  #
-  #  Activates normal entry in future calls of linenoise(), i.e. user
-  #  input will again be echoed back to the terminal during entry.
-  # 
-  proc linenoiseGetHidden*(): cint
-  #
-  #  Adds a copy of the given line of the command history.
-  # 
-  proc linenoiseHistoryAdd*(line: cstring): cint
-  #
-  #  Sets the maximum length of the command history, in lines.
-  #  If the history is currently longer, it will be trimmed,
-  #  retaining only the most recent entries. If len is 0 or less
-  #  then this function does nothing.
-  # 
-  proc linenoiseHistorySetMaxLen*(len: cint): cint
-  #
-  #  Returns the current maximum length of the history, in lines.
-  # 
-  proc linenoiseHistoryGetMaxLen*(): cint
-  #
-  #  Saves the current contents of the history to the given file.
-  #  Returns 0 on success.
-  # 
-  proc linenoiseHistorySave*(filename: cstring): cint
-  #
-  #  Replaces the current history with the contents
-  #  of the given file.  Returns 0 on success.
-  # 
-  proc linenoiseHistoryLoad*(filename: cstring): cint
-  #
-  #  Frees all history entries, clearing the history.
-  # 
-  proc linenoiseHistoryFree*()
-  #
-  #  Returns a pointer to the list of history entries, writing its
-  #  length to *len if len is not NULL. The memory is owned by linenoise
-  #  and must not be freed.
-  # 
-  proc linenoiseHistory*(len: ptr cint): cstringArray
-  #
-  #  Returns the number of display columns in the current terminal.
-  # 
-  proc linenoiseColumns*(): cint
-  #
-  #  Returns the number of display rows|lines in the current terminal.
-  # 
-  proc linenoiseLines*(): cint
+proc linenoiseHistoryGetMaxLen*(): cint
+#
+#  Saves the current contents of the history to the given file.
+#  Returns 0 on success.
+# 
+proc linenoiseHistorySave*(filename: cstring): cint
+#
+#  Replaces the current history with the contents
+#  of the given file.  Returns 0 on success.
+# 
+proc linenoiseHistoryLoad*(filename: cstring): cint
+#
+#  Frees all history entries, clearing the history.
+# 
+proc linenoiseHistoryFree*()
+#
+#  Returns a pointer to the list of history entries, writing its
+#  length to *len if len is not NULL. The memory is owned by linenoise
+#  and must not be freed.
+# 
+proc linenoiseHistory*(len: ptr cint): cstringArray
+#
+#  Returns the number of display columns in the current terminal.
+# 
+proc linenoiseColumns*(): cint
+#
+#  Returns the number of display rows|lines in the current terminal.
+# 
+proc linenoiseLines*(): cint

@@ -1,13 +1,22 @@ 
-all:  linenoise_example linenoise_utf8_example linenoise_cpp_example
+STD=
+WARN= -Wall -Wno-comment
+OPT= -Os
+
+CFLAGS= $(STD) $(WARN) $(OPT) $(DEBUG) $(CFLAGS)
+LDFLAGS= $(LDFLAGS)
+DEBUG= -g
 
-linenoise_example: linenoise.h linenoise.c example.c
-	$(CC) -Wall -W -Os -g -o $@ linenoise.c example.c
+CC := $(CC) $(R_CFLAGS)
+LD := $(CC) $(R_LDFLAGS)
+
+
+linenoise.o: linenoise.h linenoise.c
 
-linenoise_utf8_example: linenoise.c utf8.c example.c
-	$(CC) -DNO_COMPLETION -DUSE_UTF8 -Wall -W -Os -g -o $@ linenoise.c utf8.c example.c
+linenoise_example: linenoise.o example.o
+	$(LD) -o $@ $^
 
-linenoise_cpp_example: linenoise.h linenoise.c
-	g++ -Wall -W -Os -g -o $@ linenoise.c example.c
+.c.o:
+	$(CC) -c $<
 
 clean:
-	rm -f linenoise_example linenoise_utf8_example linenoise_cpp_example *.o
+	rm -f linenoise_example *.o

@@ -0,0 +1,47 @@ 
+Extracted from MSOpenTech's [Windows port](https://github.com/MSOpenTech/redis) of redis.
+
+# Linenoise
+
+A minimal, zero-config, BSD licensed, readline replacement.
+
+News: linenoise is now part of [Android](http://android.git.kernel.org/?p=platform/system/core.git;a=tree;f=liblinenoise;h=56450eaed7f783760e5e6a5993ef75cde2e29dea;hb=HEAD Android)!
+
+## Can a line editing library be 20k lines of code?
+
+Line editing with some support for history is a really important feature for command line utilities. Instead of retyping almost the same stuff again and again it's just much better to hit the up arrow and edit on syntax errors, or in order to try a slightly different command. But apparently code dealing with terminals is some sort of Black Magic: readline is 30k lines of code, libedit 20k. Is it reasonable to link small utilities to huge libraries just to get a minimal support for line editing?
+
+So what usually happens is either:
+
+ * Large programs with configure scripts disabling line editing if readline is not present in the system, or not supporting it at all since readline is GPL licensed and libedit (the BSD clone) is not as known and available as readline is (Readl world example of this problem: Tclsh).
+ * Smaller programs not using a configure script not supporting line editing at all (A problem we had with Redis-cli for instance).
+ 
+The result is a pollution of binaries without line editing support.
+
+So I spent more or less two hours doing a reality check resulting in this little library: is it *really* needed for a line editing library to be 20k lines of code? Apparently not, it is possibe to get a very small, zero configuration, trivial to embed library, that solves the problem. Smaller programs will just include this, supporing line editing out of the box. Larger programs may use this little library or just checking with configure if readline/libedit is available and resorting to linenoise if not.
+
+## Terminals, in 2010.
+
+Apparently almost every terminal you can happen to use today has some kind of support for VT100 alike escape sequences. So I tried to write a lib using just very basic VT100 features. The resulting library appears to work everywhere I tried to use it.
+
+Since it's so young I guess there are a few bugs, or the lib may not compile or work with some operating system, but it's a matter of a few weeks and eventually we'll get it right, and there will be no excuses for not shipping command line tools without built-in line editing support.
+
+The library is currently less than 400 lines of code. In order to use it in your project just look at the *example.c* file in the source distribution, it is trivial. Linenoise is BSD code, so you can use both in free software and commercial software.
+
+## Tested with...
+
+ * Linux text only console ($TERM = linux)
+ * Linux KDE terminal application ($TERM = xterm)
+ * Linux xterm ($TERM = xterm)
+ * Mac OS X iTerm ($TERM = xterm)
+ * Mac OS X default Terminal.app ($TERM = xterm)
+ * OpenBSD 4.5 through an OSX Terminal.app ($TERM = screen)
+ * IBM AIX 6.1
+ * FreeBSD xterm ($TERM = xterm)
+
+Please test it everywhere you can and report back!
+
+## Let's push this forward!
+
+Please fork it and add something interesting and send me a pull request. What's especially interesting are fixes, new key bindings, completion.
+
+Send feedbacks to antirez at gmail

@@ -1,65 +1,25 @@ 
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 #include "linenoise.h"
 
-#ifndef NO_COMPLETION
+
 void completion(const char *buf, linenoiseCompletions *lc) {
     if (buf[0] == 'h') {
         linenoiseAddCompletion(lc,"hello");
         linenoiseAddCompletion(lc,"hello there");
     }
 }
-#endif
 
-int main(int argc, char *argv[]) {
+int main(void) {
     char *line;
-#ifdef HAVE_MULTILINE
-    /* Note: multiline support has not yet been integrated */
-    char *prgname = argv[0];
 
-    /* Parse options, with --multiline we enable multi line editing. */
-    while(argc > 1) {
-        argc--;
-        argv++;
-        if (!strcmp(*argv,"--multiline")) {
-            linenoiseSetMultiLine(1);
-            printf("Multi-line mode enabled.\n");
-        } else {
-            fprintf(stderr, "Usage: %s [--multiline]\n", prgname);
-            exit(1);
-        }
-    }
-#endif
-
-#ifndef NO_COMPLETION
-    /* Set the completion callback. This will be called every time the
-     * user uses the <tab> key. */
     linenoiseSetCompletionCallback(completion);
-#endif
-
-    /* Load history from file. The history file is just a plain text file
-     * where entries are separated by newlines. */
     linenoiseHistoryLoad("history.txt"); /* Load the history at startup */
-
-    /* Now this is the main loop of the typical linenoise-based application.
-     * The call to linenoise() will block as long as the user types something
-     * and presses enter.
-     *
-     * The typed string is returned as a malloc() allocated string by
-     * linenoise, so the user needs to free() it. */
     while((line = linenoise("hello> ")) != NULL) {
-        /* Do something with the string. */
-        if (line[0] != '\0' && line[0] != '/') {
+        if (line[0] != '\0') {
             printf("echo: '%s'\n", line);
-            linenoiseHistoryAdd(line); /* Add to the history. */
-            linenoiseHistorySave("history.txt"); /* Save the history on disk. */
-        } else if (!strncmp(line,"/historylen",11)) {
-            /* The "/historylen" command will change the history len. */
-            int len = atoi(line+11);
-            linenoiseHistorySetMaxLen(len);
-        } else if (line[0] == '/') {
-            printf("Unreconized command: %s\n", line);
+            linenoiseHistoryAdd(line);
+            linenoiseHistorySave("history.txt"); /* Save every new entry */
         }
         free(line);
     }

@@ -2,9 +2,8 @@ /* linenoise.c -- guerrilla line editing library against the idea that a
  * line editing lib needs to be 20,000 lines of C code.
  *
  * You can find the latest source code at:
- *
- *   http://github.com/msteveb/linenoise
- *   (forked from http://github.com/antirez/linenoise)
+ * 
+ *   http://github.com/antirez/linenoise
  *
  * Does a number of crazy assumptions that happen to be true in 99.9999% of
  * the 2010 UNIX computers around.
@@ -13,21 +12,20 @@ * ------------------------------------------------------------------------
  *
  * Copyright (c) 2010, Salvatore Sanfilippo <antirez at gmail dot com>
  * Copyright (c) 2010, Pieter Noordhuis <pcnoordhuis at gmail dot com>
- * Copyright (c) 2011, Steve Bennett <steveb at workware dot net dot au>
  *
  * All rights reserved.
- *
+ * 
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
- *
+ * 
  *  *  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *
  *  *  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
- *
+ * 
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@@ -39,22 +37,30 @@ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
+ * 
  * ------------------------------------------------------------------------
  *
  * References:
  * - http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
  * - http://www.3waylabs.com/nw/WWW/products/wizcon/vt220.html
  *
+ * Todo list:
+ * - Switch to gets() if $TERM is something we can't support.
+ * - Filter bogus Ctrl+<char> combinations.
+ * - Win32 support
+ *
  * Bloat:
  * - Completion?
+ * - History search like Ctrl+r in readline?
  *
- * Unix/termios
- * ------------
  * List of escape sequences used by this program, we do everything just
- * a few sequences. In order to be so cheap we may have some
+ * with three sequences. In order to be so cheap we may have some
  * flickering effect with some slow terminal, but the lesser sequences
  * the more compatible.
+ *
+ * CHA (Cursor Horizontal Absolute)
+ *    Sequence: ESC [ n G
+ *    Effect: moves cursor to column n
  *
  * EL (Erase Line)
  *    Sequence: ESC [ n K
@@ -66,10 +72,6 @@ * CUF (CUrsor Forward)
  *    Sequence: ESC [ n C
  *    Effect: moves cursor forward of n chars
  *
- * CR (Carriage Return)
- *    Sequence: \r
- *    Effect: moves cursor to column 1
- *
  * The following are used to clear the screen: ESC [ H ESC [ 2 J
  * This is actually composed of two sequences:
  *
@@ -80,163 +82,204 @@ *
  * ED2 (Clear entire screen)
  *    Sequence: ESC [ 2 J
  *    Effect: clear the whole screen
- *
- * == For highlighting control characters, we also use the following two ==
- * SO (enter StandOut)
- *    Sequence: ESC [ 7 m
- *    Effect: Uses some standout mode such as reverse video
- *
- * SE (Standout End)
- *    Sequence: ESC [ 0 m
- *    Effect: Exit standout mode
- *
- * == Only used if TIOCGWINSZ fails ==
- * DSR/CPR (Report cursor position)
- *    Sequence: ESC [ 6 n
- *    Effect: reports current cursor position as ESC [ NNN ; MMM R
- *
- * win32/console
- * -------------
- * If __MINGW32__ is defined, the win32 console API is used.
- * This could probably be made to work for the msvc compiler too.
- * This support based in part on work by Jon Griffiths.
+ * 
  */
 
-#ifdef _WIN32 /* Windows platform, either MinGW or Visual Studio (MSVC) */
-#include <windows.h>
-#include <fcntl.h>
-#define USE_WINCONSOLE
-#ifdef __MINGW32__
-#define HAVE_UNISTD_H
-#else
-/* Microsoft headers don't like old POSIX names */
-#define strdup _strdup
-#define snprintf _snprintf
-#endif
-#else
+#ifndef _WIN32
 #include <termios.h>
+#include <unistd.h>
 #include <sys/ioctl.h>
-#include <sys/poll.h>
-#define USE_TERMIOS
-#define HAVE_UNISTD_H
 #endif
 
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
 #include <stdlib.h>
-#include <stdarg.h>
 #include <stdio.h>
 #include <errno.h>
 #include <string.h>
 #include <stdlib.h>
 #include <sys/types.h>
-
 #include "linenoise.h"
-#include "utf8.h"
 
-#define LINENOISE_DEFAULT_HISTORY_MAX_LEN 100
-#define LINENOISE_MAX_LINE 4096
+#ifdef _WIN32
+#include <windows.h>
+#endif
 
-#define ctrl(C) ((C) - '@')
 
-/* Use -ve numbers here to co-exist with normal unicode chars */
-enum {
-    SPECIAL_NONE,
-    SPECIAL_UP = -20,
-    SPECIAL_DOWN = -21,
-    SPECIAL_LEFT = -22,
-    SPECIAL_RIGHT = -23,
-    SPECIAL_DELETE = -24,
-    SPECIAL_HOME = -25,
-    SPECIAL_END = -26,
-    SPECIAL_INSERT = -27,
-    SPECIAL_PAGE_UP = -28,
-    SPECIAL_PAGE_DOWN = -29
-};
+#define LINENOISE_DEFAULT_HISTORY_MAX_LEN 100
+#define LINENOISE_MAX_LINE 4096
+static char *unsupported_term[] = {"dumb","cons25",NULL};
+static linenoiseCompletionCallback *completionCallback = NULL;
 
+#ifndef _WIN32
+static struct termios orig_termios; /* in order to restore at exit */
+#endif
+static int rawmode = 0; /* for atexit() function to check if restore is needed*/
+static int atexit_registered = 0; /* register atexit just 1 time */
 static int history_max_len = LINENOISE_DEFAULT_HISTORY_MAX_LEN;
 static int history_len = 0;
-static char **history = NULL;
+char **history = NULL;
 
-/* input mode: visible (default), vs. hidden (full, stars) */
-static int is_hidden = LN_HIDDEN_NO;
+static void linenoiseAtExit(void);
+int linenoiseHistoryAdd(const char *line);
 
-/* Structure to contain the status of the current (being edited) line */
-struct current {
-    char *buf;  /* Current buffer. Always null terminated */
-    int bufmax; /* Size of the buffer, including space for the null termination */
-    int len;    /* Number of bytes in 'buf' */
-    int chars;  /* Number of chars in 'buf' (utf-8 chars) */
-    int pos;    /* Cursor position, measured in chars */
-    int cols;   /* Size of the window, in chars */
-    int rows;   /* Screen rows */
-    const char *prompt;
-    char *capture; /* Allocated capture buffer, or NULL for none. Always null terminated */
-#if defined(USE_TERMIOS)
-    int fd;     /* Terminal fd */
-#elif defined(USE_WINCONSOLE)
-    HANDLE outh; /* Console output handle */
-    HANDLE inh; /* Console input handle */
-    int x;      /* Current column during output */
-    int y;      /* Current row */
+#ifdef _WIN32
+#ifndef STDIN_FILENO
+  #define STDIN_FILENO (_fileno(stdin))
 #endif
-};
+
+
+HANDLE hOut;
+HANDLE hIn;
+DWORD consolemode;
+
+static int win32read(char *c) {
+
+    DWORD foo;
+    INPUT_RECORD b;
+    KEY_EVENT_RECORD e;
+
+    while (1) {
+        if (!ReadConsoleInput(hIn, &b, 1, &foo)) return 0;
+        if (!foo) return 0;
+
+        if (b.EventType == KEY_EVENT && b.Event.KeyEvent.bKeyDown) {
+
+            e = b.Event.KeyEvent;
+            *c = b.Event.KeyEvent.uChar.AsciiChar;
+
+            //if (e.dwControlKeyState & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED)) {
+                /* Alt+key ignored */
+            //} else
+            if (e.dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)) {
+
+                /* Ctrl+Key */
+                switch (*c) {
+                    case 'D':
+                        *c = 4;
+                        return 1;
+                    case 'C':
+                        *c = 3;
+                        return 1;
+                    case 'H':
+                        *c = 8;
+                        return 1;
+                    case 'T':
+                        *c = 20;
+                        return 1;
+                    case 'B': /* ctrl-b, left_arrow */
+                        *c = 2;
+                        return 1;
+                    case 'F': /* ctrl-f right_arrow*/
+                        *c = 6;
+                        return 1;
+                    case 'P': /* ctrl-p up_arrow*/
+                        *c = 16;
+                        return 1;
+                    case 'N': /* ctrl-n down_arrow*/
+                        *c = 14;
+                        return 1;
+                    case 'U': /* Ctrl+u, delete the whole line. */
+                        *c = 21;
+                        return 1;
+                    case 'K': /* Ctrl+k, delete from current to end of line. */
+                        *c = 11;
+                        return 1;
+                    case 'A': /* Ctrl+a, go to the start of the line */
+                        *c = 1;
+                        return 1;
+                    case 'E': /* ctrl+e, go to the end of the line */
+                        *c = 5;
+                        return 1;
+                }
 
-static int fd_read(struct current *current);
-static int getWindowSize(struct current *current);
+                /* Other Ctrl+KEYs ignored */
+            } else {
 
-void linenoiseHistoryFree(void) {
-    if (history) {
-        int j;
+                switch (e.wVirtualKeyCode) {
 
-        for (j = 0; j < history_len; j++)
-            free(history[j]);
-        free(history);
-        history = NULL;
-        history_len = 0;
+                    case VK_ESCAPE: /* ignore - send ctrl-c, will return -1 */
+                        *c = 3;
+                        return 1;
+                    case VK_RETURN:  /* enter */
+                        *c = 13;
+                        return 1;
+                    case VK_LEFT:   /* left */
+                        *c = 2;
+                        return 1;
+                    case VK_RIGHT: /* right */
+                        *c = 6;
+                        return 1;
+                    case VK_UP:   /* up */
+                        *c = 16;
+                        return 1;
+                    case VK_DOWN:  /* down */
+                        *c = 14;
+                        return 1;
+                    case VK_HOME:
+                        *c = 1;
+                        return 1;
+                    case VK_END:
+                        *c = 5;
+                        return 1;
+                    case VK_BACK:
+                        *c = 8;
+                        return 1;
+                    case VK_DELETE:
+                        *c = 127;
+                        return 1;
+                    default:
+                        if (*c) return 1;
+                }
+            }
+        }
     }
+
+    return -1; /* Makes compiler happy */
 }
 
-#if defined(USE_TERMIOS)
-static void linenoiseAtExit(void);
-static struct termios orig_termios; /* in order to restore at exit */
-static int rawmode = 0; /* for atexit() function to check if restore is needed*/
-static int atexit_registered = 0; /* register atexit just 1 time */
+#ifdef __STRICT_ANSI__
+char *strdup(const char *s) {
+    size_t l = strlen(s)+1;
+    char *p = malloc(l);
+
+    memcpy(p,s,l);
+    return p;
+}
+#endif /*   __STRICT_ANSI__   */
 
-static const char *unsupported_term[] = {"dumb","cons25",NULL};
+#endif /*   _WIN32    */
 
 static int isUnsupportedTerm(void) {
+#ifndef _WIN32
     char *term = getenv("TERM");
+    int j;
 
-    if (term) {
+    if (term == NULL) return 0;
+    for (j = 0; unsupported_term[j]; j++)
+        if (!strcasecmp(term,unsupported_term[j])) return 1;
+#endif
+    return 0;
+}
+
+static void freeHistory(void) {
+    if (history) {
         int j;
-        for (j = 0; unsupported_term[j]; j++) {
-            if (strcmp(term, unsupported_term[j]) == 0) {
-                return 1;
-            }
-        }
+
+        for (j = 0; j < history_len; j++)
+            free(history[j]);
+        free(history);
     }
-    return 0;
 }
 
-static int enableRawMode(struct current *current) {
+static int enableRawMode(int fd) {
+#ifndef _WIN32
     struct termios raw;
 
-    current->fd = STDIN_FILENO;
-    current->cols = 0;
-
-    if (!isatty(current->fd) || isUnsupportedTerm() ||
-        tcgetattr(current->fd, &orig_termios) == -1) {
-fatal:
-        errno = ENOTTY;
-        return -1;
-    }
-
+    if (!isatty(STDIN_FILENO)) goto fatal;
     if (!atexit_registered) {
         atexit(linenoiseAtExit);
         atexit_registered = 1;
     }
+    if (tcgetattr(fd,&orig_termios) == -1) goto fatal;
 
     raw = orig_termios;  /* modify the original mode */
     /* input modes: no break, no CR to NL, no parity check, no strip char,
@@ -254,892 +297,189 @@ * We want read to return every single byte, without timeout. */
     raw.c_cc[VMIN] = 1; raw.c_cc[VTIME] = 0; /* 1 byte, no timer */
 
     /* put terminal in raw mode after flushing */
-    if (tcsetattr(current->fd,TCSADRAIN,&raw) < 0) {
-        goto fatal;
-    }
+    if (tcsetattr(fd,TCSAFLUSH,&raw) < 0) goto fatal;
     rawmode = 1;
-    return 0;
-}
-
-static void disableRawMode(struct current *current) {
-    /* Don't even check the return value as it's too late. */
-    if (rawmode && tcsetattr(current->fd,TCSADRAIN,&orig_termios) != -1)
-        rawmode = 0;
-}
-
-/* At exit we'll try to fix the terminal to the initial conditions. */
-static void linenoiseAtExit(void) {
-    if (rawmode) {
-        tcsetattr(STDIN_FILENO, TCSADRAIN, &orig_termios);
-    }
-    linenoiseHistoryFree();
-}
-
-/* gcc/glibc insists that we care about the return code of write!
- * Clarification: This means that a void-cast like "(void) (EXPR)"
- * does not work.
- */
-#define IGNORE_RC(EXPR) if (EXPR) {}
-
-/* This is fdprintf() on some systems, but use a different
- * name to avoid conflicts
- */
-static void fd_printf(int fd, const char *format, ...)
-{
-    va_list args;
-    char buf[64];
-    int n;
-
-    va_start(args, format);
-    n = vsnprintf(buf, sizeof(buf), format, args);
-    va_end(args);
-    IGNORE_RC(write(fd, buf, n));
-}
-
-static void clearScreen(struct current *current)
-{
-    fd_printf(current->fd, "\x1b[H\x1b[2J");
-}
-
-static void cursorToLeft(struct current *current)
-{
-    fd_printf(current->fd, "\r");
-}
-
-static int outputChars(struct current *current, const char *buf, int len)
-{
-    return write(current->fd, buf, len);
-}
-
-static void outputControlChar(struct current *current, char ch)
-{
-    fd_printf(current->fd, "\x1b[7m^%c\x1b[0m", ch);
-}
-
-static void eraseEol(struct current *current)
-{
-    fd_printf(current->fd, "\x1b[0K");
-}
-
-static void setCursorPos(struct current *current, int x)
-{
-    fd_printf(current->fd, "\r\x1b[%dC", x);
-}
-
-/**
- * Reads a char from 'fd', waiting at most 'timeout' milliseconds.
- *
- * A timeout of -1 means to wait forever.
- *
- * Returns -1 if no char is received within the time or an error occurs.
- */
-static int fd_read_char(int fd, int timeout)
-{
-    struct pollfd p;
-    unsigned char c;
-
-    p.fd = fd;
-    p.events = POLLIN;
-
-    if (poll(&p, 1, timeout) == 0) {
-        /* timeout */
-        return -1;
-    }
-    if (read(fd, &c, 1) != 1) {
-        return -1;
-    }
-    return c;
-}
-
-/**
- * Reads a complete utf-8 character
- * and returns the unicode value, or -1 on error.
- */
-static int fd_read(struct current *current)
-{
-#ifdef USE_UTF8
-    char buf[4];
-    int n;
-    int i;
-    int c;
-
-    if (read(current->fd, &buf[0], 1) != 1) {
-        return -1;
-    }
-    n = utf8_charlen(buf[0]);
-    if (n < 1 || n > 3) {
-        return -1;
-    }
-    for (i = 1; i < n; i++) {
-        if (read(current->fd, &buf[i], 1) != 1) {
-            return -1;
-        }
-    }
-    buf[n] = 0;
-    /* decode and return the character */
-    utf8_tounicode(buf, &c);
-    return c;
 #else
-    return fd_read_char(current->fd, -1);
-#endif
-}
 
-static int countColorControlChars(const char* prompt)
-{
-    /* ANSI color control sequences have the form:
-     * "\x1b" "[" [0-9;]* "m"
-     * We parse them with a simple state machine.
-     */
-
-    enum {
-        search_esc,
-        expect_bracket,
-        expect_trail
-    } state = search_esc;
-    int len = 0, found = 0;
-    char ch;
-
-    /* XXX: Strictly we should be checking utf8 chars rather than
-     *      bytes in case of the extremely unlikely scenario where
-     *      an ANSI sequence is part of a utf8 sequence.
-     */
-    while ((ch = *prompt++) != 0) {
-        switch (state) {
-        case search_esc:
-            if (ch == '\x1b') {
-                state = expect_bracket;
-            }
-            break;
-        case expect_bracket:
-            if (ch == '[') {
-                state = expect_trail;
-                /* 3 for "\e[ ... m" */
-                len = 3;
-                break;
-            }
-            state = search_esc;
-            break;
-        case expect_trail:
-            if ((ch == ';') || ((ch >= '0' && ch <= '9'))) {
-                /* 0-9, or semicolon */
-                len++;
-                break;
-            }
-            if (ch == 'm') {
-                found += len;
-            }
-            state = search_esc;
-            break;
-        }
-    }
-
-    return found;
-}
-
-/**
- * Stores the current cursor column in '*cols'.
- * Returns 1 if OK, or 0 if failed to determine cursor pos.
- */
-static int queryCursor(int fd, int* cols, int* rows)
-{
-    /* control sequence - report cursor location */
-    fd_printf(fd, "\x1b[6n");
-
-    /* Parse the response: ESC [ rows ; cols R */
-    if (fd_read_char(fd, 100) == 0x1b &&
-        fd_read_char(fd, 100) == '[') {
-
-        int n = 0;
-        while (1) {
-            int ch = fd_read_char(fd, 100);
-            if (ch == ';') {
-                /* Got rows */
-                if (n != 0 && n < 1000) {
-                    *rows = n;
-                }
-		/* Reset accumulator for cols */
-                n = 0;
-            }
-            else if (ch == 'R') {
-                /* Got cols */
-                if (n != 0 && n < 1000) {
-                    *cols = n;
-                }
-                break;
-            }
-            else if (ch >= 0 && ch <= '9') {
-                n = n * 10 + ch - '0';
-            }
-            else {
-                break;
-            }
-        }
-        return 1;
-    }
-
-    return 0;
-}
-
-/**
- * Updates current->cols with the current window size (width),
- * and     current->rows with the current window rows (height)
- */
-static int getWindowSize(struct current *current)
-{
-    struct winsize ws;
-
-    if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0 && ws.ws_col != 0) {
-        current->cols = ws.ws_col;
-        current->rows = ws.ws_row;
-        return 0;
-    }
-
-    /* Failed to query the window size. Perhaps we are on a serial terminal.
-     * Try to query the width by sending the cursor as far to the right
-     * and reading back the cursor position.
-     * Note that this is only done once per call to linenoise rather than
-     * every time the line is refreshed for efficiency reasons.
-     *
-     * In more detail, we:
-     * (a) request current cursor position,
-     * (b) move cursor far right, far down
-     * (c) request cursor position again,
-     * (d) at last move back to the old position.
-     * This gives us the width without messing with the externally
-     * visible cursor position.
-     *
-     * Console codes:
-     * A up
-     * B down
-     * C right
-     * D left
-     *
-     * For portability we are NOT using the control sequences
-     *    ESC [ s
-     *    ESC [ u
-     * to save and restore the cursor position, as many terminal
-     * emulators do not honor them.
-     */
-
-    if (current->cols == 0) {
-        int herec;
-        int herel;
-
-        current->cols = 80;
-	current->rows = 25;
-
-        /* (a) */
-        if (queryCursor (current->fd, &herec, &herel)) {
-            /* (b) */
-            fd_printf(current->fd, "\x1b[999C\x1b[999B");
-
-            /* (c). Note: If (a) succeeded, then (c) should as well.
-             * For paranoia we still check and have a fallback action
-             * for (d) in case of failure..
-             */
-            if (!queryCursor (current->fd, &current->cols, &current->rows)) {
-                /* (d') Unable to get accurate position data, reset
-                 * the cursor to the far left. While this may not
-                 * restore the exact original position it should not
-                 * be too bad. We will have lost the vertical position
-		 * however.
-                 */
-                fd_printf(current->fd, "\r");
-            } else {
-                /* (d) Reset the cursor back to the original location. */
-                if (current->cols > herec) {
-                    fd_printf(current->fd, "\x1b[%dD", current->cols - herec);
-                }
-                if (current->rows > herel) {
-                    fd_printf(current->fd, "\x1b[%dA", current->rows - herel);
-                }
-            }
-        } /* 1st query failed, doing nothing => default 80 */
-    }
+    if (!atexit_registered) {
+        /* Init windows console handles only once */
+        hOut = GetStdHandle(STD_OUTPUT_HANDLE);
+        if (hOut==INVALID_HANDLE_VALUE) goto fatal;
 
-    return 0;
-}
+        if (!GetConsoleMode(hOut, &consolemode)) {
+            CloseHandle(hOut);
+            errno = ENOTTY;
+            return -1;
+        };
 
-/**
- * If escape (27) was received, reads subsequent
- * chars to determine if this is a known special key.
- *
- * Returns SPECIAL_NONE if unrecognised, or -1 if EOF.
- *
- * If no additional char is received within a short time,
- * 27 is returned.
- */
-static int check_special(int fd)
-{
-    int c = fd_read_char(fd, 50);
-    int c2;
-
-    if (c < 0) {
-        return 27;
-    }
-
-    c2 = fd_read_char(fd, 50);
-    if (c2 < 0) {
-        return c2;
-    }
-    if (c == '[' || c == 'O') {
-        /* Potential arrow key */
-        switch (c2) {
-            case 'A':
-                return SPECIAL_UP;
-            case 'B':
-                return SPECIAL_DOWN;
-            case 'C':
-                return SPECIAL_RIGHT;
-            case 'D':
-                return SPECIAL_LEFT;
-            case 'F':
-                return SPECIAL_END;
-            case 'H':
-                return SPECIAL_HOME;
+        hIn = GetStdHandle(STD_INPUT_HANDLE);
+        if (hIn == INVALID_HANDLE_VALUE) {
+            CloseHandle(hOut);
+            errno = ENOTTY;
+            return -1;
         }
-    }
-    if (c == '[' && c2 >= '1' && c2 <= '8') {
-        /* extended escape */
-        c = fd_read_char(fd, 50);
-        if (c == '~') {
-            switch (c2) {
-                case '2':
-                    return SPECIAL_INSERT;
-                case '3':
-                    return SPECIAL_DELETE;
-                case '5':
-                    return SPECIAL_PAGE_UP;
-                case '6':
-                    return SPECIAL_PAGE_DOWN;
-                case '7':
-                    return SPECIAL_HOME;
-                case '8':
-                    return SPECIAL_END;
-            }
-        }
-        while (c != -1 && c != '~') {
-            /* .e.g \e[12~ or '\e[11;2~   discard the complete sequence */
-            c = fd_read_char(fd, 50);
-        }
-    }
 
-    return SPECIAL_NONE;
-}
-#elif defined(USE_WINCONSOLE)
+        GetConsoleMode(hIn, &consolemode);
+        SetConsoleMode(hIn, ENABLE_PROCESSED_INPUT);
 
-static DWORD orig_consolemode = 0;
-
-static int enableRawMode(struct current *current) {
-    DWORD n;
-    INPUT_RECORD irec;
-
-    current->outh = GetStdHandle(STD_OUTPUT_HANDLE);
-    current->inh = GetStdHandle(STD_INPUT_HANDLE);
-
-    if (!PeekConsoleInput(current->inh, &irec, 1, &n)) {
-        return -1;
-    }
-    if (getWindowSize(current) != 0) {
-        return -1;
-    }
-    if (GetConsoleMode(current->inh, &orig_consolemode)) {
-        SetConsoleMode(current->inh, ENABLE_PROCESSED_INPUT);
+        /* Cleanup them at exit */
+        atexit(linenoiseAtExit);
+        atexit_registered = 1;
     }
-    return 0;
-}
 
-static void disableRawMode(struct current *current)
-{
-    SetConsoleMode(current->inh, orig_consolemode);
-}
-
-static void clearScreen(struct current *current)
-{
-    COORD topleft = { 0, 0 };
-    DWORD n;
-
-    FillConsoleOutputCharacter(current->outh, ' ',
-        current->cols * current->rows, topleft, &n);
-    FillConsoleOutputAttribute(current->outh,
-        FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN,
-        current->cols * current->rows, topleft, &n);
-    SetConsoleCursorPosition(current->outh, topleft);
-}
-
-static void cursorToLeft(struct current *current)
-{
-    COORD pos = { 0, (SHORT)current->y };
-    DWORD n;
-
-    FillConsoleOutputAttribute(current->outh,
-        FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN, current->cols, pos, &n);
-    current->x = 0;
-}
-
-static int outputChars(struct current *current, const char *buf, int len)
-{
-    COORD pos = { (SHORT)current->x, (SHORT)current->y };
-    DWORD n;
-
-    WriteConsoleOutputCharacter(current->outh, buf, len, pos, &n);
-    current->x += len;
+    rawmode = 1;
+#endif
     return 0;
-}
 
-static void outputControlChar(struct current *current, char ch)
-{
-    COORD pos = { (SHORT)current->x, (SHORT)current->y };
-    DWORD n;
-
-    FillConsoleOutputAttribute(current->outh, BACKGROUND_INTENSITY, 2, pos, &n);
-    outputChars(current, "^", 1);
-    outputChars(current, &ch, 1);
+fatal:
+    errno = ENOTTY;
+    return -1;
 }
 
-static void eraseEol(struct current *current)
-{
-    COORD pos = { (SHORT)current->x, (SHORT)current->y };
-    DWORD n;
-
-    FillConsoleOutputCharacter(current->outh, ' ', current->cols - current->x, pos, &n);
-}
-
-static void setCursorPos(struct current *current, int x)
-{
-    COORD pos = { (SHORT)x, (SHORT)current->y };
-
-    SetConsoleCursorPosition(current->outh, pos);
-    current->x = x;
-}
-
-static int fd_read(struct current *current)
-{
-    while (1) {
-        INPUT_RECORD irec;
-        DWORD n;
-        if (WaitForSingleObject(current->inh, INFINITE) != WAIT_OBJECT_0) {
-            break;
-        }
-        if (!ReadConsoleInput (current->inh, &irec, 1, &n)) {
-            break;
-        }
-        if (irec.EventType == KEY_EVENT && irec.Event.KeyEvent.bKeyDown) {
-            KEY_EVENT_RECORD *k = &irec.Event.KeyEvent;
-            if (k->dwControlKeyState & ENHANCED_KEY) {
-                switch (k->wVirtualKeyCode) {
-                 case VK_LEFT:
-                    return SPECIAL_LEFT;
-                 case VK_RIGHT:
-                    return SPECIAL_RIGHT;
-                 case VK_UP:
-                    return SPECIAL_UP;
-                 case VK_DOWN:
-                    return SPECIAL_DOWN;
-                 case VK_INSERT:
-                    return SPECIAL_INSERT;
-                 case VK_DELETE:
-                    return SPECIAL_DELETE;
-                 case VK_HOME:
-                    return SPECIAL_HOME;
-                 case VK_END:
-                    return SPECIAL_END;
-                 case VK_PRIOR:
-                    return SPECIAL_PAGE_UP;
-                 case VK_NEXT:
-                    return SPECIAL_PAGE_DOWN;
-                }
-            }
-            /* Note that control characters are already translated in AsciiChar */
-            else if (k->wVirtualKeyCode == VK_CONTROL)
-	        continue;
-            else {
-#ifdef USE_UTF8
-                return k->uChar.UnicodeChar;
+static void disableRawMode(int fd) {
+#ifdef _WIN32
+    rawmode = 0;
 #else
-                return k->uChar.AsciiChar;
+    /* Don't even check the return value as it's too late. */
+    if (rawmode && tcsetattr(fd,TCSAFLUSH,&orig_termios) != -1)
+        rawmode = 0;
 #endif
-            }
-        }
-    }
-    return -1;
 }
 
-static int countColorControlChars(const char* prompt)
-{
-    /* For windows we assume that there are no embedded ansi color
-     * control sequences.
-     */
-    return 0;
-}
-
-static int getWindowSize(struct current *current)
-{
-    CONSOLE_SCREEN_BUFFER_INFO info;
-    if (!GetConsoleScreenBufferInfo(current->outh, &info)) {
-        return -1;
-    }
-    current->cols = info.dwSize.X;
-    current->rows = info.dwSize.Y;
-    if (current->cols <= 0 || current->rows <= 0) {
-        current->cols = 80;
-        current->rows = 25;
-        return -1;
-    }
-    current->y = info.dwCursorPosition.Y;
-    current->x = info.dwCursorPosition.X;
-    return 0;
-}
-#endif
-
-static int utf8_getchars(char *buf, int c)
-{
-#ifdef USE_UTF8
-    return utf8_fromunicode(buf, c);
+/* At exit we'll try to fix the terminal to the initial conditions. */
+static void linenoiseAtExit(void) {
+#ifdef _WIN32
+    SetConsoleMode(hIn, consolemode);
+    CloseHandle(hOut);
+    CloseHandle(hIn);
 #else
-    *buf = c;
-    return 1;
+    disableRawMode(STDIN_FILENO);
 #endif
+    freeHistory();
 }
 
-/**
- * Returns the unicode character at the given offset,
- * or -1 if none.
- */
-static int get_char(struct current *current, int pos)
-{
-    if (pos >= 0 && pos < current->chars) {
-        int c;
-        int i = utf8_index(current->buf, pos);
-        (void)utf8_tounicode(current->buf + i, &c);
-        return c;
-    }
-    return -1;
-}
-
-static void refreshLine(const char *prompt, struct current *current)
-{
-    int plen;
-    int pchars;
-    int backup = 0;
-    int i;
-    const char *buf = current->buf;
-    int chars = current->chars;
-    int pos = current->pos;
-    int b;
-    int ch;
-    int n;
-
-    /* Should intercept SIGWINCH. For now, just get the size every time */
-    getWindowSize(current);
-
-    plen = strlen(prompt);
-    pchars = utf8_strlen(prompt, plen);
-
-    /* Scan the prompt for embedded ansi color control sequences and
-     * discount them as characters/columns.
-     */
-    pchars -= countColorControlChars(prompt);
+static int getColumns(void) {
+#ifdef _WIN32
+    CONSOLE_SCREEN_BUFFER_INFO b;
 
-    /* Account for a line which is too long to fit in the window.
-     * Note that control chars require an extra column
-     */
+    if (!GetConsoleScreenBufferInfo(hOut, &b)) return 80;
+    return b.srWindow.Right - b.srWindow.Left;
+#else
+    struct winsize ws;
 
-    /* How many cols are required to the left of 'pos'?
-     * The prompt, plus one extra for each control char
-     */
-    n = pchars + utf8_strlen(buf, current->len);
-    b = 0;
-    for (i = 0; i < pos; i++) {
-        b += utf8_tounicode(buf + b, &ch);
-        if (ch < ' ') {
-            n++;
-        }
-    }
-
-    /* If too many are needed, strip chars off the front of 'buf'
-     * until it fits. Note that if the current char is a control character,
-     * we need one extra col.
-     */
-    if (current->pos < current->chars && get_char(current, current->pos) < ' ') {
-        n++;
-    }
-
-    while (n >= current->cols && pos > 0) {
-        b = utf8_tounicode(buf, &ch);
-        if (ch < ' ') {
-            n--;
-        }
-        n--;
-        buf += b;
-        pos--;
-        chars--;
-    }
-
-    /* Cursor to left edge, then the prompt */
-    cursorToLeft(current);
-    outputChars(current, prompt, plen);
-
-    /* Now the current buffer content, but only if not fully hidden */
-
-    if (is_hidden != LN_HIDDEN_ALL) {
-        /* Need special handling for control characters.
-	 * If we hit 'cols', stop.
-	 */
-        b = 0; /* unwritted bytes */
-	n = 0; /* How many control chars were written */
-	for (i = 0; i < chars; i++) {
-	    int ch;
-	    int w = utf8_tounicode(buf + b, &ch);
-	    if (!is_hidden && ch < ' ') {
-	        n++;
-	    }
-	    if (pchars + i + n >= current->cols) {
-	        break;
-	    }
-	    if (is_hidden == LN_HIDDEN_STAR) {
-	        /* In hidden/star mode all user-entered characters are
-		 * shown as astericks ('*'). This is like control chars,
-		 * except for a different translation. */
-	        /* assert (b == 0) */
-	        outputChars(current, "*", 1);
-		buf += w;
-		/* keep b = 0; */
-	    }
-	    else if (ch < ' ') {
-	        /* A control character, so write the buffer so far */
-	        outputChars(current, buf, b);
-		buf += b + w;
-		b = 0;
-		outputControlChar(current, ch + '@');
-		if (i < pos) {
-		    backup++;
-		}
-	    }
-	    else {
-	        b += w;
-	    }
-	}
-
-	/* if (is_hidden) assert (b==0) */
-	outputChars(current, buf, b);
-
-	/* Erase to right, move cursor to original position */
-	eraseEol(current);
-	setCursorPos(current, pos + pchars + backup);
-    }
-}
-
-static void set_current(struct current *current, const char *str)
-{
-    strncpy(current->buf, str, current->bufmax);
-    current->buf[current->bufmax - 1] = 0;
-    current->len = strlen(current->buf);
-    current->pos = current->chars = utf8_strlen(current->buf, current->len);
-}
-
-static int has_room(struct current *current, int bytes)
-{
-    return current->len + bytes < current->bufmax - 1;
-}
-
-/**
- * Removes the char at 'pos'.
- *
- * Returns 1 if the line needs to be refreshed, 2 if not
- * and 0 if nothing was removed
- */
-static int remove_char(struct current *current, int pos)
-{
-    if (pos >= 0 && pos < current->chars) {
-        int p1, p2;
-        int ret = 1;
-        p1 = utf8_index(current->buf, pos);
-        p2 = p1 + utf8_index(current->buf + p1, 1);
-
-#ifdef USE_TERMIOS
-        /* optimise remove char in the case of removing the last char */
-        if (current->pos == pos + 1 && current->pos == current->chars) {
-            if (current->buf[pos] >= ' ' && utf8_strlen(current->prompt, -1) + utf8_strlen(current->buf, current->len) < current->cols - 1) {
-                ret = 2;
-                fd_printf(current->fd, "\b \b");
-            }
-        }
+    if (ioctl(1, TIOCGWINSZ, &ws) == -1) return 80;
+    return ws.ws_col;
 #endif
-
-        /* Move the null char too */
-        memmove(current->buf + p1, current->buf + p2, current->len - p2 + 1);
-        current->len -= (p2 - p1);
-        current->chars--;
-
-        if (current->pos > pos) {
-            current->pos--;
-        }
-        return ret;
-    }
-    return 0;
 }
 
-/**
- * Insert 'ch' at position 'pos'
- *
- * Returns 1 if the line needs to be refreshed, 2 if not
- * and 0 if nothing was inserted (no room)
- */
-static int insert_char(struct current *current, int pos, int ch)
-{
-    char buf[3];
-    int n = utf8_getchars(buf, ch);
-
-    if (has_room(current, n) && pos >= 0 && pos <= current->chars) {
-        int p1, p2;
-        int ret = 1;
-        p1 = utf8_index(current->buf, pos);
-        p2 = p1 + n;
-
-#ifdef USE_TERMIOS
-        /* optimise the case where adding a single char to the end and no scrolling is needed */
-        if (!is_hidden && current->pos == pos && current->chars == pos) {
-            if (ch >= ' ' && utf8_strlen(current->prompt, -1) + utf8_strlen(current->buf, current->len) < current->cols - 1) {
-                IGNORE_RC(write(current->fd, buf, n));
-                ret = 2;
-            }
-        }
+static void refreshLine(int fd, const char *prompt, char *buf, size_t len, size_t pos, size_t cols) {
+    char seq[64];
+#ifdef _WIN32
+    DWORD pl, bl, w;
+    CONSOLE_SCREEN_BUFFER_INFO b;
+    COORD coord;
 #endif
-
-        memmove(current->buf + p2, current->buf + p1, current->len - p1);
-        memcpy(current->buf + p1, buf, n);
-        current->len += n;
-
-        current->chars++;
-        if (current->pos >= pos) {
-            current->pos++;
-        }
-        return ret;
+    size_t plen = strlen(prompt);
+    
+    while((plen+pos) >= cols) {
+        buf++;
+        len--;
+        pos--;
     }
-    return 0;
-}
-
-/**
- * Captures up to 'n' characters starting at 'pos' for the cut buffer.
- *
- * This replaces any existing characters in the cut buffer.
- */
-static void capture_chars(struct current *current, int pos, int n)
-{
-    if (pos >= 0 && (pos + n - 1) < current->chars) {
-        int p1 = utf8_index(current->buf, pos);
-        int nbytes = utf8_index(current->buf + p1, n);
-
-        if (nbytes) {
-            free(current->capture);
-            /* Include space for the null terminator */
-            current->capture = (char *)malloc(nbytes + 1);
-            memcpy(current->capture, current->buf + p1, nbytes);
-            current->capture[nbytes] = '\0';
-        }
+    while (plen+len > cols) {
+        len--;
     }
-}
 
-/**
- * Removes up to 'n' characters at cursor position 'pos'.
- *
- * Returns 0 if no chars were removed or non-zero otherwise.
- */
-static int remove_chars(struct current *current, int pos, int n)
-{
-    int removed = 0;
-
-    /* First save any chars which will be removed */
-    capture_chars(current, pos, n);
-
-    while (n-- && remove_char(current, pos)) {
-        removed++;
-    }
-    return removed;
-}
-/**
- * Inserts the characters (string) 'chars' at the cursor position 'pos'.
- *
- * Returns 0 if no chars were inserted or non-zero otherwise.
- */
-static int insert_chars(struct current *current, int pos, const char *chars)
-{
-    int inserted = 0;
+#ifndef _WIN32
+    /* Cursor to left edge */
+    snprintf(seq,64,"\x1b[0G");
+    if (write(fd,seq,strlen(seq)) == -1) return;
+    /* Write the prompt and the current buffer content */
+    if (write(fd,prompt,strlen(prompt)) == -1) return;
+    if (write(fd,buf,len) == -1) return;
+    /* Erase to right */
+    snprintf(seq,64,"\x1b[0K");
+    if (write(fd,seq,strlen(seq)) == -1) return;
+    /* Move cursor to original position. */
+    snprintf(seq,64,"\x1b[0G\x1b[%dC", (int)(pos+plen));
+    if (write(fd,seq,strlen(seq)) == -1) return;
+#else
 
-    while (*chars) {
-        int ch;
-        int n = utf8_tounicode(chars, &ch);
-        if (insert_char(current, pos, ch) == 0) {
-            break;
-        }
-        inserted++;
-        pos++;
-        chars += n;
-    }
-    return inserted;
+    /* Get buffer console info */
+    if (!GetConsoleScreenBufferInfo(hOut, &b)) return;
+    /* Erase Line */
+    coord.X = 0;
+    coord.Y = b.dwCursorPosition.Y;
+    FillConsoleOutputCharacterA(hOut, ' ', b.dwSize.X, coord, &w);
+    /*  Cursor to the left edge */
+    SetConsoleCursorPosition(hOut, coord);
+    /* Write the prompt and the current buffer content */
+    WriteConsole(hOut, prompt, (DWORD)plen, &pl, NULL);
+    WriteConsole(hOut, buf, (DWORD)len, &bl, NULL);
+    /* Move cursor to original position. */
+    coord.X = (int)(pos+plen);
+    coord.Y = b.dwCursorPosition.Y;
+    SetConsoleCursorPosition(hOut, coord);
+#endif
 }
 
-#ifndef NO_COMPLETION
-static linenoiseCompletionCallback *completionCallback = NULL;
-
 static void beep() {
-#ifdef USE_TERMIOS
     fprintf(stderr, "\x7");
     fflush(stderr);
-#endif
 }
 
 static void freeCompletions(linenoiseCompletions *lc) {
     size_t i;
     for (i = 0; i < lc->len; i++)
         free(lc->cvec[i]);
-    free(lc->cvec);
+    if (lc->cvec != NULL)
+        free(lc->cvec);
 }
 
-static int completeLine(struct current *current) {
+static int completeLine(int fd, const char *prompt, char *buf, size_t buflen, size_t *len, size_t *pos, size_t cols) {
     linenoiseCompletions lc = { 0, NULL };
-    int c = 0;
+    int nread, nwritten;
+    char c = 0;
 
-    completionCallback(current->buf,&lc);
+    completionCallback(buf,&lc);
     if (lc.len == 0) {
         beep();
     } else {
         size_t stop = 0, i = 0;
+        size_t clen;
 
         while(!stop) {
             /* Show completion or original buffer */
             if (i < lc.len) {
-                struct current tmp = *current;
-                tmp.buf = lc.cvec[i];
-                tmp.pos = tmp.len = strlen(tmp.buf);
-                tmp.chars = utf8_strlen(tmp.buf, tmp.len);
-                refreshLine(current->prompt, &tmp);
+                clen = strlen(lc.cvec[i]);
+                refreshLine(fd,prompt,lc.cvec[i],clen,clen,cols);
             } else {
-                refreshLine(current->prompt, current);
+                refreshLine(fd,prompt,buf,*len,*pos,cols);
             }
 
-            c = fd_read(current);
-            if (c == -1) {
-                break;
+            nread = read(fd,&c,1);
+            if (nread <= 0) {
+                freeCompletions(&lc);
+                return -1;
             }
 
             switch(c) {
-                case '\t': /* tab */
+                case 9: /* tab */
                     i = (i+1) % (lc.len+1);
                     if (i == lc.len) beep();
                     break;
                 case 27: /* escape */
                     /* Re-show original buffer */
                     if (i < lc.len) {
-                        refreshLine(current->prompt, current);
+                        refreshLine(fd,prompt,buf,*len,*pos,cols);
                     }
                     stop = 1;
                     break;
                 default:
                     /* Update buffer and return */
                     if (i < lc.len) {
-                        set_current(current,lc.cvec[i]);
+                        nwritten = snprintf(buf,buflen,"%s",lc.cvec[i]);
+                        *len = *pos = nwritten;
                     }
                     stop = 1;
                     break;
@@ -1151,397 +491,296 @@ freeCompletions(&lc);
     return c; /* Return last read character */
 }
 
-/* Register a callback function to be called for tab-completion.
-   Returns the prior callback so that the caller may (if needed)
-   restore it when done. */
-linenoiseCompletionCallback * linenoiseSetCompletionCallback(linenoiseCompletionCallback *fn) {
-    linenoiseCompletionCallback * old = completionCallback;
-    completionCallback = fn;
-    return old;
+void linenoiseClearScreen(void) {
+    if (write(STDIN_FILENO,"\x1b[H\x1b[2J",7) <= 0) {
+        /* nothing to do, just to avoid warning. */
+    }
 }
 
-void linenoiseAddCompletion(linenoiseCompletions *lc, const char *str) {
-    lc->cvec = (char **)realloc(lc->cvec,sizeof(char*)*(lc->len+1));
-    lc->cvec[lc->len++] = strdup(str);
-}
-
+static int linenoisePrompt(int fd, char *buf, size_t buflen, const char *prompt) {
+    size_t plen = strlen(prompt);
+    size_t pos = 0;
+    size_t len = 0;
+    size_t cols = getColumns();
+    int history_index = 0;
+    size_t old_pos;
+    size_t diff;
+#ifdef _WIN32
+    DWORD foo;
 #endif
 
-static int linenoiseEdit(struct current *current) {
-    int history_index = 0;
+    buf[0] = '\0';
+    buflen--; /* Make sure there is always space for the nulterm */
 
     /* The latest history entry is always our current buffer, that
      * initially is just an empty string. */
     linenoiseHistoryAdd("");
-
-    set_current(current, "");
-    refreshLine(current->prompt, current);
-
+    
+#ifdef _WIN32
+    if (!WriteConsole(hOut, prompt, (DWORD)plen, &foo, NULL)) return -1;
+#else
+    if (write(fd,prompt,plen) == -1) return -1;
+#endif
     while(1) {
-        int dir = -1;
-        int c = fd_read(current);
+        char c;
+        int nread;
+        char seq[2], seq2[2];
+
+#ifdef _WIN32
+        nread = win32read(&c);
+#else
+        nread = read(fd,&c,1);
+#endif
+        if (nread <= 0) return (int)len;
 
-#ifndef NO_COMPLETION
-        /* Completion is forbidden for hidden input mode.
-         * Only autocomplete when the callback is set. It returns < 0 when
+        /* Only autocomplete when the callback is set. It returns < 0 when
          * there was an error reading from fd. Otherwise it will return the
          * character that should be handled next. */
-        if (c == '\t' &&
-            !is_hidden &&
-            current->pos == current->chars &&
-            completionCallback != NULL) {
-            c = completeLine(current);
+        if (c == 9 && completionCallback != NULL) {
+            c = completeLine(fd,prompt,buf,buflen,&len,&pos,cols);
             /* Return on errors */
-            if (c < 0) return current->len;
+            if (c < 0) return (int)len;
             /* Read next character when 0 */
             if (c == 0) continue;
         }
-#endif
 
-process_char:
-        if (c == -1) return current->len;
-#ifdef USE_TERMIOS
-        if (c == 27) {   /* escape sequence */
-            c = check_special(current->fd);
-        }
-#endif
         switch(c) {
-        case '\r':    /* enter */
+        case 13:    /* enter */
             history_len--;
             free(history[history_len]);
-            return current->len;
-        case ctrl('C'):     /* ctrl-c */
+            return (int)len;
+        case 3:     /* ctrl-c */
             errno = EAGAIN;
             return -1;
         case 127:   /* backspace */
-        case ctrl('H'):
-            if (remove_char(current, current->pos - 1) == 1) {
-                refreshLine(current->prompt, current);
+#ifdef _WIN32
+            /* delete in _WIN32*/
+            /* win32read() will send 127 for DEL and 8 for BS and Ctrl-H */
+            if (pos < len && len > 0) {
+                memmove(buf+pos,buf+pos+1,len-pos);
+                len--;
+                buf[len] = '\0';
+                refreshLine(fd,prompt,buf,len,pos,cols);
+            }
+            break;
+#endif
+        case 8:     /* ctrl-h */
+            if (pos > 0 && len > 0) {
+                memmove(buf+pos-1,buf+pos,len-pos);
+                pos--;
+                len--;
+                buf[len] = '\0';
+                refreshLine(fd,prompt,buf,len,pos,cols);
             }
             break;
-        case ctrl('D'):     /* ctrl-d */
-            if (current->len == 0) {
-                /* Empty line, so EOF */
+        case 4:     /* ctrl-d, remove char at right of cursor */
+            if (len > 1 && pos < (len-1)) {
+                memmove(buf+pos,buf+pos+1,len-pos);
+                len--;
+                buf[len] = '\0';
+                refreshLine(fd,prompt,buf,len,pos,cols);
+            } else if (len == 0) {
                 history_len--;
                 free(history[history_len]);
                 return -1;
             }
-            /* Otherwise fall through to delete char to right of cursor */
-        case SPECIAL_DELETE:
-            if (remove_char(current, current->pos) == 1) {
-                refreshLine(current->prompt, current);
+            break;
+        case 20:    /* ctrl-t */
+            if (pos > 0 && pos < len) {
+                int aux = buf[pos-1];
+                buf[pos-1] = buf[pos];
+                buf[pos] = aux;
+                if (pos != len-1) pos++;
+                refreshLine(fd,prompt,buf,len,pos,cols);
             }
             break;
-        case SPECIAL_INSERT:
-            /* Ignore. Expansion Hook.
-             * Future possibility: Toggle Insert/Overwrite Modes
-             */
+        case 2:     /* ctrl-b */
+            goto left_arrow;
+        case 6:     /* ctrl-f */
+            goto right_arrow;
+        case 16:    /* ctrl-p */
+            seq[1] = 65;
+            goto up_down_arrow;
+        case 14:    /* ctrl-n */
+            seq[1] = 66;
+            goto up_down_arrow;
             break;
-        case ctrl('W'):    /* ctrl-w, delete word at left. save deleted chars */
-            /* eat any spaces on the left */
-            {
-                int pos = current->pos;
-                while (pos > 0 && get_char(current, pos - 1) == ' ') {
-                    pos--;
-                }
-
-                /* now eat any non-spaces on the left */
-                while (pos > 0 && get_char(current, pos - 1) != ' ') {
+        case 27:    /* escape sequence */
+            if (read(fd,seq,2) == -1) break;
+            if (seq[0] == 91 && seq[1] == 68) {
+left_arrow:
+                /* left arrow */
+                if (pos > 0) {
                     pos--;
+                    refreshLine(fd,prompt,buf,len,pos,cols);
                 }
-
-                if (remove_chars(current, pos, current->pos - pos)) {
-                    refreshLine(current->prompt, current);
+            } else if (seq[0] == 91 && seq[1] == 67) {
+right_arrow:
+                /* right arrow */
+                if (pos != len) {
+                    pos++;
+                    refreshLine(fd,prompt,buf,len,pos,cols);
                 }
-            }
-            break;
-        case ctrl('R'):    /* ctrl-r */
-            /* Hidden input mode disables use of the history */
-            if (!is_hidden) {
-                /* Display the reverse-i-search prompt and process chars */
-                char rbuf[50];
-                char rprompt[80];
-                int rchars = 0;
-                int rlen = 0;
-                int searchpos = history_len - 1;
-
-                rbuf[0] = 0;
-                while (1) {
-                    int n = 0;
-                    const char *p = NULL;
-                    int skipsame = 0;
-                    int searchdir = -1;
-
-                    snprintf(rprompt, sizeof(rprompt), "(reverse-i-search)'%s': ", rbuf);
-                    refreshLine(rprompt, current);
-                    c = fd_read(current);
-                    if (c == ctrl('H') || c == 127) {
-                        if (rchars) {
-                            int p = utf8_index(rbuf, --rchars);
-                            rbuf[p] = 0;
-                            rlen = strlen(rbuf);
-                        }
-                        continue;
-                    }
-#ifdef USE_TERMIOS
-                    if (c == 27) {
-                        c = check_special(current->fd);
-                    }
-#endif
-                    if (c == ctrl('P') || c == SPECIAL_UP) {
-                        /* Search for the previous (earlier) match */
-                        if (searchpos > 0) {
-                            searchpos--;
-                        }
-                        skipsame = 1;
-                    }
-                    else if (c == ctrl('N') || c == SPECIAL_DOWN) {
-                        /* Search for the next (later) match */
-                        if (searchpos < history_len) {
-                            searchpos++;
-                        }
-                        searchdir = 1;
-                        skipsame = 1;
-                    }
-                    else if (c >= ' ') {
-                        if (rlen >= (int)sizeof(rbuf) + 3) {
-                            continue;
-                        }
-
-                        n = utf8_getchars(rbuf + rlen, c);
-                        rlen += n;
-                        rchars++;
-                        rbuf[rlen] = 0;
-
-                        /* Adding a new char resets the search location */
-                        searchpos = history_len - 1;
-                    }
-                    else {
-                        /* Exit from incremental search mode */
+            } else if (seq[0] == 91 && (seq[1] == 65 || seq[1] == 66)) {
+up_down_arrow:
+                /* up and down arrow: history */
+                if (history_len > 1) {
+                    /* Update the current history entry before to
+                     * overwrite it with tne next one. */
+                    free(history[history_len-1-history_index]);
+                    history[history_len-1-history_index] = strdup(buf);
+                    /* Show the new entry */
+                    history_index += (seq[1] == 65) ? 1 : -1;
+                    if (history_index < 0) {
+                        history_index = 0;
+                        break;
+                    } else if (history_index >= history_len) {
+                        history_index = history_len-1;
                         break;
                     }
-
-                    /* Now search through the history for a match */
-                    for (; searchpos >= 0 && searchpos < history_len; searchpos += searchdir) {
-                        p = strstr(history[searchpos], rbuf);
-                        if (p) {
-                            /* Found a match */
-                            if (skipsame && strcmp(history[searchpos], current->buf) == 0) {
-                                /* But it is identical, so skip it */
-                                continue;
-                            }
-                            /* Copy the matching line and set the cursor position */
-                            set_current(current,history[searchpos]);
-                            current->pos = utf8_strlen(history[searchpos], p - history[searchpos]);
-                            break;
-                        }
-                    }
-                    if (!p && n) {
-                        /* No match, so don't add it */
-                        rchars--;
-                        rlen -= n;
-                        rbuf[rlen] = 0;
-                    }
-                }
-                if (c == ctrl('G') || c == ctrl('C')) {
-                    /* ctrl-g terminates the search with no effect */
-                    set_current(current, "");
-                    c = 0;
+                    strncpy(buf,history[history_len-1-history_index],buflen);
+                    buf[buflen] = '\0';
+                    len = pos = strlen(buf);
+                    refreshLine(fd,prompt,buf,len,pos,cols);
                 }
-                else if (c == ctrl('J')) {
-                    /* ctrl-j terminates the search leaving the buffer in place */
-                    c = 0;
+            } else if (seq[0] == 91 && seq[1] > 48 && seq[1] < 55) {
+                /* extended escape */
+                if (read(fd,seq2,2) == -1) break;
+                if (seq[1] == 51 && seq2[0] == 126) {
+                    /* delete */
+                    if (len > 0 && pos < len) {
+                        memmove(buf+pos,buf+pos+1,len-pos-1);
+                        len--;
+                        buf[len] = '\0';
+                        refreshLine(fd,prompt,buf,len,pos,cols);
+                    }
                 }
-                /* Go process the char normally */
-                refreshLine(current->prompt, current);
-                goto process_char;
             }
             break;
-        case ctrl('T'):    /* ctrl-t */
-            if (current->pos > 0 && current->pos <= current->chars) {
-                /* If cursor is at end, transpose the previous two chars */
-                int fixer = (current->pos == current->chars);
-                c = get_char(current, current->pos - fixer);
-                remove_char(current, current->pos - fixer);
-                insert_char(current, current->pos - 1, c);
-                refreshLine(current->prompt, current);
-            }
-            break;
-        case ctrl('V'):    /* ctrl-v */
-            if (has_room(current, 3)) {
-                /* Insert the ^V first */
-                if (insert_char(current, current->pos, c)) {
-                    refreshLine(current->prompt, current);
-                    /* Now wait for the next char. Can insert anything except \0 */
-                    c = fd_read(current);
-
-                    /* Remove the ^V first */
-                    remove_char(current, current->pos - 1);
-                    if (c != -1) {
-                        /* Insert the actual char */
-                        insert_char(current, current->pos, c);
+        default:
+            if (len < buflen) {
+                if (len == pos) {
+                    buf[pos] = c;
+                    pos++;
+                    len++;
+                    buf[len] = '\0';
+                    if (plen+len < cols) {
+                        /* Avoid a full update of the line in the
+                         * trivial case. */
+#ifdef _WIN32
+                        if (!WriteConsole(hOut, &c, 1, &foo, NULL)) return -1;
+#else
+                        if (write(fd,&c,1) == -1) return -1;
+#endif
+                    } else {
+                        refreshLine(fd,prompt,buf,len,pos,cols);
                     }
-                    refreshLine(current->prompt, current);
+                } else {
+                    memmove(buf+pos+1,buf+pos,len-pos);
+                    buf[pos] = c;
+                    len++;
+                    pos++;
+                    buf[len] = '\0';
+                    refreshLine(fd,prompt,buf,len,pos,cols);
                 }
             }
             break;
-        case ctrl('B'):
-        case SPECIAL_LEFT:
-            if (current->pos > 0) {
-                current->pos--;
-                refreshLine(current->prompt, current);
-            }
+        case 21: /* Ctrl+u, delete the whole line. */
+            buf[0] = '\0';
+            pos = len = 0;
+            refreshLine(fd,prompt,buf,len,pos,cols);
             break;
-        case ctrl('F'):
-        case SPECIAL_RIGHT:
-            if (current->pos < current->chars) {
-                current->pos++;
-                refreshLine(current->prompt, current);
-            }
+        case 11: /* Ctrl+k, delete from current to end of line. */
+            buf[pos] = '\0';
+            len = pos;
+            refreshLine(fd,prompt,buf,len,pos,cols);
             break;
-        case SPECIAL_PAGE_UP:
-          dir = history_len - history_index - 1; /* move to start of history */
-          goto history_navigation;
-        case SPECIAL_PAGE_DOWN:
-          dir = -history_index; /* move to 0 == end of history, i.e. current */
-          goto history_navigation;
-        case ctrl('P'):
-        case SPECIAL_UP:
-            dir = 1;
-          goto history_navigation;
-        case ctrl('N'):
-        case SPECIAL_DOWN:
-history_navigation:
-            /* Hidden input mode disables use of the history */
-            if (!is_hidden && history_len > 1) {
-                /* Update the current history entry before to
-                 * overwrite it with tne next one. */
-                free(history[history_len - 1 - history_index]);
-                history[history_len - 1 - history_index] = strdup(current->buf);
-                /* Show the new entry */
-                history_index += dir;
-                if (history_index < 0) {
-                    history_index = 0;
-                    break;
-                } else if (history_index >= history_len) {
-                    history_index = history_len - 1;
-                    break;
-                }
-                set_current(current, history[history_len - 1 - history_index]);
-                refreshLine(current->prompt, current);
-            }
+        case 1: /* Ctrl+a, go to the start of the line */
+            pos = 0;
+            refreshLine(fd,prompt,buf,len,pos,cols);
             break;
-        case ctrl('A'): /* Ctrl+a, go to the start of the line */
-        case SPECIAL_HOME:
-            current->pos = 0;
-            refreshLine(current->prompt, current);
+        case 5: /* ctrl+e, go to the end of the line */
+            pos = len;
+            refreshLine(fd,prompt,buf,len,pos,cols);
             break;
-        case ctrl('E'): /* ctrl+e, go to the end of the line */
-        case SPECIAL_END:
-            current->pos = current->chars;
-            refreshLine(current->prompt, current);
+        case 12: /* ctrl+l, clear screen */
+            linenoiseClearScreen();
+            refreshLine(fd,prompt,buf,len,pos,cols);
             break;
-        case ctrl('U'): /* Ctrl+u, delete to beginning of line, save deleted chars. */
-            if (remove_chars(current, 0, current->pos)) {
-                refreshLine(current->prompt, current);
-            }
-            break;
-        case ctrl('K'): /* Ctrl+k, delete from current to end of line, save deleted chars. */
-            if (remove_chars(current, current->pos, current->chars - current->pos)) {
-                refreshLine(current->prompt, current);
-            }
-            break;
-        case ctrl('Y'): /* Ctrl+y, insert saved chars at current position */
-            if (current->capture && insert_chars(current, current->pos, current->capture)) {
-                refreshLine(current->prompt, current);
-            }
-            break;
-        case ctrl('L'): /* Ctrl+L, clear screen */
-            clearScreen(current);
-            /* Force recalc of window size for serial terminals */
-            current->cols = 0;
-            refreshLine(current->prompt, current);
-            break;
-        default:
-            /* Only tab is allowed without ^V */
-            if (c == '\t' || c >= ' ') {
-                if (insert_char(current, current->pos, c) == 1) {
-                    refreshLine(current->prompt, current);
-                }
-            }
+        case 23: /* ctrl+w, delete previous word */
+            old_pos = pos;
+            while (pos > 0 && buf[pos-1] == ' ')
+                pos--;
+            while (pos > 0 && buf[pos-1] != ' ')
+                pos--;
+            diff = old_pos - pos;
+            memmove(&buf[pos], &buf[old_pos], len-old_pos+1);
+            len -= diff;
+            refreshLine(fd,prompt,buf,len,pos,cols);
             break;
         }
     }
-    return current->len;
+    return (int)len;
 }
 
-int linenoiseColumns(void)
-{
-    struct current current;
-    enableRawMode (&current);
-    getWindowSize (&current);
-    disableRawMode (&current);
-    return current.cols;
-}
-
-int linenoiseLines(void)
-{
-    struct current current;
-    enableRawMode (&current);
-    getWindowSize (&current);
-    disableRawMode (&current);
-    return current.rows;
-}
-
-char *linenoise(const char *prompt)
-{
+static int linenoiseRaw(char *buf, size_t buflen, const char *prompt) {
+    int fd = STDIN_FILENO;
     int count;
-    struct current current;
-    char buf[LINENOISE_MAX_LINE];
 
-    if (enableRawMode(&current) == -1) {
-        printf("%s", prompt);
-        fflush(stdout);
-        if (fgets(buf, sizeof(buf), stdin) == NULL) {
-            return NULL;
-        }
-        count = strlen(buf);
+    if (buflen == 0) {
+        errno = EINVAL;
+        return -1;
+    }
+    if (!isatty(STDIN_FILENO)) {
+        if (fgets(buf, (int)buflen, stdin) == NULL) return -1;
+        count = (int)strlen(buf);
         if (count && buf[count-1] == '\n') {
             count--;
             buf[count] = '\0';
         }
+    } else {
+        if (enableRawMode(fd) == -1) return -1;
+        count = linenoisePrompt(fd, buf, buflen, prompt);
+        disableRawMode(fd);
+        printf("\n");
     }
-    else
-    {
-        current.buf = buf;
-        current.bufmax = sizeof(buf);
-        current.len = 0;
-        current.chars = 0;
-        current.pos = 0;
-        current.prompt = prompt;
-        current.capture = NULL;
+    return count;
+}
 
-        count = linenoiseEdit(&current);
+char *linenoise(const char *prompt) {
+    char buf[LINENOISE_MAX_LINE];
+    int count;
 
-        disableRawMode(&current);
-        printf("\n");
+    if (isUnsupportedTerm()) {
+        size_t len;
 
-        free(current.capture);
-        if (count == -1) {
-            return NULL;
+        printf("%s",prompt);
+        fflush(stdout);
+        if (fgets(buf,LINENOISE_MAX_LINE,stdin) == NULL) return NULL;
+        len = strlen(buf);
+        while(len && (buf[len-1] == '\n' || buf[len-1] == '\r')) {
+            len--;
+            buf[len] = '\0';
         }
+        return strdup(buf);
+    } else {
+        count = linenoiseRaw(buf,LINENOISE_MAX_LINE,prompt);
+        if (count == -1) return NULL;
+        return strdup(buf);
     }
-    return strdup(buf);
 }
 
-void linenoiseSetHidden(int enable)
-{
-    is_hidden = enable;
+/* Register a callback function to be called for tab-completion. */
+void linenoiseSetCompletionCallback(linenoiseCompletionCallback *fn) {
+    completionCallback = fn;
 }
 
-int linenoiseGetHidden(void)
-{
-    return is_hidden;
+void linenoiseAddCompletion(linenoiseCompletions *lc, char *str) {
+    size_t len = strlen(str);
+    char *copy = malloc(len+1);
+    memcpy(copy,str,len+1);
+    lc->cvec = realloc(lc->cvec,sizeof(char*)*(lc->len+1));
+    lc->cvec[lc->len++] = copy;
 }
 
 /* Using a circular buffer is smarter, but a bit more complex to handle. */
@@ -1550,16 +789,10 @@ char *linecopy;
 
     if (history_max_len == 0) return 0;
     if (history == NULL) {
-        history = (char **)malloc(sizeof(char*)*history_max_len);
+        history = malloc(sizeof(char*)*history_max_len);
         if (history == NULL) return 0;
         memset(history,0,(sizeof(char*)*history_max_len));
     }
-
-    /* do not insert duplicate lines into history */
-    if (history_len > 0 && strcmp(line, history[history_len - 1]) == 0) {
-        return 0;
-    }
-
     linecopy = strdup(line);
     if (!linecopy) return 0;
     if (history_len == history_max_len) {
@@ -1572,31 +805,19 @@ history_len++;
     return 1;
 }
 
-int linenoiseHistoryGetMaxLen(void) {
-    return history_max_len;
-}
-
 int linenoiseHistorySetMaxLen(int len) {
-    char **newHistory;
+    char **new;
 
     if (len < 1) return 0;
     if (history) {
         int tocopy = history_len;
 
-        newHistory = (char **)malloc(sizeof(char*)*len);
-        if (newHistory == NULL) return 0;
-
-        /* If we can't copy everything, free the elements we'll not use. */
-        if (len < tocopy) {
-            int j;
-
-            for (j = 0; j < tocopy-len; j++) free(history[j]);
-            tocopy = len;
-        }
-        memset(newHistory,0,sizeof(char*)*len);
-        memcpy(newHistory,history+(history_len-tocopy), sizeof(char*)*tocopy);
+        new = malloc(sizeof(char*)*len);
+        if (new == NULL) return 0;
+        if (len < tocopy) tocopy = len;
+        memcpy(new,history+(history_max_len-tocopy), sizeof(char*)*tocopy);
         free(history);
-        history = newHistory;
+        history = new;
     }
     history_max_len = len;
     if (history_len > history_max_len)
@@ -1606,32 +827,17 @@ }
 
 /* Save the history in the specified file. On success 0 is returned
  * otherwise -1 is returned. */
-int linenoiseHistorySave(const char *filename) {
+int linenoiseHistorySave(char *filename) {
+#ifdef _WIN32
+    FILE *fp = fopen(filename,"wb");
+#else
     FILE *fp = fopen(filename,"w");
+#endif
     int j;
-
+    
     if (fp == NULL) return -1;
-    for (j = 0; j < history_len; j++) {
-        const char *str = history[j];
-        /* Need to encode backslash, nl and cr */
-        while (*str) {
-            if (*str == '\\') {
-                fputs("\\\\", fp);
-            }
-            else if (*str == '\n') {
-                fputs("\\n", fp);
-            }
-            else if (*str == '\r') {
-                fputs("\\r", fp);
-            }
-            else {
-                fputc(*str, fp);
-            }
-            str++;
-        }
-        fputc('\n', fp);
-    }
-
+    for (j = 0; j < history_len; j++)
+        fprintf(fp,"%s\n",history[j]);
     fclose(fp);
     return 0;
 }
@@ -1641,51 +847,20 @@ * zero is returned and no operation is performed.
  *
  * If the file exists and the operation succeeded 0 is returned, otherwise
  * on error -1 is returned. */
-int linenoiseHistoryLoad(const char *filename) {
+int linenoiseHistoryLoad(char *filename) {
     FILE *fp = fopen(filename,"r");
     char buf[LINENOISE_MAX_LINE];
-
+    
     if (fp == NULL) return -1;
 
     while (fgets(buf,LINENOISE_MAX_LINE,fp) != NULL) {
-        char *src, *dest;
-
-        /* Decode backslash escaped values */
-        for (src = dest = buf; *src; src++) {
-            char ch = *src;
-
-            if (ch == '\\') {
-                src++;
-                if (*src == 'n') {
-                    ch = '\n';
-                }
-                else if (*src == 'r') {
-                    ch = '\r';
-                } else {
-                    ch = *src;
-                }
-            }
-            *dest++ = ch;
-        }
-        /* Remove trailing newline */
-        if (dest != buf && (dest[-1] == '\n' || dest[-1] == '\r')) {
-            dest--;
-        }
-        *dest = 0;
-
+        char *p;
+        
+        p = strchr(buf,'\r');
+        if (!p) p = strchr(buf,'\n');
+        if (p) *p = '\0';
         linenoiseHistoryAdd(buf);
     }
     fclose(fp);
     return 0;
 }
-
-/* Provide access to the history buffer.
- *
- * If 'len' is not NULL, the length is stored in *len.
- */
-char **linenoiseHistory(int *len) {
-    if (len) {
-        *len = history_len;
-    }
-    return history;
-}

@@ -3,138 +3,53 @@ * line editing lib needs to be 20,000 lines of C code.
  *
  * See linenoise.c for more information.
  *
- * ------------------------------------------------------------------------
- *
  * Copyright (c) 2010, Salvatore Sanfilippo <antirez at gmail dot com>
  * Copyright (c) 2010, Pieter Noordhuis <pcnoordhuis at gmail dot com>
  *
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * modification, are permitted provided that the following conditions are met:
  *
- *  *  Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- *
- *  *  Redistributions in binary form must reproduce the above copyright
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
  *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef __LINENOISE_H
 #define __LINENOISE_H
 
-#ifndef NO_COMPLETION
 typedef struct linenoiseCompletions {
   size_t len;
   char **cvec;
 } linenoiseCompletions;
 
-/*
- * The callback type for tab completion handlers.
- */
 typedef void(linenoiseCompletionCallback)(const char *, linenoiseCompletions *);
-
-/*
- * Sets the current tab completion handler and returns the previous one, or NULL
- * if no prior one has been set.
- */
-linenoiseCompletionCallback * linenoiseSetCompletionCallback(linenoiseCompletionCallback *);
+void linenoiseSetCompletionCallback(linenoiseCompletionCallback *);
+void linenoiseAddCompletion(linenoiseCompletions *, char *);
 
-/*
- * Adds a copy of the given string to the given completion list. The copy is owned
- * by the linenoiseCompletions object.
- */
-void linenoiseAddCompletion(linenoiseCompletions *, const char *);
-#endif
-
-/*
- * Prompts for input using the given string as the input
- * prompt. Returns when the user has tapped ENTER or (on an empty
- * line) EOF (Ctrl-D on Unix, Ctrl-Z on Windows). Returns either
- * a copy of the entered string (for ENTER) or NULL (on EOF).  The
- * caller owns the returned string and must eventually free() it.
- */
 char *linenoise(const char *prompt);
-
-/*
- * Activates password entry in future calls of linenoise(), i.e. user
- * input will not be echoed back to the terminal during entry.
- */
-#define LN_HIDDEN_NO   (0) /* Fully visible entry.           */
-#define LN_HIDDEN_ALL  (1) /* Fully hidden, no echo at all   */
-#define LN_HIDDEN_STAR (2) /* Hidden entry, echoing *'s back */
-void linenoiseSetHidden(int enable);
-
-/*
- * Activates normal entry in future calls of linenoise(), i.e. user
- * input will again be echoed back to the terminal during entry.
- */
-int linenoiseGetHidden(void);
-
-/*
- * Adds a copy of the given line of the command history.
- */
 int linenoiseHistoryAdd(const char *line);
-
-/*
- * Sets the maximum length of the command history, in lines.
- * If the history is currently longer, it will be trimmed,
- * retaining only the most recent entries. If len is 0 or less
- * then this function does nothing.
- */
 int linenoiseHistorySetMaxLen(int len);
-
-/*
- * Returns the current maximum length of the history, in lines.
- */
-int linenoiseHistoryGetMaxLen(void);
-
-/*
- * Saves the current contents of the history to the given file.
- * Returns 0 on success.
- */
-int linenoiseHistorySave(const char *filename);
-
-/*
- * Replaces the current history with the contents
- * of the given file.  Returns 0 on success.
- */
-int linenoiseHistoryLoad(const char *filename);
-
-/*
- * Frees all history entries, clearing the history.
- */
-void linenoiseHistoryFree(void);
-
-/*
- * Returns a pointer to the list of history entries, writing its
- * length to *len if len is not NULL. The memory is owned by linenoise
- * and must not be freed.
- */
-char **linenoiseHistory(int *len);
-
-/*
- * Returns the number of display columns in the current terminal.
- */
-int linenoiseColumns(void);
-
-/*
- * Returns the number of display rows|lines in the current terminal.
- */
-int linenoiseLines(void);
+int linenoiseHistorySave(char *filename);
+int linenoiseHistoryLoad(char *filename);
+void linenoiseClearScreen(void);
 
 #endif /* __LINENOISE_H */

@@ -1,115 +0,0 @@ 
-/**
- * UTF-8 utility functions
- *
- * (c) 2010 Steve Bennett <steveb@workware.net.au>
- *
- * See LICENCE for licence details.
- */
-
-#include <ctype.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include "utf8.h"
-
-#ifdef USE_UTF8
-int utf8_fromunicode(char *p, unsigned short uc)
-{
-    if (uc <= 0x7f) {
-        *p = uc;
-        return 1;
-    }
-    else if (uc <= 0x7ff) {
-        *p++ = 0xc0 | ((uc & 0x7c0) >> 6);
-        *p = 0x80 | (uc & 0x3f);
-        return 2;
-    }
-    else {
-        *p++ = 0xe0 | ((uc & 0xf000) >> 12);
-        *p++ = 0x80 | ((uc & 0xfc0) >> 6);
-        *p = 0x80 | (uc & 0x3f);
-        return 3;
-    }
-}
-
-int utf8_charlen(int c)
-{
-    if ((c & 0x80) == 0) {
-        return 1;
-    }
-    if ((c & 0xe0) == 0xc0) {
-        return 2;
-    }
-    if ((c & 0xf0) == 0xe0) {
-        return 3;
-    }
-    if ((c & 0xf8) == 0xf0) {
-        return 4;
-    }
-    /* Invalid sequence */
-    return -1;
-}
-
-int utf8_strlen(const char *str, int bytelen)
-{
-    int charlen = 0;
-    if (bytelen < 0) {
-        bytelen = strlen(str);
-    }
-    while (bytelen) {
-        int c;
-        int l = utf8_tounicode(str, &c);
-        charlen++;
-        str += l;
-        bytelen -= l;
-    }
-    return charlen;
-}
-
-int utf8_index(const char *str, int index)
-{
-    const char *s = str;
-    while (index--) {
-        int c;
-        s += utf8_tounicode(s, &c);
-    }
-    return s - str;
-}
-
-int utf8_charequal(const char *s1, const char *s2)
-{
-    int c1, c2;
-
-    utf8_tounicode(s1, &c1);
-    utf8_tounicode(s2, &c2);
-
-    return c1 == c2;
-}
-
-int utf8_tounicode(const char *str, int *uc)
-{
-    unsigned const char *s = (unsigned const char *)str;
-
-    if (s[0] < 0xc0) {
-        *uc = s[0];
-        return 1;
-    }
-    if (s[0] < 0xe0) {
-        if ((s[1] & 0xc0) == 0x80) {
-            *uc = ((s[0] & ~0xc0) << 6) | (s[1] & ~0x80);
-            return 2;
-        }
-    }
-    else if (s[0] < 0xf0) {
-        if (((str[1] & 0xc0) == 0x80) && ((str[2] & 0xc0) == 0x80)) {
-            *uc = ((s[0] & ~0xe0) << 12) | ((s[1] & ~0x80) << 6) | (s[2] & ~0x80);
-            return 3;
-        }
-    }
-
-    /* Invalid sequence, so just return the byte */
-    *uc = *s;
-    return 1;
-}
-
-#endif

@@ -1,79 +0,0 @@ 
-#ifndef UTF8_UTIL_H
-#define UTF8_UTIL_H
-/**
- * UTF-8 utility functions
- *
- * (c) 2010 Steve Bennett <steveb@workware.net.au>
- *
- * See LICENCE for licence details.
- */
-
-#ifndef USE_UTF8
-#include <ctype.h>
-
-/* No utf-8 support. 1 byte = 1 char */
-#define utf8_strlen(S, B) ((B) < 0 ? (int)strlen(S) : (B))
-#define utf8_tounicode(S, CP) (*(CP) = (unsigned char)*(S), 1)
-#define utf8_index(C, I) (I)
-#define utf8_charlen(C) 1
-
-#else
-/**
- * Converts the given unicode codepoint (0 - 0xffff) to utf-8
- * and stores the result at 'p'.
- * 
- * Returns the number of utf-8 characters (1-3).
- */
-int utf8_fromunicode(char *p, unsigned short uc);
-
-/**
- * Returns the length of the utf-8 sequence starting with 'c'.
- * 
- * Returns 1-4, or -1 if this is not a valid start byte.
- *
- * Note that charlen=4 is not supported by the rest of the API.
- */
-int utf8_charlen(int c);
-
-/**
- * Returns the number of characters in the utf-8 
- * string of the given byte length.
- *
- * Any bytes which are not part of an valid utf-8
- * sequence are treated as individual characters.
- *
- * The string *must* be null terminated.
- *
- * Does not support unicode code points > \uffff
- */
-int utf8_strlen(const char *str, int bytelen);
-
-/**
- * Returns the byte index of the given character in the utf-8 string.
- * 
- * The string *must* be null terminated.
- *
- * This will return the byte length of a utf-8 string
- * if given the char length.
- */
-int utf8_index(const char *str, int charindex);
-
-/**
- * Returns the unicode codepoint corresponding to the
- * utf-8 sequence 'str'.
- * 
- * Stores the result in *uc and returns the number of bytes
- * consumed.
- *
- * If 'str' is null terminated, then an invalid utf-8 sequence
- * at the end of the string will be returned as individual bytes.
- *
- * If it is not null terminated, the length *must* be checked first.
- *
- * Does not support unicode code points > \uffff
- */
-int utf8_tounicode(const char *str, int *uc);
-
-#endif
-
-#endif

@@ -45,7 +45,7 @@ # 	\xDD		Match byte with hex value 0xDD
 # 	\meta		Match one of the meta character: ^$().[*+?\
 # 
 
-{.compile: "vendor/slre/libslre.c".}
+{.compile: "slre/libslre.c".}
 #
 #  Compiled regular expression
 #