From 8384223ac82670d39e1f40834dc4375f43c02a94 Mon Sep 17 00:00:00 2001 From: Vas Crabb Date: Tue, 7 Mar 2023 05:33:37 +1100 Subject: Updated forked linenoise to latest upstream. This removes the need to force it to build as C++, and adds proper UTF-8 support for Windows. Since this is a fork of linenoise, there's no hope for getting lua-linenoise to sync with it upstream. I made the bare minimum changes to keep it working, but didn't add bindings for new functionality (e.g. multi-line editing). --- 3rdparty/linenoise/Makefile | 26 +- 3rdparty/linenoise/README.markdown | 69 ++ 3rdparty/linenoise/example.c | 32 +- 3rdparty/linenoise/linenoise-win32.c | 377 +++++++ 3rdparty/linenoise/linenoise.c | 1908 +++++++++++++++++++--------------- 3rdparty/linenoise/linenoise.h | 31 +- 3rdparty/linenoise/stringbuf.c | 173 +++ 3rdparty/linenoise/stringbuf.h | 137 +++ 3rdparty/linenoise/teststringbuf.c | 137 +++ 3rdparty/linenoise/utf8.c | 148 ++- 3rdparty/linenoise/utf8.h | 10 +- 3rdparty/lua-linenoise/linenoise.c | 26 +- plugins/console/init.lua | 20 +- scripts/src/3rdparty.lua | 691 ++++++------ 14 files changed, 2511 insertions(+), 1274 deletions(-) create mode 100644 3rdparty/linenoise/linenoise-win32.c create mode 100644 3rdparty/linenoise/stringbuf.c create mode 100644 3rdparty/linenoise/stringbuf.h create mode 100644 3rdparty/linenoise/teststringbuf.c diff --git a/3rdparty/linenoise/Makefile b/3rdparty/linenoise/Makefile index 3086e9279e8..d8746ab181b 100644 --- a/3rdparty/linenoise/Makefile +++ b/3rdparty/linenoise/Makefile @@ -1,13 +1,23 @@ -all: linenoise_example linenoise_utf8_example linenoise_cpp_example +CFLAGS += -Wall -W -Os -g +CC ?= gcc -linenoise_example: linenoise.h linenoise.c example.c - $(CC) -Wall -W -Os -g -o $@ linenoise.c example.c +all: linenoise_example linenoise_utf8_example -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.h linenoise-ship.c linenoise-win32.c example.c + $(CC) $(CFLAGS) -o $@ linenoise-ship.c example.c -linenoise_cpp_example: linenoise.h linenoise.c - g++ -Wall -W -Os -g -o $@ linenoise.c example.c +linenoise_utf8_example: linenoise.h linenoise-ship.c linenoise-win32.c + $(CC) $(CFLAGS) -DUSE_UTF8 -o $@ linenoise-ship.c example.c clean: - rm -f linenoise_example linenoise_utf8_example linenoise_cpp_example *.o + rm -f linenoise_example linenoise_utf8_example linenoise-ship.c *.o + +ship: linenoise-ship.c + +# linenoise-ship.c simplifies delivery of linenoise support +# simple copy linenoise-ship.c to linenoise.c in your application, and also linenoise.h +# - If you want win32 support, also copy linenoise-win32.c +# - If you never want to support utf-8, you can omit utf8.h and utf8.c + +linenoise-ship.c: utf8.h utf8.c stringbuf.h stringbuf.c linenoise.c + cat $^ >$@ diff --git a/3rdparty/linenoise/README.markdown b/3rdparty/linenoise/README.markdown index d474059211b..88ef530f1ec 100644 --- a/3rdparty/linenoise/README.markdown +++ b/3rdparty/linenoise/README.markdown @@ -1,5 +1,74 @@ # Linenoise +## What's different in this fork? + +- Win32 console +- full utf8 support (what about utf8 on windows) +- insert control characters +- now with multiline + +## How do I include linenoise line editing support in my application? + +From the Makefile: + + linenoise-ship.c simplifies delivery of linenoise support + + simple copy linenoise-ship.c to linenoise.c in your application, and also linenoise.h + + * If you want win32 support, also copy linenoise-win32.c + * If you never want to support utf-8, you can omit utf8.h and utf8.c + +To enable utf-8 support, define USE_UTF8 + +## Where do I get it? + +Get it here: [https://github.com/msteveb/linenoise](https://github.com/msteveb/linenoise) + +## Key bindings + +This version supports the following key bindings: + + ctrl-j, Enter Return the current line as the result + ctrl-a, Home Go to the start of the line + ctrl-e, End Go to the end of the line + ctrl-u Delete to beginning of line + ctrl-k Delete to end of line + ctrl-y Insert previously deleted chars at cursor + ctrl-l Clear screen + ctrl-c Quit + ctrl-z Exit to background (Unix only) + ctrl-h, Backspace Delete char to left of cursor + ctrl-d With empty line - return + ctrl-d, Del Delete char to right of cursor + meta-b Move word left + meta-f Move word right + ctrl-w Delete word to left + ctrl-t Transpose char and cursor and char to left of cursor, then move right + ctrl-v Insert next char as control character + ctrl-b, Left Move one char left + ctrl-f, Right Move one char right + ctrl-p, Up Move to previous history line + ctrl-n, Down Move to next history line + Page-Up Move to start of history + Page-Down Move to end of history + Tab Tab complete + ctrl-r Begin reverse incremental search + +In reverse incremental search: + + Normal char Add char to incremental search word + ctrl-h, Backspace Remove last char from incremental search word + ctrl-p, Up Move to previous match + ctrl-n, Down Move to next match + ctrl-g, ctrl-c Return to normal mode with empty line + Any other key Return to normal mode with the current line and process the key + +-------------------------------------------------------- + +## Original README below + +Can a line editing library be 20k lines of code? + A minimal, zero-config, BSD licensed, readline replacement. News: linenoise now includes minimal completion support, thanks to Pieter Noordhuis (@pnoordhuis). diff --git a/3rdparty/linenoise/example.c b/3rdparty/linenoise/example.c index f6ce462e6b1..29a95590b2f 100644 --- a/3rdparty/linenoise/example.c +++ b/3rdparty/linenoise/example.c @@ -5,50 +5,70 @@ #ifndef NO_COMPLETION void completion(const char *buf, linenoiseCompletions *lc, void *userdata) { + (void)userdata; if (buf[0] == 'h') { linenoiseAddCompletion(lc,"hello"); linenoiseAddCompletion(lc,"hello there"); } } + +char *hints(const char *buf, int *color, int *bold, void *userdata) { + (void)userdata; + if (!strcasecmp(buf,"hello")) { + *color = 35; + *bold = 0; + return " World"; + } + return NULL; +} #endif int main(int argc, char *argv[]) { + const char *prompt = "hello> "; char *line; -#ifdef HAVE_MULTILINE - /* Note: multiline support has not yet been integrated */ char *prgname = argv[0]; + const char *initial; /* Parse options, with --multiline we enable multi line editing. */ - while(argc > 1) { + while(argc > 1 && argv[1][0] == '-') { argc--; argv++; if (!strcmp(*argv,"--multiline")) { linenoiseSetMultiLine(1); printf("Multi-line mode enabled.\n"); + } else if (!strcmp(*argv,"--fancyprompt")) { + prompt = "\x1b[1;31m\xf0\xa0\x8a\x9d-\xc2\xb5hello>\x1b[0m "; + } else if (!strcmp(*argv,"--prompt") && argc > 1) { + argc--; + argv++; + prompt = *argv; } else { - fprintf(stderr, "Usage: %s [--multiline]\n", prgname); + fprintf(stderr, "Usage: %s [--multiline] [--fancyprompt] [--prompt text]\n", prgname); exit(1); } } -#endif #ifndef NO_COMPLETION /* Set the completion callback. This will be called every time the * user uses the key. */ linenoiseSetCompletionCallback(completion, NULL); + linenoiseSetHintsCallback(hints, NULL); #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 */ + initial = (argc > 1) ? argv[1] : ""; + /* 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) { + while((line = linenoiseWithInitial(prompt, initial)) != NULL) { + initial = ""; /* Do something with the string. */ if (line[0] != '\0' && line[0] != '/') { printf("echo: '%s'\n", line); diff --git a/3rdparty/linenoise/linenoise-win32.c b/3rdparty/linenoise/linenoise-win32.c new file mode 100644 index 00000000000..fed70b8b5f1 --- /dev/null +++ b/3rdparty/linenoise/linenoise-win32.c @@ -0,0 +1,377 @@ + +/* this code is not standalone + * it is included into linenoise.c + * for windows. + * It is deliberately kept separate so that + * applications that have no need for windows + * support can omit this + */ +static DWORD orig_consolemode = 0; + +static int flushOutput(struct current *current); +static void outputNewline(struct current *current); + +static void refreshStart(struct current *current) +{ + (void)current; +} + +static void refreshEnd(struct current *current) +{ + (void)current; +} + +static void refreshStartChars(struct current *current) +{ + assert(current->output == NULL); + /* We accumulate all output here */ + current->output = sb_alloc(); +#ifdef USE_UTF8 + current->ubuflen = 0; +#endif +} + +static void refreshNewline(struct current *current) +{ + DRL(""); + outputNewline(current); +} + +static void refreshEndChars(struct current *current) +{ + assert(current->output); + flushOutput(current); + sb_free(current->output); + current->output = NULL; +} + +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); + } +#ifdef USE_UTF8 + /* XXX is this the right thing to do? */ + SetConsoleCP(65001); +#endif + return 0; +} + +static void disableRawMode(struct current *current) +{ + SetConsoleMode(current->inh, orig_consolemode); +} + +void linenoiseClearScreen(void) +{ + /* XXX: This is ugly. Should just have the caller pass a handle */ + struct current current; + + current.outh = GetStdHandle(STD_OUTPUT_HANDLE); + + if (getWindowSize(¤t) == 0) { + 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; + DWORD n; + + pos.X = 0; + pos.Y = (SHORT)current->y; + + FillConsoleOutputAttribute(current->outh, + FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN, current->cols, pos, &n); + current->x = 0; +} + +#ifdef USE_UTF8 +static void flush_ubuf(struct current *current) +{ + COORD pos; + DWORD nwritten; + pos.Y = (SHORT)current->y; + pos.X = (SHORT)current->x; + SetConsoleCursorPosition(current->outh, pos); + WriteConsoleW(current->outh, current->ubuf, current->ubuflen, &nwritten, 0); + current->x += current->ubufcols; + current->ubuflen = 0; + current->ubufcols = 0; +} + +static void add_ubuf(struct current *current, int ch) +{ + /* This code originally by: Author: Mark E. Davis, 1994. */ + static const int halfShift = 10; /* used for shifting by 10 bits */ + + static const DWORD halfBase = 0x0010000UL; + static const DWORD halfMask = 0x3FFUL; + + #define UNI_SUR_HIGH_START 0xD800 + #define UNI_SUR_HIGH_END 0xDBFF + #define UNI_SUR_LOW_START 0xDC00 + #define UNI_SUR_LOW_END 0xDFFF + + #define UNI_MAX_BMP 0x0000FFFF + + if (ch > UNI_MAX_BMP) { + /* convert from unicode to utf16 surrogate pairs + * There is always space for one extra word in ubuf + */ + ch -= halfBase; + current->ubuf[current->ubuflen++] = (WORD)((ch >> halfShift) + UNI_SUR_HIGH_START); + current->ubuf[current->ubuflen++] = (WORD)((ch & halfMask) + UNI_SUR_LOW_START); + } + else { + current->ubuf[current->ubuflen++] = ch; + } + current->ubufcols += utf8_width(ch); + if (current->ubuflen >= UBUF_MAX_CHARS) { + flush_ubuf(current); + } +} +#endif + +static int flushOutput(struct current *current) +{ + const char *pt = sb_str(current->output); + int len = sb_len(current->output); + +#ifdef USE_UTF8 + /* convert utf8 in current->output into utf16 in current->ubuf + */ + while (len) { + int ch; + int n = utf8_tounicode(pt, &ch); + + pt += n; + len -= n; + + add_ubuf(current, ch); + } + flush_ubuf(current); +#else + DWORD nwritten; + COORD pos; + + pos.Y = (SHORT)current->y; + pos.X = (SHORT)current->x; + + SetConsoleCursorPosition(current->outh, pos); + WriteConsoleA(current->outh, pt, len, &nwritten, 0); + + current->x += len; +#endif + + sb_clear(current->output); + + return 0; +} + +static int outputChars(struct current *current, const char *buf, int len) +{ + if (len < 0) { + len = strlen(buf); + } + assert(current->output); + + sb_append_len(current->output, buf, len); + + return 0; +} + +static void outputNewline(struct current *current) +{ + /* On the last row output a newline to force a scroll */ + if (current->y + 1 == current->rows) { + outputChars(current, "\n", 1); + } + flushOutput(current); + current->x = 0; + current->y++; +} + +static void setOutputHighlight(struct current *current, const int *props, int nprops) +{ + int colour = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN; + int bold = 0; + int reverse = 0; + int i; + + for (i = 0; i < nprops; i++) { + switch (props[i]) { + case 0: + colour = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN; + bold = 0; + reverse = 0; + break; + case 1: + bold = FOREGROUND_INTENSITY; + break; + case 7: + reverse = 1; + break; + case 30: + colour = 0; + break; + case 31: + colour = FOREGROUND_RED; + break; + case 32: + colour = FOREGROUND_GREEN; + break; + case 33: + colour = FOREGROUND_RED | FOREGROUND_GREEN; + break; + case 34: + colour = FOREGROUND_BLUE; + break; + case 35: + colour = FOREGROUND_RED | FOREGROUND_BLUE; + break; + case 36: + colour = FOREGROUND_BLUE | FOREGROUND_GREEN; + break; + case 37: + colour = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN; + break; + } + } + + flushOutput(current); + + if (reverse) { + SetConsoleTextAttribute(current->outh, BACKGROUND_INTENSITY); + } + else { + SetConsoleTextAttribute(current->outh, colour | bold); + } +} + +static void eraseEol(struct current *current) +{ + COORD pos; + DWORD n; + + pos.X = (SHORT) current->x; + pos.Y = (SHORT) current->y; + + FillConsoleOutputCharacter(current->outh, ' ', current->cols - current->x, pos, &n); +} + +static void setCursorXY(struct current *current) +{ + COORD pos; + + pos.X = (SHORT) current->x; + pos.Y = (SHORT) current->y; + + SetConsoleCursorPosition(current->outh, pos); +} + + +static void setCursorPos(struct current *current, int x) +{ + current->x = x; + setCursorXY(current); +} + +static void cursorUp(struct current *current, int n) +{ + current->y -= n; + setCursorXY(current); +} + +static void cursorDown(struct current *current, int n) +{ + current->y += n; + setCursorXY(current); +} + +static int fd_read(struct current *current) +{ + while (1) { + INPUT_RECORD irec; + DWORD n; + if (WaitForSingleObject(current->inh, INFINITE) != WAIT_OBJECT_0) { + break; + } + if (!ReadConsoleInputW(current->inh, &irec, 1, &n)) { + break; + } + if (irec.EventType == KEY_EVENT) { + KEY_EVENT_RECORD *k = &irec.Event.KeyEvent; + if (k->bKeyDown || k->wVirtualKeyCode == VK_MENU) { + 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 { + return k->uChar.UnicodeChar; + } + } + } + } + return -1; +} + +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; +} diff --git a/3rdparty/linenoise/linenoise.c b/3rdparty/linenoise/linenoise.c index ee1b391df58..16bce73db9d 100644 --- a/3rdparty/linenoise/linenoise.c +++ b/3rdparty/linenoise/linenoise.c @@ -57,14 +57,12 @@ * 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 + * Sequence: ESC [ 0 K + * Effect: clear from cursor to end of line * * CUF (CUrsor Forward) * Sequence: ESC [ n C - * Effect: moves cursor forward of n chars + * Effect: moves cursor forward n chars * * CR (Carriage Return) * Sequence: \r @@ -95,6 +93,15 @@ * Sequence: ESC [ 6 n * Effect: reports current cursor position as ESC [ NNN ; MMM R * + * == Only used in multiline mode == + * CUU (Cursor Up) + * Sequence: ESC [ n A + * Effect: moves cursor up n chars. + * + * CUD (Cursor Down) + * Sequence: ESC [ n B + * Effect: moves cursor down n chars. + * * win32/console * ------------- * If __MINGW32__ is defined, the win32 console API is used. @@ -108,10 +115,6 @@ #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 @@ -127,22 +130,38 @@ #include #include #include +#include #include #include +#include #include #include +#if defined(_WIN32) && !defined(__MINGW32__) +/* Microsoft headers don't like old POSIX names */ +#define strdup _strdup +#define snprintf _snprintf +#endif + #include "linenoise.h" +#ifndef STRINGBUF_H +#include "stringbuf.h" +#endif +#ifndef UTF8_UTIL_H #include "utf8.h" +#endif -#define LINENOISE_DEFAULT_HISTORY_MAX_LEN 200 -#define LINENOISE_MAX_LINE 4096 +#define LINENOISE_DEFAULT_HISTORY_MAX_LEN 100 +/* ctrl('A') -> 0x01 */ #define ctrl(C) ((C) - '@') +/* meta('a') -> 0xe1 */ +#define meta(C) ((C) | 0x80) /* Use -ve numbers here to co-exist with normal unicode chars */ enum { SPECIAL_NONE, + /* don't use -1 here since that indicates error */ SPECIAL_UP = -20, SPECIAL_DOWN = -21, SPECIAL_LEFT = -22, @@ -152,26 +171,29 @@ enum { SPECIAL_END = -26, SPECIAL_INSERT = -27, SPECIAL_PAGE_UP = -28, - SPECIAL_PAGE_DOWN = -29 + SPECIAL_PAGE_DOWN = -29, + + /* Some handy names for other special keycodes */ + CHAR_ESCAPE = 27, + CHAR_DELETE = 127, }; static int history_max_len = LINENOISE_DEFAULT_HISTORY_MAX_LEN; static int history_len = 0; static char **history = NULL; -static char preload_buf[LINENOISE_MAX_LINE]; -static int preload = 0; -static int refresh = 0; /* 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) */ + stringbuf *buf; /* Current buffer. Always null terminated */ int pos; /* Cursor position, measured in chars */ int cols; /* Size of the window, in chars */ + int nrows; /* How many rows are being used in multiline mode (>= 1) */ + int rpos; /* The current row containing the cursor - multiline mode only */ + int colsright; /* refreshLine() cached cols for insert_char() optimisation */ + int colsleft; /* refreshLine() cached cols for remove_char() optimisation */ const char *prompt; - char *capture; /* Allocated capture buffer, or NULL for none. Always null terminated */ + stringbuf *capture; /* capture buffer, or NULL for none. Always null terminated */ + stringbuf *output; /* used only during refreshLine() - output accumulator */ #if defined(USE_TERMIOS) int fd; /* Terminal fd */ #elif defined(USE_WINCONSOLE) @@ -180,12 +202,35 @@ struct current { int rows; /* Screen rows */ int x; /* Current column during output */ int y; /* Current row */ +#ifdef USE_UTF8 + #define UBUF_MAX_CHARS 132 + WORD ubuf[UBUF_MAX_CHARS + 1]; /* Accumulates utf16 output - one extra for final surrogate pairs */ + int ubuflen; /* length used in ubuf */ + int ubufcols; /* how many columns are represented by the chars in ubuf? */ +#endif #endif }; static int fd_read(struct current *current); static int getWindowSize(struct current *current); -static void refreshLine(const char *prompt, struct current *current); +static void cursorDown(struct current *current, int n); +static void cursorUp(struct current *current, int n); +static void eraseEol(struct current *current); +static void refreshLine(struct current *current); +static void refreshLineAlt(struct current *current, const char *prompt, const char *buf, int cursor_pos); +static void setCursorPos(struct current *current, int x); +static void setOutputHighlight(struct current *current, const int *props, int nprops); +static void set_current(struct current *current, const char *str); + +static int fd_isatty(struct current *current) +{ +#ifdef USE_TERMIOS + return isatty(current->fd); +#else + (void)current; + return 0; +#endif +} void linenoiseHistoryFree(void) { if (history) { @@ -199,52 +244,131 @@ void linenoiseHistoryFree(void) { } } -static int checkForColor(const char *buf, int *colors, int *size) -{ - /* ANSI color control sequences have the form: - * "\x1b" "[" [0-9;]* "m" - * We parse them with a simple state machine. - */ +typedef enum { + EP_START, /* looking for ESC */ + EP_ESC, /* looking for [ */ + EP_DIGITS, /* parsing digits */ + EP_PROPS, /* parsing digits or semicolons */ + EP_END, /* ok */ + EP_ERROR, /* error */ +} ep_state_t; + +struct esc_parser { + ep_state_t state; + int props[5]; /* properties are stored here */ + int maxprops; /* size of the props[] array */ + int numprops; /* number of properties found */ + int termchar; /* terminator char, or 0 for any alpha */ + int current; /* current (partial) property value */ +}; - int len = 1, attrnum = 0, color = 0; - char ch; - if(!*buf || (*buf++ != '[')) - return 0; +/** + * Initialise the escape sequence parser at *parser. + * + * If termchar is 0 any alpha char terminates ok. Otherwise only the given + * char terminates successfully. + * Run the parser state machine with calls to parseEscapeSequence() for each char. + */ +static void initParseEscapeSeq(struct esc_parser *parser, int termchar) +{ + parser->state = EP_START; + parser->maxprops = sizeof(parser->props) / sizeof(*parser->props); + parser->numprops = 0; + parser->current = 0; + parser->termchar = termchar; +} - /* 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 = *buf++) != 0) { - len++; - if ((ch >= '0' && ch <= '9')) { - color *= 10; - color += ch - '0'; - } - else if (ch == ';') { - if (attrnum < *size) { - colors[attrnum] = color; - attrnum++; +/** + * Pass character 'ch' into the state machine to parse: + * 'ESC' '[' (';' )* + * + * The first character must be ESC. + * Returns the current state. The state machine is done when it returns either EP_END + * or EP_ERROR. + * + * On EP_END, the "property/attribute" values can be read from parser->props[] + * of length parser->numprops. + */ +static int parseEscapeSequence(struct esc_parser *parser, int ch) +{ + switch (parser->state) { + case EP_START: + parser->state = (ch == '\x1b') ? EP_ESC : EP_ERROR; + break; + case EP_ESC: + parser->state = (ch == '[') ? EP_DIGITS : EP_ERROR; + break; + case EP_PROPS: + if (ch == ';') { + parser->state = EP_DIGITS; +donedigits: + if (parser->numprops + 1 < parser->maxprops) { + parser->props[parser->numprops++] = parser->current; + parser->current = 0; + } + break; } - color = 0; - } - else if (ch == 'm') { - if (attrnum < *size) { - colors[attrnum] = color; - attrnum++; + /* fall through */ + case EP_DIGITS: + if (ch >= '0' && ch <= '9') { + parser->current = parser->current * 10 + (ch - '0'); + parser->state = EP_PROPS; + break; + } + /* must be terminator */ + if (parser->termchar != ch) { + if (parser->termchar != 0 || !((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'))) { + parser->state = EP_ERROR; + break; + } } + parser->state = EP_END; + goto donedigits; + case EP_END: + parser->state = EP_ERROR; break; - } - else { - len = 0; + case EP_ERROR: break; - } } - if(!ch) - return 0; - *size = attrnum; - return len; + return parser->state; +} + +/*#define DEBUG_REFRESHLINE*/ + +#ifdef DEBUG_REFRESHLINE +#define DRL(ARGS...) fprintf(dfh, ARGS) +static FILE *dfh; + +static void DRL_CHAR(int ch) +{ + if (ch < ' ') { + DRL("^%c", ch + '@'); + } + else if (ch > 127) { + DRL("\\u%04x", ch); + } + else { + DRL("%c", ch); + } +} +static void DRL_STR(const char *str) +{ + while (*str) { + int ch; + int n = utf8_tounicode(str, &ch); + str += n; + DRL_CHAR(ch); + } } +#else +#define DRL(...) +#define DRL_CHAR(ch) +#define DRL_STR(str) +#endif + +#if defined(USE_WINCONSOLE) +#include "linenoise-win32.c" +#endif #if defined(USE_TERMIOS) static void linenoiseAtExit(void); @@ -252,7 +376,7 @@ 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 const char *unsupported_term[] = {"dumb","cons25","emacs",NULL}; static int isUnsupportedTerm(void) { char *term = getenv("TERM"); @@ -329,10 +453,25 @@ static void linenoiseAtExit(void) { */ #define IGNORE_RC(EXPR) if (EXPR) {} -/* This is fdprintf() on some systems, but use a different - * name to avoid conflicts +/** + * Output bytes directly, or accumulate output (if current->output is set) + */ +static void outputChars(struct current *current, const char *buf, int len) +{ + if (len < 0) { + len = strlen(buf); + } + if (current->output) { + sb_append_len(current->output, buf, len); + } + else { + IGNORE_RC(write(current->fd, buf, len)); + } +} + +/* Like outputChars, but using printf-style formatting */ -static void fd_printf(int fd, const char *format, ...) +static void outputFormatted(struct current *current, const char *format, ...) { va_list args; char buf[64]; @@ -340,33 +479,29 @@ static void fd_printf(int fd, const char *format, ...) va_start(args, format); n = vsnprintf(buf, sizeof(buf), format, args); + /* This will never happen because we are sure to use outputFormatted() only for short sequences */ + assert(n < (int)sizeof(buf)); va_end(args); - IGNORE_RC(write(fd, buf, n)); -} - -void linenoiseClearScreen(void) -{ - fd_printf(STDOUT_FILENO, "\x1b[H\x1b[2J"); + outputChars(current, buf, n); } static void cursorToLeft(struct current *current) { - fd_printf(current->fd, "\r"); + outputChars(current, "\r", -1); } -static int outputChars(struct current *current, const char *buf, int len) +static void setOutputHighlight(struct current *current, const int *props, int nprops) { - return write(current->fd, buf, len); -} - -static void outputControlChar(struct current *current, char ch) -{ - fd_printf(current->fd, "\x1b[7m^%c\x1b[0m", ch); + outputChars(current, "\x1b[", -1); + while (nprops--) { + outputFormatted(current, "%d%c", *props, (nprops == 0) ? 'm' : ';'); + props++; + } } static void eraseEol(struct current *current) { - fd_printf(current->fd, "\x1b[0K"); + outputChars(current, "\x1b[0K", -1); } static void setCursorPos(struct current *current, int x) @@ -375,10 +510,29 @@ static void setCursorPos(struct current *current, int x) cursorToLeft(current); } else { - fd_printf(current->fd, "\r\x1b[%dC", x); + outputFormatted(current, "\r\x1b[%dC", x); + } +} + +static void cursorUp(struct current *current, int n) +{ + if (n) { + outputFormatted(current, "\x1b[%dA", n); + } +} + +static void cursorDown(struct current *current, int n) +{ + if (n) { + outputFormatted(current, "\x1b[%dB", n); } } +void linenoiseClearScreen(void) +{ + IGNORE_RC(write(STDOUT_FILENO, "\x1b[H\x1b[2J", 7)); +} + /** * Reads a char from 'fd', waiting at most 'timeout' milliseconds. * @@ -410,25 +564,8 @@ static int fd_read_char(int fd, int timeout) */ static int fd_read(struct current *current) { - struct pollfd p; - int ret; - p.fd = current->fd; - p.events = POLLIN; - while(1) { - ret = poll(&p, 1, 100); - if (ret == -1) - return -1; - else if (!ret) { - if (!refresh) - continue; - refresh = 0; - refreshLine(current->prompt, current); - } - else - break; - } #ifdef USE_UTF8 - char buf[4]; + char buf[MAX_UTF8_LEN]; int n; int i; int c; @@ -437,7 +574,7 @@ static int fd_read(struct current *current) return -1; } n = utf8_charlen(buf[0]); - if (n < 1 || n > 3) { + if (n < 1) { return -1; } for (i = 1; i < n; i++) { @@ -445,7 +582,6 @@ static int fd_read(struct current *current) return -1; } } - buf[n] = 0; /* decode and return the character */ utf8_tounicode(buf, &c); return c; @@ -454,43 +590,40 @@ static int fd_read(struct current *current) #endif } + /** * 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) +static int queryCursor(struct current *current, int* cols) { + struct esc_parser parser; + int ch; + + /* Should not be buffering this output, it needs to go immediately */ + assert(current->output == NULL); + /* control sequence - report cursor location */ - fd_printf(fd, "\x1b[6n"); + outputChars(current, "\x1b[6n", -1); /* 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; + initParseEscapeSeq(&parser, 'R'); + while ((ch = fd_read_char(current->fd, 100)) > 0) { + switch (parseEscapeSequence(&parser, ch)) { + default: + continue; + case EP_END: + if (parser.numprops == 2 && parser.props[1] < 1000) { + *cols = parser.props[1]; + return 1; } break; - } - else if (ch >= 0 && ch <= '9') { - n = n * 10 + ch - '0'; - } - else { + case EP_ERROR: break; - } } - return 1; + /* failed */ + break; } - return 0; } @@ -522,46 +655,40 @@ static int getWindowSize(struct current *current) */ if (current->cols == 0) { - int here = 0; + int here; + /* If anything fails => default 80 */ current->cols = 80; /* (a) */ - if (queryCursor (current->fd, &here)) { + if (queryCursor (current, &here)) { /* (b) */ - fd_printf(current->fd, "\x1b[999C"); + setCursorPos(current, 999); /* (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, ¤t->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 { + if (queryCursor (current, ¤t->cols)) { /* (d) Reset the cursor back to the original location. */ if (current->cols > here) { - fd_printf(current->fd, "\x1b[%dD", current->cols - here); + setCursorPos(current, here); } } - } /* 1st query failed, doing nothing => default 80 */ + } } return 0; } /** - * If escape (27) was received, reads subsequent + * If CHAR_ESCAPE 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. + * CHAR_ESCAPE is returned. */ static int check_special(int fd) { @@ -569,7 +696,11 @@ static int check_special(int fd) int c2; if (c < 0) { - return 27; + return CHAR_ESCAPE; + } + else if (c >= 'a' && c <= 'z') { + /* esc-a => meta-a */ + return meta(c); } c2 = fd_read_char(fd, 50); @@ -620,444 +751,545 @@ static int check_special(int fd) 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); +#endif - 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 clearOutputHighlight(struct current *current) +{ + int nohighlight = 0; + setOutputHighlight(current, &nohighlight, 1); } -static void disableRawMode(struct current *current) +static void outputControlChar(struct current *current, char ch) { - SetConsoleMode(current->inh, orig_consolemode); + int reverse = 7; + setOutputHighlight(current, &reverse, 1); + outputChars(current, "^", 1); + outputChars(current, &ch, 1); + clearOutputHighlight(current); } -void linenoiseClearScreen(void) +#ifndef utf8_getchars +static int utf8_getchars(char *buf, int c) { - /* XXX: This is ugly. Should just have the caller pass a handle */ - struct current current; - - current.outh = GetStdHandle(STD_OUTPUT_HANDLE); - - if (getWindowSize(¤t) == 0) { - COORD topleft = { 0, 0 }; - DWORD n; +#ifdef USE_UTF8 + return utf8_fromunicode(buf, c); +#else + *buf = c; + return 1; +#endif +} +#endif - 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); +/** + * 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 < sb_chars(current->buf)) { + int c; + int i = utf8_index(sb_str(current->buf), pos); + (void)utf8_tounicode(sb_str(current->buf) + i, &c); + return c; } + return -1; } -static void cursorToLeft(struct current *current) +static int char_display_width(int ch) { - COORD pos; - DWORD n; + if (ch < ' ') { + /* control chars take two positions */ + return 2; + } + else { + return utf8_width(ch); + } +} - pos.X = 0; - pos.Y = (SHORT)current->y; +#ifndef NO_COMPLETION +static linenoiseCompletionCallback *completionCallback = NULL; +static void *completionUserdata = NULL; +static int showhints = 1; +static linenoiseHintsCallback *hintsCallback = NULL; +static linenoiseFreeHintsCallback *freeHintsCallback = NULL; +static void *hintsUserdata = NULL; - FillConsoleOutputAttribute(current->outh, - FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN, current->cols, pos, &n); - current->x = 0; +static void beep() { +#ifdef USE_TERMIOS + fprintf(stderr, "\x7"); + fflush(stderr); +#endif } -static int outputChars(struct current *current, const char *buf, int len) -{ - COORD pos; - DWORD n; - unsigned short color = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN; +static void freeCompletions(linenoiseCompletions *lc) { + size_t i; + for (i = 0; i < lc->len; i++) + free(lc->cvec[i]); + free(lc->cvec); +} - pos.Y = (SHORT)current->y; +static int completeLine(struct current *current) { + linenoiseCompletions lc = { 0, NULL }; + int c = 0; -#ifdef USE_UTF8 - while ( len > 0 ) { - int c, s; - wchar_t wc; - - if(buf[0] == '\x1b') - { - int count, size = 5, colors[5]; - unsigned short intens = 0; - if((count = checkForColor(buf + 1, colors, &size))) - { - int i; - for(i = 0; i < size; i++) { - switch(colors[i]) { - case 0: - color = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN; - intens = 0; - break; - - case 1: // BOLD - case 5: // BLINK - intens = FOREGROUND_INTENSITY; - break; - - case 30: - color = BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_GREEN; - break; - - case 31: - color = FOREGROUND_RED; - break; - - case 32: - color = FOREGROUND_GREEN; - break; - - case 33: - color = FOREGROUND_RED | FOREGROUND_GREEN; - break; - - case 34: - color = FOREGROUND_BLUE; - break; - - case 35: - color = FOREGROUND_BLUE | FOREGROUND_RED; - break; - - case 36: - color = FOREGROUND_BLUE | FOREGROUND_GREEN; - break; - - case 37: - color = FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE; - break; + completionCallback(sb_str(current->buf),&lc,completionUserdata); + if (lc.len == 0) { + beep(); + } else { + size_t stop = 0, i = 0; + + while(!stop) { + /* Show completion or original buffer */ + if (i < lc.len) { + int chars = utf8_strlen(lc.cvec[i], -1); + refreshLineAlt(current, current->prompt, lc.cvec[i], chars); + } else { + refreshLine(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 CHAR_ESCAPE: /* escape */ + /* Re-show original buffer */ + if (i < lc.len) { + refreshLine(current); } - } - color |= intens; - buf += count + 1; - len -= count + 1; - continue; + stop = 1; + break; + default: + /* Update buffer and return */ + if (i < lc.len) { + set_current(current,lc.cvec[i]); + } + stop = 1; + break; } } + } - s = utf8_tounicode(buf, &c); + freeCompletions(&lc); + return c; /* Return last read character */ +} - len -= s; - buf += s; - - wc = (wchar_t)c; +/* 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, void *userdata) { + linenoiseCompletionCallback * old = completionCallback; + completionCallback = fn; + completionUserdata = userdata; + return old; +} - pos.X = (SHORT)current->x; +void linenoiseAddCompletion(linenoiseCompletions *lc, const char *str) { + lc->cvec = (char **)realloc(lc->cvec,sizeof(char*)*(lc->len+1)); + lc->cvec[lc->len++] = strdup(str); +} - /* fixed display utf8 character */ - WriteConsoleOutputCharacterW(current->outh, &wc, 1, pos, &n); - WriteConsoleOutputAttribute(current->outh, &color, 1, pos, &n); +void linenoiseSetHintsCallback(linenoiseHintsCallback *callback, void *userdata) +{ + hintsCallback = callback; + hintsUserdata = userdata; +} - current->x += utf8_width(c); - } -#else - pos.X = (SHORT)current->x; +void linenoiseSetFreeHintsCallback(linenoiseFreeHintsCallback *callback) +{ + freeHintsCallback = callback; +} - WriteConsoleOutputCharacterA(current->outh, buf, len, pos, &n); - current->x += len; #endif - return 0; -} -static void outputControlChar(struct current *current, char ch) +static const char *reduceSingleBuf(const char *buf, int availcols, int *cursor_pos) { - COORD pos; - DWORD n; + /* We have availcols columns available. + * If necessary, strip chars off the front of buf until *cursor_pos + * fits within availcols + */ + int needcols = 0; + int pos = 0; + int new_cursor_pos = *cursor_pos; + const char *pt = buf; - pos.X = (SHORT) current->x; - pos.Y = (SHORT) current->y; + DRL("reduceSingleBuf: availcols=%d, cursor_pos=%d\n", availcols, *cursor_pos); - FillConsoleOutputAttribute(current->outh, BACKGROUND_INTENSITY, 2, pos, &n); - outputChars(current, "^", 1); - outputChars(current, &ch, 1); -} + while (*pt) { + int ch; + int n = utf8_tounicode(pt, &ch); + pt += n; + + needcols += char_display_width(ch); + + /* If we need too many cols, strip + * chars off the front of buf to make it fit. + * We keep 3 extra cols to the right of the cursor. + * 2 for possible wide chars, 1 for the last column that + * can't be used. + */ + while (needcols >= availcols - 3) { + n = utf8_tounicode(buf, &ch); + buf += n; + needcols -= char_display_width(ch); + DRL_CHAR(ch); + + /* and adjust the apparent cursor position */ + new_cursor_pos--; + + if (buf == pt) { + /* can't remove more than this */ + break; + } + } -static void eraseEol(struct current *current) -{ - COORD pos; - DWORD n; + if (pos++ == *cursor_pos) { + break; + } - pos.X = (SHORT) current->x; - pos.Y = (SHORT) current->y; + } + DRL(""); + DRL_STR(buf); + DRL("\nafter reduce, needcols=%d, new_cursor_pos=%d\n", needcols, new_cursor_pos); - FillConsoleOutputCharacter(current->outh, ' ', current->cols - current->x, pos, &n); + /* Done, now new_cursor_pos contains the adjusted cursor position + * and buf points to he adjusted start + */ + *cursor_pos = new_cursor_pos; + return buf; } -static void setCursorPos(struct current *current, int x) -{ - COORD pos; - - pos.X = (SHORT)x; - pos.Y = (SHORT) current->y; +static int mlmode = 0; - SetConsoleCursorPosition(current->outh, pos); - current->x = x; +void linenoiseSetMultiLine(int enableml) +{ + mlmode = enableml; } -static int fd_read(struct current *current) +/* Helper of refreshSingleLine() and refreshMultiLine() to show hints + * to the right of the prompt. + * Returns 1 if a hint was shown, or 0 if not + * If 'display' is 0, does no output. Just returns the appropriate return code. + */ +static int refreshShowHints(struct current *current, const char *buf, int availcols, int display) { - while (1) { - INPUT_RECORD irec; - DWORD n; - DWORD ret = WaitForSingleObject(current->inh, 100); - if (ret == WAIT_TIMEOUT) { - if (!refresh) - continue; - refresh = 0; - refreshLine(current->prompt, current); - continue; - } - else if (ret != 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; - case VK_RETURN: -#ifdef USE_UTF8 - return k->uChar.UnicodeChar; -#else - return k->uChar.AsciiChar; -#endif + int rc = 0; + if (showhints && hintsCallback && availcols > 0) { + int bold = 0; + int color = -1; + char *hint = hintsCallback(buf, &color, &bold, hintsUserdata); + if (hint) { + rc = 1; + if (display) { + const char *pt; + if (bold == 1 && color == -1) color = 37; + if (bold || color > 0) { + int props[3] = { bold, color, 49 }; /* bold, color, fgnormal */ + setOutputHighlight(current, props, 3); } - } - /* 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 + DRL("", bold, color); + pt = hint; + while (*pt) { + int ch; + int n = utf8_tounicode(pt, &ch); + int width = char_display_width(ch); + + if (width >= availcols) { + DRL(""); + break; + } + DRL_CHAR(ch); + + availcols -= width; + outputChars(current, pt, n); + pt += n; + } + if (bold || color > 0) { + clearOutputHighlight(current); + } + /* Call the function to free the hint returned. */ + if (freeHintsCallback) freeHintsCallback(hint, hintsUserdata); } } } - return -1; + return rc; } -static int getWindowSize(struct current *current) +#ifdef USE_TERMIOS +static void refreshStart(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; + /* We accumulate all output here */ + assert(current->output == NULL); + current->output = sb_alloc(); } -#endif -static int countColorControlChars(const char* prompt) +static void refreshEnd(struct current *current) { - char ch; - int found = 0, len, size = 0; - while ((ch = *prompt) != 0) { - if(ch == '\x1b') { - len = checkForColor(++prompt, NULL, &size); - prompt += len; - found += len + 1; - } - else - prompt++; - } - return found; + /* Output everything at once */ + IGNORE_RC(write(current->fd, sb_str(current->output), sb_len(current->output))); + sb_free(current->output); + current->output = NULL; } -static int utf8_getchars(char *buf, int c) +static void refreshStartChars(struct current *current) { -#ifdef USE_UTF8 - return utf8_fromunicode(buf, c); -#else - *buf = c; - return 1; -#endif + (void)current; } -/** - * Returns the unicode character at the given offset, - * or -1 if none. - */ -static int get_char(struct current *current, int pos) +static void refreshNewline(struct current *current) { - 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; + DRL(""); + outputChars(current, "\n", 1); } -static void refreshLine(const char *prompt, struct current *current) +static void refreshEndChars(struct current *current) +{ + (void)current; +} +#endif + +static void refreshLineAlt(struct current *current, const char *prompt, const char *buf, int cursor_pos) { - 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; - int width; - int bufwidth; + const char *pt; + int displaycol; + int displayrow; + int visible; + int currentpos; + int notecursor; + int cursorcol = 0; + int cursorrow = 0; + int hint; + struct esc_parser parser; + +#ifdef DEBUG_REFRESHLINE + dfh = fopen("linenoise.debuglog", "a"); +#endif /* Should intercept SIGWINCH. For now, just get the size every time */ getWindowSize(current); - plen = strlen(prompt); - pchars = utf8_strwidth(prompt, utf8_strlen(prompt, plen)); + refreshStart(current); - /* Scan the prompt for embedded ansi color control sequences and - * discount them as characters/columns. - */ - pchars -= countColorControlChars(prompt); + DRL("wincols=%d, cursor_pos=%d, nrows=%d, rpos=%d\n", current->cols, cursor_pos, current->nrows, current->rpos); - /* Account for a line which is too long to fit in the window. - * Note that control chars require an extra column + /* Here is the plan: + * (a) move the the bottom row, going down the appropriate number of lines + * (b) move to beginning of line and erase the current line + * (c) go up one line and do the same, until we have erased up to the first row + * (d) output the prompt, counting cols and rows, taking into account escape sequences + * (e) output the buffer, counting cols and rows + * (e') when we hit the current pos, save the cursor position + * (f) move the cursor to the saved cursor position + * (g) save the current cursor row and number of rows */ - /* How many cols are required to the left of 'pos'? - * The prompt, plus one extra for each control char - */ - n = pchars + utf8_strwidth(buf, utf8_strlen(buf, current->len)); - b = 0; - for (i = 0; i < pos; i++) { - b += utf8_tounicode(buf + b, &ch); - if (ch < ' ') { - n++; + /* (a) - The cursor is currently at row rpos */ + cursorDown(current, current->nrows - current->rpos - 1); + DRL("", current->nrows - current->rpos - 1); + + /* (b), (c) - Erase lines upwards until we get to the first row */ + for (i = 0; i < current->nrows; i++) { + if (i) { + DRL(""); + cursorUp(current, 1); } + DRL(""); + cursorToLeft(current); + eraseEol(current); } + DRL("\n"); - /* Pluse one if the current char is a control character */ - if (current->pos < current->chars && get_char(current, current->pos) < ' ') { - n++; - } + /* (d) First output the prompt. control sequences don't take up display space */ + pt = prompt; + displaycol = 0; /* current display column */ + displayrow = 0; /* current display row */ + visible = 1; - /* 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. - */ - while (n >= current->cols && pos > 0) { - b = utf8_tounicode(buf, &ch); - if (ch < ' ') { - n--; + refreshStartChars(current); + + while (*pt) { + int width; + int ch; + int n = utf8_tounicode(pt, &ch); + + if (visible && ch == CHAR_ESCAPE) { + /* The start of an escape sequence, so not visible */ + visible = 0; + initParseEscapeSeq(&parser, 'm'); + DRL(""); + } + + if (ch == '\n' || ch == '\r') { + /* treat both CR and NL the same and force wrap */ + refreshNewline(current); + displaycol = 0; + displayrow++; + } + else { + width = visible * utf8_width(ch); + + displaycol += width; + if (displaycol >= current->cols) { + /* need to wrap to the next line because of newline or if it doesn't fit + * XXX this is a problem in single line mode + */ + refreshNewline(current); + displaycol = width; + displayrow++; + } + + DRL_CHAR(ch); +#ifdef USE_WINCONSOLE + if (visible) { + outputChars(current, pt, n); + } +#else + outputChars(current, pt, n); +#endif + } + pt += n; + + if (!visible) { + switch (parseEscapeSequence(&parser, ch)) { + case EP_END: + visible = 1; + setOutputHighlight(current, parser.props, parser.numprops); + DRL("", parser.numprops); + break; + case EP_ERROR: + DRL(""); + visible = 1; + break; + } } - n -= utf8_width(ch); - buf += b; - pos--; - chars--; } - /* Cursor to left edge, then the prompt */ - cursorToLeft(current); - outputChars(current, prompt, plen); + /* Now we are at the first line with all lines erased */ + DRL("\nafter prompt: displaycol=%d, displayrow=%d\n", displaycol, displayrow); - /* 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 */ - width = 0; /* current display width */ - bufwidth = utf8_strwidth(buf, pos); + /* (e) output the buffer, counting cols and rows */ + if (mlmode == 0) { + /* In this mode we may need to trim chars from the start of the buffer until the + * cursor fits in the window. + */ + pt = reduceSingleBuf(buf, current->cols - displaycol, &cursor_pos); + } + else { + pt = buf; + } - for (i = 0; i < chars; i++) { + currentpos = 0; + notecursor = -1; + + while (*pt) { int ch; - int w = utf8_tounicode(buf + b, &ch); - if (ch < ' ') { - n++; + int n = utf8_tounicode(pt, &ch); + int width = char_display_width(ch); + + if (currentpos == cursor_pos) { + /* (e') wherever we output this character is where we want the cursor */ + notecursor = 1; } - width += utf8_width(ch); + if (displaycol + width >= current->cols) { + if (mlmode == 0) { + /* In single line mode stop once we print as much as we can on one line */ + DRL(""); + break; + } + /* need to wrap to the next line since it doesn't fit */ + refreshNewline(current); + displaycol = 0; + displayrow++; + } - if (pchars + width + n >= current->cols) { - break; + if (notecursor == 1) { + /* (e') Save this position as the current cursor position */ + cursorcol = displaycol; + cursorrow = displayrow; + notecursor = 0; + DRL(""); } + + displaycol += width; + 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, pt, n); } + DRL_CHAR(ch); + if (width != 1) { + DRL("", width); + } + + pt += n; + currentpos++; + } + + /* If we didn't see the cursor, it is at the current location */ + if (notecursor) { + DRL(""); + cursorcol = displaycol; + cursorrow = displayrow; + } + + DRL("\nafter buf: displaycol=%d, displayrow=%d, cursorcol=%d, cursorrow=%d\n", displaycol, displayrow, cursorcol, cursorrow); + + /* (f) show hints */ + hint = refreshShowHints(current, buf, current->cols - displaycol, 1); + + /* Remember how many many cols are available for insert optimisation */ + if (prompt == current->prompt && hint == 0) { + current->colsright = current->cols - displaycol; + current->colsleft = displaycol; + } + else { + /* Can't optimise */ + current->colsright = 0; + current->colsleft = 0; + } + DRL("\nafter hints: colsleft=%d, colsright=%d\n\n", current->colsleft, current->colsright); + + refreshEndChars(current); + + /* (g) move the cursor to the correct place */ + cursorUp(current, displayrow - cursorrow); + setCursorPos(current, cursorcol); + + /* (h) Update the number of rows if larger, but never reduce this */ + if (displayrow >= current->nrows) { + current->nrows = displayrow + 1; } - outputChars(current, buf, b); + /* And remember the row that the cursor is on */ + current->rpos = cursorrow; - /* Erase to right, move cursor to original position */ - eraseEol(current); - setCursorPos(current, bufwidth + pchars + backup); + refreshEnd(current); + +#ifdef DEBUG_REFRESHLINE + fclose(dfh); +#endif } -static void set_current(struct current *current, const char *str) +static void refreshLine(struct current *current) { - 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); + refreshLineAlt(current, current->prompt, sb_str(current->buf), current->pos); } -static int has_room(struct current *current, int bytes) +static void set_current(struct current *current, const char *str) { - return current->len + bytes < current->bufmax - 1; + sb_clear(current->buf); + sb_append(current->buf, str); + current->pos = sb_chars(current->buf); } /** @@ -1068,31 +1300,52 @@ static int has_room(struct current *current, int bytes) */ 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 (pos >= 0 && pos < sb_chars(current->buf)) { + int offset = utf8_index(sb_str(current->buf), pos); + int nbytes = utf8_index(sb_str(current->buf) + offset, 1); + int rc = 1; + + /* Now we try to optimise in the simple but very common case that: + * - outputChars() can be used directly (not win32) + * - we are removing the char at EOL + * - the buffer is not empty + * - there are columns available to the left + * - the char being deleted is not a wide or utf-8 character + * - no hints are being shown + */ + if (current->output && current->pos == pos + 1 && current->pos == sb_chars(current->buf) && pos > 0) { +#ifdef USE_UTF8 + /* Could implement utf8_prev_len() but simplest just to not optimise this case */ + char last = sb_str(current->buf)[offset]; +#else + char last = 0; +#endif + if (current->colsleft > 0 && (last & 0x80) == 0) { + /* Have cols on the left and not a UTF-8 char or continuation */ + /* Yes, can optimise */ + current->colsleft--; + current->colsright++; + rc = 2; } } -#endif - /* Move the null char too */ - memmove(current->buf + p1, current->buf + p2, current->len - p2 + 1); - current->len -= (p2 - p1); - current->chars--; + sb_delete(current->buf, offset, nbytes); if (current->pos > pos) { current->pos--; } - return ret; + if (rc == 2) { + if (refreshShowHints(current, sb_str(current->buf), current->colsright, 0)) { + /* A hint needs to be shown, so can't optimise after all */ + rc = 1; + } + else { + /* optimised output */ + outputChars(current, "\b \b", 3); + } + } + return rc; + return 1; } return 0; } @@ -1105,34 +1358,45 @@ static int remove_char(struct current *current, int pos) */ 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; + if (pos >= 0 && pos <= sb_chars(current->buf)) { + char buf[MAX_UTF8_LEN + 1]; + int offset = utf8_index(sb_str(current->buf), pos); + int n = utf8_getchars(buf, ch); + int rc = 1; + + /* null terminate since sb_insert() requires it */ + buf[n] = 0; + + /* Now we try to optimise in the simple but very common case that: + * - outputChars() can be used directly (not win32) + * - we are inserting at EOL + * - there are enough columns available + * - no hints are being shown + */ + if (current->output && pos == current->pos && pos == sb_chars(current->buf)) { + int width = char_display_width(ch); + if (current->colsright > width) { + /* Yes, can optimise */ + current->colsright -= width; + current->colsleft -= width; + rc = 2; } } -#endif - - memmove(current->buf + p2, current->buf + p1, current->len - p1); - memcpy(current->buf + p1, buf, n); - current->len += n; - - current->chars++; + sb_insert(current->buf, offset, buf); if (current->pos >= pos) { current->pos++; } - return ret; + if (rc == 2) { + if (refreshShowHints(current, sb_str(current->buf), current->colsright, 0)) { + /* A hint needs to be shown, so can't optimise after all */ + rc = 1; + } + else { + /* optimised output */ + outputChars(current, buf, n); + } + } + return rc; } return 0; } @@ -1142,18 +1406,20 @@ static int insert_char(struct current *current, int pos, int ch) * * This replaces any existing characters in the cut buffer. */ -static void capture_chars(struct current *current, int pos, int n) +static void capture_chars(struct current *current, int pos, int nchars) { - 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'; + if (pos >= 0 && (pos + nchars - 1) < sb_chars(current->buf)) { + int offset = utf8_index(sb_str(current->buf), pos); + int nbytes = utf8_index(sb_str(current->buf) + offset, nchars); + + if (nbytes > 0) { + if (current->capture) { + sb_clear(current->capture); + } + else { + current->capture = sb_alloc(); + } + sb_append_len(current->capture, sb_str(current->buf) + offset, nbytes); } } } @@ -1197,108 +1463,139 @@ static int insert_chars(struct current *current, int pos, const char *chars) return inserted; } -#ifndef NO_COMPLETION -static linenoiseCompletionCallback *completionCallback = NULL; +static int skip_space_nonspace(struct current *current, int dir, int check_is_space) +{ + int moved = 0; + int checkoffset = (dir < 0) ? -1 : 0; + int limit = (dir < 0) ? 0 : sb_chars(current->buf); + while (current->pos != limit && (get_char(current, current->pos + checkoffset) == ' ') == check_is_space) { + current->pos += dir; + moved++; + } + return moved; +} -static void beep(void) { -#ifdef USE_TERMIOS - fprintf(stderr, "\x7"); - fflush(stderr); -#endif +static int skip_space(struct current *current, int dir) +{ + return skip_space_nonspace(current, dir, 1); } -static void freeCompletions(linenoiseCompletions *lc) { - size_t i; - for (i = 0; i < lc->len; i++) - free(lc->cvec[i]); - free(lc->cvec); +static int skip_nonspace(struct current *current, int dir) +{ + return skip_space_nonspace(current, dir, 0); } -static int completeLine(struct current *current) { - linenoiseCompletions lc = { 0, NULL, -1 }; +/** + * Returns the keycode to process, or 0 if none. + */ +static int reverseIncrementalSearch(struct current *current) +{ + /* 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; + int c; - int c = 0; + 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); + refreshLineAlt(current, rprompt, sb_str(current->buf), current->pos); + c = fd_read(current); + if (c == ctrl('H') || c == CHAR_DELETE) { + if (rchars) { + int p_ind = utf8_index(rbuf, --rchars); + rbuf[p_ind] = 0; + rlen = strlen(rbuf); + } + continue; + } +#ifdef USE_TERMIOS + if (c == CHAR_ESCAPE) { + 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 >= ' ' && c <= '~') { + /* >= here to allow for null terminator */ + if (rlen >= (int)sizeof(rbuf) - MAX_UTF8_LEN) { + continue; + } - completionCallback(current->buf,&lc,utf8_index(current->buf, current->pos)); - if (lc.len == 0) { - beep(); - } else if ((lc.len == 1) && (lc.cvec[0][0] == '\0')) { - refreshLine(current->prompt, current); // if only completion is empty refresh - } else { - size_t stop = 0, i = 0; + n = utf8_getchars(rbuf + rlen, c); + rlen += n; + rchars++; + rbuf[rlen] = 0; - while(!stop) { - /* Show completion or original buffer */ - if (i < lc.len) { - struct current tmp = *current; - tmp.buf = lc.cvec[i]; - tmp.len = strlen(tmp.buf); - tmp.pos = (lc.pos != -1) ? lc.pos : tmp.len; - tmp.chars = utf8_strlen(tmp.buf, tmp.len); - refreshLine(current->prompt, &tmp); - } else { - refreshLine(current->prompt, current); - } + /* Adding a new char resets the search location */ + searchpos = history_len - 1; + } + else { + /* Exit from incremental search mode */ + break; + } - c = fd_read(current); - if (c == -1) { + /* 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], sb_str(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; } - - 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; - } + } + 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; + } - 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 linenoiseAddCompletion(linenoiseCompletions *lc, const char *str, int pos) { - lc->cvec = (char **)realloc(lc->cvec,sizeof(char*)*(lc->len+1)); - lc->cvec[lc->len++] = strdup(str); - lc->pos = pos; + /* Go process the char normally */ + refreshLine(current); + return c; } -#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, (preload) ? preload_buf : ""); - preload = 0; - refreshLine(current->prompt, current); + refreshLine(current); while(1) { int dir = -1; @@ -1308,47 +1605,71 @@ static int linenoiseEdit(struct current *current) { /* 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' && completionCallback != NULL) { + if (c == '\t' && current->pos == sb_chars(current->buf) && completionCallback != NULL) { c = completeLine(current); - /* Return on errors */ - if (c < 0) return current->len; - /* Read next character when 0 */ - if (c == 0) continue; } #endif + if (c == ctrl('R')) { + /* reverse incremental search will provide an alternative keycode or 0 for none */ + c = reverseIncrementalSearch(current); + /* go on to process the returned char normally */ + } -process_char: - if (c == -1) return current->len; #ifdef USE_TERMIOS - if (c == 27) { /* escape sequence */ + if (c == CHAR_ESCAPE) { /* escape sequence */ c = check_special(current->fd); } #endif + if (c == -1) { + /* Return on errors */ + return sb_len(current->buf); + } + switch(c) { - case '\r': /* enter */ + case SPECIAL_NONE: + break; + case '\r': /* enter/CR */ + case '\n': /* LF */ history_len--; free(history[history_len]); - return current->len; + current->pos = sb_chars(current->buf); + if (mlmode || hintsCallback) { + showhints = 0; + refreshLine(current); + showhints = 1; + } + return sb_len(current->buf); case ctrl('C'): /* ctrl-c */ errno = EAGAIN; return -1; - case 127: /* backspace */ + case ctrl('Z'): /* ctrl-z */ +#ifdef SIGTSTP + /* send ourselves SIGSUSP */ + disableRawMode(current); + raise(SIGTSTP); + /* and resume */ + enableRawMode(current); + refreshLine(current); +#endif + continue; + case CHAR_DELETE: /* backspace */ case ctrl('H'): if (remove_char(current, current->pos - 1) == 1) { - refreshLine(current->prompt, current); + refreshLine(current); } break; case ctrl('D'): /* ctrl-d */ - if (current->len == 0) { + if (sb_len(current->buf) == 0) { /* Empty line, so EOF */ history_len--; free(history[history_len]); return -1; } /* Otherwise fall through to delete char to right of cursor */ + /* fall-thru */ case SPECIAL_DELETE: if (remove_char(current, current->pos) == 1) { - refreshLine(current->prompt, current); + refreshLine(current); } break; case SPECIAL_INSERT: @@ -1356,6 +1677,24 @@ process_char: * Future possibility: Toggle Insert/Overwrite Modes */ break; + case meta('b'): /* meta-b, move word left */ + if (skip_nonspace(current, -1)) { + refreshLine(current); + } + else if (skip_space(current, -1)) { + skip_nonspace(current, -1); + refreshLine(current); + } + break; + case meta('f'): /* meta-f, move word right */ + if (skip_space(current, 1)) { + refreshLine(current); + } + else if (skip_nonspace(current, 1)) { + skip_space(current, 1); + refreshLine(current); + } + break; case ctrl('W'): /* ctrl-w, delete word at left. save deleted chars */ /* eat any spaces on the left */ { @@ -1370,151 +1709,48 @@ process_char: } 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; + refreshLine(current); } - 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 (current->pos > 0 && current->pos <= sb_chars(current->buf)) { /* If cursor is at end, transpose the previous two chars */ - int fixer = (current->pos == current->chars); + int fixer = (current->pos == sb_chars(current->buf)); c = get_char(current, current->pos - fixer); remove_char(current, current->pos - fixer); insert_char(current, current->pos - 1, c); - refreshLine(current->prompt, current); + refreshLine(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); + /* Insert the ^V first */ + if (insert_char(current, current->pos, c)) { + refreshLine(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 > 0) { + /* Insert the actual char, can't be error or null */ + insert_char(current, current->pos, c); } + refreshLine(current); } break; case ctrl('B'): case SPECIAL_LEFT: if (current->pos > 0) { current->pos--; - refreshLine(current->prompt, current); + refreshLine(current); } break; case ctrl('F'): case SPECIAL_RIGHT: - if (current->pos < current->chars) { + if (current->pos < sb_chars(current->buf)) { current->pos++; - refreshLine(current->prompt, current); + refreshLine(current); } break; case SPECIAL_PAGE_UP: @@ -1534,7 +1770,7 @@ history_navigation: /* 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); + history[history_len - 1 - history_index] = strdup(sb_str(current->buf)); /* Show the new entry */ history_index += dir; if (history_index < 0) { @@ -1545,148 +1781,181 @@ history_navigation: break; } set_current(current, history[history_len - 1 - history_index]); - refreshLine(current->prompt, current); + refreshLine(current); } break; case ctrl('A'): /* Ctrl+a, go to the start of the line */ case SPECIAL_HOME: current->pos = 0; - refreshLine(current->prompt, current); + refreshLine(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); + current->pos = sb_chars(current->buf); + refreshLine(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); + refreshLine(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); + if (remove_chars(current, current->pos, sb_chars(current->buf) - current->pos)) { + refreshLine(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); + if (current->capture && insert_chars(current, current->pos, sb_str(current->capture))) { + refreshLine(current); } break; case ctrl('L'): /* Ctrl+L, clear screen */ linenoiseClearScreen(); /* Force recalc of window size for serial terminals */ current->cols = 0; - refreshLine(current->prompt, current); + current->rpos = 0; + refreshLine(current); break; default: + if (c >= meta('a') && c <= meta('z')) { + /* Don't insert meta chars that are not bound */ + break; + } /* Only tab is allowed without ^V */ if (c == '\t' || c >= ' ') { if (insert_char(current, current->pos, c) == 1) { - refreshLine(current->prompt, current); + refreshLine(current); } } break; } } - return current->len; + return sb_len(current->buf); } int linenoiseColumns(void) { struct current current; - current.cols = 0; + current.output = NULL; enableRawMode (¤t); getWindowSize (¤t); disableRawMode (¤t); return current.cols; } -void linenoisePreloadBuffer(const char* preloadText) +/** + * Reads a line from the file handle (without the trailing NL or CRNL) + * and returns it in a stringbuf. + * Returns NULL if no characters are read before EOF or error. + * + * Note that the character count will *not* be correct for lines containing + * utf8 sequences. Do not rely on the character count. + */ +static stringbuf *sb_getline(FILE *fh) { - size_t n = 0; - while((n < LINENOISE_MAX_LINE) && preloadText[n]) - n++; - if(n >= LINENOISE_MAX_LINE) - return; - preload = 1; - strcpy(preload_buf, preloadText); -} + stringbuf *sb = sb_alloc(); + int c; + int n = 0; -void linenoiseRefresh(void) -{ - refresh = 1; + while ((c = getc(fh)) != EOF) { + char ch; + n++; + if (c == '\r') { + /* CRLF -> LF */ + continue; + } + if (c == '\n' || c == '\r') { + break; + } + ch = c; + /* ignore the effect of character count for partial utf8 sequences */ + sb_append_len(sb, &ch, 1); + } + if (n == 0 || sb->data == NULL) { + sb_free(sb); + return NULL; + } + return sb; } -char *linenoise(const char *prompt) +char *linenoiseWithInitial(const char *prompt, const char *initial) { int count; struct current current; - char buf[LINENOISE_MAX_LINE]; + stringbuf *sb; + + memset(¤t, 0, sizeof(current)); if (enableRawMode(¤t) == -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'; + sb = sb_getline(stdin); + if (sb && !fd_isatty(¤t)) { + printf("%s\n", sb_str(sb)); + fflush(stdout); } } - else - { - current.buf = buf; - current.bufmax = sizeof(buf); - current.len = 0; - current.chars = 0; + else { + current.buf = sb_alloc(); current.pos = 0; + current.nrows = 1; current.prompt = prompt; - current.capture = NULL; + + /* The latest history entry is always our current buffer */ + linenoiseHistoryAdd(initial); + set_current(¤t, initial); count = linenoiseEdit(¤t); disableRawMode(¤t); printf("\n"); - free(current.capture); + sb_free(current.capture); if (count == -1) { + sb_free(current.buf); return NULL; } + sb = current.buf; } - return strdup(buf); + return sb ? sb_to_string(sb) : NULL; +} + +char *linenoise(const char *prompt) +{ + return linenoiseWithInitial(prompt, ""); } /* Using a circular buffer is smarter, but a bit more complex to handle. */ -int linenoiseHistoryAdd(const char *line) { - char *linecopy; +static int linenoiseHistoryAddAllocated(char *line) { - if (history_max_len == 0) return 0; + if (history_max_len == 0) { +notinserted: + free(line); + 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)); + history = (char **)calloc(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; + goto notinserted; } - 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[history_len] = line; history_len++; return 1; } +int linenoiseHistoryAdd(const char *line) { + return linenoiseHistoryAddAllocated(strdup(line)); +} + int linenoiseHistoryGetMaxLen(void) { return history_max_len; } @@ -1698,8 +1967,7 @@ int linenoiseHistorySetMaxLen(int len) { if (history) { int tocopy = history_len; - newHistory = (char **)malloc(sizeof(char*)*len); - if (newHistory == NULL) return 0; + newHistory = (char **)calloc(sizeof(char*), len); /* If we can't copy everything, free the elements we'll not use. */ if (len < tocopy) { @@ -1708,7 +1976,6 @@ int linenoiseHistorySetMaxLen(int len) { 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; @@ -1751,22 +2018,25 @@ int linenoiseHistorySave(const char *filename) { return 0; } -/* Load the history from the specified file. If the file does not exist - * zero is returned and no operation is performed. +/* Load the history from the specified file. * - * If the file exists and the operation succeeded 0 is returned, otherwise - * on error -1 is returned. */ + * If the file does not exist or can't be opened, no operation is performed + * and -1 is returned. + * Otherwise 0 is returned. + */ int linenoiseHistoryLoad(const char *filename) { FILE *fp = fopen(filename,"r"); - char buf[LINENOISE_MAX_LINE]; + stringbuf *sb; if (fp == NULL) return -1; - while (fgets(buf,LINENOISE_MAX_LINE,fp) != NULL) { - char *src, *dest; + while ((sb = sb_getline(fp)) != NULL) { + /* Take the stringbuf and decode backslash escaped values */ + char *buf = sb_to_string(sb); + char *dest = buf; + const char *src; - /* Decode backslash escaped values */ - for (src = dest = buf; *src; src++) { + for (src = buf; *src; src++) { char ch = *src; if (ch == '\\') { @@ -1782,13 +2052,9 @@ int linenoiseHistoryLoad(const char *filename) { } *dest++ = ch; } - /* Remove trailing newline */ - if (dest != buf && (dest[-1] == '\n' || dest[-1] == '\r')) { - dest--; - } *dest = 0; - linenoiseHistoryAdd(buf); + linenoiseHistoryAddAllocated(buf); } fclose(fp); return 0; diff --git a/3rdparty/linenoise/linenoise.h b/3rdparty/linenoise/linenoise.h index aa1f77ec819..8842de3a4e8 100644 --- a/3rdparty/linenoise/linenoise.h +++ b/3rdparty/linenoise/linenoise.h @@ -37,29 +37,38 @@ #ifndef __LINENOISE_H #define __LINENOISE_H +#ifdef __cplusplus +extern "C" { +#endif + #ifndef NO_COMPLETION typedef struct linenoiseCompletions { size_t len; char **cvec; - int pos; } linenoiseCompletions; /* * The callback type for tab completion handlers. */ -typedef void(linenoiseCompletionCallback)(const char *prefix, linenoiseCompletions *comp, int pos); +typedef void(linenoiseCompletionCallback)(const char *prefix, linenoiseCompletions *comp, void *userdata); /* * Sets the current tab completion handler and returns the previous one, or NULL * if no prior one has been set. */ -linenoiseCompletionCallback * linenoiseSetCompletionCallback(linenoiseCompletionCallback *comp); +linenoiseCompletionCallback * linenoiseSetCompletionCallback(linenoiseCompletionCallback *comp, void *userdata); /* * Adds a copy of the given string to the given completion list. The copy is owned * by the linenoiseCompletions object. */ -void linenoiseAddCompletion(linenoiseCompletions *comp, const char *str, int pos); +void linenoiseAddCompletion(linenoiseCompletions *comp, const char *str); + +typedef char*(linenoiseHintsCallback)(const char *, int *color, int *bold, void *userdata); +typedef void(linenoiseFreeHintsCallback)(void *hint, void *userdata); +void linenoiseSetHintsCallback(linenoiseHintsCallback *callback, void *userdata); +void linenoiseSetFreeHintsCallback(linenoiseFreeHintsCallback *callback); + #endif /* @@ -71,6 +80,11 @@ void linenoiseAddCompletion(linenoiseCompletions *comp, const char *str, int pos */ char *linenoise(const char *prompt); +/** + * Like linenoise() but starts with an initial buffer. + */ +char *linenoiseWithInitial(const char *prompt, const char *initial); + /** * Clear the screen. */ @@ -123,8 +137,13 @@ char **linenoiseHistory(int *len); */ int linenoiseColumns(void); -void linenoisePreloadBuffer(const char* preloadText); +/** + * Enable or disable multiline mode (disabled by default) + */ +void linenoiseSetMultiLine(int enableml); -void linenoiseRefresh(void); +#ifdef __cplusplus +} +#endif #endif /* __LINENOISE_H */ diff --git a/3rdparty/linenoise/stringbuf.c b/3rdparty/linenoise/stringbuf.c new file mode 100644 index 00000000000..2b9fe70604a --- /dev/null +++ b/3rdparty/linenoise/stringbuf.c @@ -0,0 +1,173 @@ +/** + * resizable string buffer + * + * (c) 2017-2020 Steve Bennett + * + * See utf8.c for licence details. + */ +#include +#include +#include +#include +#include + +#ifndef STRINGBUF_H +#include "stringbuf.h" +#endif +#ifdef USE_UTF8 +#ifndef UTF8_UTIL_H +#include "utf8.h" +#endif +#endif + +#define SB_INCREMENT 200 + +stringbuf *sb_alloc(void) +{ + stringbuf *sb = (stringbuf *)malloc(sizeof(*sb)); + sb->remaining = 0; + sb->last = 0; +#ifdef USE_UTF8 + sb->chars = 0; +#endif + sb->data = NULL; + + return(sb); +} + +void sb_free(stringbuf *sb) +{ + if (sb) { + free(sb->data); + } + free(sb); +} + +static void sb_realloc(stringbuf *sb, int newlen) +{ + sb->data = (char *)realloc(sb->data, newlen); + sb->remaining = newlen - sb->last; +} + +void sb_append(stringbuf *sb, const char *str) +{ + sb_append_len(sb, str, strlen(str)); +} + +void sb_append_len(stringbuf *sb, const char *str, int len) +{ + if (sb->remaining < len + 1) { + sb_realloc(sb, sb->last + len + 1 + SB_INCREMENT); + } + memcpy(sb->data + sb->last, str, len); + sb->data[sb->last + len] = 0; + + sb->last += len; + sb->remaining -= len; +#ifdef USE_UTF8 + sb->chars += utf8_strlen(str, len); +#endif +} + +char *sb_to_string(stringbuf *sb) +{ + if (sb->data == NULL) { + /* Return an allocated empty string, not null */ + return strdup(""); + } + else { + /* Just return the data and free the stringbuf structure */ + char *pt = sb->data; + free(sb); + return pt; + } +} + +/* Insert and delete operations */ + +/* Moves up all the data at position 'pos' and beyond by 'len' bytes + * to make room for new data + * + * Note: Does *not* update sb->chars + */ +static void sb_insert_space(stringbuf *sb, int pos, int len) +{ + assert(pos <= sb->last); + + /* Make sure there is enough space */ + if (sb->remaining < len) { + sb_realloc(sb, sb->last + len + SB_INCREMENT); + } + /* Now move it up */ + memmove(sb->data + pos + len, sb->data + pos, sb->last - pos); + sb->last += len; + sb->remaining -= len; + /* And null terminate */ + sb->data[sb->last] = 0; +} + +/** + * Move down all the data from pos + len, effectively + * deleting the data at position 'pos' of length 'len' + */ +static void sb_delete_space(stringbuf *sb, int pos, int len) +{ + assert(pos < sb->last); + assert(pos + len <= sb->last); + +#ifdef USE_UTF8 + sb->chars -= utf8_strlen(sb->data + pos, len); +#endif + + /* Now move it up */ + memmove(sb->data + pos, sb->data + pos + len, sb->last - pos - len); + sb->last -= len; + sb->remaining += len; + /* And null terminate */ + sb->data[sb->last] = 0; +} + +void sb_insert(stringbuf *sb, int index, const char *str) +{ + if (index >= sb->last) { + /* Inserting after the end of the list appends. */ + sb_append(sb, str); + } + else { + int len = strlen(str); + + sb_insert_space(sb, index, len); + memcpy(sb->data + index, str, len); +#ifdef USE_UTF8 + sb->chars += utf8_strlen(str, len); +#endif + } +} + +/** + * Delete the bytes at index 'index' for length 'len' + * Has no effect if the index is past the end of the list. + */ +void sb_delete(stringbuf *sb, int index, int len) +{ + if (index < sb->last) { + char *pos = sb->data + index; + if (len < 0) { + len = sb->last; + } + + sb_delete_space(sb, pos - sb->data, len); + } +} + +void sb_clear(stringbuf *sb) +{ + if (sb->data) { + /* Null terminate */ + sb->data[0] = 0; + sb->last = 0; +#ifdef USE_UTF8 + sb->chars = 0; +#endif + } +} diff --git a/3rdparty/linenoise/stringbuf.h b/3rdparty/linenoise/stringbuf.h new file mode 100644 index 00000000000..8ac6c9a6a05 --- /dev/null +++ b/3rdparty/linenoise/stringbuf.h @@ -0,0 +1,137 @@ +#ifndef STRINGBUF_H +#define STRINGBUF_H +/** + * resizable string buffer + * + * (c) 2017-2020 Steve Bennett + * + * See utf8.c for licence details. + */ +#ifdef __cplusplus +extern "C" { +#endif + +/** @file + * A stringbuf is a resizing, null terminated string buffer. + * + * The buffer is reallocated as necessary. + * + * In general it is *not* OK to call these functions with a NULL pointer + * unless stated otherwise. + * + * If USE_UTF8 is defined, supports utf8. + */ + +/** + * The stringbuf structure should not be accessed directly. + * Use the functions below. + */ +typedef struct { + int remaining; /**< Allocated, but unused space */ + int last; /**< Index of the null terminator (and thus the length of the string) */ +#ifdef USE_UTF8 + int chars; /**< Count of characters */ +#endif + char *data; /**< Allocated memory containing the string or NULL for empty */ +} stringbuf; + +/** + * Allocates and returns a new stringbuf with no elements. + */ +stringbuf *sb_alloc(void); + +/** + * Frees a stringbuf. + * It is OK to call this with NULL. + */ +void sb_free(stringbuf *sb); + +/** + * Returns an allocated copy of the stringbuf + */ +stringbuf *sb_copy(stringbuf *sb); + +/** + * Returns the byte length of the buffer. + * + * Returns 0 for both a NULL buffer and an empty buffer. + */ +static inline int sb_len(stringbuf *sb) { + return sb->last; +} + +/** + * Returns the utf8 character length of the buffer. + * + * Returns 0 for both a NULL buffer and an empty buffer. + */ +static inline int sb_chars(stringbuf *sb) { +#ifdef USE_UTF8 + return sb->chars; +#else + return sb->last; +#endif +} + +/** + * Appends a null terminated string to the stringbuf + */ +void sb_append(stringbuf *sb, const char *str); + +/** + * Like sb_append() except does not require a null terminated string. + * The length of 'str' is given as 'len' + * + * Note that in utf8 mode, characters will *not* be counted correctly + * if a partial utf8 sequence is added with sb_append_len() + */ +void sb_append_len(stringbuf *sb, const char *str, int len); + +/** + * Returns a pointer to the null terminated string in the buffer. + * + * Note this pointer only remains valid until the next modification to the + * string buffer. + * + * The returned pointer can be used to update the buffer in-place + * as long as care is taken to not overwrite the end of the buffer. + */ +static inline char *sb_str(const stringbuf *sb) +{ + return sb->data; +} + +/** + * Inserts the given string *before* (zero-based) byte 'index' in the stringbuf. + * If index is past the end of the buffer, the string is appended, + * just like sb_append() + */ +void sb_insert(stringbuf *sb, int index, const char *str); + +/** + * Delete 'len' bytes in the string at the given index. + * + * Any bytes past the end of the buffer are ignored. + * The buffer remains null terminated. + * + * If len is -1, deletes to the end of the buffer. + */ +void sb_delete(stringbuf *sb, int index, int len); + +/** + * Clear to an empty buffer. + */ +void sb_clear(stringbuf *sb); + +/** + * Return an allocated copy of buffer and frees 'sb'. + * + * If 'sb' is empty, returns an allocated copy of "". + */ +char *sb_to_string(stringbuf *sb); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/3rdparty/linenoise/teststringbuf.c b/3rdparty/linenoise/teststringbuf.c new file mode 100644 index 00000000000..5a2a8b2f823 --- /dev/null +++ b/3rdparty/linenoise/teststringbuf.c @@ -0,0 +1,137 @@ +#include +#include +#include +#include + +#include +#include + +static void show_buf(stringbuf *sb) +{ + printf("[%d] = %s\n", sb_len(sb), sb_str(sb)); +} + +#define validate_buf(SB, EXP) validate_buf_(__FILE__, __LINE__, SB, EXP) + +static void validate_buf_(const char *file, int line, stringbuf *sb, const char *expected) +{ + const char *pt = sb_str(sb); + if (pt == NULL) { + if (expected != NULL) { + fprintf(stderr, "%s:%d: Error: Expected NULL, got '%s'\n", file, line, pt); + abort(); + } + } + else if (strcmp(pt, expected) != 0) { + show_buf(sb); + fprintf(stderr, "%s:%d: Error: Expected '%s', got '%s'\n", file, line, expected, pt); + abort(); + } + sb_free(sb); +} + +int main(void) +{ + stringbuf *sb; + char *pt; + + sb = sb_alloc(); + validate_buf(sb, NULL); + + sb = sb_alloc(); + sb_append(sb, "hello"); + sb_append(sb, "world"); + validate_buf(sb, "helloworld"); + + sb = sb_alloc(); + sb_append(sb, "hello"); + sb_append(sb, "world"); + sb_append(sb, ""); + sb_append(sb, "xxx"); + assert(sb_len(sb) == 13); + validate_buf(sb, "helloworldxxx"); + + sb = sb_alloc(); + sb_append(sb, "first"); + sb_append(sb, "string"); + validate_buf(sb, "firststring"); + + sb = sb_alloc(); + sb_append(sb, ""); + validate_buf(sb, ""); + + sb = sb_alloc(); + sb_append_len(sb, "one string here", 3); + sb_append_len(sb, "second string here", 6); + validate_buf(sb, "onesecond"); + + sb = sb_alloc(); + sb_append_len(sb, "one string here", 3); + sb_append_len(sb, "second string here", 6); + pt = sb_to_string(sb); + assert(strcmp(pt, "onesecond") == 0); + free(pt); + + sb = sb_alloc(); + pt = sb_to_string(sb); + assert(strcmp(pt, "") == 0); + free(pt); + + sb = sb_alloc(); + sb_append(sb, "one"); + sb_append(sb, "three"); + sb_insert(sb, 3, "two"); + validate_buf(sb, "onetwothree"); + + sb = sb_alloc(); + sb_insert(sb, 0, "two"); + sb_insert(sb, 0, "one"); + sb_insert(sb, 20, "three"); + validate_buf(sb, "onetwothree"); + + sb = sb_alloc(); + sb_append(sb, "one"); + sb_append(sb, "extra"); + sb_append(sb, "two"); + sb_append(sb, "three"); + sb_delete(sb, 3, 5); + validate_buf(sb, "onetwothree"); + + sb = sb_alloc(); + sb_append(sb, "one"); + sb_append(sb, "two"); + sb_append(sb, "three"); + validate_buf(sb, "onetwothree"); + /*sb_delete(sb, 6, -1);*/ + /*validate_buf(sb, "onetwo");*/ + + sb = sb_alloc(); + sb_append(sb, "one"); + sb_append(sb, "two"); + sb_append(sb, "three"); + sb_delete(sb, 0, -1); + validate_buf(sb, ""); + + sb = sb_alloc(); + sb_append(sb, "one"); + sb_append(sb, "two"); + sb_append(sb, "three"); + sb_delete(sb, 50, 20); + validate_buf(sb, "onetwothree"); + + /* OK to sb_free() a NULL pointer */ + sb_free(NULL); + +#ifdef USE_UTF8 + sb = sb_alloc(); + sb_append(sb, "oneµtwo"); + assert(sb_len(sb) == 8); + assert(sb_chars(sb) == 7); + sb_delete(sb, 3, 2); + assert(sb_len(sb) == 6); + assert(sb_chars(sb) == 6); + validate_buf(sb, "onetwo"); +#endif + + return(0); +} diff --git a/3rdparty/linenoise/utf8.c b/3rdparty/linenoise/utf8.c index 7cd3be8cd5c..75f07085998 100644 --- a/3rdparty/linenoise/utf8.c +++ b/3rdparty/linenoise/utf8.c @@ -1,16 +1,39 @@ /** * UTF-8 utility functions * - * (c) 2010-2016 Steve Bennett + * (c) 2010-2019 Steve Bennett * - * See LICENCE for licence details. + * 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 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. */ #include #include #include #include +#ifndef UTF8_UTIL_H #include "utf8.h" +#endif #ifdef USE_UTF8 int utf8_fromunicode(char *p, unsigned uc) @@ -64,7 +87,7 @@ int utf8_strlen(const char *str, int bytelen) if (bytelen < 0) { bytelen = strlen(str); } - while (bytelen) { + while (bytelen > 0) { int c; int l = utf8_tounicode(str, &c); charlen++; @@ -108,19 +131,28 @@ int utf8_tounicode(const char *str, int *uc) if (s[0] < 0xe0) { if ((s[1] & 0xc0) == 0x80) { *uc = ((s[0] & ~0xc0) << 6) | (s[1] & ~0x80); - return 2; + if (*uc >= 0x80) { + return 2; + } + /* Otherwise this is an invalid sequence */ } } 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; + if (*uc >= 0x800) { + return 3; + } + /* Otherwise this is an invalid sequence */ } } else if (s[0] < 0xf8) { if (((str[1] & 0xc0) == 0x80) && ((str[2] & 0xc0) == 0x80) && ((str[3] & 0xc0) == 0x80)) { *uc = ((s[0] & ~0xf0) << 18) | ((s[1] & ~0x80) << 12) | ((s[2] & ~0x80) << 6) | (s[3] & ~0x80); - return 4; + if (*uc >= 0x10000) { + return 4; + } + /* Otherwise this is an invalid sequence */ } } @@ -136,52 +168,68 @@ struct utf8range { /* From http://unicode.org/Public/UNIDATA/UnicodeData.txt */ static const struct utf8range unicode_range_combining[] = { - { 0x0300, 0x0370 }, { 0x0483, 0x048a }, { 0x0591, 0x05be }, { 0x05bf, 0x05c0 }, - { 0x05c1, 0x05c3 }, { 0x05c4, 0x05c6 }, { 0x05c7, 0x05d0 }, { 0x0610, 0x061b }, - { 0x064b, 0x0660 }, { 0x0670, 0x0671 }, { 0x06d6, 0x06dd }, { 0x06de, 0x06e5 }, - { 0x06e7, 0x06e9 }, { 0x06ea, 0x06ee }, { 0x0711, 0x0712 }, { 0x0730, 0x074d }, - { 0x07a6, 0x07b1 }, { 0x07eb, 0x07f4 }, { 0x0816, 0x081a }, { 0x081b, 0x0824 }, - { 0x0825, 0x0828 }, { 0x0829, 0x0830 }, { 0x0900, 0x0904 }, { 0x093c, 0x093d }, - { 0x093e, 0x0950 }, { 0x0951, 0x0958 }, { 0x0962, 0x0964 }, { 0x0981, 0x0985 }, - { 0x09bc, 0x09bd }, { 0x09be, 0x09ce }, { 0x09d7, 0x09dc }, { 0x09e2, 0x09e6 }, - { 0x0a01, 0x0a05 }, { 0x0a3c, 0x0a59 }, { 0x0a70, 0x0a72 }, { 0x0a75, 0x0a85 }, - { 0x0abc, 0x0abd }, { 0x0abe, 0x0ad0 }, { 0x0ae2, 0x0ae6 }, { 0x0b01, 0x0b05 }, - { 0x0b3c, 0x0b3d }, { 0x0b3e, 0x0b5c }, { 0x0b62, 0x0b66 }, { 0x0b82, 0x0b83 }, - { 0x0bbe, 0x0bd0 }, { 0x0bd7, 0x0be6 }, { 0x0c01, 0x0c05 }, { 0x0c3e, 0x0c58 }, - { 0x0c62, 0x0c66 }, { 0x0c82, 0x0c85 }, { 0x0cbc, 0x0cbd }, { 0x0cbe, 0x0cde }, - { 0x0ce2, 0x0ce6 }, { 0x0d02, 0x0d05 }, { 0x0d3e, 0x0d60 }, { 0x0d62, 0x0d66 }, - { 0x0d82, 0x0d85 }, { 0x0dca, 0x0df4 }, { 0x0e31, 0x0e32 }, { 0x0e34, 0x0e3f }, - { 0x0e47, 0x0e4f }, { 0x0eb1, 0x0eb2 }, { 0x0eb4, 0x0ebd }, { 0x0ec8, 0x0ed0 }, - { 0x0f18, 0x0f1a }, { 0x0f35, 0x0f36 }, { 0x0f37, 0x0f38 }, { 0x0f39, 0x0f3a }, - { 0x0f3e, 0x0f40 }, { 0x0f71, 0x0f85 }, { 0x0f86, 0x0f88 }, { 0x0f90, 0x0fbe }, - { 0x0fc6, 0x0fc7 }, { 0x102b, 0x103f }, { 0x1056, 0x105a }, { 0x105e, 0x1061 }, - { 0x1062, 0x1065 }, { 0x1067, 0x106e }, { 0x1071, 0x1075 }, { 0x1082, 0x108e }, - { 0x108f, 0x1090 }, { 0x109a, 0x109e }, { 0x135f, 0x1360 }, { 0x1712, 0x1720 }, - { 0x1732, 0x1735 }, { 0x1752, 0x1760 }, { 0x1772, 0x1780 }, { 0x17b6, 0x17d4 }, - { 0x17dd, 0x17e0 }, { 0x180b, 0x180e }, { 0x18a9, 0x18aa }, { 0x1920, 0x1940 }, - { 0x19b0, 0x19c1 }, { 0x19c8, 0x19d0 }, { 0x1a17, 0x1a1e }, { 0x1a55, 0x1a80 }, - { 0x1b00, 0x1b05 }, { 0x1b34, 0x1b45 }, { 0x1b6b, 0x1b74 }, { 0x1b80, 0x1b83 }, - { 0x1ba1, 0x1bae }, { 0x1c24, 0x1c3b }, { 0x1cd0, 0x1cd3 }, { 0x1cd4, 0x1ce9 }, - { 0x1ced, 0x1cee }, { 0x1cf2, 0x1d00 }, { 0x1dc0, 0x1e00 }, { 0x20d0, 0x2100 }, - { 0x2cef, 0x2cf9 }, { 0x2de0, 0x2e00 }, { 0x302a, 0x3030 }, { 0x3099, 0x309b }, - { 0xa66f, 0xa673 }, { 0xa67c, 0xa67e }, { 0xa6f0, 0xa6f2 }, { 0xa802, 0xa803 }, - { 0xa806, 0xa807 }, { 0xa80b, 0xa80c }, { 0xa823, 0xa828 }, { 0xa880, 0xa882 }, - { 0xa8b4, 0xa8ce }, { 0xa8e0, 0xa8f2 }, { 0xa926, 0xa92e }, { 0xa947, 0xa95f }, - { 0xa980, 0xa984 }, { 0xa9b3, 0xa9c1 }, { 0xaa29, 0xaa40 }, { 0xaa43, 0xaa44 }, - { 0xaa4c, 0xaa50 }, { 0xaa7b, 0xaa80 }, { 0xaab0, 0xaab1 }, { 0xaab2, 0xaab5 }, - { 0xaab7, 0xaab9 }, { 0xaabe, 0xaac0 }, { 0xaac1, 0xaac2 }, { 0xabe3, 0xabeb }, - { 0xabec, 0xabf0 }, { 0xfb1e, 0xfb1f }, { 0xfe00, 0xfe10 }, { 0xfe20, 0xfe30 }, + { 0x0300, 0x0370 }, { 0x0483, 0x048a }, { 0x0591, 0x05d0 }, { 0x0610, 0x061b }, + { 0x064b, 0x0660 }, { 0x0670, 0x0671 }, { 0x06d6, 0x06dd }, { 0x06df, 0x06e5 }, + { 0x06e7, 0x06ee }, { 0x0711, 0x0712 }, { 0x0730, 0x074d }, { 0x07a6, 0x07b1 }, + { 0x07eb, 0x07f4 }, { 0x0816, 0x0830 }, { 0x0859, 0x085e }, { 0x08d4, 0x0904 }, + { 0x093a, 0x0958 }, { 0x0962, 0x0964 }, { 0x0981, 0x0985 }, { 0x09bc, 0x09ce }, + { 0x09d7, 0x09dc }, { 0x09e2, 0x09e6 }, { 0x0a01, 0x0a05 }, { 0x0a3c, 0x0a59 }, + { 0x0a70, 0x0a72 }, { 0x0a75, 0x0a85 }, { 0x0abc, 0x0ad0 }, { 0x0ae2, 0x0ae6 }, + { 0x0afa, 0x0b05 }, { 0x0b3c, 0x0b5c }, { 0x0b62, 0x0b66 }, { 0x0b82, 0x0b83 }, + { 0x0bbe, 0x0bd0 }, { 0x0bd7, 0x0be6 }, { 0x0c00, 0x0c05 }, { 0x0c3e, 0x0c58 }, + { 0x0c62, 0x0c66 }, { 0x0c81, 0x0c85 }, { 0x0cbc, 0x0cde }, { 0x0ce2, 0x0ce6 }, + { 0x0d00, 0x0d05 }, { 0x0d3b, 0x0d4e }, { 0x0d57, 0x0d58 }, { 0x0d62, 0x0d66 }, + { 0x0d82, 0x0d85 }, { 0x0dca, 0x0de6 }, { 0x0df2, 0x0df4 }, { 0x0e31, 0x0e32 }, + { 0x0e34, 0x0e3f }, { 0x0e47, 0x0e4f }, { 0x0eb1, 0x0eb2 }, { 0x0eb4, 0x0ebd }, + { 0x0ec8, 0x0ed0 }, { 0x0f18, 0x0f1a }, { 0x0f35, 0x0f3a }, { 0x0f3e, 0x0f40 }, + { 0x0f71, 0x0f88 }, { 0x0f8d, 0x0fbe }, { 0x0fc6, 0x0fc7 }, { 0x102b, 0x103f }, + { 0x1056, 0x105a }, { 0x105e, 0x1065 }, { 0x1067, 0x106e }, { 0x1071, 0x1075 }, + { 0x1082, 0x1090 }, { 0x109a, 0x109e }, { 0x135d, 0x1360 }, { 0x1712, 0x1720 }, + { 0x1732, 0x1735 }, { 0x1752, 0x1760 }, { 0x1772, 0x1780 }, { 0x17b4, 0x17d4 }, + { 0x17dd, 0x17e0 }, { 0x180b, 0x180e }, { 0x1885, 0x1887 }, { 0x18a9, 0x18aa }, + { 0x1920, 0x1940 }, { 0x1a17, 0x1a1e }, { 0x1a55, 0x1a80 }, { 0x1ab0, 0x1b05 }, + { 0x1b34, 0x1b45 }, { 0x1b6b, 0x1b74 }, { 0x1b80, 0x1b83 }, { 0x1ba1, 0x1bae }, + { 0x1be6, 0x1bfc }, { 0x1c24, 0x1c3b }, { 0x1cd0, 0x1ce9 }, { 0x1ced, 0x1cee }, + { 0x1cf2, 0x1cf5 }, { 0x1cf7, 0x1d00 }, { 0x1dc0, 0x1e00 }, { 0x20d0, 0x2100 }, + { 0x2cef, 0x2cf2 }, { 0x2d7f, 0x2d80 }, { 0x2de0, 0x2e00 }, { 0x302a, 0x3030 }, + { 0x3099, 0x309b }, { 0xa66f, 0xa67e }, { 0xa69e, 0xa6a0 }, { 0xa6f0, 0xa6f2 }, + { 0xa802, 0xa803 }, { 0xa806, 0xa807 }, { 0xa80b, 0xa80c }, { 0xa823, 0xa828 }, + { 0xa880, 0xa882 }, { 0xa8b4, 0xa8ce }, { 0xa8e0, 0xa8f2 }, { 0xa926, 0xa92e }, + { 0xa947, 0xa95f }, { 0xa980, 0xa984 }, { 0xa9b3, 0xa9c1 }, { 0xa9e5, 0xa9e6 }, + { 0xaa29, 0xaa40 }, { 0xaa43, 0xaa44 }, { 0xaa4c, 0xaa50 }, { 0xaa7b, 0xaa7e }, + { 0xaab0, 0xaab5 }, { 0xaab7, 0xaab9 }, { 0xaabe, 0xaac2 }, { 0xaaeb, 0xaaf0 }, + { 0xaaf5, 0xab01 }, { 0xabe3, 0xabf0 }, { 0xfb1e, 0xfb1f }, { 0xfe00, 0xfe10 }, + { 0xfe20, 0xfe30 }, }; +/* From http://unicode.org/Public/UNIDATA/EastAsianWidth.txt */ static const struct utf8range unicode_range_wide[] = { - { 0x1100, 0x115f }, { 0x2329, 0x232a }, { 0x2e80, 0x2e99 }, { 0x2e9b, 0x2ef3 }, - { 0x2f00, 0x2fd5 }, { 0x2ff0, 0x2ffb }, { 0x3000, 0x303e }, { 0x3041, 0x3096 }, - { 0x3099, 0x30ff }, { 0x3105, 0x312d }, { 0x3131, 0x318e }, { 0x3190, 0x31ba }, - { 0x31c0, 0x31e3 }, { 0x31f0, 0x321e }, { 0x3220, 0x3247 }, { 0x3250, 0x4dbf }, - { 0x4e00, 0xa48c }, { 0xa490, 0xa4c6 }, { 0xa960, 0xa97c }, { 0xac00, 0xd7a3 }, - { 0xf900, 0xfaff }, { 0xfe10, 0xfe19 }, { 0xfe30, 0xfe52 }, { 0xfe54, 0xfe66 }, - { 0xfe68, 0xfe6b }, { 0xff01, 0xffe6 }, { 0x1b000, 0x1b001 }, { 0x1f200, 0x1f202 }, - { 0x1f210, 0x1f23a }, { 0x1f240, 0x1f248 }, { 0x1f250, 0x1f251 }, { 0x20000, 0x3fffd }, + { 0x1100, 0x115f }, { 0x231a, 0x231b }, { 0x2329, 0x232a }, { 0x23e9, 0x23ec }, + { 0x23f0, 0x23f0 }, { 0x23f3, 0x23f3 }, { 0x25fd, 0x25fe }, { 0x2614, 0x2615 }, + { 0x2648, 0x2653 }, { 0x267f, 0x267f }, { 0x2693, 0x2693 }, { 0x26a1, 0x26a1 }, + { 0x26aa, 0x26ab }, { 0x26bd, 0x26be }, { 0x26c4, 0x26c5 }, { 0x26ce, 0x26ce }, + { 0x26d4, 0x26d4 }, { 0x26ea, 0x26ea }, { 0x26f2, 0x26f3 }, { 0x26f5, 0x26f5 }, + { 0x26fa, 0x26fa }, { 0x26fd, 0x26fd }, { 0x2705, 0x2705 }, { 0x270a, 0x270b }, + { 0x2728, 0x2728 }, { 0x274c, 0x274c }, { 0x274e, 0x274e }, { 0x2753, 0x2755 }, + { 0x2757, 0x2757 }, { 0x2795, 0x2797 }, { 0x27b0, 0x27b0 }, { 0x27bf, 0x27bf }, + { 0x2b1b, 0x2b1c }, { 0x2b50, 0x2b50 }, { 0x2b55, 0x2b55 }, { 0x2e80, 0x2e99 }, + { 0x2e9b, 0x2ef3 }, { 0x2f00, 0x2fd5 }, { 0x2ff0, 0x2ffb }, { 0x3001, 0x303e }, + { 0x3041, 0x3096 }, { 0x3099, 0x30ff }, { 0x3105, 0x312e }, { 0x3131, 0x318e }, + { 0x3190, 0x31ba }, { 0x31c0, 0x31e3 }, { 0x31f0, 0x321e }, { 0x3220, 0x3247 }, + { 0x3250, 0x32fe }, { 0x3300, 0x4dbf }, { 0x4e00, 0xa48c }, { 0xa490, 0xa4c6 }, + { 0xa960, 0xa97c }, { 0xac00, 0xd7a3 }, { 0xf900, 0xfaff }, { 0xfe10, 0xfe19 }, + { 0xfe30, 0xfe52 }, { 0xfe54, 0xfe66 }, { 0xfe68, 0xfe6b }, { 0x16fe0, 0x16fe1 }, + { 0x17000, 0x187ec }, { 0x18800, 0x18af2 }, { 0x1b000, 0x1b11e }, { 0x1b170, 0x1b2fb }, + { 0x1f004, 0x1f004 }, { 0x1f0cf, 0x1f0cf }, { 0x1f18e, 0x1f18e }, { 0x1f191, 0x1f19a }, + { 0x1f200, 0x1f202 }, { 0x1f210, 0x1f23b }, { 0x1f240, 0x1f248 }, { 0x1f250, 0x1f251 }, + { 0x1f260, 0x1f265 }, { 0x1f300, 0x1f320 }, { 0x1f32d, 0x1f335 }, { 0x1f337, 0x1f37c }, + { 0x1f37e, 0x1f393 }, { 0x1f3a0, 0x1f3ca }, { 0x1f3cf, 0x1f3d3 }, { 0x1f3e0, 0x1f3f0 }, + { 0x1f3f4, 0x1f3f4 }, { 0x1f3f8, 0x1f43e }, { 0x1f440, 0x1f440 }, { 0x1f442, 0x1f4fc }, + { 0x1f4ff, 0x1f53d }, { 0x1f54b, 0x1f54e }, { 0x1f550, 0x1f567 }, { 0x1f57a, 0x1f57a }, + { 0x1f595, 0x1f596 }, { 0x1f5a4, 0x1f5a4 }, { 0x1f5fb, 0x1f64f }, { 0x1f680, 0x1f6c5 }, + { 0x1f6cc, 0x1f6cc }, { 0x1f6d0, 0x1f6d2 }, { 0x1f6eb, 0x1f6ec }, { 0x1f6f4, 0x1f6f8 }, + { 0x1f910, 0x1f93e }, { 0x1f940, 0x1f94c }, { 0x1f950, 0x1f96b }, { 0x1f980, 0x1f997 }, + { 0x1f9c0, 0x1f9c0 }, { 0x1f9d0, 0x1f9e6 }, { 0x20000, 0x2fffd }, { 0x30000, 0x3fffd }, }; #define ARRAYSIZE(A) sizeof(A) / sizeof(*(A)) @@ -202,7 +250,7 @@ static int cmp_range(const void *key, const void *cm) static int utf8_in_range(const struct utf8range *range, int num, int ch) { const struct utf8range *r = - (const struct utf8range *)bsearch(&ch, range, num, sizeof(*range), cmp_range); + bsearch(&ch, range, num, sizeof(*range), cmp_range); if (r) { return 1; diff --git a/3rdparty/linenoise/utf8.h b/3rdparty/linenoise/utf8.h index b9ed2a93f3e..dd9c94ec7e3 100644 --- a/3rdparty/linenoise/utf8.h +++ b/3rdparty/linenoise/utf8.h @@ -8,15 +8,16 @@ extern "C" { /** * UTF-8 utility functions * - * (c) 2010-2016 Steve Bennett + * (c) 2010-2019 Steve Bennett * - * See LICENCE for licence details. + * See utf8.c for licence details. */ -#define USE_UTF8 #ifndef USE_UTF8 #include +#define MAX_UTF8_LEN 1 + /* No utf-8 support. 1 byte = 1 char */ #define utf8_strlen(S, B) ((B) < 0 ? (int)strlen(S) : (B)) #define utf8_strwidth(S, B) utf8_strlen((S), (B)) @@ -26,6 +27,9 @@ extern "C" { #define utf8_width(C) 1 #else + +#define MAX_UTF8_LEN 4 + /** * Converts the given unicode codepoint (0 - 0x1fffff) to utf-8 * and stores the result at 'p'. diff --git a/3rdparty/lua-linenoise/linenoise.c b/3rdparty/lua-linenoise/linenoise.c index aab7c1418ea..40494c1ef26 100644 --- a/3rdparty/lua-linenoise/linenoise.c +++ b/3rdparty/lua-linenoise/linenoise.c @@ -44,7 +44,7 @@ static int handle_ln_ok(lua_State *L) return 1; } -static void completion_callback_wrapper(const char *line, linenoiseCompletions *completions, int pos) +static void completion_callback_wrapper(const char *line, linenoiseCompletions *completions, void *userdata) { lua_State *L = completion_state; @@ -54,9 +54,8 @@ static void completion_callback_wrapper(const char *line, linenoiseCompletions * lua_setmetatable(L, -2); lua_pushstring(L, line); - lua_pushinteger(L, pos); - lua_pcall(L, 3, 0, 0); + lua_pcall(L, 2, 0, 0); } static int l_linenoise(lua_State *L) @@ -102,14 +101,6 @@ static int l_historyadd(lua_State *L) return handle_ln_ok(L); } -static int l_preloadbuffer(lua_State *L) -{ - const char *line = luaL_checkstring(L, 1); - linenoisePreloadBuffer(line); - - return handle_ln_ok(L); -} - static int l_historysetmaxlen(lua_State *L) { int len = luaL_checkinteger(L, 1); @@ -153,7 +144,7 @@ static int l_setcompletion(lua_State *L) lua_pushvalue(L, 1); completion_func_ref = luaL_ref(L, LUA_REGISTRYINDEX); - linenoiseSetCompletionCallback(completion_callback_wrapper); + linenoiseSetCompletionCallback(completion_callback_wrapper, NULL); return handle_ln_ok(L); } @@ -162,19 +153,12 @@ static int l_addcompletion(lua_State *L) { linenoiseCompletions *completions = *((linenoiseCompletions **) luaL_checkudata(L, 1, LN_COMPLETION_TYPE)); const char *entry = luaL_checkstring(L, 2); - int pos = luaL_checkinteger(L, 3); - linenoiseAddCompletion(completions, (char *) entry, pos); + linenoiseAddCompletion(completions, (char *) entry); return handle_ln_ok(L); } -static int l_refresh(lua_State *L) -{ - linenoiseRefresh(); - return handle_ln_ok(L); -} - static int l_historyget(lua_State *L) { int len, i; @@ -198,8 +182,6 @@ luaL_Reg linenoise_funcs[] = { { "clearscreen", l_clearscreen }, { "setcompletion", l_setcompletion}, { "addcompletion", l_addcompletion }, - { "preload", l_preloadbuffer }, - { "refresh", l_refresh }, /* Aliases for more consistent function names */ { "addhistory", l_historyadd }, diff --git a/plugins/console/init.lua b/plugins/console/init.lua index 1b40ac50bee..3e10e17bc14 100644 --- a/plugins/console/init.lua +++ b/plugins/console/init.lua @@ -23,16 +23,6 @@ function console.startplugin() local matches = {} local lastindex = 0 local consolebuf - _G.history = function (index) - local history = ln.historyget() - if index then - ln.preload(history[index]) - return - end - for num, line in ipairs(history) do - print(num, line) - end - end print(" /| /| /| /| /| _______") print(" / | / | / | / | / | / /") print(" / |/ | / | / |/ | / ____/ ") @@ -51,11 +41,11 @@ function console.startplugin() ln.historysetmaxlen(50) local scr = [[ local ln = require('linenoise') - ln.setcompletion(function(c, str, pos) - status = str .. "\x01" .. tostring(pos) + ln.setcompletion( + function(c, str) yield() - ln.addcompletion(c, status:match("([^\x01]*)\x01(.*)")) - end) + ln.addcompletion(c, str) + end) local ret = ln.linenoise('$PROMPT') if ret == nil then return "\n" @@ -256,7 +246,7 @@ function console.startplugin() lastindex = lastindex + 1 print(consolebuf[lastindex]) end - ln.refresh() + -- ln.refresh() FIXME: how to replicate this now that the API has been removed? end if conth.yield then conth:continue(get_completions(conth.result:match("([^\x01]*)\x01(.*)"))) diff --git a/scripts/src/3rdparty.lua b/scripts/src/3rdparty.lua index 5d98eba82cb..3ccd1c43b89 100644 --- a/scripts/src/3rdparty.lua +++ b/scripts/src/3rdparty.lua @@ -220,349 +220,350 @@ end -------------------------------------------------- project "softfloat3" -uuid "9c22fc90-53fd-11e8-b566-0800200c9a66" -kind "StaticLib" + uuid "9c22fc90-53fd-11e8-b566-0800200c9a66" + kind "StaticLib" -options { - "ForceCPP", -} + options { + "ForceCPP", + } -includedirs { - MAME_DIR .. "src/osd", - MAME_DIR .. "3rdparty/softfloat3/build/MAME", - MAME_DIR .. "3rdparty/softfloat3/source", - MAME_DIR .. "3rdparty/softfloat3/source/include", - MAME_DIR .. "3rdparty/softfloat3/source/8086", -} + includedirs { + MAME_DIR .. "src/osd", + MAME_DIR .. "3rdparty/softfloat3/build/MAME", + MAME_DIR .. "3rdparty/softfloat3/source", + MAME_DIR .. "3rdparty/softfloat3/source/include", + MAME_DIR .. "3rdparty/softfloat3/source/8086", + } -configuration { "gmake or ninja" } -buildoptions_cpp { - "-x c++", -} + configuration { "gmake or ninja" } + buildoptions_cpp { + "-x c++", + } if _OPTIONS["gcc"]~=nil and not string.find(_OPTIONS["gcc"], "clang") then - buildoptions_cpp { - "-Wno-error=implicit-fallthrough", - } + buildoptions_cpp { + "-Wno-error=implicit-fallthrough", + } end -configuration { "vs*" } -buildoptions { - "/wd4701", -- warning C4701: potentially uninitialized local variable 'xxx' used - "/wd4703", -- warning C4703: potentially uninitialized local pointer variable 'xxx' used -} + configuration { "vs*" } + buildoptions { + "/wd4701", -- warning C4701: potentially uninitialized local variable 'xxx' used + "/wd4703", -- warning C4703: potentially uninitialized local pointer variable 'xxx' used + } -configuration { } -defines { - "SOFTFLOAT_ROUND_ODD", - "INLINE_LEVEL=5", - "SOFTFLOAT_FAST_DIV32TO16", - "SOFTFLOAT_FAST_DIV64TO32", - "SOFTFLOAT_FAST_INT64" -} + configuration { } -files { - MAME_DIR .. "3rdparty/softfloat3/source/s_eq128.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_le128.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_lt128.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_shortShiftLeft128.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_shortShiftRight128.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_shortShiftRightJam64.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_shortShiftRightJam64Extra.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_shortShiftRightJam128.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_shortShiftRightJam128Extra.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_shiftRightJam32.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_shiftRightJam64.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_shiftRightJam64Extra.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_shiftRightJam128.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_shiftRightJam128Extra.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_shiftRightJam256M.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_countLeadingZeros8.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_countLeadingZeros16.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_countLeadingZeros32.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_countLeadingZeros64.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_add128.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_add256M.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_sub128.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_sub256M.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_mul64ByShifted32To128.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_mul64To128.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_mul128By32.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_mul128To256M.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_approxRecip_1Ks.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_approxRecip32_1.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_approxRecipSqrt_1Ks.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_approxRecipSqrt32_1.c", - MAME_DIR .. "3rdparty/softfloat3/source/8086/softfloat_raiseFlags.c", - MAME_DIR .. "3rdparty/softfloat3/source/8086/s_commonNaNToF16UI.c", - MAME_DIR .. "3rdparty/softfloat3/source/8086/s_propagateNaNF16UI.c", - MAME_DIR .. "3rdparty/softfloat3/source/8086/s_f32UIToCommonNaN.c", - MAME_DIR .. "3rdparty/softfloat3/source/8086/s_commonNaNToF32UI.c", - MAME_DIR .. "3rdparty/softfloat3/source/8086/s_propagateNaNF32UI.c", - MAME_DIR .. "3rdparty/softfloat3/source/8086/s_f64UIToCommonNaN.c", - MAME_DIR .. "3rdparty/softfloat3/source/8086/s_commonNaNToF64UI.c", - MAME_DIR .. "3rdparty/softfloat3/source/8086/s_propagateNaNF64UI.c", - MAME_DIR .. "3rdparty/softfloat3/source/8086/extF80M_isSignalingNaN.c", - MAME_DIR .. "3rdparty/softfloat3/source/8086/s_extF80UIToCommonNaN.c", - MAME_DIR .. "3rdparty/softfloat3/source/8086/s_commonNaNToExtF80UI.c", - MAME_DIR .. "3rdparty/softfloat3/source/8086/s_propagateNaNExtF80UI.c", - MAME_DIR .. "3rdparty/softfloat3/source/8086/f128M_isSignalingNaN.c", - MAME_DIR .. "3rdparty/softfloat3/source/8086/s_f128UIToCommonNaN.c", - MAME_DIR .. "3rdparty/softfloat3/source/8086/s_commonNaNToF128UI.c", - MAME_DIR .. "3rdparty/softfloat3/source/8086/s_propagateNaNF128UI.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_roundToUI32.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_roundToUI64.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_roundToI32.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_roundToI64.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_normSubnormalF16Sig.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_roundPackToF16.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_normRoundPackToF16.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_addMagsF16.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_subMagsF16.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_mulAddF16.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_normSubnormalF32Sig.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_roundPackToF32.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_normRoundPackToF32.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_addMagsF32.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_subMagsF32.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_mulAddF32.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_normSubnormalF64Sig.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_roundPackToF64.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_normRoundPackToF64.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_addMagsF64.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_subMagsF64.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_mulAddF64.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_normSubnormalExtF80Sig.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_roundPackToExtF80.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_normRoundPackToExtF80.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_addMagsExtF80.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_subMagsExtF80.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_normSubnormalF128Sig.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_roundPackToF128.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_normRoundPackToF128.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_addMagsF128.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_subMagsF128.c", - MAME_DIR .. "3rdparty/softfloat3/source/s_mulAddF128.c", - MAME_DIR .. "3rdparty/softfloat3/source/softfloat_state.c", - MAME_DIR .. "3rdparty/softfloat3/source/ui32_to_f16.c", - MAME_DIR .. "3rdparty/softfloat3/source/ui32_to_f32.c", - MAME_DIR .. "3rdparty/softfloat3/source/ui32_to_f64.c", - MAME_DIR .. "3rdparty/softfloat3/source/ui32_to_extF80.c", - MAME_DIR .. "3rdparty/softfloat3/source/ui32_to_extF80M.c", - MAME_DIR .. "3rdparty/softfloat3/source/ui32_to_f128.c", - MAME_DIR .. "3rdparty/softfloat3/source/ui32_to_f128M.c", - MAME_DIR .. "3rdparty/softfloat3/source/ui64_to_f16.c", - MAME_DIR .. "3rdparty/softfloat3/source/ui64_to_f32.c", - MAME_DIR .. "3rdparty/softfloat3/source/ui64_to_f64.c", - MAME_DIR .. "3rdparty/softfloat3/source/ui64_to_extF80.c", - MAME_DIR .. "3rdparty/softfloat3/source/ui64_to_extF80M.c", - MAME_DIR .. "3rdparty/softfloat3/source/ui64_to_f128.c", - MAME_DIR .. "3rdparty/softfloat3/source/ui64_to_f128M.c", - MAME_DIR .. "3rdparty/softfloat3/source/i32_to_f16.c", - MAME_DIR .. "3rdparty/softfloat3/source/i32_to_f32.c", - MAME_DIR .. "3rdparty/softfloat3/source/i32_to_f64.c", - MAME_DIR .. "3rdparty/softfloat3/source/i32_to_extF80.c", - MAME_DIR .. "3rdparty/softfloat3/source/i32_to_extF80M.c", - MAME_DIR .. "3rdparty/softfloat3/source/i32_to_f128.c", - MAME_DIR .. "3rdparty/softfloat3/source/i32_to_f128M.c", - MAME_DIR .. "3rdparty/softfloat3/source/i64_to_f16.c", - MAME_DIR .. "3rdparty/softfloat3/source/i64_to_f32.c", - MAME_DIR .. "3rdparty/softfloat3/source/i64_to_f64.c", - MAME_DIR .. "3rdparty/softfloat3/source/i64_to_extF80.c", - MAME_DIR .. "3rdparty/softfloat3/source/i64_to_extF80M.c", - MAME_DIR .. "3rdparty/softfloat3/source/i64_to_f128.c", - MAME_DIR .. "3rdparty/softfloat3/source/i64_to_f128M.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_to_ui32.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_to_ui64.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_to_i32.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_to_i64.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_to_ui32_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_to_ui64_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_to_i32_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_to_i64_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_to_f32.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_to_f64.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_to_extF80.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_to_extF80M.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_to_f128.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_to_f128M.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_roundToInt.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_add.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_sub.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_mul.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_mulAdd.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_div.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_rem.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_sqrt.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_eq.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_le.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_lt.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_eq_signaling.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_le_quiet.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_lt_quiet.c", - MAME_DIR .. "3rdparty/softfloat3/source/f16_isSignalingNaN.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_to_ui32.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_to_ui64.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_to_i32.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_to_i64.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_to_ui32_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_to_ui64_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_to_i32_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_to_i64_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_to_f16.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_to_f64.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_to_extF80.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_to_extF80M.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_to_f128.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_to_f128M.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_roundToInt.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_add.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_sub.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_mul.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_mulAdd.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_div.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_rem.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_sqrt.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_eq.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_le.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_lt.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_eq_signaling.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_le_quiet.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_lt_quiet.c", - MAME_DIR .. "3rdparty/softfloat3/source/f32_isSignalingNaN.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_to_ui32.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_to_ui64.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_to_i32.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_to_i64.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_to_ui32_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_to_ui64_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_to_i32_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_to_i64_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_to_f16.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_to_f32.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_to_extF80.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_to_extF80M.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_to_f128.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_to_f128M.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_roundToInt.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_add.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_sub.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_mul.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_mulAdd.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_div.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_rem.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_sqrt.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_eq.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_le.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_lt.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_eq_signaling.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_le_quiet.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_lt_quiet.c", - MAME_DIR .. "3rdparty/softfloat3/source/f64_isSignalingNaN.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_ui32.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_ui64.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_i32.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_i64.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_ui32_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_ui64_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_i32_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_i64_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_f16.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_f32.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_f64.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_f128.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_roundToInt.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_add.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_sub.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_mul.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_div.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_rem.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_sqrt.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_eq.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_le.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_lt.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_eq_signaling.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_le_quiet.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_lt_quiet.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80_isSignalingNaN.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_ui32.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_ui64.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_i32.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_i64.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_ui32_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_ui64_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_i32_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_i64_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_f16.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_f32.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_f64.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_f128M.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_roundToInt.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_add.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_sub.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_mul.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_div.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_rem.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_sqrt.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_eq.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_le.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_lt.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_eq_signaling.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_le_quiet.c", - MAME_DIR .. "3rdparty/softfloat3/source/extF80M_lt_quiet.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_to_ui32.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_to_ui64.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_to_i32.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_to_i64.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_to_ui32_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_to_ui64_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_to_i32_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_to_i64_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_to_f16.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_to_f32.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_to_extF80.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_to_f64.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_roundToInt.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_add.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_sub.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_mul.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_mulAdd.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_div.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_rem.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_sqrt.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_eq.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_le.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_lt.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_eq_signaling.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_le_quiet.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_lt_quiet.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128_isSignalingNaN.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_ui32.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_ui64.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_i32.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_i64.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_ui32_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_ui64_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_i32_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_i64_r_minMag.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_f16.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_f32.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_extF80M.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_f64.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_roundToInt.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_add.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_sub.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_mul.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_mulAdd.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_div.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_rem.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_sqrt.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_eq.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_le.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_lt.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_eq_signaling.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_le_quiet.c", - MAME_DIR .. "3rdparty/softfloat3/source/f128M_lt_quiet.c", -} + defines { + "SOFTFLOAT_ROUND_ODD", + "INLINE_LEVEL=5", + "SOFTFLOAT_FAST_DIV32TO16", + "SOFTFLOAT_FAST_DIV64TO32", + "SOFTFLOAT_FAST_INT64" + } + + files { + MAME_DIR .. "3rdparty/softfloat3/source/s_eq128.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_le128.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_lt128.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_shortShiftLeft128.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_shortShiftRight128.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_shortShiftRightJam64.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_shortShiftRightJam64Extra.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_shortShiftRightJam128.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_shortShiftRightJam128Extra.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_shiftRightJam32.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_shiftRightJam64.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_shiftRightJam64Extra.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_shiftRightJam128.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_shiftRightJam128Extra.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_shiftRightJam256M.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_countLeadingZeros8.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_countLeadingZeros16.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_countLeadingZeros32.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_countLeadingZeros64.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_add128.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_add256M.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_sub128.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_sub256M.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_mul64ByShifted32To128.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_mul64To128.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_mul128By32.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_mul128To256M.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_approxRecip_1Ks.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_approxRecip32_1.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_approxRecipSqrt_1Ks.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_approxRecipSqrt32_1.c", + MAME_DIR .. "3rdparty/softfloat3/source/8086/softfloat_raiseFlags.c", + MAME_DIR .. "3rdparty/softfloat3/source/8086/s_commonNaNToF16UI.c", + MAME_DIR .. "3rdparty/softfloat3/source/8086/s_propagateNaNF16UI.c", + MAME_DIR .. "3rdparty/softfloat3/source/8086/s_f32UIToCommonNaN.c", + MAME_DIR .. "3rdparty/softfloat3/source/8086/s_commonNaNToF32UI.c", + MAME_DIR .. "3rdparty/softfloat3/source/8086/s_propagateNaNF32UI.c", + MAME_DIR .. "3rdparty/softfloat3/source/8086/s_f64UIToCommonNaN.c", + MAME_DIR .. "3rdparty/softfloat3/source/8086/s_commonNaNToF64UI.c", + MAME_DIR .. "3rdparty/softfloat3/source/8086/s_propagateNaNF64UI.c", + MAME_DIR .. "3rdparty/softfloat3/source/8086/extF80M_isSignalingNaN.c", + MAME_DIR .. "3rdparty/softfloat3/source/8086/s_extF80UIToCommonNaN.c", + MAME_DIR .. "3rdparty/softfloat3/source/8086/s_commonNaNToExtF80UI.c", + MAME_DIR .. "3rdparty/softfloat3/source/8086/s_propagateNaNExtF80UI.c", + MAME_DIR .. "3rdparty/softfloat3/source/8086/f128M_isSignalingNaN.c", + MAME_DIR .. "3rdparty/softfloat3/source/8086/s_f128UIToCommonNaN.c", + MAME_DIR .. "3rdparty/softfloat3/source/8086/s_commonNaNToF128UI.c", + MAME_DIR .. "3rdparty/softfloat3/source/8086/s_propagateNaNF128UI.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_roundToUI32.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_roundToUI64.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_roundToI32.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_roundToI64.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_normSubnormalF16Sig.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_roundPackToF16.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_normRoundPackToF16.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_addMagsF16.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_subMagsF16.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_mulAddF16.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_normSubnormalF32Sig.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_roundPackToF32.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_normRoundPackToF32.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_addMagsF32.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_subMagsF32.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_mulAddF32.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_normSubnormalF64Sig.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_roundPackToF64.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_normRoundPackToF64.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_addMagsF64.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_subMagsF64.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_mulAddF64.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_normSubnormalExtF80Sig.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_roundPackToExtF80.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_normRoundPackToExtF80.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_addMagsExtF80.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_subMagsExtF80.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_normSubnormalF128Sig.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_roundPackToF128.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_normRoundPackToF128.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_addMagsF128.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_subMagsF128.c", + MAME_DIR .. "3rdparty/softfloat3/source/s_mulAddF128.c", + MAME_DIR .. "3rdparty/softfloat3/source/softfloat_state.c", + MAME_DIR .. "3rdparty/softfloat3/source/ui32_to_f16.c", + MAME_DIR .. "3rdparty/softfloat3/source/ui32_to_f32.c", + MAME_DIR .. "3rdparty/softfloat3/source/ui32_to_f64.c", + MAME_DIR .. "3rdparty/softfloat3/source/ui32_to_extF80.c", + MAME_DIR .. "3rdparty/softfloat3/source/ui32_to_extF80M.c", + MAME_DIR .. "3rdparty/softfloat3/source/ui32_to_f128.c", + MAME_DIR .. "3rdparty/softfloat3/source/ui32_to_f128M.c", + MAME_DIR .. "3rdparty/softfloat3/source/ui64_to_f16.c", + MAME_DIR .. "3rdparty/softfloat3/source/ui64_to_f32.c", + MAME_DIR .. "3rdparty/softfloat3/source/ui64_to_f64.c", + MAME_DIR .. "3rdparty/softfloat3/source/ui64_to_extF80.c", + MAME_DIR .. "3rdparty/softfloat3/source/ui64_to_extF80M.c", + MAME_DIR .. "3rdparty/softfloat3/source/ui64_to_f128.c", + MAME_DIR .. "3rdparty/softfloat3/source/ui64_to_f128M.c", + MAME_DIR .. "3rdparty/softfloat3/source/i32_to_f16.c", + MAME_DIR .. "3rdparty/softfloat3/source/i32_to_f32.c", + MAME_DIR .. "3rdparty/softfloat3/source/i32_to_f64.c", + MAME_DIR .. "3rdparty/softfloat3/source/i32_to_extF80.c", + MAME_DIR .. "3rdparty/softfloat3/source/i32_to_extF80M.c", + MAME_DIR .. "3rdparty/softfloat3/source/i32_to_f128.c", + MAME_DIR .. "3rdparty/softfloat3/source/i32_to_f128M.c", + MAME_DIR .. "3rdparty/softfloat3/source/i64_to_f16.c", + MAME_DIR .. "3rdparty/softfloat3/source/i64_to_f32.c", + MAME_DIR .. "3rdparty/softfloat3/source/i64_to_f64.c", + MAME_DIR .. "3rdparty/softfloat3/source/i64_to_extF80.c", + MAME_DIR .. "3rdparty/softfloat3/source/i64_to_extF80M.c", + MAME_DIR .. "3rdparty/softfloat3/source/i64_to_f128.c", + MAME_DIR .. "3rdparty/softfloat3/source/i64_to_f128M.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_to_ui32.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_to_ui64.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_to_i32.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_to_i64.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_to_ui32_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_to_ui64_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_to_i32_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_to_i64_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_to_f32.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_to_f64.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_to_extF80.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_to_extF80M.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_to_f128.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_to_f128M.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_roundToInt.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_add.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_sub.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_mul.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_mulAdd.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_div.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_rem.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_sqrt.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_eq.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_le.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_lt.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_eq_signaling.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_le_quiet.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_lt_quiet.c", + MAME_DIR .. "3rdparty/softfloat3/source/f16_isSignalingNaN.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_to_ui32.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_to_ui64.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_to_i32.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_to_i64.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_to_ui32_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_to_ui64_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_to_i32_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_to_i64_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_to_f16.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_to_f64.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_to_extF80.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_to_extF80M.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_to_f128.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_to_f128M.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_roundToInt.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_add.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_sub.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_mul.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_mulAdd.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_div.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_rem.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_sqrt.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_eq.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_le.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_lt.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_eq_signaling.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_le_quiet.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_lt_quiet.c", + MAME_DIR .. "3rdparty/softfloat3/source/f32_isSignalingNaN.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_to_ui32.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_to_ui64.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_to_i32.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_to_i64.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_to_ui32_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_to_ui64_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_to_i32_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_to_i64_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_to_f16.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_to_f32.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_to_extF80.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_to_extF80M.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_to_f128.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_to_f128M.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_roundToInt.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_add.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_sub.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_mul.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_mulAdd.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_div.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_rem.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_sqrt.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_eq.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_le.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_lt.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_eq_signaling.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_le_quiet.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_lt_quiet.c", + MAME_DIR .. "3rdparty/softfloat3/source/f64_isSignalingNaN.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_ui32.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_ui64.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_i32.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_i64.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_ui32_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_ui64_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_i32_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_i64_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_f16.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_f32.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_f64.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_to_f128.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_roundToInt.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_add.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_sub.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_mul.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_div.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_rem.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_sqrt.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_eq.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_le.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_lt.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_eq_signaling.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_le_quiet.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_lt_quiet.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80_isSignalingNaN.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_ui32.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_ui64.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_i32.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_i64.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_ui32_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_ui64_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_i32_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_i64_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_f16.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_f32.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_f64.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_to_f128M.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_roundToInt.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_add.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_sub.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_mul.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_div.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_rem.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_sqrt.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_eq.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_le.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_lt.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_eq_signaling.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_le_quiet.c", + MAME_DIR .. "3rdparty/softfloat3/source/extF80M_lt_quiet.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_to_ui32.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_to_ui64.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_to_i32.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_to_i64.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_to_ui32_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_to_ui64_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_to_i32_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_to_i64_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_to_f16.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_to_f32.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_to_extF80.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_to_f64.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_roundToInt.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_add.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_sub.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_mul.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_mulAdd.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_div.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_rem.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_sqrt.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_eq.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_le.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_lt.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_eq_signaling.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_le_quiet.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_lt_quiet.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128_isSignalingNaN.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_ui32.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_ui64.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_i32.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_i64.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_ui32_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_ui64_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_i32_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_i64_r_minMag.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_f16.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_f32.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_extF80M.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_to_f64.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_roundToInt.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_add.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_sub.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_mul.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_mulAdd.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_div.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_rem.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_sqrt.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_eq.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_le.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_lt.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_eq_signaling.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_le_quiet.c", + MAME_DIR .. "3rdparty/softfloat3/source/f128M_lt_quiet.c", + } ------------------------------------------------- @@ -848,8 +849,8 @@ project "lua" } configuration { "gmake or ninja" } - buildoptions_c { - "-Wno-bad-function-cast" + buildoptions_cpp { + "-x c++", } configuration { "vs*" } @@ -939,6 +940,9 @@ project "lualibs" buildoptions { "-Wno-error=unused-variable", } + buildoptions_cpp { + "-x c++", + } configuration { "vs*" } buildoptions { @@ -1674,14 +1678,10 @@ project "linenoise" addprojectflags() - options { - "ForceCPP", - } - configuration { "gmake or ninja" } buildoptions { "-Wno-error=unused-variable", - "-Wno-error=implicit-fallthrough", + "-Wno-error=strict-prototypes", } configuration { "vs*" } @@ -1691,13 +1691,18 @@ project "linenoise" configuration { } + defines { + "USE_UTF8", + } + includedirs { MAME_DIR .. "3rdparty/linenoise", } files { - MAME_DIR .. "3rdparty/linenoise/utf8.c", MAME_DIR .. "3rdparty/linenoise/linenoise.c", + MAME_DIR .. "3rdparty/linenoise/stringbuf.c", + MAME_DIR .. "3rdparty/linenoise/utf8.c", } -- cgit v1.2.3