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