src/edit.c

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