2 * Copyright (c) 1991, 1993, 1994
3 * The Regents of the University of California. All rights reserved.
4 * Copyright (c) 1991, 1993, 1994, 1995, 1996
5 * Keith Bostic. All rights reserved.
7 * See the LICENSE file for redistribution information.
13 static const char sccsid[] = "$Id: key.c,v 10.54 2013/11/13 12:15:27 zy Exp $";
16 #include <sys/types.h>
17 #include <sys/queue.h>
20 #include <bitstring.h>
33 static int v_event_append __P((SCR *, EVENT *));
34 static int v_event_grow __P((SCR *, int));
35 static int v_key_cmp __P((const void *, const void *));
36 static void v_keyval __P((SCR *, int, scr_keyval_t));
37 static void v_sync __P((SCR *, int));
41 * Historic vi always used:
43 * ^D: autoindent deletion
44 * ^H: last character deletion
45 * ^W: last word deletion
46 * ^Q: quote the next character (if not used in flow control).
47 * ^V: quote the next character
49 * regardless of the user's choices for these characters. The user's erase
50 * and kill characters worked in addition to these characters. Nvi wires
51 * down the above characters, but in addition permits the VEOF, VERASE, VKILL
52 * and VWERASE characters described by the user's termios structure.
54 * Ex was not consistent with this scheme, as it historically ran in tty
55 * cooked mode. This meant that the scroll command and autoindent erase
56 * characters were mapped to the user's EOF character, and the character
57 * and word deletion characters were the user's tty character and word
58 * deletion characters. This implementation makes it all consistent, as
59 * described above for vi.
62 * This means that all screens share a special key set.
65 {K_BACKSLASH, '\\'}, /* \ */
66 {K_CARAT, '^'}, /* ^ */
67 {K_CNTRLD, '\004'}, /* ^D */
68 {K_CNTRLR, '\022'}, /* ^R */
69 {K_CNTRLT, '\024'}, /* ^T */
70 {K_CNTRLZ, '\032'}, /* ^Z */
71 {K_COLON, ':'}, /* : */
72 {K_CR, '\r'}, /* \r */
73 {K_ESCAPE, '\033'}, /* ^[ */
74 {K_FORMFEED, '\f'}, /* \f */
75 {K_HEXCHAR, '\030'}, /* ^X */
76 {K_NL, '\n'}, /* \n */
77 {K_RIGHTBRACE, '}'}, /* } */
78 {K_RIGHTPAREN, ')'}, /* ) */
79 {K_TAB, '\t'}, /* \t */
80 {K_VERASE, '\b'}, /* \b */
81 {K_VKILL, '\025'}, /* ^U */
82 {K_VLNEXT, '\021'}, /* ^Q */
83 {K_VLNEXT, '\026'}, /* ^V */
84 {K_VWERASE, '\027'}, /* ^W */
85 {K_ZERO, '0'}, /* 0 */
87 #define ADDITIONAL_CHARACTERS 4
88 {K_NOTUSED, 0}, /* VEOF, VERASE, VKILL, VWERASE */
94 (sizeof(keylist) / sizeof(keylist[0])) - ADDITIONAL_CHARACTERS;
98 * Initialize the special key lookup table.
100 * PUBLIC: int v_key_init __P((SCR *));
114 v_keyval(sp, K_CNTRLD, KEY_VEOF);
115 v_keyval(sp, K_VERASE, KEY_VERASE);
116 v_keyval(sp, K_VKILL, KEY_VKILL);
117 v_keyval(sp, K_VWERASE, KEY_VWERASE);
119 /* Sort the special key list. */
120 qsort(keylist, nkeylist, sizeof(keylist[0]), v_key_cmp);
122 /* Initialize the fast lookup table. */
123 for (kp = keylist, cnt = nkeylist; cnt--; ++kp)
124 gp->special_key[kp->ch] = kp->value;
126 /* Find a non-printable character to use as a message separator. */
127 for (ch = 1; ch <= UCHAR_MAX; ++ch)
132 if (ch != gp->noprint) {
133 msgq(sp, M_ERR, "079|No non-printable character found");
143 * We've left some open slots in the keylist table, and if these values exist,
144 * we put them into place. Note, they may reset (or duplicate) values already
145 * in the table, so we check for that first.
157 /* Get the key's value from the screen. */
158 if (sp->gp->scr_keyval(sp, name, &ch, &dne))
163 /* Check for duplication. */
164 for (kp = keylist; kp->value != K_NOTUSED; ++kp)
170 /* Add a new entry. */
171 if (kp->value == K_NOTUSED) {
172 keylist[nkeylist].ch = ch;
173 keylist[nkeylist].value = val;
180 * Build the fast-lookup key display array.
182 * PUBLIC: void v_key_ilookup __P((SCR *));
185 v_key_ilookup(SCR *sp)
192 for (gp = sp->gp, ch = 0;; ++ch) {
193 for (p = gp->cname[ch].name, t = v_key_name(sp, ch),
194 len = gp->cname[ch].len = sp->clen; len--;)
196 if (ch == MAX_FAST_KEY)
203 * Return the length of the string that will display the key.
204 * This routine is the backup for the KEY_LEN() macro.
206 * PUBLIC: size_t v_key_len __P((SCR *, ARG_CHAR_T));
213 (void)v_key_name(sp, ch);
219 * Return the string that will display the key. This routine
220 * is the backup for the KEY_NAME() macro.
222 * PUBLIC: char *v_key_name __P((SCR *, ARG_CHAR_T));
229 static const char hexdigit[] = "0123456789abcdef";
230 static const char octdigit[] = "01234567";
236 * Cache the last checked character. It won't be a problem
237 * since nvi will rescan the mapping when settings changed.
239 if (ach && sp->lastc == ach)
244 len = wctomb(sp->cname, ach);
245 if (len > MB_CUR_MAX)
247 sp->cname[(len = 1)-1] = (u_char)ach;
249 ch = (u_char)sp->cname[0];
250 sp->cname[len] = '\0';
252 /* See if the character was explicitly declared printable or not. */
253 if ((chp = O_STR(sp, O_PRINT)) != NULL)
254 if (strstr(chp, sp->cname) != NULL)
256 if ((chp = O_STR(sp, O_NOPRINT)) != NULL)
257 if (strstr(chp, sp->cname) != NULL)
261 * Historical (ARPA standard) mappings. Printable characters are left
262 * alone. Control characters less than 0x20 are represented as '^'
263 * followed by the character offset from the '@' character in the ASCII
264 * character set. Del (0x7f) is represented as '^' followed by '?'.
267 * The following code depends on the current locale being identical to
268 * the ASCII map from 0x40 to 0x5f (since 0x1f + 0x40 == 0x5f). I'm
269 * told that this is a reasonable assumption...
272 * The code prints non-printable wide characters in 4 or 5 digits
273 * Unicode escape sequences, so only supports plane 0 to 15.
275 if (CAN_PRINT(sp, ach))
277 nopr: if (iscntrl(ch) && (ch < 0x20 || ch == 0x7f)) {
279 sp->cname[1] = ch == 0x7f ? '?' : '@' + ch;
284 if (INTISWIDE(ach)) {
287 if (!strcmp(codeset(), "UTF-8"))
288 uc = decode_utf8(sp->cname);
291 char buf[sizeof(sp->cname)] = "";
292 size_t left = sizeof(sp->cname);
293 char *in = sp->cname;
295 iconv(sp->conv.id[IC_IE_TO_UTF16],
296 (iconv_src_t)&in, &len, &out, &left);
297 iconv(sp->conv.id[IC_IE_TO_UTF16],
298 NULL, NULL, NULL, NULL);
299 uc = decode_utf16(buf, 1);
303 len = snprintf(sp->cname, sizeof(sp->cname),
304 uc < 0x10000 ? "\\u%04x" : "\\U%05X", uc);
309 if (O_ISSET(sp, O_OCTAL)) {
311 sp->cname[1] = octdigit[(ch & 0300) >> 6];
312 sp->cname[2] = octdigit[(ch & 070) >> 3];
313 sp->cname[3] = octdigit[ ch & 07 ];
317 sp->cname[2] = hexdigit[(ch & 0xf0) >> 4];
318 sp->cname[3] = hexdigit[ ch & 0x0f ];
321 done: sp->cname[sp->clen = len] = '\0';
327 * Fill in the value for a key. This routine is the backup
328 * for the KEY_VAL() macro.
330 * PUBLIC: e_key_t v_key_val __P((SCR *, ARG_CHAR_T));
340 kp = bsearch(&k, keylist, nkeylist, sizeof(keylist[0]), v_key_cmp);
341 return (kp == NULL ? K_NOTUSED : kp->value);
346 * Push events/keys onto the front of the buffer.
348 * There is a single input buffer in ex/vi. Characters are put onto the
349 * end of the buffer by the terminal input routines, and pushed onto the
350 * front of the buffer by various other functions in ex/vi. Each key has
351 * an associated flag value, which indicates if it has already been quoted,
352 * and if it is the result of a mapping or an abbreviation.
354 * PUBLIC: int v_event_push __P((SCR *, EVENT *, CHAR_T *, size_t, u_int));
359 EVENT *p_evp, /* Push event. */
360 CHAR_T *p_s, /* Push characters. */
361 size_t nitems, /* Number of items to push. */
362 u_int flags) /* CH_* flags. */
368 /* If we have room, stuff the items into the buffer. */
370 if (nitems <= gp->i_next ||
371 (gp->i_event != NULL && gp->i_cnt == 0 && nitems <= gp->i_nelem)) {
373 gp->i_next -= nitems;
378 * If there are currently items in the queue, shift them up,
379 * leaving some extra room. Get enough space plus a little
382 #define TERM_PUSH_SHIFT 30
383 total = gp->i_cnt + gp->i_next + nitems + TERM_PUSH_SHIFT;
384 if (total >= gp->i_nelem && v_event_grow(sp, MAX(total, 64)))
387 BCOPY(gp->i_event + gp->i_next,
388 gp->i_event + TERM_PUSH_SHIFT + nitems, gp->i_cnt);
389 gp->i_next = TERM_PUSH_SHIFT;
391 /* Put the new items into the queue. */
392 copy: gp->i_cnt += nitems;
393 for (evp = gp->i_event + gp->i_next; nitems--; ++evp) {
397 evp->e_event = E_CHARACTER;
399 evp->e_value = KEY_VAL(sp, evp->e_c);
400 F_INIT(&evp->e_ch, flags);
408 * Append events onto the tail of the buffer.
415 CHAR_T *s; /* Characters. */
418 size_t nevents; /* Number of events. */
420 /* Grow the buffer as necessary. */
421 nevents = argp->e_event == E_STRING ? argp->e_len : 1;
423 if (gp->i_event == NULL ||
424 nevents > gp->i_nelem - (gp->i_next + gp->i_cnt))
425 v_event_grow(sp, MAX(nevents, 64));
426 evp = gp->i_event + gp->i_next + gp->i_cnt;
427 gp->i_cnt += nevents;
429 /* Transform strings of characters into single events. */
430 if (argp->e_event == E_STRING)
431 for (s = argp->e_csp; nevents--; ++evp) {
432 evp->e_event = E_CHARACTER;
434 evp->e_value = KEY_VAL(sp, evp->e_c);
442 /* Remove events from the queue. */
443 #define QREM(len) { \
444 if ((gp->i_cnt -= len) == 0) \
452 * Return the next event.
455 * The flag EC_NODIGIT probably needs some explanation. First, the idea of
456 * mapping keys is that one or more keystrokes act like a function key.
457 * What's going on is that vi is reading a number, and the character following
458 * the number may or may not be mapped (EC_MAPCOMMAND). For example, if the
459 * user is entering the z command, a valid command is "z40+", and we don't want
460 * to map the '+', i.e. if '+' is mapped to "xxx", we don't want to change it
461 * into "z40xxx". However, if the user enters "35x", we want to put all of the
462 * characters through the mapping code.
464 * Historical practice is a bit muddled here. (Surprise!) It always permitted
465 * mapping digits as long as they weren't the first character of the map, e.g.
466 * ":map ^A1 xxx" was okay. It also permitted the mapping of the digits 1-9
467 * (the digit 0 was a special case as it doesn't indicate the start of a count)
468 * as the first character of the map, but then ignored those mappings. While
469 * it's probably stupid to map digits, vi isn't your mother.
471 * The way this works is that the EC_MAPNODIGIT causes term_key to return the
472 * end-of-digit without "looking" at the next character, i.e. leaving it as the
473 * user entered it. Presumably, the next term_key call will tell us how the
474 * user wants it handled.
476 * There is one more complication. Users might map keys to digits, and, as
477 * it's described above, the commands:
482 * would return the keys "d2<end-of-digits>1G", when the user probably wanted
483 * "d21<end-of-digits>G". So, if a map starts off with a digit we continue as
484 * before, otherwise, we pretend we haven't mapped the character, and return
487 * Now that that's out of the way, let's talk about Energizer Bunny macros.
488 * It's easy to create macros that expand to a loop, e.g. map x 3x. It's
489 * fairly easy to detect this example, because it's all internal to term_key.
490 * If we're expanding a macro and it gets big enough, at some point we can
491 * assume it's looping and kill it. The examples that are tough are the ones
492 * where the parser is involved, e.g. map x "ayyx"byy. We do an expansion
493 * on 'x', and get "ayyx"byy. We then return the first 4 characters, and then
494 * find the looping macro again. There is no way that we can detect this
495 * without doing a full parse of the command, because the character that might
496 * cause the loop (in this case 'x') may be a literal character, e.g. the map
497 * map x "ayy"xyy"byy is perfectly legal and won't cause a loop.
499 * Historic vi tried to detect looping macros by disallowing obvious cases in
500 * the map command, maps that that ended with the same letter as they started
501 * (which wrongly disallowed "map x 'x"), and detecting macros that expanded
502 * too many times before keys were returned to the command parser. It didn't
503 * get many (most?) of the tricky cases right, however, and it was certainly
504 * possible to create macros that ran forever. And, even if it did figure out
505 * what was going on, the user was usually tossed into ex mode. Finally, any
506 * changes made before vi realized that the macro was recursing were left in
507 * place. We recover gracefully, but the only recourse the user has in an
508 * infinite macro loop is to interrupt.
511 * It is historic practice that mapping characters to themselves as the first
512 * part of the mapped string was legal, and did not cause infinite loops, i.e.
513 * ":map! { {^M^T" and ":map n nz." were known to work. The initial, matching
514 * characters were returned instead of being remapped.
517 * It is also historic practice that the macro "map ] ]]^" caused a single ]
518 * keypress to behave as the command ]] (the ^ got the map past the vi check
519 * for "tail recursion"). Conversely, the mapping "map n nn^" went recursive.
520 * What happened was that, in the historic vi, maps were expanded as the keys
521 * were retrieved, but not all at once and not centrally. So, the keypress ]
522 * pushed ]]^ on the stack, and then the first ] from the stack was passed to
523 * the ]] command code. The ]] command then retrieved a key without entering
524 * the mapping code. This could bite us anytime a user has a map that depends
525 * on secondary keys NOT being mapped. I can't see any possible way to make
526 * this work in here without the complete abandonment of Rationality Itself.
529 * The final issue is recovery. It would be possible to undo all of the work
530 * that was done by the macro if we entered a record into the log so that we
531 * knew when the macro started, and, in fact, this might be worth doing at some
532 * point. Given that this might make the log grow unacceptably (consider that
533 * cursor keys are done with maps), for now we leave any changes made in place.
535 * PUBLIC: int v_event_get __P((SCR *, EVENT *, int, u_int32_t));
547 int init_nomap, ispartial, istimeout, remap_cnt;
551 /* If simply checking for interrupts, argp may be NULL. */
555 retry: istimeout = remap_cnt = 0;
558 * If the queue isn't empty and we're timing out for characters,
559 * return immediately.
561 if (gp->i_cnt != 0 && LF_ISSET(EC_TIMEOUT))
565 * If the queue is empty, we're checking for interrupts, or we're
566 * timing out for characters, get more events.
568 if (gp->i_cnt == 0 || LF_ISSET(EC_INTERRUPT | EC_TIMEOUT)) {
570 * If we're reading new characters, check any scripting
573 if (F_ISSET(gp, G_SCRWIN) && sscr_input(sp))
575 loop: if (gp->scr_event(sp, argp,
576 LF_ISSET(EC_INTERRUPT | EC_QUOTED | EC_RAW), timeout))
578 switch (argp->e_event) {
583 * Fatal conditions cause the file to be synced to
586 v_sync(sp, RCV_ENDSESSION | RCV_PRESERVE |
587 (argp->e_event == E_SIGTERM ? 0: RCV_EMAIL));
593 /* Set the global interrupt flag. */
594 F_SET(sp->gp, G_INTERRUPTED);
597 * If the caller was interested in interrupts, return
600 if (LF_ISSET(EC_INTERRUPT))
604 append: if (v_event_append(sp, argp))
611 * If the caller was only interested in interrupts or timeouts, return
612 * immediately. (We may have gotten characters, and that's okay, they
613 * were queued up for later use.)
615 if (LF_ISSET(EC_INTERRUPT | EC_TIMEOUT))
618 newmap: evp = &gp->i_event[gp->i_next];
621 * If the next event in the queue isn't a character event, return
624 if (evp->e_event != E_CHARACTER) {
631 * If the key isn't mappable because:
633 * + ... the timeout has expired
634 * + ... it's not a mappable key
635 * + ... neither the command or input map flags are set
636 * + ... there are no maps that can apply to it
638 * return it forthwith.
640 if (istimeout || F_ISSET(&evp->e_ch, CH_NOMAP) ||
641 !LF_ISSET(EC_MAPCOMMAND | EC_MAPINPUT) ||
642 ((evp->e_c & ~MAX_BIT_SEQ) == 0 &&
643 !bit_test(gp->seqb, evp->e_c)))
646 /* Search the map. */
647 qp = seq_find(sp, NULL, evp, NULL, gp->i_cnt,
648 LF_ISSET(EC_MAPCOMMAND) ? SEQ_COMMAND : SEQ_INPUT, &ispartial);
651 * If get a partial match, get more characters and retry the map.
652 * If time out without further characters, return the characters
656 * <escape> characters are a problem. Cursor keys start with <escape>
657 * characters, so there's almost always a map in place that begins with
658 * an <escape> character. If we timeout <escape> keys in the same way
659 * that we timeout other keys, the user will get a noticeable pause as
660 * they enter <escape> to terminate input mode. If key timeout is set
661 * for a slow link, users will get an even longer pause. Nvi used to
662 * simply timeout <escape> characters at 1/10th of a second, but this
663 * loses over PPP links where the latency is greater than 100Ms.
666 if (O_ISSET(sp, O_TIMEOUT))
667 timeout = (evp->e_value == K_ESCAPE ?
668 O_VAL(sp, O_ESCAPETIME) :
669 O_VAL(sp, O_KEYTIME)) * 100;
675 /* If no map, return the character. */
677 nomap: if (!ISDIGIT(evp->e_c) && LF_ISSET(EC_MAPNODIGIT))
685 * If looking for the end of a digit string, and the first character
686 * of the map is it, pretend we haven't seen the character.
688 if (LF_ISSET(EC_MAPNODIGIT) &&
689 qp->output != NULL && !ISDIGIT(qp->output[0])) {
690 not_digit: argp->e_c = CH_NOT_DIGIT;
691 argp->e_value = K_NOTUSED;
692 argp->e_event = E_CHARACTER;
693 F_INIT(&argp->e_ch, 0);
697 /* Find out if the initial segments are identical. */
698 init_nomap = !e_memcmp(qp->output, &gp->i_event[gp->i_next], qp->ilen);
700 /* Delete the mapped characters from the queue. */
703 /* If keys mapped to nothing, go get more. */
704 if (qp->output == NULL)
707 /* If remapping characters... */
708 if (O_ISSET(sp, O_REMAP)) {
710 * Periodically check for interrupts. Always check the first
711 * time through, because it's possible to set up a map that
712 * will return a character every time, but will expand to more,
713 * e.g. "map! a aaaa" will always return a 'a', but we'll never
714 * get anywhere useful.
716 if ((++remap_cnt == 1 || remap_cnt % 10 == 0) &&
717 (gp->scr_event(sp, &ev,
718 EC_INTERRUPT, 0) || ev.e_event == E_INTERRUPT)) {
719 F_SET(sp->gp, G_INTERRUPTED);
720 argp->e_event = E_INTERRUPT;
725 * If an initial part of the characters mapped, they are not
726 * further remapped -- return the first one. Push the rest
727 * of the characters, or all of the characters if no initial
728 * part mapped, back on the queue.
731 if (v_event_push(sp, NULL, qp->output + qp->ilen,
732 qp->olen - qp->ilen, CH_MAPPED))
734 if (v_event_push(sp, NULL,
735 qp->output, qp->ilen, CH_NOMAP | CH_MAPPED))
737 evp = &gp->i_event[gp->i_next];
740 if (v_event_push(sp, NULL, qp->output, qp->olen, CH_MAPPED))
745 /* Else, push the characters on the queue and return one. */
746 if (v_event_push(sp, NULL, qp->output, qp->olen, CH_MAPPED | CH_NOMAP))
754 * Walk the screen lists, sync'ing files to their backup copies.
764 TAILQ_FOREACH(sp, gp->dq, q)
766 TAILQ_FOREACH(sp, gp->hq, q)
774 * PUBLIC: void v_event_err __P((SCR *, EVENT *));
781 switch (evp->e_event) {
783 msgq(sp, M_ERR, "276|Unexpected character event");
786 msgq(sp, M_ERR, "277|Unexpected end-of-file event");
789 msgq(sp, M_ERR, "279|Unexpected interrupt event");
792 msgq(sp, M_ERR, "281|Unexpected repaint event");
795 msgq(sp, M_ERR, "285|Unexpected string event");
798 msgq(sp, M_ERR, "286|Unexpected timeout event");
801 msgq(sp, M_ERR, "316|Unexpected resize event");
805 * Theoretically, none of these can occur, as they're handled at the
815 /* Free any allocated memory. */
816 if (evp->e_asp != NULL)
822 * Flush any flagged keys, returning if any keys were flushed.
824 * PUBLIC: int v_event_flush __P((SCR *, u_int));
834 for (rval = 0, gp = sp->gp; gp->i_cnt != 0 &&
835 F_ISSET(&gp->i_event[gp->i_next].e_ch, flags); rval = 1)
842 * Grow the terminal queue.
850 size_t new_nelem, olen;
853 new_nelem = gp->i_nelem + add;
854 olen = gp->i_nelem * sizeof(gp->i_event[0]);
855 BINC_RET(sp, EVENT, gp->i_event, olen, new_nelem * sizeof(gp->i_event[0]));
856 gp->i_nelem = olen / sizeof(gp->i_event[0]);
862 * Compare two keys for sorting.
869 return (((KEYLIST *)ap)->ch - ((KEYLIST *)bp)->ch);