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