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