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