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