diff --git a/main.c b/main.c index cb64dca..944bd83 100644 --- a/main.c +++ b/main.c @@ -84,7 +84,7 @@ static void repl(CState *state) linenoiseHistoryAdd(line); interpret(state, line, "REPL"); - linenoiseFree(line); + free(line); } } diff --git a/util/linenoise.c b/util/linenoise.c index 5e8aee5..3ed891a 100644 --- a/util/linenoise.c +++ b/util/linenoise.c @@ -1,17 +1,716 @@ +#line 1 "utf8.h" +#ifndef UTF8_UTIL_H +#define UTF8_UTIL_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * UTF-8 utility functions + * + * (c) 2010-2019 Steve Bennett + * + * See utf8.c for licence details. + */ + +#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)) +#define utf8_tounicode(S, CP) (*(CP) = (unsigned char)*(S), 1) +#define utf8_index(C, I) (I) +#define utf8_charlen(C) 1 + #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'. + * + * Returns the number of utf-8 characters + */ +int utf8_fromunicode(char *p, unsigned uc); + +/** + * Returns the length of the utf-8 sequence starting with 'c'. + * + * Returns 1-4, or -1 if this is not a valid start byte. + * + * Note that charlen=4 is not supported by the rest of the API. + */ +int utf8_charlen(int c); + +/** + * Returns the number of characters in the utf-8 + * string of the given byte length. + * + * Any bytes which are not part of an valid utf-8 + * sequence are treated as individual characters. + * + * The string *must* be null terminated. + * + * Does not support unicode code points > \u1fffff + */ +int utf8_strlen(const char *str, int bytelen); + +/** + * Calculates the display width of the first 'charlen' characters in 'str'. + * See utf8_width() + */ +int utf8_strwidth(const char *str, int charlen); + +/** + * Returns the byte index of the given character in the utf-8 string. + * + * The string *must* be null terminated. + * + * This will return the byte length of a utf-8 string + * if given the char length. + */ +int utf8_index(const char *str, int charindex); + +/** + * Returns the unicode codepoint corresponding to the + * utf-8 sequence 'str'. + * + * Stores the result in *uc and returns the number of bytes + * consumed. + * + * If 'str' is null terminated, then an invalid utf-8 sequence + * at the end of the string will be returned as individual bytes. + * + * If it is not null terminated, the length *must* be checked first. + * + * Does not support unicode code points > \u1fffff + */ +int utf8_tounicode(const char *str, int *uc); + +/** + * Returns the width (in characters) of the given unicode codepoint. + * This is 1 for normal letters and 0 for combining characters and 2 for wide characters. + */ +int utf8_width(int ch); + +#endif + +#ifdef __cplusplus +} +#endif + +#endif +#line 1 "utf8.c" +/** + * UTF-8 utility functions + * + * (c) 2010-2019 Steve Bennett + * + * 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) +{ + if (uc <= 0x7f) { + *p = uc; + return 1; + } + else if (uc <= 0x7ff) { + *p++ = 0xc0 | ((uc & 0x7c0) >> 6); + *p = 0x80 | (uc & 0x3f); + return 2; + } + else if (uc <= 0xffff) { + *p++ = 0xe0 | ((uc & 0xf000) >> 12); + *p++ = 0x80 | ((uc & 0xfc0) >> 6); + *p = 0x80 | (uc & 0x3f); + return 3; + } + /* Note: We silently truncate to 21 bits here: 0x1fffff */ + else { + *p++ = 0xf0 | ((uc & 0x1c0000) >> 18); + *p++ = 0x80 | ((uc & 0x3f000) >> 12); + *p++ = 0x80 | ((uc & 0xfc0) >> 6); + *p = 0x80 | (uc & 0x3f); + return 4; + } +} + +int utf8_charlen(int c) +{ + if ((c & 0x80) == 0) { + return 1; + } + if ((c & 0xe0) == 0xc0) { + return 2; + } + if ((c & 0xf0) == 0xe0) { + return 3; + } + if ((c & 0xf8) == 0xf0) { + return 4; + } + /* Invalid sequence */ + return -1; +} + +int utf8_strlen(const char *str, int bytelen) +{ + int charlen = 0; + if (bytelen < 0) { + bytelen = strlen(str); + } + while (bytelen > 0) { + int c; + int l = utf8_tounicode(str, &c); + charlen++; + str += l; + bytelen -= l; + } + return charlen; +} + +int utf8_strwidth(const char *str, int charlen) +{ + int width = 0; + while (charlen) { + int c; + int l = utf8_tounicode(str, &c); + width += utf8_width(c); + str += l; + charlen--; + } + return width; +} + +int utf8_index(const char *str, int index) +{ + const char *s = str; + while (index--) { + int c; + s += utf8_tounicode(s, &c); + } + return s - str; +} + +int utf8_tounicode(const char *str, int *uc) +{ + unsigned const char *s = (unsigned const char *)str; + + if (s[0] < 0xc0) { + *uc = s[0]; + return 1; + } + if (s[0] < 0xe0) { + if ((s[1] & 0xc0) == 0x80) { + *uc = ((s[0] & ~0xc0) << 6) | (s[1] & ~0x80); + 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); + 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); + if (*uc >= 0x10000) { + return 4; + } + /* Otherwise this is an invalid sequence */ + } + } + + /* Invalid sequence, so just return the byte */ + *uc = *s; + return 1; +} + +struct utf8range { + int lower; /* lower inclusive */ + int upper; /* upper exclusive */ +}; + +/* From http://unicode.org/Public/UNIDATA/UnicodeData.txt */ +static const struct utf8range unicode_range_combining[] = { + { 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 }, { 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)) + +static int cmp_range(const void *key, const void *cm) +{ + const struct utf8range *range = (const struct utf8range *)cm; + int ch = *(int *)key; + if (ch < range->lower) { + return -1; + } + if (ch >= range->upper) { + return 1; + } + return 0; +} + +static int utf8_in_range(const struct utf8range *range, int num, int ch) +{ + const struct utf8range *r = + bsearch(&ch, range, num, sizeof(*range), cmp_range); + + if (r) { + return 1; + } + return 0; +} + +int utf8_width(int ch) +{ + /* short circuit for common case */ + if (isascii(ch)) { + return 1; + } + if (utf8_in_range(unicode_range_combining, ARRAYSIZE(unicode_range_combining), ch)) { + return 0; + } + if (utf8_in_range(unicode_range_wide, ARRAYSIZE(unicode_range_wide), ch)) { + return 2; + } + return 1; +} +#endif +#line 1 "stringbuf.h" +#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 +#line 1 "stringbuf.c" +/** + * 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 + } +} +#line 1 "linenoise.c" /* linenoise.c -- guerrilla line editing library against the idea that a * line editing lib needs to be 20,000 lines of C code. * * You can find the latest source code at: * - * http://github.com/antirez/linenoise + * http://github.com/msteveb/linenoise + * (forked from http://github.com/antirez/linenoise) * * Does a number of crazy assumptions that happen to be true in 99.9999% of * the 2010 UNIX computers around. * * ------------------------------------------------------------------------ * - * Copyright (c) 2010-2023, Salvatore Sanfilippo - * Copyright (c) 2010-2013, Pieter Noordhuis + * Copyright (c) 2010, Salvatore Sanfilippo + * Copyright (c) 2010, Pieter Noordhuis + * Copyright (c) 2011, Steve Bennett * * All rights reserved. * @@ -44,195 +743,377 @@ * - http://invisible-island.net/xterm/ctlseqs/ctlseqs.html * - http://www.3waylabs.com/nw/WWW/products/wizcon/vt220.html * - * Todo list: - * - Filter bogus Ctrl+ combinations. - * - Win32 support - * * Bloat: - * - History search like Ctrl+r in readline? + * - Completion? * + * Unix/termios + * ------------ * List of escape sequences used by this program, we do everything just - * with three sequences. In order to be so cheap we may have some + * a few sequences. In order to be so cheap we may have some * flickering effect with some slow terminal, but the lesser sequences * the more compatible. * * EL (Erase Line) - * Sequence: ESC [ n K - * Effect: if n is 0 or missing, clear from cursor to end of line - * Effect: if n is 1, clear from beginning of line to cursor - * Effect: if n is 2, clear entire line + * Sequence: ESC [ 0 K + * Effect: clear from cursor to end of line * * CUF (CUrsor Forward) * Sequence: ESC [ n C * Effect: moves cursor forward n chars * - * CUB (CUrsor Backward) - * Sequence: ESC [ n D - * Effect: moves cursor backward n chars + * CR (Carriage Return) + * Sequence: \r + * Effect: moves cursor to column 1 * - * The following is used to get the terminal width if getting - * the width with the TIOCGWINSZ ioctl fails + * The following are used to clear the screen: ESC [ H ESC [ 2 J + * This is actually composed of two sequences: * - * DSR (Device Status Report) - * Sequence: ESC [ 6 n - * Effect: reports the current cusor position as ESC [ n ; m R - * where n is the row and m is the column - * - * When multi line mode is enabled, we also use an additional escape - * sequence. However multi line editing is disabled by default. - * - * CUU (Cursor Up) - * Sequence: ESC [ n A - * Effect: moves cursor up of n chars. - * - * CUD (Cursor Down) - * Sequence: ESC [ n B - * Effect: moves cursor down of n chars. - * - * When linenoiseClearScreen() is called, two additional escape sequences - * are used in order to clear the screen and position the cursor at home - * position. - * - * CUP (Cursor position) + * cursorhome * Sequence: ESC [ H * Effect: moves the cursor to upper left corner * - * ED (Erase display) + * ED2 (Clear entire screen) * Sequence: ESC [ 2 J * Effect: clear the whole screen * + * == For highlighting control characters, we also use the following two == + * SO (enter StandOut) + * Sequence: ESC [ 7 m + * Effect: Uses some standout mode such as reverse video + * + * SE (Standout End) + * Sequence: ESC [ 0 m + * Effect: Exit standout mode + * + * == Only used if TIOCGWINSZ fails == + * DSR/CPR (Report cursor position) + * Sequence: ESC [ 6 n + * Effect: reports current cursor position as ESC [ NNN ; MMM R + * + * == 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. + * This could probably be made to work for the msvc compiler too. + * This support based in part on work by Jon Griffiths. */ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "linenoise.h" - -#define LINENOISE_DEFAULT_HISTORY_MAX_LEN 100 -#define LINENOISE_MAX_LINE 4096 -static char *unsupported_term[] = {"dumb","cons25","emacs",NULL}; -static linenoiseCompletionCallback *completionCallback = NULL; -static linenoiseHintsCallback *hintsCallback = NULL; -static linenoiseFreeHintsCallback *freeHintsCallback = NULL; -static char *linenoiseNoTTY(void); -static void refreshLineWithCompletion(struct linenoiseState *ls, linenoiseCompletions *lc, int flags); -static void refreshLineWithFlags(struct linenoiseState *l, int flags); - -static struct termios orig_termios; /* In order to restore at exit.*/ -static int maskmode = 0; /* Show "***" instead of input. For passwords. */ -static int rawmode = 0; /* For atexit() function to check if restore is needed*/ -static int mlmode = 0; /* Multi line mode. Default is single line. */ -static int atexit_registered = 0; /* Register atexit just 1 time. */ -static int history_max_len = LINENOISE_DEFAULT_HISTORY_MAX_LEN; -static int history_len = 0; -static char **history = NULL; - -enum KEY_ACTION{ - KEY_NULL = 0, /* NULL */ - CTRL_A = 1, /* Ctrl+a */ - CTRL_B = 2, /* Ctrl-b */ - CTRL_C = 3, /* Ctrl-c */ - CTRL_D = 4, /* Ctrl-d */ - CTRL_E = 5, /* Ctrl-e */ - CTRL_F = 6, /* Ctrl-f */ - CTRL_H = 8, /* Ctrl-h */ - TAB = 9, /* Tab */ - CTRL_K = 11, /* Ctrl+k */ - CTRL_L = 12, /* Ctrl+l */ - ENTER = 13, /* Enter */ - CTRL_N = 14, /* Ctrl-n */ - CTRL_P = 16, /* Ctrl-p */ - CTRL_T = 20, /* Ctrl-t */ - CTRL_U = 21, /* Ctrl+u */ - CTRL_W = 23, /* Ctrl+w */ - ESC = 27, /* Escape */ - BACKSPACE = 127 /* Backspace */ -}; - -static void linenoiseAtExit(void); -int linenoiseHistoryAdd(const char *line); -#define REFRESH_CLEAN (1<<0) // Clean the old prompt from the screen -#define REFRESH_WRITE (1<<1) // Rewrite the prompt on the screen. -#define REFRESH_ALL (REFRESH_CLEAN|REFRESH_WRITE) // Do both. -static void refreshLine(struct linenoiseState *l); - -/* Debugging macro. */ -#if 0 -FILE *lndebug_fp = NULL; -#define lndebug(...) \ - do { \ - if (lndebug_fp == NULL) { \ - lndebug_fp = fopen("/tmp/lndebug.txt","a"); \ - fprintf(lndebug_fp, \ - "[%d %d %d] p: %d, rows: %d, rpos: %d, max: %d, oldmax: %d\n", \ - (int)l->len,(int)l->pos,(int)l->oldpos,plen,rows,rpos, \ - (int)l->oldrows,old_rows); \ - } \ - fprintf(lndebug_fp, ", " __VA_ARGS__); \ - fflush(lndebug_fp); \ - } while (0) +#ifdef _WIN32 /* Windows platform, either MinGW or Visual Studio (MSVC) */ +#include +#include +#define USE_WINCONSOLE +#ifdef __MINGW32__ +#define HAVE_UNISTD_H +#endif #else -#define lndebug(fmt, ...) +#include +#include +#include +#define USE_TERMIOS +#define HAVE_UNISTD_H #endif -/* ======================= Low level terminal handling ====================== */ +#ifdef HAVE_UNISTD_H +#include +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include -/* Enable "mask mode". When it is enabled, instead of the input that - * the user is typing, the terminal will just display a corresponding - * number of asterisks, like "****". This is useful for passwords and other - * secrets that should not be displayed. */ -void linenoiseMaskModeEnable(void) { - maskmode = 1; +#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 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, + SPECIAL_RIGHT = -23, + SPECIAL_DELETE = -24, + SPECIAL_HOME = -25, + SPECIAL_END = -26, + SPECIAL_INSERT = -27, + SPECIAL_PAGE_UP = -28, + 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 int history_index = 0; +static char **history = NULL; + +/* Structure to contain the status of the current (being edited) line */ +struct current { + 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; + 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) + HANDLE outh; /* Console output handle */ + HANDLE inh; /* Console input handle */ + 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 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 } -/* Disable mask mode. */ -void linenoiseMaskModeDisable(void) { - maskmode = 0; +void linenoiseHistoryFree(void) { + if (history) { + int j; + + for (j = 0; j < history_len; j++) + free(history[j]); + free(history); + history = NULL; + history_len = 0; + } } -/* Set if to use or not the multi line mode. */ -void linenoiseSetMultiLine(int ml) { - mlmode = ml; +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 */ +}; + +/** + * 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; } -/* Return true if the terminal name is in the list of terminals we know are - * not able to understand basic escape sequences. */ +/** + * 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; + } + /* 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; + case EP_ERROR: + break; + } + 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); +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","emacs",NULL}; + static int isUnsupportedTerm(void) { char *term = getenv("TERM"); - int j; - if (term == NULL) return 0; - for (j = 0; unsupported_term[j]; j++) - if (!strcasecmp(term,unsupported_term[j])) return 1; + if (term) { + int j; + for (j = 0; unsupported_term[j]; j++) { + if (strcmp(term, unsupported_term[j]) == 0) { + return 1; + } + } + } return 0; } -/* Raw mode: 1960 magic shit. */ -static int enableRawMode(int fd) { +static int enableRawMode(struct current *current) { struct termios raw; - if (!isatty(STDIN_FILENO)) goto fatal; + current->fd = STDIN_FILENO; + current->cols = 0; + + if (!isatty(current->fd) || isUnsupportedTerm() || + tcgetattr(current->fd, &orig_termios) == -1) { +fatal: + errno = ENOTTY; + return -1; + } + if (!atexit_registered) { atexit(linenoiseAtExit); atexit_registered = 1; } - if (tcgetattr(fd,&orig_termios) == -1) goto fatal; raw = orig_termios; /* modify the original mode */ /* input modes: no break, no CR to NL, no parity check, no strip char, * no start/stop output control. */ raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON); - /* output modes - disable post processing */ - raw.c_oflag &= ~(OPOST); + /* output modes - actually, no need to disable post processing */ + /*raw.c_oflag &= ~(OPOST);*/ /* control modes - set 8 bit chars */ raw.c_cflag |= (CS8); /* local modes - choing off, canonical off, no extended functions, @@ -243,194 +1124,452 @@ static int enableRawMode(int fd) { raw.c_cc[VMIN] = 1; raw.c_cc[VTIME] = 0; /* 1 byte, no timer */ /* put terminal in raw mode after flushing */ - if (tcsetattr(fd,TCSAFLUSH,&raw) < 0) goto fatal; + if (tcsetattr(current->fd,TCSADRAIN,&raw) < 0) { + goto fatal; + } rawmode = 1; return 0; - -fatal: - errno = ENOTTY; - return -1; } -static void disableRawMode(int fd) { +static void disableRawMode(struct current *current) { /* Don't even check the return value as it's too late. */ - if (rawmode && tcsetattr(fd,TCSAFLUSH,&orig_termios) != -1) + if (rawmode && tcsetattr(current->fd,TCSADRAIN,&orig_termios) != -1) rawmode = 0; } -/* Use the ESC [6n escape sequence to query the horizontal cursor position - * and return it. On error -1 is returned, on success the position of the - * cursor. */ -static int getCursorPosition(int ifd, int ofd) { - char buf[32]; - int cols, rows; - unsigned int i = 0; - - /* Report cursor location */ - if (write(ofd, "\x1b[6n", 4) != 4) return -1; - - /* Read the response: ESC [ rows ; cols R */ - while (i < sizeof(buf)-1) { - if (read(ifd,buf+i,1) != 1) break; - if (buf[i] == 'R') break; - i++; +/* At exit we'll try to fix the terminal to the initial conditions. */ +static void linenoiseAtExit(void) { + if (rawmode) { + tcsetattr(STDIN_FILENO, TCSADRAIN, &orig_termios); } - buf[i] = '\0'; - - /* Parse it. */ - if (buf[0] != ESC || buf[1] != '[') return -1; - if (sscanf(buf+2,"%d;%d",&rows,&cols) != 2) return -1; - return cols; + linenoiseHistoryFree(); } -/* Try to get the number of columns in the current terminal, or assume 80 - * if it fails. */ -static int getColumns(int ifd, int ofd) { +/* gcc/glibc insists that we care about the return code of write! + * Clarification: This means that a void-cast like "(void) (EXPR)" + * does not work. + */ +#define IGNORE_RC(EXPR) if (EXPR) {} + +/** + * 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 outputFormatted(struct current *current, const char *format, ...) +{ + va_list args; + char buf[64]; + int n; + + 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); + outputChars(current, buf, n); +} + +static void cursorToLeft(struct current *current) +{ + outputChars(current, "\r", -1); +} + +static void setOutputHighlight(struct current *current, const int *props, int nprops) +{ + outputChars(current, "\x1b[", -1); + while (nprops--) { + outputFormatted(current, "%d%c", *props, (nprops == 0) ? 'm' : ';'); + props++; + } +} + +static void eraseEol(struct current *current) +{ + outputChars(current, "\x1b[0K", -1); +} + +static void setCursorPos(struct current *current, int x) +{ + if (x == 0) { + cursorToLeft(current); + } + else { + 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. + * + * A timeout of -1 means to wait forever. + * + * Returns -1 if no char is received within the time or an error occurs. + */ +static int fd_read_char(int fd, int timeout) +{ + struct pollfd p; + unsigned char c; + + p.fd = fd; + p.events = POLLIN; + + if (poll(&p, 1, timeout) == 0) { + /* timeout */ + return -1; + } + if (read(fd, &c, 1) != 1) { + return -1; + } + return c; +} + +/** + * Reads a complete utf-8 character + * and returns the unicode value, or -1 on error. + */ +static int fd_read(struct current *current) +{ +#ifdef USE_UTF8 + char buf[MAX_UTF8_LEN]; + int n; + int i; + int c; + + if (read(current->fd, &buf[0], 1) != 1) { + return -1; + } + n = utf8_charlen(buf[0]); + if (n < 1) { + return -1; + } + for (i = 1; i < n; i++) { + if (read(current->fd, &buf[i], 1) != 1) { + return -1; + } + } + /* decode and return the character */ + utf8_tounicode(buf, &c); + return c; +#else + return fd_read_char(current->fd, -1); +#endif +} + + +/** + * Stores the current cursor column in '*cols'. + * Returns 1 if OK, or 0 if failed to determine cursor pos. + */ +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 */ + outputChars(current, "\x1b[6n", -1); + + /* Parse the response: ESC [ rows ; cols R */ + 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; + case EP_ERROR: + break; + } + /* failed */ + break; + } + return 0; +} + +/** + * Updates current->cols with the current window size (width) + */ +static int getWindowSize(struct current *current) +{ struct winsize ws; - if (ioctl(1, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0) { - /* ioctl() failed. Try to query the terminal itself. */ - int start, cols; + if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0 && ws.ws_col != 0) { + current->cols = ws.ws_col; + return 0; + } - /* Get the initial position so we can restore it later. */ - start = getCursorPosition(ifd,ofd); - if (start == -1) goto failed; + /* Failed to query the window size. Perhaps we are on a serial terminal. + * Try to query the width by sending the cursor as far to the right + * and reading back the cursor position. + * Note that this is only done once per call to linenoise rather than + * every time the line is refreshed for efficiency reasons. + * + * In more detail, we: + * (a) request current cursor position, + * (b) move cursor far right, + * (c) request cursor position again, + * (d) at last move back to the old position. + * This gives us the width without messing with the externally + * visible cursor position. + */ - /* Go to right margin and get position. */ - if (write(ofd,"\x1b[999C",6) != 6) goto failed; - cols = getCursorPosition(ifd,ofd); - if (cols == -1) goto failed; + if (current->cols == 0) { + int here; - /* Restore position. */ - if (cols > start) { - char seq[32]; - snprintf(seq,32,"\x1b[%dD",cols-start); - if (write(ofd,seq,strlen(seq)) == -1) { - /* Can't recover... */ + /* If anything fails => default 80 */ + current->cols = 80; + + /* (a) */ + if (queryCursor (current, &here)) { + /* (b) */ + 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, ¤t->cols)) { + /* (d) Reset the cursor back to the original location. */ + if (current->cols > here) { + setCursorPos(current, here); + } } } - return cols; - } else { - return ws.ws_col; } -failed: - return 80; + return 0; } -/* Clear the screen. Used to handle ctrl+l */ -void linenoiseClearScreen(void) { - if (write(STDOUT_FILENO,"\x1b[H\x1b[2J",7) <= 0) { - /* nothing to do, just to avoid warning. */ +/** + * 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, + * CHAR_ESCAPE is returned. + */ +static int check_special(int fd) +{ + int c = fd_read_char(fd, 50); + int c2; + + if (c < 0) { + return CHAR_ESCAPE; + } + else if (c >= 'a' && c <= 'z') { + /* esc-a => meta-a */ + return meta(c); + } + + c2 = fd_read_char(fd, 50); + if (c2 < 0) { + return c2; + } + if (c == '[' || c == 'O') { + /* Potential arrow key */ + switch (c2) { + case 'A': + return SPECIAL_UP; + case 'B': + return SPECIAL_DOWN; + case 'C': + return SPECIAL_RIGHT; + case 'D': + return SPECIAL_LEFT; + case 'F': + return SPECIAL_END; + case 'H': + return SPECIAL_HOME; + } + } + if (c == '[' && c2 >= '1' && c2 <= '8') { + /* extended escape */ + c = fd_read_char(fd, 50); + if (c == '~') { + switch (c2) { + case '2': + return SPECIAL_INSERT; + case '3': + return SPECIAL_DELETE; + case '5': + return SPECIAL_PAGE_UP; + case '6': + return SPECIAL_PAGE_DOWN; + case '7': + return SPECIAL_HOME; + case '8': + return SPECIAL_END; + } + } + while (c != -1 && c != '~') { + /* .e.g \e[12~ or '\e[11;2~ discard the complete sequence */ + c = fd_read_char(fd, 50); + } + } + + return SPECIAL_NONE; +} +#endif + +static void clearOutputHighlight(struct current *current) +{ + int nohighlight = 0; + setOutputHighlight(current, &nohighlight, 1); +} + +static void outputControlChar(struct current *current, char ch) +{ + int reverse = 7; + setOutputHighlight(current, &reverse, 1); + outputChars(current, "^", 1); + outputChars(current, &ch, 1); + clearOutputHighlight(current); +} + +#ifndef utf8_getchars +static int utf8_getchars(char *buf, int c) +{ +#ifdef USE_UTF8 + return utf8_fromunicode(buf, c); +#else + *buf = c; + return 1; +#endif +} +#endif + +/** + * Returns the unicode character at the given offset, + * or -1 if none. + */ +static int get_char(struct current *current, int pos) +{ + if (pos >= 0 && pos < 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 int char_display_width(int ch) +{ + if (ch < ' ') { + /* control chars take two positions */ + return 2; + } + else { + return utf8_width(ch); } } -/* Beep, used for completion when there is nothing to complete or when all - * the choices were already shown. */ -static void linenoiseBeep(void) { +#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; + +static void beep(void) { +#ifdef USE_TERMIOS fprintf(stderr, "\x7"); fflush(stderr); +#endif } -/* ============================== Completion ================================ */ - -/* Free a list of completion option populated by linenoiseAddCompletion(). */ static void freeCompletions(linenoiseCompletions *lc) { size_t i; for (i = 0; i < lc->len; i++) free(lc->cvec[i]); - if (lc->cvec != NULL) - free(lc->cvec); + free(lc->cvec); } -/* Called by completeLine() and linenoiseShow() to render the current - * edited line with the proposed completion. If the current completion table - * is already available, it is passed as second argument, otherwise the - * function will use the callback to obtain it. - * - * Flags are the same as refreshLine*(), that is REFRESH_* macros. */ -static void refreshLineWithCompletion(struct linenoiseState *ls, linenoiseCompletions *lc, int flags) { - /* Obtain the table of completions if the caller didn't provide one. */ - linenoiseCompletions ctable = { 0, NULL }; - if (lc == NULL) { - completionCallback(ls->buf,&ctable); - lc = &ctable; - } - - /* Show the edited line with completion if possible, or just refresh. */ - if (ls->completion_idx < lc->len) { - struct linenoiseState saved = *ls; - ls->len = ls->pos = strlen(lc->cvec[ls->completion_idx]); - ls->buf = lc->cvec[ls->completion_idx]; - refreshLineWithFlags(ls,flags); - ls->len = saved.len; - ls->pos = saved.pos; - ls->buf = saved.buf; - } else { - refreshLineWithFlags(ls,flags); - } - - /* Free the completions table if needed. */ - if (lc != &ctable) freeCompletions(&ctable); -} - -/* This is an helper function for linenoiseEdit*() and is called when the - * user types the key in order to complete the string currently in the - * input. - * - * The state of the editing is encapsulated into the pointed linenoiseState - * structure as described in the structure definition. - * - * If the function returns non-zero, the caller should handle the - * returned value as a byte read from the standard input, and process - * it as usually: this basically means that the function may return a byte - * read from the termianl but not processed. Otherwise, if zero is returned, - * the input was consumed by the completeLine() function to navigate the - * possible completions, and the caller should read for the next characters - * from stdin. */ -static int completeLine(struct linenoiseState *ls, int keypressed) { +static int completeLine(struct current *current) { linenoiseCompletions lc = { 0, NULL }; - int nwritten; - char c = keypressed; + int c = 0; - completionCallback(ls->buf,&lc); + completionCallback(sb_str(current->buf),&lc,completionUserdata); if (lc.len == 0) { - linenoiseBeep(); - ls->in_completion = 0; + beep(); } else { - switch(c) { - case 9: /* tab */ - if (ls->in_completion == 0) { - ls->in_completion = 1; - ls->completion_idx = 0; - } else { - ls->completion_idx = (ls->completion_idx+1) % (lc.len+1); - if (ls->completion_idx == lc.len) linenoiseBeep(); - } - c = 0; - break; - case 27: /* escape */ - /* Re-show original buffer */ - if (ls->completion_idx < lc.len) refreshLine(ls); - ls->in_completion = 0; - c = 0; - break; - default: - /* Update buffer and return */ - if (ls->completion_idx < lc.len) { - nwritten = snprintf(ls->buf,ls->buflen,"%s", - lc.cvec[ls->completion_idx]); - ls->len = ls->pos = nwritten; - } - ls->in_completion = 0; - break; - } + size_t stop = 0, i = 0; - /* Show completion or original buffer */ - if (ls->in_completion && ls->completion_idx < lc.len) { - refreshLineWithCompletion(ls,&lc,REFRESH_ALL); - } else { - refreshLine(ls); + 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); + } + stop = 1; + break; + default: + /* Update buffer and return */ + if (i < lc.len) { + set_current(current,lc.cvec[i]); + } + stop = 1; + break; + } } } @@ -438,856 +1577,1111 @@ static int completeLine(struct linenoiseState *ls, int keypressed) { return c; /* Return last read character */ } -/* Register a callback function to be called for tab-completion. */ -void linenoiseSetCompletionCallback(linenoiseCompletionCallback *fn) { +/* 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; } -/* Register a hits function to be called to show hits to the user at the - * right of the prompt. */ -void linenoiseSetHintsCallback(linenoiseHintsCallback *fn) { - hintsCallback = fn; -} - -/* Register a function to free the hints returned by the hints callback - * registered with linenoiseSetHintsCallback(). */ -void linenoiseSetFreeHintsCallback(linenoiseFreeHintsCallback *fn) { - freeHintsCallback = fn; -} - -/* This function is used by the callback function registered by the user - * in order to add completion options given the input string when the - * user typed . See the example.c source code for a very easy to - * understand example. */ void linenoiseAddCompletion(linenoiseCompletions *lc, const char *str) { - size_t len = strlen(str); - char *copy, **cvec; + lc->cvec = (char **)realloc(lc->cvec,sizeof(char*)*(lc->len+1)); + lc->cvec[lc->len++] = strdup(str); +} + +void linenoiseSetHintsCallback(linenoiseHintsCallback *callback, void *userdata) +{ + hintsCallback = callback; + hintsUserdata = userdata; +} + +void linenoiseSetFreeHintsCallback(linenoiseFreeHintsCallback *callback) +{ + freeHintsCallback = callback; +} + +#endif + + +static const char *reduceSingleBuf(const char *buf, int availcols, int *cursor_pos) +{ + /* 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; + + DRL("reduceSingleBuf: availcols=%d, cursor_pos=%d\n", availcols, *cursor_pos); + + 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; + } + } + + if (pos++ == *cursor_pos) { + break; + } - copy = malloc(len+1); - if (copy == NULL) return; - memcpy(copy,str,len+1); - cvec = realloc(lc->cvec,sizeof(char*)*(lc->len+1)); - if (cvec == NULL) { - free(copy); - return; } - lc->cvec = cvec; - lc->cvec[lc->len++] = copy; + DRL(""); + DRL_STR(buf); + DRL("\nafter reduce, needcols=%d, new_cursor_pos=%d\n", needcols, new_cursor_pos); + + /* Done, now new_cursor_pos contains the adjusted cursor position + * and buf points to he adjusted start + */ + *cursor_pos = new_cursor_pos; + return buf; } -/* =========================== Line editing ================================= */ +static int mlmode = 0; -/* We define a very simple "append buffer" structure, that is an heap - * allocated string where we can append to. This is useful in order to - * write all the escape sequences in a buffer and flush them to the standard - * output in a single call, to avoid flickering effects. */ -struct abuf { - char *b; - int len; -}; - -static void abInit(struct abuf *ab) { - ab->b = NULL; - ab->len = 0; -} - -static void abAppend(struct abuf *ab, const char *s, int len) { - char *new = realloc(ab->b,ab->len+len); - - if (new == NULL) return; - memcpy(new+ab->len,s,len); - ab->b = new; - ab->len += len; -} - -static void abFree(struct abuf *ab) { - free(ab->b); +void linenoiseSetMultiLine(int enableml) +{ + mlmode = enableml; } /* Helper of refreshSingleLine() and refreshMultiLine() to show hints - * to the right of the prompt. */ -void refreshShowHints(struct abuf *ab, struct linenoiseState *l, int plen) { - char seq[64]; - if (hintsCallback && plen+l->len < l->cols) { - int color = -1, bold = 0; - char *hint = hintsCallback(l->buf,&color,&bold); + * 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) +{ + int rc = 0; + if (showhints && hintsCallback && availcols > 0) { + int bold = 0; + int color = -1; + char *hint = hintsCallback(buf, &color, &bold, hintsUserdata); if (hint) { - int hintlen = strlen(hint); - int hintmaxlen = l->cols-(plen+l->len); - if (hintlen > hintmaxlen) hintlen = hintmaxlen; - if (bold == 1 && color == -1) color = 37; - if (color != -1 || bold != 0) - snprintf(seq,64,"\033[%d;%d;49m",bold,color); - else - seq[0] = '\0'; - abAppend(ab,seq,strlen(seq)); - abAppend(ab,hint,hintlen); - if (color != -1 || bold != 0) - abAppend(ab,"\033[0m",4); - /* Call the function to free the hint returned. */ - if (freeHintsCallback) freeHintsCallback(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); + } + DRL("", bold, color); + pt = hint; + while (*pt) { + int ch; + int n = utf8_tounicode(pt, &ch); + int width = char_display_width(ch); -/* Single line low level line refresh. - * - * Rewrite the currently edited line accordingly to the buffer content, - * cursor position, and number of columns of the terminal. - * - * Flags is REFRESH_* macros. The function can just remove the old - * prompt, just write it, or both. */ -static void refreshSingleLine(struct linenoiseState *l, int flags) { - char seq[64]; - size_t plen = strlen(l->prompt); - int fd = l->ofd; - char *buf = l->buf; - size_t len = l->len; - size_t pos = l->pos; - struct abuf ab; + if (width >= availcols) { + DRL(""); + break; + } + DRL_CHAR(ch); - while((plen+pos) >= l->cols) { - buf++; - len--; - pos--; - } - while (plen+len > l->cols) { - len--; - } - - abInit(&ab); - /* Cursor to left edge */ - snprintf(seq,sizeof(seq),"\r"); - abAppend(&ab,seq,strlen(seq)); - - if (flags & REFRESH_WRITE) { - /* Write the prompt and the current buffer content */ - abAppend(&ab,l->prompt,strlen(l->prompt)); - if (maskmode == 1) { - while (len--) abAppend(&ab,"*",1); - } else { - abAppend(&ab,buf,len); - } - /* Show hits if any. */ - refreshShowHints(&ab,l,plen); - } - - /* Erase to right */ - snprintf(seq,sizeof(seq),"\x1b[0K"); - abAppend(&ab,seq,strlen(seq)); - - if (flags & REFRESH_WRITE) { - /* Move cursor to original position. */ - snprintf(seq,sizeof(seq),"\r\x1b[%dC", (int)(pos+plen)); - abAppend(&ab,seq,strlen(seq)); - } - - if (write(fd,ab.b,ab.len) == -1) {} /* Can't recover from write error. */ - abFree(&ab); -} - -/* Multi line low level line refresh. - * - * Rewrite the currently edited line accordingly to the buffer content, - * cursor position, and number of columns of the terminal. - * - * Flags is REFRESH_* macros. The function can just remove the old - * prompt, just write it, or both. */ -static void refreshMultiLine(struct linenoiseState *l, int flags) { - char seq[64]; - int plen = strlen(l->prompt); - int rows = (plen+l->len+l->cols-1)/l->cols; /* rows used by current buf. */ - int rpos = (plen+l->oldpos+l->cols)/l->cols; /* cursor relative row. */ - int rpos2; /* rpos after refresh. */ - int col; /* colum position, zero-based. */ - int old_rows = l->oldrows; - int fd = l->ofd, j; - struct abuf ab; - - l->oldrows = rows; - - /* First step: clear all the lines used before. To do so start by - * going to the last row. */ - abInit(&ab); - - if (flags & REFRESH_CLEAN) { - if (old_rows-rpos > 0) { - lndebug("go down %d", old_rows-rpos); - snprintf(seq,64,"\x1b[%dB", old_rows-rpos); - abAppend(&ab,seq,strlen(seq)); - } - - /* Now for every row clear it, go up. */ - for (j = 0; j < old_rows-1; j++) { - lndebug("clear+up"); - snprintf(seq,64,"\r\x1b[0K\x1b[1A"); - abAppend(&ab,seq,strlen(seq)); - } - } - - if (flags & REFRESH_ALL) { - /* Clean the top line. */ - lndebug("clear"); - snprintf(seq,64,"\r\x1b[0K"); - abAppend(&ab,seq,strlen(seq)); - } - - if (flags & REFRESH_WRITE) { - /* Write the prompt and the current buffer content */ - abAppend(&ab,l->prompt,strlen(l->prompt)); - if (maskmode == 1) { - unsigned int i; - for (i = 0; i < l->len; i++) abAppend(&ab,"*",1); - } else { - abAppend(&ab,l->buf,l->len); - } - - /* Show hits if any. */ - refreshShowHints(&ab,l,plen); - - /* If we are at the very end of the screen with our prompt, we need to - * emit a newline and move the prompt to the first column. */ - if (l->pos && - l->pos == l->len && - (l->pos+plen) % l->cols == 0) - { - lndebug(""); - abAppend(&ab,"\n",1); - snprintf(seq,64,"\r"); - abAppend(&ab,seq,strlen(seq)); - rows++; - if (rows > (int)l->oldrows) l->oldrows = rows; - } - - /* Move cursor to right position. */ - rpos2 = (plen+l->pos+l->cols)/l->cols; /* Current cursor relative row */ - lndebug("rpos2 %d", rpos2); - - /* Go up till we reach the expected positon. */ - if (rows-rpos2 > 0) { - lndebug("go-up %d", rows-rpos2); - snprintf(seq,64,"\x1b[%dA", rows-rpos2); - abAppend(&ab,seq,strlen(seq)); - } - - /* Set column. */ - col = (plen+(int)l->pos) % (int)l->cols; - lndebug("set col %d", 1+col); - if (col) - snprintf(seq,64,"\r\x1b[%dC", col); - else - snprintf(seq,64,"\r"); - abAppend(&ab,seq,strlen(seq)); - } - - lndebug("\n"); - l->oldpos = l->pos; - - if (write(fd,ab.b,ab.len) == -1) {} /* Can't recover from write error. */ - abFree(&ab); -} - -/* Calls the two low level functions refreshSingleLine() or - * refreshMultiLine() according to the selected mode. */ -static void refreshLineWithFlags(struct linenoiseState *l, int flags) { - if (mlmode) - refreshMultiLine(l,flags); - else - refreshSingleLine(l,flags); -} - -/* Utility function to avoid specifying REFRESH_ALL all the times. */ -static void refreshLine(struct linenoiseState *l) { - refreshLineWithFlags(l,REFRESH_ALL); -} - -/* Hide the current line, when using the multiplexing API. */ -void linenoiseHide(struct linenoiseState *l) { - if (mlmode) - refreshMultiLine(l,REFRESH_CLEAN); - else - refreshSingleLine(l,REFRESH_CLEAN); -} - -/* Show the current line, when using the multiplexing API. */ -void linenoiseShow(struct linenoiseState *l) { - if (l->in_completion) { - refreshLineWithCompletion(l,NULL,REFRESH_WRITE); - } else { - refreshLineWithFlags(l,REFRESH_WRITE); - } -} - -/* Insert the character 'c' at cursor current position. - * - * On error writing to the terminal -1 is returned, otherwise 0. */ -int linenoiseEditInsert(struct linenoiseState *l, char c) { - if (l->len < l->buflen) { - if (l->len == l->pos) { - l->buf[l->pos] = c; - l->pos++; - l->len++; - l->buf[l->len] = '\0'; - if ((!mlmode && l->plen+l->len < l->cols && !hintsCallback)) { - /* Avoid a full update of the line in the - * trivial case. */ - char d = (maskmode==1) ? '*' : c; - if (write(l->ofd,&d,1) == -1) return -1; - } else { - refreshLine(l); + 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); } - } else { - memmove(l->buf+l->pos+1,l->buf+l->pos,l->len-l->pos); - l->buf[l->pos] = c; - l->len++; - l->pos++; - l->buf[l->len] = '\0'; - refreshLine(l); } } + return rc; +} + +#ifdef USE_TERMIOS +static void refreshStart(struct current *current) +{ + /* We accumulate all output here */ + assert(current->output == NULL); + current->output = sb_alloc(); +} + +static void refreshEnd(struct current *current) +{ + /* 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 void refreshStartChars(struct current *current) +{ + (void)current; +} + +static void refreshNewline(struct current *current) +{ + DRL(""); + outputChars(current, "\n", 1); +} + +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 i; + 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); + + refreshStart(current); + + DRL("wincols=%d, cursor_pos=%d, nrows=%d, rpos=%d\n", current->cols, cursor_pos, current->nrows, current->rpos); + + /* 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 + */ + + /* (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"); + + /* (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; + + 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; + } + } + } + + /* Now we are at the first line with all lines erased */ + DRL("\nafter prompt: displaycol=%d, displayrow=%d\n", displaycol, displayrow); + + + /* (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; + } + + currentpos = 0; + notecursor = -1; + + while (*pt) { + int ch; + 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; + } + + 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 (notecursor == 1) { + /* (e') Save this position as the current cursor position */ + cursorcol = displaycol; + cursorrow = displayrow; + notecursor = 0; + DRL(""); + } + + displaycol += width; + + if (ch < ' ') { + outputControlChar(current, ch + '@'); + } + else { + 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; + } + /* And remember the row that the cursor is on */ + current->rpos = cursorrow; + + refreshEnd(current); + +#ifdef DEBUG_REFRESHLINE + fclose(dfh); +#endif +} + +static void refreshLine(struct current *current) +{ + refreshLineAlt(current, current->prompt, sb_str(current->buf), current->pos); +} + +static void set_current(struct current *current, const char *str) +{ + sb_clear(current->buf); + sb_append(current->buf, str); + current->pos = sb_chars(current->buf); +} + +/** + * Removes the char at 'pos'. + * + * Returns 1 if the line needs to be refreshed, 2 if not + * and 0 if nothing was removed + */ +static int remove_char(struct current *current, int pos) +{ + if (pos >= 0 && pos < 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; + } + } + + sb_delete(current->buf, offset, nbytes); + + if (current->pos > pos) { + current->pos--; + } + 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; } -/* Move cursor on the left. */ -void linenoiseEditMoveLeft(struct linenoiseState *l) { - if (l->pos > 0) { - l->pos--; - refreshLine(l); +/** + * Insert 'ch' at position 'pos' + * + * Returns 1 if the line needs to be refreshed, 2 if not + * and 0 if nothing was inserted (no room) + */ +static int insert_char(struct current *current, int pos, int ch) +{ + 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; + } + } + sb_insert(current->buf, offset, buf); + if (current->pos >= pos) { + current->pos++; + } + 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; +} + +/** + * Captures up to 'n' characters starting at 'pos' for the cut buffer. + * + * This replaces any existing characters in the cut buffer. + */ +static void capture_chars(struct current *current, int pos, int nchars) +{ + 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); + } } } -/* Move cursor on the right. */ -void linenoiseEditMoveRight(struct linenoiseState *l) { - if (l->pos != l->len) { - l->pos++; - refreshLine(l); +/** + * Removes up to 'n' characters at cursor position 'pos'. + * + * Returns 0 if no chars were removed or non-zero otherwise. + */ +static int remove_chars(struct current *current, int pos, int n) +{ + int removed = 0; + + /* First save any chars which will be removed */ + capture_chars(current, pos, n); + + while (n-- && remove_char(current, pos)) { + removed++; } + return removed; +} +/** + * Inserts the characters (string) 'chars' at the cursor position 'pos'. + * + * Returns 0 if no chars were inserted or non-zero otherwise. + */ +static int insert_chars(struct current *current, int pos, const char *chars) +{ + int inserted = 0; + + while (*chars) { + int ch; + int n = utf8_tounicode(chars, &ch); + if (insert_char(current, pos, ch) == 0) { + break; + } + inserted++; + pos++; + chars += n; + } + return inserted; } -/* Move cursor to the start of the line. */ -void linenoiseEditMoveHome(struct linenoiseState *l) { - if (l->pos != 0) { - l->pos = 0; - refreshLine(l); +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; } -/* Move cursor to the end of the line. */ -void linenoiseEditMoveEnd(struct linenoiseState *l) { - if (l->pos != l->len) { - l->pos = l->len; - refreshLine(l); - } +static int skip_space(struct current *current, int dir) +{ + return skip_space_nonspace(current, dir, 1); } -/* Substitute the currently edited line with the next or previous history - * entry as specified by 'dir'. */ -#define LINENOISE_HISTORY_NEXT 0 -#define LINENOISE_HISTORY_PREV 1 -void linenoiseEditHistoryNext(struct linenoiseState *l, int dir) { +static int skip_nonspace(struct current *current, int dir) +{ + return skip_space_nonspace(current, dir, 0); +} + +static void set_history_index(struct current *current, int new_index) +{ if (history_len > 1) { /* Update the current history entry before to * overwrite it with the next one. */ - free(history[history_len - 1 - l->history_index]); - history[history_len - 1 - l->history_index] = strdup(l->buf); + free(history[history_len - 1 - history_index]); + history[history_len - 1 - history_index] = strdup(sb_str(current->buf)); /* Show the new entry */ - l->history_index += (dir == LINENOISE_HISTORY_PREV) ? 1 : -1; - if (l->history_index < 0) { - l->history_index = 0; - return; - } else if (l->history_index >= history_len) { - l->history_index = history_len-1; - return; - } - strncpy(l->buf,history[history_len - 1 - l->history_index],l->buflen); - l->buf[l->buflen-1] = '\0'; - l->len = l->pos = strlen(l->buf); - refreshLine(l); - } -} - -/* Delete the character at the right of the cursor without altering the cursor - * position. Basically this is what happens with the "Delete" keyboard key. */ -void linenoiseEditDelete(struct linenoiseState *l) { - if (l->len > 0 && l->pos < l->len) { - memmove(l->buf+l->pos,l->buf+l->pos+1,l->len-l->pos-1); - l->len--; - l->buf[l->len] = '\0'; - refreshLine(l); - } -} - -/* Backspace implementation. */ -void linenoiseEditBackspace(struct linenoiseState *l) { - if (l->pos > 0 && l->len > 0) { - memmove(l->buf+l->pos-1,l->buf+l->pos,l->len-l->pos); - l->pos--; - l->len--; - l->buf[l->len] = '\0'; - refreshLine(l); - } -} - -/* Delete the previosu word, maintaining the cursor at the start of the - * current word. */ -void linenoiseEditDeletePrevWord(struct linenoiseState *l) { - size_t old_pos = l->pos; - size_t diff; - - while (l->pos > 0 && l->buf[l->pos-1] == ' ') - l->pos--; - while (l->pos > 0 && l->buf[l->pos-1] != ' ') - l->pos--; - diff = old_pos - l->pos; - memmove(l->buf+l->pos,l->buf+old_pos,l->len-old_pos+1); - l->len -= diff; - refreshLine(l); -} - -/* This function is part of the multiplexed API of Linenoise, that is used - * in order to implement the blocking variant of the API but can also be - * called by the user directly in an event driven program. It will: - * - * 1. Initialize the linenoise state passed by the user. - * 2. Put the terminal in RAW mode. - * 3. Show the prompt. - * 4. Return control to the user, that will have to call linenoiseEditFeed() - * each time there is some data arriving in the standard input. - * - * The user can also call linenoiseEditHide() and linenoiseEditShow() if it - * is required to show some input arriving asyncronously, without mixing - * it with the currently edited line. - * - * When linenoiseEditFeed() returns non-NULL, the user finished with the - * line editing session (pressed enter CTRL-D/C): in this case the caller - * needs to call linenoiseEditStop() to put back the terminal in normal - * mode. This will not destroy the buffer, as long as the linenoiseState - * is still valid in the context of the caller. - * - * The function returns 0 on success, or -1 if writing to standard output - * fails. If stdin_fd or stdout_fd are set to -1, the default is to use - * STDIN_FILENO and STDOUT_FILENO. - */ -int linenoiseEditStart(struct linenoiseState *l, int stdin_fd, int stdout_fd, char *buf, size_t buflen, const char *prompt) { - /* Populate the linenoise state that we pass to functions implementing - * specific editing functionalities. */ - l->in_completion = 0; - l->ifd = stdin_fd != -1 ? stdin_fd : STDIN_FILENO; - l->ofd = stdout_fd != -1 ? stdout_fd : STDOUT_FILENO; - l->buf = buf; - l->buflen = buflen; - l->prompt = prompt; - l->plen = strlen(prompt); - l->oldpos = l->pos = 0; - l->len = 0; - l->cols = getColumns(stdin_fd, stdout_fd); - l->oldrows = 0; - l->history_index = 0; - - /* Buffer starts empty. */ - l->buf[0] = '\0'; - l->buflen--; /* Make sure there is always space for the nulterm */ - - /* If stdin is not a tty, stop here with the initialization. We - * will actually just read a line from standard input in blocking - * mode later, in linenoiseEditFeed(). */ - if (!isatty(l->ifd)) return 0; - - /* Enter raw mode. */ - if (enableRawMode(l->ifd) == -1) return -1; - - /* The latest history entry is always our current buffer, that - * initially is just an empty string. */ - linenoiseHistoryAdd(""); - - if (write(l->ofd,prompt,l->plen) == -1) return -1; - return 0; -} - -char *linenoiseEditMore = "If you see this, you are misusing the API: when linenoiseEditFeed() is called, if it returns linenoiseEditMore the user is yet editing the line. See the README file for more information."; - -/* This function is part of the multiplexed API of linenoise, see the top - * comment on linenoiseEditStart() for more information. Call this function - * each time there is some data to read from the standard input file - * descriptor. In the case of blocking operations, this function can just be - * called in a loop, and block. - * - * The function returns linenoiseEditMore to signal that line editing is still - * in progress, that is, the user didn't yet pressed enter / CTRL-D. Otherwise - * the function returns the pointer to the heap-allocated buffer with the - * edited line, that the user should free with linenoiseFree(). - * - * On special conditions, NULL is returned and errno is populated: - * - * EAGAIN if the user pressed Ctrl-C - * ENOENT if the user pressed Ctrl-D - * - * Some other errno: I/O error. - */ -char *linenoiseEditFeed(struct linenoiseState *l) { - /* Not a TTY, pass control to line reading without character - * count limits. */ - if (!isatty(l->ifd)) return linenoiseNoTTY(); - - char c; - int nread; - char seq[3]; - - nread = read(l->ifd,&c,1); - if (nread <= 0) return NULL; - - /* 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 ((l->in_completion || c == 9) && completionCallback != NULL) { - c = completeLine(l,c); - /* Return on errors */ - if (c < 0) return NULL; - /* Read next character when 0 */ - if (c == 0) return linenoiseEditMore; - } - - switch(c) { - case ENTER: /* enter */ - history_len--; - free(history[history_len]); - if (mlmode) linenoiseEditMoveEnd(l); - if (hintsCallback) { - /* Force a refresh without hints to leave the previous - * line as the user typed it after a newline. */ - linenoiseHintsCallback *hc = hintsCallback; - hintsCallback = NULL; - refreshLine(l); - hintsCallback = hc; - } - return strdup(l->buf); - case CTRL_C: /* ctrl-c */ - errno = EAGAIN; - return NULL; - case BACKSPACE: /* backspace */ - case 8: /* ctrl-h */ - linenoiseEditBackspace(l); - break; - case CTRL_D: /* ctrl-d, remove char at right of cursor, or if the - line is empty, act as end-of-file. */ - if (l->len > 0) { - linenoiseEditDelete(l); + history_index = new_index; + if (history_index < 0) { + history_index = 0; + } else if (history_index >= history_len) { + history_index = history_len - 1; } else { + set_current(current, history[history_len - 1 - history_index]); + refreshLine(current); + } + } +} + +/** + * 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; + + 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('R')) { + /* Search for the previous (earlier) match */ + if (searchpos > 0) { + searchpos--; + } + skipsame = 1; + } + else if (c == ctrl('S')) { + /* Search for the next (later) match */ + if (searchpos < history_len) { + searchpos++; + } + searchdir = 1; + skipsame = 1; + } + else if (c == ctrl('P') || c == SPECIAL_UP) { + /* Exit Ctrl-R mode and go to the previous history line from the current search pos */ + set_history_index(current, history_len - searchpos); + c = 0; + break; + } + else if (c == ctrl('N') || c == SPECIAL_DOWN) { + /* Exit Ctrl-R mode and go to the next history line from the current search pos */ + set_history_index(current, history_len - searchpos - 2); + c = 0; + break; + } + else if (c >= ' ' && c <= '~') { + /* >= here to allow for null terminator */ + if (rlen >= (int)sizeof(rbuf) - MAX_UTF8_LEN) { + 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], sb_str(current->buf)) == 0) { + /* But it is identical, so skip it */ + continue; + } + /* Copy the matching line and set the cursor position */ + history_index = history_len - 1 - searchpos; + 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, ""); + history_index = 0; + c = 0; + } + else if (c == ctrl('J')) { + /* ctrl-j terminates the search leaving the buffer in place */ + history_index = 0; + c = 0; + } + /* Go process the char normally */ + refreshLine(current); + return c; +} + +static int linenoiseEdit(struct current *current) { + history_index = 0; + + refreshLine(current); + + while(1) { + int c = fd_read(current); + +#ifndef NO_COMPLETION + /* Only autocomplete when the callback is set. It returns < 0 when + * there was an error reading from fd. Otherwise it will return the + * character that should be handled next. */ + if (c == '\t' && current->pos == sb_chars(current->buf) && completionCallback != NULL) { + c = completeLine(current); + } +#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 */ + } + +#ifdef USE_TERMIOS + 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 SPECIAL_NONE: + break; + case '\r': /* enter/CR */ + case '\n': /* LF */ history_len--; free(history[history_len]); - errno = ENOENT; - return NULL; - } - break; - case CTRL_T: /* ctrl-t, swaps current character with previous. */ - if (l->pos > 0 && l->pos < l->len) { - int aux = l->buf[l->pos-1]; - l->buf[l->pos-1] = l->buf[l->pos]; - l->buf[l->pos] = aux; - if (l->pos != l->len-1) l->pos++; - refreshLine(l); - } - break; - case CTRL_B: /* ctrl-b */ - linenoiseEditMoveLeft(l); - break; - case CTRL_F: /* ctrl-f */ - linenoiseEditMoveRight(l); - break; - case CTRL_P: /* ctrl-p */ - linenoiseEditHistoryNext(l, LINENOISE_HISTORY_PREV); - break; - case CTRL_N: /* ctrl-n */ - linenoiseEditHistoryNext(l, LINENOISE_HISTORY_NEXT); - break; - case ESC: /* escape sequence */ - /* Read the next two bytes representing the escape sequence. - * Use two calls to handle slow terminals returning the two - * chars at different times. */ - if (read(l->ifd,seq,1) == -1) break; - if (read(l->ifd,seq+1,1) == -1) break; - - /* ESC [ sequences. */ - if (seq[0] == '[') { - if (seq[1] >= '0' && seq[1] <= '9') { - /* Extended escape, read additional byte. */ - if (read(l->ifd,seq+2,1) == -1) break; - if (seq[2] == '~') { - switch(seq[1]) { - case '3': /* Delete key. */ - linenoiseEditDelete(l); - break; - } + 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 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); + } + break; + case ctrl('D'): /* ctrl-d */ + 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); + } + break; + case SPECIAL_INSERT: + /* Ignore. Expansion Hook. + * 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 */ + { + int pos = current->pos; + while (pos > 0 && get_char(current, pos - 1) == ' ') { + pos--; } - } else { - switch(seq[1]) { - case 'A': /* Up */ - linenoiseEditHistoryNext(l, LINENOISE_HISTORY_PREV); - break; - case 'B': /* Down */ - linenoiseEditHistoryNext(l, LINENOISE_HISTORY_NEXT); - break; - case 'C': /* Right */ - linenoiseEditMoveRight(l); - break; - case 'D': /* Left */ - linenoiseEditMoveLeft(l); - break; - case 'H': /* Home */ - linenoiseEditMoveHome(l); - break; - case 'F': /* End*/ - linenoiseEditMoveEnd(l); - break; + + /* now eat any non-spaces on the left */ + while (pos > 0 && get_char(current, pos - 1) != ' ') { + pos--; + } + + if (remove_chars(current, pos, current->pos - pos)) { + refreshLine(current); } } - } + break; + case ctrl('T'): /* ctrl-t */ + if (current->pos > 0 && current->pos <= sb_chars(current->buf)) { + /* If cursor is at end, transpose the previous two 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); + } + break; + case ctrl('V'): /* ctrl-v */ + /* 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); - /* ESC O sequences. */ - else if (seq[0] == 'O') { - switch(seq[1]) { - case 'H': /* Home */ - linenoiseEditMoveHome(l); - break; - case 'F': /* End*/ - linenoiseEditMoveEnd(l); + /* 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); + } + break; + case ctrl('F'): + case SPECIAL_RIGHT: + if (current->pos < sb_chars(current->buf)) { + current->pos++; + refreshLine(current); + } + break; + case SPECIAL_PAGE_UP: /* move to start of history */ + set_history_index(current, history_len - 1); + break; + case SPECIAL_PAGE_DOWN: /* move to 0 == end of history, i.e. current */ + set_history_index(current, 0); + break; + case ctrl('P'): + case SPECIAL_UP: + set_history_index(current, history_index + 1); + break; + case ctrl('N'): + case SPECIAL_DOWN: + set_history_index(current, history_index - 1); + break; + case ctrl('A'): /* Ctrl+a, go to the start of the line */ + case SPECIAL_HOME: + current->pos = 0; + refreshLine(current); + break; + case ctrl('E'): /* ctrl+e, go to the end of the line */ + case SPECIAL_END: + 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); + } + break; + case ctrl('K'): /* Ctrl+k, delete from current to end of line, save deleted chars. */ + 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, 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; + 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); + } + } + break; } - break; - default: - if (linenoiseEditInsert(l,c)) return NULL; - break; - case CTRL_U: /* Ctrl+u, delete the whole line. */ - l->buf[0] = '\0'; - l->pos = l->len = 0; - refreshLine(l); - break; - case CTRL_K: /* Ctrl+k, delete from current to end of line. */ - l->buf[l->pos] = '\0'; - l->len = l->pos; - refreshLine(l); - break; - case CTRL_A: /* Ctrl+a, go to the start of the line */ - linenoiseEditMoveHome(l); - break; - case CTRL_E: /* ctrl+e, go to the end of the line */ - linenoiseEditMoveEnd(l); - break; - case CTRL_L: /* ctrl+l, clear screen */ - linenoiseClearScreen(); - refreshLine(l); - break; - case CTRL_W: /* ctrl+w, delete previous word */ - linenoiseEditDeletePrevWord(l); - break; } - return linenoiseEditMore; + return sb_len(current->buf); } -/* This is part of the multiplexed linenoise API. See linenoiseEditStart() - * for more information. This function is called when linenoiseEditFeed() - * returns something different than NULL. At this point the user input - * is in the buffer, and we can restore the terminal in normal mode. */ -void linenoiseEditStop(struct linenoiseState *l) { - if (!isatty(l->ifd)) return; - disableRawMode(l->ifd); - printf("\n"); -} - -/* This just implements a blocking loop for the multiplexed API. - * In many applications that are not event-drivern, we can just call - * the blocking linenoise API, wait for the user to complete the editing - * and return the buffer. */ -static char *linenoiseBlockingEdit(int stdin_fd, int stdout_fd, char *buf, size_t buflen, const char *prompt) +int linenoiseColumns(void) { - struct linenoiseState l; + struct current current; + current.output = NULL; + enableRawMode (¤t); + getWindowSize (¤t); + disableRawMode (¤t); + return current.cols; +} - /* Editing without a buffer is invalid. */ - if (buflen == 0) { - errno = EINVAL; +/** + * 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) +{ + stringbuf *sb = sb_alloc(); + int c; + int n = 0; + + 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; } - - linenoiseEditStart(&l,stdin_fd,stdout_fd,buf,buflen,prompt); - char *res; - while((res = linenoiseEditFeed(&l)) == linenoiseEditMore); - linenoiseEditStop(&l); - return res; + return sb; } -/* This special mode is used by linenoise in order to print scan codes - * on screen for debugging / development purposes. It is implemented - * by the linenoise_example program using the --keycodes option. */ -void linenoisePrintKeyCodes(void) { - char quit[4]; +char *linenoiseWithInitial(const char *prompt, const char *initial) +{ + int count; + struct current current; + stringbuf *sb; - printf("Linenoise key codes debugging mode.\n" - "Press keys to see scan codes. Type 'quit' at any time to exit.\n"); - if (enableRawMode(STDIN_FILENO) == -1) return; - memset(quit,' ',4); - while(1) { - char c; - int nread; + memset(¤t, 0, sizeof(current)); - nread = read(STDIN_FILENO,&c,1); - if (nread <= 0) continue; - memmove(quit,quit+1,sizeof(quit)-1); /* shift string to left. */ - quit[sizeof(quit)-1] = c; /* Insert current char on the right. */ - if (memcmp(quit,"quit",sizeof(quit)) == 0) break; - - printf("'%c' %02x (%d) (type quit to exit)\n", - isprint(c) ? c : '?', (int)c, (int)c); - printf("\r"); /* Go left edge manually, we are in raw mode. */ + if (enableRawMode(¤t) == -1) { + printf("%s", prompt); fflush(stdout); - } - disableRawMode(STDIN_FILENO); -} - -/* This function is called when linenoise() is called with the standard - * input file descriptor not attached to a TTY. So for example when the - * program using linenoise is called in pipe or with a file redirected - * to its standard input. In this case, we want to be able to return the - * line regardless of its length (by default we are limited to 4k). */ -static char *linenoiseNoTTY(void) { - char *line = NULL; - size_t len = 0, maxlen = 0; - - while(1) { - if (len == maxlen) { - if (maxlen == 0) maxlen = 16; - maxlen *= 2; - char *oldval = line; - line = realloc(line,maxlen); - if (line == NULL) { - if (oldval) free(oldval); - return NULL; - } - } - int c = fgetc(stdin); - if (c == EOF || c == '\n') { - if (c == EOF && len == 0) { - free(line); - return NULL; - } else { - line[len] = '\0'; - return line; - } - } else { - line[len] = c; - len++; + sb = sb_getline(stdin); + if (sb && !fd_isatty(¤t)) { + printf("%s\n", sb_str(sb)); + fflush(stdout); } } -} + else { + current.buf = sb_alloc(); + current.pos = 0; + current.nrows = 1; + current.prompt = prompt; -/* The high level function that is the main API of the linenoise library. - * This function checks if the terminal has basic capabilities, just checking - * for a blacklist of stupid terminals, and later either calls the line - * editing function or uses dummy fgets() so that you will be able to type - * something even in the most desperate of the conditions. */ -char *linenoise(const char *prompt) { - char buf[LINENOISE_MAX_LINE]; + /* The latest history entry is always our current buffer */ + linenoiseHistoryAdd(initial); + set_current(¤t, initial); - if (!isatty(STDIN_FILENO)) { - /* Not a tty: read from file / pipe. In this mode we don't want any - * limit to the line size, so we call a function to handle that. */ - return linenoiseNoTTY(); - } else if (isUnsupportedTerm()) { - size_t len; + count = linenoiseEdit(¤t); - printf("%s",prompt); - fflush(stdout); - if (fgets(buf,LINENOISE_MAX_LINE,stdin) == NULL) return NULL; - len = strlen(buf); - while(len && (buf[len-1] == '\n' || buf[len-1] == '\r')) { - len--; - buf[len] = '\0'; + disableRawMode(¤t); + printf("\n"); + + sb_free(current.capture); + if (count == -1) { + sb_free(current.buf); + return NULL; } - return strdup(buf); - } else { - char *retval = linenoiseBlockingEdit(STDIN_FILENO,STDOUT_FILENO,buf,LINENOISE_MAX_LINE,prompt); - return retval; + sb = current.buf; } + return sb ? sb_to_string(sb) : NULL; } -/* This is just a wrapper the user may want to call in order to make sure - * the linenoise returned buffer is freed with the same allocator it was - * created with. Useful when the main program is using an alternative - * allocator. */ -void linenoiseFree(void *ptr) { - if (ptr == linenoiseEditMore) return; // Protect from API misuse. - free(ptr); +char *linenoise(const char *prompt) +{ + return linenoiseWithInitial(prompt, ""); } -/* ================================ History ================================= */ +/* Using a circular buffer is smarter, but a bit more complex to handle. */ +static int linenoiseHistoryAddAllocated(char *line) { -/* Free the history, but does not reset it. Only used when we have to - * exit() to avoid memory leaks are reported by valgrind & co. */ -static void freeHistory(void) { - if (history) { - int j; - - for (j = 0; j < history_len; j++) - free(history[j]); - free(history); + if (history_max_len == 0) { +notinserted: + free(line); + return 0; } -} - -/* At exit we'll try to fix the terminal to the initial conditions. */ -static void linenoiseAtExit(void) { - disableRawMode(STDIN_FILENO); - freeHistory(); -} - -/* This is the API call to add a new entry in the linenoise history. - * It uses a fixed array of char pointers that are shifted (memmoved) - * when the history max length is reached in order to remove the older - * entry and make room for the new one, so it is not exactly suitable for huge - * histories, but will work well for a few hundred of entries. - * - * Using a circular buffer is smarter, but a bit more complex to handle. */ -int linenoiseHistoryAdd(const char *line) { - char *linecopy; - - if (history_max_len == 0) return 0; - - /* Initialization on first call. */ if (history == NULL) { - history = 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); } - /* Don't add duplicated lines. */ - if (history_len && !strcmp(history[history_len-1], line)) return 0; + /* do not insert duplicate lines into history */ + if (history_len > 0 && strcmp(line, history[history_len - 1]) == 0) { + goto notinserted; + } - /* Add an heap allocated copy of the line in the history. - * If we reached the max length, remove the older line. */ - 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; } -/* Set the maximum length for the history. This function can be called even - * if there is already some history, the function will make sure to retain - * just the latest 'len' elements if the new history length value is smaller - * than the amount of items already inside the history. */ +int linenoiseHistoryAdd(const char *line) { + return linenoiseHistoryAddAllocated(strdup(line)); +} + +int linenoiseHistoryGetMaxLen(void) { + return history_max_len; +} + int linenoiseHistorySetMaxLen(int len) { - char **new; + char **newHistory; if (len < 1) return 0; if (history) { int tocopy = history_len; - new = malloc(sizeof(char*)*len); - if (new == 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) { @@ -1296,10 +2690,9 @@ int linenoiseHistorySetMaxLen(int len) { for (j = 0; j < tocopy-len; j++) free(history[j]); tocopy = len; } - memset(new,0,sizeof(char*)*len); - memcpy(new,history+(history_len-tocopy), sizeof(char*)*tocopy); + memcpy(newHistory,history+(history_len-tocopy), sizeof(char*)*tocopy); free(history); - history = new; + history = newHistory; } history_max_len = len; if (history_len > history_max_len) @@ -1310,39 +2703,466 @@ int linenoiseHistorySetMaxLen(int len) { /* Save the history in the specified file. On success 0 is returned * otherwise -1 is returned. */ int linenoiseHistorySave(const char *filename) { - mode_t old_umask = umask(S_IXUSR|S_IRWXG|S_IRWXO); - FILE *fp; + FILE *fp = fopen(filename,"w"); int j; - fp = fopen(filename,"w"); - umask(old_umask); if (fp == NULL) return -1; - chmod(filename,S_IRUSR|S_IWUSR); - for (j = 0; j < history_len; j++) - fprintf(fp,"%s\n",history[j]); + for (j = 0; j < history_len; j++) { + const char *str = history[j]; + /* Need to encode backslash, nl and cr */ + while (*str) { + if (*str == '\\') { + fputs("\\\\", fp); + } + else if (*str == '\n') { + fputs("\\n", fp); + } + else if (*str == '\r') { + fputs("\\r", fp); + } + else { + fputc(*str, fp); + } + str++; + } + fputc('\n', fp); + } + fclose(fp); return 0; } -/* Load the history from the specified file. If the file does not exist - * zero is returned and no operation is performed. +/* 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 *p; + 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; - p = strchr(buf,'\r'); - if (!p) p = strchr(buf,'\n'); - if (p) *p = '\0'; - linenoiseHistoryAdd(buf); + for (src = buf; *src; src++) { + char ch = *src; + + if (ch == '\\') { + src++; + if (*src == 'n') { + ch = '\n'; + } + else if (*src == 'r') { + ch = '\r'; + } else { + ch = *src; + } + } + *dest++ = ch; + } + *dest = 0; + + linenoiseHistoryAddAllocated(buf); } fclose(fp); return 0; } + +/* Provide access to the history buffer. + * + * If 'len' is not NULL, the length is stored in *len. + */ +char **linenoiseHistory(int *len) { + if (len) { + *len = history_len; + } + return history; +} + +#ifdef WIN32 + +/* 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; + case VK_RETURN: + return k->uChar.UnicodeChar; + } + } + /* 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; +} +#endif \ No newline at end of file diff --git a/util/linenoise.h b/util/linenoise.h index 3f0270e..e7810cf 100644 --- a/util/linenoise.h +++ b/util/linenoise.h @@ -1,14 +1,12 @@ -/* linenoise.h -- VERSION 1.0 - * - * Guerrilla line editing library against the idea that a line editing lib - * needs to be 20,000 lines of C code. +/* linenoise.h -- guerrilla line editing library against the idea that a + * line editing lib needs to be 20,000 lines of C code. * * See linenoise.c for more information. * * ------------------------------------------------------------------------ * - * Copyright (c) 2010-2023, Salvatore Sanfilippo - * Copyright (c) 2010-2013, Pieter Noordhuis + * Copyright (c) 2010, Salvatore Sanfilippo + * Copyright (c) 2010, Pieter Noordhuis * * All rights reserved. * @@ -43,68 +41,109 @@ extern "C" { #endif -#include /* For size_t. */ - -extern char *linenoiseEditMore; - -/* The linenoiseState structure represents the state during line editing. - * We pass this state to functions implementing specific editing - * functionalities. */ -struct linenoiseState { - int in_completion; /* The user pressed TAB and we are now in completion - * mode, so input is handled by completeLine(). */ - size_t completion_idx; /* Index of next completion to propose. */ - int ifd; /* Terminal stdin file descriptor. */ - int ofd; /* Terminal stdout file descriptor. */ - char *buf; /* Edited line buffer. */ - size_t buflen; /* Edited line buffer size. */ - const char *prompt; /* Prompt to display. */ - size_t plen; /* Prompt length. */ - size_t pos; /* Current cursor position. */ - size_t oldpos; /* Previous refresh cursor position. */ - size_t len; /* Current edited line length. */ - size_t cols; /* Number of columns in terminal. */ - size_t oldrows; /* Rows used by last refrehsed line (multiline mode) */ - int history_index; /* The history index we are currently editing. */ -}; +#include +#include +#ifndef NO_COMPLETION typedef struct linenoiseCompletions { size_t len; char **cvec; } linenoiseCompletions; -/* Non blocking API. */ -int linenoiseEditStart(struct linenoiseState *l, int stdin_fd, int stdout_fd, char *buf, size_t buflen, const char *prompt); -char *linenoiseEditFeed(struct linenoiseState *l); -void linenoiseEditStop(struct linenoiseState *l); -void linenoiseHide(struct linenoiseState *l); -void linenoiseShow(struct linenoiseState *l); +/* + * The callback type for tab completion handlers. + */ +typedef void(linenoiseCompletionCallback)(const char *prefix, linenoiseCompletions *comp, void *userdata); -/* Blocking API. */ +/* + * Sets the current tab completion handler and returns the previous one, or NULL + * if no prior one has been set. + */ +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); + +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 + +/* + * Prompts for input using the given string as the input + * prompt. Returns when the user has tapped ENTER or (on an empty + * line) EOF (Ctrl-D on Unix, Ctrl-Z on Windows). Returns either + * a copy of the entered string (for ENTER) or NULL (on EOF). The + * caller owns the returned string and must eventually free() it. + */ char *linenoise(const char *prompt); -void linenoiseFree(void *ptr); -/* Completion API. */ -typedef void(linenoiseCompletionCallback)(const char *, linenoiseCompletions *); -typedef char*(linenoiseHintsCallback)(const char *, int *color, int *bold); -typedef void(linenoiseFreeHintsCallback)(void *); -void linenoiseSetCompletionCallback(linenoiseCompletionCallback *); -void linenoiseSetHintsCallback(linenoiseHintsCallback *); -void linenoiseSetFreeHintsCallback(linenoiseFreeHintsCallback *); -void linenoiseAddCompletion(linenoiseCompletions *, const char *); +/** + * Like linenoise() but starts with an initial buffer. + */ +char *linenoiseWithInitial(const char *prompt, const char *initial); -/* History API. */ +/** + * Clear the screen. + */ +void linenoiseClearScreen(void); + +/* + * Adds a copy of the given line of the command history. + */ int linenoiseHistoryAdd(const char *line); + +/* + * Sets the maximum length of the command history, in lines. + * If the history is currently longer, it will be trimmed, + * retaining only the most recent entries. If len is 0 or less + * then this function does nothing. + */ int linenoiseHistorySetMaxLen(int len); + +/* + * Returns the current maximum length of the history, in lines. + */ +int linenoiseHistoryGetMaxLen(void); + +/* + * Saves the current contents of the history to the given file. + * Returns 0 on success. + */ int linenoiseHistorySave(const char *filename); + +/* + * Replaces the current history with the contents + * of the given file. Returns 0 on success. + */ int linenoiseHistoryLoad(const char *filename); -/* Other utilities. */ -void linenoiseClearScreen(void); -void linenoiseSetMultiLine(int ml); -void linenoisePrintKeyCodes(void); -void linenoiseMaskModeEnable(void); -void linenoiseMaskModeDisable(void); +/* + * Frees all history entries, clearing the history. + */ +void linenoiseHistoryFree(void); + +/* + * Returns a pointer to the list of history entries, writing its + * length to *len if len is not NULL. The memory is owned by linenoise + * and must not be freed. + */ +char **linenoiseHistory(int *len); + +/* + * Returns the number of display columns in the current terminal. + */ +int linenoiseColumns(void); + +/** + * Enable or disable multiline mode (disabled by default) + */ +void linenoiseSetMultiLine(int enableml); #ifdef __cplusplus }