git/compat/terminal.c

622 lines
14 KiB
C
Raw Normal View History

#include "git-compat-util.h"
#include "compat/terminal.h"
#include "gettext.h"
#include "sigchain.h"
#include "strbuf.h"
#include "run-command.h"
#include "string-list.h"
built-in add -p: handle Escape sequences more efficiently When `interactive.singlekey = true`, we react immediately to keystrokes, even to Escape sequences (e.g. when pressing a cursor key). The problem with Escape sequences is that we do not really know when they are done, and as a heuristic we poll standard input for half a second to make sure that we got all of it. While waiting half a second is not asking for a whole lot, it can become quite annoying over time, therefore with this patch, we read the terminal capabilities (if available) and extract known Escape sequences from there, then stop polling immediately when we detected that the user pressed a key that generated such a known sequence. This recapitulates the remaining part of b5cc003253c8 (add -i: ignore terminal escape sequences, 2011-05-17). Note: We do *not* query the terminal capabilities directly. That would either require a lot of platform-specific code, or it would require linking to a library such as ncurses. Linking to a library in the built-ins is something we try very hard to avoid (we even kicked the libcurl dependency to a non-built-in remote helper, just to shave off a tiny fraction of a second from Git's startup time). And the platform-specific code would be a maintenance nightmare. Even worse: in Git for Windows' case, we would need to query MSYS2 pseudo terminals, which `git.exe` simply cannot do (because it is intentionally *not* an MSYS2 program). To address this, we simply spawn `infocmp -L -1` and parse its output (which works even in Git for Windows, because that helper is included in the end-user facing installations). This is done only once, as in the Perl version, but it is done only when the first Escape sequence is encountered, not upon startup of `git add -i`; This saves on startup time, yet makes reacting to the first Escape sequence slightly more sluggish. But it allows us to keep the terminal-related code encapsulated in the `compat/terminal.c` file. Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de> Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-14 18:43:52 +00:00
#include "hashmap.h"
#if defined(HAVE_DEV_TTY) || defined(GIT_WINDOWS_NATIVE)
static void restore_term_on_signal(int sig)
{
restore_term();
/* restore_term calls sigchain_pop_common */
raise(sig);
}
#ifdef HAVE_DEV_TTY
#define INPUT_PATH "/dev/tty"
#define OUTPUT_PATH "/dev/tty"
static volatile sig_atomic_t term_fd_needs_closing;
static int term_fd = -1;
static struct termios old_term;
static const char *background_resume_msg;
static const char *restore_error_msg;
static volatile sig_atomic_t ttou_received;
/* async safe error function for use by signal handlers. */
static void write_err(const char *msg)
{
write_in_full(2, "error: ", strlen("error: "));
write_in_full(2, msg, strlen(msg));
write_in_full(2, "\n", 1);
}
static void print_background_resume_msg(int signo)
{
int saved_errno = errno;
sigset_t mask;
struct sigaction old_sa;
struct sigaction sa = { .sa_handler = SIG_DFL };
ttou_received = 1;
write_err(background_resume_msg);
sigaction(signo, &sa, &old_sa);
raise(signo);
sigemptyset(&mask);
sigaddset(&mask, signo);
sigprocmask(SIG_UNBLOCK, &mask, NULL);
/* Stopped here */
sigprocmask(SIG_BLOCK, &mask, NULL);
sigaction(signo, &old_sa, NULL);
errno = saved_errno;
}
static void restore_terminal_on_suspend(int signo)
{
int saved_errno = errno;
int res;
struct termios t;
sigset_t mask;
struct sigaction old_sa;
struct sigaction sa = { .sa_handler = SIG_DFL };
int can_restore = 1;
if (tcgetattr(term_fd, &t) < 0)
can_restore = 0;
if (tcsetattr(term_fd, TCSAFLUSH, &old_term) < 0)
write_err(restore_error_msg);
sigaction(signo, &sa, &old_sa);
raise(signo);
sigemptyset(&mask);
sigaddset(&mask, signo);
sigprocmask(SIG_UNBLOCK, &mask, NULL);
/* Stopped here */
sigprocmask(SIG_BLOCK, &mask, NULL);
sigaction(signo, &old_sa, NULL);
if (!can_restore) {
write_err(restore_error_msg);
goto out;
}
/*
* If we resume in the background then we receive SIGTTOU when calling
* tcsetattr() below. Set up a handler to print an error message in that
* case.
*/
sigemptyset(&mask);
sigaddset(&mask, SIGTTOU);
sa.sa_mask = old_sa.sa_mask;
sa.sa_handler = print_background_resume_msg;
sa.sa_flags = SA_RESTART;
sigaction(SIGTTOU, &sa, &old_sa);
again:
ttou_received = 0;
sigprocmask(SIG_UNBLOCK, &mask, NULL);
res = tcsetattr(term_fd, TCSAFLUSH, &t);
sigprocmask(SIG_BLOCK, &mask, NULL);
if (ttou_received)
goto again;
else if (res < 0)
write_err(restore_error_msg);
sigaction(SIGTTOU, &old_sa, NULL);
out:
errno = saved_errno;
}
static void reset_job_signals(void)
{
if (restore_error_msg) {
signal(SIGTTIN, SIG_DFL);
signal(SIGTTOU, SIG_DFL);
signal(SIGTSTP, SIG_DFL);
restore_error_msg = NULL;
background_resume_msg = NULL;
}
}
static void close_term_fd(void)
{
if (term_fd_needs_closing)
close(term_fd);
term_fd_needs_closing = 0;
term_fd = -1;
}
void restore_term(void)
{
if (term_fd < 0)
return;
tcsetattr(term_fd, TCSAFLUSH, &old_term);
close_term_fd();
sigchain_pop_common();
reset_job_signals();
}
int save_term(enum save_term_flags flags)
{
struct sigaction sa;
if (term_fd < 0)
term_fd = ((flags & SAVE_TERM_STDIN)
? 0
: open("/dev/tty", O_RDWR));
if (term_fd < 0)
return -1;
term_fd_needs_closing = !(flags & SAVE_TERM_STDIN);
if (tcgetattr(term_fd, &old_term) < 0) {
close_term_fd();
return -1;
}
sigchain_push_common(restore_term_on_signal);
/*
* If job control is disabled then the shell will have set the
* disposition of SIGTSTP to SIG_IGN.
*/
sigaction(SIGTSTP, NULL, &sa);
if (sa.sa_handler == SIG_IGN)
return 0;
/* avoid calling gettext() from signal handler */
background_resume_msg = _("cannot resume in the background, please use 'fg' to resume");
restore_error_msg = _("cannot restore terminal settings");
sa.sa_handler = restore_terminal_on_suspend;
sa.sa_flags = SA_RESTART;
sigemptyset(&sa.sa_mask);
sigaddset(&sa.sa_mask, SIGTSTP);
sigaddset(&sa.sa_mask, SIGTTIN);
sigaddset(&sa.sa_mask, SIGTTOU);
sigaction(SIGTSTP, &sa, NULL);
sigaction(SIGTTIN, &sa, NULL);
sigaction(SIGTTOU, &sa, NULL);
return 0;
}
static int disable_bits(enum save_term_flags flags, tcflag_t bits)
{
struct termios t;
if (save_term(flags) < 0)
return -1;
t = old_term;
t.c_lflag &= ~bits;
if (bits & ICANON) {
t.c_cc[VMIN] = 1;
t.c_cc[VTIME] = 0;
}
if (!tcsetattr(term_fd, TCSAFLUSH, &t))
return 0;
sigchain_pop_common();
reset_job_signals();
close_term_fd();
return -1;
}
static int disable_echo(enum save_term_flags flags)
{
return disable_bits(flags, ECHO);
}
static int enable_non_canonical(enum save_term_flags flags)
{
return disable_bits(flags, ICANON | ECHO);
}
/*
* On macos it is not possible to use poll() with a terminal so use select
* instead.
*/
static int getchar_with_timeout(int timeout)
{
struct timeval tv, *tvp = NULL;
fd_set readfds;
int res;
again:
if (timeout >= 0) {
tv.tv_sec = timeout / 1000;
tv.tv_usec = (timeout % 1000) * 1000;
tvp = &tv;
}
FD_ZERO(&readfds);
FD_SET(0, &readfds);
res = select(1, &readfds, NULL, NULL, tvp);
if (!res)
return EOF;
if (res < 0) {
if (errno == EINTR)
goto again;
else
return EOF;
}
return getchar();
}
#elif defined(GIT_WINDOWS_NATIVE)
#define INPUT_PATH "CONIN$"
#define OUTPUT_PATH "CONOUT$"
#define FORCE_TEXT "t"
static int use_stty = 1;
static struct string_list stty_restore = STRING_LIST_INIT_DUP;
static HANDLE hconin = INVALID_HANDLE_VALUE;
static HANDLE hconout = INVALID_HANDLE_VALUE;
static DWORD cmode_in, cmode_out;
void restore_term(void)
{
if (use_stty) {
int i;
struct child_process cp = CHILD_PROCESS_INIT;
if (stty_restore.nr == 0)
return;
strvec_push(&cp.args, "stty");
for (i = 0; i < stty_restore.nr; i++)
strvec_push(&cp.args, stty_restore.items[i].string);
run_command(&cp);
string_list_clear(&stty_restore, 0);
return;
}
sigchain_pop_common();
if (hconin == INVALID_HANDLE_VALUE)
return;
SetConsoleMode(hconin, cmode_in);
CloseHandle(hconin);
if (cmode_out) {
assert(hconout != INVALID_HANDLE_VALUE);
SetConsoleMode(hconout, cmode_out);
CloseHandle(hconout);
}
hconin = hconout = INVALID_HANDLE_VALUE;
}
int save_term(enum save_term_flags flags)
{
hconin = CreateFileA("CONIN$", GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL);
if (hconin == INVALID_HANDLE_VALUE)
return -1;
if (flags & SAVE_TERM_DUPLEX) {
hconout = CreateFileA("CONOUT$", GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL);
if (hconout == INVALID_HANDLE_VALUE)
goto error;
GetConsoleMode(hconout, &cmode_out);
}
GetConsoleMode(hconin, &cmode_in);
use_stty = 0;
sigchain_push_common(restore_term_on_signal);
return 0;
error:
CloseHandle(hconin);
hconin = INVALID_HANDLE_VALUE;
return -1;
}
static int disable_bits(enum save_term_flags flags, DWORD bits)
{
if (use_stty) {
struct child_process cp = CHILD_PROCESS_INIT;
strvec_push(&cp.args, "stty");
if (bits & ENABLE_LINE_INPUT) {
string_list_append(&stty_restore, "icanon");
/*
* POSIX allows VMIN and VTIME to overlap with VEOF and
* VEOL - let's hope that is not the case on windows.
*/
strvec_pushl(&cp.args, "-icanon", "min", "1", "time", "0", NULL);
}
if (bits & ENABLE_ECHO_INPUT) {
string_list_append(&stty_restore, "echo");
strvec_push(&cp.args, "-echo");
}
if (bits & ENABLE_PROCESSED_INPUT) {
string_list_append(&stty_restore, "-ignbrk");
string_list_append(&stty_restore, "intr");
string_list_append(&stty_restore, "^c");
strvec_push(&cp.args, "ignbrk");
strvec_push(&cp.args, "intr");
strvec_push(&cp.args, "");
}
if (run_command(&cp) == 0)
return 0;
/* `stty` could not be executed; access the Console directly */
use_stty = 0;
}
if (save_term(flags) < 0)
return -1;
if (!SetConsoleMode(hconin, cmode_in & ~bits)) {
CloseHandle(hconin);
hconin = INVALID_HANDLE_VALUE;
sigchain_pop_common();
return -1;
}
return 0;
}
static int disable_echo(enum save_term_flags flags)
{
return disable_bits(flags, ENABLE_ECHO_INPUT);
}
static int enable_non_canonical(enum save_term_flags flags)
{
return disable_bits(flags,
ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT);
}
built-in add -p: handle Escape sequences in interactive.singlekey mode This recapitulates part of b5cc003253c8 (add -i: ignore terminal escape sequences, 2011-05-17): add -i: ignore terminal escape sequences On the author's terminal, the up-arrow input sequence is ^[[A, and thus fat-fingering an up-arrow into 'git checkout -p' is quite dangerous: git-add--interactive.perl will ignore the ^[ and [ characters and happily treat A as "discard everything". As a band-aid fix, use Term::Cap to get all terminal capabilities. Then use the heuristic that any capability value that starts with ^[ (i.e., \e in perl) must be a key input sequence. Finally, given an input that starts with ^[, read more characters until we have read a full escape sequence, then return that to the caller. We use a timeout of 0.5 seconds on the subsequent reads to avoid getting stuck if the user actually input a lone ^[. Since none of the currently recognized keys start with ^[, the net result is that the sequence as a whole will be ignored and the help displayed. Note that we leave part for later which uses "Term::Cap to get all terminal capabilities", for several reasons: 1. it is actually not really necessary, as the timeout of 0.5 seconds should be plenty sufficient to catch Escape sequences, 2. it is cleaner to keep the change to special-case Escape sequences separate from the change that reads all terminal capabilities to speed things up, and 3. in practice, relying on the terminal capabilities is a bit overrated, as the information could be incomplete, or plain wrong. For example, in this developer's tmux sessions, the terminal capabilities claim that the "cursor up" sequence is ^[M, but the actual sequence produced by the "cursor up" key is ^[[A. Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de> Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-14 18:43:51 +00:00
/*
* Override `getchar()`, as the default implementation does not use
* `ReadFile()`.
*
* This poses a problem when we want to see whether the standard
* input has more characters, as the default of Git for Windows is to start the
* Bash in a MinTTY, which uses a named pipe to emulate a pty, in which case
* our `poll()` emulation calls `PeekNamedPipe()`, which seems to require
* `ReadFile()` to be called first to work properly (it only reports 0
* available bytes, otherwise).
*
* So let's just override `getchar()` with a version backed by `ReadFile()` and
* go our merry ways from here.
*/
static int mingw_getchar(void)
{
DWORD read = 0;
unsigned char ch;
if (!ReadFile(GetStdHandle(STD_INPUT_HANDLE), &ch, 1, &read, NULL))
return EOF;
if (!read) {
error("Unexpected 0 read");
return EOF;
}
return ch;
}
#define getchar mingw_getchar
static int getchar_with_timeout(int timeout)
{
struct pollfd pfd = { .fd = 0, .events = POLLIN };
if (poll(&pfd, 1, timeout) < 1)
return EOF;
return getchar();
}
#endif
#ifndef FORCE_TEXT
#define FORCE_TEXT
#endif
char *git_terminal_prompt(const char *prompt, int echo)
{
static struct strbuf buf = STRBUF_INIT;
int r;
FILE *input_fh, *output_fh;
input_fh = fopen(INPUT_PATH, "r" FORCE_TEXT);
if (!input_fh)
return NULL;
output_fh = fopen(OUTPUT_PATH, "w" FORCE_TEXT);
if (!output_fh) {
fclose(input_fh);
return NULL;
}
if (!echo && disable_echo(0)) {
fclose(input_fh);
fclose(output_fh);
return NULL;
}
fputs(prompt, output_fh);
fflush(output_fh);
r = strbuf_getline_lf(&buf, input_fh);
if (!echo) {
putc('\n', output_fh);
fflush(output_fh);
}
restore_term();
fclose(input_fh);
fclose(output_fh);
if (r == EOF)
return NULL;
return buf.buf;
}
built-in add -p: handle Escape sequences more efficiently When `interactive.singlekey = true`, we react immediately to keystrokes, even to Escape sequences (e.g. when pressing a cursor key). The problem with Escape sequences is that we do not really know when they are done, and as a heuristic we poll standard input for half a second to make sure that we got all of it. While waiting half a second is not asking for a whole lot, it can become quite annoying over time, therefore with this patch, we read the terminal capabilities (if available) and extract known Escape sequences from there, then stop polling immediately when we detected that the user pressed a key that generated such a known sequence. This recapitulates the remaining part of b5cc003253c8 (add -i: ignore terminal escape sequences, 2011-05-17). Note: We do *not* query the terminal capabilities directly. That would either require a lot of platform-specific code, or it would require linking to a library such as ncurses. Linking to a library in the built-ins is something we try very hard to avoid (we even kicked the libcurl dependency to a non-built-in remote helper, just to shave off a tiny fraction of a second from Git's startup time). And the platform-specific code would be a maintenance nightmare. Even worse: in Git for Windows' case, we would need to query MSYS2 pseudo terminals, which `git.exe` simply cannot do (because it is intentionally *not* an MSYS2 program). To address this, we simply spawn `infocmp -L -1` and parse its output (which works even in Git for Windows, because that helper is included in the end-user facing installations). This is done only once, as in the Perl version, but it is done only when the first Escape sequence is encountered, not upon startup of `git add -i`; This saves on startup time, yet makes reacting to the first Escape sequence slightly more sluggish. But it allows us to keep the terminal-related code encapsulated in the `compat/terminal.c` file. Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de> Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-14 18:43:52 +00:00
/*
* The `is_known_escape_sequence()` function returns 1 if the passed string
* corresponds to an Escape sequence that the terminal capabilities contains.
*
* To avoid depending on ncurses or other platform-specific libraries, we rely
* on the presence of the `infocmp` executable to do the job for us (failing
* silently if the program is not available or refused to run).
*/
struct escape_sequence_entry {
struct hashmap_entry entry;
char sequence[FLEX_ARRAY];
};
static int sequence_entry_cmp(const void *hashmap_cmp_fn_data UNUSED,
const struct hashmap_entry *he1,
const struct hashmap_entry *he2,
built-in add -p: handle Escape sequences more efficiently When `interactive.singlekey = true`, we react immediately to keystrokes, even to Escape sequences (e.g. when pressing a cursor key). The problem with Escape sequences is that we do not really know when they are done, and as a heuristic we poll standard input for half a second to make sure that we got all of it. While waiting half a second is not asking for a whole lot, it can become quite annoying over time, therefore with this patch, we read the terminal capabilities (if available) and extract known Escape sequences from there, then stop polling immediately when we detected that the user pressed a key that generated such a known sequence. This recapitulates the remaining part of b5cc003253c8 (add -i: ignore terminal escape sequences, 2011-05-17). Note: We do *not* query the terminal capabilities directly. That would either require a lot of platform-specific code, or it would require linking to a library such as ncurses. Linking to a library in the built-ins is something we try very hard to avoid (we even kicked the libcurl dependency to a non-built-in remote helper, just to shave off a tiny fraction of a second from Git's startup time). And the platform-specific code would be a maintenance nightmare. Even worse: in Git for Windows' case, we would need to query MSYS2 pseudo terminals, which `git.exe` simply cannot do (because it is intentionally *not* an MSYS2 program). To address this, we simply spawn `infocmp -L -1` and parse its output (which works even in Git for Windows, because that helper is included in the end-user facing installations). This is done only once, as in the Perl version, but it is done only when the first Escape sequence is encountered, not upon startup of `git add -i`; This saves on startup time, yet makes reacting to the first Escape sequence slightly more sluggish. But it allows us to keep the terminal-related code encapsulated in the `compat/terminal.c` file. Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de> Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-14 18:43:52 +00:00
const void *keydata)
{
const struct escape_sequence_entry
*e1 = container_of(he1, const struct escape_sequence_entry, entry),
*e2 = container_of(he2, const struct escape_sequence_entry, entry);
built-in add -p: handle Escape sequences more efficiently When `interactive.singlekey = true`, we react immediately to keystrokes, even to Escape sequences (e.g. when pressing a cursor key). The problem with Escape sequences is that we do not really know when they are done, and as a heuristic we poll standard input for half a second to make sure that we got all of it. While waiting half a second is not asking for a whole lot, it can become quite annoying over time, therefore with this patch, we read the terminal capabilities (if available) and extract known Escape sequences from there, then stop polling immediately when we detected that the user pressed a key that generated such a known sequence. This recapitulates the remaining part of b5cc003253c8 (add -i: ignore terminal escape sequences, 2011-05-17). Note: We do *not* query the terminal capabilities directly. That would either require a lot of platform-specific code, or it would require linking to a library such as ncurses. Linking to a library in the built-ins is something we try very hard to avoid (we even kicked the libcurl dependency to a non-built-in remote helper, just to shave off a tiny fraction of a second from Git's startup time). And the platform-specific code would be a maintenance nightmare. Even worse: in Git for Windows' case, we would need to query MSYS2 pseudo terminals, which `git.exe` simply cannot do (because it is intentionally *not* an MSYS2 program). To address this, we simply spawn `infocmp -L -1` and parse its output (which works even in Git for Windows, because that helper is included in the end-user facing installations). This is done only once, as in the Perl version, but it is done only when the first Escape sequence is encountered, not upon startup of `git add -i`; This saves on startup time, yet makes reacting to the first Escape sequence slightly more sluggish. But it allows us to keep the terminal-related code encapsulated in the `compat/terminal.c` file. Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de> Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-14 18:43:52 +00:00
return strcmp(e1->sequence, keydata ? keydata : e2->sequence);
}
static int is_known_escape_sequence(const char *sequence)
{
static struct hashmap sequences;
static int initialized;
if (!initialized) {
struct child_process cp = CHILD_PROCESS_INIT;
struct strbuf buf = STRBUF_INIT;
char *p, *eol;
hashmap_init(&sequences, sequence_entry_cmp, NULL, 0);
built-in add -p: handle Escape sequences more efficiently When `interactive.singlekey = true`, we react immediately to keystrokes, even to Escape sequences (e.g. when pressing a cursor key). The problem with Escape sequences is that we do not really know when they are done, and as a heuristic we poll standard input for half a second to make sure that we got all of it. While waiting half a second is not asking for a whole lot, it can become quite annoying over time, therefore with this patch, we read the terminal capabilities (if available) and extract known Escape sequences from there, then stop polling immediately when we detected that the user pressed a key that generated such a known sequence. This recapitulates the remaining part of b5cc003253c8 (add -i: ignore terminal escape sequences, 2011-05-17). Note: We do *not* query the terminal capabilities directly. That would either require a lot of platform-specific code, or it would require linking to a library such as ncurses. Linking to a library in the built-ins is something we try very hard to avoid (we even kicked the libcurl dependency to a non-built-in remote helper, just to shave off a tiny fraction of a second from Git's startup time). And the platform-specific code would be a maintenance nightmare. Even worse: in Git for Windows' case, we would need to query MSYS2 pseudo terminals, which `git.exe` simply cannot do (because it is intentionally *not* an MSYS2 program). To address this, we simply spawn `infocmp -L -1` and parse its output (which works even in Git for Windows, because that helper is included in the end-user facing installations). This is done only once, as in the Perl version, but it is done only when the first Escape sequence is encountered, not upon startup of `git add -i`; This saves on startup time, yet makes reacting to the first Escape sequence slightly more sluggish. But it allows us to keep the terminal-related code encapsulated in the `compat/terminal.c` file. Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de> Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-14 18:43:52 +00:00
strvec_pushl(&cp.args, "infocmp", "-L", "-1", NULL);
built-in add -p: handle Escape sequences more efficiently When `interactive.singlekey = true`, we react immediately to keystrokes, even to Escape sequences (e.g. when pressing a cursor key). The problem with Escape sequences is that we do not really know when they are done, and as a heuristic we poll standard input for half a second to make sure that we got all of it. While waiting half a second is not asking for a whole lot, it can become quite annoying over time, therefore with this patch, we read the terminal capabilities (if available) and extract known Escape sequences from there, then stop polling immediately when we detected that the user pressed a key that generated such a known sequence. This recapitulates the remaining part of b5cc003253c8 (add -i: ignore terminal escape sequences, 2011-05-17). Note: We do *not* query the terminal capabilities directly. That would either require a lot of platform-specific code, or it would require linking to a library such as ncurses. Linking to a library in the built-ins is something we try very hard to avoid (we even kicked the libcurl dependency to a non-built-in remote helper, just to shave off a tiny fraction of a second from Git's startup time). And the platform-specific code would be a maintenance nightmare. Even worse: in Git for Windows' case, we would need to query MSYS2 pseudo terminals, which `git.exe` simply cannot do (because it is intentionally *not* an MSYS2 program). To address this, we simply spawn `infocmp -L -1` and parse its output (which works even in Git for Windows, because that helper is included in the end-user facing installations). This is done only once, as in the Perl version, but it is done only when the first Escape sequence is encountered, not upon startup of `git add -i`; This saves on startup time, yet makes reacting to the first Escape sequence slightly more sluggish. But it allows us to keep the terminal-related code encapsulated in the `compat/terminal.c` file. Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de> Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-14 18:43:52 +00:00
if (pipe_command(&cp, NULL, 0, &buf, 0, NULL, 0))
strbuf_setlen(&buf, 0);
for (eol = p = buf.buf; *p; p = eol + 1) {
p = strchr(p, '=');
if (!p)
break;
p++;
eol = strchrnul(p, '\n');
if (starts_with(p, "\\E")) {
char *comma = memchr(p, ',', eol - p);
struct escape_sequence_entry *e;
p[0] = '^';
p[1] = '[';
FLEX_ALLOC_MEM(e, sequence, p, comma - p);
hashmap_entry_init(&e->entry,
strhash(e->sequence));
hashmap_add(&sequences, &e->entry);
}
if (!*eol)
break;
}
initialized = 1;
}
return !!hashmap_get_from_hash(&sequences, strhash(sequence), sequence);
}
int read_key_without_echo(struct strbuf *buf)
{
static int warning_displayed;
int ch;
if (warning_displayed || enable_non_canonical(SAVE_TERM_STDIN) < 0) {
if (!warning_displayed) {
warning("reading single keystrokes not supported on "
"this platform; reading line instead");
warning_displayed = 1;
}
return strbuf_getline(buf, stdin);
}
strbuf_reset(buf);
ch = getchar();
if (ch == EOF) {
restore_term();
return EOF;
}
strbuf_addch(buf, ch);
built-in add -p: handle Escape sequences in interactive.singlekey mode This recapitulates part of b5cc003253c8 (add -i: ignore terminal escape sequences, 2011-05-17): add -i: ignore terminal escape sequences On the author's terminal, the up-arrow input sequence is ^[[A, and thus fat-fingering an up-arrow into 'git checkout -p' is quite dangerous: git-add--interactive.perl will ignore the ^[ and [ characters and happily treat A as "discard everything". As a band-aid fix, use Term::Cap to get all terminal capabilities. Then use the heuristic that any capability value that starts with ^[ (i.e., \e in perl) must be a key input sequence. Finally, given an input that starts with ^[, read more characters until we have read a full escape sequence, then return that to the caller. We use a timeout of 0.5 seconds on the subsequent reads to avoid getting stuck if the user actually input a lone ^[. Since none of the currently recognized keys start with ^[, the net result is that the sequence as a whole will be ignored and the help displayed. Note that we leave part for later which uses "Term::Cap to get all terminal capabilities", for several reasons: 1. it is actually not really necessary, as the timeout of 0.5 seconds should be plenty sufficient to catch Escape sequences, 2. it is cleaner to keep the change to special-case Escape sequences separate from the change that reads all terminal capabilities to speed things up, and 3. in practice, relying on the terminal capabilities is a bit overrated, as the information could be incomplete, or plain wrong. For example, in this developer's tmux sessions, the terminal capabilities claim that the "cursor up" sequence is ^[M, but the actual sequence produced by the "cursor up" key is ^[[A. Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de> Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-14 18:43:51 +00:00
if (ch == '\033' /* ESC */) {
/*
* We are most likely looking at an Escape sequence. Let's try
* to read more bytes, waiting at most half a second, assuming
* that the sequence is complete if we did not receive any byte
* within that time.
*
* Start by replacing the Escape byte with ^[ */
strbuf_splice(buf, buf->len - 1, 1, "^[", 2);
built-in add -p: handle Escape sequences more efficiently When `interactive.singlekey = true`, we react immediately to keystrokes, even to Escape sequences (e.g. when pressing a cursor key). The problem with Escape sequences is that we do not really know when they are done, and as a heuristic we poll standard input for half a second to make sure that we got all of it. While waiting half a second is not asking for a whole lot, it can become quite annoying over time, therefore with this patch, we read the terminal capabilities (if available) and extract known Escape sequences from there, then stop polling immediately when we detected that the user pressed a key that generated such a known sequence. This recapitulates the remaining part of b5cc003253c8 (add -i: ignore terminal escape sequences, 2011-05-17). Note: We do *not* query the terminal capabilities directly. That would either require a lot of platform-specific code, or it would require linking to a library such as ncurses. Linking to a library in the built-ins is something we try very hard to avoid (we even kicked the libcurl dependency to a non-built-in remote helper, just to shave off a tiny fraction of a second from Git's startup time). And the platform-specific code would be a maintenance nightmare. Even worse: in Git for Windows' case, we would need to query MSYS2 pseudo terminals, which `git.exe` simply cannot do (because it is intentionally *not* an MSYS2 program). To address this, we simply spawn `infocmp -L -1` and parse its output (which works even in Git for Windows, because that helper is included in the end-user facing installations). This is done only once, as in the Perl version, but it is done only when the first Escape sequence is encountered, not upon startup of `git add -i`; This saves on startup time, yet makes reacting to the first Escape sequence slightly more sluggish. But it allows us to keep the terminal-related code encapsulated in the `compat/terminal.c` file. Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de> Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-14 18:43:52 +00:00
/*
* Query the terminal capabilities once about all the Escape
* sequences it knows about, so that we can avoid waiting for
* half a second when we know that the sequence is complete.
*/
while (!is_known_escape_sequence(buf->buf)) {
ch = getchar_with_timeout(500);
built-in add -p: handle Escape sequences in interactive.singlekey mode This recapitulates part of b5cc003253c8 (add -i: ignore terminal escape sequences, 2011-05-17): add -i: ignore terminal escape sequences On the author's terminal, the up-arrow input sequence is ^[[A, and thus fat-fingering an up-arrow into 'git checkout -p' is quite dangerous: git-add--interactive.perl will ignore the ^[ and [ characters and happily treat A as "discard everything". As a band-aid fix, use Term::Cap to get all terminal capabilities. Then use the heuristic that any capability value that starts with ^[ (i.e., \e in perl) must be a key input sequence. Finally, given an input that starts with ^[, read more characters until we have read a full escape sequence, then return that to the caller. We use a timeout of 0.5 seconds on the subsequent reads to avoid getting stuck if the user actually input a lone ^[. Since none of the currently recognized keys start with ^[, the net result is that the sequence as a whole will be ignored and the help displayed. Note that we leave part for later which uses "Term::Cap to get all terminal capabilities", for several reasons: 1. it is actually not really necessary, as the timeout of 0.5 seconds should be plenty sufficient to catch Escape sequences, 2. it is cleaner to keep the change to special-case Escape sequences separate from the change that reads all terminal capabilities to speed things up, and 3. in practice, relying on the terminal capabilities is a bit overrated, as the information could be incomplete, or plain wrong. For example, in this developer's tmux sessions, the terminal capabilities claim that the "cursor up" sequence is ^[M, but the actual sequence produced by the "cursor up" key is ^[[A. Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de> Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-14 18:43:51 +00:00
if (ch == EOF)
break;
built-in add -p: handle Escape sequences in interactive.singlekey mode This recapitulates part of b5cc003253c8 (add -i: ignore terminal escape sequences, 2011-05-17): add -i: ignore terminal escape sequences On the author's terminal, the up-arrow input sequence is ^[[A, and thus fat-fingering an up-arrow into 'git checkout -p' is quite dangerous: git-add--interactive.perl will ignore the ^[ and [ characters and happily treat A as "discard everything". As a band-aid fix, use Term::Cap to get all terminal capabilities. Then use the heuristic that any capability value that starts with ^[ (i.e., \e in perl) must be a key input sequence. Finally, given an input that starts with ^[, read more characters until we have read a full escape sequence, then return that to the caller. We use a timeout of 0.5 seconds on the subsequent reads to avoid getting stuck if the user actually input a lone ^[. Since none of the currently recognized keys start with ^[, the net result is that the sequence as a whole will be ignored and the help displayed. Note that we leave part for later which uses "Term::Cap to get all terminal capabilities", for several reasons: 1. it is actually not really necessary, as the timeout of 0.5 seconds should be plenty sufficient to catch Escape sequences, 2. it is cleaner to keep the change to special-case Escape sequences separate from the change that reads all terminal capabilities to speed things up, and 3. in practice, relying on the terminal capabilities is a bit overrated, as the information could be incomplete, or plain wrong. For example, in this developer's tmux sessions, the terminal capabilities claim that the "cursor up" sequence is ^[M, but the actual sequence produced by the "cursor up" key is ^[[A. Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de> Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-14 18:43:51 +00:00
strbuf_addch(buf, ch);
}
}
restore_term();
return 0;
}
#else
int save_term(enum save_term_flags flags)
{
/* no duplex support available */
return -!!(flags & SAVE_TERM_DUPLEX);
}
void restore_term(void)
{
}
char *git_terminal_prompt(const char *prompt, int echo)
{
return getpass(prompt);
}
int read_key_without_echo(struct strbuf *buf)
{
static int warning_displayed;
const char *res;
if (!warning_displayed) {
warning("reading single keystrokes not supported on this "
"platform; reading line instead");
warning_displayed = 1;
}
res = getpass("");
strbuf_reset(buf);
if (!res)
return EOF;
strbuf_addstr(buf, res);
return 0;
}
#endif