Bruce/ask
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Bruce Hill 2019-06-04 19:27:54 -07:00
commit 3f4bcca969
4 changed files with 760 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
Makefile Normal file
View File

@ -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

19
README.md Normal file
View File

@ -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.

393
ask.c Normal file
View File

@ -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 <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <termios.h>
#include <unistd.h>
#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

304
bterm.h Normal file
View File

@ -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 <poll.h>
#include <stdio.h>
#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