1/* $NetBSD: keymacro.c,v 1.24 2019/07/23 10:18:52 christos Exp $ */ 2 3/*- 4 * Copyright (c) 1992, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * This code is derived from software contributed to Berkeley by 8 * Christos Zoulas of Cornell University. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35#include "config.h" 36#if !defined(lint) && !defined(SCCSID) 37#if 0 38static char sccsid[] = "@(#)key.c 8.1 (Berkeley) 6/4/93"; 39#else 40__RCSID("$NetBSD: keymacro.c,v 1.24 2019/07/23 10:18:52 christos Exp $"); 41#endif 42#endif /* not lint && not SCCSID */ 43 44/* 45 * keymacro.c: This module contains the procedures for maintaining 46 * the extended-key map. 47 * 48 * An extended-key (key) is a sequence of keystrokes introduced 49 * with a sequence introducer and consisting of an arbitrary 50 * number of characters. This module maintains a map (the 51 * el->el_keymacro.map) 52 * to convert these extended-key sequences into input strs 53 * (XK_STR) or editor functions (XK_CMD). 54 * 55 * Warning: 56 * If key is a substr of some other keys, then the longer 57 * keys are lost!! That is, if the keys "abcd" and "abcef" 58 * are in el->el_keymacro.map, adding the key "abc" will cause 59 * the first two definitions to be lost. 60 * 61 * Restrictions: 62 * ------------- 63 * 1) It is not possible to have one key that is a 64 * substr of another. 65 */ 66#include <stdlib.h> 67#include <string.h> 68 69#include "el.h" 70#include "fcns.h" 71 72/* 73 * The Nodes of the el->el_keymacro.map. The el->el_keymacro.map is a 74 * linked list of these node elements 75 */ 76struct keymacro_node_t { 77 wchar_t ch; /* single character of key */ 78 int type; /* node type */ 79 keymacro_value_t val; /* command code or pointer to str, */ 80 /* if this is a leaf */ 81 struct keymacro_node_t *next; /* ptr to next char of this key */ 82 struct keymacro_node_t *sibling;/* ptr to another key with same prefix*/ 83}; 84 85static int node_trav(EditLine *, keymacro_node_t *, wchar_t *, 86 keymacro_value_t *); 87static int node__try(EditLine *, keymacro_node_t *, 88 const wchar_t *, keymacro_value_t *, int); 89static keymacro_node_t *node__get(wint_t); 90static void node__free(keymacro_node_t *); 91static void node__put(EditLine *, keymacro_node_t *); 92static int node__delete(EditLine *, keymacro_node_t **, 93 const wchar_t *); 94static int node_lookup(EditLine *, const wchar_t *, 95 keymacro_node_t *, size_t); 96static int node_enum(EditLine *, keymacro_node_t *, size_t); 97 98#define KEY_BUFSIZ EL_BUFSIZ 99 100 101/* keymacro_init(): 102 * Initialize the key maps 103 */ 104libedit_private int 105keymacro_init(EditLine *el) 106{ 107 108 el->el_keymacro.buf = el_calloc(KEY_BUFSIZ, 109 sizeof(*el->el_keymacro.buf)); 110 if (el->el_keymacro.buf == NULL) 111 return -1; 112 el->el_keymacro.map = NULL; 113 keymacro_reset(el); 114 return 0; 115} 116 117/* keymacro_end(): 118 * Free the key maps 119 */ 120libedit_private void 121keymacro_end(EditLine *el) 122{ 123 124 el_free(el->el_keymacro.buf); 125 el->el_keymacro.buf = NULL; 126 node__free(el->el_keymacro.map); 127} 128 129 130/* keymacro_map_cmd(): 131 * Associate cmd with a key value 132 */ 133libedit_private keymacro_value_t * 134keymacro_map_cmd(EditLine *el, int cmd) 135{ 136 137 el->el_keymacro.val.cmd = (el_action_t) cmd; 138 return &el->el_keymacro.val; 139} 140 141 142/* keymacro_map_str(): 143 * Associate str with a key value 144 */ 145libedit_private keymacro_value_t * 146keymacro_map_str(EditLine *el, wchar_t *str) 147{ 148 149 el->el_keymacro.val.str = str; 150 return &el->el_keymacro.val; 151} 152 153 154/* keymacro_reset(): 155 * Takes all nodes on el->el_keymacro.map and puts them on free list. 156 * Then initializes el->el_keymacro.map with arrow keys 157 * [Always bind the ansi arrow keys?] 158 */ 159libedit_private void 160keymacro_reset(EditLine *el) 161{ 162 163 node__put(el, el->el_keymacro.map); 164 el->el_keymacro.map = NULL; 165 return; 166} 167 168 169/* keymacro_get(): 170 * Calls the recursive function with entry point el->el_keymacro.map 171 * Looks up *ch in map and then reads characters until a 172 * complete match is found or a mismatch occurs. Returns the 173 * type of the match found (XK_STR or XK_CMD). 174 * Returns NULL in val.str and XK_STR for no match. 175 * Returns XK_NOD for end of file or read error. 176 * The last character read is returned in *ch. 177 */ 178libedit_private int 179keymacro_get(EditLine *el, wchar_t *ch, keymacro_value_t *val) 180{ 181 182 return node_trav(el, el->el_keymacro.map, ch, val); 183} 184 185 186/* keymacro_add(): 187 * Adds key to the el->el_keymacro.map and associates the value in 188 * val with it. If key is already is in el->el_keymacro.map, the new 189 * code is applied to the existing key. Ntype specifies if code is a 190 * command, an out str or a unix command. 191 */ 192libedit_private void 193keymacro_add(EditLine *el, const wchar_t *key, keymacro_value_t *val, 194 int ntype) 195{ 196 197 if (key[0] == '\0') { 198 (void) fprintf(el->el_errfile, 199 "keymacro_add: Null extended-key not allowed.\n"); 200 return; 201 } 202 if (ntype == XK_CMD && val->cmd == ED_SEQUENCE_LEAD_IN) { 203 (void) fprintf(el->el_errfile, 204 "keymacro_add: sequence-lead-in command not allowed\n"); 205 return; 206 } 207 if (el->el_keymacro.map == NULL) 208 /* tree is initially empty. Set up new node to match key[0] */ 209 el->el_keymacro.map = node__get(key[0]); 210 /* it is properly initialized */ 211 212 /* Now recurse through el->el_keymacro.map */ 213 (void) node__try(el, el->el_keymacro.map, key, val, ntype); 214 return; 215} 216 217 218/* keymacro_clear(): 219 * 220 */ 221libedit_private void 222keymacro_clear(EditLine *el, el_action_t *map, const wchar_t *in) 223{ 224 if (*in > N_KEYS) /* can't be in the map */ 225 return; 226 if ((map[(unsigned char)*in] == ED_SEQUENCE_LEAD_IN) && 227 ((map == el->el_map.key && 228 el->el_map.alt[(unsigned char)*in] != ED_SEQUENCE_LEAD_IN) || 229 (map == el->el_map.alt && 230 el->el_map.key[(unsigned char)*in] != ED_SEQUENCE_LEAD_IN))) 231 (void) keymacro_delete(el, in); 232} 233 234 235/* keymacro_delete(): 236 * Delete the key and all longer keys staring with key, if 237 * they exists. 238 */ 239libedit_private int 240keymacro_delete(EditLine *el, const wchar_t *key) 241{ 242 243 if (key[0] == '\0') { 244 (void) fprintf(el->el_errfile, 245 "keymacro_delete: Null extended-key not allowed.\n"); 246 return -1; 247 } 248 if (el->el_keymacro.map == NULL) 249 return 0; 250 251 (void) node__delete(el, &el->el_keymacro.map, key); 252 return 0; 253} 254 255 256/* keymacro_print(): 257 * Print the binding associated with key key. 258 * Print entire el->el_keymacro.map if null 259 */ 260libedit_private void 261keymacro_print(EditLine *el, const wchar_t *key) 262{ 263 264 /* do nothing if el->el_keymacro.map is empty and null key specified */ 265 if (el->el_keymacro.map == NULL && *key == 0) 266 return; 267 268 el->el_keymacro.buf[0] = '"'; 269 if (node_lookup(el, key, el->el_keymacro.map, (size_t)1) <= -1) 270 /* key is not bound */ 271 (void) fprintf(el->el_errfile, "Unbound extended key \"%ls" 272 "\"\n", key); 273 return; 274} 275 276 277/* node_trav(): 278 * recursively traverses node in tree until match or mismatch is 279 * found. May read in more characters. 280 */ 281static int 282node_trav(EditLine *el, keymacro_node_t *ptr, wchar_t *ch, 283 keymacro_value_t *val) 284{ 285 286 if (ptr->ch == *ch) { 287 /* match found */ 288 if (ptr->next) { 289 /* key not complete so get next char */ 290 if (el_wgetc(el, ch) != 1) 291 return XK_NOD; 292 return node_trav(el, ptr->next, ch, val); 293 } else { 294 *val = ptr->val; 295 if (ptr->type != XK_CMD) 296 *ch = '\0'; 297 return ptr->type; 298 } 299 } else { 300 /* no match found here */ 301 if (ptr->sibling) { 302 /* try next sibling */ 303 return node_trav(el, ptr->sibling, ch, val); 304 } else { 305 /* no next sibling -- mismatch */ 306 val->str = NULL; 307 return XK_STR; 308 } 309 } 310} 311 312 313/* node__try(): 314 * Find a node that matches *str or allocate a new one 315 */ 316static int 317node__try(EditLine *el, keymacro_node_t *ptr, const wchar_t *str, 318 keymacro_value_t *val, int ntype) 319{ 320 321 if (ptr->ch != *str) { 322 keymacro_node_t *xm; 323 324 for (xm = ptr; xm->sibling != NULL; xm = xm->sibling) 325 if (xm->sibling->ch == *str) 326 break; 327 if (xm->sibling == NULL) 328 xm->sibling = node__get(*str); /* setup new node */ 329 ptr = xm->sibling; 330 } 331 if (*++str == '\0') { 332 /* we're there */ 333 if (ptr->next != NULL) { 334 node__put(el, ptr->next); 335 /* lose longer keys with this prefix */ 336 ptr->next = NULL; 337 } 338 switch (ptr->type) { 339 case XK_CMD: 340 case XK_NOD: 341 break; 342 case XK_STR: 343 if (ptr->val.str) 344 el_free(ptr->val.str); 345 break; 346 default: 347 EL_ABORT((el->el_errfile, "Bad XK_ type %d\n", 348 ptr->type)); 349 break; 350 } 351 352 switch (ptr->type = ntype) { 353 case XK_CMD: 354 ptr->val = *val; 355 break; 356 case XK_STR: 357 if ((ptr->val.str = wcsdup(val->str)) == NULL) 358 return -1; 359 break; 360 default: 361 EL_ABORT((el->el_errfile, "Bad XK_ type %d\n", ntype)); 362 break; 363 } 364 } else { 365 /* still more chars to go */ 366 if (ptr->next == NULL) 367 ptr->next = node__get(*str); /* setup new node */ 368 (void) node__try(el, ptr->next, str, val, ntype); 369 } 370 return 0; 371} 372 373 374/* node__delete(): 375 * Delete node that matches str 376 */ 377static int 378node__delete(EditLine *el, keymacro_node_t **inptr, const wchar_t *str) 379{ 380 keymacro_node_t *ptr; 381 keymacro_node_t *prev_ptr = NULL; 382 383 ptr = *inptr; 384 385 if (ptr->ch != *str) { 386 keymacro_node_t *xm; 387 388 for (xm = ptr; xm->sibling != NULL; xm = xm->sibling) 389 if (xm->sibling->ch == *str) 390 break; 391 if (xm->sibling == NULL) 392 return 0; 393 prev_ptr = xm; 394 ptr = xm->sibling; 395 } 396 if (*++str == '\0') { 397 /* we're there */ 398 if (prev_ptr == NULL) 399 *inptr = ptr->sibling; 400 else 401 prev_ptr->sibling = ptr->sibling; 402 ptr->sibling = NULL; 403 node__put(el, ptr); 404 return 1; 405 } else if (ptr->next != NULL && 406 node__delete(el, &ptr->next, str) == 1) { 407 if (ptr->next != NULL) 408 return 0; 409 if (prev_ptr == NULL) 410 *inptr = ptr->sibling; 411 else 412 prev_ptr->sibling = ptr->sibling; 413 ptr->sibling = NULL; 414 node__put(el, ptr); 415 return 1; 416 } else { 417 return 0; 418 } 419} 420 421 422/* node__put(): 423 * Puts a tree of nodes onto free list using free(3). 424 */ 425static void 426node__put(EditLine *el, keymacro_node_t *ptr) 427{ 428 if (ptr == NULL) 429 return; 430 431 if (ptr->next != NULL) { 432 node__put(el, ptr->next); 433 ptr->next = NULL; 434 } 435 node__put(el, ptr->sibling); 436 437 switch (ptr->type) { 438 case XK_CMD: 439 case XK_NOD: 440 break; 441 case XK_STR: 442 if (ptr->val.str != NULL) 443 el_free(ptr->val.str); 444 break; 445 default: 446 EL_ABORT((el->el_errfile, "Bad XK_ type %d\n", ptr->type)); 447 break; 448 } 449 el_free(ptr); 450} 451 452 453/* node__get(): 454 * Returns pointer to a keymacro_node_t for ch. 455 */ 456static keymacro_node_t * 457node__get(wint_t ch) 458{ 459 keymacro_node_t *ptr; 460 461 ptr = el_malloc(sizeof(*ptr)); 462 if (ptr == NULL) 463 return NULL; 464 ptr->ch = ch; 465 ptr->type = XK_NOD; 466 ptr->val.str = NULL; 467 ptr->next = NULL; 468 ptr->sibling = NULL; 469 return ptr; 470} 471 472static void 473node__free(keymacro_node_t *k) 474{ 475 if (k == NULL) 476 return; 477 node__free(k->sibling); 478 node__free(k->next); 479 el_free(k); 480} 481 482/* node_lookup(): 483 * look for the str starting at node ptr. 484 * Print if last node 485 */ 486static int 487node_lookup(EditLine *el, const wchar_t *str, keymacro_node_t *ptr, 488 size_t cnt) 489{ 490 ssize_t used; 491 492 if (ptr == NULL) 493 return -1; /* cannot have null ptr */ 494 495 if (!str || *str == 0) { 496 /* no more chars in str. node_enum from here. */ 497 (void) node_enum(el, ptr, cnt); 498 return 0; 499 } else { 500 /* If match put this char into el->el_keymacro.buf. Recurse */ 501 if (ptr->ch == *str) { 502 /* match found */ 503 used = ct_visual_char(el->el_keymacro.buf + cnt, 504 KEY_BUFSIZ - cnt, ptr->ch); 505 if (used == -1) 506 return -1; /* ran out of buffer space */ 507 if (ptr->next != NULL) 508 /* not yet at leaf */ 509 return (node_lookup(el, str + 1, ptr->next, 510 (size_t)used + cnt)); 511 else { 512 /* next node is null so key should be complete */ 513 if (str[1] == 0) { 514 size_t px = cnt + (size_t)used; 515 el->el_keymacro.buf[px] = '"'; 516 el->el_keymacro.buf[px + 1] = '\0'; 517 keymacro_kprint(el, el->el_keymacro.buf, 518 &ptr->val, ptr->type); 519 return 0; 520 } else 521 return -1; 522 /* mismatch -- str still has chars */ 523 } 524 } else { 525 /* no match found try sibling */ 526 if (ptr->sibling) 527 return (node_lookup(el, str, ptr->sibling, 528 cnt)); 529 else 530 return -1; 531 } 532 } 533} 534 535 536/* node_enum(): 537 * Traverse the node printing the characters it is bound in buffer 538 */ 539static int 540node_enum(EditLine *el, keymacro_node_t *ptr, size_t cnt) 541{ 542 ssize_t used; 543 544 if (cnt >= KEY_BUFSIZ - 5) { /* buffer too small */ 545 el->el_keymacro.buf[++cnt] = '"'; 546 el->el_keymacro.buf[++cnt] = '\0'; 547 (void) fprintf(el->el_errfile, 548 "Some extended keys too long for internal print buffer"); 549 (void) fprintf(el->el_errfile, " \"%ls...\"\n", 550 el->el_keymacro.buf); 551 return 0; 552 } 553 if (ptr == NULL) { 554#ifdef DEBUG_EDIT 555 (void) fprintf(el->el_errfile, 556 "node_enum: BUG!! Null ptr passed\n!"); 557#endif 558 return -1; 559 } 560 /* put this char at end of str */ 561 used = ct_visual_char(el->el_keymacro.buf + cnt, KEY_BUFSIZ - cnt, 562 ptr->ch); 563 if (ptr->next == NULL) { 564 /* print this key and function */ 565 el->el_keymacro.buf[cnt + (size_t)used ] = '"'; 566 el->el_keymacro.buf[cnt + (size_t)used + 1] = '\0'; 567 keymacro_kprint(el, el->el_keymacro.buf, &ptr->val, ptr->type); 568 } else 569 (void) node_enum(el, ptr->next, cnt + (size_t)used); 570 571 /* go to sibling if there is one */ 572 if (ptr->sibling) 573 (void) node_enum(el, ptr->sibling, cnt); 574 return 0; 575} 576 577 578/* keymacro_kprint(): 579 * Print the specified key and its associated 580 * function specified by val 581 */ 582libedit_private void 583keymacro_kprint(EditLine *el, const wchar_t *key, keymacro_value_t *val, 584 int ntype) 585{ 586 el_bindings_t *fp; 587 char unparsbuf[EL_BUFSIZ]; 588 static const char fmt[] = "%-15s-> %s\n"; 589 590 if (val != NULL) 591 switch (ntype) { 592 case XK_STR: 593 (void) keymacro__decode_str(val->str, unparsbuf, 594 sizeof(unparsbuf), 595 ntype == XK_STR ? "\"\"" : "[]"); 596 (void) fprintf(el->el_outfile, fmt, 597 ct_encode_string(key, &el->el_scratch), unparsbuf); 598 break; 599 case XK_CMD: 600 for (fp = el->el_map.help; fp->name; fp++) 601 if (val->cmd == fp->func) { 602 wcstombs(unparsbuf, fp->name, sizeof(unparsbuf)); 603 unparsbuf[sizeof(unparsbuf) -1] = '\0'; 604 (void) fprintf(el->el_outfile, fmt, 605 ct_encode_string(key, &el->el_scratch), unparsbuf); 606 break; 607 } 608#ifdef DEBUG_KEY 609 if (fp->name == NULL) 610 (void) fprintf(el->el_outfile, 611 "BUG! Command not found.\n"); 612#endif 613 614 break; 615 default: 616 EL_ABORT((el->el_errfile, "Bad XK_ type %d\n", ntype)); 617 break; 618 } 619 else 620 (void) fprintf(el->el_outfile, fmt, ct_encode_string(key, 621 &el->el_scratch), "no input"); 622} 623 624 625#define ADDC(c) \ 626 if (b < eb) \ 627 *b++ = c; \ 628 else \ 629 b++ 630/* keymacro__decode_str(): 631 * Make a printable version of the ey 632 */ 633libedit_private size_t 634keymacro__decode_str(const wchar_t *str, char *buf, size_t len, 635 const char *sep) 636{ 637 char *b = buf, *eb = b + len; 638 const wchar_t *p; 639 640 b = buf; 641 if (sep[0] != '\0') { 642 ADDC(sep[0]); 643 } 644 if (*str == '\0') { 645 ADDC('^'); 646 ADDC('@'); 647 goto add_endsep; 648 } 649 for (p = str; *p != 0; p++) { 650 wchar_t dbuf[VISUAL_WIDTH_MAX]; 651 wchar_t *p2 = dbuf; 652 ssize_t l = ct_visual_char(dbuf, VISUAL_WIDTH_MAX, *p); 653 while (l-- > 0) { 654 ssize_t n = ct_encode_char(b, (size_t)(eb - b), *p2++); 655 if (n == -1) /* ran out of space */ 656 goto add_endsep; 657 else 658 b += n; 659 } 660 } 661add_endsep: 662 if (sep[0] != '\0' && sep[1] != '\0') { 663 ADDC(sep[1]); 664 } 665 ADDC('\0'); 666 if ((size_t)(b - buf) >= len) 667 buf[len - 1] = '\0'; 668 return (size_t)(b - buf); 669} 670