commit 3f4bcca9693975dce840d5af657b7251605a45be Author: Bruce Hill Date: Tue Jun 4 19:27:54 2019 -0700 Initial commit diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..92d8a54 --- /dev/null +++ b/Makefile @@ -0,0 +1,44 @@ +PREFIX= +CC=gcc +CFLAGS=-O0 -std=gnu99 -D_XOPEN_SOURCE=500 -D_GNU_SOURCE -D_POSIX_C_SOURCE=200809L \ + -Wall -Wpedantic -Wno-unknown-pragmas -fsanitize=address -fno-omit-frame-pointer +UNAME := $(shell uname) +ifeq ($(UNAME),Darwin) +CFLAGS += -D_DARWIN_C_SOURCE -Weverything -Wno-missing-field-initializers -Wno-padded\ + -Wno-missing-noreturn -Wno-cast-qual +endif +LIBS= +NAME=ask +G=-g + +all: $(NAME) + +clean: + rm $(NAME) + +$(NAME): $(NAME).c bterm.h + $(CC) $(NAME).c $(LIBS) $(CFLAGS) $(G) -o $(NAME) + +install: $(NAME) + @prefix="$(PREFIX)"; \ + if [[ ! $$prefix ]]; then \ + read -p $$'\033[1mWhere do you want to install? (default: /usr/local) \033[0m' prefix; \ + fi; \ + if [[ ! $$prefix ]]; then \ + prefix="/usr/local"; \ + fi; \ + mkdir -pv $$prefix/bin $$prefix/share/man/man1 \ + && cp -v $(NAME) $$prefix/bin/ \ + && cp -v $(NAME).1 $$prefix/share/man/man1/ + +uninstall: + @prefix="$(PREFIX)"; \ + if [[ ! $$prefix ]]; then \ + read -p $$'\033[1mWhere do you want to uninstall from? (default: /usr/local) \033[0m' prefix; \ + fi; \ + if [[ ! $$prefix ]]; then \ + prefix="/usr/local"; \ + fi; \ + echo "Deleting..."; \ + rm -rvf $$prefix/bin/$(NAME) $$prefix/share/man/man1/$(NAME).1 + diff --git a/README.md b/README.md new file mode 100644 index 0000000..ec3d16c --- /dev/null +++ b/README.md @@ -0,0 +1,19 @@ +# ask - a simple command line asker +`ask` is a simple command line tool to get user input. `ask` is less janky than +`read`, more compact than `fzf`, and less bloated than `readline`-based tools. +`ask` supports most of the typical line editing functionality (e.g. arrow keys, +backspace, Ctrl-U) and can be used to perform fuzzy matching or basic user input +all on a single line of terminal space. Like fuzzy find tools, `ask` plays nicely +with unix pipelines, but it's a bit more visually compact. `ask`'s functionality +overlaps with fuzzy finders, but if you want to see a full list of things you're +filtering through, use `fzy` or `fzf` instead of `ask`. + +## Usage +Here's a simple program to move a file from the current directory: + + #!/bin/sh + file="`ls | ask "Pick a file: "`" + mv "$file" "`ask "Move $file to: "`" + +## License +`ask` is released under the MIT License. See LICENSE for details. diff --git a/ask.c b/ask.c new file mode 100644 index 0000000..42b7b3b --- /dev/null +++ b/ask.c @@ -0,0 +1,393 @@ +/* ask - a simple command line asker + * Copyright 2019 Bruce Hill + * Released under the MIT License (see LICENSE for details) + * Usage: ask [-p | --password] [-q | --quickpick] [prompt [initial value]] + * -p: password mode + * -q: quickpick mode (exit when only one option remains) + */ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "bterm.h" + +static int password = 0, quickpick = 0, case_sensitive = 0, to_skip = 0; + +#define LOWERCASE(c) ('A' <= (c) && (c) <= 'Z' ? ((c) + 'a' - 'A') : (c)) +#define EQ(a, b) (case_sensitive ? (a) == (b) : LOWERCASE(a) == LOWERCASE(b)) + +static inline void *memcheck(void *p) +{ + if (!p) { + fprintf(stderr, "Memory allocation failure\n"); + exit(1); + } + return p; +} + +static int score(const char *str, const char *patt) +{ + if (!patt[0]) return 0; + int score = 0; + const char *sp = str, *pp = patt; + while (*sp && !EQ(*sp, *pp)) ++sp; + while (*sp && *pp && EQ(*sp, *pp)) { + ++score; + ++sp; + ++pp; + } + for (; *pp; ++sp, ++pp) { + while (*sp && !EQ(*sp, *pp)) ++sp; + if (!*sp) return 0; + } + if (*pp && !*sp) return 0; + return score; +} + +static void draw_line(FILE *out, const char *line, const char *hl, const char *cur) +{ + int dim = 0, backtrack = 0; + for (const char *pl = line, *phl = hl; *pl; pl++) { + if (phl >= cur) ++backtrack; + if (case_sensitive ? *pl == *phl : LOWERCASE(*pl) == LOWERCASE(*phl)) { + ++phl; + if (dim) { + fputs("\033[22m", out); + dim = 0; + } + } else if (!dim) { + fputs("\033[2m", out); + dim = 1; + } + fputc(*pl, out); + } + if (backtrack) + fprintf(out, "\033[%dD", backtrack); +} + +/* + * A basic fuzzly matcher + */ +static char *fzline(FILE *in, FILE *out, const char *prompt, const char *initial, int nopts, char **opts) +{ + size_t cap = initial ? strlen(initial) + 100 : 100; + char *buf = memcheck(calloc(cap, 1)); + char *picked = NULL; + int b = 0, len = 0; + if (initial) { + if (!strcpy(buf, initial)) return NULL; + len = (int)strlen(initial); + b = len; + fputs(initial, out); + } + + // Show cursor and set to blinking line: + while (1) { + fputs("\033[G\033[K\033[0m", out); + if (prompt) { + fputs("\033[1G\033[K\033[37;1m", out); + fputs(prompt, out); + fputs("\033[0m", out); + } + picked = NULL; + case_sensitive = 0; + for (const char *p = buf; *p; ++p) + case_sensitive |= ('A' <= *p && *p <= 'Z'); + + int ncandidates = 0; + for (int i = 0; i < nopts; i++) + ncandidates += score(opts[i], buf) > 0; + + int bestscore = 0; + char *best = NULL; + int skipped = 0; + for (int i = 0; i < nopts; i++) { + int s = score(opts[i], buf); + if (s && skipped < to_skip) { + ++skipped; + continue; + } + if (s > bestscore) { + best = opts[i]; + bestscore = s; + } + } + if (quickpick && ncandidates == 1 && best) + return best; + + picked = best; + if (best) { + draw_line(out, best, buf, &buf[b]); + } else { + fprintf(out, "\033[0;31m%s\033[0m", buf); + if (b < (int)strlen(buf)) + fprintf(out, "\033[%dD", (int)strlen(buf) - b); + } + fflush(out); + int key; + skip_redraw: + key = bgetkey(in, NULL, NULL, -1); + switch (key) { + case -1: case -2: case -3: goto skip_redraw; + case '\r': + // TODO: support backslash-enter + goto finished; + case KEY_CTRL_C: case KEY_ESC: + free(buf); + picked = NULL; + goto finished; + case KEY_CTRL_A: + if (b > 0) b = 0; + break; + case KEY_CTRL_E: + if (b < len) b = len; + break; + case KEY_CTRL_U: { + int to_clear = b; + if (to_clear) { + memmove(buf, buf+b, (size_t)(len-b)); + buf[len -= b] = 0; + b = 0; + } + break; + } + case KEY_CTRL_K: + if (b < len) + buf[len = b] = 0; + break; + case KEY_CTRL_N: + if (ncandidates) + to_skip = (to_skip + 1) % ncandidates; + break; + case KEY_CTRL_P: + if (ncandidates) + to_skip = (to_skip + ncandidates - 1) % ncandidates; + break; + case KEY_BACKSPACE: case KEY_BACKSPACE2: + if (b > 0) { + --b; + memmove(buf+b, buf+b+1, (size_t)(len-b)); + buf[--len] = 0; + } + break; + case KEY_DELETE: case KEY_CTRL_D: + if (b < len) { + memmove(buf+b, buf+b+1, (size_t)(len-b)); + buf[--len] = 0; + } + break; + case KEY_ARROW_LEFT: case KEY_CTRL_B: + if (b > 0) --b; + break; + case KEY_ARROW_RIGHT: case KEY_CTRL_F: + if (b < len) ++b; + break; + default: + if (' ' <= key && key <= '~') { + if (len + 1 >= (int)cap) { + buf = memcheck(realloc(buf, (cap += 100))); + if (!buf) goto finished; + } + if (b < len) + memmove(buf+b+1, buf+b, (size_t)(len-b+1)); + buf[b++] = (char)key; + buf[++len] = 0; + } + break; + } + } + finished: + return picked; +} + +/** + * A basic readline implementation. No history, but all the normal editing + * key bindings like Ctrl-U to clear to the beginning of the line, backspace, + * arrow keys, etc. + * + * Takes an input file and output file, and an optional prompt and returns + * a malloc'd string containing the user's input or NULL if an error occurred + * or if the user hit Escape or Ctrl-c. + */ +static char *breadline(FILE *in, FILE *out, const char *prompt, const char *initial) +{ + size_t cap = initial ? strlen(initial) + 100 : 100; + char *buf = calloc(cap, 1); + if (!buf) return NULL; + int i = 0, len = 0; + if (prompt) { + fputs("\033[1G\033[K\033[37;1m", out); + fputs(prompt, out); + fputs("\033[0m", out); + } + if (initial) { + strcpy(buf, initial); + len = (int)strlen(initial); + i = len; + fputs(initial, out); + } + // Show cursor + fputs("\033[?25h", out); + while (1) { + fflush(out); + int key = bgetkey(in, NULL, NULL, -1); + switch (key) { + case -1: case -2: case -3: continue; + case '\r': + // TODO: support backslash-enter + goto finished; + case KEY_CTRL_C: case KEY_ESC: + free(buf); + buf = NULL; + goto finished; + case KEY_CTRL_A: + if (i > 0) { + fprintf(out, "\033[%dD", i); + i = 0; + } + break; + case KEY_CTRL_E: + if (i < len) { + fprintf(out, "\033[%dC", len-i); + i = len; + } + break; + case KEY_CTRL_U: { + int to_clear = i; + if (to_clear) { + memmove(buf, buf+i, (size_t)(len-i)); + buf[len -= i] = 0; + i = 0; + fprintf(out, "\033[%dD\033[K", to_clear); + if (len > 0) + fprintf(out, "%s\033[%dD", buf, len); + } + break; + } + case KEY_CTRL_K: + if (i < len) { + buf[len = i] = 0; + fputs("\033[K", out); + } + break; + case KEY_BACKSPACE: case KEY_BACKSPACE2: + if (i > 0) { + --i; + memmove(buf+i, buf+i+1, (size_t)(len-i)); + buf[--len] = 0; + if (i == len) fputs("\033[D \033[D", out); + else fprintf(out, "\033[D%s\033[K\033[%dD", buf+i, len-i); + } + break; + case KEY_DELETE: case KEY_CTRL_D: + if (i < len) { + memmove(buf+i, buf+i+1, (size_t)(len-i)); + buf[--len] = 0; + if (i == len) fputs(" \033[D", out); + else fprintf(out, "%s\033[K\033[%dD", buf+i, len-i); + } + break; + case KEY_ARROW_LEFT: case KEY_CTRL_B: + if (i > 0) { + --i; + fputs("\033[D", out); + } + break; + case KEY_ARROW_RIGHT: case KEY_CTRL_F: + if (i < len) { + ++i; + fputs("\033[C", out); + } + break; + default: + if (' ' <= key && key <= '~') { + if (len + 1 >= (int)cap) { + cap += 100; + buf = realloc(buf, cap); + if (!buf) goto finished; + } + if (i < len) + memmove(buf+i+1, buf+i, (size_t)(len-i+1)); + buf[i++] = (char)key; + buf[++len] = 0; + if (i == len) + fputc(key, out); + else + fprintf(out, "%c%s\033[%dD", (char)key, buf+i, len-i); + } + break; + } + } + finished: + // Reset cursor to block + fputs("\033[1G\033[1 q\033[2K", out); + return buf; +} + +int main(int argc, char *argv[]) +{ + FILE *tty_in = fopen("/dev/tty", "r"); + FILE *tty_out = fopen("/dev/tty", "w"); + struct termios orig_termios, bb_termios; + tcgetattr(fileno(tty_out), &orig_termios); + cfmakeraw(&bb_termios); + if (tcsetattr(fileno(tty_out), TCSAFLUSH, &bb_termios) == -1) + return 1; + + char *prompt = NULL, *initial = NULL; + char **lines = NULL; + size_t linescap = 0, linecap = 0; + int nlines = 0; + char *line = NULL; + struct pollfd pfd = {STDIN_FILENO, POLLIN, 0}; + if (poll(&pfd, 1, 50) > 0) { + while ((getline(&line, &linecap, stdin)) >= 0) { + if ((size_t)nlines >= linescap) + lines = memcheck(realloc(lines, (linescap += 100)*sizeof(char*))); + if (!line[0]) continue; + if (line[strlen(line)-1] == '\n') + line[strlen(line)-1] = '\0'; + lines[nlines++] = memcheck(strdup(line)); + } + } + int a = 1; + while (a < argc) { + if (strcmp(argv[a], "-p") == 0 || strcmp(argv[a], "--password") == 0) { + password = 1; + } else if (strcmp(argv[a], "-q") == 0 || strcmp(argv[a], "--quickpick") == 0) { + quickpick = 1; + } else break; + ++a; + } + if (!prompt && a < argc) prompt = argv[a++]; + if (!initial && a < argc) initial = argv[a++]; + + while (a < argc) { + if ((size_t)nlines >= linescap) + lines = memcheck(realloc(lines, (linescap += 100)*sizeof(char*))); + lines[nlines++] = argv[a++]; + } + + char *output = nlines > 0 + ? fzline(tty_in, tty_out, prompt, initial, nlines, lines) + : breadline(tty_in, tty_out, prompt, initial); + + fputs("\033[G\033[K\033[0m", tty_out); + fflush(tty_out); + tcsetattr(fileno(tty_out), TCSAFLUSH, &orig_termios); + fclose(tty_out); + tty_out = NULL; + fclose(tty_in); + tty_in = NULL; + + if (!output) return 1; + + puts(output); + return 0; +} +// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1 diff --git a/bterm.h b/bterm.h new file mode 100644 index 0000000..07152d7 --- /dev/null +++ b/bterm.h @@ -0,0 +1,304 @@ +/* + * bterm.h + * Copyright 2019 Bruce Hill + * Released under the MIT License + * + * Definitions of some basic terminal stuff, like reading keys + * and some terminal escape sequences. + */ + +#ifndef FILE__BTERM_H +#define FILE__BTERM_H + +#include +#include + +#define KEY_F1 (0xFFFF-0) +#define KEY_F2 (0xFFFF-1) +#define KEY_F3 (0xFFFF-2) +#define KEY_F4 (0xFFFF-3) +#define KEY_F5 (0xFFFF-4) +#define KEY_F6 (0xFFFF-5) +#define KEY_F7 (0xFFFF-6) +#define KEY_F8 (0xFFFF-7) +#define KEY_F9 (0xFFFF-8) +#define KEY_F10 (0xFFFF-9) +#define KEY_F11 (0xFFFF-10) +#define KEY_F12 (0xFFFF-11) +#define KEY_INSERT (0xFFFF-12) +#define KEY_DELETE (0xFFFF-13) +#define KEY_HOME (0xFFFF-14) +#define KEY_END (0xFFFF-15) +#define KEY_PGUP (0xFFFF-16) +#define KEY_PGDN (0xFFFF-17) +#define KEY_ARROW_UP (0xFFFF-18) +#define KEY_ARROW_DOWN (0xFFFF-19) +#define KEY_ARROW_LEFT (0xFFFF-20) +#define KEY_ARROW_RIGHT (0xFFFF-21) +#define KEY_MOUSE_LEFT (0xFFFF-22) +#define KEY_MOUSE_RIGHT (0xFFFF-23) +#define KEY_MOUSE_MIDDLE (0xFFFF-24) +#define KEY_MOUSE_RELEASE (0xFFFF-25) +#define KEY_MOUSE_WHEEL_UP (0xFFFF-26) +#define KEY_MOUSE_WHEEL_DOWN (0xFFFF-27) +#define KEY_MOUSE_DOUBLE_LEFT (0xFFFF-28) + +/* These are all ASCII code points below SPACE character and a BACKSPACE key. */ +#define KEY_CTRL_TILDE 0x00 +#define KEY_CTRL_2 0x00 /* clash with 'CTRL_TILDE' */ +#define KEY_CTRL_A 0x01 +#define KEY_CTRL_B 0x02 +#define KEY_CTRL_C 0x03 +#define KEY_CTRL_D 0x04 +#define KEY_CTRL_E 0x05 +#define KEY_CTRL_F 0x06 +#define KEY_CTRL_G 0x07 +#define KEY_BACKSPACE 0x08 +#define KEY_CTRL_H 0x08 /* clash with 'CTRL_BACKSPACE' */ +#define KEY_TAB 0x09 +#define KEY_CTRL_I 0x09 /* clash with 'TAB' */ +#define KEY_CTRL_J 0x0A +#define KEY_CTRL_K 0x0B +#define KEY_CTRL_L 0x0C +#define KEY_ENTER 0x0D +#define KEY_CTRL_M 0x0D /* clash with 'ENTER' */ +#define KEY_CTRL_N 0x0E +#define KEY_CTRL_O 0x0F +#define KEY_CTRL_P 0x10 +#define KEY_CTRL_Q 0x11 +#define KEY_CTRL_R 0x12 +#define KEY_CTRL_S 0x13 +#define KEY_CTRL_T 0x14 +#define KEY_CTRL_U 0x15 +#define KEY_CTRL_V 0x16 +#define KEY_CTRL_W 0x17 +#define KEY_CTRL_X 0x18 +#define KEY_CTRL_Y 0x19 +#define KEY_CTRL_Z 0x1A +#define KEY_ESC 0x1B +#define KEY_CTRL_LSQ_BRACKET 0x1B /* clash with 'ESC' */ +#define KEY_CTRL_3 0x1B /* clash with 'ESC' */ +#define KEY_CTRL_4 0x1C +#define KEY_CTRL_BACKSLASH 0x1C /* clash with 'CTRL_4' */ +#define KEY_CTRL_5 0x1D +#define KEY_CTRL_RSQ_BRACKET 0x1D /* clash with 'CTRL_5' */ +#define KEY_CTRL_6 0x1E +#define KEY_CTRL_7 0x1F +#define KEY_CTRL_SLASH 0x1F /* clash with 'CTRL_7' */ +#define KEY_CTRL_UNDERSCORE 0x1F /* clash with 'CTRL_7' */ +#define KEY_SPACE 0x20 +#define KEY_BACKSPACE2 0x7F +#define KEY_CTRL_8 0x7F /* clash with 'BACKSPACE2' */ + + +// Terminal escape sequences: +#define CSI "\033[" +#define T_WRAP "7" +#define T_SHOW_CURSOR "25" +#define T_MOUSE_XY "1000" +#define T_MOUSE_CELL "1002" +#define T_MOUSE_SGR "1006" +#define T_ALT_SCREEN "1049" +#define T_ON(opt) CSI "?" opt "h" +#define T_OFF(opt) CSI "?" opt "l" + +#define move_cursor(f, x, y) fprintf((f), CSI "%d;%dH", (int)(y)+1, (int)(x)+1) + +#define ESC_DELAY 10 + +int bgetkey(FILE *in, int *mouse_x, int *mouse_y, int timeout); +const char *bkeyname(int key); + +static inline int nextchar(int fd, int timeout) +{ + char c; + struct pollfd pfd = {fd, POLLIN, 0}; + if (poll(&pfd, 1, timeout) > 0) + return read(fd, &c, 1) == 1 ? c : -1; + return -1; +} + +/* + * Get one key of input from the given file. Returns -1 on failure. + * If mouse_x or mouse_y are non-null and a mouse event occurs, they will be + * set to the position of the mouse (0-indexed). + */ +int bgetkey(FILE *in, int *mouse_x, int *mouse_y, int timeout) +{ + int fd = fileno(in); + int numcode = 0, super = 0; + int c = nextchar(fd, timeout); + if (c == '\x1b') + goto escape; + + return c; + + escape: + c = nextchar(fd, ESC_DELAY); + // Actual escape key: + if (c < 0) + return KEY_ESC; + + switch (c) { + case '\x1b': ++super; goto escape; + case '[': goto CSI_start; + case 'P': goto DCS; + case 'O': goto SS3; + default: return -1; + } + + CSI_start: + c = nextchar(fd, ESC_DELAY); + if (c == -1) + return -1; + + switch (c) { + case 'A': return KEY_ARROW_UP; + case 'B': return KEY_ARROW_DOWN; + case 'C': return KEY_ARROW_RIGHT; + case 'D': return KEY_ARROW_LEFT; + case 'F': return KEY_END; + case 'H': return KEY_HOME; + case '~': + switch (numcode) { + case 3: return KEY_DELETE; + case 5: return KEY_PGUP; + case 6: return KEY_PGDN; + case 15: return KEY_F5; + case 17: return KEY_F6; + case 18: return KEY_F7; + case 19: return KEY_F8; + case 20: return KEY_F9; + case 21: return KEY_F10; + case 23: return KEY_F11; + case 24: return KEY_F12; + } + return -1; + case '<': { // Mouse clicks + int buttons = 0, x = 0, y = 0; + char buf; + while (read(fd, &buf, 1) == 1 && '0' <= buf && buf <= '9') + buttons = buttons * 10 + (buf - '0'); + if (buf != ';') return -1; + while (read(fd, &buf, 1) == 1 && '0' <= buf && buf <= '9') + x = x * 10 + (buf - '0'); + if (buf != ';') return -1; + while (read(fd, &buf, 1) == 1 && '0' <= buf && buf <= '9') + y = y * 10 + (buf - '0'); + if (buf != 'm' && buf != 'M') return -1; + + if (mouse_x) *mouse_x = x - 1; + if (mouse_y) *mouse_y = y - 1; + + if (buf == 'm') + return KEY_MOUSE_RELEASE; + switch (buttons) { + case 64: return KEY_MOUSE_WHEEL_UP; + case 65: return KEY_MOUSE_WHEEL_DOWN; + case 0: return KEY_MOUSE_LEFT; + case 1: return KEY_MOUSE_RIGHT; + case 2: return KEY_MOUSE_MIDDLE; + default: return -1; + } + break; + } + default: + if ('0' <= c && c <= '9') { + // Ps prefix + numcode = 10*numcode + (c - '0'); + goto CSI_start; + } + } + return -1; + + DCS: + return -1; + + SS3: + switch (nextchar(fd, ESC_DELAY)) { + case 'P': return KEY_F1; + case 'Q': return KEY_F2; + case 'R': return KEY_F3; + case 'S': return KEY_F4; + default: break; + } + return -1; +} + +/* + * Return the name of a key, if one exists and is different from the key itself + * (i.e. bkeyname('c') == NULL, bkeyname(' ') == "Space") + */ +const char *bkeyname(int key) +{ + // TODO: currently only the keys I'm using are named + switch (key) { + case KEY_F1: return "F1"; + case KEY_F2: return "F2"; + case KEY_F3: return "F3"; + case KEY_F4: return "F4"; + case KEY_F5: return "F5"; + case KEY_F6: return "F6"; + case KEY_F7: return "F7"; + case KEY_F8: return "F8"; + case KEY_F9: return "F9"; + case KEY_F10: return "F10"; + case KEY_F11: return "F11"; + case KEY_F12: return "F12"; + case KEY_INSERT: return "Insert"; + case KEY_DELETE: return "Delete"; + case KEY_HOME: return "Home"; + case KEY_END: return "End"; + case KEY_PGUP: return "PgUp"; + case KEY_PGDN: return "PgDn"; + case KEY_ARROW_UP: return "Up"; + case KEY_ARROW_DOWN: return "Down"; + case KEY_ARROW_LEFT: return "Left"; + case KEY_ARROW_RIGHT: return "Right"; + case KEY_MOUSE_LEFT: return "Left click"; + case KEY_MOUSE_RIGHT: return "Right click"; + case KEY_MOUSE_MIDDLE: return "Middle click"; + case KEY_MOUSE_RELEASE: return "Mouse release"; + case KEY_MOUSE_WHEEL_UP: return "Mouse wheel up"; + case KEY_MOUSE_WHEEL_DOWN: return "Mouse wheel down"; + case KEY_MOUSE_DOUBLE_LEFT: return "Double left click"; + case KEY_CTRL_TILDE: return "Ctrl-[2~]"; + case KEY_CTRL_A: return "Ctrl-a"; + case KEY_CTRL_B: return "Ctrl-b"; + case KEY_CTRL_C: return "Ctrl-c"; + case KEY_CTRL_D: return "Ctrl-d"; + case KEY_CTRL_E: return "Ctrl-e"; + case KEY_CTRL_F: return "Ctrl-f"; + case KEY_CTRL_G: return "Ctrl-g"; + case KEY_CTRL_H: return "Ctrl-h"; + case KEY_TAB: return "Tab"; + case KEY_CTRL_J: return "Ctrl-j"; + case KEY_CTRL_K: return "Ctrl-k"; + case KEY_CTRL_L: return "Ctrl-l"; + case KEY_ENTER: return "Enter"; + case KEY_CTRL_N: return "Ctrl-n"; + case KEY_CTRL_O: return "Ctrl-o"; + case KEY_CTRL_P: return "Ctrl-p"; + case KEY_CTRL_Q: return "Ctrl-q"; + case KEY_CTRL_R: return "Ctrl-r"; + case KEY_CTRL_S: return "Ctrl-s"; + case KEY_CTRL_T: return "Ctrl-t"; + case KEY_CTRL_U: return "Ctrl-u"; + case KEY_CTRL_V: return "Ctrl-v"; + case KEY_CTRL_W: return "Ctrl-w"; + case KEY_CTRL_X: return "Ctrl-x"; + case KEY_CTRL_Y: return "Ctrl-y"; + case KEY_CTRL_Z: return "Ctrl-z"; + case KEY_ESC: return "Esc"; + case KEY_CTRL_BACKSLASH: return "Ctrl-[4\\]"; + case KEY_CTRL_RSQ_BRACKET: return "Ctrl-[5]]"; + case KEY_CTRL_6: return "Ctrl-6"; + case KEY_CTRL_SLASH: return "Ctrl-[7/_]"; + case KEY_SPACE: return "Space"; + case KEY_BACKSPACE2: return "Backspace"; + } + return NULL; +} + +#endif +// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1