1 /* $OpenBSD: edit.c,v 1.41 2015/09/01 13:12:31 tedu Exp $ */ 2 /* $OpenBSD: edit.h,v 1.9 2011/05/30 17:14:35 martynas Exp $ */ 3 /* $OpenBSD: emacs.c,v 1.52 2015/09/10 22:48:58 nicm Exp $ */ 4 /* $OpenBSD: vi.c,v 1.30 2015/09/10 22:48:58 nicm Exp $ */ 5 6 /*- 7 * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 8 * 2011, 2012, 2013, 2014, 2015 9 * mirabilos <m (at) mirbsd.org> 10 * 11 * Provided that these terms and disclaimer and all copyright notices 12 * are retained or reproduced in an accompanying document, permission 13 * is granted to deal in this work without restriction, including un- 14 * limited rights to use, publicly perform, distribute, sell, modify, 15 * merge, give away, or sublicence. 16 * 17 * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to 18 * the utmost extent permitted by applicable law, neither express nor 19 * implied; without malicious intent or gross negligence. In no event 20 * may a licensor, author or contributor be held liable for indirect, 21 * direct, other damage, loss, or other issues arising in any way out 22 * of dealing in the work, even if advised of the possibility of such 23 * damage or existence of a defect, except proven that it results out 24 * of said person's immediate fault when using the work as intended. 25 */ 26 27 #include "sh.h" 28 29 #ifndef MKSH_NO_CMDLINE_EDITING 30 31 __RCSID("$MirOS: src/bin/mksh/edit.c,v 1.292 2015/10/09 16:11:13 tg Exp $"); 32 33 /* 34 * in later versions we might use libtermcap for this, but since external 35 * dependencies are problematic, this has not yet been decided on; another 36 * good string is "\033c" except on hardware terminals like the DEC VT420 37 * which do a full power cycle then... 38 */ 39 #ifndef MKSH_CLS_STRING 40 #define MKSH_CLS_STRING "\033[;H\033[J" 41 #endif 42 #ifndef MKSH_CLRTOEOL_STRING 43 #define MKSH_CLRTOEOL_STRING "\033[K" 44 #endif 45 46 /* tty driver characters we are interested in */ 47 typedef struct { 48 int erase; 49 int kill; 50 int werase; 51 int intr; 52 int quit; 53 int eof; 54 } X_chars; 55 56 static X_chars edchars; 57 58 /* x_cf_glob() flags */ 59 #define XCF_COMMAND BIT(0) /* Do command completion */ 60 #define XCF_FILE BIT(1) /* Do file completion */ 61 #define XCF_FULLPATH BIT(2) /* command completion: store full path */ 62 #define XCF_COMMAND_FILE (XCF_COMMAND | XCF_FILE) 63 #define XCF_IS_COMMAND BIT(3) /* return flag: is command */ 64 #define XCF_IS_NOSPACE BIT(4) /* return flag: do not append a space */ 65 66 static char editmode; 67 static int xx_cols; /* for Emacs mode */ 68 static int modified; /* buffer has been "modified" */ 69 static char *holdbufp; /* place to hold last edit buffer */ 70 71 static int x_getc(void); 72 static void x_putcf(int); 73 static void x_modified(void); 74 static void x_mode(bool); 75 static int x_do_comment(char *, ssize_t, ssize_t *); 76 static void x_print_expansions(int, char * const *, bool); 77 static int x_cf_glob(int *, const char *, int, int, int *, int *, char ***); 78 static size_t x_longest_prefix(int, char * const *); 79 static void x_glob_hlp_add_qchar(char *); 80 static char *x_glob_hlp_tilde_and_rem_qchar(char *, bool); 81 static int x_basename(const char *, const char *); 82 static void x_free_words(int, char **); 83 static int x_escape(const char *, size_t, int (*)(const char *, size_t)); 84 static int x_emacs(char *); 85 static void x_init_prompt(bool); 86 #if !MKSH_S_NOVI 87 static int x_vi(char *); 88 #endif 89 90 #define x_flush() shf_flush(shl_out) 91 #if defined(MKSH_SMALL) && !defined(MKSH_SMALL_BUT_FAST) 92 #define x_putc(c) x_putcf(c) 93 #else 94 #define x_putc(c) shf_putc((c), shl_out) 95 #endif 96 97 static int path_order_cmp(const void *, const void *); 98 static void glob_table(const char *, XPtrV *, struct table *); 99 static void glob_path(int, const char *, XPtrV *, const char *); 100 static int x_file_glob(int *, char *, char ***); 101 static int x_command_glob(int, char *, char ***); 102 static int x_locate_word(const char *, int, int, int *, bool *); 103 104 static int x_e_getmbc(char *); 105 static int x_e_rebuildline(const char *); 106 107 /* +++ generic editing functions +++ */ 108 109 /* 110 * read an edited command line 111 */ 112 int 113 x_read(char *buf) 114 { 115 int i; 116 117 x_mode(true); 118 modified = 1; 119 if (Flag(FEMACS) || Flag(FGMACS)) 120 i = x_emacs(buf); 121 #if !MKSH_S_NOVI 122 else if (Flag(FVI)) 123 i = x_vi(buf); 124 #endif 125 else 126 /* internal error */ 127 i = -1; 128 editmode = 0; 129 x_mode(false); 130 return (i); 131 } 132 133 /* tty I/O */ 134 135 static int 136 x_getc(void) 137 { 138 char c; 139 ssize_t n; 140 141 while ((n = blocking_read(STDIN_FILENO, &c, 1)) < 0 && errno == EINTR) 142 if (trap) { 143 x_mode(false); 144 runtraps(0); 145 #ifdef SIGWINCH 146 if (got_winch) { 147 change_winsz(); 148 if (x_cols != xx_cols && editmode == 1) { 149 /* redraw line in Emacs mode */ 150 xx_cols = x_cols; 151 x_init_prompt(false); 152 x_e_rebuildline(MKSH_CLRTOEOL_STRING); 153 } 154 } 155 #endif 156 x_mode(true); 157 } 158 return ((n == 1) ? (int)(unsigned char)c : -1); 159 } 160 161 static void 162 x_putcf(int c) 163 { 164 shf_putc(c, shl_out); 165 } 166 167 /********************************* 168 * Misc common code for vi/emacs * 169 *********************************/ 170 171 /*- 172 * Handle the commenting/uncommenting of a line. 173 * Returns: 174 * 1 if a carriage return is indicated (comment added) 175 * 0 if no return (comment removed) 176 * -1 if there is an error (not enough room for comment chars) 177 * If successful, *lenp contains the new length. Note: cursor should be 178 * moved to the start of the line after (un)commenting. 179 */ 180 static int 181 x_do_comment(char *buf, ssize_t bsize, ssize_t *lenp) 182 { 183 ssize_t i, j, len = *lenp; 184 185 if (len == 0) 186 /* somewhat arbitrary - it's what AT&T ksh does */ 187 return (1); 188 189 /* Already commented? */ 190 if (buf[0] == '#') { 191 bool saw_nl = false; 192 193 for (j = 0, i = 1; i < len; i++) { 194 if (!saw_nl || buf[i] != '#') 195 buf[j++] = buf[i]; 196 saw_nl = buf[i] == '\n'; 197 } 198 *lenp = j; 199 return (0); 200 } else { 201 int n = 1; 202 203 /* See if there's room for the #s - 1 per \n */ 204 for (i = 0; i < len; i++) 205 if (buf[i] == '\n') 206 n++; 207 if (len + n >= bsize) 208 return (-1); 209 /* Now add them... */ 210 for (i = len, j = len + n; --i >= 0; ) { 211 if (buf[i] == '\n') 212 buf[--j] = '#'; 213 buf[--j] = buf[i]; 214 } 215 buf[0] = '#'; 216 *lenp += n; 217 return (1); 218 } 219 } 220 221 /**************************************************** 222 * Common file/command completion code for vi/emacs * 223 ****************************************************/ 224 225 static void 226 x_print_expansions(int nwords, char * const *words, bool is_command) 227 { 228 bool use_copy = false; 229 int prefix_len; 230 XPtrV l = { NULL, 0, 0 }; 231 232 /* 233 * Check if all matches are in the same directory (in this 234 * case, we want to omit the directory name) 235 */ 236 if (!is_command && 237 (prefix_len = x_longest_prefix(nwords, words)) > 0) { 238 int i; 239 240 /* Special case for 1 match (prefix is whole word) */ 241 if (nwords == 1) 242 prefix_len = x_basename(words[0], NULL); 243 /* Any (non-trailing) slashes in non-common word suffixes? */ 244 for (i = 0; i < nwords; i++) 245 if (x_basename(words[i] + prefix_len, NULL) > 246 prefix_len) 247 break; 248 /* All in same directory? */ 249 if (i == nwords) { 250 while (prefix_len > 0 && words[0][prefix_len - 1] != '/') 251 prefix_len--; 252 use_copy = true; 253 XPinit(l, nwords + 1); 254 for (i = 0; i < nwords; i++) 255 XPput(l, words[i] + prefix_len); 256 XPput(l, NULL); 257 } 258 } 259 /* 260 * Enumerate expansions 261 */ 262 x_putc('\r'); 263 x_putc('\n'); 264 pr_list(use_copy ? (char **)XPptrv(l) : words); 265 266 if (use_copy) 267 /* not x_free_words() */ 268 XPfree(l); 269 } 270 271 /* 272 * Convert backslash-escaped string to QCHAR-escaped 273 * string useful for globbing; loses QCHAR unless it 274 * can squeeze in, eg. by previous loss of backslash 275 */ 276 static void 277 x_glob_hlp_add_qchar(char *cp) 278 { 279 char ch, *dp = cp; 280 bool escaping = false; 281 282 while ((ch = *cp++)) { 283 if (ch == '\\' && !escaping) { 284 escaping = true; 285 continue; 286 } 287 if (escaping || (ch == QCHAR && (cp - dp) > 1)) { 288 /* 289 * empirically made list of chars to escape 290 * for globbing as well as QCHAR itself 291 */ 292 switch (ch) { 293 case QCHAR: 294 case '$': 295 case '*': 296 case '?': 297 case '[': 298 case '\\': 299 case '`': 300 *dp++ = QCHAR; 301 break; 302 } 303 escaping = false; 304 } 305 *dp++ = ch; 306 } 307 *dp = '\0'; 308 } 309 310 /* 311 * Run tilde expansion on argument string, return the result 312 * after unescaping; if the flag is set, the original string 313 * is freed if changed and assumed backslash-escaped, if not 314 * it is assumed QCHAR-escaped 315 */ 316 static char * 317 x_glob_hlp_tilde_and_rem_qchar(char *s, bool magic_flag) 318 { 319 char ch, *cp, *dp; 320 321 /* 322 * On the string, check whether we have a tilde expansion, 323 * and if so, discern "~foo/bar" and "~/baz" from "~blah"; 324 * if we have a directory part (the former), try to expand 325 */ 326 if (*s == '~' && (cp = strchr(s, '/')) != NULL) { 327 /* ok, so split into "~foo"/"bar" or "~"/"baz" */ 328 *cp++ = 0; 329 /* try to expand the tilde */ 330 if (!(dp = do_tilde(s + 1))) { 331 /* nope, revert damage */ 332 *--cp = '/'; 333 } else { 334 /* ok, expand and replace */ 335 cp = shf_smprintf("%s/%s", dp, cp); 336 if (magic_flag) 337 afree(s, ATEMP); 338 s = cp; 339 } 340 } 341 342 /* ... convert it from backslash-escaped via QCHAR-escaped... */ 343 if (magic_flag) 344 x_glob_hlp_add_qchar(s); 345 /* ... to unescaped, for comparison with the matches */ 346 cp = dp = s; 347 348 while ((ch = *cp++)) { 349 if (ch == QCHAR && !(ch = *cp++)) 350 break; 351 *dp++ = ch; 352 } 353 *dp = '\0'; 354 355 return (s); 356 } 357 358 /** 359 * Do file globbing: 360 * - does expansion, checks for no match, etc. 361 * - sets *wordsp to array of matching strings 362 * - returns number of matching strings 363 */ 364 static int 365 x_file_glob(int *flagsp, char *toglob, char ***wordsp) 366 { 367 char **words, *cp; 368 int nwords; 369 XPtrV w; 370 struct source *s, *sold; 371 372 /* remove all escaping backward slashes */ 373 x_glob_hlp_add_qchar(toglob); 374 375 /* 376 * Convert "foo*" (toglob) to an array of strings (words) 377 */ 378 sold = source; 379 s = pushs(SWSTR, ATEMP); 380 s->start = s->str = toglob; 381 source = s; 382 if (yylex(ONEWORD | LQCHAR) != LWORD) { 383 source = sold; 384 internal_warningf("%s: %s", "fileglob", "bad substitution"); 385 return (0); 386 } 387 source = sold; 388 afree(s, ATEMP); 389 XPinit(w, 32); 390 cp = yylval.cp; 391 while (*cp == CHAR || *cp == QCHAR) 392 cp += 2; 393 nwords = DOGLOB | DOTILDE | DOMARKDIRS; 394 if (*cp != EOS) { 395 /* probably a $FOO expansion */ 396 *flagsp |= XCF_IS_NOSPACE; 397 /* this always results in at most one match */ 398 nwords = 0; 399 } 400 expand(yylval.cp, &w, nwords); 401 XPput(w, NULL); 402 words = (char **)XPclose(w); 403 404 for (nwords = 0; words[nwords]; nwords++) 405 ; 406 if (nwords == 1) { 407 struct stat statb; 408 409 /* Expand any tilde and drop all QCHAR for comparison */ 410 toglob = x_glob_hlp_tilde_and_rem_qchar(toglob, false); 411 412 /* 413 * Check if globbing failed (returned glob pattern), 414 * but be careful (e.g. toglob == "ab*" when the file 415 * "ab*" exists is not an error). 416 * Also, check for empty result - happens if we tried 417 * to glob something which evaluated to an empty 418 * string (e.g., "$FOO" when there is no FOO, etc). 419 */ 420 if ((strcmp(words[0], toglob) == 0 && 421 stat(words[0], &statb) < 0) || 422 words[0][0] == '\0') { 423 x_free_words(nwords, words); 424 words = NULL; 425 nwords = 0; 426 } 427 } 428 429 if ((*wordsp = nwords ? words : NULL) == NULL && words != NULL) 430 x_free_words(nwords, words); 431 432 return (nwords); 433 } 434 435 /* Data structure used in x_command_glob() */ 436 struct path_order_info { 437 char *word; 438 int base; 439 int path_order; 440 }; 441 442 /* Compare routine used in x_command_glob() */ 443 static int 444 path_order_cmp(const void *aa, const void *bb) 445 { 446 const struct path_order_info *a = (const struct path_order_info *)aa; 447 const struct path_order_info *b = (const struct path_order_info *)bb; 448 int t; 449 450 t = strcmp(a->word + a->base, b->word + b->base); 451 return (t ? t : a->path_order - b->path_order); 452 } 453 454 static int 455 x_command_glob(int flags, char *toglob, char ***wordsp) 456 { 457 char *pat, *fpath; 458 size_t nwords; 459 XPtrV w; 460 struct block *l; 461 462 /* Convert "foo*" (toglob) to a pattern for future use */ 463 pat = evalstr(toglob, DOPAT | DOTILDE); 464 465 XPinit(w, 32); 466 467 glob_table(pat, &w, &keywords); 468 glob_table(pat, &w, &aliases); 469 glob_table(pat, &w, &builtins); 470 for (l = e->loc; l; l = l->next) 471 glob_table(pat, &w, &l->funs); 472 473 glob_path(flags, pat, &w, path); 474 if ((fpath = str_val(global("FPATH"))) != null) 475 glob_path(flags, pat, &w, fpath); 476 477 nwords = XPsize(w); 478 479 if (!nwords) { 480 *wordsp = NULL; 481 XPfree(w); 482 return (0); 483 } 484 /* Sort entries */ 485 if (flags & XCF_FULLPATH) { 486 /* Sort by basename, then path order */ 487 struct path_order_info *info, *last_info = NULL; 488 char **words = (char **)XPptrv(w); 489 size_t i, path_order = 0; 490 491 info = (struct path_order_info *) 492 alloc2(nwords, sizeof(struct path_order_info), ATEMP); 493 for (i = 0; i < nwords; i++) { 494 info[i].word = words[i]; 495 info[i].base = x_basename(words[i], NULL); 496 if (!last_info || info[i].base != last_info->base || 497 strncmp(words[i], last_info->word, info[i].base) != 0) { 498 last_info = &info[i]; 499 path_order++; 500 } 501 info[i].path_order = path_order; 502 } 503 qsort(info, nwords, sizeof(struct path_order_info), 504 path_order_cmp); 505 for (i = 0; i < nwords; i++) 506 words[i] = info[i].word; 507 afree(info, ATEMP); 508 } else { 509 /* Sort and remove duplicate entries */ 510 char **words = (char **)XPptrv(w); 511 size_t i, j; 512 513 qsort(words, nwords, sizeof(void *), xstrcmp); 514 for (i = j = 0; i < nwords - 1; i++) { 515 if (strcmp(words[i], words[i + 1])) 516 words[j++] = words[i]; 517 else 518 afree(words[i], ATEMP); 519 } 520 words[j++] = words[i]; 521 w.len = nwords = j; 522 } 523 524 XPput(w, NULL); 525 *wordsp = (char **)XPclose(w); 526 527 return (nwords); 528 } 529 530 #define IS_WORDC(c) (!ctype(c, C_LEX1) && (c) != '\'' && (c) != '"' && \ 531 (c) != '`' && (c) != '=' && (c) != ':') 532 533 static int 534 x_locate_word(const char *buf, int buflen, int pos, int *startp, 535 bool *is_commandp) 536 { 537 int start, end; 538 539 /* Bad call? Probably should report error */ 540 if (pos < 0 || pos > buflen) { 541 *startp = pos; 542 *is_commandp = false; 543 return (0); 544 } 545 /* The case where pos == buflen happens to take care of itself... */ 546 547 start = pos; 548 /* 549 * Keep going backwards to start of word (has effect of allowing 550 * one blank after the end of a word) 551 */ 552 for (; (start > 0 && IS_WORDC(buf[start - 1])) || 553 (start > 1 && buf[start - 2] == '\\'); start--) 554 ; 555 /* Go forwards to end of word */ 556 for (end = start; end < buflen && IS_WORDC(buf[end]); end++) { 557 if (buf[end] == '\\' && (end + 1) < buflen) 558 end++; 559 } 560 561 if (is_commandp) { 562 bool iscmd; 563 int p = start - 1; 564 565 /* Figure out if this is a command */ 566 while (p >= 0 && ksh_isspace(buf[p])) 567 p--; 568 iscmd = p < 0 || vstrchr(";|&()`", buf[p]); 569 if (iscmd) { 570 /* 571 * If command has a /, path, etc. is not searched; 572 * only current directory is searched which is just 573 * like file globbing. 574 */ 575 for (p = start; p < end; p++) 576 if (buf[p] == '/') 577 break; 578 iscmd = p == end; 579 } 580 *is_commandp = iscmd; 581 } 582 *startp = start; 583 584 return (end - start); 585 } 586 587 static int 588 x_cf_glob(int *flagsp, const char *buf, int buflen, int pos, int *startp, 589 int *endp, char ***wordsp) 590 { 591 int len, nwords = 0; 592 char **words = NULL; 593 bool is_command; 594 595 len = x_locate_word(buf, buflen, pos, startp, &is_command); 596 if (!((*flagsp) & XCF_COMMAND)) 597 is_command = false; 598 /* 599 * Don't do command globing on zero length strings - it takes too 600 * long and isn't very useful. File globs are more likely to be 601 * useful, so allow these. 602 */ 603 if (len == 0 && is_command) 604 return (0); 605 606 if (len >= 0) { 607 char *toglob, *s; 608 609 /* 610 * Given a string, copy it and possibly add a '*' to the end. 611 */ 612 613 strndupx(toglob, buf + *startp, len + /* the '*' */ 1, ATEMP); 614 toglob[len] = '\0'; 615 616 /* 617 * If the pathname contains a wildcard (an unquoted '*', 618 * '?', or '[') or an extglob, then it is globbed based 619 * on that value (i.e., without the appended '*'). Same 620 * for parameter substitutions (as in cat $HOME/.ss) 621 * without appending a trailing space (LP: #710539), as 622 * well as for ~foo (but not ~foo/). 623 */ 624 for (s = toglob; *s; s++) { 625 if (*s == '\\' && s[1]) 626 s++; 627 else if (*s == '?' || *s == '*' || *s == '[' || 628 *s == '$' || 629 /* ?() *() +() @() !() but two already checked */ 630 (s[1] == '(' /*)*/ && 631 (*s == '+' || *s == '@' || *s == '!'))) { 632 /* 633 * just expand based on the extglob 634 * or parameter 635 */ 636 goto dont_add_glob; 637 } 638 } 639 640 if (*toglob == '~' && !vstrchr(toglob, '/')) { 641 /* neither for '~foo' (but '~foo/bar') */ 642 *flagsp |= XCF_IS_NOSPACE; 643 goto dont_add_glob; 644 } 645 646 /* append a glob */ 647 toglob[len] = '*'; 648 toglob[len + 1] = '\0'; 649 dont_add_glob: 650 /* 651 * Expand (glob) it now. 652 */ 653 654 nwords = is_command ? 655 x_command_glob(*flagsp, toglob, &words) : 656 x_file_glob(flagsp, toglob, &words); 657 afree(toglob, ATEMP); 658 } 659 if (nwords == 0) { 660 *wordsp = NULL; 661 return (0); 662 } 663 if (is_command) 664 *flagsp |= XCF_IS_COMMAND; 665 *wordsp = words; 666 *endp = *startp + len; 667 668 return (nwords); 669 } 670 671 /* 672 * Find longest common prefix 673 */ 674 static size_t 675 x_longest_prefix(int nwords, char * const * words) 676 { 677 int i; 678 size_t j, prefix_len; 679 char *p; 680 681 if (nwords <= 0) 682 return (0); 683 684 prefix_len = strlen(words[0]); 685 for (i = 1; i < nwords; i++) 686 for (j = 0, p = words[i]; j < prefix_len; j++) 687 if (p[j] != words[0][j]) { 688 prefix_len = j; 689 break; 690 } 691 /* false for nwords==1 as 0 = words[0][prefix_len] then */ 692 if (UTFMODE && prefix_len && (words[0][prefix_len] & 0xC0) == 0x80) 693 while (prefix_len && (words[0][prefix_len] & 0xC0) != 0xC0) 694 --prefix_len; 695 return (prefix_len); 696 } 697 698 static void 699 x_free_words(int nwords, char **words) 700 { 701 while (nwords) 702 afree(words[--nwords], ATEMP); 703 afree(words, ATEMP); 704 } 705 706 /*- 707 * Return the offset of the basename of string s (which ends at se - need not 708 * be null terminated). Trailing slashes are ignored. If s is just a slash, 709 * then the offset is 0 (actually, length - 1). 710 * s Return 711 * /etc 1 712 * /etc/ 1 713 * /etc// 1 714 * /etc/fo 5 715 * foo 0 716 * /// 2 717 * 0 718 */ 719 static int 720 x_basename(const char *s, const char *se) 721 { 722 const char *p; 723 724 if (se == NULL) 725 se = s + strlen(s); 726 if (s == se) 727 return (0); 728 729 /* Skip trailing slashes */ 730 for (p = se - 1; p > s && *p == '/'; p--) 731 ; 732 for (; p > s && *p != '/'; p--) 733 ; 734 if (*p == '/' && p + 1 < se) 735 p++; 736 737 return (p - s); 738 } 739 740 /* 741 * Apply pattern matching to a table: all table entries that match a pattern 742 * are added to wp. 743 */ 744 static void 745 glob_table(const char *pat, XPtrV *wp, struct table *tp) 746 { 747 struct tstate ts; 748 struct tbl *te; 749 750 ktwalk(&ts, tp); 751 while ((te = ktnext(&ts))) 752 if (gmatchx(te->name, pat, false)) { 753 char *cp; 754 755 strdupx(cp, te->name, ATEMP); 756 XPput(*wp, cp); 757 } 758 } 759 760 static void 761 glob_path(int flags, const char *pat, XPtrV *wp, const char *lpath) 762 { 763 const char *sp = lpath, *p; 764 char *xp, **words; 765 size_t pathlen, patlen, oldsize, newsize, i, j; 766 XString xs; 767 768 patlen = strlen(pat); 769 checkoktoadd(patlen, 129 + X_EXTRA); 770 ++patlen; 771 Xinit(xs, xp, patlen + 128, ATEMP); 772 while (sp) { 773 xp = Xstring(xs, xp); 774 if (!(p = cstrchr(sp, MKSH_PATHSEPC))) 775 p = sp + strlen(sp); 776 pathlen = p - sp; 777 if (pathlen) { 778 /* 779 * Copy sp into xp, stuffing any MAGIC characters 780 * on the way 781 */ 782 const char *s = sp; 783 784 XcheckN(xs, xp, pathlen * 2); 785 while (s < p) { 786 if (ISMAGIC(*s)) 787 *xp++ = MAGIC; 788 *xp++ = *s++; 789 } 790 *xp++ = '/'; 791 pathlen++; 792 } 793 sp = p; 794 XcheckN(xs, xp, patlen); 795 memcpy(xp, pat, patlen); 796 797 oldsize = XPsize(*wp); 798 /* mark dirs */ 799 glob_str(Xstring(xs, xp), wp, true); 800 newsize = XPsize(*wp); 801 802 /* Check that each match is executable... */ 803 words = (char **)XPptrv(*wp); 804 for (i = j = oldsize; i < newsize; i++) { 805 if (ksh_access(words[i], X_OK) == 0) { 806 words[j] = words[i]; 807 if (!(flags & XCF_FULLPATH)) 808 memmove(words[j], words[j] + pathlen, 809 strlen(words[j] + pathlen) + 1); 810 j++; 811 } else 812 afree(words[i], ATEMP); 813 } 814 wp->len = j; 815 816 if (!*sp++) 817 break; 818 } 819 Xfree(xs, xp); 820 } 821 822 /* 823 * if argument string contains any special characters, they will 824 * be escaped and the result will be put into edit buffer by 825 * keybinding-specific function 826 */ 827 static int 828 x_escape(const char *s, size_t len, int (*putbuf_func)(const char *, size_t)) 829 { 830 size_t add = 0, wlen = len; 831 const char *ifs = str_val(local("IFS", 0)); 832 int rval = 0; 833 834 while (wlen - add > 0) 835 if (vstrchr("\"#$&'()*:;<=>?[\\`{|}", s[add]) || 836 vstrchr(ifs, s[add])) { 837 if (putbuf_func(s, add) != 0) { 838 rval = -1; 839 break; 840 } 841 putbuf_func(s[add] == '\n' ? "'" : "\\", 1); 842 putbuf_func(&s[add], 1); 843 if (s[add] == '\n') 844 putbuf_func("'", 1); 845 846 add++; 847 wlen -= add; 848 s += add; 849 add = 0; 850 } else 851 ++add; 852 if (wlen > 0 && rval == 0) 853 rval = putbuf_func(s, wlen); 854 855 return (rval); 856 } 857 858 859 /* +++ emacs editing mode +++ */ 860 861 static Area aedit; 862 #define AEDIT &aedit /* area for kill ring and macro defns */ 863 864 /* values returned by keyboard functions */ 865 #define KSTD 0 866 #define KEOL 1 /* ^M, ^J */ 867 #define KINTR 2 /* ^G, ^C */ 868 869 struct x_ftab { 870 int (*xf_func)(int c); 871 const char *xf_name; 872 short xf_flags; 873 }; 874 875 struct x_defbindings { 876 unsigned char xdb_func; /* XFUNC_* */ 877 unsigned char xdb_tab; 878 unsigned char xdb_char; 879 }; 880 881 #define XF_ARG 1 /* command takes number prefix */ 882 #define XF_NOBIND 2 /* not allowed to bind to function */ 883 #define XF_PREFIX 4 /* function sets prefix */ 884 885 /* Separator for completion */ 886 #define is_cfs(c) ((c) == ' ' || (c) == '\t' || (c) == '"' || (c) == '\'') 887 /* Separator for motion */ 888 #define is_mfs(c) (!(ksh_isalnux(c) || (c) == '$' || ((c) & 0x80))) 889 890 #define X_NTABS 4 /* normal, meta1, meta2, pc */ 891 #define X_TABSZ 256 /* size of keydef tables etc */ 892 893 /*- 894 * Arguments for do_complete() 895 * 0 = enumerate M-= complete as much as possible and then list 896 * 1 = complete M-Esc 897 * 2 = list M-? 898 */ 899 typedef enum { 900 CT_LIST, /* list the possible completions */ 901 CT_COMPLETE, /* complete to longest prefix */ 902 CT_COMPLIST /* complete and then list (if non-exact) */ 903 } Comp_type; 904 905 /* 906 * The following are used for my horizontal scrolling stuff 907 */ 908 static char *xbuf; /* beg input buffer */ 909 static char *xend; /* end input buffer */ 910 static char *xcp; /* current position */ 911 static char *xep; /* current end */ 912 static char *xbp; /* start of visible portion of input buffer */ 913 static char *xlp; /* last char visible on screen */ 914 static bool x_adj_ok; 915 /* 916 * we use x_adj_done so that functions can tell 917 * whether x_adjust() has been called while they are active. 918 */ 919 static int x_adj_done; /* is incremented by x_adjust() */ 920 921 static int x_displen; 922 static int x_arg; /* general purpose arg */ 923 static bool x_arg_defaulted; /* x_arg not explicitly set; defaulted to 1 */ 924 925 static bool xlp_valid; /* lastvis pointer was recalculated */ 926 927 static char **x_histp; /* history position */ 928 static int x_nextcmd; /* for newline-and-next */ 929 static char **x_histncp; /* saved x_histp for " */ 930 static char *xmp; /* mark pointer */ 931 static unsigned char x_last_command; 932 static unsigned char (*x_tab)[X_TABSZ]; /* key definition */ 933 #ifndef MKSH_SMALL 934 static char *(*x_atab)[X_TABSZ]; /* macro definitions */ 935 #endif 936 static unsigned char x_bound[(X_TABSZ * X_NTABS + 7) / 8]; 937 #define KILLSIZE 20 938 static char *killstack[KILLSIZE]; 939 static int killsp, killtp; 940 static int x_curprefix; 941 #ifndef MKSH_SMALL 942 static char *macroptr; /* bind key macro active? */ 943 #endif 944 #if !MKSH_S_NOVI 945 static int winwidth; /* width of window */ 946 static char *wbuf[2]; /* window buffers */ 947 static int wbuf_len; /* length of window buffers (x_cols - 3) */ 948 static int win; /* window buffer in use */ 949 static char morec; /* more character at right of window */ 950 static int lastref; /* argument to last refresh() */ 951 static int holdlen; /* length of holdbuf */ 952 #endif 953 static int pwidth; /* width of prompt */ 954 static int prompt_trunc; /* how much of prompt to truncate or -1 */ 955 static int x_col; /* current column on line */ 956 957 static int x_ins(const char *); 958 static void x_delete(size_t, bool); 959 static size_t x_bword(void); 960 static size_t x_fword(bool); 961 static void x_goto(char *); 962 static char *x_bs0(char *, char *) MKSH_A_PURE; 963 static void x_bs3(char **); 964 static int x_size_str(char *); 965 static int x_size2(char *, char **); 966 static void x_zots(char *); 967 static void x_zotc3(char **); 968 static void x_load_hist(char **); 969 static int x_search(char *, int, int); 970 #ifndef MKSH_SMALL 971 static int x_search_dir(int); 972 #endif 973 static int x_match(char *, char *); 974 static void x_redraw(int); 975 static void x_push(int); 976 static char *x_mapin(const char *, Area *); 977 static char *x_mapout(int); 978 static void x_mapout2(int, char **); 979 static void x_print(int, int); 980 static void x_adjust(void); 981 static void x_e_ungetc(int); 982 static int x_e_getc(void); 983 static void x_e_putc2(int); 984 static void x_e_putc3(const char **); 985 static void x_e_puts(const char *); 986 #ifndef MKSH_SMALL 987 static int x_fold_case(int); 988 #endif 989 static char *x_lastcp(void); 990 static void do_complete(int, Comp_type); 991 static size_t x_nb2nc(size_t) MKSH_A_PURE; 992 993 static int unget_char = -1; 994 995 static int x_do_ins(const char *, size_t); 996 static void bind_if_not_bound(int, int, int); 997 998 enum emacs_funcs { 999 #define EMACSFN_ENUMS 1000 #include "emacsfn.h" 1001 XFUNC_MAX 1002 }; 1003 1004 #define EMACSFN_DEFNS 1005 #include "emacsfn.h" 1006 1007 static const struct x_ftab x_ftab[] = { 1008 #define EMACSFN_ITEMS 1009 #include "emacsfn.h" 1010 }; 1011 1012 static struct x_defbindings const x_defbindings[] = { 1013 { XFUNC_del_back, 0, CTRL('?') }, 1014 { XFUNC_del_bword, 1, CTRL('?') }, 1015 { XFUNC_eot_del, 0, CTRL('D') }, 1016 { XFUNC_del_back, 0, CTRL('H') }, 1017 { XFUNC_del_bword, 1, CTRL('H') }, 1018 { XFUNC_del_bword, 1, 'h' }, 1019 { XFUNC_mv_bword, 1, 'b' }, 1020 { XFUNC_mv_fword, 1, 'f' }, 1021 { XFUNC_del_fword, 1, 'd' }, 1022 { XFUNC_mv_back, 0, CTRL('B') }, 1023 { XFUNC_mv_forw, 0, CTRL('F') }, 1024 { XFUNC_search_char_forw, 0, CTRL(']') }, 1025 { XFUNC_search_char_back, 1, CTRL(']') }, 1026 { XFUNC_newline, 0, CTRL('M') }, 1027 { XFUNC_newline, 0, CTRL('J') }, 1028 { XFUNC_end_of_text, 0, CTRL('_') }, 1029 { XFUNC_abort, 0, CTRL('G') }, 1030 { XFUNC_prev_com, 0, CTRL('P') }, 1031 { XFUNC_next_com, 0, CTRL('N') }, 1032 { XFUNC_nl_next_com, 0, CTRL('O') }, 1033 { XFUNC_search_hist, 0, CTRL('R') }, 1034 { XFUNC_beg_hist, 1, '<' }, 1035 { XFUNC_end_hist, 1, '>' }, 1036 { XFUNC_goto_hist, 1, 'g' }, 1037 { XFUNC_mv_end, 0, CTRL('E') }, 1038 { XFUNC_mv_begin, 0, CTRL('A') }, 1039 { XFUNC_draw_line, 0, CTRL('L') }, 1040 { XFUNC_cls, 1, CTRL('L') }, 1041 { XFUNC_meta1, 0, CTRL('[') }, 1042 { XFUNC_meta2, 0, CTRL('X') }, 1043 { XFUNC_kill, 0, CTRL('K') }, 1044 { XFUNC_yank, 0, CTRL('Y') }, 1045 { XFUNC_meta_yank, 1, 'y' }, 1046 { XFUNC_literal, 0, CTRL('^') }, 1047 { XFUNC_comment, 1, '#' }, 1048 { XFUNC_transpose, 0, CTRL('T') }, 1049 { XFUNC_complete, 1, CTRL('[') }, 1050 { XFUNC_comp_list, 0, CTRL('I') }, 1051 { XFUNC_comp_list, 1, '=' }, 1052 { XFUNC_enumerate, 1, '?' }, 1053 { XFUNC_expand, 1, '*' }, 1054 { XFUNC_comp_file, 1, CTRL('X') }, 1055 { XFUNC_comp_comm, 2, CTRL('[') }, 1056 { XFUNC_list_comm, 2, '?' }, 1057 { XFUNC_list_file, 2, CTRL('Y') }, 1058 { XFUNC_set_mark, 1, ' ' }, 1059 { XFUNC_kill_region, 0, CTRL('W') }, 1060 { XFUNC_xchg_point_mark, 2, CTRL('X') }, 1061 { XFUNC_literal, 0, CTRL('V') }, 1062 { XFUNC_version, 1, CTRL('V') }, 1063 { XFUNC_prev_histword, 1, '.' }, 1064 { XFUNC_prev_histword, 1, '_' }, 1065 { XFUNC_set_arg, 1, '0' }, 1066 { XFUNC_set_arg, 1, '1' }, 1067 { XFUNC_set_arg, 1, '2' }, 1068 { XFUNC_set_arg, 1, '3' }, 1069 { XFUNC_set_arg, 1, '4' }, 1070 { XFUNC_set_arg, 1, '5' }, 1071 { XFUNC_set_arg, 1, '6' }, 1072 { XFUNC_set_arg, 1, '7' }, 1073 { XFUNC_set_arg, 1, '8' }, 1074 { XFUNC_set_arg, 1, '9' }, 1075 #ifndef MKSH_SMALL 1076 { XFUNC_fold_upper, 1, 'U' }, 1077 { XFUNC_fold_upper, 1, 'u' }, 1078 { XFUNC_fold_lower, 1, 'L' }, 1079 { XFUNC_fold_lower, 1, 'l' }, 1080 { XFUNC_fold_capitalise, 1, 'C' }, 1081 { XFUNC_fold_capitalise, 1, 'c' }, 1082 #endif 1083 /* 1084 * These for ANSI arrow keys: arguablely shouldn't be here by 1085 * default, but its simpler/faster/smaller than using termcap 1086 * entries. 1087 */ 1088 { XFUNC_meta2, 1, '[' }, 1089 { XFUNC_meta2, 1, 'O' }, 1090 { XFUNC_prev_com, 2, 'A' }, 1091 { XFUNC_next_com, 2, 'B' }, 1092 { XFUNC_mv_forw, 2, 'C' }, 1093 { XFUNC_mv_back, 2, 'D' }, 1094 #ifndef MKSH_SMALL 1095 { XFUNC_vt_hack, 2, '1' }, 1096 { XFUNC_mv_begin | 0x80, 2, '7' }, 1097 { XFUNC_mv_begin, 2, 'H' }, 1098 { XFUNC_mv_end | 0x80, 2, '4' }, 1099 { XFUNC_mv_end | 0x80, 2, '8' }, 1100 { XFUNC_mv_end, 2, 'F' }, 1101 { XFUNC_del_char | 0x80, 2, '3' }, 1102 { XFUNC_del_char, 2, 'P' }, 1103 { XFUNC_search_hist_up | 0x80, 2, '5' }, 1104 { XFUNC_search_hist_dn | 0x80, 2, '6' }, 1105 #endif 1106 /* PC scancodes */ 1107 #if !defined(MKSH_SMALL) || defined(__OS2__) 1108 { XFUNC_meta3, 0, 0 }, 1109 { XFUNC_mv_begin, 3, 71 }, 1110 { XFUNC_prev_com, 3, 72 }, 1111 #ifndef MKSH_SMALL 1112 { XFUNC_search_hist_up, 3, 73 }, 1113 #endif 1114 { XFUNC_mv_back, 3, 75 }, 1115 { XFUNC_mv_forw, 3, 77 }, 1116 { XFUNC_mv_end, 3, 79 }, 1117 { XFUNC_next_com, 3, 80 }, 1118 #ifndef MKSH_SMALL 1119 { XFUNC_search_hist_dn, 3, 81 }, 1120 #endif 1121 { XFUNC_del_char, 3, 83 }, 1122 #endif 1123 #ifndef MKSH_SMALL 1124 /* more non-standard ones */ 1125 { XFUNC_edit_line, 2, 'e' } 1126 #endif 1127 }; 1128 1129 static size_t 1130 x_nb2nc(size_t nb) 1131 { 1132 char *cp; 1133 size_t nc = 0; 1134 1135 for (cp = xcp; cp < (xcp + nb); ++nc) 1136 cp += utf_ptradj(cp); 1137 return (nc); 1138 } 1139 1140 static void 1141 x_modified(void) 1142 { 1143 if (!modified) { 1144 x_histp = histptr + 1; 1145 modified = 1; 1146 } 1147 } 1148 1149 #ifdef MKSH_SMALL 1150 #define XFUNC_VALUE(f) (f) 1151 #else 1152 #define XFUNC_VALUE(f) (f & 0x7F) 1153 #endif 1154 1155 static int 1156 x_e_getmbc(char *sbuf) 1157 { 1158 int c, pos = 0; 1159 unsigned char *buf = (unsigned char *)sbuf; 1160 1161 memset(buf, 0, 4); 1162 buf[pos++] = c = x_e_getc(); 1163 if (c == -1) 1164 return (-1); 1165 if (UTFMODE) { 1166 if ((buf[0] >= 0xC2) && (buf[0] < 0xF0)) { 1167 c = x_e_getc(); 1168 if (c == -1) 1169 return (-1); 1170 if ((c & 0xC0) != 0x80) { 1171 x_e_ungetc(c); 1172 return (1); 1173 } 1174 buf[pos++] = c; 1175 } 1176 if ((buf[0] >= 0xE0) && (buf[0] < 0xF0)) { 1177 /* XXX x_e_ungetc is one-octet only */ 1178 buf[pos++] = c = x_e_getc(); 1179 if (c == -1) 1180 return (-1); 1181 } 1182 } 1183 return (pos); 1184 } 1185 1186 static void 1187 x_init_prompt(bool doprint) 1188 { 1189 prompt_trunc = pprompt(prompt, doprint ? 0 : -1); 1190 pwidth = prompt_trunc % x_cols; 1191 prompt_trunc -= pwidth; 1192 if ((mksh_uari_t)pwidth > ((mksh_uari_t)x_cols - 3 - MIN_EDIT_SPACE)) { 1193 /* force newline after prompt */ 1194 prompt_trunc = -1; 1195 pwidth = 0; 1196 if (doprint) 1197 x_e_putc2('\n'); 1198 } 1199 } 1200 1201 static int 1202 x_emacs(char *buf) 1203 { 1204 int c, i; 1205 unsigned char f; 1206 1207 xbp = xbuf = buf; 1208 xend = buf + LINE; 1209 xlp = xcp = xep = buf; 1210 *xcp = 0; 1211 xlp_valid = true; 1212 xmp = NULL; 1213 x_curprefix = 0; 1214 x_histp = histptr + 1; 1215 x_last_command = XFUNC_error; 1216 1217 x_init_prompt(true); 1218 x_displen = (xx_cols = x_cols) - 2 - (x_col = pwidth); 1219 x_adj_done = 0; 1220 x_adj_ok = true; 1221 1222 x_histncp = NULL; 1223 if (x_nextcmd >= 0) { 1224 int off = source->line - x_nextcmd; 1225 if (histptr - history >= off) { 1226 x_load_hist(histptr - off); 1227 x_histncp = x_histp; 1228 } 1229 x_nextcmd = -1; 1230 } 1231 editmode = 1; 1232 while (/* CONSTCOND */ 1) { 1233 x_flush(); 1234 if ((c = x_e_getc()) < 0) 1235 return (0); 1236 1237 f = x_curprefix == -1 ? XFUNC_insert : 1238 x_tab[x_curprefix][c]; 1239 #ifndef MKSH_SMALL 1240 if (f & 0x80) { 1241 f &= 0x7F; 1242 if ((i = x_e_getc()) != '~') 1243 x_e_ungetc(i); 1244 } 1245 1246 /* avoid bind key macro recursion */ 1247 if (macroptr && f == XFUNC_ins_string) 1248 f = XFUNC_insert; 1249 #endif 1250 1251 if (!(x_ftab[f].xf_flags & XF_PREFIX) && 1252 x_last_command != XFUNC_set_arg) { 1253 x_arg = 1; 1254 x_arg_defaulted = true; 1255 } 1256 i = c | (x_curprefix << 8); 1257 x_curprefix = 0; 1258 switch ((*x_ftab[f].xf_func)(i)) { 1259 case KSTD: 1260 if (!(x_ftab[f].xf_flags & XF_PREFIX)) 1261 x_last_command = f; 1262 break; 1263 case KEOL: 1264 i = xep - xbuf; 1265 return (i); 1266 case KINTR: 1267 /* special case for interrupt */ 1268 trapsig(SIGINT); 1269 x_mode(false); 1270 unwind(LSHELL); 1271 } 1272 /* ad-hoc hack for fixing the cursor position */ 1273 x_goto(xcp); 1274 } 1275 } 1276 1277 static int 1278 x_insert(int c) 1279 { 1280 static int left, pos, save_arg; 1281 static char str[4]; 1282 1283 /* 1284 * Should allow tab and control chars. 1285 */ 1286 if (c == 0) { 1287 invmbs: 1288 left = 0; 1289 x_e_putc2(7); 1290 return (KSTD); 1291 } 1292 if (UTFMODE) { 1293 if (((c & 0xC0) == 0x80) && left) { 1294 str[pos++] = c; 1295 if (!--left) { 1296 str[pos] = '\0'; 1297 x_arg = save_arg; 1298 while (x_arg--) 1299 x_ins(str); 1300 } 1301 return (KSTD); 1302 } 1303 if (left) { 1304 if (x_curprefix == -1) { 1305 /* flush invalid multibyte */ 1306 str[pos] = '\0'; 1307 while (save_arg--) 1308 x_ins(str); 1309 } 1310 } 1311 if ((c >= 0xC2) && (c < 0xE0)) 1312 left = 1; 1313 else if ((c >= 0xE0) && (c < 0xF0)) 1314 left = 2; 1315 else if (c > 0x7F) 1316 goto invmbs; 1317 else 1318 left = 0; 1319 if (left) { 1320 save_arg = x_arg; 1321 pos = 1; 1322 str[0] = c; 1323 return (KSTD); 1324 } 1325 } 1326 left = 0; 1327 str[0] = c; 1328 str[1] = '\0'; 1329 while (x_arg--) 1330 x_ins(str); 1331 return (KSTD); 1332 } 1333 1334 #ifndef MKSH_SMALL 1335 static int 1336 x_ins_string(int c) 1337 { 1338 macroptr = x_atab[c >> 8][c & 255]; 1339 /* 1340 * we no longer need to bother checking if macroptr is 1341 * not NULL but first char is NUL; x_e_getc() does it 1342 */ 1343 return (KSTD); 1344 } 1345 #endif 1346 1347 static int 1348 x_do_ins(const char *cp, size_t len) 1349 { 1350 if (xep + len >= xend) { 1351 x_e_putc2(7); 1352 return (-1); 1353 } 1354 memmove(xcp + len, xcp, xep - xcp + 1); 1355 memmove(xcp, cp, len); 1356 xcp += len; 1357 xep += len; 1358 x_modified(); 1359 return (0); 1360 } 1361 1362 static int 1363 x_ins(const char *s) 1364 { 1365 char *cp = xcp; 1366 int adj = x_adj_done; 1367 1368 if (x_do_ins(s, strlen(s)) < 0) 1369 return (-1); 1370 /* 1371 * x_zots() may result in a call to x_adjust() 1372 * we want xcp to reflect the new position. 1373 */ 1374 xlp_valid = false; 1375 x_lastcp(); 1376 x_adj_ok = tobool(xcp >= xlp); 1377 x_zots(cp); 1378 /* has x_adjust() been called? */ 1379 if (adj == x_adj_done) { 1380 /* no */ 1381 cp = xlp; 1382 while (cp > xcp) 1383 x_bs3(&cp); 1384 } 1385 if (xlp == xep - 1) 1386 x_redraw(xx_cols); 1387 x_adj_ok = true; 1388 return (0); 1389 } 1390 1391 static int 1392 x_del_back(int c MKSH_A_UNUSED) 1393 { 1394 ssize_t i = 0; 1395 1396 if (xcp == xbuf) { 1397 x_e_putc2(7); 1398 return (KSTD); 1399 } 1400 do { 1401 x_goto(xcp - 1); 1402 } while ((++i < x_arg) && (xcp != xbuf)); 1403 x_delete(i, false); 1404 return (KSTD); 1405 } 1406 1407 static int 1408 x_del_char(int c MKSH_A_UNUSED) 1409 { 1410 char *cp, *cp2; 1411 size_t i = 0; 1412 1413 cp = xcp; 1414 while (i < (size_t)x_arg) { 1415 utf_ptradjx(cp, cp2); 1416 if (cp2 > xep) 1417 break; 1418 cp = cp2; 1419 i++; 1420 } 1421 1422 if (!i) { 1423 x_e_putc2(7); 1424 return (KSTD); 1425 } 1426 x_delete(i, false); 1427 return (KSTD); 1428 } 1429 1430 /* Delete nc chars to the right of the cursor (including cursor position) */ 1431 static void 1432 x_delete(size_t nc, bool push) 1433 { 1434 size_t i, nb, nw; 1435 char *cp; 1436 1437 if (nc == 0) 1438 return; 1439 1440 nw = 0; 1441 cp = xcp; 1442 for (i = 0; i < nc; ++i) { 1443 char *cp2; 1444 int j; 1445 1446 j = x_size2(cp, &cp2); 1447 if (cp2 > xep) 1448 break; 1449 cp = cp2; 1450 nw += j; 1451 } 1452 nb = cp - xcp; 1453 /* nc = i; */ 1454 1455 if (xmp != NULL && xmp > xcp) { 1456 if (xcp + nb > xmp) 1457 xmp = xcp; 1458 else 1459 xmp -= nb; 1460 } 1461 /* 1462 * This lets us yank a word we have deleted. 1463 */ 1464 if (push) 1465 x_push(nb); 1466 1467 xep -= nb; 1468 /* Copies the NUL */ 1469 memmove(xcp, xcp + nb, xep - xcp + 1); 1470 /* don't redraw */ 1471 x_adj_ok = false; 1472 xlp_valid = false; 1473 x_zots(xcp); 1474 /* 1475 * if we are already filling the line, 1476 * there is no need to ' ', '\b'. 1477 * But if we must, make sure we do the minimum. 1478 */ 1479 if ((i = xx_cols - 2 - x_col) > 0 || xep - xlp == 0) { 1480 nw = i = (nw < i) ? nw : i; 1481 while (i--) 1482 x_e_putc2(' '); 1483 if (x_col == xx_cols - 2) { 1484 x_e_putc2((xep > xlp) ? '>' : (xbp > xbuf) ? '<' : ' '); 1485 ++nw; 1486 } 1487 while (nw--) 1488 x_e_putc2('\b'); 1489 } 1490 /*x_goto(xcp);*/ 1491 x_adj_ok = true; 1492 xlp_valid = false; 1493 cp = x_lastcp(); 1494 while (cp > xcp) 1495 x_bs3(&cp); 1496 1497 x_modified(); 1498 return; 1499 } 1500 1501 static int 1502 x_del_bword(int c MKSH_A_UNUSED) 1503 { 1504 x_delete(x_bword(), true); 1505 return (KSTD); 1506 } 1507 1508 static int 1509 x_mv_bword(int c MKSH_A_UNUSED) 1510 { 1511 x_bword(); 1512 return (KSTD); 1513 } 1514 1515 static int 1516 x_mv_fword(int c MKSH_A_UNUSED) 1517 { 1518 x_fword(true); 1519 return (KSTD); 1520 } 1521 1522 static int 1523 x_del_fword(int c MKSH_A_UNUSED) 1524 { 1525 x_delete(x_fword(false), true); 1526 return (KSTD); 1527 } 1528 1529 static size_t 1530 x_bword(void) 1531 { 1532 size_t nb = 0; 1533 char *cp = xcp; 1534 1535 if (cp == xbuf) { 1536 x_e_putc2(7); 1537 return (0); 1538 } 1539 while (x_arg--) { 1540 while (cp != xbuf && is_mfs(cp[-1])) { 1541 cp--; 1542 nb++; 1543 } 1544 while (cp != xbuf && !is_mfs(cp[-1])) { 1545 cp--; 1546 nb++; 1547 } 1548 } 1549 x_goto(cp); 1550 return (x_nb2nc(nb)); 1551 } 1552 1553 static size_t 1554 x_fword(bool move) 1555 { 1556 size_t nc; 1557 char *cp = xcp; 1558 1559 if (cp == xep) { 1560 x_e_putc2(7); 1561 return (0); 1562 } 1563 while (x_arg--) { 1564 while (cp != xep && is_mfs(*cp)) 1565 cp++; 1566 while (cp != xep && !is_mfs(*cp)) 1567 cp++; 1568 } 1569 nc = x_nb2nc(cp - xcp); 1570 if (move) 1571 x_goto(cp); 1572 return (nc); 1573 } 1574 1575 static void 1576 x_goto(char *cp) 1577 { 1578 cp = cp >= xep ? xep : x_bs0(cp, xbuf); 1579 if (cp < xbp || cp >= utf_skipcols(xbp, x_displen)) { 1580 /* we are heading off screen */ 1581 xcp = cp; 1582 x_adjust(); 1583 } else if (cp < xcp) { 1584 /* move back */ 1585 while (cp < xcp) 1586 x_bs3(&xcp); 1587 } else if (cp > xcp) { 1588 /* move forward */ 1589 while (cp > xcp) 1590 x_zotc3(&xcp); 1591 } 1592 } 1593 1594 static char * 1595 x_bs0(char *cp, char *lower_bound) 1596 { 1597 if (UTFMODE) 1598 while ((!lower_bound || (cp > lower_bound)) && 1599 ((*(unsigned char *)cp & 0xC0) == 0x80)) 1600 --cp; 1601 return (cp); 1602 } 1603 1604 static void 1605 x_bs3(char **p) 1606 { 1607 int i; 1608 1609 *p = x_bs0((*p) - 1, NULL); 1610 i = x_size2(*p, NULL); 1611 while (i--) 1612 x_e_putc2('\b'); 1613 } 1614 1615 static int 1616 x_size_str(char *cp) 1617 { 1618 int size = 0; 1619 while (*cp) 1620 size += x_size2(cp, &cp); 1621 return (size); 1622 } 1623 1624 static int 1625 x_size2(char *cp, char **dcp) 1626 { 1627 uint8_t c = *(unsigned char *)cp; 1628 1629 if (UTFMODE && (c > 0x7F)) 1630 return (utf_widthadj(cp, (const char **)dcp)); 1631 if (dcp) 1632 *dcp = cp + 1; 1633 if (c == '\t') 1634 /* Kludge, tabs are always four spaces. */ 1635 return (4); 1636 if (ISCTRL(c) && /* but not C1 */ c < 0x80) 1637 /* control unsigned char */ 1638 return (2); 1639 return (1); 1640 } 1641 1642 static void 1643 x_zots(char *str) 1644 { 1645 int adj = x_adj_done; 1646 1647 x_lastcp(); 1648 while (*str && str < xlp && x_col < xx_cols && adj == x_adj_done) 1649 x_zotc3(&str); 1650 } 1651 1652 static void 1653 x_zotc3(char **cp) 1654 { 1655 unsigned char c = **(unsigned char **)cp; 1656 1657 if (c == '\t') { 1658 /* Kludge, tabs are always four spaces. */ 1659 x_e_puts(" "); 1660 (*cp)++; 1661 } else if (ISCTRL(c) && /* but not C1 */ c < 0x80) { 1662 x_e_putc2('^'); 1663 x_e_putc2(UNCTRL(c)); 1664 (*cp)++; 1665 } else 1666 x_e_putc3((const char **)cp); 1667 } 1668 1669 static int 1670 x_mv_back(int c MKSH_A_UNUSED) 1671 { 1672 if (xcp == xbuf) { 1673 x_e_putc2(7); 1674 return (KSTD); 1675 } 1676 while (x_arg--) { 1677 x_goto(xcp - 1); 1678 if (xcp == xbuf) 1679 break; 1680 } 1681 return (KSTD); 1682 } 1683 1684 static int 1685 x_mv_forw(int c MKSH_A_UNUSED) 1686 { 1687 char *cp = xcp, *cp2; 1688 1689 if (xcp == xep) { 1690 x_e_putc2(7); 1691 return (KSTD); 1692 } 1693 while (x_arg--) { 1694 utf_ptradjx(cp, cp2); 1695 if (cp2 > xep) 1696 break; 1697 cp = cp2; 1698 } 1699 x_goto(cp); 1700 return (KSTD); 1701 } 1702 1703 static int 1704 x_search_char_forw(int c MKSH_A_UNUSED) 1705 { 1706 char *cp = xcp; 1707 char tmp[4]; 1708 1709 *xep = '\0'; 1710 if (x_e_getmbc(tmp) < 0) { 1711 x_e_putc2(7); 1712 return (KSTD); 1713 } 1714 while (x_arg--) { 1715 if ((cp = (cp == xep) ? NULL : strstr(cp + 1, tmp)) == NULL && 1716 (cp = strstr(xbuf, tmp)) == NULL) { 1717 x_e_putc2(7); 1718 return (KSTD); 1719 } 1720 } 1721 x_goto(cp); 1722 return (KSTD); 1723 } 1724 1725 static int 1726 x_search_char_back(int c MKSH_A_UNUSED) 1727 { 1728 char *cp = xcp, *p, tmp[4]; 1729 bool b; 1730 1731 if (x_e_getmbc(tmp) < 0) { 1732 x_e_putc2(7); 1733 return (KSTD); 1734 } 1735 for (; x_arg--; cp = p) 1736 for (p = cp; ; ) { 1737 if (p-- == xbuf) 1738 p = xep; 1739 if (p == cp) { 1740 x_e_putc2(7); 1741 return (KSTD); 1742 } 1743 if ((tmp[1] && ((p+1) > xep)) || 1744 (tmp[2] && ((p+2) > xep))) 1745 continue; 1746 b = true; 1747 if (*p != tmp[0]) 1748 b = false; 1749 if (b && tmp[1] && p[1] != tmp[1]) 1750 b = false; 1751 if (b && tmp[2] && p[2] != tmp[2]) 1752 b = false; 1753 if (b) 1754 break; 1755 } 1756 x_goto(cp); 1757 return (KSTD); 1758 } 1759 1760 static int 1761 x_newline(int c MKSH_A_UNUSED) 1762 { 1763 x_e_putc2('\r'); 1764 x_e_putc2('\n'); 1765 x_flush(); 1766 *xep++ = '\n'; 1767 return (KEOL); 1768 } 1769 1770 static int 1771 x_end_of_text(int c MKSH_A_UNUSED) 1772 { 1773 char tmp = edchars.eof; 1774 char *cp = &tmp; 1775 1776 x_zotc3(&cp); 1777 x_putc('\r'); 1778 x_putc('\n'); 1779 x_flush(); 1780 return (KEOL); 1781 } 1782 1783 static int 1784 x_beg_hist(int c MKSH_A_UNUSED) 1785 { 1786 x_load_hist(history); 1787 return (KSTD); 1788 } 1789 1790 static int 1791 x_end_hist(int c MKSH_A_UNUSED) 1792 { 1793 x_load_hist(histptr); 1794 return (KSTD); 1795 } 1796 1797 static int 1798 x_prev_com(int c MKSH_A_UNUSED) 1799 { 1800 x_load_hist(x_histp - x_arg); 1801 return (KSTD); 1802 } 1803 1804 static int 1805 x_next_com(int c MKSH_A_UNUSED) 1806 { 1807 x_load_hist(x_histp + x_arg); 1808 return (KSTD); 1809 } 1810 1811 /* 1812 * Goto a particular history number obtained from argument. 1813 * If no argument is given history 1 is probably not what you 1814 * want so we'll simply go to the oldest one. 1815 */ 1816 static int 1817 x_goto_hist(int c MKSH_A_UNUSED) 1818 { 1819 if (x_arg_defaulted) 1820 x_load_hist(history); 1821 else 1822 x_load_hist(histptr + x_arg - source->line); 1823 return (KSTD); 1824 } 1825 1826 static void 1827 x_load_hist(char **hp) 1828 { 1829 int oldsize; 1830 char *sp = NULL; 1831 1832 if (hp == histptr + 1) { 1833 sp = holdbufp; 1834 modified = 0; 1835 } else if (hp < history || hp > histptr) { 1836 x_e_putc2(7); 1837 return; 1838 } 1839 if (sp == NULL) 1840 sp = *hp; 1841 x_histp = hp; 1842 oldsize = x_size_str(xbuf); 1843 if (modified) 1844 strlcpy(holdbufp, xbuf, LINE); 1845 strlcpy(xbuf, sp, xend - xbuf); 1846 xbp = xbuf; 1847 xep = xcp = xbuf + strlen(xbuf); 1848 xlp_valid = false; 1849 if (xep <= x_lastcp()) { 1850 x_redraw(oldsize); 1851 } 1852 x_goto(xep); 1853 modified = 0; 1854 } 1855 1856 static int 1857 x_nl_next_com(int c MKSH_A_UNUSED) 1858 { 1859 if (!x_histncp || (x_histp != x_histncp && x_histp != histptr + 1)) 1860 /* fresh start of ^O */ 1861 x_histncp = x_histp; 1862 x_nextcmd = source->line - (histptr - x_histncp) + 1; 1863 return (x_newline('\n')); 1864 } 1865 1866 static int 1867 x_eot_del(int c) 1868 { 1869 if (xep == xbuf && x_arg_defaulted) 1870 return (x_end_of_text(c)); 1871 else 1872 return (x_del_char(c)); 1873 } 1874 1875 /* reverse incremental history search */ 1876 static int 1877 x_search_hist(int c) 1878 { 1879 int offset = -1; /* offset of match in xbuf, else -1 */ 1880 char pat[80 + 1]; /* pattern buffer */ 1881 char *p = pat; 1882 unsigned char f; 1883 1884 *p = '\0'; 1885 while (/* CONSTCOND */ 1) { 1886 if (offset < 0) { 1887 x_e_puts("\nI-search: "); 1888 x_e_puts(pat); 1889 } 1890 x_flush(); 1891 if ((c = x_e_getc()) < 0) 1892 return (KSTD); 1893 f = x_tab[0][c]; 1894 if (c == CTRL('[')) { 1895 if ((f & 0x7F) == XFUNC_meta1) { 1896 if ((c = x_e_getc()) < 0) 1897 return (KSTD); 1898 f = x_tab[1][c] & 0x7F; 1899 if (f == XFUNC_meta1 || f == XFUNC_meta2) 1900 x_meta1(CTRL('[')); 1901 x_e_ungetc(c); 1902 } 1903 break; 1904 } 1905 #ifndef MKSH_SMALL 1906 if (f & 0x80) { 1907 f &= 0x7F; 1908 if ((c = x_e_getc()) != '~') 1909 x_e_ungetc(c); 1910 } 1911 #endif 1912 if (f == XFUNC_search_hist) 1913 offset = x_search(pat, 0, offset); 1914 else if (f == XFUNC_del_back) { 1915 if (p == pat) { 1916 offset = -1; 1917 break; 1918 } 1919 if (p > pat) 1920 *--p = '\0'; 1921 if (p == pat) 1922 offset = -1; 1923 else 1924 offset = x_search(pat, 1, offset); 1925 continue; 1926 } else if (f == XFUNC_insert) { 1927 /* add char to pattern */ 1928 /* overflow check... */ 1929 if ((size_t)(p - pat) >= sizeof(pat) - 1) { 1930 x_e_putc2(7); 1931 continue; 1932 } 1933 *p++ = c, *p = '\0'; 1934 if (offset >= 0) { 1935 /* already have partial match */ 1936 offset = x_match(xbuf, pat); 1937 if (offset >= 0) { 1938 x_goto(xbuf + offset + (p - pat) - 1939 (*pat == '^')); 1940 continue; 1941 } 1942 } 1943 offset = x_search(pat, 0, offset); 1944 } else if (f == XFUNC_abort) { 1945 if (offset >= 0) 1946 x_load_hist(histptr + 1); 1947 break; 1948 } else { 1949 /* other command */ 1950 x_e_ungetc(c); 1951 break; 1952 } 1953 } 1954 if (offset < 0) 1955 x_redraw(-1); 1956 return (KSTD); 1957 } 1958 1959 /* search backward from current line */ 1960 static int 1961 x_search(char *pat, int sameline, int offset) 1962 { 1963 char **hp; 1964 int i; 1965 1966 for (hp = x_histp - (sameline ? 0 : 1); hp >= history; --hp) { 1967 i = x_match(*hp, pat); 1968 if (i >= 0) { 1969 if (offset < 0) 1970 x_e_putc2('\n'); 1971 x_load_hist(hp); 1972 x_goto(xbuf + i + strlen(pat) - (*pat == '^')); 1973 return (i); 1974 } 1975 } 1976 x_e_putc2(7); 1977 x_histp = histptr; 1978 return (-1); 1979 } 1980 1981 #ifndef MKSH_SMALL 1982 /* anchored search up from current line */ 1983 static int 1984 x_search_hist_up(int c MKSH_A_UNUSED) 1985 { 1986 return (x_search_dir(-1)); 1987 } 1988 1989 /* anchored search down from current line */ 1990 static int 1991 x_search_hist_dn(int c MKSH_A_UNUSED) 1992 { 1993 return (x_search_dir(1)); 1994 } 1995 1996 /* anchored search in the indicated direction */ 1997 static int 1998 x_search_dir(int search_dir /* should've been bool */) 1999 { 2000 char **hp = x_histp + search_dir; 2001 size_t curs = xcp - xbuf; 2002 2003 while (histptr >= hp && hp >= history) { 2004 if (strncmp(xbuf, *hp, curs) == 0) { 2005 x_load_hist(hp); 2006 x_goto(xbuf + curs); 2007 break; 2008 } 2009 hp += search_dir; 2010 } 2011 return (KSTD); 2012 } 2013 #endif 2014 2015 /* return position of first match of pattern in string, else -1 */ 2016 static int 2017 x_match(char *str, char *pat) 2018 { 2019 if (*pat == '^') { 2020 return ((strncmp(str, pat + 1, strlen(pat + 1)) == 0) ? 0 : -1); 2021 } else { 2022 char *q = strstr(str, pat); 2023 return ((q == NULL) ? -1 : q - str); 2024 } 2025 } 2026 2027 static int 2028 x_del_line(int c MKSH_A_UNUSED) 2029 { 2030 int i, j; 2031 2032 *xep = 0; 2033 i = xep - xbuf; 2034 j = x_size_str(xbuf); 2035 xcp = xbuf; 2036 x_push(i); 2037 xlp = xbp = xep = xbuf; 2038 xlp_valid = true; 2039 *xcp = 0; 2040 xmp = NULL; 2041 x_redraw(j); 2042 x_modified(); 2043 return (KSTD); 2044 } 2045 2046 static int 2047 x_mv_end(int c MKSH_A_UNUSED) 2048 { 2049 x_goto(xep); 2050 return (KSTD); 2051 } 2052 2053 static int 2054 x_mv_begin(int c MKSH_A_UNUSED) 2055 { 2056 x_goto(xbuf); 2057 return (KSTD); 2058 } 2059 2060 static int 2061 x_draw_line(int c MKSH_A_UNUSED) 2062 { 2063 x_redraw(-1); 2064 return (KSTD); 2065 } 2066 2067 static int 2068 x_e_rebuildline(const char *clrstr) 2069 { 2070 shf_puts(clrstr, shl_out); 2071 x_adjust(); 2072 return (KSTD); 2073 } 2074 2075 static int 2076 x_cls(int c MKSH_A_UNUSED) 2077 { 2078 return (x_e_rebuildline(MKSH_CLS_STRING)); 2079 } 2080 2081 /* 2082 * Redraw (part of) the line. If limit is < 0, the everything is redrawn 2083 * on a NEW line, otherwise limit is the screen column up to which needs 2084 * redrawing. 2085 */ 2086 static void 2087 x_redraw(int limit) 2088 { 2089 int i, j; 2090 char *cp; 2091 2092 x_adj_ok = false; 2093 if (limit == -1) 2094 x_e_putc2('\n'); 2095 else 2096 x_e_putc2('\r'); 2097 x_flush(); 2098 if (xbp == xbuf) { 2099 if (prompt_trunc != -1) 2100 pprompt(prompt, prompt_trunc); 2101 x_col = pwidth; 2102 } 2103 x_displen = xx_cols - 2 - x_col; 2104 xlp_valid = false; 2105 x_zots(xbp); 2106 if (xbp != xbuf || xep > xlp) 2107 limit = xx_cols; 2108 if (limit >= 0) { 2109 if (xep > xlp) 2110 /* we fill the line */ 2111 i = 0; 2112 else { 2113 char *cpl = xbp; 2114 2115 i = limit; 2116 while (cpl < xlp) 2117 i -= x_size2(cpl, &cpl); 2118 } 2119 2120 j = 0; 2121 while ((j < i) || (x_col < (xx_cols - 2))) { 2122 if (!(x_col < (xx_cols - 2))) 2123 break; 2124 x_e_putc2(' '); 2125 j++; 2126 } 2127 i = ' '; 2128 if (xep > xlp) { 2129 /* more off screen */ 2130 if (xbp > xbuf) 2131 i = '*'; 2132 else 2133 i = '>'; 2134 } else if (xbp > xbuf) 2135 i = '<'; 2136 x_e_putc2(i); 2137 j++; 2138 while (j--) 2139 x_e_putc2('\b'); 2140 } 2141 cp = xlp; 2142 while (cp > xcp) 2143 x_bs3(&cp); 2144 x_adj_ok = true; 2145 return; 2146 } 2147 2148 static int 2149 x_transpose(int c MKSH_A_UNUSED) 2150 { 2151 unsigned int tmpa, tmpb; 2152 2153 /*- 2154 * What transpose is meant to do seems to be up for debate. This 2155 * is a general summary of the options; the text is abcd with the 2156 * upper case character or underscore indicating the cursor position: 2157 * Who Before After Before After 2158 * AT&T ksh in emacs mode: abCd abdC abcd_ (bell) 2159 * AT&T ksh in gmacs mode: abCd baCd abcd_ abdc_ 2160 * gnu emacs: abCd acbD abcd_ abdc_ 2161 * Pdksh currently goes with GNU behavior since I believe this is the 2162 * most common version of emacs, unless in gmacs mode, in which case 2163 * it does the AT&T ksh gmacs mode. 2164 * This should really be broken up into 3 functions so users can bind 2165 * to the one they want. 2166 */ 2167 if (xcp == xbuf) { 2168 x_e_putc2(7); 2169 return (KSTD); 2170 } else if (xcp == xep || Flag(FGMACS)) { 2171 if (xcp - xbuf == 1) { 2172 x_e_putc2(7); 2173 return (KSTD); 2174 } 2175 /* 2176 * Gosling/Unipress emacs style: Swap two characters before 2177 * the cursor, do not change cursor position 2178 */ 2179 x_bs3(&xcp); 2180 if (utf_mbtowc(&tmpa, xcp) == (size_t)-1) { 2181 x_e_putc2(7); 2182 return (KSTD); 2183 } 2184 x_bs3(&xcp); 2185 if (utf_mbtowc(&tmpb, xcp) == (size_t)-1) { 2186 x_e_putc2(7); 2187 return (KSTD); 2188 } 2189 utf_wctomb(xcp, tmpa); 2190 x_zotc3(&xcp); 2191 utf_wctomb(xcp, tmpb); 2192 x_zotc3(&xcp); 2193 } else { 2194 /* 2195 * GNU emacs style: Swap the characters before and under the 2196 * cursor, move cursor position along one. 2197 */ 2198 if (utf_mbtowc(&tmpa, xcp) == (size_t)-1) { 2199 x_e_putc2(7); 2200 return (KSTD); 2201 } 2202 x_bs3(&xcp); 2203 if (utf_mbtowc(&tmpb, xcp) == (size_t)-1) { 2204 x_e_putc2(7); 2205 return (KSTD); 2206 } 2207 utf_wctomb(xcp, tmpa); 2208 x_zotc3(&xcp); 2209 utf_wctomb(xcp, tmpb); 2210 x_zotc3(&xcp); 2211 } 2212 x_modified(); 2213 return (KSTD); 2214 } 2215 2216 static int 2217 x_literal(int c MKSH_A_UNUSED) 2218 { 2219 x_curprefix = -1; 2220 return (KSTD); 2221 } 2222 2223 static int 2224 x_meta1(int c MKSH_A_UNUSED) 2225 { 2226 x_curprefix = 1; 2227 return (KSTD); 2228 } 2229 2230 static int 2231 x_meta2(int c MKSH_A_UNUSED) 2232 { 2233 x_curprefix = 2; 2234 return (KSTD); 2235 } 2236 2237 static int 2238 x_meta3(int c MKSH_A_UNUSED) 2239 { 2240 x_curprefix = 3; 2241 return (KSTD); 2242 } 2243 2244 static int 2245 x_kill(int c MKSH_A_UNUSED) 2246 { 2247 size_t col = xcp - xbuf; 2248 size_t lastcol = xep - xbuf; 2249 size_t ndel, narg; 2250 2251 if (x_arg_defaulted || (narg = x_arg) > lastcol) 2252 narg = lastcol; 2253 if (narg < col) { 2254 x_goto(xbuf + narg); 2255 ndel = col - narg; 2256 } else 2257 ndel = narg - col; 2258 x_delete(x_nb2nc(ndel), true); 2259 return (KSTD); 2260 } 2261 2262 static void 2263 x_push(int nchars) 2264 { 2265 afree(killstack[killsp], AEDIT); 2266 strndupx(killstack[killsp], xcp, nchars, AEDIT); 2267 killsp = (killsp + 1) % KILLSIZE; 2268 } 2269 2270 static int 2271 x_yank(int c MKSH_A_UNUSED) 2272 { 2273 if (killsp == 0) 2274 killtp = KILLSIZE; 2275 else 2276 killtp = killsp; 2277 killtp--; 2278 if (killstack[killtp] == 0) { 2279 x_e_puts("\nnothing to yank"); 2280 x_redraw(-1); 2281 return (KSTD); 2282 } 2283 xmp = xcp; 2284 x_ins(killstack[killtp]); 2285 return (KSTD); 2286 } 2287 2288 static int 2289 x_meta_yank(int c MKSH_A_UNUSED) 2290 { 2291 size_t len; 2292 2293 if ((x_last_command != XFUNC_yank && x_last_command != XFUNC_meta_yank) || 2294 killstack[killtp] == 0) { 2295 killtp = killsp; 2296 x_e_puts("\nyank something first"); 2297 x_redraw(-1); 2298 return (KSTD); 2299 } 2300 len = strlen(killstack[killtp]); 2301 x_goto(xcp - len); 2302 x_delete(x_nb2nc(len), false); 2303 do { 2304 if (killtp == 0) 2305 killtp = KILLSIZE - 1; 2306 else 2307 killtp--; 2308 } while (killstack[killtp] == 0); 2309 x_ins(killstack[killtp]); 2310 return (KSTD); 2311 } 2312 2313 static int 2314 x_abort(int c MKSH_A_UNUSED) 2315 { 2316 /* x_zotc(c); */ 2317 xlp = xep = xcp = xbp = xbuf; 2318 xlp_valid = true; 2319 *xcp = 0; 2320 x_modified(); 2321 return (KINTR); 2322 } 2323 2324 static int 2325 x_error(int c MKSH_A_UNUSED) 2326 { 2327 x_e_putc2(7); 2328 return (KSTD); 2329 } 2330 2331 #ifndef MKSH_SMALL 2332 /* special VT100 style key sequence hack */ 2333 static int 2334 x_vt_hack(int c) 2335 { 2336 /* we only support PF2-'1' for now */ 2337 if (c != (2 << 8 | '1')) 2338 return (x_error(c)); 2339 2340 /* what's the next character? */ 2341 switch ((c = x_e_getc())) { 2342 case '~': 2343 x_arg = 1; 2344 x_arg_defaulted = true; 2345 return (x_mv_begin(0)); 2346 case ';': 2347 /* "interesting" sequence detected */ 2348 break; 2349 default: 2350 goto unwind_err; 2351 } 2352 2353 /* XXX x_e_ungetc is one-octet only */ 2354 if ((c = x_e_getc()) != '5' && c != '3') 2355 goto unwind_err; 2356 2357 /*- 2358 * At this point, we have read the following octets so far: 2359 * - ESC+[ or ESC+O or Ctrl-X (Prefix 2) 2360 * - 1 (vt_hack) 2361 * - ; 2362 * - 5 (Ctrl key combiner) or 3 (Alt key combiner) 2363 * We can now accept one more octet designating the key. 2364 */ 2365 2366 switch ((c = x_e_getc())) { 2367 case 'C': 2368 return (x_mv_fword(c)); 2369 case 'D': 2370 return (x_mv_bword(c)); 2371 } 2372 2373 unwind_err: 2374 x_e_ungetc(c); 2375 return (x_error(c)); 2376 } 2377 #endif 2378 2379 static char * 2380 x_mapin(const char *cp, Area *ap) 2381 { 2382 char *news, *op; 2383 2384 strdupx(news, cp, ap); 2385 op = news; 2386 while (*cp) { 2387 /* XXX -- should handle \^ escape? */ 2388 if (*cp == '^') { 2389 cp++; 2390 /*XXX or ^^ escape? this is ugly. */ 2391 if (*cp >= '?') 2392 /* includes '?'; ASCII */ 2393 *op++ = CTRL(*cp); 2394 else { 2395 *op++ = '^'; 2396 cp--; 2397 } 2398 } else 2399 *op++ = *cp; 2400 cp++; 2401 } 2402 *op = '\0'; 2403 2404 return (news); 2405 } 2406 2407 static void 2408 x_mapout2(int c, char **buf) 2409 { 2410 char *p = *buf; 2411 2412 if (ISCTRL(c)) { 2413 *p++ = '^'; 2414 *p++ = UNCTRL(c); 2415 } else 2416 *p++ = c; 2417 *p = 0; 2418 *buf = p; 2419 } 2420 2421 static char * 2422 x_mapout(int c) 2423 { 2424 static char buf[8]; 2425 char *bp = buf; 2426 2427 x_mapout2(c, &bp); 2428 return (buf); 2429 } 2430 2431 static void 2432 x_print(int prefix, int key) 2433 { 2434 int f = x_tab[prefix][key]; 2435 2436 if (prefix) 2437 /* prefix == 1 || prefix == 2 */ 2438 shf_puts(x_mapout(prefix == 1 ? CTRL('[') : 2439 prefix == 2 ? CTRL('X') : 0), shl_stdout); 2440 #ifdef MKSH_SMALL 2441 shprintf("%s = ", x_mapout(key)); 2442 #else 2443 shprintf("%s%s = ", x_mapout(key), (f & 0x80) ? "~" : ""); 2444 if (XFUNC_VALUE(f) != XFUNC_ins_string) 2445 #endif 2446 shprintf("%s\n", x_ftab[XFUNC_VALUE(f)].xf_name); 2447 #ifndef MKSH_SMALL 2448 else 2449 shprintf("'%s'\n", x_atab[prefix][key]); 2450 #endif 2451 } 2452 2453 int 2454 x_bind(const char *a1, const char *a2, 2455 #ifndef MKSH_SMALL 2456 /* bind -m */ 2457 bool macro, 2458 #endif 2459 /* bind -l */ 2460 bool list) 2461 { 2462 unsigned char f; 2463 int prefix, key; 2464 char *m1, *m2; 2465 #ifndef MKSH_SMALL 2466 char *sp = NULL; 2467 bool hastilde; 2468 #endif 2469 2470 if (x_tab == NULL) { 2471 bi_errorf("can't bind, not a tty"); 2472 return (1); 2473 } 2474 /* List function names */ 2475 if (list) { 2476 for (f = 0; f < NELEM(x_ftab); f++) 2477 if (!(x_ftab[f].xf_flags & XF_NOBIND)) 2478 shprintf("%s\n", x_ftab[f].xf_name); 2479 return (0); 2480 } 2481 if (a1 == NULL) { 2482 for (prefix = 0; prefix < X_NTABS; prefix++) 2483 for (key = 0; key < X_TABSZ; key++) { 2484 f = XFUNC_VALUE(x_tab[prefix][key]); 2485 if (f == XFUNC_insert || f == XFUNC_error 2486 #ifndef MKSH_SMALL 2487 || (macro && f != XFUNC_ins_string) 2488 #endif 2489 ) 2490 continue; 2491 x_print(prefix, key); 2492 } 2493 return (0); 2494 } 2495 m2 = m1 = x_mapin(a1, ATEMP); 2496 prefix = 0; 2497 for (;; m1++) { 2498 key = (unsigned char)*m1; 2499 f = XFUNC_VALUE(x_tab[prefix][key]); 2500 if (f == XFUNC_meta1) 2501 prefix = 1; 2502 else if (f == XFUNC_meta2) 2503 prefix = 2; 2504 else if (f == XFUNC_meta3) 2505 prefix = 3; 2506 else 2507 break; 2508 } 2509 if (*++m1 2510 #ifndef MKSH_SMALL 2511 && ((*m1 != '~') || *(m1 + 1)) 2512 #endif 2513 ) { 2514 char msg[256]; 2515 const char *c = a1; 2516 m1 = msg; 2517 while (*c && (size_t)(m1 - msg) < sizeof(msg) - 3) 2518 x_mapout2(*c++, &m1); 2519 bi_errorf("%s: %s", "too long key sequence", msg); 2520 return (1); 2521 } 2522 #ifndef MKSH_SMALL 2523 hastilde = tobool(*m1); 2524 #endif 2525 afree(m2, ATEMP); 2526 2527 if (a2 == NULL) { 2528 x_print(prefix, key); 2529 return (0); 2530 } 2531 if (*a2 == 0) { 2532 f = XFUNC_insert; 2533 #ifndef MKSH_SMALL 2534 } else if (macro) { 2535 f = XFUNC_ins_string; 2536 sp = x_mapin(a2, AEDIT); 2537 #endif 2538 } else { 2539 for (f = 0; f < NELEM(x_ftab); f++) 2540 if (!strcmp(x_ftab[f].xf_name, a2)) 2541 break; 2542 if (f == NELEM(x_ftab) || x_ftab[f].xf_flags & XF_NOBIND) { 2543 bi_errorf("%s: %s %s", a2, "no such", Tfunction); 2544 return (1); 2545 } 2546 } 2547 2548 #ifndef MKSH_SMALL 2549 if (XFUNC_VALUE(x_tab[prefix][key]) == XFUNC_ins_string && 2550 x_atab[prefix][key]) 2551 afree(x_atab[prefix][key], AEDIT); 2552 #endif 2553 x_tab[prefix][key] = f 2554 #ifndef MKSH_SMALL 2555 | (hastilde ? 0x80 : 0) 2556 #endif 2557 ; 2558 #ifndef MKSH_SMALL 2559 x_atab[prefix][key] = sp; 2560 #endif 2561 2562 /* Track what the user has bound so x_mode(true) won't toast things */ 2563 if (f == XFUNC_insert) 2564 x_bound[(prefix * X_TABSZ + key) / 8] &= 2565 ~(1 << ((prefix * X_TABSZ + key) % 8)); 2566 else 2567 x_bound[(prefix * X_TABSZ + key) / 8] |= 2568 (1 << ((prefix * X_TABSZ + key) % 8)); 2569 2570 return (0); 2571 } 2572 2573 static void 2574 bind_if_not_bound(int p, int k, int func) 2575 { 2576 int t; 2577 2578 /* 2579 * Has user already bound this key? 2580 * If so, do not override it. 2581 */ 2582 t = p * X_TABSZ + k; 2583 if (x_bound[t >> 3] & (1 << (t & 7))) 2584 return; 2585 2586 x_tab[p][k] = func; 2587 } 2588 2589 static int 2590 x_set_mark(int c MKSH_A_UNUSED) 2591 { 2592 xmp = xcp; 2593 return (KSTD); 2594 } 2595 2596 static int 2597 x_kill_region(int c MKSH_A_UNUSED) 2598 { 2599 size_t rsize; 2600 char *xr; 2601 2602 if (xmp == NULL) { 2603 x_e_putc2(7); 2604 return (KSTD); 2605 } 2606 if (xmp > xcp) { 2607 rsize = xmp - xcp; 2608 xr = xcp; 2609 } else { 2610 rsize = xcp - xmp; 2611 xr = xmp; 2612 } 2613 x_goto(xr); 2614 x_delete(x_nb2nc(rsize), true); 2615 xmp = xr; 2616 return (KSTD); 2617 } 2618 2619 static int 2620 x_xchg_point_mark(int c MKSH_A_UNUSED) 2621 { 2622 char *tmp; 2623 2624 if (xmp == NULL) { 2625 x_e_putc2(7); 2626 return (KSTD); 2627 } 2628 tmp = xmp; 2629 xmp = xcp; 2630 x_goto(tmp); 2631 return (KSTD); 2632 } 2633 2634 static int 2635 x_noop(int c MKSH_A_UNUSED) 2636 { 2637 return (KSTD); 2638 } 2639 2640 /* 2641 * File/command name completion routines 2642 */ 2643 static int 2644 x_comp_comm(int c MKSH_A_UNUSED) 2645 { 2646 do_complete(XCF_COMMAND, CT_COMPLETE); 2647 return (KSTD); 2648 } 2649 2650 static int 2651 x_list_comm(int c MKSH_A_UNUSED) 2652 { 2653 do_complete(XCF_COMMAND, CT_LIST); 2654 return (KSTD); 2655 } 2656 2657 static int 2658 x_complete(int c MKSH_A_UNUSED) 2659 { 2660 do_complete(XCF_COMMAND_FILE, CT_COMPLETE); 2661 return (KSTD); 2662 } 2663 2664 static int 2665 x_enumerate(int c MKSH_A_UNUSED) 2666 { 2667 do_complete(XCF_COMMAND_FILE, CT_LIST); 2668 return (KSTD); 2669 } 2670 2671 static int 2672 x_comp_file(int c MKSH_A_UNUSED) 2673 { 2674 do_complete(XCF_FILE, CT_COMPLETE); 2675 return (KSTD); 2676 } 2677 2678 static int 2679 x_list_file(int c MKSH_A_UNUSED) 2680 { 2681 do_complete(XCF_FILE, CT_LIST); 2682 return (KSTD); 2683 } 2684 2685 static int 2686 x_comp_list(int c MKSH_A_UNUSED) 2687 { 2688 do_complete(XCF_COMMAND_FILE, CT_COMPLIST); 2689 return (KSTD); 2690 } 2691 2692 static int 2693 x_expand(int c MKSH_A_UNUSED) 2694 { 2695 char **words; 2696 int start, end, nwords, i; 2697 2698 i = XCF_FILE; 2699 nwords = x_cf_glob(&i, xbuf, xep - xbuf, xcp - xbuf, 2700 &start, &end, &words); 2701 2702 if (nwords == 0) { 2703 x_e_putc2(7); 2704 return (KSTD); 2705 } 2706 x_goto(xbuf + start); 2707 x_delete(x_nb2nc(end - start), false); 2708 2709 i = 0; 2710 while (i < nwords) { 2711 if (x_escape(words[i], strlen(words[i]), x_do_ins) < 0 || 2712 (++i < nwords && x_ins(" ") < 0)) { 2713 x_e_putc2(7); 2714 return (KSTD); 2715 } 2716 } 2717 x_adjust(); 2718 2719 return (KSTD); 2720 } 2721 2722 static void 2723 do_complete( 2724 /* XCF_{COMMAND,FILE,COMMAND_FILE} */ 2725 int flags, 2726 /* 0 for list, 1 for complete and 2 for complete-list */ 2727 Comp_type type) 2728 { 2729 char **words; 2730 int start, end, nlen, olen, nwords; 2731 bool completed; 2732 2733 nwords = x_cf_glob(&flags, xbuf, xep - xbuf, xcp - xbuf, 2734 &start, &end, &words); 2735 /* no match */ 2736 if (nwords == 0) { 2737 x_e_putc2(7); 2738 return; 2739 } 2740 if (type == CT_LIST) { 2741 x_print_expansions(nwords, words, 2742 tobool(flags & XCF_IS_COMMAND)); 2743 x_redraw(0); 2744 x_free_words(nwords, words); 2745 return; 2746 } 2747 olen = end - start; 2748 nlen = x_longest_prefix(nwords, words); 2749 if (nwords == 1) { 2750 /* 2751 * always complete single matches; 2752 * any expansion of parameter substitution 2753 * is always at most one result, too 2754 */ 2755 completed = true; 2756 } else { 2757 char *unescaped; 2758 2759 /* make a copy of the original string part */ 2760 strndupx(unescaped, xbuf + start, olen, ATEMP); 2761 2762 /* expand any tilde and unescape the string for comparison */ 2763 unescaped = x_glob_hlp_tilde_and_rem_qchar(unescaped, true); 2764 2765 /* 2766 * match iff entire original string is part of the 2767 * longest prefix, implying the latter is at least 2768 * the same size (after unescaping) 2769 */ 2770 completed = !strncmp(words[0], unescaped, strlen(unescaped)); 2771 2772 afree(unescaped, ATEMP); 2773 } 2774 if (type == CT_COMPLIST && nwords > 1) { 2775 /* 2776 * print expansions, since we didn't get back 2777 * just a single match 2778 */ 2779 x_print_expansions(nwords, words, 2780 tobool(flags & XCF_IS_COMMAND)); 2781 } 2782 if (completed) { 2783 /* expand on the command line */ 2784 xmp = NULL; 2785 xcp = xbuf + start; 2786 xep -= olen; 2787 memmove(xcp, xcp + olen, xep - xcp + 1); 2788 x_escape(words[0], nlen, x_do_ins); 2789 } 2790 x_adjust(); 2791 /* 2792 * append a space if this is a single non-directory match 2793 * and not a parameter or homedir substitution 2794 */ 2795 if (nwords == 1 && words[0][nlen - 1] != '/' && 2796 !(flags & XCF_IS_NOSPACE)) { 2797 x_ins(" "); 2798 } 2799 2800 x_free_words(nwords, words); 2801 } 2802 2803 /*- 2804 * NAME: 2805 * x_adjust - redraw the line adjusting starting point etc. 2806 * 2807 * DESCRIPTION: 2808 * This function is called when we have exceeded the bounds 2809 * of the edit window. It increments x_adj_done so that 2810 * functions like x_ins and x_delete know that we have been 2811 * called and can skip the x_bs() stuff which has already 2812 * been done by x_redraw. 2813 * 2814 * RETURN VALUE: 2815 * None 2816 */ 2817 static void 2818 x_adjust(void) 2819 { 2820 int col_left, n; 2821 2822 /* flag the fact that we were called */ 2823 x_adj_done++; 2824 2825 /* 2826 * calculate the amount of columns we need to "go back" 2827 * from xcp to set xbp to (but never < xbuf) to 2/3 of 2828 * the display width; take care of pwidth though 2829 */ 2830 if ((col_left = xx_cols * 2 / 3) < MIN_EDIT_SPACE) { 2831 /* 2832 * cowardly refuse to do anything 2833 * if the available space is too small; 2834 * fall back to dumb pdksh code 2835 */ 2836 if ((xbp = xcp - (x_displen / 2)) < xbuf) 2837 xbp = xbuf; 2838 /* elide UTF-8 fixup as penalty */ 2839 goto x_adjust_out; 2840 } 2841 2842 /* fix up xbp to just past a character end first */ 2843 xbp = xcp >= xep ? xep : x_bs0(xcp, xbuf); 2844 /* walk backwards */ 2845 while (xbp > xbuf && col_left > 0) { 2846 xbp = x_bs0(xbp - 1, xbuf); 2847 col_left -= (n = x_size2(xbp, NULL)); 2848 } 2849 /* check if we hit the prompt */ 2850 if (xbp == xbuf && xcp != xbuf && col_left >= 0 && col_left < pwidth) { 2851 /* so we did; force scrolling occurs */ 2852 xbp += utf_ptradj(xbp); 2853 } 2854 2855 x_adjust_out: 2856 xlp_valid = false; 2857 x_redraw(xx_cols); 2858 x_flush(); 2859 } 2860 2861 static void 2862 x_e_ungetc(int c) 2863 { 2864 unget_char = c < 0 ? -1 : (c & 255); 2865 } 2866 2867 static int 2868 x_e_getc(void) 2869 { 2870 int c; 2871 2872 if (unget_char >= 0) { 2873 c = unget_char; 2874 unget_char = -1; 2875 return (c); 2876 } 2877 2878 #ifndef MKSH_SMALL 2879 if (macroptr) { 2880 if ((c = (unsigned char)*macroptr++)) 2881 return (c); 2882 macroptr = NULL; 2883 } 2884 #endif 2885 2886 return (x_getc()); 2887 } 2888 2889 static void 2890 x_e_putc2(int c) 2891 { 2892 int width = 1; 2893 2894 if (c == '\r' || c == '\n') 2895 x_col = 0; 2896 if (x_col < xx_cols) { 2897 if (UTFMODE && (c > 0x7F)) { 2898 char utf_tmp[3]; 2899 size_t x; 2900 2901 if (c < 0xA0) 2902 c = 0xFFFD; 2903 x = utf_wctomb(utf_tmp, c); 2904 x_putc(utf_tmp[0]); 2905 if (x > 1) 2906 x_putc(utf_tmp[1]); 2907 if (x > 2) 2908 x_putc(utf_tmp[2]); 2909 width = utf_wcwidth(c); 2910 } else 2911 x_putc(c); 2912 switch (c) { 2913 case 7: 2914 break; 2915 case '\r': 2916 case '\n': 2917 break; 2918 case '\b': 2919 x_col--; 2920 break; 2921 default: 2922 x_col += width; 2923 break; 2924 } 2925 } 2926 if (x_adj_ok && (x_col < 0 || x_col >= (xx_cols - 2))) 2927 x_adjust(); 2928 } 2929 2930 static void 2931 x_e_putc3(const char **cp) 2932 { 2933 int width = 1, c = **(const unsigned char **)cp; 2934 2935 if (c == '\r' || c == '\n') 2936 x_col = 0; 2937 if (x_col < xx_cols) { 2938 if (UTFMODE && (c > 0x7F)) { 2939 char *cp2; 2940 2941 width = utf_widthadj(*cp, (const char **)&cp2); 2942 while (*cp < cp2) 2943 x_putcf(*(*cp)++); 2944 } else { 2945 (*cp)++; 2946 x_putc(c); 2947 } 2948 switch (c) { 2949 case 7: 2950 break; 2951 case '\r': 2952 case '\n': 2953 break; 2954 case '\b': 2955 x_col--; 2956 break; 2957 default: 2958 x_col += width; 2959 break; 2960 } 2961 } 2962 if (x_adj_ok && (x_col < 0 || x_col >= (xx_cols - 2))) 2963 x_adjust(); 2964 } 2965 2966 static void 2967 x_e_puts(const char *s) 2968 { 2969 int adj = x_adj_done; 2970 2971 while (*s && adj == x_adj_done) 2972 x_e_putc3(&s); 2973 } 2974 2975 /*- 2976 * NAME: 2977 * x_set_arg - set an arg value for next function 2978 * 2979 * DESCRIPTION: 2980 * This is a simple implementation of M-[0-9]. 2981 * 2982 * RETURN VALUE: 2983 * KSTD 2984 */ 2985 static int 2986 x_set_arg(int c) 2987 { 2988 unsigned int n = 0; 2989 bool first = true; 2990 2991 /* strip command prefix */ 2992 c &= 255; 2993 while (c >= 0 && ksh_isdigit(c)) { 2994 n = n * 10 + ksh_numdig(c); 2995 if (n > LINE) 2996 /* upper bound for repeat */ 2997 goto x_set_arg_too_big; 2998 c = x_e_getc(); 2999 first = false; 3000 } 3001 if (c < 0 || first) { 3002 x_set_arg_too_big: 3003 x_e_putc2(7); 3004 x_arg = 1; 3005 x_arg_defaulted = true; 3006 } else { 3007 x_e_ungetc(c); 3008 x_arg = n; 3009 x_arg_defaulted = false; 3010 } 3011 return (KSTD); 3012 } 3013 3014 /* Comment or uncomment the current line. */ 3015 static int 3016 x_comment(int c MKSH_A_UNUSED) 3017 { 3018 int oldsize = x_size_str(xbuf); 3019 ssize_t len = xep - xbuf; 3020 int ret = x_do_comment(xbuf, xend - xbuf, &len); 3021 3022 if (ret < 0) 3023 x_e_putc2(7); 3024 else { 3025 x_modified(); 3026 xep = xbuf + len; 3027 *xep = '\0'; 3028 xcp = xbp = xbuf; 3029 x_redraw(oldsize); 3030 if (ret > 0) 3031 return (x_newline('\n')); 3032 } 3033 return (KSTD); 3034 } 3035 3036 static int 3037 x_version(int c MKSH_A_UNUSED) 3038 { 3039 char *o_xbuf = xbuf, *o_xend = xend; 3040 char *o_xbp = xbp, *o_xep = xep, *o_xcp = xcp; 3041 int lim = x_lastcp() - xbp; 3042 size_t vlen; 3043 char *v; 3044 3045 strdupx(v, KSH_VERSION, ATEMP); 3046 3047 xbuf = xbp = xcp = v; 3048 xend = xep = v + (vlen = strlen(v)); 3049 x_redraw(lim); 3050 x_flush(); 3051 3052 c = x_e_getc(); 3053 xbuf = o_xbuf; 3054 xend = o_xend; 3055 xbp = o_xbp; 3056 xep = o_xep; 3057 xcp = o_xcp; 3058 x_redraw((int)vlen); 3059 3060 if (c < 0) 3061 return (KSTD); 3062 /* This is what AT&T ksh seems to do... Very bizarre */ 3063 if (c != ' ') 3064 x_e_ungetc(c); 3065 3066 afree(v, ATEMP); 3067 return (KSTD); 3068 } 3069 3070 #ifndef MKSH_SMALL 3071 static int 3072 x_edit_line(int c MKSH_A_UNUSED) 3073 { 3074 if (x_arg_defaulted) { 3075 if (xep == xbuf) { 3076 x_e_putc2(7); 3077 return (KSTD); 3078 } 3079 if (modified) { 3080 *xep = '\0'; 3081 histsave(&source->line, xbuf, HIST_STORE, true); 3082 x_arg = 0; 3083 } else 3084 x_arg = source->line - (histptr - x_histp); 3085 } 3086 if (x_arg) 3087 shf_snprintf(xbuf, xend - xbuf, "%s %d", 3088 "fc -e ${VISUAL:-${EDITOR:-vi}} --", x_arg); 3089 else 3090 strlcpy(xbuf, "fc -e ${VISUAL:-${EDITOR:-vi}} --", xend - xbuf); 3091 xep = xbuf + strlen(xbuf); 3092 return (x_newline('\n')); 3093 } 3094 #endif 3095 3096 /*- 3097 * NAME: 3098 * x_prev_histword - recover word from prev command 3099 * 3100 * DESCRIPTION: 3101 * This function recovers the last word from the previous 3102 * command and inserts it into the current edit line. If a 3103 * numeric arg is supplied then the n'th word from the 3104 * start of the previous command is used. 3105 * As a side effect, trashes the mark in order to achieve 3106 * being called in a repeatable fashion. 3107 * 3108 * Bound to M-. 3109 * 3110 * RETURN VALUE: 3111 * KSTD 3112 */ 3113 static int 3114 x_prev_histword(int c MKSH_A_UNUSED) 3115 { 3116 char *rcp, *cp; 3117 char **xhp; 3118 int m = 1; 3119 /* -1 = defaulted; 0+ = argument */ 3120 static int last_arg = -1; 3121 3122 if (x_last_command == XFUNC_prev_histword) { 3123 if (xmp && modified > 1) 3124 x_kill_region(0); 3125 if (modified) 3126 m = modified; 3127 } else 3128 last_arg = x_arg_defaulted ? -1 : x_arg; 3129 xhp = histptr - (m - 1); 3130 if ((xhp < history) || !(cp = *xhp)) { 3131 x_e_putc2(7); 3132 x_modified(); 3133 return (KSTD); 3134 } 3135 x_set_mark(0); 3136 if ((x_arg = last_arg) == -1) { 3137 /* x_arg_defaulted */ 3138 3139 rcp = &cp[strlen(cp) - 1]; 3140 /* 3141 * ignore white-space after the last word 3142 */ 3143 while (rcp > cp && is_cfs(*rcp)) 3144 rcp--; 3145 while (rcp > cp && !is_cfs(*rcp)) 3146 rcp--; 3147 if (is_cfs(*rcp)) 3148 rcp++; 3149 x_ins(rcp); 3150 } else { 3151 /* not x_arg_defaulted */ 3152 char ch; 3153 3154 rcp = cp; 3155 /* 3156 * ignore white-space at start of line 3157 */ 3158 while (*rcp && is_cfs(*rcp)) 3159 rcp++; 3160 while (x_arg-- > 0) { 3161 while (*rcp && !is_cfs(*rcp)) 3162 rcp++; 3163 while (*rcp && is_cfs(*rcp)) 3164 rcp++; 3165 } 3166 cp = rcp; 3167 while (*rcp && !is_cfs(*rcp)) 3168 rcp++; 3169 ch = *rcp; 3170 *rcp = '\0'; 3171 x_ins(cp); 3172 *rcp = ch; 3173 } 3174 modified = m + 1; 3175 return (KSTD); 3176 } 3177 3178 #ifndef MKSH_SMALL 3179 /* Uppercase N(1) words */ 3180 static int 3181 x_fold_upper(int c MKSH_A_UNUSED) 3182 { 3183 return (x_fold_case('U')); 3184 } 3185 3186 /* Lowercase N(1) words */ 3187 static int 3188 x_fold_lower(int c MKSH_A_UNUSED) 3189 { 3190 return (x_fold_case('L')); 3191 } 3192 3193 /* Titlecase N(1) words */ 3194 static int 3195 x_fold_capitalise(int c MKSH_A_UNUSED) 3196 { 3197 return (x_fold_case('C')); 3198 } 3199 3200 /*- 3201 * NAME: 3202 * x_fold_case - convert word to UPPER/lower/Capital case 3203 * 3204 * DESCRIPTION: 3205 * This function is used to implement M-U/M-u, M-L/M-l, M-C/M-c 3206 * to UPPER CASE, lower case or Capitalise Words. 3207 * 3208 * RETURN VALUE: 3209 * None 3210 */ 3211 static int 3212 x_fold_case(int c) 3213 { 3214 char *cp = xcp; 3215 3216 if (cp == xep) { 3217 x_e_putc2(7); 3218 return (KSTD); 3219 } 3220 while (x_arg--) { 3221 /* 3222 * first skip over any white-space 3223 */ 3224 while (cp != xep && is_mfs(*cp)) 3225 cp++; 3226 /* 3227 * do the first char on its own since it may be 3228 * a different action than for the rest. 3229 */ 3230 if (cp != xep) { 3231 if (c == 'L') 3232 /* lowercase */ 3233 *cp = ksh_tolower(*cp); 3234 else 3235 /* uppercase, capitalise */ 3236 *cp = ksh_toupper(*cp); 3237 cp++; 3238 } 3239 /* 3240 * now for the rest of the word 3241 */ 3242 while (cp != xep && !is_mfs(*cp)) { 3243 if (c == 'U') 3244 /* uppercase */ 3245 *cp = ksh_toupper(*cp); 3246 else 3247 /* lowercase, capitalise */ 3248 *cp = ksh_tolower(*cp); 3249 cp++; 3250 } 3251 } 3252 x_goto(cp); 3253 x_modified(); 3254 return (KSTD); 3255 } 3256 #endif 3257 3258 /*- 3259 * NAME: 3260 * x_lastcp - last visible char 3261 * 3262 * SYNOPSIS: 3263 * x_lastcp() 3264 * 3265 * DESCRIPTION: 3266 * This function returns a pointer to that char in the 3267 * edit buffer that will be the last displayed on the 3268 * screen. The sequence: 3269 * 3270 * cp = x_lastcp(); 3271 * while (cp > xcp) 3272 * x_bs3(&cp); 3273 * 3274 * Will position the cursor correctly on the screen. 3275 * 3276 * RETURN VALUE: 3277 * cp or NULL 3278 */ 3279 static char * 3280 x_lastcp(void) 3281 { 3282 if (!xlp_valid) { 3283 int i = 0, j; 3284 char *xlp2; 3285 3286 xlp = xbp; 3287 while (xlp < xep) { 3288 j = x_size2(xlp, &xlp2); 3289 if ((i + j) > x_displen) 3290 break; 3291 i += j; 3292 xlp = xlp2; 3293 } 3294 } 3295 xlp_valid = true; 3296 return (xlp); 3297 } 3298 3299 static void 3300 x_mode(bool onoff) 3301 { 3302 static bool x_cur_mode; 3303 3304 if (x_cur_mode == onoff) 3305 return; 3306 x_cur_mode = onoff; 3307 3308 if (onoff) { 3309 x_mkraw(tty_fd, NULL, false); 3310 3311 edchars.erase = tty_state.c_cc[VERASE]; 3312 edchars.kill = tty_state.c_cc[VKILL]; 3313 edchars.intr = tty_state.c_cc[VINTR]; 3314 edchars.quit = tty_state.c_cc[VQUIT]; 3315 edchars.eof = tty_state.c_cc[VEOF]; 3316 #ifdef VWERASE 3317 edchars.werase = tty_state.c_cc[VWERASE]; 3318 #else 3319 edchars.werase = 0; 3320 #endif 3321 3322 if (!edchars.erase) 3323 edchars.erase = CTRL('H'); 3324 if (!edchars.kill) 3325 edchars.kill = CTRL('U'); 3326 if (!edchars.intr) 3327 edchars.intr = CTRL('C'); 3328 if (!edchars.quit) 3329 edchars.quit = CTRL('\\'); 3330 if (!edchars.eof) 3331 edchars.eof = CTRL('D'); 3332 if (!edchars.werase) 3333 edchars.werase = CTRL('W'); 3334 3335 #ifdef _POSIX_VDISABLE 3336 /* Convert unset values to internal 'unset' value */ 3337 if (edchars.erase == _POSIX_VDISABLE) 3338 edchars.erase = -1; 3339 if (edchars.kill == _POSIX_VDISABLE) 3340 edchars.kill = -1; 3341 if (edchars.intr == _POSIX_VDISABLE) 3342 edchars.intr = -1; 3343 if (edchars.quit == _POSIX_VDISABLE) 3344 edchars.quit = -1; 3345 if (edchars.eof == _POSIX_VDISABLE) 3346 edchars.eof = -1; 3347 if (edchars.werase == _POSIX_VDISABLE) 3348 edchars.werase = -1; 3349 #endif 3350 3351 if (edchars.erase >= 0) { 3352 bind_if_not_bound(0, edchars.erase, XFUNC_del_back); 3353 bind_if_not_bound(1, edchars.erase, XFUNC_del_bword); 3354 } 3355 if (edchars.kill >= 0) 3356 bind_if_not_bound(0, edchars.kill, XFUNC_del_line); 3357 if (edchars.werase >= 0) 3358 bind_if_not_bound(0, edchars.werase, XFUNC_del_bword); 3359 if (edchars.intr >= 0) 3360 bind_if_not_bound(0, edchars.intr, XFUNC_abort); 3361 if (edchars.quit >= 0) 3362 bind_if_not_bound(0, edchars.quit, XFUNC_noop); 3363 } else 3364 mksh_tcset(tty_fd, &tty_state); 3365 } 3366 3367 #if !MKSH_S_NOVI 3368 /* +++ vi editing mode +++ */ 3369 3370 struct edstate { 3371 char *cbuf; 3372 ssize_t winleft; 3373 ssize_t cbufsize; 3374 ssize_t linelen; 3375 ssize_t cursor; 3376 }; 3377 3378 static int vi_hook(int); 3379 static int nextstate(int); 3380 static int vi_insert(int); 3381 static int vi_cmd(int, const char *); 3382 static int domove(int, const char *, int); 3383 static int redo_insert(int); 3384 static void yank_range(int, int); 3385 static int bracktype(int); 3386 static void save_cbuf(void); 3387 static void restore_cbuf(void); 3388 static int putbuf(const char *, ssize_t, bool); 3389 static void del_range(int, int); 3390 static int findch(int, int, bool, bool) MKSH_A_PURE; 3391 static int forwword(int); 3392 static int backword(int); 3393 static int endword(int); 3394 static int Forwword(int); 3395 static int Backword(int); 3396 static int Endword(int); 3397 static int grabhist(int, int); 3398 static int grabsearch(int, int, int, const char *); 3399 static void redraw_line(bool); 3400 static void refresh(int); 3401 static int outofwin(void); 3402 static void rewindow(void); 3403 static int newcol(unsigned char, int); 3404 static void display(char *, char *, int); 3405 static void ed_mov_opt(int, char *); 3406 static int expand_word(int); 3407 static int complete_word(int, int); 3408 static int print_expansions(struct edstate *, int); 3409 #define char_len(c) ((ISCTRL((unsigned char)c) && \ 3410 /* but not C1 */ (unsigned char)c < 0x80) ? 2 : 1) 3411 static void x_vi_zotc(int); 3412 static void vi_error(void); 3413 static void vi_macro_reset(void); 3414 static int x_vi_putbuf(const char *, size_t); 3415 3416 #define vC 0x01 /* a valid command that isn't a vM, vE, vU */ 3417 #define vM 0x02 /* movement command (h, l, etc.) */ 3418 #define vE 0x04 /* extended command (c, d, y) */ 3419 #define vX 0x08 /* long command (@, f, F, t, T, etc.) */ 3420 #define vU 0x10 /* an UN-undoable command (that isn't a vM) */ 3421 #define vB 0x20 /* bad command (^@) */ 3422 #define vZ 0x40 /* repeat count defaults to 0 (not 1) */ 3423 #define vS 0x80 /* search (/, ?) */ 3424 3425 #define is_bad(c) (classify[(c)&0x7f]&vB) 3426 #define is_cmd(c) (classify[(c)&0x7f]&(vM|vE|vC|vU)) 3427 #define is_move(c) (classify[(c)&0x7f]&vM) 3428 #define is_extend(c) (classify[(c)&0x7f]&vE) 3429 #define is_long(c) (classify[(c)&0x7f]&vX) 3430 #define is_undoable(c) (!(classify[(c)&0x7f]&vU)) 3431 #define is_srch(c) (classify[(c)&0x7f]&vS) 3432 #define is_zerocount(c) (classify[(c)&0x7f]&vZ) 3433 3434 static const unsigned char classify[128] = { 3435 /* 0 1 2 3 4 5 6 7 */ 3436 /* 0 ^@ ^A ^B ^C ^D ^E ^F ^G */ 3437 vB, 0, 0, 0, 0, vC|vU, vC|vZ, 0, 3438 /* 1 ^H ^I ^J ^K ^L ^M ^N ^O */ 3439 vM, vC|vZ, 0, 0, vC|vU, 0, vC, 0, 3440 /* 2 ^P ^Q ^R ^S ^T ^U ^V ^W */ 3441 vC, 0, vC|vU, 0, 0, 0, vC, 0, 3442 /* 3 ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */ 3443 vC, 0, 0, vC|vZ, 0, 0, 0, 0, 3444 /* 4 <space> ! " # $ % & ' */ 3445 vM, 0, 0, vC, vM, vM, 0, 0, 3446 /* 5 ( ) * + , - . / */ 3447 0, 0, vC, vC, vM, vC, 0, vC|vS, 3448 /* 6 0 1 2 3 4 5 6 7 */ 3449 vM, 0, 0, 0, 0, 0, 0, 0, 3450 /* 7 8 9 : ; < = > ? */ 3451 0, 0, 0, vM, 0, vC, 0, vC|vS, 3452 /* 8 @ A B C D E F G */ 3453 vC|vX, vC, vM, vC, vC, vM, vM|vX, vC|vU|vZ, 3454 /* 9 H I J K L M N O */ 3455 0, vC, 0, 0, 0, 0, vC|vU, vU, 3456 /* A P Q R S T U V W */ 3457 vC, 0, vC, vC, vM|vX, vC, 0, vM, 3458 /* B X Y Z [ \ ] ^ _ */ 3459 vC, vC|vU, 0, vU, vC|vZ, 0, vM, vC|vZ, 3460 /* C ` a b c d e f g */ 3461 0, vC, vM, vE, vE, vM, vM|vX, vC|vZ, 3462 /* D h i j k l m n o */ 3463 vM, vC, vC|vU, vC|vU, vM, 0, vC|vU, 0, 3464 /* E p q r s t u v w */ 3465 vC, 0, vX, vC, vM|vX, vC|vU, vC|vU|vZ, vM, 3466 /* F x y z { | } ~ ^? */ 3467 vC, vE|vU, 0, 0, vM|vZ, 0, vC, 0 3468 }; 3469 3470 #define MAXVICMD 3 3471 #define SRCHLEN 40 3472 3473 #define INSERT 1 3474 #define REPLACE 2 3475 3476 #define VNORMAL 0 /* command, insert or replace mode */ 3477 #define VARG1 1 /* digit prefix (first, eg, 5l) */ 3478 #define VEXTCMD 2 /* cmd + movement (eg, cl) */ 3479 #define VARG2 3 /* digit prefix (second, eg, 2c3l) */ 3480 #define VXCH 4 /* f, F, t, T, @ */ 3481 #define VFAIL 5 /* bad command */ 3482 #define VCMD 6 /* single char command (eg, X) */ 3483 #define VREDO 7 /* . */ 3484 #define VLIT 8 /* ^V */ 3485 #define VSEARCH 9 /* /, ? */ 3486 #define VVERSION 10 /* <ESC> ^V */ 3487 #define VPREFIX2 11 /* ^[[ and ^[O in insert mode */ 3488 3489 static struct edstate *save_edstate(struct edstate *old); 3490 static void restore_edstate(struct edstate *old, struct edstate *news); 3491 static void free_edstate(struct edstate *old); 3492 3493 static struct edstate ebuf; 3494 static struct edstate undobuf; 3495 3496 static struct edstate *es; /* current editor state */ 3497 static struct edstate *undo; 3498 3499 static char *ibuf; /* input buffer */ 3500 static bool first_insert; /* set when starting in insert mode */ 3501 static int saved_inslen; /* saved inslen for first insert */ 3502 static int inslen; /* length of input buffer */ 3503 static int srchlen; /* length of current search pattern */ 3504 static char *ybuf; /* yank buffer */ 3505 static int yanklen; /* length of yank buffer */ 3506 static int fsavecmd = ' '; /* last find command */ 3507 static int fsavech; /* character to find */ 3508 static char lastcmd[MAXVICMD]; /* last non-move command */ 3509 static int lastac; /* argcnt for lastcmd */ 3510 static int lastsearch = ' '; /* last search command */ 3511 static char srchpat[SRCHLEN]; /* last search pattern */ 3512 static int insert; /* <>0 in insert mode */ 3513 static int hnum; /* position in history */ 3514 static int ohnum; /* history line copied (after mod) */ 3515 static int hlast; /* 1 past last position in history */ 3516 static int state; 3517 3518 /* 3519 * Information for keeping track of macros that are being expanded. 3520 * The format of buf is the alias contents followed by a NUL byte followed 3521 * by the name (letter) of the alias. The end of the buffer is marked by 3522 * a double NUL. The name of the alias is stored so recursive macros can 3523 * be detected. 3524 */ 3525 struct macro_state { 3526 unsigned char *p; /* current position in buf */ 3527 unsigned char *buf; /* pointer to macro(s) being expanded */ 3528 size_t len; /* how much data in buffer */ 3529 }; 3530 static struct macro_state macro; 3531 3532 /* last input was expanded */ 3533 static enum expand_mode { 3534 NONE = 0, EXPAND, COMPLETE, PRINT 3535 } expanded; 3536 3537 static int 3538 x_vi(char *buf) 3539 { 3540 int c; 3541 3542 state = VNORMAL; 3543 ohnum = hnum = hlast = histnum(-1) + 1; 3544 insert = INSERT; 3545 saved_inslen = inslen; 3546 first_insert = true; 3547 inslen = 0; 3548 vi_macro_reset(); 3549 3550 ebuf.cbuf = buf; 3551 if (undobuf.cbuf == NULL) { 3552 ibuf = alloc(LINE, AEDIT); 3553 ybuf = alloc(LINE, AEDIT); 3554 undobuf.cbuf = alloc(LINE, AEDIT); 3555 } 3556 undobuf.cbufsize = ebuf.cbufsize = LINE; 3557 undobuf.linelen = ebuf.linelen = 0; 3558 undobuf.cursor = ebuf.cursor = 0; 3559 undobuf.winleft = ebuf.winleft = 0; 3560 es = &ebuf; 3561 undo = &undobuf; 3562 3563 x_init_prompt(true); 3564 x_col = pwidth; 3565 3566 if (wbuf_len != x_cols - 3 && ((wbuf_len = x_cols - 3))) { 3567 wbuf[0] = aresize(wbuf[0], wbuf_len, AEDIT); 3568 wbuf[1] = aresize(wbuf[1], wbuf_len, AEDIT); 3569 } 3570 if (wbuf_len) { 3571 memset(wbuf[0], ' ', wbuf_len); 3572 memset(wbuf[1], ' ', wbuf_len); 3573 } 3574 winwidth = x_cols - pwidth - 3; 3575 win = 0; 3576 morec = ' '; 3577 lastref = 1; 3578 holdlen = 0; 3579 3580 editmode = 2; 3581 x_flush(); 3582 while (/* CONSTCOND */ 1) { 3583 if (macro.p) { 3584 c = (unsigned char)*macro.p++; 3585 /* end of current macro? */ 3586 if (!c) { 3587 /* more macros left to finish? */ 3588 if (*macro.p++) 3589 continue; 3590 /* must be the end of all the macros */ 3591 vi_macro_reset(); 3592 c = x_getc(); 3593 } 3594 } else 3595 c = x_getc(); 3596 3597 if (c == -1) 3598 break; 3599 if (state != VLIT) { 3600 if (c == edchars.intr || c == edchars.quit) { 3601 /* pretend we got an interrupt */ 3602 x_vi_zotc(c); 3603 x_flush(); 3604 trapsig(c == edchars.intr ? SIGINT : SIGQUIT); 3605 x_mode(false); 3606 unwind(LSHELL); 3607 } else if (c == edchars.eof && state != VVERSION) { 3608 if (es->linelen == 0) { 3609 x_vi_zotc(edchars.eof); 3610 c = -1; 3611 break; 3612 } 3613 continue; 3614 } 3615 } 3616 if (vi_hook(c)) 3617 break; 3618 x_flush(); 3619 } 3620 3621 x_putc('\r'); 3622 x_putc('\n'); 3623 x_flush(); 3624 3625 if (c == -1 || (ssize_t)LINE <= es->linelen) 3626 return (-1); 3627 3628 if (es->cbuf != buf) 3629 memcpy(buf, es->cbuf, es->linelen); 3630 3631 buf[es->linelen++] = '\n'; 3632 3633 return (es->linelen); 3634 } 3635 3636 static int 3637 vi_hook(int ch) 3638 { 3639 static char curcmd[MAXVICMD], locpat[SRCHLEN]; 3640 static int cmdlen, argc1, argc2; 3641 3642 switch (state) { 3643 3644 case VNORMAL: 3645 /* PC scancodes */ 3646 if (!ch) switch (cmdlen = 0, (ch = x_getc())) { 3647 case 71: ch = '0'; goto pseudo_vi_command; 3648 case 72: ch = 'k'; goto pseudo_vi_command; 3649 case 73: ch = 'A'; goto vi_xfunc_search_up; 3650 case 75: ch = 'h'; goto pseudo_vi_command; 3651 case 77: ch = 'l'; goto pseudo_vi_command; 3652 case 79: ch = '$'; goto pseudo_vi_command; 3653 case 80: ch = 'j'; goto pseudo_vi_command; 3654 case 83: ch = 'x'; goto pseudo_vi_command; 3655 default: ch = 0; goto vi_insert_failed; 3656 } 3657 if (insert != 0) { 3658 if (ch == CTRL('v')) { 3659 state = VLIT; 3660 ch = '^'; 3661 } 3662 switch (vi_insert(ch)) { 3663 case -1: 3664 vi_insert_failed: 3665 vi_error(); 3666 state = VNORMAL; 3667 break; 3668 case 0: 3669 if (state == VLIT) { 3670 es->cursor--; 3671 refresh(0); 3672 } else 3673 refresh(insert != 0); 3674 break; 3675 case 1: 3676 return (1); 3677 } 3678 } else { 3679 if (ch == '\r' || ch == '\n') 3680 return (1); 3681 cmdlen = 0; 3682 argc1 = 0; 3683 if (ch >= ord('1') && ch <= ord('9')) { 3684 argc1 = ksh_numdig(ch); 3685 state = VARG1; 3686 } else { 3687 pseudo_vi_command: 3688 curcmd[cmdlen++] = ch; 3689 state = nextstate(ch); 3690 if (state == VSEARCH) { 3691 save_cbuf(); 3692 es->cursor = 0; 3693 es->linelen = 0; 3694 if (putbuf(ch == '/' ? "/" : "?", 1, 3695 false) != 0) 3696 return (-1); 3697 refresh(0); 3698 } 3699 if (state == VVERSION) { 3700 save_cbuf(); 3701 es->cursor = 0; 3702 es->linelen = 0; 3703 putbuf(KSH_VERSION, 3704 strlen(KSH_VERSION), false); 3705 refresh(0); 3706 } 3707 } 3708 } 3709 break; 3710 3711 case VLIT: 3712 if (is_bad(ch)) { 3713 del_range(es->cursor, es->cursor + 1); 3714 vi_error(); 3715 } else 3716 es->cbuf[es->cursor++] = ch; 3717 refresh(1); 3718 state = VNORMAL; 3719 break; 3720 3721 case VVERSION: 3722 restore_cbuf(); 3723 state = VNORMAL; 3724 refresh(0); 3725 break; 3726 3727 case VARG1: 3728 if (ksh_isdigit(ch)) 3729 argc1 = argc1 * 10 + ksh_numdig(ch); 3730 else { 3731 curcmd[cmdlen++] = ch; 3732 state = nextstate(ch); 3733 } 3734 break; 3735 3736 case VEXTCMD: 3737 argc2 = 0; 3738 if (ch >= ord('1') && ch <= ord('9')) { 3739 argc2 = ksh_numdig(ch); 3740 state = VARG2; 3741 return (0); 3742 } else { 3743 curcmd[cmdlen++] = ch; 3744 if (ch == curcmd[0]) 3745 state = VCMD; 3746 else if (is_move(ch)) 3747 state = nextstate(ch); 3748 else 3749 state = VFAIL; 3750 } 3751 break; 3752 3753 case VARG2: 3754 if (ksh_isdigit(ch)) 3755 argc2 = argc2 * 10 + ksh_numdig(ch); 3756 else { 3757 if (argc1 == 0) 3758 argc1 = argc2; 3759 else 3760 argc1 *= argc2; 3761 curcmd[cmdlen++] = ch; 3762 if (ch == curcmd[0]) 3763 state = VCMD; 3764 else if (is_move(ch)) 3765 state = nextstate(ch); 3766 else 3767 state = VFAIL; 3768 } 3769 break; 3770 3771 case VXCH: 3772 if (ch == CTRL('[')) 3773 state = VNORMAL; 3774 else { 3775 curcmd[cmdlen++] = ch; 3776 state = VCMD; 3777 } 3778 break; 3779 3780 case VSEARCH: 3781 if (ch == '\r' || ch == '\n' /*|| ch == CTRL('[')*/ ) { 3782 restore_cbuf(); 3783 /* Repeat last search? */ 3784 if (srchlen == 0) { 3785 if (!srchpat[0]) { 3786 vi_error(); 3787 state = VNORMAL; 3788 refresh(0); 3789 return (0); 3790 } 3791 } else { 3792 locpat[srchlen] = '\0'; 3793 memcpy(srchpat, locpat, srchlen + 1); 3794 } 3795 state = VCMD; 3796 } else if (ch == edchars.erase || ch == CTRL('h')) { 3797 if (srchlen != 0) { 3798 srchlen--; 3799 es->linelen -= char_len(locpat[srchlen]); 3800 es->cursor = es->linelen; 3801 refresh(0); 3802 return (0); 3803 } 3804 restore_cbuf(); 3805 state = VNORMAL; 3806 refresh(0); 3807 } else if (ch == edchars.kill) { 3808 srchlen = 0; 3809 es->linelen = 1; 3810 es->cursor = 1; 3811 refresh(0); 3812 return (0); 3813 } else if (ch == edchars.werase) { 3814 unsigned int i, n; 3815 struct edstate new_es, *save_es; 3816 3817 new_es.cursor = srchlen; 3818 new_es.cbuf = locpat; 3819 3820 save_es = es; 3821 es = &new_es; 3822 n = backword(1); 3823 es = save_es; 3824 3825 i = (unsigned)srchlen; 3826 while (--i >= n) 3827 es->linelen -= char_len(locpat[i]); 3828 srchlen = (int)n; 3829 es->cursor = es->linelen; 3830 refresh(0); 3831 return (0); 3832 } else { 3833 if (srchlen == SRCHLEN - 1) 3834 vi_error(); 3835 else { 3836 locpat[srchlen++] = ch; 3837 if (ISCTRL(ch) && /* but not C1 */ ch < 0x80) { 3838 if ((size_t)es->linelen + 2 > 3839 (size_t)es->cbufsize) 3840 vi_error(); 3841 es->cbuf[es->linelen++] = '^'; 3842 es->cbuf[es->linelen++] = UNCTRL(ch); 3843 } else { 3844 if (es->linelen >= es->cbufsize) 3845 vi_error(); 3846 es->cbuf[es->linelen++] = ch; 3847 } 3848 es->cursor = es->linelen; 3849 refresh(0); 3850 } 3851 return (0); 3852 } 3853 break; 3854 3855 case VPREFIX2: 3856 vi_xfunc_search_up: 3857 state = VFAIL; 3858 switch (ch) { 3859 case 'A': 3860 /* the cursor may not be at the BOL */ 3861 if (!es->cursor) 3862 break; 3863 /* nor further in the line than we can search for */ 3864 if ((size_t)es->cursor >= sizeof(srchpat) - 1) 3865 es->cursor = sizeof(srchpat) - 2; 3866 /* anchor the search pattern */ 3867 srchpat[0] = '^'; 3868 /* take the current line up to the cursor */ 3869 memmove(srchpat + 1, es->cbuf, es->cursor); 3870 srchpat[es->cursor + 1] = '\0'; 3871 /* set a magic flag */ 3872 argc1 = 2 + (int)es->cursor; 3873 /* and emulate a backwards history search */ 3874 lastsearch = '/'; 3875 *curcmd = 'n'; 3876 goto pseudo_VCMD; 3877 } 3878 break; 3879 } 3880 3881 switch (state) { 3882 case VCMD: 3883 pseudo_VCMD: 3884 state = VNORMAL; 3885 switch (vi_cmd(argc1, curcmd)) { 3886 case -1: 3887 vi_error(); 3888 refresh(0); 3889 break; 3890 case 0: 3891 if (insert != 0) 3892 inslen = 0; 3893 refresh(insert != 0); 3894 break; 3895 case 1: 3896 refresh(0); 3897 return (1); 3898 case 2: 3899 /* back from a 'v' command - don't redraw the screen */ 3900 return (1); 3901 } 3902 break; 3903 3904 case VREDO: 3905 state = VNORMAL; 3906 if (argc1 != 0) 3907 lastac = argc1; 3908 switch (vi_cmd(lastac, lastcmd)) { 3909 case -1: 3910 vi_error(); 3911 refresh(0); 3912 break; 3913 case 0: 3914 if (insert != 0) { 3915 if (lastcmd[0] == 's' || lastcmd[0] == 'c' || 3916 lastcmd[0] == 'C') { 3917 if (redo_insert(1) != 0) 3918 vi_error(); 3919 } else { 3920 if (redo_insert(lastac) != 0) 3921 vi_error(); 3922 } 3923 } 3924 refresh(0); 3925 break; 3926 case 1: 3927 refresh(0); 3928 return (1); 3929 case 2: 3930 /* back from a 'v' command - can't happen */ 3931 break; 3932 } 3933 break; 3934 3935 case VFAIL: 3936 state = VNORMAL; 3937 vi_error(); 3938 break; 3939 } 3940 return (0); 3941 } 3942 3943 static int 3944 nextstate(int ch) 3945 { 3946 if (is_extend(ch)) 3947 return (VEXTCMD); 3948 else if (is_srch(ch)) 3949 return (VSEARCH); 3950 else if (is_long(ch)) 3951 return (VXCH); 3952 else if (ch == '.') 3953 return (VREDO); 3954 else if (ch == CTRL('v')) 3955 return (VVERSION); 3956 else if (is_cmd(ch)) 3957 return (VCMD); 3958 else 3959 return (VFAIL); 3960 } 3961 3962 static int 3963 vi_insert(int ch) 3964 { 3965 int tcursor; 3966 3967 if (ch == edchars.erase || ch == CTRL('h')) { 3968 if (insert == REPLACE) { 3969 if (es->cursor == undo->cursor) { 3970 vi_error(); 3971 return (0); 3972 } 3973 if (inslen > 0) 3974 inslen--; 3975 es->cursor--; 3976 if (es->cursor >= undo->linelen) 3977 es->linelen--; 3978 else 3979 es->cbuf[es->cursor] = undo->cbuf[es->cursor]; 3980 } else { 3981 if (es->cursor == 0) 3982 return (0); 3983 if (inslen > 0) 3984 inslen--; 3985 es->cursor--; 3986 es->linelen--; 3987 memmove(&es->cbuf[es->cursor], &es->cbuf[es->cursor + 1], 3988 es->linelen - es->cursor + 1); 3989 } 3990 expanded = NONE; 3991 return (0); 3992 } 3993 if (ch == edchars.kill) { 3994 if (es->cursor != 0) { 3995 inslen = 0; 3996 memmove(es->cbuf, &es->cbuf[es->cursor], 3997 es->linelen - es->cursor); 3998 es->linelen -= es->cursor; 3999 es->cursor = 0; 4000 } 4001 expanded = NONE; 4002 return (0); 4003 } 4004 if (ch == edchars.werase) { 4005 if (es->cursor != 0) { 4006 tcursor = backword(1); 4007 memmove(&es->cbuf[tcursor], &es->cbuf[es->cursor], 4008 es->linelen - es->cursor); 4009 es->linelen -= es->cursor - tcursor; 4010 if (inslen < es->cursor - tcursor) 4011 inslen = 0; 4012 else 4013 inslen -= es->cursor - tcursor; 4014 es->cursor = tcursor; 4015 } 4016 expanded = NONE; 4017 return (0); 4018 } 4019 /* 4020 * If any chars are entered before escape, trash the saved insert 4021 * buffer (if user inserts & deletes char, ibuf gets trashed and 4022 * we don't want to use it) 4023 */ 4024 if (first_insert && ch != CTRL('[')) 4025 saved_inslen = 0; 4026 switch (ch) { 4027 case '\0': 4028 return (-1); 4029 4030 case '\r': 4031 case '\n': 4032 return (1); 4033 4034 case CTRL('['): 4035 expanded = NONE; 4036 if (first_insert) { 4037 first_insert = false; 4038 if (inslen == 0) { 4039 inslen = saved_inslen; 4040 return (redo_insert(0)); 4041 } 4042 lastcmd[0] = 'a'; 4043 lastac = 1; 4044 } 4045 if (lastcmd[0] == 's' || lastcmd[0] == 'c' || 4046 lastcmd[0] == 'C') 4047 return (redo_insert(0)); 4048 else 4049 return (redo_insert(lastac - 1)); 4050 4051 /* { Begin nonstandard vi commands */ 4052 case CTRL('x'): 4053 expand_word(0); 4054 break; 4055 4056 case CTRL('f'): 4057 complete_word(0, 0); 4058 break; 4059 4060 case CTRL('e'): 4061 print_expansions(es, 0); 4062 break; 4063 4064 case CTRL('i'): 4065 if (Flag(FVITABCOMPLETE)) { 4066 complete_word(0, 0); 4067 break; 4068 } 4069 /* FALLTHROUGH */ 4070 /* End nonstandard vi commands } */ 4071 4072 default: 4073 if (es->linelen >= es->cbufsize - 1) 4074 return (-1); 4075 ibuf[inslen++] = ch; 4076 if (insert == INSERT) { 4077 memmove(&es->cbuf[es->cursor + 1], &es->cbuf[es->cursor], 4078 es->linelen - es->cursor); 4079 es->linelen++; 4080 } 4081 es->cbuf[es->cursor++] = ch; 4082 if (insert == REPLACE && es->cursor > es->linelen) 4083 es->linelen++; 4084 expanded = NONE; 4085 } 4086 return (0); 4087 } 4088 4089 static int 4090 vi_cmd(int argcnt, const char *cmd) 4091 { 4092 int ncursor; 4093 int cur, c1, c2, c3 = 0; 4094 int any; 4095 struct edstate *t; 4096 4097 if (argcnt == 0 && !is_zerocount(*cmd)) 4098 argcnt = 1; 4099 4100 if (is_move(*cmd)) { 4101 if ((cur = domove(argcnt, cmd, 0)) >= 0) { 4102 if (cur == es->linelen && cur != 0) 4103 cur--; 4104 es->cursor = cur; 4105 } else 4106 return (-1); 4107 } else { 4108 /* Don't save state in middle of macro.. */ 4109 if (is_undoable(*cmd) && !macro.p) { 4110 undo->winleft = es->winleft; 4111 memmove(undo->cbuf, es->cbuf, es->linelen); 4112 undo->linelen = es->linelen; 4113 undo->cursor = es->cursor; 4114 lastac = argcnt; 4115 memmove(lastcmd, cmd, MAXVICMD); 4116 } 4117 switch (*cmd) { 4118 4119 case CTRL('l'): 4120 case CTRL('r'): 4121 redraw_line(true); 4122 break; 4123 4124 case '@': 4125 { 4126 static char alias[] = "_\0"; 4127 struct tbl *ap; 4128 size_t olen, nlen; 4129 char *p, *nbuf; 4130 4131 /* lookup letter in alias list... */ 4132 alias[1] = cmd[1]; 4133 ap = ktsearch(&aliases, alias, hash(alias)); 4134 if (!cmd[1] || !ap || !(ap->flag & ISSET)) 4135 return (-1); 4136 /* check if this is a recursive call... */ 4137 if ((p = (char *)macro.p)) 4138 while ((p = strnul(p)) && p[1]) 4139 if (*++p == cmd[1]) 4140 return (-1); 4141 /* insert alias into macro buffer */ 4142 nlen = strlen(ap->val.s) + 1; 4143 olen = !macro.p ? 2 : 4144 macro.len - (macro.p - macro.buf); 4145 /* 4146 * at this point, it's fairly reasonable that 4147 * nlen + olen + 2 doesn't overflow 4148 */ 4149 nbuf = alloc(nlen + 1 + olen, AEDIT); 4150 memcpy(nbuf, ap->val.s, nlen); 4151 nbuf[nlen++] = cmd[1]; 4152 if (macro.p) { 4153 memcpy(nbuf + nlen, macro.p, olen); 4154 afree(macro.buf, AEDIT); 4155 nlen += olen; 4156 } else { 4157 nbuf[nlen++] = '\0'; 4158 nbuf[nlen++] = '\0'; 4159 } 4160 macro.p = macro.buf = (unsigned char *)nbuf; 4161 macro.len = nlen; 4162 } 4163 break; 4164 4165 case 'a': 4166 modified = 1; 4167 hnum = hlast; 4168 if (es->linelen != 0) 4169 es->cursor++; 4170 insert = INSERT; 4171 break; 4172 4173 case 'A': 4174 modified = 1; 4175 hnum = hlast; 4176 del_range(0, 0); 4177 es->cursor = es->linelen; 4178 insert = INSERT; 4179 break; 4180 4181 case 'S': 4182 es->cursor = domove(1, "^", 1); 4183 del_range(es->cursor, es->linelen); 4184 modified = 1; 4185 hnum = hlast; 4186 insert = INSERT; 4187 break; 4188 4189 case 'Y': 4190 cmd = "y$"; 4191 /* ahhhhhh... */ 4192 case 'c': 4193 case 'd': 4194 case 'y': 4195 if (*cmd == cmd[1]) { 4196 c1 = *cmd == 'c' ? domove(1, "^", 1) : 0; 4197 c2 = es->linelen; 4198 } else if (!is_move(cmd[1])) 4199 return (-1); 4200 else { 4201 if ((ncursor = domove(argcnt, &cmd[1], 1)) < 0) 4202 return (-1); 4203 if (*cmd == 'c' && 4204 (cmd[1] == 'w' || cmd[1] == 'W') && 4205 !ksh_isspace(es->cbuf[es->cursor])) { 4206 do { 4207 --ncursor; 4208 } while (ksh_isspace(es->cbuf[ncursor])); 4209 ncursor++; 4210 } 4211 if (ncursor > es->cursor) { 4212 c1 = es->cursor; 4213 c2 = ncursor; 4214 } else { 4215 c1 = ncursor; 4216 c2 = es->cursor; 4217 if (cmd[1] == '%') 4218 c2++; 4219 } 4220 } 4221 if (*cmd != 'c' && c1 != c2) 4222 yank_range(c1, c2); 4223 if (*cmd != 'y') { 4224 del_range(c1, c2); 4225 es->cursor = c1; 4226 } 4227 if (*cmd == 'c') { 4228 modified = 1; 4229 hnum = hlast; 4230 insert = INSERT; 4231 } 4232 break; 4233 4234 case 'p': 4235 modified = 1; 4236 hnum = hlast; 4237 if (es->linelen != 0) 4238 es->cursor++; 4239 while (putbuf(ybuf, yanklen, false) == 0 && 4240 --argcnt > 0) 4241 ; 4242 if (es->cursor != 0) 4243 es->cursor--; 4244 if (argcnt != 0) 4245 return (-1); 4246 break; 4247 4248 case 'P': 4249 modified = 1; 4250 hnum = hlast; 4251 any = 0; 4252 while (putbuf(ybuf, yanklen, false) == 0 && 4253 --argcnt > 0) 4254 any = 1; 4255 if (any && es->cursor != 0) 4256 es->cursor--; 4257 if (argcnt != 0) 4258 return (-1); 4259 break; 4260 4261 case 'C': 4262 modified = 1; 4263 hnum = hlast; 4264 del_range(es->cursor, es->linelen); 4265 insert = INSERT; 4266 break; 4267 4268 case 'D': 4269 yank_range(es->cursor, es->linelen); 4270 del_range(es->cursor, es->linelen); 4271 if (es->cursor != 0) 4272 es->cursor--; 4273 break; 4274 4275 case 'g': 4276 if (!argcnt) 4277 argcnt = hlast; 4278 /* FALLTHROUGH */ 4279 case 'G': 4280 if (!argcnt) 4281 argcnt = 1; 4282 else 4283 argcnt = hlast - (source->line - argcnt); 4284 if (grabhist(modified, argcnt - 1) < 0) 4285 return (-1); 4286 else { 4287 modified = 0; 4288 hnum = argcnt - 1; 4289 } 4290 break; 4291 4292 case 'i': 4293 modified = 1; 4294 hnum = hlast; 4295 insert = INSERT; 4296 break; 4297 4298 case 'I': 4299 modified = 1; 4300 hnum = hlast; 4301 es->cursor = domove(1, "^", 1); 4302 insert = INSERT; 4303 break; 4304 4305 case 'j': 4306 case '+': 4307 case CTRL('n'): 4308 if (grabhist(modified, hnum + argcnt) < 0) 4309 return (-1); 4310 else { 4311 modified = 0; 4312 hnum += argcnt; 4313 } 4314 break; 4315 4316 case 'k': 4317 case '-': 4318 case CTRL('p'): 4319 if (grabhist(modified, hnum - argcnt) < 0) 4320 return (-1); 4321 else { 4322 modified = 0; 4323 hnum -= argcnt; 4324 } 4325 break; 4326 4327 case 'r': 4328 if (es->linelen == 0) 4329 return (-1); 4330 modified = 1; 4331 hnum = hlast; 4332 if (cmd[1] == 0) 4333 vi_error(); 4334 else { 4335 int n; 4336 4337 if (es->cursor + argcnt > es->linelen) 4338 return (-1); 4339 for (n = 0; n < argcnt; ++n) 4340 es->cbuf[es->cursor + n] = cmd[1]; 4341 es->cursor += n - 1; 4342 } 4343 break; 4344 4345 case 'R': 4346 modified = 1; 4347 hnum = hlast; 4348 insert = REPLACE; 4349 break; 4350 4351 case 's': 4352 if (es->linelen == 0) 4353 return (-1); 4354 modified = 1; 4355 hnum = hlast; 4356 if (es->cursor + argcnt > es->linelen) 4357 argcnt = es->linelen - es->cursor; 4358 del_range(es->cursor, es->cursor + argcnt); 4359 insert = INSERT; 4360 break; 4361 4362 case 'v': 4363 if (!argcnt) { 4364 if (es->linelen == 0) 4365 return (-1); 4366 if (modified) { 4367 es->cbuf[es->linelen] = '\0'; 4368 histsave(&source->line, es->cbuf, 4369 HIST_STORE, true); 4370 } else 4371 argcnt = source->line + 1 - 4372 (hlast - hnum); 4373 } 4374 if (argcnt) 4375 shf_snprintf(es->cbuf, es->cbufsize, "%s %d", 4376 "fc -e ${VISUAL:-${EDITOR:-vi}} --", 4377 argcnt); 4378 else 4379 strlcpy(es->cbuf, 4380 "fc -e ${VISUAL:-${EDITOR:-vi}} --", 4381 es->cbufsize); 4382 es->linelen = strlen(es->cbuf); 4383 return (2); 4384 4385 case 'x': 4386 if (es->linelen == 0) 4387 return (-1); 4388 modified = 1; 4389 hnum = hlast; 4390 if (es->cursor + argcnt > es->linelen) 4391 argcnt = es->linelen - es->cursor; 4392 yank_range(es->cursor, es->cursor + argcnt); 4393 del_range(es->cursor, es->cursor + argcnt); 4394 break; 4395 4396 case 'X': 4397 if (es->cursor > 0) { 4398 modified = 1; 4399 hnum = hlast; 4400 if (es->cursor < argcnt) 4401 argcnt = es->cursor; 4402 yank_range(es->cursor - argcnt, es->cursor); 4403 del_range(es->cursor - argcnt, es->cursor); 4404 es->cursor -= argcnt; 4405 } else 4406 return (-1); 4407 break; 4408 4409 case 'u': 4410 t = es; 4411 es = undo; 4412 undo = t; 4413 break; 4414 4415 case 'U': 4416 if (!modified) 4417 return (-1); 4418 if (grabhist(modified, ohnum) < 0) 4419 return (-1); 4420 modified = 0; 4421 hnum = ohnum; 4422 break; 4423 4424 case '?': 4425 if (hnum == hlast) 4426 hnum = -1; 4427 /* ahhh */ 4428 case '/': 4429 c3 = 1; 4430 srchlen = 0; 4431 lastsearch = *cmd; 4432 /* FALLTHROUGH */ 4433 case 'n': 4434 case 'N': 4435 if (lastsearch == ' ') 4436 return (-1); 4437 if (lastsearch == '?') 4438 c1 = 1; 4439 else 4440 c1 = 0; 4441 if (*cmd == 'N') 4442 c1 = !c1; 4443 if ((c2 = grabsearch(modified, hnum, 4444 c1, srchpat)) < 0) { 4445 if (c3) { 4446 restore_cbuf(); 4447 refresh(0); 4448 } 4449 return (-1); 4450 } else { 4451 modified = 0; 4452 hnum = c2; 4453 ohnum = hnum; 4454 } 4455 if (argcnt >= 2) { 4456 /* flag from cursor-up command */ 4457 es->cursor = argcnt - 2; 4458 return (0); 4459 } 4460 break; 4461 case '_': 4462 { 4463 bool inspace; 4464 char *p, *sp; 4465 4466 if (histnum(-1) < 0) 4467 return (-1); 4468 p = *histpos(); 4469 #define issp(c) (ksh_isspace(c) || (c) == '\n') 4470 if (argcnt) { 4471 while (*p && issp(*p)) 4472 p++; 4473 while (*p && --argcnt) { 4474 while (*p && !issp(*p)) 4475 p++; 4476 while (*p && issp(*p)) 4477 p++; 4478 } 4479 if (!*p) 4480 return (-1); 4481 sp = p; 4482 } else { 4483 sp = p; 4484 inspace = false; 4485 while (*p) { 4486 if (issp(*p)) 4487 inspace = true; 4488 else if (inspace) { 4489 inspace = false; 4490 sp = p; 4491 } 4492 p++; 4493 } 4494 p = sp; 4495 } 4496 modified = 1; 4497 hnum = hlast; 4498 if (es->cursor != es->linelen) 4499 es->cursor++; 4500 while (*p && !issp(*p)) { 4501 argcnt++; 4502 p++; 4503 } 4504 if (putbuf(" ", 1, false) != 0 || 4505 putbuf(sp, argcnt, false) != 0) { 4506 if (es->cursor != 0) 4507 es->cursor--; 4508 return (-1); 4509 } 4510 insert = INSERT; 4511 } 4512 break; 4513 4514 case '~': 4515 { 4516 char *p; 4517 int i; 4518 4519 if (es->linelen == 0) 4520 return (-1); 4521 for (i = 0; i < argcnt; i++) { 4522 p = &es->cbuf[es->cursor]; 4523 if (ksh_islower(*p)) { 4524 modified = 1; 4525 hnum = hlast; 4526 *p = ksh_toupper(*p); 4527 } else if (ksh_isupper(*p)) { 4528 modified = 1; 4529 hnum = hlast; 4530 *p = ksh_tolower(*p); 4531 } 4532 if (es->cursor < es->linelen - 1) 4533 es->cursor++; 4534 } 4535 break; 4536 } 4537 4538 case '#': 4539 { 4540 int ret = x_do_comment(es->cbuf, es->cbufsize, 4541 &es->linelen); 4542 if (ret >= 0) 4543 es->cursor = 0; 4544 return (ret); 4545 } 4546 4547 /* AT&T ksh */ 4548 case '=': 4549 /* Nonstandard vi/ksh */ 4550 case CTRL('e'): 4551 print_expansions(es, 1); 4552 break; 4553 4554 4555 /* Nonstandard vi/ksh */ 4556 case CTRL('i'): 4557 if (!Flag(FVITABCOMPLETE)) 4558 return (-1); 4559 complete_word(1, argcnt); 4560 break; 4561 4562 /* some annoying AT&T kshs */ 4563 case CTRL('['): 4564 if (!Flag(FVIESCCOMPLETE)) 4565 return (-1); 4566 /* AT&T ksh */ 4567 case '\\': 4568 /* Nonstandard vi/ksh */ 4569 case CTRL('f'): 4570 complete_word(1, argcnt); 4571 break; 4572 4573 4574 /* AT&T ksh */ 4575 case '*': 4576 /* Nonstandard vi/ksh */ 4577 case CTRL('x'): 4578 expand_word(1); 4579 break; 4580 4581 4582 /* mksh: cursor movement */ 4583 case '[': 4584 case 'O': 4585 state = VPREFIX2; 4586 if (es->linelen != 0) 4587 es->cursor++; 4588 insert = INSERT; 4589 return (0); 4590 } 4591 if (insert == 0 && es->cursor != 0 && es->cursor >= es->linelen) 4592 es->cursor--; 4593 } 4594 return (0); 4595 } 4596 4597 static int 4598 domove(int argcnt, const char *cmd, int sub) 4599 { 4600 int bcount, i = 0, t; 4601 int ncursor = 0; 4602 4603 switch (*cmd) { 4604 case 'b': 4605 if (!sub && es->cursor == 0) 4606 return (-1); 4607 ncursor = backword(argcnt); 4608 break; 4609 4610 case 'B': 4611 if (!sub && es->cursor == 0) 4612 return (-1); 4613 ncursor = Backword(argcnt); 4614 break; 4615 4616 case 'e': 4617 if (!sub && es->cursor + 1 >= es->linelen) 4618 return (-1); 4619 ncursor = endword(argcnt); 4620 if (sub && ncursor < es->linelen) 4621 ncursor++; 4622 break; 4623 4624 case 'E': 4625 if (!sub && es->cursor + 1 >= es->linelen) 4626 return (-1); 4627 ncursor = Endword(argcnt); 4628 if (sub && ncursor < es->linelen) 4629 ncursor++; 4630 break; 4631 4632 case 'f': 4633 case 'F': 4634 case 't': 4635 case 'T': 4636 fsavecmd = *cmd; 4637 fsavech = cmd[1]; 4638 /* drop through */ 4639 4640 case ',': 4641 case ';': 4642 if (fsavecmd == ' ') 4643 return (-1); 4644 i = fsavecmd == 'f' || fsavecmd == 'F'; 4645 t = fsavecmd > 'a'; 4646 if (*cmd == ',') 4647 t = !t; 4648 if ((ncursor = findch(fsavech, argcnt, tobool(t), 4649 tobool(i))) < 0) 4650 return (-1); 4651 if (sub && t) 4652 ncursor++; 4653 break; 4654 4655 case 'h': 4656 case CTRL('h'): 4657 if (!sub && es->cursor == 0) 4658 return (-1); 4659 ncursor = es->cursor - argcnt; 4660 if (ncursor < 0) 4661 ncursor = 0; 4662 break; 4663 4664 case ' ': 4665 case 'l': 4666 if (!sub && es->cursor + 1 >= es->linelen) 4667 return (-1); 4668 if (es->linelen != 0) { 4669 ncursor = es->cursor + argcnt; 4670 if (ncursor > es->linelen) 4671 ncursor = es->linelen; 4672 } 4673 break; 4674 4675 case 'w': 4676 if (!sub && es->cursor + 1 >= es->linelen) 4677 return (-1); 4678 ncursor = forwword(argcnt); 4679 break; 4680 4681 case 'W': 4682 if (!sub && es->cursor + 1 >= es->linelen) 4683 return (-1); 4684 ncursor = Forwword(argcnt); 4685 break; 4686 4687 case '0': 4688 ncursor = 0; 4689 break; 4690 4691 case '^': 4692 ncursor = 0; 4693 while (ncursor < es->linelen - 1 && 4694 ksh_isspace(es->cbuf[ncursor])) 4695 ncursor++; 4696 break; 4697 4698 case '|': 4699 ncursor = argcnt; 4700 if (ncursor > es->linelen) 4701 ncursor = es->linelen; 4702 if (ncursor) 4703 ncursor--; 4704 break; 4705 4706 case '$': 4707 if (es->linelen != 0) 4708 ncursor = es->linelen; 4709 else 4710 ncursor = 0; 4711 break; 4712 4713 case '%': 4714 ncursor = es->cursor; 4715 while (ncursor < es->linelen && 4716 (i = bracktype(es->cbuf[ncursor])) == 0) 4717 ncursor++; 4718 if (ncursor == es->linelen) 4719 return (-1); 4720 bcount = 1; 4721 do { 4722 if (i > 0) { 4723 if (++ncursor >= es->linelen) 4724 return (-1); 4725 } else { 4726 if (--ncursor < 0) 4727 return (-1); 4728 } 4729 t = bracktype(es->cbuf[ncursor]); 4730 if (t == i) 4731 bcount++; 4732 else if (t == -i) 4733 bcount--; 4734 } while (bcount != 0); 4735 if (sub && i > 0) 4736 ncursor++; 4737 break; 4738 4739 default: 4740 return (-1); 4741 } 4742 return (ncursor); 4743 } 4744 4745 static int 4746 redo_insert(int count) 4747 { 4748 while (count-- > 0) 4749 if (putbuf(ibuf, inslen, tobool(insert == REPLACE)) != 0) 4750 return (-1); 4751 if (es->cursor > 0) 4752 es->cursor--; 4753 insert = 0; 4754 return (0); 4755 } 4756 4757 static void 4758 yank_range(int a, int b) 4759 { 4760 yanklen = b - a; 4761 if (yanklen != 0) 4762 memmove(ybuf, &es->cbuf[a], yanklen); 4763 } 4764 4765 static int 4766 bracktype(int ch) 4767 { 4768 switch (ch) { 4769 4770 case '(': 4771 return (1); 4772 4773 case '[': 4774 return (2); 4775 4776 case '{': 4777 return (3); 4778 4779 case ')': 4780 return (-1); 4781 4782 case ']': 4783 return (-2); 4784 4785 case '}': 4786 return (-3); 4787 4788 default: 4789 return (0); 4790 } 4791 } 4792 4793 /* 4794 * Non user interface editor routines below here 4795 */ 4796 4797 static void 4798 save_cbuf(void) 4799 { 4800 memmove(holdbufp, es->cbuf, es->linelen); 4801 holdlen = es->linelen; 4802 holdbufp[holdlen] = '\0'; 4803 } 4804 4805 static void 4806 restore_cbuf(void) 4807 { 4808 es->cursor = 0; 4809 es->linelen = holdlen; 4810 memmove(es->cbuf, holdbufp, holdlen); 4811 } 4812 4813 /* return a new edstate */ 4814 static struct edstate * 4815 save_edstate(struct edstate *old) 4816 { 4817 struct edstate *news; 4818 4819 news = alloc(sizeof(struct edstate), AEDIT); 4820 news->cbuf = alloc(old->cbufsize, AEDIT); 4821 memcpy(news->cbuf, old->cbuf, old->linelen); 4822 news->cbufsize = old->cbufsize; 4823 news->linelen = old->linelen; 4824 news->cursor = old->cursor; 4825 news->winleft = old->winleft; 4826 return (news); 4827 } 4828 4829 static void 4830 restore_edstate(struct edstate *news, struct edstate *old) 4831 { 4832 memcpy(news->cbuf, old->cbuf, old->linelen); 4833 news->linelen = old->linelen; 4834 news->cursor = old->cursor; 4835 news->winleft = old->winleft; 4836 free_edstate(old); 4837 } 4838 4839 static void 4840 free_edstate(struct edstate *old) 4841 { 4842 afree(old->cbuf, AEDIT); 4843 afree(old, AEDIT); 4844 } 4845 4846 /* 4847 * this is used for calling x_escape() in complete_word() 4848 */ 4849 static int 4850 x_vi_putbuf(const char *s, size_t len) 4851 { 4852 return (putbuf(s, len, false)); 4853 } 4854 4855 static int 4856 putbuf(const char *buf, ssize_t len, bool repl) 4857 { 4858 if (len == 0) 4859 return (0); 4860 if (repl) { 4861 if (es->cursor + len >= es->cbufsize) 4862 return (-1); 4863 if (es->cursor + len > es->linelen) 4864 es->linelen = es->cursor + len; 4865 } else { 4866 if (es->linelen + len >= es->cbufsize) 4867 return (-1); 4868 memmove(&es->cbuf[es->cursor + len], &es->cbuf[es->cursor], 4869 es->linelen - es->cursor); 4870 es->linelen += len; 4871 } 4872 memmove(&es->cbuf[es->cursor], buf, len); 4873 es->cursor += len; 4874 return (0); 4875 } 4876 4877 static void 4878 del_range(int a, int b) 4879 { 4880 if (es->linelen != b) 4881 memmove(&es->cbuf[a], &es->cbuf[b], es->linelen - b); 4882 es->linelen -= b - a; 4883 } 4884 4885 static int 4886 findch(int ch, int cnt, bool forw, bool incl) 4887 { 4888 int ncursor; 4889 4890 if (es->linelen == 0) 4891 return (-1); 4892 ncursor = es->cursor; 4893 while (cnt--) { 4894 do { 4895 if (forw) { 4896 if (++ncursor == es->linelen) 4897 return (-1); 4898 } else { 4899 if (--ncursor < 0) 4900 return (-1); 4901 } 4902 } while (es->cbuf[ncursor] != ch); 4903 } 4904 if (!incl) { 4905 if (forw) 4906 ncursor--; 4907 else 4908 ncursor++; 4909 } 4910 return (ncursor); 4911 } 4912 4913 static int 4914 forwword(int argcnt) 4915 { 4916 int ncursor; 4917 4918 ncursor = es->cursor; 4919 while (ncursor < es->linelen && argcnt--) { 4920 if (ksh_isalnux(es->cbuf[ncursor])) 4921 while (ksh_isalnux(es->cbuf[ncursor]) && 4922 ncursor < es->linelen) 4923 ncursor++; 4924 else if (!ksh_isspace(es->cbuf[ncursor])) 4925 while (!ksh_isalnux(es->cbuf[ncursor]) && 4926 !ksh_isspace(es->cbuf[ncursor]) && 4927 ncursor < es->linelen) 4928 ncursor++; 4929 while (ksh_isspace(es->cbuf[ncursor]) && 4930 ncursor < es->linelen) 4931 ncursor++; 4932 } 4933 return (ncursor); 4934 } 4935 4936 static int 4937 backword(int argcnt) 4938 { 4939 int ncursor; 4940 4941 ncursor = es->cursor; 4942 while (ncursor > 0 && argcnt--) { 4943 while (--ncursor > 0 && ksh_isspace(es->cbuf[ncursor])) 4944 ; 4945 if (ncursor > 0) { 4946 if (ksh_isalnux(es->cbuf[ncursor])) 4947 while (--ncursor >= 0 && 4948 ksh_isalnux(es->cbuf[ncursor])) 4949 ; 4950 else 4951 while (--ncursor >= 0 && 4952 !ksh_isalnux(es->cbuf[ncursor]) && 4953 !ksh_isspace(es->cbuf[ncursor])) 4954 ; 4955 ncursor++; 4956 } 4957 } 4958 return (ncursor); 4959 } 4960 4961 static int 4962 endword(int argcnt) 4963 { 4964 int ncursor; 4965 4966 ncursor = es->cursor; 4967 while (ncursor < es->linelen && argcnt--) { 4968 while (++ncursor < es->linelen - 1 && 4969 ksh_isspace(es->cbuf[ncursor])) 4970 ; 4971 if (ncursor < es->linelen - 1) { 4972 if (ksh_isalnux(es->cbuf[ncursor])) 4973 while (++ncursor < es->linelen && 4974 ksh_isalnux(es->cbuf[ncursor])) 4975 ; 4976 else 4977 while (++ncursor < es->linelen && 4978 !ksh_isalnux(es->cbuf[ncursor]) && 4979 !ksh_isspace(es->cbuf[ncursor])) 4980 ; 4981 ncursor--; 4982 } 4983 } 4984 return (ncursor); 4985 } 4986 4987 static int 4988 Forwword(int argcnt) 4989 { 4990 int ncursor; 4991 4992 ncursor = es->cursor; 4993 while (ncursor < es->linelen && argcnt--) { 4994 while (!ksh_isspace(es->cbuf[ncursor]) && 4995 ncursor < es->linelen) 4996 ncursor++; 4997 while (ksh_isspace(es->cbuf[ncursor]) && 4998 ncursor < es->linelen) 4999 ncursor++; 5000 } 5001 return (ncursor); 5002 } 5003 5004 static int 5005 Backword(int argcnt) 5006 { 5007 int ncursor; 5008 5009 ncursor = es->cursor; 5010 while (ncursor > 0 && argcnt--) { 5011 while (--ncursor >= 0 && ksh_isspace(es->cbuf[ncursor])) 5012 ; 5013 while (ncursor >= 0 && !ksh_isspace(es->cbuf[ncursor])) 5014 ncursor--; 5015 ncursor++; 5016 } 5017 return (ncursor); 5018 } 5019 5020 static int 5021 Endword(int argcnt) 5022 { 5023 int ncursor; 5024 5025 ncursor = es->cursor; 5026 while (ncursor < es->linelen - 1 && argcnt--) { 5027 while (++ncursor < es->linelen - 1 && 5028 ksh_isspace(es->cbuf[ncursor])) 5029 ; 5030 if (ncursor < es->linelen - 1) { 5031 while (++ncursor < es->linelen && 5032 !ksh_isspace(es->cbuf[ncursor])) 5033 ; 5034 ncursor--; 5035 } 5036 } 5037 return (ncursor); 5038 } 5039 5040 static int 5041 grabhist(int save, int n) 5042 { 5043 char *hptr; 5044 5045 if (n < 0 || n > hlast) 5046 return (-1); 5047 if (n == hlast) { 5048 restore_cbuf(); 5049 ohnum = n; 5050 return (0); 5051 } 5052 (void)histnum(n); 5053 if ((hptr = *histpos()) == NULL) { 5054 internal_warningf("%s: %s", "grabhist", "bad history array"); 5055 return (-1); 5056 } 5057 if (save) 5058 save_cbuf(); 5059 if ((es->linelen = strlen(hptr)) >= es->cbufsize) 5060 es->linelen = es->cbufsize - 1; 5061 memmove(es->cbuf, hptr, es->linelen); 5062 es->cursor = 0; 5063 ohnum = n; 5064 return (0); 5065 } 5066 5067 static int 5068 grabsearch(int save, int start, int fwd, const char *pat) 5069 { 5070 char *hptr; 5071 int hist; 5072 bool anchored; 5073 5074 if ((start == 0 && fwd == 0) || (start >= hlast - 1 && fwd == 1)) 5075 return (-1); 5076 if (fwd) 5077 start++; 5078 else 5079 start--; 5080 anchored = *pat == '^' ? (++pat, true) : false; 5081 if ((hist = findhist(start, fwd, pat, anchored)) < 0) { 5082 /* (start != 0 && fwd && match(holdbufp, pat) >= 0) */ 5083 if (start != 0 && fwd && strcmp(holdbufp, pat) >= 0) { 5084 restore_cbuf(); 5085 return (0); 5086 } else 5087 return (-1); 5088 } 5089 if (save) 5090 save_cbuf(); 5091 histnum(hist); 5092 hptr = *histpos(); 5093 if ((es->linelen = strlen(hptr)) >= es->cbufsize) 5094 es->linelen = es->cbufsize - 1; 5095 memmove(es->cbuf, hptr, es->linelen); 5096 es->cursor = 0; 5097 return (hist); 5098 } 5099 5100 static void 5101 redraw_line(bool newl) 5102 { 5103 if (wbuf_len) 5104 memset(wbuf[win], ' ', wbuf_len); 5105 if (newl) { 5106 x_putc('\r'); 5107 x_putc('\n'); 5108 } 5109 if (prompt_trunc != -1) 5110 pprompt(prompt, prompt_trunc); 5111 x_col = pwidth; 5112 morec = ' '; 5113 } 5114 5115 static void 5116 refresh(int leftside) 5117 { 5118 if (leftside < 0) 5119 leftside = lastref; 5120 else 5121 lastref = leftside; 5122 if (outofwin()) 5123 rewindow(); 5124 display(wbuf[1 - win], wbuf[win], leftside); 5125 win = 1 - win; 5126 } 5127 5128 static int 5129 outofwin(void) 5130 { 5131 int cur, col; 5132 5133 if (es->cursor < es->winleft) 5134 return (1); 5135 col = 0; 5136 cur = es->winleft; 5137 while (cur < es->cursor) 5138 col = newcol((unsigned char)es->cbuf[cur++], col); 5139 if (col >= winwidth) 5140 return (1); 5141 return (0); 5142 } 5143 5144 static void 5145 rewindow(void) 5146 { 5147 int tcur, tcol; 5148 int holdcur1, holdcol1; 5149 int holdcur2, holdcol2; 5150 5151 holdcur1 = holdcur2 = tcur = 0; 5152 holdcol1 = holdcol2 = tcol = 0; 5153 while (tcur < es->cursor) { 5154 if (tcol - holdcol2 > winwidth / 2) { 5155 holdcur1 = holdcur2; 5156 holdcol1 = holdcol2; 5157 holdcur2 = tcur; 5158 holdcol2 = tcol; 5159 } 5160 tcol = newcol((unsigned char)es->cbuf[tcur++], tcol); 5161 } 5162 while (tcol - holdcol1 > winwidth / 2) 5163 holdcol1 = newcol((unsigned char)es->cbuf[holdcur1++], 5164 holdcol1); 5165 es->winleft = holdcur1; 5166 } 5167 5168 static int 5169 newcol(unsigned char ch, int col) 5170 { 5171 if (ch == '\t') 5172 return ((col | 7) + 1); 5173 return (col + char_len(ch)); 5174 } 5175 5176 static void 5177 display(char *wb1, char *wb2, int leftside) 5178 { 5179 unsigned char ch; 5180 char *twb1, *twb2, mc; 5181 int cur, col, cnt; 5182 int ncol = 0; 5183 int moreright; 5184 5185 col = 0; 5186 cur = es->winleft; 5187 moreright = 0; 5188 twb1 = wb1; 5189 while (col < winwidth && cur < es->linelen) { 5190 if (cur == es->cursor && leftside) 5191 ncol = col + pwidth; 5192 if ((ch = es->cbuf[cur]) == '\t') 5193 do { 5194 *twb1++ = ' '; 5195 } while (++col < winwidth && (col & 7) != 0); 5196 else if (col < winwidth) { 5197 if (ISCTRL(ch) && /* but not C1 */ ch < 0x80) { 5198 *twb1++ = '^'; 5199 if (++col < winwidth) { 5200 *twb1++ = UNCTRL(ch); 5201 col++; 5202 } 5203 } else { 5204 *twb1++ = ch; 5205 col++; 5206 } 5207 } 5208 if (cur == es->cursor && !leftside) 5209 ncol = col + pwidth - 1; 5210 cur++; 5211 } 5212 if (cur == es->cursor) 5213 ncol = col + pwidth; 5214 if (col < winwidth) { 5215 while (col < winwidth) { 5216 *twb1++ = ' '; 5217 col++; 5218 } 5219 } else 5220 moreright++; 5221 *twb1 = ' '; 5222 5223 col = pwidth; 5224 cnt = winwidth; 5225 twb1 = wb1; 5226 twb2 = wb2; 5227 while (cnt--) { 5228 if (*twb1 != *twb2) { 5229 if (x_col != col) 5230 ed_mov_opt(col, wb1); 5231 x_putc(*twb1); 5232 x_col++; 5233 } 5234 twb1++; 5235 twb2++; 5236 col++; 5237 } 5238 if (es->winleft > 0 && moreright) 5239 /* 5240 * POSIX says to use * for this but that is a globbing 5241 * character and may confuse people; + is more innocuous 5242 */ 5243 mc = '+'; 5244 else if (es->winleft > 0) 5245 mc = '<'; 5246 else if (moreright) 5247 mc = '>'; 5248 else 5249 mc = ' '; 5250 if (mc != morec) { 5251 ed_mov_opt(pwidth + winwidth + 1, wb1); 5252 x_putc(mc); 5253 x_col++; 5254 morec = mc; 5255 } 5256 if (x_col != ncol) 5257 ed_mov_opt(ncol, wb1); 5258 } 5259 5260 static void 5261 ed_mov_opt(int col, char *wb) 5262 { 5263 if (col < x_col) { 5264 if (col + 1 < x_col - col) { 5265 x_putc('\r'); 5266 if (prompt_trunc != -1) 5267 pprompt(prompt, prompt_trunc); 5268 x_col = pwidth; 5269 while (x_col++ < col) 5270 x_putcf(*wb++); 5271 } else { 5272 while (x_col-- > col) 5273 x_putc('\b'); 5274 } 5275 } else { 5276 wb = &wb[x_col - pwidth]; 5277 while (x_col++ < col) 5278 x_putcf(*wb++); 5279 } 5280 x_col = col; 5281 } 5282 5283 5284 /* replace word with all expansions (ie, expand word*) */ 5285 static int 5286 expand_word(int cmd) 5287 { 5288 static struct edstate *buf; 5289 int rval = 0, nwords, start, end, i; 5290 char **words; 5291 5292 /* Undo previous expansion */ 5293 if (cmd == 0 && expanded == EXPAND && buf) { 5294 restore_edstate(es, buf); 5295 buf = 0; 5296 expanded = NONE; 5297 return (0); 5298 } 5299 if (buf) { 5300 free_edstate(buf); 5301 buf = 0; 5302 } 5303 5304 i = XCF_COMMAND_FILE | XCF_FULLPATH; 5305 nwords = x_cf_glob(&i, es->cbuf, es->linelen, es->cursor, 5306 &start, &end, &words); 5307 if (nwords == 0) { 5308 vi_error(); 5309 return (-1); 5310 } 5311 5312 buf = save_edstate(es); 5313 expanded = EXPAND; 5314 del_range(start, end); 5315 es->cursor = start; 5316 i = 0; 5317 while (i < nwords) { 5318 if (x_escape(words[i], strlen(words[i]), x_vi_putbuf) != 0) { 5319 rval = -1; 5320 break; 5321 } 5322 if (++i < nwords && putbuf(" ", 1, false) != 0) { 5323 rval = -1; 5324 break; 5325 } 5326 } 5327 i = buf->cursor - end; 5328 if (rval == 0 && i > 0) 5329 es->cursor += i; 5330 modified = 1; 5331 hnum = hlast; 5332 insert = INSERT; 5333 lastac = 0; 5334 refresh(0); 5335 return (rval); 5336 } 5337 5338 static int 5339 complete_word(int cmd, int count) 5340 { 5341 static struct edstate *buf; 5342 int rval, nwords, start, end, flags; 5343 size_t match_len; 5344 char **words; 5345 char *match; 5346 bool is_unique; 5347 5348 /* Undo previous completion */ 5349 if (cmd == 0 && expanded == COMPLETE && buf) { 5350 print_expansions(buf, 0); 5351 expanded = PRINT; 5352 return (0); 5353 } 5354 if (cmd == 0 && expanded == PRINT && buf) { 5355 restore_edstate(es, buf); 5356 buf = 0; 5357 expanded = NONE; 5358 return (0); 5359 } 5360 if (buf) { 5361 free_edstate(buf); 5362 buf = 0; 5363 } 5364 5365 /* 5366 * XCF_FULLPATH for count 'cause the menu printed by 5367 * print_expansions() was done this way. 5368 */ 5369 flags = XCF_COMMAND_FILE; 5370 if (count) 5371 flags |= XCF_FULLPATH; 5372 nwords = x_cf_glob(&flags, es->cbuf, es->linelen, es->cursor, 5373 &start, &end, &words); 5374 if (nwords == 0) { 5375 vi_error(); 5376 return (-1); 5377 } 5378 if (count) { 5379 int i; 5380 5381 count--; 5382 if (count >= nwords) { 5383 vi_error(); 5384 x_print_expansions(nwords, words, 5385 tobool(flags & XCF_IS_COMMAND)); 5386 x_free_words(nwords, words); 5387 redraw_line(false); 5388 return (-1); 5389 } 5390 /* 5391 * Expand the count'th word to its basename 5392 */ 5393 if (flags & XCF_IS_COMMAND) { 5394 match = words[count] + 5395 x_basename(words[count], NULL); 5396 /* If more than one possible match, use full path */ 5397 for (i = 0; i < nwords; i++) 5398 if (i != count && 5399 strcmp(words[i] + x_basename(words[i], 5400 NULL), match) == 0) { 5401 match = words[count]; 5402 break; 5403 } 5404 } else 5405 match = words[count]; 5406 match_len = strlen(match); 5407 is_unique = true; 5408 /* expanded = PRINT; next call undo */ 5409 } else { 5410 match = words[0]; 5411 match_len = x_longest_prefix(nwords, words); 5412 /* next call will list completions */ 5413 expanded = COMPLETE; 5414 is_unique = nwords == 1; 5415 } 5416 5417 buf = save_edstate(es); 5418 del_range(start, end); 5419 es->cursor = start; 5420 5421 /* 5422 * escape all shell-sensitive characters and put the result into 5423 * command buffer 5424 */ 5425 rval = x_escape(match, match_len, x_vi_putbuf); 5426 5427 if (rval == 0 && is_unique) { 5428 /* 5429 * If exact match, don't undo. Allows directory completions 5430 * to be used (ie, complete the next portion of the path). 5431 */ 5432 expanded = NONE; 5433 5434 /* 5435 * append a space if this is a non-directory match 5436 * and not a parameter or homedir substitution 5437 */ 5438 if (match_len > 0 && match[match_len - 1] != '/' && 5439 !(flags & XCF_IS_NOSPACE)) 5440 rval = putbuf(" ", 1, false); 5441 } 5442 x_free_words(nwords, words); 5443 5444 modified = 1; 5445 hnum = hlast; 5446 insert = INSERT; 5447 /* prevent this from being redone... */ 5448 lastac = 0; 5449 refresh(0); 5450 5451 return (rval); 5452 } 5453 5454 static int 5455 print_expansions(struct edstate *est, int cmd MKSH_A_UNUSED) 5456 { 5457 int start, end, nwords, i; 5458 char **words; 5459 5460 i = XCF_COMMAND_FILE | XCF_FULLPATH; 5461 nwords = x_cf_glob(&i, est->cbuf, est->linelen, est->cursor, 5462 &start, &end, &words); 5463 if (nwords == 0) { 5464 vi_error(); 5465 return (-1); 5466 } 5467 x_print_expansions(nwords, words, tobool(i & XCF_IS_COMMAND)); 5468 x_free_words(nwords, words); 5469 redraw_line(false); 5470 return (0); 5471 } 5472 5473 /* Similar to x_zotc(emacs.c), but no tab weirdness */ 5474 static void 5475 x_vi_zotc(int c) 5476 { 5477 if (ISCTRL(c)) { 5478 x_putc('^'); 5479 c = UNCTRL(c); 5480 } 5481 x_putc(c); 5482 } 5483 5484 static void 5485 vi_error(void) 5486 { 5487 /* Beem out of any macros as soon as an error occurs */ 5488 vi_macro_reset(); 5489 x_putc(7); 5490 x_flush(); 5491 } 5492 5493 static void 5494 vi_macro_reset(void) 5495 { 5496 if (macro.p) { 5497 afree(macro.buf, AEDIT); 5498 memset((char *)¯o, 0, sizeof(macro)); 5499 } 5500 } 5501 #endif /* !MKSH_S_NOVI */ 5502 5503 /* called from main.c */ 5504 void 5505 x_init(void) 5506 { 5507 int i, j; 5508 5509 /* 5510 * Set edchars to -2 to force initial binding, except 5511 * we need default values for some deficient systems 5512 */ 5513 edchars.erase = edchars.kill = edchars.intr = edchars.quit = 5514 edchars.eof = -2; 5515 /* ^W */ 5516 edchars.werase = 027; 5517 5518 /* command line editing specific memory allocation */ 5519 ainit(AEDIT); 5520 holdbufp = alloc(LINE, AEDIT); 5521 5522 /* initialise Emacs command line editing mode */ 5523 x_nextcmd = -1; 5524 5525 x_tab = alloc2(X_NTABS, sizeof(*x_tab), AEDIT); 5526 for (j = 0; j < X_TABSZ; j++) 5527 x_tab[0][j] = XFUNC_insert; 5528 for (i = 1; i < X_NTABS; i++) 5529 for (j = 0; j < X_TABSZ; j++) 5530 x_tab[i][j] = XFUNC_error; 5531 for (i = 0; i < (int)NELEM(x_defbindings); i++) 5532 x_tab[x_defbindings[i].xdb_tab][x_defbindings[i].xdb_char] 5533 = x_defbindings[i].xdb_func; 5534 5535 #ifndef MKSH_SMALL 5536 x_atab = alloc2(X_NTABS, sizeof(*x_atab), AEDIT); 5537 for (i = 1; i < X_NTABS; i++) 5538 for (j = 0; j < X_TABSZ; j++) 5539 x_atab[i][j] = NULL; 5540 #endif 5541 } 5542 5543 #ifdef DEBUG_LEAKS 5544 void 5545 x_done(void) 5546 { 5547 if (x_tab != NULL) 5548 afreeall(AEDIT); 5549 } 5550 #endif 5551 #endif /* !MKSH_NO_CMDLINE_EDITING */ 5552
