1 /* $NetBSD: emacs.c,v 1.38 2018/05/08 16:37:59 kamil Exp $ */ 2 3 /* 4 * Emacs-like command line editing and history 5 * 6 * created by Ron Natalie at BRL 7 * modified by Doug Kingston, Doug Gwyn, and Lou Salkind 8 * adapted to PD ksh by Eric Gisin 9 */ 10 #include <sys/cdefs.h> 11 12 #ifndef lint 13 __RCSID("$NetBSD: emacs.c,v 1.38 2018/05/08 16:37:59 kamil Exp $"); 14 #endif 15 16 #include "config.h" 17 #ifdef EMACS 18 19 #include <sys/stat.h> 20 #include <ctype.h> 21 #include <locale.h> 22 #include <stdbool.h> 23 24 #include "sh.h" 25 #include "ksh_dir.h" 26 #include "edit.h" 27 28 static Area aedit; 29 #define AEDIT &aedit /* area for kill ring and macro defns */ 30 31 #undef CTRL /* _BSD brain damage */ 32 #define CTRL(x) ((x) == '?' ? 0x7F : (x) & 0x1F) /* ASCII */ 33 #define UNCTRL(x) ((x) == 0x7F ? '?' : (x) | 0x40) /* ASCII */ 34 #define META(x) ((x) & 0x7f) 35 #define ISMETA(x) (Flag(FEMACSUSEMETA) && ((x) & 0x80)) 36 37 38 /* values returned by keyboard functions */ 39 #define KSTD 0 40 #define KEOL 1 /* ^M, ^J */ 41 #define KINTR 2 /* ^G, ^C */ 42 43 struct x_ftab { 44 int (*xf_func) ARGS((int c)); 45 const char *xf_name; 46 short xf_flags; 47 }; 48 49 /* index into struct x_ftab x_ftab[] - small is good */ 50 typedef unsigned char Findex; 51 52 struct x_defbindings { 53 Findex xdb_func; /* XFUNC_* */ 54 unsigned char xdb_tab; 55 unsigned char xdb_char; 56 }; 57 58 #define XF_ARG 1 /* command takes number prefix */ 59 #define XF_NOBIND 2 /* not allowed to bind to function */ 60 #define XF_PREFIX 4 /* function sets prefix */ 61 62 /* Separator for completion */ 63 #define is_cfs(c) (c == ' ' || c == '\t' || c == '"' || c == '\'') 64 #define is_mfs(c) (!(isalnum((unsigned char)c) || c == '_' || c == '$')) /* Separator for motion */ 65 66 # define CHARMASK 0xFF /* 8-bit character mask */ 67 # define X_NTABS 3 /* normal, meta1, meta2 */ 68 #define X_TABSZ (CHARMASK+1) /* size of keydef tables etc */ 69 70 /* Arguments for do_complete() 71 * 0 = enumerate M-= complete as much as possible and then list 72 * 1 = complete M-Esc 73 * 2 = list M-? 74 */ 75 typedef enum { CT_LIST, /* list the possible completions */ 76 CT_COMPLETE, /* complete to longest prefix */ 77 CT_COMPLIST /* complete and then list (if non-exact) */ 78 } Comp_type; 79 80 /* { from 4.9 edit.h */ 81 /* 82 * The following are used for my horizontal scrolling stuff 83 */ 84 static char *xbuf; /* beg input buffer */ 85 static char *xend; /* end input buffer */ 86 static char *xcp; /* current position */ 87 static char *xep; /* current end */ 88 static char *xbp; /* start of visible portion of input buffer */ 89 static char *xlp; /* last char visible on screen */ 90 static int x_adj_ok; 91 /* 92 * we use x_adj_done so that functions can tell 93 * whether x_adjust() has been called while they are active. 94 */ 95 static int x_adj_done; 96 97 static int xx_cols; 98 static int x_col; 99 static int x_displen; 100 static int x_arg; /* general purpose arg */ 101 static int x_arg_defaulted;/* x_arg not explicitly set; defaulted to 1 */ 102 103 static int xlp_valid; 104 /* end from 4.9 edit.h } */ 105 106 static int x_prefix1 = CTRL('['), x_prefix2 = CTRL('X'); 107 static char **x_histp; /* history position */ 108 static int x_nextcmd; /* for newline-and-next */ 109 static char *xmp; /* mark pointer */ 110 static Findex x_last_command; 111 static Findex (*x_tab)[X_TABSZ]; /* key definition */ 112 static char *(*x_atab)[X_TABSZ]; /* macro definitions */ 113 static unsigned char x_bound[(X_TABSZ * X_NTABS + 7) / 8]; 114 #define KILLSIZE 20 115 static char *killstack[KILLSIZE]; 116 static int killsp, killtp; 117 static int x_curprefix; 118 static char *macroptr; 119 static int prompt_trunc; 120 static int prompt_skip; 121 122 static int x_ins ARGS((char *cp)); 123 static void x_delete ARGS((int nc, int push)); 124 static int x_bword ARGS((void)); 125 static int x_fword ARGS((void)); 126 static void x_goto ARGS((char *cp)); 127 static void x_bs ARGS((int c)); 128 static int x_size_str ARGS((char *cp)); 129 static int x_size ARGS((int c)); 130 static void x_zots ARGS((char *str)); 131 static void x_zotc ARGS((int c)); 132 static void x_load_hist ARGS((char **hp)); 133 static int x_search ARGS((char *pat, int sameline, int offset)); 134 static int x_match ARGS((char *str, char *pat)); 135 static void x_redraw ARGS((int limit)); 136 static void x_push ARGS((int nchars)); 137 static char * x_mapin ARGS((const char *cp, Area *area)); 138 static char * x_mapout ARGS((int c)); 139 static void x_print ARGS((int prefix, int key)); 140 static void x_adjust ARGS((void)); 141 static void x_e_ungetc ARGS((int c)); 142 static int x_e_getc ARGS((void)); 143 static void x_e_putc ARGS((int c)); 144 static void x_e_puts ARGS((const char *s)); 145 static int x_comment ARGS((int c)); 146 static int x_fold_case ARGS((int c)); 147 static char *x_lastcp ARGS((void)); 148 static void do_complete ARGS((int flags, Comp_type type)); 149 static int x_emacs_putbuf ARGS((const char *s, size_t len)); 150 151 152 /* The lines between START-FUNC-TAB .. END-FUNC-TAB are run through a 153 * script (emacs-gen.sh) that generates emacs.out which contains: 154 * - function declarations for x_* functions 155 * - defines of the form XFUNC_<name> where <name> is function 156 * name, sans leading x_. 157 * Note that the script treats #ifdef and { 0, 0, 0} specially - use with 158 * caution. 159 */ 160 #include "emacs.out" 161 static const struct x_ftab x_ftab[] = { 162 /* @START-FUNC-TAB@ */ 163 { x_abort, "abort", 0 }, 164 { x_beg_hist, "beginning-of-history", 0 }, 165 { x_comp_comm, "complete-command", 0 }, 166 { x_comp_file, "complete-file", 0 }, 167 { x_complete, "complete", 0 }, 168 { x_del_back, "delete-char-backward", XF_ARG }, 169 { x_del_bword, "delete-word-backward", XF_ARG }, 170 { x_del_char, "delete-char-forward", XF_ARG }, 171 { x_del_fword, "delete-word-forward", XF_ARG }, 172 { x_del_line, "kill-line", 0 }, 173 { x_draw_line, "redraw", 0 }, 174 { x_end_hist, "end-of-history", 0 }, 175 { x_end_of_text, "eot", 0 }, 176 { x_enumerate, "list", 0 }, 177 { x_eot_del, "eot-or-delete", XF_ARG }, 178 { x_error, "error", 0 }, 179 { x_goto_hist, "goto-history", XF_ARG }, 180 { x_ins_string, "macro-string", XF_NOBIND }, 181 { x_insert, "auto-insert", XF_ARG }, 182 { x_kill, "kill-to-eol", XF_ARG }, 183 { x_kill_region, "kill-region", 0 }, 184 { x_list_comm, "list-command", 0 }, 185 { x_list_file, "list-file", 0 }, 186 { x_literal, "quote", 0 }, 187 { x_meta1, "prefix-1", XF_PREFIX }, 188 { x_meta2, "prefix-2", XF_PREFIX }, 189 { x_meta_yank, "yank-pop", 0 }, 190 { x_mv_back, "backward-char", XF_ARG }, 191 { x_mv_begin, "beginning-of-line", 0 }, 192 { x_mv_bword, "backward-word", XF_ARG }, 193 { x_mv_end, "end-of-line", 0 }, 194 { x_mv_forw, "forward-char", XF_ARG }, 195 { x_mv_fword, "forward-word", XF_ARG }, 196 { x_newline, "newline", 0 }, 197 { x_next_com, "down-history", XF_ARG }, 198 { x_nl_next_com, "newline-and-next", 0 }, 199 { x_noop, "no-op", 0 }, 200 { x_prev_com, "up-history", XF_ARG }, 201 { x_prev_histword, "prev-hist-word", XF_ARG }, 202 { x_search_char_forw, "search-character-forward", XF_ARG }, 203 { x_search_char_back, "search-character-backward", XF_ARG }, 204 { x_search_hist, "search-history", 0 }, 205 { x_set_mark, "set-mark-command", 0 }, 206 { x_stuff, "stuff", 0 }, 207 { x_stuffreset, "stuff-reset", 0 }, 208 { x_transpose, "transpose-chars", 0 }, 209 { x_version, "version", 0 }, 210 { x_xchg_point_mark, "exchange-point-and-mark", 0 }, 211 { x_yank, "yank", 0 }, 212 { x_comp_list, "complete-list", 0 }, 213 { x_expand, "expand-file", 0 }, 214 { x_fold_capitalize, "capitalize-word", XF_ARG }, 215 { x_fold_lower, "downcase-word", XF_ARG }, 216 { x_fold_upper, "upcase-word", XF_ARG }, 217 { x_set_arg, "set-arg", XF_NOBIND }, 218 { x_comment, "comment", 0 }, 219 #ifdef SILLY 220 { x_game_of_life, "play-game-of-life", 0 }, 221 #else 222 { 0, 0, 0 }, 223 #endif 224 #ifdef DEBUG 225 { x_debug_info, "debug-info", 0 }, 226 #else 227 { 0, 0, 0 }, 228 { 0, 0, 0 }, 229 #endif 230 /* @END-FUNC-TAB@ */ 231 }; 232 233 static struct x_defbindings const x_defbindings[] = { 234 { XFUNC_del_back, 0, CTRL('?') }, 235 { XFUNC_del_bword, 1, CTRL('?') }, 236 { XFUNC_eot_del, 0, CTRL('D') }, 237 { XFUNC_del_back, 0, CTRL('H') }, 238 { XFUNC_del_bword, 1, CTRL('H') }, 239 { XFUNC_del_bword, 1, 'h' }, 240 { XFUNC_mv_bword, 1, 'b' }, 241 { XFUNC_mv_fword, 1, 'f' }, 242 { XFUNC_del_fword, 1, 'd' }, 243 { XFUNC_mv_back, 0, CTRL('B') }, 244 { XFUNC_mv_forw, 0, CTRL('F') }, 245 { XFUNC_search_char_forw, 0, CTRL(']') }, 246 { XFUNC_search_char_back, 1, CTRL(']') }, 247 { XFUNC_newline, 0, CTRL('M') }, 248 { XFUNC_newline, 0, CTRL('J') }, 249 { XFUNC_end_of_text, 0, CTRL('_') }, 250 { XFUNC_abort, 0, CTRL('G') }, 251 { XFUNC_prev_com, 0, CTRL('P') }, 252 { XFUNC_next_com, 0, CTRL('N') }, 253 { XFUNC_nl_next_com, 0, CTRL('O') }, 254 { XFUNC_search_hist, 0, CTRL('R') }, 255 { XFUNC_beg_hist, 1, '<' }, 256 { XFUNC_end_hist, 1, '>' }, 257 { XFUNC_goto_hist, 1, 'g' }, 258 { XFUNC_mv_end, 0, CTRL('E') }, 259 { XFUNC_mv_begin, 0, CTRL('A') }, 260 { XFUNC_draw_line, 0, CTRL('L') }, 261 { XFUNC_meta1, 0, CTRL('[') }, 262 { XFUNC_meta2, 0, CTRL('X') }, 263 { XFUNC_kill, 0, CTRL('K') }, 264 { XFUNC_yank, 0, CTRL('Y') }, 265 { XFUNC_meta_yank, 1, 'y' }, 266 { XFUNC_literal, 0, CTRL('^') }, 267 { XFUNC_comment, 1, '#' }, 268 #if defined(BRL) && defined(TIOCSTI) 269 { XFUNC_stuff, 0, CTRL('T') }, 270 #else 271 { XFUNC_transpose, 0, CTRL('T') }, 272 #endif 273 { XFUNC_complete, 1, CTRL('[') }, 274 { XFUNC_comp_list, 0, CTRL('I') }, 275 { XFUNC_comp_list, 1, '=' }, 276 { XFUNC_enumerate, 1, '?' }, 277 { XFUNC_expand, 1, '*' }, 278 { XFUNC_comp_file, 1, CTRL('X') }, 279 { XFUNC_comp_comm, 2, CTRL('[') }, 280 { XFUNC_list_comm, 2, '?' }, 281 { XFUNC_list_file, 2, CTRL('Y') }, 282 { XFUNC_set_mark, 1, ' ' }, 283 { XFUNC_kill_region, 0, CTRL('W') }, 284 { XFUNC_xchg_point_mark, 2, CTRL('X') }, 285 { XFUNC_version, 0, CTRL('V') }, 286 #ifdef DEBUG 287 { XFUNC_debug_info, 1, CTRL('H') }, 288 #endif 289 { XFUNC_prev_histword, 1, '.' }, 290 { XFUNC_prev_histword, 1, '_' }, 291 { XFUNC_set_arg, 1, '0' }, 292 { XFUNC_set_arg, 1, '1' }, 293 { XFUNC_set_arg, 1, '2' }, 294 { XFUNC_set_arg, 1, '3' }, 295 { XFUNC_set_arg, 1, '4' }, 296 { XFUNC_set_arg, 1, '5' }, 297 { XFUNC_set_arg, 1, '6' }, 298 { XFUNC_set_arg, 1, '7' }, 299 { XFUNC_set_arg, 1, '8' }, 300 { XFUNC_set_arg, 1, '9' }, 301 { XFUNC_fold_upper, 1, 'U' }, 302 { XFUNC_fold_upper, 1, 'u' }, 303 { XFUNC_fold_lower, 1, 'L' }, 304 { XFUNC_fold_lower, 1, 'l' }, 305 { XFUNC_fold_capitalize, 1, 'C' }, 306 { XFUNC_fold_capitalize, 1, 'c' }, 307 /* These for ansi arrow keys: arguablely shouldn't be here by 308 * default, but its simpler/faster/smaller than using termcap 309 * entries. 310 */ 311 { XFUNC_meta2, 1, '[' }, 312 { XFUNC_meta2, 1, 'O' }, 313 { XFUNC_prev_com, 2, 'A' }, 314 { XFUNC_next_com, 2, 'B' }, 315 { XFUNC_mv_forw, 2, 'C' }, 316 { XFUNC_mv_back, 2, 'D' }, 317 }; 318 319 int 320 x_emacs(buf, len) 321 char *buf; 322 size_t len; 323 { 324 int c; 325 const char *p; 326 int i; 327 Findex f; 328 329 xbp = xbuf = buf; xend = buf + len; 330 xlp = xcp = xep = buf; 331 *xcp = 0; 332 xlp_valid = true; 333 xmp = NULL; 334 x_curprefix = 0; 335 macroptr = (char *) 0; 336 x_histp = histptr + 1; 337 x_last_command = XFUNC_error; 338 339 xx_cols = x_cols; 340 x_col = promptlen(prompt, &p); 341 prompt_skip = p - prompt; 342 prompt_trunc = x_col - (x_cols - 3 - MIN_EDIT_SPACE); 343 if (prompt_trunc > 0) 344 x_col -= prompt_trunc; 345 else 346 prompt_trunc = 0; 347 x_adj_ok = 1; 348 x_displen = xx_cols - 2 - x_col; 349 x_adj_done = 0; 350 351 pprompt(prompt, prompt_trunc); 352 353 if (x_nextcmd >= 0) { 354 int off = source->line - x_nextcmd; 355 if (histptr - histlist >= off) 356 x_load_hist(histptr - off); 357 x_nextcmd = -1; 358 } 359 360 while (1) { 361 x_flush(); 362 if ((c = x_e_getc()) < 0) 363 return 0; 364 365 if (ISMETA(c)) { 366 c = META(c); 367 x_curprefix = 1; 368 } 369 370 f = x_curprefix == -1 ? XFUNC_insert 371 : x_tab[x_curprefix][c&CHARMASK]; 372 373 if (!(x_ftab[f].xf_flags & XF_PREFIX) 374 && x_last_command != XFUNC_set_arg) 375 { 376 x_arg = 1; 377 x_arg_defaulted = 1; 378 } 379 i = c | (x_curprefix << 8); 380 x_curprefix = 0; 381 switch (i = (*x_ftab[f].xf_func)(i)) { 382 case KSTD: 383 if (!(x_ftab[f].xf_flags & XF_PREFIX)) 384 x_last_command = f; 385 break; 386 case KEOL: 387 i = xep - xbuf; 388 return i; 389 case KINTR: /* special case for interrupt */ 390 trapsig(SIGINT); 391 x_mode(false); 392 unwind(LSHELL); 393 } 394 } 395 } 396 397 static int 398 x_insert(c) 399 int c; 400 { 401 char str[2]; 402 403 /* 404 * Should allow tab and control chars. 405 */ 406 if (c == 0) { 407 x_e_putc(BEL); 408 return KSTD; 409 } 410 str[0] = c; 411 str[1] = '\0'; 412 while (x_arg--) 413 x_ins(str); 414 return KSTD; 415 } 416 417 static int 418 x_ins_string(c) 419 int c; 420 { 421 if (macroptr) { 422 x_e_putc(BEL); 423 return KSTD; 424 } 425 macroptr = x_atab[c>>8][c & CHARMASK]; 426 if (macroptr && !*macroptr) { 427 /* XXX bell? */ 428 macroptr = (char *) 0; 429 } 430 return KSTD; 431 } 432 433 static int x_do_ins(const char *cp, int len); 434 435 static int 436 x_do_ins(cp, len) 437 const char *cp; 438 int len; 439 { 440 if (xep+len >= xend) { 441 x_e_putc(BEL); 442 return -1; 443 } 444 445 memmove(xcp+len, xcp, xep - xcp + 1); 446 memmove(xcp, cp, len); 447 xcp += len; 448 xep += len; 449 return 0; 450 } 451 452 static int 453 x_ins(s) 454 char *s; 455 { 456 char *cp = xcp; 457 int adj = x_adj_done; 458 459 if (x_do_ins(s, strlen(s)) < 0) 460 return -1; 461 /* 462 * x_zots() may result in a call to x_adjust() 463 * we want xcp to reflect the new position. 464 */ 465 xlp_valid = false; 466 x_lastcp(); 467 x_adj_ok = (xcp >= xlp); 468 x_zots(cp); 469 if (adj == x_adj_done) /* has x_adjust() been called? */ 470 { 471 /* no */ 472 for (cp = xlp; cp > xcp; ) 473 x_bs(*--cp); 474 } 475 476 x_adj_ok = 1; 477 return 0; 478 } 479 480 /* 481 * this is used for x_escape() in do_complete() 482 */ 483 static int 484 x_emacs_putbuf(s, len) 485 const char *s; 486 size_t len; 487 { 488 int rval; 489 490 if ((rval = x_do_ins(s, len)) != 0) 491 return (rval); 492 return (rval); 493 } 494 495 static int 496 x_del_back(c) 497 int c; 498 { 499 int col = xcp - xbuf; 500 501 if (col == 0) { 502 x_e_putc(BEL); 503 return KSTD; 504 } 505 if (x_arg > col) 506 x_arg = col; 507 x_goto(xcp - x_arg); 508 x_delete(x_arg, false); 509 return KSTD; 510 } 511 512 static int 513 x_del_char(c) 514 int c; 515 { 516 int nleft = xep - xcp; 517 518 if (!nleft) { 519 x_e_putc(BEL); 520 return KSTD; 521 } 522 if (x_arg > nleft) 523 x_arg = nleft; 524 x_delete(x_arg, false); 525 return KSTD; 526 } 527 528 /* Delete nc chars to the right of the cursor (including cursor position) */ 529 static void 530 x_delete(nc, push) 531 int nc; 532 int push; 533 { 534 int i,j; 535 char *cp; 536 537 if (nc == 0) 538 return; 539 if (xmp != NULL && xmp > xcp) { 540 if (xcp + nc > xmp) 541 xmp = xcp; 542 else 543 xmp -= nc; 544 } 545 546 /* 547 * This lets us yank a word we have deleted. 548 */ 549 if (push) 550 x_push(nc); 551 552 xep -= nc; 553 cp = xcp; 554 j = 0; 555 i = nc; 556 while (i--) { 557 j += x_size(*cp++); 558 } 559 memmove(xcp, xcp+nc, xep - xcp + 1); /* Copies the null */ 560 x_adj_ok = 0; /* don't redraw */ 561 x_zots(xcp); 562 /* 563 * if we are already filling the line, 564 * there is no need to ' ','\b'. 565 * But if we must, make sure we do the minimum. 566 */ 567 if ((i = x_displen) > 0) 568 { 569 j = (j < i) ? j : i; 570 i = j; 571 while (i--) 572 x_e_putc(' '); 573 i = j; 574 while (i--) 575 x_e_putc('\b'); 576 } 577 /*x_goto(xcp);*/ 578 x_adj_ok = 1; 579 xlp_valid = false; 580 for (cp = x_lastcp(); cp > xcp; ) 581 x_bs(*--cp); 582 583 return; 584 } 585 586 static int 587 x_del_bword(c) 588 int c; 589 { 590 x_delete(x_bword(), true); 591 return KSTD; 592 } 593 594 static int 595 x_mv_bword(c) 596 int c; 597 { 598 (void)x_bword(); 599 return KSTD; 600 } 601 602 static int 603 x_mv_fword(c) 604 int c; 605 { 606 x_goto(xcp + x_fword()); 607 return KSTD; 608 } 609 610 static int 611 x_del_fword(c) 612 int c; 613 { 614 x_delete(x_fword(), true); 615 return KSTD; 616 } 617 618 static int 619 x_bword() 620 { 621 int nc = 0; 622 char *cp = xcp; 623 624 if (cp == xbuf) { 625 x_e_putc(BEL); 626 return 0; 627 } 628 while (x_arg--) 629 { 630 while (cp != xbuf && is_mfs(cp[-1])) 631 { 632 cp--; 633 nc++; 634 } 635 while (cp != xbuf && !is_mfs(cp[-1])) 636 { 637 cp--; 638 nc++; 639 } 640 } 641 x_goto(cp); 642 return nc; 643 } 644 645 static int 646 x_fword() 647 { 648 int nc = 0; 649 char *cp = xcp; 650 651 if (cp == xep) { 652 x_e_putc(BEL); 653 return 0; 654 } 655 while (x_arg--) 656 { 657 while (cp != xep && is_mfs(*cp)) 658 { 659 cp++; 660 nc++; 661 } 662 while (cp != xep && !is_mfs(*cp)) 663 { 664 cp++; 665 nc++; 666 } 667 } 668 return nc; 669 } 670 671 static void 672 x_goto(cp) 673 char *cp; 674 { 675 if (cp < xbp || cp >= (xbp + x_displen)) 676 { 677 /* we are heading off screen */ 678 xcp = cp; 679 x_adjust(); 680 } 681 else 682 { 683 if (cp < xcp) /* move back */ 684 { 685 while (cp < xcp) 686 x_bs(*--xcp); 687 } 688 else 689 { 690 if (cp > xcp) /* move forward */ 691 { 692 while (cp > xcp) 693 x_zotc(*xcp++); 694 } 695 } 696 } 697 } 698 699 static void 700 x_bs(c) 701 int c; 702 { 703 int i; 704 i = x_size(c); 705 while (i--) 706 x_e_putc('\b'); 707 } 708 709 static int 710 x_size_str(cp) 711 char *cp; 712 { 713 int size = 0; 714 while (*cp) 715 size += x_size(*cp++); 716 return size; 717 } 718 719 static int 720 x_size(c) 721 int c; 722 { 723 if (c=='\t') 724 return 4; /* Kludge, tabs are always four spaces. */ 725 if (iscntrl((unsigned char)c)) /* control char */ 726 return 2; 727 return 1; 728 } 729 730 static void 731 x_zots(str) 732 char *str; 733 { 734 int adj = x_adj_done; 735 736 x_lastcp(); 737 while (*str && str < xlp && adj == x_adj_done) 738 x_zotc(*str++); 739 } 740 741 static void 742 x_zotc(c) 743 int c; 744 { 745 if (c == '\t') { 746 /* Kludge, tabs are always four spaces. */ 747 x_e_puts(" "); 748 } else if (iscntrl((unsigned char)c)) { 749 x_e_putc('^'); 750 x_e_putc(UNCTRL(c)); 751 } else 752 x_e_putc(c); 753 } 754 755 static int 756 x_mv_back(c) 757 int c; 758 { 759 int col = xcp - xbuf; 760 761 if (col == 0) { 762 x_e_putc(BEL); 763 return KSTD; 764 } 765 if (x_arg > col) 766 x_arg = col; 767 x_goto(xcp - x_arg); 768 return KSTD; 769 } 770 771 static int 772 x_mv_forw(c) 773 int c; 774 { 775 int nleft = xep - xcp; 776 777 if (!nleft) { 778 x_e_putc(BEL); 779 return KSTD; 780 } 781 if (x_arg > nleft) 782 x_arg = nleft; 783 x_goto(xcp + x_arg); 784 return KSTD; 785 } 786 787 static int 788 x_search_char_forw(c) 789 int c; 790 { 791 char *cp = xcp; 792 793 *xep = '\0'; 794 c = x_e_getc(); 795 while (x_arg--) { 796 if (c < 0 797 || ((cp = (cp == xep) ? NULL : strchr(cp + 1, c)) == NULL 798 && (cp = strchr(xbuf, c)) == NULL)) 799 { 800 x_e_putc(BEL); 801 return KSTD; 802 } 803 } 804 x_goto(cp); 805 return KSTD; 806 } 807 808 static int 809 x_search_char_back(c) 810 int c; 811 { 812 char *cp = xcp, *p; 813 814 c = x_e_getc(); 815 for (; x_arg--; cp = p) 816 for (p = cp; ; ) { 817 if (p-- == xbuf) 818 p = xep; 819 if (c < 0 || p == cp) { 820 x_e_putc(BEL); 821 return KSTD; 822 } 823 if (*p == c) 824 break; 825 } 826 x_goto(cp); 827 return KSTD; 828 } 829 830 static int 831 x_newline(c) 832 int c; 833 { 834 x_e_putc('\r'); 835 x_e_putc('\n'); 836 x_flush(); 837 *xep++ = '\n'; 838 return KEOL; 839 } 840 841 static int 842 x_end_of_text(c) 843 int c; 844 { 845 return KEOL; 846 } 847 848 static int x_beg_hist(c) int c; { x_load_hist(histlist); return KSTD;} 849 850 static int x_end_hist(c) int c; { x_load_hist(histptr); return KSTD;} 851 852 static int x_prev_com(c) int c; { x_load_hist(x_histp - x_arg); return KSTD;} 853 854 static int x_next_com(c) int c; { x_load_hist(x_histp + x_arg); return KSTD;} 855 856 /* Goto a particular history number obtained from argument. 857 * If no argument is given history 1 is probably not what you 858 * want so we'll simply go to the oldest one. 859 */ 860 static int 861 x_goto_hist(c) 862 int c; 863 { 864 if (x_arg_defaulted) 865 x_load_hist(histlist); 866 else 867 x_load_hist(histptr + x_arg - source->line); 868 return KSTD; 869 } 870 871 static void 872 x_load_hist(hp) 873 char **hp; 874 { 875 int oldsize; 876 877 if (hp < histlist || hp > histptr) { 878 x_e_putc(BEL); 879 return; 880 } 881 x_histp = hp; 882 oldsize = x_size_str(xbuf); 883 strlcpy(xbuf, *hp, xend - xbuf); 884 xbp = xbuf; 885 xep = xcp = xbuf + strlen(xbuf); 886 xlp_valid = false; 887 if (xep > x_lastcp()) 888 x_goto(xep); 889 else 890 x_redraw(oldsize); 891 } 892 893 static int 894 x_nl_next_com(c) 895 int c; 896 { 897 x_nextcmd = source->line - (histptr - x_histp) + 1; 898 return (x_newline(c)); 899 } 900 901 static int 902 x_eot_del(c) 903 int c; 904 { 905 if (xep == xbuf && x_arg_defaulted) 906 return (x_end_of_text(c)); 907 else 908 return (x_del_char(c)); 909 } 910 911 /* reverse incremental history search */ 912 static int 913 x_search_hist(c) 914 int c; 915 { 916 int offset = -1; /* offset of match in xbuf, else -1 */ 917 char pat [256+1]; /* pattern buffer */ 918 char *p = pat; 919 Findex f; 920 921 *p = '\0'; 922 while (1) { 923 if (offset < 0) { 924 x_e_puts("\nI-search: "); 925 x_e_puts(pat); 926 } 927 x_flush(); 928 if ((c = x_e_getc()) < 0) 929 return KSTD; 930 f = x_tab[0][c&CHARMASK]; 931 if (c == CTRL('[')) 932 break; 933 else if (f == XFUNC_search_hist) 934 offset = x_search(pat, 0, offset); 935 else if (f == XFUNC_del_back) { 936 if (p == pat) { 937 offset = -1; 938 break; 939 } 940 if (p > pat) 941 *--p = '\0'; 942 if (p == pat) 943 offset = -1; 944 else 945 offset = x_search(pat, 1, offset); 946 continue; 947 } else if (f == XFUNC_insert) { 948 /* add char to pattern */ 949 /* overflow check... */ 950 if (p >= &pat[sizeof(pat) - 1]) { 951 x_e_putc(BEL); 952 continue; 953 } 954 *p++ = c, *p = '\0'; 955 if (offset >= 0) { 956 /* already have partial match */ 957 offset = x_match(xbuf, pat); 958 if (offset >= 0) { 959 x_goto(xbuf + offset + (p - pat) - (*pat == '^')); 960 continue; 961 } 962 } 963 offset = x_search(pat, 0, offset); 964 } else { /* other command */ 965 x_e_ungetc(c); 966 break; 967 } 968 } 969 if (offset < 0) 970 x_redraw(-1); 971 return KSTD; 972 } 973 974 /* search backward from current line */ 975 static int 976 x_search(pat, sameline, offset) 977 char *pat; 978 int sameline; 979 int offset; 980 { 981 char **hp; 982 int i; 983 984 for (hp = x_histp - (sameline ? 0 : 1) ; hp >= histlist; --hp) { 985 i = x_match(*hp, pat); 986 if (i >= 0) { 987 if (offset < 0) 988 x_e_putc('\n'); 989 x_load_hist(hp); 990 x_goto(xbuf + i + strlen(pat) - (*pat == '^')); 991 return i; 992 } 993 } 994 x_e_putc(BEL); 995 x_histp = histptr; 996 return -1; 997 } 998 999 /* return position of first match of pattern in string, else -1 */ 1000 static int 1001 x_match(str, pat) 1002 char *str, *pat; 1003 { 1004 if (*pat == '^') { 1005 return (strncmp(str, pat+1, strlen(pat+1)) == 0) ? 0 : -1; 1006 } else { 1007 char *q = strstr(str, pat); 1008 return (q == NULL) ? -1 : q - str; 1009 } 1010 } 1011 1012 static int 1013 x_del_line(c) 1014 int c; 1015 { 1016 int i, j; 1017 1018 *xep = 0; 1019 i = xep - xbuf; 1020 j = x_size_str(xbuf); 1021 xcp = xbuf; 1022 x_push(i); 1023 xlp = xbp = xep = xbuf; 1024 xlp_valid = true; 1025 *xcp = 0; 1026 xmp = NULL; 1027 x_redraw(j); 1028 return KSTD; 1029 } 1030 1031 static int 1032 x_mv_end(c) 1033 int c; 1034 { 1035 x_goto(xep); 1036 return KSTD; 1037 } 1038 1039 static int 1040 x_mv_begin(c) 1041 int c; 1042 { 1043 x_goto(xbuf); 1044 return KSTD; 1045 } 1046 1047 static int 1048 x_draw_line(c) 1049 int c; 1050 { 1051 x_redraw(-1); 1052 return KSTD; 1053 1054 } 1055 1056 /* Redraw (part of) the line. If limit is < 0, the everything is redrawn 1057 * on a NEW line, otherwise limit is the screen column up to which needs 1058 * redrawing. 1059 */ 1060 static void 1061 x_redraw(limit) 1062 int limit; 1063 { 1064 int i, j; 1065 char *cp; 1066 1067 x_adj_ok = 0; 1068 if (limit == -1) 1069 x_e_putc('\n'); 1070 else 1071 x_e_putc('\r'); 1072 x_flush(); 1073 if (xbp == xbuf) 1074 { 1075 pprompt(prompt + prompt_skip, 0); 1076 x_col = promptlen(prompt, (const char **) 0); 1077 } 1078 x_displen = xx_cols - 2 - x_col; 1079 xlp_valid = false; 1080 cp = x_lastcp(); 1081 x_zots(xbp); 1082 if (xbp != xbuf || xep > xlp) 1083 limit = xx_cols; 1084 if (limit >= 0) 1085 { 1086 if (xep > xlp) 1087 i = 0; /* we fill the line */ 1088 else 1089 i = limit - (xlp - xbp); 1090 1091 for (j = 0; j < i && x_col < (xx_cols - 2); j++) 1092 x_e_putc(' '); 1093 i = ' '; 1094 if (xep > xlp) /* more off screen */ 1095 { 1096 if (xbp > xbuf) 1097 i = '*'; 1098 else 1099 i = '>'; 1100 } 1101 else 1102 if (xbp > xbuf) 1103 i = '<'; 1104 x_e_putc(i); 1105 j++; 1106 while (j--) 1107 x_e_putc('\b'); 1108 } 1109 for (cp = xlp; cp > xcp; ) 1110 x_bs(*--cp); 1111 x_adj_ok = 1; 1112 D__(x_flush();) 1113 return; 1114 } 1115 1116 static int 1117 x_transpose(c) 1118 int c; 1119 { 1120 char tmp; 1121 1122 /* What transpose is meant to do seems to be up for debate. This 1123 * is a general summary of the options; the text is abcd with the 1124 * upper case character or underscore indicating the cursor position: 1125 * Who Before After Before After 1126 * at&t ksh in emacs mode: abCd abdC abcd_ (bell) 1127 * at&t ksh in gmacs mode: abCd baCd abcd_ abdc_ 1128 * gnu emacs: abCd acbD abcd_ abdc_ 1129 * Pdksh currently goes with GNU behavior since I believe this is the 1130 * most common version of emacs, unless in gmacs mode, in which case 1131 * it does the at&t ksh gmacs mode. 1132 * This should really be broken up into 3 functions so users can bind 1133 * to the one they want. 1134 */ 1135 if (xcp == xbuf) { 1136 x_e_putc(BEL); 1137 return KSTD; 1138 } else if (xcp == xep || Flag(FGMACS)) { 1139 if (xcp - xbuf == 1) { 1140 x_e_putc(BEL); 1141 return KSTD; 1142 } 1143 /* Gosling/Unipress emacs style: Swap two characters before the 1144 * cursor, do not change cursor position 1145 */ 1146 x_bs(xcp[-1]); 1147 x_bs(xcp[-2]); 1148 x_zotc(xcp[-1]); 1149 x_zotc(xcp[-2]); 1150 tmp = xcp[-1]; 1151 xcp[-1] = xcp[-2]; 1152 xcp[-2] = tmp; 1153 } else { 1154 /* GNU emacs style: Swap the characters before and under the 1155 * cursor, move cursor position along one. 1156 */ 1157 x_bs(xcp[-1]); 1158 x_zotc(xcp[0]); 1159 x_zotc(xcp[-1]); 1160 tmp = xcp[-1]; 1161 xcp[-1] = xcp[0]; 1162 xcp[0] = tmp; 1163 x_bs(xcp[0]); 1164 x_goto(xcp + 1); 1165 } 1166 return KSTD; 1167 } 1168 1169 static int 1170 x_literal(c) 1171 int c; 1172 { 1173 x_curprefix = -1; 1174 return KSTD; 1175 } 1176 1177 static int 1178 x_meta1(c) 1179 int c; 1180 { 1181 x_curprefix = 1; 1182 return KSTD; 1183 } 1184 1185 static int 1186 x_meta2(c) 1187 int c; 1188 { 1189 x_curprefix = 2; 1190 return KSTD; 1191 } 1192 1193 static int 1194 x_kill(c) 1195 int c; 1196 { 1197 int col = xcp - xbuf; 1198 int lastcol = xep - xbuf; 1199 int ndel; 1200 1201 if (x_arg_defaulted) 1202 x_arg = lastcol; 1203 else if (x_arg > lastcol) 1204 x_arg = lastcol; 1205 ndel = x_arg - col; 1206 if (ndel < 0) { 1207 x_goto(xbuf + x_arg); 1208 ndel = -ndel; 1209 } 1210 x_delete(ndel, true); 1211 return KSTD; 1212 } 1213 1214 static void 1215 x_push(nchars) 1216 int nchars; 1217 { 1218 char *cp = str_nsave(xcp, nchars, AEDIT); 1219 if (killstack[killsp]) 1220 afree((void *)killstack[killsp], AEDIT); 1221 killstack[killsp] = cp; 1222 killsp = (killsp + 1) % KILLSIZE; 1223 } 1224 1225 static int 1226 x_yank(c) 1227 int c; 1228 { 1229 if (killsp == 0) 1230 killtp = KILLSIZE; 1231 else 1232 killtp = killsp; 1233 killtp--; 1234 if (killstack[killtp] == 0) { 1235 x_e_puts("\nnothing to yank"); 1236 x_redraw(-1); 1237 return KSTD; 1238 } 1239 xmp = xcp; 1240 x_ins(killstack[killtp]); 1241 return KSTD; 1242 } 1243 1244 static int 1245 x_meta_yank(c) 1246 int c; 1247 { 1248 int len; 1249 if ((x_last_command != XFUNC_yank && x_last_command != XFUNC_meta_yank) 1250 || killstack[killtp] == 0) { 1251 killtp = killsp; 1252 x_e_puts("\nyank something first"); 1253 x_redraw(-1); 1254 return KSTD; 1255 } 1256 len = strlen(killstack[killtp]); 1257 x_goto(xcp - len); 1258 x_delete(len, false); 1259 do { 1260 if (killtp == 0) 1261 killtp = KILLSIZE - 1; 1262 else 1263 killtp--; 1264 } while (killstack[killtp] == 0); 1265 x_ins(killstack[killtp]); 1266 return KSTD; 1267 } 1268 1269 static int 1270 x_abort(c) 1271 int c; 1272 { 1273 /* x_zotc(c); */ 1274 xlp = xep = xcp = xbp = xbuf; 1275 xlp_valid = true; 1276 *xcp = 0; 1277 return KINTR; 1278 } 1279 1280 static int 1281 x_error(c) 1282 int c; 1283 { 1284 x_e_putc(BEL); 1285 return KSTD; 1286 } 1287 1288 static int 1289 x_stuffreset(c) 1290 int c; 1291 { 1292 #ifdef TIOCSTI 1293 (void)x_stuff(c); 1294 return KINTR; 1295 #else 1296 x_zotc(c); 1297 xlp = xcp = xep = xbp = xbuf; 1298 xlp_valid = true; 1299 *xcp = 0; 1300 x_redraw(-1); 1301 return KSTD; 1302 #endif 1303 } 1304 1305 static int 1306 x_stuff(c) 1307 int c; 1308 { 1309 #if 0 || defined TIOCSTI 1310 char ch = c; 1311 bool savmode = x_mode(false); 1312 1313 (void)ioctl(TTY, TIOCSTI, &ch); 1314 (void)x_mode(savmode); 1315 x_redraw(-1); 1316 #endif 1317 return KSTD; 1318 } 1319 1320 static char * 1321 x_mapin(cp, area) 1322 const char *cp; 1323 Area *area; 1324 { 1325 char *new, *op; 1326 1327 op = new = str_save(cp, area); 1328 while (*cp) { 1329 /* XXX -- should handle \^ escape? */ 1330 if (*cp == '^') { 1331 cp++; 1332 if (*cp >= '?') /* includes '?'; ASCII */ 1333 *op++ = CTRL(*cp); 1334 else { 1335 *op++ = '^'; 1336 cp--; 1337 } 1338 } else 1339 *op++ = *cp; 1340 cp++; 1341 } 1342 *op = '\0'; 1343 1344 return new; 1345 } 1346 1347 static char * 1348 x_mapout(c) 1349 int c; 1350 { 1351 static char buf[8]; 1352 char *p = buf; 1353 1354 if (iscntrl((unsigned char)c)) { 1355 *p++ = '^'; 1356 *p++ = UNCTRL(c); 1357 } else 1358 *p++ = c; 1359 *p = 0; 1360 return buf; 1361 } 1362 1363 static void 1364 x_print(prefix, key) 1365 int prefix, key; 1366 { 1367 if (prefix == 1) 1368 shprintf("%s", x_mapout(x_prefix1)); 1369 if (prefix == 2) 1370 shprintf("%s", x_mapout(x_prefix2)); 1371 1372 shprintf("%s = ", x_mapout(key)); 1373 if (x_tab[prefix][key] != XFUNC_ins_string) 1374 shprintf("%s\n", x_ftab[x_tab[prefix][key]].xf_name); 1375 else 1376 shprintf("'%s'\n", x_atab[prefix][key]); 1377 } 1378 1379 int 1380 x_bind(a1, a2, macro, list) 1381 const char *a1, *a2; 1382 int macro; /* bind -m */ 1383 int list; /* bind -l */ 1384 { 1385 Findex f; 1386 int prefix, key; 1387 char *sp = NULL; 1388 char *m1, *m2; 1389 1390 if (x_tab == NULL) { 1391 bi_errorf("cannot bind, not a tty"); 1392 return 1; 1393 } 1394 1395 /* List function names */ 1396 if (list) { 1397 for (f = 0; f < NELEM(x_ftab); f++) 1398 if (x_ftab[f].xf_name 1399 && !(x_ftab[f].xf_flags & XF_NOBIND)) 1400 shprintf("%s\n", x_ftab[f].xf_name); 1401 return 0; 1402 } 1403 1404 if (a1 == NULL) { 1405 for (prefix = 0; prefix < X_NTABS; prefix++) 1406 for (key = 0; key < X_TABSZ; key++) { 1407 f = x_tab[prefix][key]; 1408 if (f == XFUNC_insert || f == XFUNC_error 1409 || (macro && f != XFUNC_ins_string)) 1410 continue; 1411 x_print(prefix, key); 1412 } 1413 return 0; 1414 } 1415 1416 m2 = m1 = x_mapin(a1, ATEMP); 1417 prefix = key = 0; 1418 for (;; m1++) { 1419 key = *m1 & CHARMASK; 1420 if (x_tab[prefix][key] == XFUNC_meta1) 1421 prefix = 1; 1422 else if (x_tab[prefix][key] == XFUNC_meta2) 1423 prefix = 2; 1424 else 1425 break; 1426 } 1427 afree(m2, ATEMP); 1428 1429 if (a2 == NULL) { 1430 x_print(prefix, key); 1431 return 0; 1432 } 1433 1434 if (*a2 == 0) 1435 f = XFUNC_insert; 1436 else if (!macro) { 1437 for (f = 0; f < NELEM(x_ftab); f++) 1438 if (x_ftab[f].xf_name 1439 && strcmp(x_ftab[f].xf_name, a2) == 0) 1440 break; 1441 if (f == NELEM(x_ftab) || x_ftab[f].xf_flags & XF_NOBIND) { 1442 bi_errorf("%s: no such function", a2); 1443 return 1; 1444 } 1445 #if 0 /* This breaks the bind commands that map arrow keys */ 1446 if (f == XFUNC_meta1) 1447 x_prefix1 = key; 1448 if (f == XFUNC_meta2) 1449 x_prefix2 = key; 1450 #endif /* 0 */ 1451 } else { 1452 f = XFUNC_ins_string; 1453 sp = x_mapin(a2, AEDIT); 1454 } 1455 1456 if (x_tab[prefix][key] == XFUNC_ins_string && x_atab[prefix][key]) 1457 afree((void *)x_atab[prefix][key], AEDIT); 1458 x_tab[prefix][key] = f; 1459 x_atab[prefix][key] = sp; 1460 1461 /* Track what the user has bound so x_emacs_keys() won't toast things */ 1462 if (f == XFUNC_insert) 1463 x_bound[(prefix * X_TABSZ + key) / 8] &= 1464 ~(1 << ((prefix * X_TABSZ + key) % 8)); 1465 else 1466 x_bound[(prefix * X_TABSZ + key) / 8] |= 1467 (1 << ((prefix * X_TABSZ + key) % 8)); 1468 1469 return 0; 1470 } 1471 1472 void 1473 x_init_emacs() 1474 { 1475 size_t i; 1476 int j; 1477 char *locale; 1478 1479 ainit(AEDIT); 1480 x_nextcmd = -1; 1481 1482 x_tab = (Findex (*)[X_TABSZ]) alloc(sizeofN(*x_tab, X_NTABS), AEDIT); 1483 for (j = 0; j < X_TABSZ; j++) 1484 x_tab[0][j] = XFUNC_insert; 1485 for (i = 1; i < X_NTABS; i++) 1486 for (j = 0; j < X_TABSZ; j++) 1487 x_tab[i][j] = XFUNC_error; 1488 for (i = 0; i < NELEM(x_defbindings); i++) 1489 x_tab[(unsigned char)x_defbindings[i].xdb_tab][x_defbindings[i].xdb_char] 1490 = x_defbindings[i].xdb_func; 1491 1492 x_atab = (char *(*)[X_TABSZ]) alloc(sizeofN(*x_atab, X_NTABS), AEDIT); 1493 for (i = 1; i < X_NTABS; i++) 1494 for (j = 0; j < X_TABSZ; j++) 1495 x_atab[i][j] = NULL; 1496 1497 /* Determine if we can translate meta key or use 8-bit AscII 1498 * XXX - It would be nice if there was a locale attribute to 1499 * determine if the locale is 7-bit or not. 1500 */ 1501 locale = setlocale(LC_CTYPE, NULL); 1502 if (locale == NULL || !strcmp(locale, "C") || !strcmp(locale, "POSIX")) 1503 Flag(FEMACSUSEMETA) = 0; 1504 } 1505 1506 static void bind_if_not_bound(int p, int k, int func); 1507 1508 static void 1509 bind_if_not_bound(p, k, func) 1510 int p, k; 1511 int func; 1512 { 1513 /* Has user already bound this key? If so, don't override it */ 1514 if (x_bound[((p) * X_TABSZ + (k)) / 8] 1515 & (1 << (((p) * X_TABSZ + (k)) % 8))) 1516 return; 1517 1518 x_tab[p][k] = func; 1519 } 1520 1521 void 1522 x_emacs_keys(ec) 1523 X_chars *ec; 1524 { 1525 if (ec->erase >= 0) { 1526 bind_if_not_bound(0, ec->erase, XFUNC_del_back); 1527 bind_if_not_bound(1, ec->erase, XFUNC_del_bword); 1528 } 1529 if (ec->kill >= 0) 1530 bind_if_not_bound(0, ec->kill, XFUNC_del_line); 1531 if (ec->werase >= 0) 1532 bind_if_not_bound(0, ec->werase, XFUNC_del_bword); 1533 if (ec->intr >= 0) 1534 bind_if_not_bound(0, ec->intr, XFUNC_abort); 1535 if (ec->quit >= 0) 1536 bind_if_not_bound(0, ec->quit, XFUNC_noop); 1537 } 1538 1539 static int 1540 x_set_mark(c) 1541 int c; 1542 { 1543 xmp = xcp; 1544 return KSTD; 1545 } 1546 1547 static int 1548 x_kill_region(c) 1549 int c; 1550 { 1551 int rsize; 1552 char *xr; 1553 1554 if (xmp == NULL) { 1555 x_e_putc(BEL); 1556 return KSTD; 1557 } 1558 if (xmp > xcp) { 1559 rsize = xmp - xcp; 1560 xr = xcp; 1561 } else { 1562 rsize = xcp - xmp; 1563 xr = xmp; 1564 } 1565 x_goto(xr); 1566 x_delete(rsize, true); 1567 xmp = xr; 1568 return KSTD; 1569 } 1570 1571 static int 1572 x_xchg_point_mark(c) 1573 int c; 1574 { 1575 char *tmp; 1576 1577 if (xmp == NULL) { 1578 x_e_putc(BEL); 1579 return KSTD; 1580 } 1581 tmp = xmp; 1582 xmp = xcp; 1583 x_goto( tmp ); 1584 return KSTD; 1585 } 1586 1587 static int 1588 x_version(c) 1589 int c; 1590 { 1591 char *o_xbuf = xbuf, *o_xend = xend; 1592 char *o_xbp = xbp, *o_xep = xep, *o_xcp = xcp; 1593 int lim = x_lastcp() - xbp; 1594 1595 xbuf = xbp = xcp = ksh_version + 4; 1596 xend = xep = ksh_version + 4 + strlen(ksh_version + 4); 1597 x_redraw(lim); 1598 x_flush(); 1599 1600 c = x_e_getc(); 1601 xbuf = o_xbuf; 1602 xend = o_xend; 1603 xbp = o_xbp; 1604 xep = o_xep; 1605 xcp = o_xcp; 1606 x_redraw(strlen(ksh_version)); 1607 1608 if (c < 0) 1609 return KSTD; 1610 /* This is what at&t ksh seems to do... Very bizarre */ 1611 if (c != ' ') 1612 x_e_ungetc(c); 1613 1614 return KSTD; 1615 } 1616 1617 static int 1618 x_noop(c) 1619 int c; 1620 { 1621 return KSTD; 1622 } 1623 1624 #ifdef SILLY 1625 static int 1626 x_game_of_life(c) 1627 int c; 1628 { 1629 char newbuf [256+1]; 1630 char *ip, *op; 1631 int i, len; 1632 1633 i = xep - xbuf; 1634 *xep = 0; 1635 len = x_size_str(xbuf); 1636 xcp = xbp = xbuf; 1637 memmove(newbuf+1, xbuf, i); 1638 newbuf[0] = 'A'; 1639 newbuf[i] = 'A'; 1640 for (ip = newbuf+1, op = xbuf; --i >= 0; ip++, op++) { 1641 /* Empty space */ 1642 if (*ip < '@' || *ip == '_' || *ip == 0x7F) { 1643 /* Two adults, make whoopee */ 1644 if (ip[-1] < '_' && ip[1] < '_') { 1645 /* Make kid look like parents. */ 1646 *op = '`' + ((ip[-1] + ip[1])/2)%32; 1647 if (*op == 0x7F) /* Birth defect */ 1648 *op = '`'; 1649 } 1650 else 1651 *op = ' '; /* nothing happens */ 1652 continue; 1653 } 1654 /* Child */ 1655 if (*ip > '`') { 1656 /* All alone, dies */ 1657 if (ip[-1] == ' ' && ip[1] == ' ') 1658 *op = ' '; 1659 else /* Gets older */ 1660 *op = *ip-'`'+'@'; 1661 continue; 1662 } 1663 /* Adult */ 1664 /* Overcrowded, dies */ 1665 if (ip[-1] >= '@' && ip[1] >= '@') { 1666 *op = ' '; 1667 continue; 1668 } 1669 *op = *ip; 1670 } 1671 *op = 0; 1672 x_redraw(len); 1673 return KSTD; 1674 } 1675 #endif 1676 1677 /* 1678 * File/command name completion routines 1679 */ 1680 1681 1682 static int 1683 x_comp_comm(c) 1684 int c; 1685 { 1686 do_complete(XCF_COMMAND, CT_COMPLETE); 1687 return KSTD; 1688 } 1689 static int 1690 x_list_comm(c) 1691 int c; 1692 { 1693 do_complete(XCF_COMMAND, CT_LIST); 1694 return KSTD; 1695 } 1696 static int 1697 x_complete(c) 1698 int c; 1699 { 1700 do_complete(XCF_COMMAND_FILE, CT_COMPLETE); 1701 return KSTD; 1702 } 1703 static int 1704 x_enumerate(c) 1705 int c; 1706 { 1707 do_complete(XCF_COMMAND_FILE, CT_LIST); 1708 return KSTD; 1709 } 1710 static int 1711 x_comp_file(c) 1712 int c; 1713 { 1714 do_complete(XCF_FILE, CT_COMPLETE); 1715 return KSTD; 1716 } 1717 static int 1718 x_list_file(c) 1719 int c; 1720 { 1721 do_complete(XCF_FILE, CT_LIST); 1722 return KSTD; 1723 } 1724 static int 1725 x_comp_list(c) 1726 int c; 1727 { 1728 do_complete(XCF_COMMAND_FILE, CT_COMPLIST); 1729 return KSTD; 1730 } 1731 static int 1732 x_expand(c) 1733 int c; 1734 { 1735 char **words; 1736 int nwords = 0; 1737 int start, end; 1738 int is_command; 1739 int i; 1740 1741 nwords = x_cf_glob(XCF_FILE, 1742 xbuf, xep - xbuf, xcp - xbuf, 1743 &start, &end, &words, &is_command); 1744 1745 if (nwords == 0) { 1746 x_e_putc(BEL); 1747 return KSTD; 1748 } 1749 1750 x_goto(xbuf + start); 1751 x_delete(end - start, false); 1752 for (i = 0; i < nwords;) { 1753 if (x_escape(words[i], strlen(words[i]), x_emacs_putbuf) < 0 || 1754 (++i < nwords && x_ins(space) < 0)) 1755 { 1756 x_e_putc(BEL); 1757 return KSTD; 1758 } 1759 } 1760 x_adjust(); 1761 1762 return KSTD; 1763 } 1764 1765 /* type == 0 for list, 1 for complete and 2 for complete-list */ 1766 static void 1767 do_complete(flags, type) 1768 int flags; /* XCF_{COMMAND,FILE,COMMAND_FILE} */ 1769 Comp_type type; 1770 { 1771 char **words; 1772 int nwords; 1773 int start, end, nlen, olen; 1774 int is_command; 1775 int completed = 0; 1776 1777 nwords = x_cf_glob(flags, xbuf, xep - xbuf, xcp - xbuf, 1778 &start, &end, &words, &is_command); 1779 /* no match */ 1780 if (nwords == 0) { 1781 x_e_putc(BEL); 1782 return; 1783 } 1784 1785 if (type == CT_LIST) { 1786 x_print_expansions(nwords, words, is_command); 1787 x_redraw(0); 1788 x_free_words(nwords, words); 1789 return; 1790 } 1791 1792 olen = end - start; 1793 nlen = x_longest_prefix(nwords, words); 1794 /* complete */ 1795 if (nwords == 1 || nlen > olen) { 1796 x_goto(xbuf + start); 1797 x_delete(olen, false); 1798 x_escape(words[0], nlen, x_emacs_putbuf); 1799 x_adjust(); 1800 completed = 1; 1801 } 1802 /* add space if single non-dir match */ 1803 if ((nwords == 1) && (!ISDIRSEP(words[0][nlen - 1]))) { 1804 x_ins(space); 1805 completed = 1; 1806 } 1807 1808 if (type == CT_COMPLIST && !completed) { 1809 x_print_expansions(nwords, words, is_command); 1810 completed = 1; 1811 } 1812 1813 if (completed) 1814 x_redraw(0); 1815 1816 x_free_words(nwords, words); 1817 } 1818 1819 /* NAME: 1820 * x_adjust - redraw the line adjusting starting point etc. 1821 * 1822 * DESCRIPTION: 1823 * This function is called when we have exceeded the bounds 1824 * of the edit window. It increments x_adj_done so that 1825 * functions like x_ins and x_delete know that we have been 1826 * called and can skip the x_bs() stuff which has already 1827 * been done by x_redraw. 1828 * 1829 * RETURN VALUE: 1830 * None 1831 */ 1832 1833 static void 1834 x_adjust() 1835 { 1836 x_adj_done++; /* flag the fact that we were called. */ 1837 /* 1838 * we had a problem if the prompt length > xx_cols / 2 1839 */ 1840 if ((xbp = xcp - (x_displen / 2)) < xbuf) 1841 xbp = xbuf; 1842 xlp_valid = false; 1843 x_redraw(xx_cols); 1844 x_flush(); 1845 } 1846 1847 static int unget_char = -1; 1848 1849 static void 1850 x_e_ungetc(c) 1851 int c; 1852 { 1853 unget_char = c; 1854 } 1855 1856 static int 1857 x_e_getc() 1858 { 1859 int c; 1860 1861 if (unget_char >= 0) { 1862 c = unget_char; 1863 unget_char = -1; 1864 } else { 1865 if (macroptr) { 1866 c = (unsigned char) *macroptr++; 1867 if (!*macroptr) 1868 macroptr = (char *) 0; 1869 } else 1870 c = x_getc(); 1871 } 1872 1873 return c <= CHARMASK ? c : (c & CHARMASK); 1874 } 1875 1876 static void 1877 x_e_putc(c) 1878 int c; 1879 { 1880 if (c == '\r' || c == '\n') 1881 x_col = 0; 1882 if (x_col < xx_cols) 1883 { 1884 x_putc(c); 1885 switch(c) 1886 { 1887 case BEL: 1888 break; 1889 case '\r': 1890 case '\n': 1891 break; 1892 case '\b': 1893 x_col--; 1894 break; 1895 default: 1896 x_col++; 1897 break; 1898 } 1899 } 1900 if (x_adj_ok && (x_col < 0 || x_col >= (xx_cols - 2))) 1901 { 1902 x_adjust(); 1903 } 1904 } 1905 1906 #ifdef DEBUG 1907 static int 1908 x_debug_info(c) 1909 int c; 1910 { 1911 x_flush(); 1912 shellf("\nksh debug:\n"); 1913 shellf("\tx_col == %d,\t\tx_cols == %d,\tx_displen == %d\n", 1914 x_col, xx_cols, x_displen); 1915 shellf("\txcp == 0x%lx,\txep == 0x%lx\n", (long) xcp, (long) xep); 1916 shellf("\txbp == 0x%lx,\txbuf == 0x%lx\n", (long) xbp, (long) xbuf); 1917 shellf("\txlp == 0x%lx\n", (long) xlp); 1918 shellf("\txlp == 0x%lx\n", (long) x_lastcp()); 1919 shellf(newline); 1920 x_redraw(-1); 1921 return 0; 1922 } 1923 #endif 1924 1925 static void 1926 x_e_puts(s) 1927 const char *s; 1928 { 1929 int adj = x_adj_done; 1930 1931 while (*s && adj == x_adj_done) 1932 x_e_putc(*s++); 1933 } 1934 1935 /* NAME: 1936 * x_set_arg - set an arg value for next function 1937 * 1938 * DESCRIPTION: 1939 * This is a simple implementation of M-[0-9]. 1940 * 1941 * RETURN VALUE: 1942 * KSTD 1943 */ 1944 1945 static int 1946 x_set_arg(c) 1947 int c; 1948 { 1949 int n = 0; 1950 int first = 1; 1951 1952 c &= CHARMASK; /* strip command prefix */ 1953 for (; c >= 0 && isdigit(c); c = x_e_getc(), first = 0) 1954 n = n * 10 + (c - '0'); 1955 if (c < 0 || first) { 1956 x_e_putc(BEL); 1957 x_arg = 1; 1958 x_arg_defaulted = 1; 1959 } else { 1960 x_e_ungetc(c); 1961 x_arg = n; 1962 x_arg_defaulted = 0; 1963 } 1964 return KSTD; 1965 } 1966 1967 1968 /* Comment or uncomment the current line. */ 1969 static int 1970 x_comment(c) 1971 int c; 1972 { 1973 int oldsize = x_size_str(xbuf); 1974 int len = xep - xbuf; 1975 int ret = x_do_comment(xbuf, xend - xbuf, &len); 1976 1977 if (ret < 0) 1978 x_e_putc(BEL); 1979 else { 1980 xep = xbuf + len; 1981 *xep = '\0'; 1982 xcp = xbp = xbuf; 1983 x_redraw(oldsize); 1984 if (ret > 0) 1985 return x_newline('\n'); 1986 } 1987 return KSTD; 1988 } 1989 1990 1991 /* NAME: 1992 * x_prev_histword - recover word from prev command 1993 * 1994 * DESCRIPTION: 1995 * This function recovers the last word from the previous 1996 * command and inserts it into the current edit line. If a 1997 * numeric arg is supplied then the n'th word from the 1998 * start of the previous command is used. 1999 * 2000 * Bound to M-. 2001 * 2002 * RETURN VALUE: 2003 * KSTD 2004 */ 2005 2006 static int 2007 x_prev_histword(c) 2008 int c; 2009 { 2010 char *rcp; 2011 char *cp; 2012 2013 cp = *histptr; 2014 if (!cp) 2015 x_e_putc(BEL); 2016 else if (x_arg_defaulted) { 2017 rcp = &cp[strlen(cp) - 1]; 2018 /* 2019 * ignore white-space after the last word 2020 */ 2021 while (rcp > cp && is_cfs(*rcp)) 2022 rcp--; 2023 while (rcp > cp && !is_cfs(*rcp)) 2024 rcp--; 2025 if (is_cfs(*rcp)) 2026 rcp++; 2027 x_ins(rcp); 2028 } else { 2029 int i; 2030 2031 rcp = cp; 2032 /* 2033 * ignore white-space at start of line 2034 */ 2035 while (*rcp && is_cfs(*rcp)) 2036 rcp++; 2037 while (x_arg-- > 1) 2038 { 2039 while (*rcp && !is_cfs(*rcp)) 2040 rcp++; 2041 while (*rcp && is_cfs(*rcp)) 2042 rcp++; 2043 } 2044 cp = rcp; 2045 while (*rcp && !is_cfs(*rcp)) 2046 rcp++; 2047 i = *rcp; 2048 *rcp = '\0'; 2049 x_ins(cp); 2050 *rcp = i; 2051 } 2052 return KSTD; 2053 } 2054 2055 /* Uppercase N(1) words */ 2056 static int 2057 x_fold_upper(c) 2058 int c; 2059 { 2060 return x_fold_case('U'); 2061 } 2062 2063 /* Lowercase N(1) words */ 2064 static int 2065 x_fold_lower(c) 2066 int c; 2067 { 2068 return x_fold_case('L'); 2069 } 2070 2071 /* Lowercase N(1) words */ 2072 static int 2073 x_fold_capitalize(c) 2074 int c; 2075 { 2076 return x_fold_case('C'); 2077 } 2078 2079 /* NAME: 2080 * x_fold_case - convert word to UPPER/lower/Capital case 2081 * 2082 * DESCRIPTION: 2083 * This function is used to implement M-U,M-u,M-L,M-l,M-C and M-c 2084 * to UPPER case, lower case or Capitalize words. 2085 * 2086 * RETURN VALUE: 2087 * None 2088 */ 2089 2090 static int 2091 x_fold_case(c) 2092 int c; 2093 { 2094 char *cp = xcp; 2095 2096 if (cp == xep) { 2097 x_e_putc(BEL); 2098 return KSTD; 2099 } 2100 while (x_arg--) { 2101 /* 2102 * first skip over any white-space 2103 */ 2104 while (cp != xep && is_mfs(*cp)) 2105 cp++; 2106 /* 2107 * do the first char on its own since it may be 2108 * a different action than for the rest. 2109 */ 2110 if (cp != xep) { 2111 if (c == 'L') { /* lowercase */ 2112 if (isupper((unsigned char)*cp)) 2113 *cp = tolower((unsigned char)*cp); 2114 } else { /* uppercase, capitialize */ 2115 if (islower((unsigned char)*cp)) 2116 *cp = toupper((unsigned char)*cp); 2117 } 2118 cp++; 2119 } 2120 /* 2121 * now for the rest of the word 2122 */ 2123 while (cp != xep && !is_mfs((unsigned char)*cp)) { 2124 if (c == 'U') { /* uppercase */ 2125 if (islower((unsigned char)*cp)) 2126 *cp = toupper((unsigned char)*cp); 2127 } else { /* lowercase, capitialize */ 2128 if (isupper((unsigned char)*cp)) 2129 *cp = tolower((unsigned char)*cp); 2130 } 2131 cp++; 2132 } 2133 } 2134 x_goto(cp); 2135 return KSTD; 2136 } 2137 2138 /* NAME: 2139 * x_lastcp - last visible char 2140 * 2141 * SYNOPSIS: 2142 * x_lastcp() 2143 * 2144 * DESCRIPTION: 2145 * This function returns a pointer to that char in the 2146 * edit buffer that will be the last displayed on the 2147 * screen. The sequence: 2148 * 2149 * for (cp = x_lastcp(); cp > xcp; cp) 2150 * x_bs(*--cp); 2151 * 2152 * Will position the cursor correctly on the screen. 2153 * 2154 * RETURN VALUE: 2155 * cp or NULL 2156 */ 2157 2158 static char * 2159 x_lastcp() 2160 { 2161 char *rcp; 2162 int i; 2163 2164 if (!xlp_valid) 2165 { 2166 for (i = 0, rcp = xbp; rcp < xep && i < x_displen; rcp++) 2167 i += x_size(*rcp); 2168 xlp = rcp; 2169 } 2170 xlp_valid = true; 2171 return (xlp); 2172 } 2173 2174 #endif /* EDIT */ 2175
Indexes created Mon Sep 22 10:09:38 GMT 2025