endif
endif
ifeq (,$(DL_IMPL))
  ENABLE_MODULES := 0
endif

# cgiish...
OBJ_USING_TH1_AMAL := cgiish.o linenoiseish.o th1ish_cgi.o
$(OBJ_USING_TH1_AMAL): CPPFLAGS+=-DTH1ISH_AMALGAMATION_BUILD=1
$(OBJ_USING_TH1_AMAL): th1ish_amalgamation.h
ifeq (0,1)# enable this block to build cgiish as a loadable module
ifeq (1,$(ENABLE_MODULES))
  cgiish.DLL.OBJECTS := cgiish.o th1ish_cgi.o
  $(eval $(call ShakeNMake.CALL.RULES.DLLS,cgiish))
  $(cgiish.DLL): $(libth1ish.LIB)
  all: $(cgiish.DLL)
endif
endif
# /cgiish
ifeq (1,$(ENABLE_MODULES))
  linenoise/utf8.o linenoise/linenoise.o: CFLAGS+=-std=c99
  linenoiseish.DLL.OBJECTS := linenoise/utf8.o linenoise/linenoise.o linenoiseish.o
  $(eval $(call ShakeNMake.CALL.RULES.DLLS,linenoiseish))
  $(linenoiseish.DLL): $(libth1ish.LIB)
  all: $(linenoiseish.DLL)
endif

# /ENABLE_MODULES
########################################################################

########################################
# Set up file-specific CPPFLAGS/LDFLAGS.
# Set up the loadable modules flags...

all:  linenoise_example linenoise_utf8_example linenoise_cpp_example

linenoise_example: linenoise.h linenoise.c example.c
	$(CC) -Wall -W -Os -g -o $@ linenoise.c example.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_cpp_example: linenoise.h linenoise.c
	g++ -Wall -W -Os -g -o $@ linenoise.c example.c

clean:
	rm -f linenoise_example linenoise_utf8_example linenoise_cpp_example *.o

# Linenoise

A minimal, zero-config, BSD licensed, readline replacement.

News: linenoise now includes minimal completion support, thanks to Pieter Noordhuis (@pnoordhuis).

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 (Real 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 2000 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

#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[]) {
    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] != '/') {
            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);
        }
        free(line);
    }
    return 0;
}

/* 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)
 *
 * Does a number of crazy assumptions that happen to be true in 99.9999% of
 * the 2010 UNIX computers around.
 *
 * ------------------------------------------------------------------------
 *
 * 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
 * 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.
 *
 * ------------------------------------------------------------------------
 *
 * References:
 * - http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
 * - http://www.3waylabs.com/nw/WWW/products/wizcon/vt220.html
 *
 * Bloat:
 * - Completion?
 *
 * 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
 * flickering effect with some slow terminal, but the lesser sequences
 * the more compatible.
 *
 * EL (Erase Line)
 *    Sequence: ESC [ n K
 *    Effect: if n is 0 or missing, clear from cursor to end of line
 *    Effect: if n is 1, clear from beginning of line to cursor
 *    Effect: if n is 2, clear entire line
 *
 * 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:
 *
 * cursorhome
 *    Sequence: ESC [ H
 *    Effect: moves the cursor to upper left corner
 *
 * 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
#include <termios.h>
#include <sys/ioctl.h>
#include <sys/poll.h>
#define USE_TERMIOS
#define HAVE_UNISTD_H
#endif

extern char * strdup(char const *)
    /* cannot explain why my build is not picking up system's strdup()! */;

#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

#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
};

static int history_max_len = LINENOISE_DEFAULT_HISTORY_MAX_LEN;
static int history_len = 0;
static char **history = NULL;

/* 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 */
    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 rows;   /* Screen rows */
    int x;      /* Current column during output */
    int y;      /* Current row */
#endif
};

static int fd_read(struct current *current);
static int getWindowSize(struct current *current);

void linenoiseHistoryFree(void) {
    if (history) {
        int j;

        for (j = 0; j < history_len; j++)
            free(history[j]);
        free(history);
        history = NULL;
        history_len = 0;
    }
}

#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 */

static const char *unsupported_term[] = {"dumb","cons25",NULL};

static int isUnsupportedTerm(void) {
    char *term = getenv("TERM");

    if (term) {
        int j;
        for (j = 0; unsupported_term[j]; j++) {
            if (strcmp(term, unsupported_term[j]) == 0) {
                return 1;
            }
        }
    }
    return 0;
}

static int enableRawMode(struct current *current) {
    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 (!atexit_registered) {
        atexit(linenoiseAtExit);
        atexit_registered = 1;
    }

    raw = orig_termios;  /* modify the original mode */
    /* input modes: no break, no CR to NL, no parity check, no strip char,
     * no start/stop output control. */
    raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
    /* output modes - disable post processing */
    raw.c_oflag &= ~(OPOST);
    /* control modes - set 8 bit chars */
    raw.c_cflag |= (CS8);
    /* local modes - choing off, canonical off, no extended functions,
     * no signal chars (^Z,^C) */
    raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
    /* control chars - set return condition: min number of bytes and timer.
     * 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;
    }
    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)
{
    /* 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 == ';') {
                /* Ignore rows */
                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)
 */
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;
        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,
     * (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.
     */

    if (current->cols == 0) {
        int here;

        current->cols = 80;

        /* (a) */
        if (queryCursor (current->fd, &here)) {
            /* (b) */
            fd_printf(current->fd, "\x1b[999C");

            /* (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)) {
                /* (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.
                 */
                fd_printf(current->fd, "\r");
            } else {
                /* (d) Reset the cursor back to the original location. */
                if (current->cols > here) {
                    fd_printf(current->fd, "\x1b[%dD", current->cols - here);
                }
            }
        } /* 1st query failed, doing nothing => default 80 */
    }

    return 0;
}

/**
 * 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;
        }
    }
    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)

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);
    }
    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;
    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);
}

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;
#else
                return k->uChar.AsciiChar;
#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;
        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);
#else
    *buf = c;
    return 1;
#endif
}

/**
 * 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);

    /* Account for a line which is too long to fit in the window.
     * Note that control chars require an extra column
     */

    /* 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 */

    /* 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 (ch < ' ') {
            n++;
        }
        if (pchars + i + n >= current->cols) {
            break;
        }
        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;
        }
    }
    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");
            }
        }
#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 (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;
            }
        }
#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;
    }
    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';
        }
    }
}

/**
 * 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;

    while (*chars) {
        int ch;
        int n = utf8_tounicode(chars, &ch);
        if (insert_char(current, pos, ch) == 0) {
            break;
        }
        inserted++;
        pos++;
        chars += n;
    }
    return inserted;
}

#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);
}

static int completeLine(struct current *current) {
    linenoiseCompletions lc = { 0, NULL };
    int c = 0;

    completionCallback(current->buf,&lc);
    if (lc.len == 0) {
        beep();
    } else {
        size_t stop = 0, i = 0;

        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);
            } else {
                refreshLine(current->prompt, current);
            }

            c = fd_read(current);
            if (c == -1) {
                break;
            }

            switch(c) {
                case '\t': /* 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);
                    }
                    stop = 1;
                    break;
                default:
                    /* Update buffer and return */
                    if (i < lc.len) {
                        set_current(current,lc.cvec[i]);
                    }
                    stop = 1;
                    break;
            }
        }
    }

    freeCompletions(&lc);
    return c; /* Return last read character */
}

/* Register a callback function to be called for tab-completion. */
void linenoiseSetCompletionCallback(linenoiseCompletionCallback *fn) {
    completionCallback = fn;
}

void linenoiseAddCompletion(linenoiseCompletions *lc, const char *str) {
    lc->cvec = (char **)realloc(lc->cvec,sizeof(char*)*(lc->len+1));
    lc->cvec[lc->len++] = strdup(str);
}

#endif

static int linenoiseEdit(struct current *current) {
    int history_index = 0;

    /* The latest history entry is always our current buffer, that
     * initially is just an empty string. */
    linenoiseHistoryAdd("");

    set_current(current, "");
    refreshLine(current->prompt, current);

    while(1) {
        int dir = -1;
        int c = fd_read(current);

#ifndef NO_COMPLETION
        /* 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' && current->pos == current->chars && completionCallback != NULL) {
            c = completeLine(current);
            /* Return on errors */
            if (c < 0) return current->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 */
            history_len--;
            free(history[history_len]);
            return current->len;
        case ctrl('C'):     /* ctrl-c */
            errno = EAGAIN;
            return -1;
        case 127:   /* backspace */
        case ctrl('H'):
            if (remove_char(current, current->pos - 1) == 1) {
                refreshLine(current->prompt, current);
            }
            break;
        case ctrl('D'):     /* ctrl-d */
            if (current->len == 0) {
                /* Empty line, so EOF */
                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 SPECIAL_INSERT:
            /* Ignore. Expansion Hook.
             * Future possibility: Toggle Insert/Overwrite Modes
             */
            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) != ' ') {
                    pos--;
                }

                if (remove_chars(current, pos, current->pos - pos)) {
                    refreshLine(current->prompt, current);
                }
            }
            break;
        case ctrl('R'):    /* ctrl-r */
            {
                /* 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 */
                        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;
                }
                else if (c == ctrl('J')) {
                    /* ctrl-j terminates the search leaving the buffer in place */
                    c = 0;
                }
                /* 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);
                    }
                    refreshLine(current->prompt, current);
                }
            }
            break;
        case ctrl('B'):
        case SPECIAL_LEFT:
            if (current->pos > 0) {
                current->pos--;
                refreshLine(current->prompt, current);
            }
            break;
        case ctrl('F'):
        case SPECIAL_RIGHT:
            if (current->pos < current->chars) {
                current->pos++;
                refreshLine(current->prompt, current);
            }
            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:
            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(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);
            }
            break;
        case ctrl('A'): /* Ctrl+a, go to the start of the line */
        case SPECIAL_HOME:
            current->pos = 0;
            refreshLine(current->prompt, current);
            break;
        case ctrl('E'): /* ctrl+e, go to the end of the line */
        case SPECIAL_END:
            current->pos = current->chars;
            refreshLine(current->prompt, current);
            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);
                }
            }
            break;
        }
    }
    return current->len;
}

int linenoiseColumns(void)
{
    struct current current;
    enableRawMode (&current);
    getWindowSize (&current);
    disableRawMode (&current);
    return current.cols;
}

char *linenoise(const char *prompt)
{
    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 (count && buf[count-1] == '\n') {
            count--;
            buf[count] = '\0';
        }
    }
    else
    {
        current.buf = buf;
        current.bufmax = sizeof(buf);
        current.len = 0;
        current.chars = 0;
        current.pos = 0;
        current.prompt = prompt;
        current.capture = NULL;

        count = linenoiseEdit(&current);

        disableRawMode(&current);
        printf("\n");

        free(current.capture);
        if (count == -1) {
            return NULL;
        }
    }
    return strdup(buf);
}

/* Using a circular buffer is smarter, but a bit more complex to handle. */
int linenoiseHistoryAdd(const char *line) {
    char *linecopy;

    if (history_max_len == 0) return 0;
    if (history == NULL) {
        history = (char **)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) {
        free(history[0]);
        memmove(history,history+1,sizeof(char*)*(history_max_len-1));
        history_len--;
    }
    history[history_len] = linecopy;
    history_len++;
    return 1;
}

int linenoiseHistoryGetMaxLen(void) {
    return history_max_len;
}

int linenoiseHistorySetMaxLen(int len) {
    char **newHistory;

    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);
        free(history);
        history = newHistory;
    }
    history_max_len = len;
    if (history_len > history_max_len)
        history_len = history_max_len;
    return 1;
}

/* Save the history in the specified file. On success 0 is returned
 * otherwise -1 is returned. */
int linenoiseHistorySave(const char *filename) {
    FILE *fp = fopen(filename,"w");
    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);
    }

    fclose(fp);
    return 0;
}

/* Load the history from the specified file. If the file does not exist
 * 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) {
    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;

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

/* linenoise.h -- guerrilla line editing library against the idea that a
 * 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:
 *
 *  *  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
 * 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.
 */

#ifndef __LINENOISE_H
#define __LINENOISE_H

#ifndef NO_COMPLETION
typedef struct linenoiseCompletions {
  size_t len;
  char **cvec;
} linenoiseCompletions;

typedef void(linenoiseCompletionCallback)(const char *, linenoiseCompletions *);
void linenoiseSetCompletionCallback(linenoiseCompletionCallback *);
void linenoiseAddCompletion(linenoiseCompletions *, const char *);
#endif

char *linenoise(const char *prompt);
int linenoiseHistoryAdd(const char *line);
int linenoiseHistorySetMaxLen(int len);
int linenoiseHistoryGetMaxLen(void);
int linenoiseHistorySave(const char *filename);
int linenoiseHistoryLoad(const char *filename);
void linenoiseHistoryFree(void);
char **linenoiseHistory(int *len);
int linenoiseColumns(void);

#endif /* __LINENOISE_H */

/**
 * 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

#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

/*
  This file implements a th1ish binding for linenoise:

  https://github.com/msteveb/linenoise
*/
#include <assert.h>
#include <memory.h> /* strlen() */
#include "linenoise/linenoise.h"
#ifdef TH1ISH_AMALGAMATION_BUILD
#include "th1ish_amalgamation.h"
#else
#include "th1ish.h"
#endif
#include <stdlib.h> /* free() */

#if 0
#include "../cwal_internal.h" /* only for debuggering */
#endif

#include <stdio.h>
#define MARKER(pfexp)                                                \
    do{ printf("MARKER: %s:%d:%s():\t",__FILE__,__LINE__,__func__); \
        printf pfexp; \
    } while(0)

/**
   This is essentially a placeholder structure to a
   unique-per-interpreter handle to the linenoise lib. We need a
   per-instance handle only so that we can implement auto-save when
   the value is cleaned up.
*/
struct ln_native {
    cwal_value * vSelf;
#ifndef NO_COMPLETION
    linenoiseCompletions * lc;
#else
    void * lc;
#endif
};
typedef struct ln_native ln_native;
/**
   Serves as a copy-constructable default instance and as a type ID
   pointer for cwal_new_native() and friends.
*/
static const ln_native ln_native_empty = {NULL, NULL};
static ln_native ln_native_shared = {NULL, NULL};

#define ARGS_IE th1ish_interp * ie = th1ish_args_interp(args); \
    assert(ie)

#define THIS_LN \
    cwal_native * nself = cwal_value_get_native(args->self);    \
    ln_native * self = nself \
        ? (ln_native *)cwal_native_get(nself, &ln_native_empty) : NULL; \
    ARGS_IE; \
    if(!self) return th1ish_toss(ie, CWAL_RC_TYPE,                      \
                                 "'this' is not (or is no longer) "\
                                 "a linenoise instance.")

static int ln_hist_load( cwal_callback_args const * args,
                         cwal_value **rv ){
    int rc;
    cwal_value * vfn = NULL;
    char const * fn;
    char setProp = 0;
    THIS_LN;
    if(!args->argc){
        vfn = cwal_prop_get(self->vSelf,
                            "historyFile", 11);
        fn = vfn ? cwal_value_get_cstr(vfn, NULL) : NULL;
    }else{
        vfn = args->argv[0];
        fn = cwal_value_get_cstr(vfn, NULL);
        if(fn) setProp = 1;
    }
    if(!fn || !*fn){
        return th1ish_toss(ie, CWAL_RC_MISUSE,
                           "Expecting a non-empty string "
                           "argument or a this.historyFile "
                           "property.");
    }
    rc = linenoiseHistoryLoad(fn);
    if(!rc && setProp){
        cwal_prop_set( args->self, "historyFile", 11, vfn );
    }
    return rc
        ? th1ish_toss(ie, CWAL_RC_ERROR,
                      "linenoiseHistoryLoad('%s') failed "
                      "with code %d.",
                      fn, rc)
        : 0;
}

static int ln_hist_save( cwal_callback_args const * args,
                         cwal_value **rv ){
    cwal_value * hName = NULL;
    char const * fn = NULL;
    THIS_LN;
    if(!args->argc){
        hName = cwal_prop_get(self->vSelf,
                              "historyFile", 11);
        fn = hName ? cwal_value_get_cstr(hName, NULL) : NULL;
    }else{
        fn = cwal_value_get_cstr(args->argv[0], NULL);
    }
    if(!fn || !*fn){
        return th1ish_toss(ie, CWAL_RC_MISUSE,
                           "Expecting a non-empty string "
                           "argument or a this.historyFile "
                           "property.");
    }
    else{
        int const rc = linenoiseHistorySave(fn);
        return rc
            ? th1ish_toss(ie, CWAL_RC_ERROR,
                          "linenoiseHistorySave('%s') failed "
                          "with code %d.",
                          fn, rc)
            : 0;
    }
}

static int ln_hist_size( cwal_callback_args const * args,
                         cwal_value **rv ){
    if(!args->argc){
        *rv = cwal_new_integer(args->engine,
                               (cwal_int_t)linenoiseHistoryGetMaxLen());
        return *rv ? 0 : CWAL_RC_OOM;
    }else{
        linenoiseHistorySetMaxLen( cwal_value_get_integer(args->argv[0]) );
        *rv = cwal_value_undefined();
        return 0;
    }
}

static int ln_hist_add( cwal_callback_args const * args,
                        cwal_value **rv ){
    ARGS_IE;
    if(!args->argc || !cwal_value_is_string(args->argv[0])){
        return th1ish_toss(ie, CWAL_RC_MISUSE,
                           "Expecting a string argument.");
    }else{
        cwal_size_t slen = 0;
        char const * str = cwal_value_get_cstr(args->argv[0], &slen);
        cwal_buffer * buf = &ie->buffer;
        cwal_size_t const oldUsed = buf->used;
        int rc = cwal_buffer_append(args->engine, buf, str, slen);
        /* We use a buffer here or this will fail if str is not
           NUL-terminated (an x-string can/will trigger this).  That
           said, we don't really expect X-strings to ever be fed in to
           the CLI history.
        */
        if(rc) return rc;
        else if(buf->used == oldUsed){
            *rv = cwal_value_false();
        }else{
            *rv =
                cwal_new_bool(
                              linenoiseHistoryAdd((char const *)(buf->mem+oldUsed))
                              ? 1 : 0);
            buf->used = oldUsed;
        }
        return 0;
    }
}

#ifndef NO_COMPLETION
static struct {
    th1ish_interp * ie;
    ln_native * ln;
    cwal_function * cb;
    int rc;
} LnCompletion = {
NULL,
NULL,
NULL,
0
};
static void ln_completion_add(linenoiseCompletions *lc, cwal_value const * v) {
    char const * str = v ? cwal_value_get_cstr(v, NULL) : NULL;
    if(str){
        linenoiseAddCompletion(lc,str);
    }
}

static void ln_completion(const char *buf, linenoiseCompletions *lc) {
    int rc;
    cwal_value * str;
    cwal_scope * sc = cwal_scope_current_get(LnCompletion.ie->e);
    cwal_value * rv = NULL;
    str = cwal_new_string_value(LnCompletion.ie->e, buf, 0);
    if(!str){
        LnCompletion.rc = CWAL_RC_OOM;
        return;
    }
    rc =
        cwal_function_call_in_scope(sc, LnCompletion.cb,
                                    LnCompletion.ln->vSelf,
                                    &rv, 1, &str);
    str = NULL;
    if(rc){
        LnCompletion.rc = rc;
    }else if(cwal_value_is_array(rv)){
        cwal_array * ar = cwal_value_get_array(rv);
        if(!ar) return;
        else{
            cwal_size_t i;
            cwal_size_t const n = cwal_array_length_get(ar);
            for(i = 0; i < n; ++i){
                ln_completion_add(lc, cwal_array_get(ar, i));
            }
        }
    }else if(rv){
        ln_completion_add(lc, rv);
    }
}
#endif
/* NO_COMPLETION */

static int ln_columns( cwal_callback_args const * args,
                        cwal_value **rv ){
    *rv = cwal_new_integer(args->engine,
                           (cwal_int_t)linenoiseColumns());
    return *rv ? 0 : CWAL_RC_OOM;
}

static int ln_readline( cwal_callback_args const * args,
                        cwal_value **rv ){
    int rc = 0;
    char const * cprompt = NULL;
    char * z;
    THIS_LN;
    if(!args->argc){
        cwal_value * vprompt =
            cwal_prop_get(self->vSelf,
                          "prompt", 6);
        cprompt = vprompt
            ? cwal_value_get_cstr(vprompt, NULL)
            : NULL;
    }else{
        cprompt = cwal_value_get_cstr(args->argv[0], NULL);
    }
    if(!cprompt) cprompt = "";
#ifndef NO_COMPLETION
    /* Thanks to Andreas Kupries for this trick... */
    {
        cwal_value * cbv = cwal_prop_get(self->vSelf,
                                         "customCompletions", 17);
        cwal_function * fn = cbv ? cwal_value_get_function(cbv) : NULL;
        LnCompletion.cb = fn;
    }
    if(LnCompletion.cb){
        linenoiseSetCompletionCallback(ln_completion);
        LnCompletion.ie = ie;
        LnCompletion.ln = self;
    }
#endif
    z = linenoise(cprompt);
#ifndef NO_COMPLETION
    if(LnCompletion.cb){
        linenoiseSetCompletionCallback(NULL);
        LnCompletion.ie = NULL;
        LnCompletion.cb = NULL;
        rc = LnCompletion.rc;
        LnCompletion.rc = 0;
    }
#endif
    if(rc) return rc;

    if(!z){
        *rv = cwal_value_undefined();
    }
    else{
        *rv = cwal_new_string_value(args->engine,
                                    z, 0);
        if(*rv && *z){
            linenoiseHistoryAdd(z);
            /* TODO: save here: linenoiseHistorySave(...); */
        }
    }
    if(z) free(z) /* reminder: z came from linenoise, i.e. malloc(), not cwal_malloc() */;
    return *rv ? 0 : CWAL_RC_OOM;
}

static int ln_history_list( cwal_callback_args const * args,
                            cwal_value **rv ){
    cwal_array * ar;
    cwal_size_t i;
    int rc = 0;
    int hCount = 0;
    char ** h;
    THIS_LN;
    ar = th1ish_new_array(ie);
    if(!ar) return CWAL_RC_OOM;
    h = linenoiseHistory(&hCount);
    if(hCount>0){
        rc = cwal_array_reserve(ar, (cwal_size_t)hCount);
        if(rc) goto end;
        for( i = 0; i < (cwal_size_t)hCount; ++i ){
            cwal_value * v = cwal_new_string_value(args->engine,
                                                   h[i], 0);
            if(!v){
                rc = CWAL_RC_OOM;
                goto end;
            }else{
                rc = cwal_array_append(ar, v);
                if(rc){
                    cwal_value_unref(v);
                    goto end;
                }
            }
        }
    }

    end:
    if(rc){
        cwal_array_unref(ar);
        return rc;
    }else{
        *rv = cwal_array_value(ar);
        return 0;
    }
}


static void ln_native_finalize( cwal_engine * e, void * v ){

    ln_native * ln = (ln_native *)v;
    cwal_value * hName = cwal_prop_get(ln->vSelf,
                                       "historyFile", 11);
    ln->vSelf = NULL;
    if(hName && cwal_value_is_string(hName)){
        char const * fn = cwal_value_get_cstr(hName, NULL);
        linenoiseHistorySave(fn);
    }
    linenoiseHistoryFree();
    if(&ln_native_shared != ln){
        cwal_free( e, ln );
    }
}

int ln_install_to_interp( th1ish_interp * ie, cwal_value * ns ){
    int rc;
    cwal_value * v;
    cwal_value * mod;
    static char const * modKey = "linenoise";
    static cwal_size_t const keyLen = 9;
    ln_native * ln;
    if(!cwal_props_can(ns)) return CWAL_RC_MISUSE;

    v = cwal_prop_get( ns, modKey, keyLen);
    if(v) return 0;

#if 0
    ln = &ln_native_shared;
#else
    ln = (ln_native*)cwal_malloc(ie->e, sizeof(ln_native));
    if(!ln) return CWAL_RC_OOM;
#endif
    mod = cwal_new_native_value(ie->e, ln, ln_native_finalize,
                                &ln_native_empty);
    if(!mod){
        cwal_free(ie->e, ln);
        return CWAL_RC_OOM;
    }
    ln->vSelf = mod;
    rc = cwal_prop_set( ns, modKey, keyLen, mod );
    if(rc){
        cwal_value_unref(mod);
        goto end;
    }
    cwal_value_prototype_set( mod, th1ish_prototype_object(ie) );

#define CHECKV if(!v){ rc = CWAL_RC_OOM; goto end; } (void)0
#define SET(KEY) rc = cwal_prop_set( mod, KEY, strlen(KEY), v ); \
    assert(!rc); if(rc) goto end
#define FUNC2(NAME,FP)                              \
    v = th1ish_new_function2( ie, FP );     \
    CHECKV; \
    SET(NAME);      \
    assert(!rc);                                                 \
    if(rc) goto end

    FUNC2("add", ln_hist_add);
    FUNC2("consoleWidth", ln_columns);
    FUNC2("getHistoryList", ln_history_list);
    FUNC2("load", ln_hist_load);
    FUNC2("read", ln_readline);
    FUNC2("save", ln_hist_save);
    FUNC2("size", ln_hist_size);
    FUNC2("canCompile", th1ish_f_basic_compile_check);
    
#undef SET
#undef FUNC2
#undef CHECKV
    end:
    return rc;
}


/*
  Install th1ish_module_load() support.
*/
/*TH1ISH_MODULE_DECL(linenoiseish);*/
TH1ISH_MODULE_IMPL(linenoiseish,ln_install_to_interp);
TH1ISH_MODULE_IMPL1(linenoiseish,ln_install_to_interp);

#undef MARKER
#undef ARGS_IE
#undef THIS_LN

/**
    Demonstration of the 'linenoiseish' plugin.

    Linenoise home: https://github.com/msteveb/linenoise
*/
const ln = [api.loadModule 'linenoiseish'].linenoise
$print 'ln =' ln

scope {
    assert 0 < ln.size() // get history limit
    ln.size(20) // set history limit
    assert 20 == ln.size()

    const hFile = "history.ln"
    if(!catch{ln.load(hFile)}){
        // Found/loaded history file
        assert ln.historyFile === hFile
    }else{
        // Could not load (probably doesn't exist)
        ln.historyFile = hFile // will auto-save this at destruction
    }

    print("Just FYI... console width =",ln.consoleWidth())

}

//ln.add("added from script "+__SRC)

/**
    To install custom completion handlers, add a method
    named customCompletions(). It takes 1 argument (the string
    entered up to the point where TAB was pressed). It may
    return nothing (no completions), a single string (a unique
    completion) or an array of strings (multiple completions
    through which linenoise will alternate on subsequent
    presses of the TAB key).

    Throwing an exception from the callback will propagate it
    up to the call point but, due to linenoise internals it
    does not get triggered until the user has pressed
    ENTER or the local EOF sequence (Unix: Ctrl-D).

    In the context of the callback, 'this' will be the
    linenoise module object.
*/
ln.myComps = ln.propertyKeys() // test/dummy completions
ln.customCompletions = proc(s){
    // throw "Just testing"
    return this.myComps // this === ln
}

// Define default prompt used by ln.read():
ln.prompt = "prompt > "

// api.x = 3 // this caused an assertion when run from user input inside our loop
1 && scope {
    var line;
    while(undefined !== (line = ln.read())){
        /* A prompt string may be passed to read() or
           set as ln.prompt. */
        if(ln.canCompile(line)){
            const v = catch {toss eval line}
            if(v inherits api.Exception){print("EXCEPTION:",v.code,':',v)}
            else{(undefined === v) || print(typename v, v)}
            //else { print(typename v, v) }
        }else{
            print("Got non-script:",line);
        }
    }
    print("Done looping")
}

0 && scope {
    ln.size(2) // C API rejects value 0 :-?
    $print ln.getHistoryList()
}

//ln.save() // not necessary: saves automatically at destruction
ln

    char enableStackTraces;
    char enableConventionalCallOp;
    char enableExtraLoopScopes;
    char enableProcTokenCaching;
    char enableArgv0Autoload;
    char dumpStringsTable;
    char dumpAllocMetrics;
    char testMode;
    int autoSweepInterval;
    char autoSweepIntervalLog;
    cwal_size_t tokenRecyclerSize;
    cwal_json_output_opt JsonOutOpt;
    struct {
        int count;
        char const * list[SHELL_MAX_E_SCRIPTS];

1/*enableStackTraces*/,
1/*enableConventionalCallOp*/,
0/*enableExtraLoopScopes*/,
1/*enableProcTokenCaching*/,
1/*enableArgv0Autoload*/,
0/*dumpStringsTable*/,
0/*dumpAllocMetrics*/,
0/*testMode*/,
3/*autoSweepInterval*/,
0/*autoSweepIntervalLog*/,
/*
  tokenRecyclerSize

  Notes: sizeof(cwal_simple_token) is currently 20 on 32-bits and
  32 on 64-bits. (8kb/that_sizeof) == 409 (32-bits) or 256

        else {
            rc = th1ish_eval_filename( ie, 0, App.inFile, &rv );
        }
    }

    end:
    if(App.tokenizeOnly){
        assert(1==ie->skipLevel);
        --ie->skipLevel;
    }

    if(App.testMode){
        MARKER(("Compilability check tests...\n"));
#define CHECK(INP,EXPECT) \
        rc = th1ish_basic_compile_check(ie, INP, -1, 0);         \
        MARKER(("%s\ncompile check rc=%d %s\n", INP, rc, cwal_rc_cstr(rc))); \
        assert(rc EXPECT); cwal_engine_sweep(ie->e) /* clean up exceptions */

        CHECK("{hi}", ==0);
        CHECK("{hi};", ==0);
        CHECK("", ==CWAL_SCR_EOF);
        CHECK(" \n/*comment*/\n{hi}; bye there; 123\n\n13;", ==0);
        CHECK(" \n/*comment*/\n{hi}; 0 ? x 1;", !=0);
        CHECK("\"...", !=0);
        CHECK("toss", !=0);
        CHECK("catch{toss}", ==0);
        CHECK("catch{toss", !=0);
#undef CHECK
        rc = 0;
    }

    switch(rc){
      case CWAL_RC_EXIT:
          exc = cwal_exception_get(ie->e)
              /* We do this to get any exception
                 thrown via fork().
              */;
          rc = exc ? CWAL_RC_EXCEPTION : 0;

            return 0;
        }
        else if(0==strcmp("-n",arg)){ /* "dry-run" mode */
            App.tokenizeOnly = 1;
            continue;
        }
        else if(CMP("metrics")) App.dumpAllocMetrics = 1;
        else if(CMP("test")) App.testMode = 1;
        else if(('-' != *arg) && !App.inFile){
            App.inFile = arg;
            continue;
        }
        else {
            MARKER(("Unknown argument or flag: [%s]\n", arg));
            rc = CWAL_RC_MISUSE;

int cwal_callback_hook_set(cwal_engine * e, cwal_callback_hook const * h ){
    if(!e) return CWAL_RC_MISUSE;
    e->cbHook = h ? *h : cwal_callback_hook_empty;
    return 0;
}

cwal_size_t cwal_strlen( char const * str ){
    return str ? (cwal_size_t)strlen(str) : 0U;
}


#undef MARKER
#undef cwal_string_empty_m
#undef cwal_obase_empty_m
#undef cwal_array_empty_m
#undef cwal_kvp_empty_m
#undef cwal_object_empty_m

   The entry-point for evaluating a single expression. It handles some
   common token cases like newlines, semicolons, and EOF, falling back
   to th1ish_eval_0().
*/
static int th1ish_eval_entry( th1ish_interp * ie, cwal_simple_token * t,
                              cwal_simple_token ** next,
                              cwal_value ** rv );











/**
   Evaluates t and subsequent expressions as arguments to be passed to
   the given function by iteratively using th1ish_eval_0().

   On success func is call()ed with selfObj as the "this" context (or
   the function itself as the context is selfObj is NULL). The selfObj

      case TT_OpMinusEq:
      case TT_OpMultEq:
      case TT_OpDivEq:
      case TT_OpModEq:
      case TT_OpAssign:
          *next = t;
          if(ie->currentIdentKey){
              /* assert(ie->currentThis); */
              /* th1ish_dump_val(ie->currentThis,"assignment LHS ie->currentThis"); */
              /* th1ish_dump_val(ie->currentIdentKey,"assignment LHS ie->currentIdentKey"); */
              rc = th1ish_eval_assignment(ie, ie->currentThis,
                                          ie->currentIdentKey,
                                          t, next, rv );
          }else if(cwal_value_is_string(*rv)){
              /* th1ish_dump_val(*rv,"assignment LHS string"); */

    /* th1ish_dump_val(v,"Dot-deref val"); */
    if(!v) v = *rv = cwal_value_undefined();
    else {
        *rv = v;
        ie->currentThis = self
            /* Ensure it wasn't overwritten by a sub-parse */
            ;
        /* assert(self); */
    }
    check_tail:
    if(!rc){
        t = th1ish_skip(ie,*next)
            /* We need this instead of cwal_st_skip() so that this doesn't
                throw:

             set code {...}
             eval code
             # or: eval $code

          However, the proper way of doing it has the
          drawback that evaling the script-side string representation
          loses the line/column numbers (resetting them, since they
          are inside a new string value). The current impl allows us
          to reference the original string sources, keeping error
          reporting intact.
        */
      case TT_LiteralStringDQ:
      case TT_LiteralStringSQ:
      case TT_ChScopeOpen:{
          rc = th1ish_eval_scope_string( ie, doScope ? 1 : 0,

    end:
#undef ADDV
#undef CHECKV
#undef RC
    return rc;    
}

int th1ish_f_basic_compile_check( cwal_callback_args const * args, cwal_value **rv ){
    int rc;
    th1ish_interp * ie = th1ish_args_interp(args);
    cwal_size_t strLen = 0;
    char const * str = args->argc
        ? cwal_value_get_cstr(args->argv[0], &strLen)
        : 0;
    assert(ie);
    if(!str) return th1ish_toss(ie, CWAL_RC_MISUSE,
                                "Expecting a string argument.");
    if(!*str) {
        *rv = cwal_value_false();
        return 0;
    }
    rc = th1ish_basic_compile_check( ie, str, (cwal_int_t)strLen, 0 );
    if(CWAL_RC_EXCEPTION==rc){
        /* Clear it. */
        cwal_exception_set(ie->e, 0);
    }
    *rv = rc ? cwal_value_false() : cwal_value_true();
    return 0;
}

int th1ish_basic_compile_check( th1ish_interp * ie,
                                char const * code,
                                cwal_int_t codeLen,
                                cwal_simple_token ** out ){
    int rc;
    cwal_simple_token * head = 0;
    cwal_simple_token * t = 0;
    cwal_simple_token * next = 0;
    cwal_size_t n;
    int const oldSkipLevel = ie ? ie->skipLevel : 0;
    if(!code || !codeLen) return CWAL_RC_RANGE;
    assert(!IE_SKIP_MODE);
    n = (codeLen>=0) ? (cwal_size_t)codeLen : (cwal_size_t)strlen(code);

    rc = th1ish_tokenize_all( ie, code, n, &head );
    if(rc) return rc;
    t = head;
    /* ++ie->skipLevel; */
    ie->skipLevel = 1;
    rc = th1ish_eval_chain(ie, t, &next, 0);
    assert(1==ie->skipLevel);
    for( ; !rc && (t != next) && !cwal_st_eof(next);
         t = next ){
        rc = th1ish_eval_chain(ie, t, &next, 0);
        assert(1==ie->skipLevel);
    }
    assert(1==ie->skipLevel);
    /* --ie->skipLevel; */
    ie->skipLevel = oldSkipLevel;
    if(!rc && out){
        *out = head;
    }else{
        th1ish_st_free_chain(ie, head, 1);
    }
    return rc;
}

#undef TNEXT
#undef IE_SKIP_MODE
#undef dump_token
#undef dump_tokenizer
#undef th1ish_dump_val
#undef TH1ISH_PROC_CACHE_TOKENS

           Scope stack. Manipulated via cwal_scope_push() and
           cwal_scope_pop().
        */
        cwal_scope * current;

        /**
           Holds any current pending exception, similarly to how the
           rv member is managed.


        */
        cwal_value * exception;

        /**
           Where clients may store their customized base prototypes
           for each cwal_type_id. The indexes in this array correspond
           directly to cwal_type_id values, but (A) that is an

    /**
       Calls cwal_scope_sweep() on e's current scope, returning the
       result of that call. Returns 0 if !e or if e has no current
       scope.
    */
    cwal_size_t cwal_engine_sweep( cwal_engine * e );

    /**
       DO NOT USE. This is a dangerous experiment.
    */
    int cwal_engine_sweep_non_vars( cwal_engine * e );
    
    /**
       On success, *s is assigned to the current scope and 0 is returned.
       On error *s is not modified and one of the following are returned:

       CWAL_RC_MISUSE: one of the arguments is NULL.

       CWAL_RC_RANGE: e currently has no scope.
    */
    int cwal_scope_current( cwal_engine * e, cwal_scope ** s );

    /**
       Simplified form for cwal_scope_current() which returns the
       current scope, or 0 if !e or if there are no scopes.
    */
    cwal_scope * cwal_scope_current_get( cwal_engine * e );




    /**
       Interpreter-level flags for "variables." Maintenance reminder:
       the Container base type (cwal_obase) and cwal_kvp only have 16
       bits for flags. That said, padding is normally applied which we
       could conceivably use by adding another 2 flag bytes.
    */
    enum cwal_var_flags {

    /**
       Returns the length of str in bytes, or 0 if !str. This is an
       O(1) operation.
    */
    cwal_size_t cwal_string_length_bytes( cwal_string const * str );

    /**
       Returns the length of the first n bytes of str in UTF8 characters, or 0 if
       !str. Results are undefined if str is not legal UTF8. This is
       an O(N) operation.
    */
    cwal_size_t cwal_cstr_length_utf8( unsigned char const * str, cwal_size_t n );

    /**
       Functionally equivalent to strlen(3) except that if !str it
       returns 0 instead of crashing, and it returns cwal_size_t,
       which very well may not be the same size as size_t.
     */
    cwal_size_t cwal_strlen( char const * str );

    /**
       Equivalent to:

       cwal_cstr_length_utf8(cwal_string_cstr(str),cwal_string_length_bytes(str))

       Returns 0 if !str.

   @see th1ish_eval_string();
   @see th1ish_tokenize_chain()
*/
int th1ish_eval_chain( th1ish_interp * ie, cwal_simple_token * head,
                       cwal_simple_token ** next, cwal_value **rv );

/**
   Similar to th1ish_eval_chain() but pushes a scope before executing
   the code. If rv is not NULL then the result value will (on success)
   be written there and it will be scoped so that it will live at
   least as long as the currently running scope (the one active when
   this function is called).
*/
int th1ish_eval_chain_push_scope( th1ish_interp * ie, cwal_simple_token * head,
                                  cwal_simple_token ** next, cwal_value **rv );

/**
   Performs the work of th1ish_tokenize_all() and th1ish_eval_chain(),
   tokenizing and evaluating the given source code.

   If pushScope is true (non-zero) then a new cwal scope is pushed
   onto the stack before execution and popped from it afterwards.

   The problem is that injectedFunction needs to reference its source
   string because the call of the function runs through the token
   chain to evaluate the call. So we need a mechanism which keeps the
   include()'d source code around for some reasonable time OR we need
   to change the token mechanism to copy the source code (which i
   really don't want to do - too memory-costly). cwal's "x-string"
   type could be used to keep these around in memory without having to
   make a second copy after reading the file's contents. The
   th1ish_script API is intended to deal with that problem.

   @see th1ish_eval_string()
*/
int th1ish_eval_filename( th1ish_interp * ie, char pushScope,
                          char const * filename,
                          cwal_value **rv );

   @code
   th1ish_script SC = th1ish_script_empty;
   th1ish_script * sc = ≻
   ... the rest is as shown above ...
   @endcode

   Design note: due to destruction ordering dependencies in
   th1ish_interp, th1ish_script instances and the internals they
   create and manage are prohibited from holding references to
   cwal_value instances. This is not a serious limitation, but more of
   a reminder to self not to get any bright ideas which involve adding
   cwal_values to this type.
*/
struct th1ish_script {
    /**
       The interpreter which compiled the script. A script is bound to

   Implements a static th1ish_loadable_module object named
   th1ish_module_##NAME##_impl and a non-static
   (th1ish_loadable_module*) named th1ish_module_##NAME which points
   to th1ish_module_##NAME##_impl. (That symbol is the one declared
   by TH1ISH_MODULE_DECL.)

   INIT_F must be a th1ish_module_init_f() function pointer.

   This macro should be used in the C file for a loadable module.
   It may be combined in a file with a single TH1ISH_MODULE_IMPL1()
   declaration with the same name, such that the module can be loaded
   both with and without the explicit symbol name.

   Example usage, in a module's header file, if any:

   @code
   TH1ISH_MODULE_DECL(cpdo);

   If it will be the only module packed in the DLL,
   one can also add this:
   
   @code
   TH1ISH_MODULE_IMPL1(cpdo,cpdoish_install_to_interp);
   @endcode

   Which simplifies client-side module loading by allowing them to
   leave out the module name, but only works if modules are compiled
   one per DLL (as opposed to being packaged together in one DLL).
   
   @see TH1ISH_MODULE_DECL
   @see TH1ISH_MODULE_IMPL1
*/
#define TH1ISH_MODULE_IMPL(NAME,INIT_F) \
    static const th1ish_loadable_module \
    th1ish_module_##NAME##_impl = { #NAME, INIT_F }; \

   (which will be (*zIdEnd-pos) bytes long).

   Expects the input to be valid, else results are undefined.
*/
void th1ish_read_identifier( char const * zPos,
                             char const * zMaxPos,
                             char const ** zIdEnd );

/**
   Tries to figure out if the first n bytes of the given th1ish script
   code string refer to compilable code without actually evaluating
   it.  It does this by first tokenizing the code, telling ie that it
   is in short-circuit skipping mode, and then proceeds to traverse
   the tokens (evaluating them only insofar as necessary to skip over
   them properly). If that traversal succeeds without an error, 0 is
   returned, otherwise an integer code representing the problem is
   returned.

   This routine takes a rather simplistic approach and may fail in
   some contexts. Its intended purposes is to analyze user input to
   see if it is executable as code or not, without exposing the
   skip-mode handling to client code. It is possible that there are
   corner cases, but for basic cases it seems to work.

   On success, if head is not NULL then *head is assigned to the start
   of the token chain parsed from the input code. It is owned by the
   caller, who must eventually pass it to th1ish_st_free_chain().
   Before doing so, however, he will presumably want to pass it to
   th1ish_eval_chain() or th1ish_eval_chain_push_scope()

   It's possible that the engine holds an exception after this
   returns, which won't normally be propagated unless this returns
   CWAL_RC_EXCEPTION and the client propagates that back through
   callbacks. Clients may want to call cwal_exception_set(ie->e, 0) to
   clear any pending exception.  One minor caveat: a cleared exception
   is (has to be) left alive, owned by its scope (very probably the
   current one), and will be cleaned up either via auto-sweeping or
   when the scope cleans up.
   
 */
int th1ish_basic_compile_check( th1ish_interp * ie,
                                char const * code,
                                cwal_int_t n,
                                cwal_simple_token ** head);

/**
   A cwal_callback_f() implementation which wraps th1ish_basic_compile_check().
   It requires that the Function wrapping this callback have a (th1ish_interp*)
   as its callback state - see th1ish_new_function2().

   The script function returns boolean true if its single string input
   parameter triggers a 0 result code from
   th1ish_basic_compile_check(), otherwise it returns boolean
   false. It does not propagate any exceptions but does throw if not
   passed a string/buffer argument (it may be empty).

*/
int th1ish_f_basic_compile_check( cwal_callback_args const * args, cwal_value **rv );



/* LICENSE

This software's source code, including accompanying documentation and
demonstration applications, are licensed under the following
conditions...