if (term) {
int j;
for (j = 0; unsupported_term[j]; j++) {
- if (strcasecmp(term, unsupported_term[j]) == 0) {
+ if (strcmp(term, unsupported_term[j]) == 0) {
return 1;
}
}
struct termios raw;
current->fd = STDIN_FILENO;
+ current->cols = 0;
if (!isatty(current->fd) || isUnsupportedTerm() ||
tcgetattr(current->fd, &orig_termios) == -1) {
/* 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,
goto fatal;
}
rawmode = 1;
-
- current->cols = 0;
return 0;
}
IGNORE_RC(write(fd, buf, n));
}
-static void clearScreen(struct current *current)
+void linenoiseClearScreen(void)
{
- fd_printf(current->fd, "\x1b[H\x1b[2J");
+ fd_printf(STDOUT_FILENO, "\x1b[H\x1b[2J");
}
static void cursorToLeft(struct current *current)
static void setCursorPos(struct current *current, int x)
{
- fd_printf(current->fd, "\r\x1b[%dC", x);
+ if (x == 0) {
+ cursorToLeft(current);
+ }
+ else {
+ fd_printf(current->fd, "\r\x1b[%dC", x);
+ }
}
/**
#endif
}
-static int countColorControlChars(const char* prompt, int plen)
+static int countColorControlChars(const char* prompt)
{
/* ANSI color control sequences have the form:
- * "\x1b" "[" [0-9;]+ "m"
+ * "\x1b" "[" [0-9;]* "m"
* We parse them with a simple state machine.
*/
enum {
search_esc,
expect_bracket,
- expect_inner,
expect_trail
} state = search_esc;
- int len, found = 0;
+ int len = 0, found = 0;
char ch;
/* XXX: Strictly we should be checking utf8 chars rather than
* bytes in case of the extremely unlikely scenario where
* an ANSI sequence is part of a utf8 sequence.
*/
- for (; plen ; plen--, prompt++) {
- ch = *prompt;
-
+ while ((ch = *prompt++) != 0) {
switch (state) {
case search_esc:
- len = 0;
if (ch == '\x1b') {
state = expect_bracket;
- len++;
}
break;
case expect_bracket:
if (ch == '[') {
- state = expect_inner;
- len++;
- } else {
- state = search_esc;
- }
- break;
- case expect_inner:
- if (ch >= '0' && ch <= '9') {
- len++;
state = expect_trail;
- } else {
- state = search_esc;
+ /* 3 for "\e[ ... m" */
+ len = 3;
+ break;
}
+ state = search_esc;
break;
case expect_trail:
- if (ch == 'm') {
+ if ((ch == ';') || ((ch >= '0' && ch <= '9'))) {
+ /* 0-9, or semicolon */
len++;
+ break;
+ }
+ if (ch == 'm') {
found += len;
- state = search_esc;
- } else if ((ch != ';') && ((ch < '0') || (ch > '9'))) {
- state = search_esc;
}
- /* 0-9, or semicolon */
- len++;
+ state = search_esc;
break;
}
}
return found;
}
+/**
+ * Stores the current cursor column in '*cols'.
+ * Returns 1 if OK, or 0 if failed to determine cursor pos.
+ */
+static int queryCursor(int fd, int* cols)
+{
+ /* control sequence - report cursor location */
+ fd_printf(fd, "\x1b[6n");
+
+ /* Parse the response: ESC [ rows ; cols R */
+ if (fd_read_char(fd, 100) == 0x1b &&
+ fd_read_char(fd, 100) == '[') {
+
+ int n = 0;
+ while (1) {
+ int ch = fd_read_char(fd, 100);
+ if (ch == ';') {
+ /* Ignore rows */
+ n = 0;
+ }
+ else if (ch == 'R') {
+ /* Got cols */
+ if (n != 0 && n < 1000) {
+ *cols = n;
+ }
+ break;
+ }
+ else if (ch >= 0 && ch <= '9') {
+ n = n * 10 + ch - '0';
+ }
+ else {
+ break;
+ }
+ }
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * Updates current->cols with the current window size (width)
+ */
static int getWindowSize(struct current *current)
{
struct winsize ws;
* and reading back the cursor position.
* Note that this is only done once per call to linenoise rather than
* every time the line is refreshed for efficiency reasons.
+ *
+ * In more detail, we:
+ * (a) request current cursor position,
+ * (b) move cursor far right,
+ * (c) request cursor position again,
+ * (d) at last move back to the old position.
+ * This gives us the width without messing with the externally
+ * visible cursor position.
*/
+
if (current->cols == 0) {
+ int here;
+
current->cols = 80;
- /* Move cursor far right and report cursor position, then back to the left */
- fd_printf(current->fd, "\x1b[999C" "\x1b[6n");
-
- /* Parse the response: ESC [ rows ; cols R */
- if (fd_read_char(current->fd, 100) == 0x1b && fd_read_char(current->fd, 100) == '[') {
- int n = 0;
- while (1) {
- int ch = fd_read_char(current->fd, 100);
- if (ch == ';') {
- /* Ignore rows */
- n = 0;
- }
- else if (ch == 'R') {
- /* Got cols */
- if (n != 0 && n < 1000) {
- current->cols = n;
- }
- break;
- }
- else if (ch >= 0 && ch <= '9') {
- n = n * 10 + ch - '0';
- }
- else {
- break;
+ /* (a) */
+ if (queryCursor (current->fd, &here)) {
+ /* (b) */
+ fd_printf(current->fd, "\x1b[999C");
+
+ /* (c). Note: If (a) succeeded, then (c) should as well.
+ * For paranoia we still check and have a fallback action
+ * for (d) in case of failure..
+ */
+ if (!queryCursor (current->fd, ¤t->cols)) {
+ /* (d') Unable to get accurate position data, reset
+ * the cursor to the far left. While this may not
+ * restore the exact original position it should not
+ * be too bad.
+ */
+ fd_printf(current->fd, "\r");
+ } else {
+ /* (d) Reset the cursor back to the original location. */
+ if (current->cols > here) {
+ fd_printf(current->fd, "\x1b[%dD", current->cols - here);
}
}
- }
+ } /* 1st query failed, doing nothing => default 80 */
}
+
return 0;
}
SetConsoleMode(current->inh, orig_consolemode);
}
-static void clearScreen(struct current *current)
+void linenoiseClearScreen(void)
{
+ HANDLE fh = GetStdHandle(STD_OUTPUT_HANDLE);
+
COORD topleft = { 0, 0 };
DWORD n;
- FillConsoleOutputCharacter(current->outh, ' ',
+ FillConsoleOutputCharacter(fh, ' ',
current->cols * current->rows, topleft, &n);
- FillConsoleOutputAttribute(current->outh,
+ FillConsoleOutputAttribute(fh,
FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN,
current->cols * current->rows, topleft, &n);
- SetConsoleCursorPosition(current->outh, topleft);
+ SetConsoleCursorPosition(fh, topleft);
}
static void cursorToLeft(struct current *current)
{
- COORD pos = { 0, (SHORT)current->y };
+ 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;
static int outputChars(struct current *current, const char *buf, int len)
{
- COORD pos = { (SHORT)current->x, (SHORT)current->y };
+ COORD pos;
DWORD n;
+ pos.X = (SHORT)current->x;
+ pos.Y = (SHORT)current->y;
+
WriteConsoleOutputCharacter(current->outh, buf, len, pos, &n);
current->x += len;
return 0;
static void outputControlChar(struct current *current, char ch)
{
- COORD pos = { (SHORT)current->x, (SHORT)current->y };
+ COORD pos;
DWORD n;
+ pos.X = (SHORT) current->x;
+ pos.Y = (SHORT) current->y;
+
FillConsoleOutputAttribute(current->outh, BACKGROUND_INTENSITY, 2, pos, &n);
outputChars(current, "^", 1);
outputChars(current, &ch, 1);
static void eraseEol(struct current *current)
{
- COORD pos = { (SHORT)current->x, (SHORT)current->y };
+ 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 setCursorPos(struct current *current, int x)
{
- COORD pos = { (SHORT)x, (SHORT)current->y };
+ COORD pos;
+
+ pos.X = (SHORT)x;
+ pos.Y = (SHORT) current->y;
SetConsoleCursorPosition(current->outh, pos);
current->x = x;
}
}
/* Note that control characters are already translated in AsciiChar */
+ else if (k->wVirtualKeyCode == VK_CONTROL)
+ continue;
else {
#ifdef USE_UTF8
return k->uChar.UnicodeChar;
return -1;
}
-static int countColorControlChars(char* prompt, int plen)
+static int countColorControlChars(const char* prompt)
{
/* For windows we assume that there are no embedded ansi color
* control sequences.
/* Scan the prompt for embedded ansi color control sequences and
* discount them as characters/columns.
*/
- pchars -= countColorControlChars(prompt, plen);
+ pchars -= countColorControlChars(prompt);
/* Account for a line which is too long to fit in the window.
* Note that control chars require an extra column
#ifndef NO_COMPLETION
static linenoiseCompletionCallback *completionCallback = NULL;
+static void *completionUserdata = NULL;
static void beep() {
#ifdef USE_TERMIOS
linenoiseCompletions lc = { 0, NULL };
int c = 0;
- completionCallback(current->buf,&lc);
+ completionCallback(current->buf,&lc,completionUserdata);
if (lc.len == 0) {
beep();
} else {
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;
}
void linenoiseAddCompletion(linenoiseCompletions *lc, const char *str) {
}
break;
case ctrl('L'): /* Ctrl+L, clear screen */
- clearScreen(current);
+ linenoiseClearScreen();
/* Force recalc of window size for serial terminals */
current->cols = 0;
refreshLine(current->prompt, current);