xref: /freebsd/contrib/nvi/vi/v_txt.c (revision 7aa383846770374466b1dcb2cefd71bde9acf463)
1 /*-
2  * Copyright (c) 1993, 1994
3  *	The Regents of the University of California.  All rights reserved.
4  * Copyright (c) 1992, 1993, 1994, 1995, 1996
5  *	Keith Bostic.  All rights reserved.
6  *
7  * See the LICENSE file for redistribution information.
8  */
9 
10 #include "config.h"
11 
12 #ifndef lint
13 static const char sccsid[] = "@(#)v_txt.c	10.87 (Berkeley) 10/13/96";
14 #endif /* not lint */
15 
16 #include <sys/types.h>
17 #include <sys/queue.h>
18 #include <sys/stat.h>
19 #include <sys/time.h>
20 
21 #include <bitstring.h>
22 #include <ctype.h>
23 #include <errno.h>
24 #include <limits.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <unistd.h>
29 
30 #include "../common/common.h"
31 #include "vi.h"
32 
33 static int	 txt_abbrev __P((SCR *, TEXT *, CHAR_T *, int, int *, int *));
34 static void	 txt_ai_resolve __P((SCR *, TEXT *, int *));
35 static TEXT	*txt_backup __P((SCR *, TEXTH *, TEXT *, u_int32_t *));
36 static int	 txt_dent __P((SCR *, TEXT *, int));
37 static int	 txt_emark __P((SCR *, TEXT *, size_t));
38 static void	 txt_err __P((SCR *, TEXTH *));
39 static int	 txt_fc __P((SCR *, TEXT *, int *));
40 static int	 txt_fc_col __P((SCR *, int, ARGS **));
41 static int	 txt_hex __P((SCR *, TEXT *));
42 static int	 txt_insch __P((SCR *, TEXT *, CHAR_T *, u_int));
43 static int	 txt_isrch __P((SCR *, VICMD *, TEXT *, u_int8_t *));
44 static int	 txt_map_end __P((SCR *));
45 static int	 txt_map_init __P((SCR *));
46 static int	 txt_margin __P((SCR *, TEXT *, TEXT *, int *, u_int32_t));
47 static void	 txt_nomorech __P((SCR *));
48 static void	 txt_Rresolve __P((SCR *, TEXTH *, TEXT *, const size_t));
49 static int	 txt_resolve __P((SCR *, TEXTH *, u_int32_t));
50 static int	 txt_showmatch __P((SCR *, TEXT *));
51 static void	 txt_unmap __P((SCR *, TEXT *, u_int32_t *));
52 
53 /* Cursor character (space is hard to track on the screen). */
54 #if defined(DEBUG) && 0
55 #undef	CH_CURSOR
56 #define	CH_CURSOR	'+'
57 #endif
58 
59 /*
60  * v_tcmd --
61  *	Fill a buffer from the terminal for vi.
62  *
63  * PUBLIC: int v_tcmd __P((SCR *, VICMD *, ARG_CHAR_T, u_int));
64  */
65 int
66 v_tcmd(sp, vp, prompt, flags)
67 	SCR *sp;
68 	VICMD *vp;
69 	ARG_CHAR_T prompt;
70 	u_int flags;
71 {
72 	/* Normally, we end up where we started. */
73 	vp->m_final.lno = sp->lno;
74 	vp->m_final.cno = sp->cno;
75 
76 	/* Initialize the map. */
77 	if (txt_map_init(sp))
78 		return (1);
79 
80 	/* Move to the last line. */
81 	sp->lno = TMAP[0].lno;
82 	sp->cno = 0;
83 
84 	/* Don't update the modeline for now. */
85 	F_SET(sp, SC_TINPUT_INFO);
86 
87 	/* Set the input flags. */
88 	LF_SET(TXT_APPENDEOL |
89 	    TXT_CR | TXT_ESCAPE | TXT_INFOLINE | TXT_MAPINPUT);
90 	if (O_ISSET(sp, O_ALTWERASE))
91 		LF_SET(TXT_ALTWERASE);
92 	if (O_ISSET(sp, O_TTYWERASE))
93 		LF_SET(TXT_TTYWERASE);
94 
95 	/* Do the input thing. */
96 	if (v_txt(sp, vp, NULL, NULL, 0, prompt, 0, 1, flags))
97 		return (1);
98 
99 	/* Reenable the modeline updates. */
100 	F_CLR(sp, SC_TINPUT_INFO);
101 
102 	/* Clean up the map. */
103 	if (txt_map_end(sp))
104 		return (1);
105 
106 	if (IS_ONELINE(sp))
107 		F_SET(sp, SC_SCR_REDRAW);	/* XXX */
108 
109 	/* Set the cursor to the resulting position. */
110 	sp->lno = vp->m_final.lno;
111 	sp->cno = vp->m_final.cno;
112 
113 	return (0);
114 }
115 
116 /*
117  * txt_map_init
118  *	Initialize the screen map for colon command-line input.
119  */
120 static int
121 txt_map_init(sp)
122 	SCR *sp;
123 {
124 	SMAP *esmp;
125 	VI_PRIVATE *vip;
126 
127 	vip = VIP(sp);
128 	if (!IS_ONELINE(sp)) {
129 		/*
130 		 * Fake like the user is doing input on the last line of the
131 		 * screen.  This makes all of the scrolling work correctly,
132 		 * and allows us the use of the vi text editing routines, not
133 		 * to mention practically infinite length ex commands.
134 		 *
135 		 * Save the current location.
136 		 */
137 		vip->sv_tm_lno = TMAP->lno;
138 		vip->sv_tm_soff = TMAP->soff;
139 		vip->sv_tm_coff = TMAP->coff;
140 		vip->sv_t_maxrows = sp->t_maxrows;
141 		vip->sv_t_minrows = sp->t_minrows;
142 		vip->sv_t_rows = sp->t_rows;
143 
144 		/*
145 		 * If it's a small screen, TMAP may be small for the screen.
146 		 * Fix it, filling in fake lines as we go.
147 		 */
148 		if (IS_SMALL(sp))
149 			for (esmp =
150 			    HMAP + (sp->t_maxrows - 1); TMAP < esmp; ++TMAP) {
151 				TMAP[1].lno = TMAP[0].lno + 1;
152 				TMAP[1].coff = HMAP->coff;
153 				TMAP[1].soff = 1;
154 			}
155 
156 		/* Build the fake entry. */
157 		TMAP[1].lno = TMAP[0].lno + 1;
158 		TMAP[1].soff = 1;
159 		TMAP[1].coff = 0;
160 		SMAP_FLUSH(&TMAP[1]);
161 		++TMAP;
162 
163 		/* Reset the screen information. */
164 		sp->t_rows = sp->t_minrows = ++sp->t_maxrows;
165 	}
166 	return (0);
167 }
168 
169 /*
170  * txt_map_end
171  *	Reset the screen map for colon command-line input.
172  */
173 static int
174 txt_map_end(sp)
175 	SCR *sp;
176 {
177 	VI_PRIVATE *vip;
178 	size_t cnt;
179 
180 	vip = VIP(sp);
181 	if (!IS_ONELINE(sp)) {
182 		/* Restore the screen information. */
183 		sp->t_rows = vip->sv_t_rows;
184 		sp->t_minrows = vip->sv_t_minrows;
185 		sp->t_maxrows = vip->sv_t_maxrows;
186 
187 		/*
188 		 * If it's a small screen, TMAP may be wrong.  Clear any
189 		 * lines that might have been overwritten.
190 		 */
191 		if (IS_SMALL(sp)) {
192 			for (cnt = sp->t_rows; cnt <= sp->t_maxrows; ++cnt) {
193 				(void)sp->gp->scr_move(sp, cnt, 0);
194 				(void)sp->gp->scr_clrtoeol(sp);
195 			}
196 			TMAP = HMAP + (sp->t_rows - 1);
197 		} else
198 			--TMAP;
199 
200 		/*
201 		 * The map may be wrong if the user entered more than one
202 		 * (logical) line.  Fix it.  If the user entered a whole
203 		 * screen, this will be slow, but we probably don't care.
204 		 */
205 		if (!O_ISSET(sp, O_LEFTRIGHT))
206 			while (vip->sv_tm_lno != TMAP->lno ||
207 			    vip->sv_tm_soff != TMAP->soff)
208 				if (vs_sm_1down(sp))
209 					return (1);
210 	}
211 
212 	/*
213 	 * Invalidate the cursor and the line size cache, the line never
214 	 * really existed.  This fixes bugs where the user searches for
215 	 * the last line on the screen + 1 and the refresh routine thinks
216 	 * that's where we just were.
217 	 */
218 	VI_SCR_CFLUSH(vip);
219 	F_SET(vip, VIP_CUR_INVALID);
220 
221 	return (0);
222 }
223 
224 /*
225  * If doing input mapping on the colon command line, may need to unmap
226  * based on the command.
227  */
228 #define	UNMAP_TST							\
229 	FL_ISSET(ec_flags, EC_MAPINPUT) && LF_ISSET(TXT_INFOLINE)
230 
231 /*
232  * Internally, we maintain tp->lno and tp->cno, externally, everyone uses
233  * sp->lno and sp->cno.  Make them consistent as necessary.
234  */
235 #define	UPDATE_POSITION(sp, tp) {					\
236 	(sp)->lno = (tp)->lno;						\
237 	(sp)->cno = (tp)->cno;						\
238 }
239 
240 /*
241  * v_txt --
242  *	Vi text input.
243  *
244  * PUBLIC: int v_txt __P((SCR *, VICMD *, MARK *,
245  * PUBLIC:    const char *, size_t, ARG_CHAR_T, recno_t, u_long, u_int32_t));
246  */
247 int
248 v_txt(sp, vp, tm, lp, len, prompt, ai_line, rcount, flags)
249 	SCR *sp;
250 	VICMD *vp;
251 	MARK *tm;		/* To MARK. */
252 	const char *lp;		/* Input line. */
253 	size_t len;		/* Input line length. */
254 	ARG_CHAR_T prompt;	/* Prompt to display. */
255 	recno_t ai_line;	/* Line number to use for autoindent count. */
256 	u_long rcount;		/* Replay count. */
257 	u_int32_t flags;	/* TXT_* flags. */
258 {
259 	EVENT ev, *evp;		/* Current event. */
260 	EVENT fc;		/* File name completion event. */
261 	GS *gp;
262 	TEXT *ntp, *tp;		/* Input text structures. */
263 	TEXT ait;		/* Autoindent text structure. */
264 	TEXT wmt;		/* Wrapmargin text structure. */
265 	TEXTH *tiqh;
266 	VI_PRIVATE *vip;
267 	abb_t abb;		/* State of abbreviation checks. */
268 	carat_t carat;		/* State of the "[^0]^D" sequences. */
269 	quote_t quote;		/* State of quotation. */
270 	size_t owrite, insert;	/* Temporary copies of TEXT fields. */
271 	size_t margin;		/* Wrapmargin value. */
272 	size_t rcol;		/* 0-N: insert offset in the replay buffer. */
273 	size_t tcol;		/* Temporary column. */
274 	u_int32_t ec_flags;	/* Input mapping flags. */
275 #define	IS_RESTART	0x01	/* Reset the incremental search. */
276 #define	IS_RUNNING	0x02	/* Incremental search turned on. */
277 	u_int8_t is_flags;
278 	int abcnt, ab_turnoff;	/* Abbreviation character count, switch. */
279 	int filec_redraw;	/* Redraw after the file completion routine. */
280 	int hexcnt;		/* Hex character count. */
281 	int showmatch;		/* Showmatch set on this character. */
282 	int wm_set, wm_skip;	/* Wrapmargin happened, blank skip flags. */
283 	int max, tmp;
284 	char *p;
285 
286 	gp = sp->gp;
287 	vip = VIP(sp);
288 
289 	/*
290 	 * Set the input flag, so tabs get displayed correctly
291 	 * and everyone knows that the text buffer is in use.
292 	 */
293 	F_SET(sp, SC_TINPUT);
294 
295 	/*
296 	 * Get one TEXT structure with some initial buffer space, reusing
297 	 * the last one if it's big enough.  (All TEXT bookkeeping fields
298 	 * default to 0 -- text_init() handles this.)  If changing a line,
299 	 * copy it into the TEXT buffer.
300 	 */
301 	tiqh = &sp->tiq;
302 	if (tiqh->cqh_first != (void *)tiqh) {
303 		tp = tiqh->cqh_first;
304 		if (tp->q.cqe_next != (void *)tiqh || tp->lb_len < len + 32) {
305 			text_lfree(tiqh);
306 			goto newtp;
307 		}
308 		tp->ai = tp->insert = tp->offset = tp->owrite = 0;
309 		if (lp != NULL) {
310 			tp->len = len;
311 			memmove(tp->lb, lp, len);
312 		} else
313 			tp->len = 0;
314 	} else {
315 newtp:		if ((tp = text_init(sp, lp, len, len + 32)) == NULL)
316 			return (1);
317 		CIRCLEQ_INSERT_HEAD(tiqh, tp, q);
318 	}
319 
320 	/* Set default termination condition. */
321 	tp->term = TERM_OK;
322 
323 	/* Set the starting line, column. */
324 	tp->lno = sp->lno;
325 	tp->cno = sp->cno;
326 
327 	/*
328 	 * Set the insert and overwrite counts.  If overwriting characters,
329 	 * do insertion afterward.  If not overwriting characters, assume
330 	 * doing insertion.  If change is to a mark, emphasize it with an
331 	 * CH_ENDMARK character.
332 	 */
333 	if (len) {
334 		if (LF_ISSET(TXT_OVERWRITE)) {
335 			tp->owrite = (tm->cno - tp->cno) + 1;
336 			tp->insert = (len - tm->cno) - 1;
337 		} else
338 			tp->insert = len - tp->cno;
339 
340 		if (LF_ISSET(TXT_EMARK) && txt_emark(sp, tp, tm->cno))
341 			return (1);
342 	}
343 
344 	/*
345 	 * Many of the special cases in text input are to handle autoindent
346 	 * support.  Somebody decided that it would be a good idea if "^^D"
347 	 * and "0^D" deleted all of the autoindented characters.  In an editor
348 	 * that takes single character input from the user, this beggars the
349 	 * imagination.  Note also, "^^D" resets the next lines' autoindent,
350 	 * but "0^D" doesn't.
351 	 *
352 	 * We assume that autoindent only happens on empty lines, so insert
353 	 * and overwrite will be zero.  If doing autoindent, figure out how
354 	 * much indentation we need and fill it in.  Update input column and
355 	 * screen cursor as necessary.
356 	 */
357 	if (LF_ISSET(TXT_AUTOINDENT) && ai_line != OOBLNO) {
358 		if (v_txt_auto(sp, ai_line, NULL, 0, tp))
359 			return (1);
360 		tp->cno = tp->ai;
361 	} else {
362 		/*
363 		 * The cc and S commands have a special feature -- leading
364 		 * <blank> characters are handled as autoindent characters.
365 		 * Beauty!
366 		 */
367 		if (LF_ISSET(TXT_AICHARS)) {
368 			tp->offset = 0;
369 			tp->ai = tp->cno;
370 		} else
371 			tp->offset = tp->cno;
372 	}
373 
374 	/* If getting a command buffer from the user, there may be a prompt. */
375 	if (LF_ISSET(TXT_PROMPT)) {
376 		tp->lb[tp->cno++] = prompt;
377 		++tp->len;
378 		++tp->offset;
379 	}
380 
381 	/*
382 	 * If appending after the end-of-line, add a space into the buffer
383 	 * and move the cursor right.  This space is inserted, i.e. pushed
384 	 * along, and then deleted when the line is resolved.  Assumes that
385 	 * the cursor is already positioned at the end of the line.  This
386 	 * avoids the nastiness of having the cursor reside on a magical
387 	 * column, i.e. a column that doesn't really exist.  The only down
388 	 * side is that we may wrap lines or scroll the screen before it's
389 	 * strictly necessary.  Not a big deal.
390 	 */
391 	if (LF_ISSET(TXT_APPENDEOL)) {
392 		tp->lb[tp->cno] = CH_CURSOR;
393 		++tp->len;
394 		++tp->insert;
395 		(void)vs_change(sp, tp->lno, LINE_RESET);
396 	}
397 
398 	/*
399 	 * Historic practice is that the wrapmargin value was a distance
400 	 * from the RIGHT-HAND margin, not the left.  It's more useful to
401 	 * us as a distance from the left-hand margin, i.e. the same as
402 	 * the wraplen value.  The wrapmargin option is historic practice.
403 	 * Nvi added the wraplen option so that it would be possible to
404 	 * edit files with consistent margins without knowing the number of
405 	 * columns in the window.
406 	 *
407 	 * XXX
408 	 * Setting margin causes a significant performance hit.  Normally
409 	 * we don't update the screen if there are keys waiting, but we
410 	 * have to if margin is set, otherwise the screen routines don't
411 	 * know where the cursor is.
412 	 *
413 	 * !!!
414 	 * Abbreviated keys were affected by the wrapmargin option in the
415 	 * historic 4BSD vi.  Mapped keys were usually, but sometimes not.
416 	 * See the comment in vi/v_text():set_txt_std for more information.
417 	 *
418 	 * !!!
419 	 * One more special case.  If an inserted <blank> character causes
420 	 * wrapmargin to split the line, the next user entered character is
421 	 * discarded if it's a <space> character.
422 	 */
423 	wm_set = wm_skip = 0;
424 	if (LF_ISSET(TXT_WRAPMARGIN))
425 		if ((margin = O_VAL(sp, O_WRAPMARGIN)) != 0)
426 			margin = sp->cols - margin;
427 		else
428 			margin = O_VAL(sp, O_WRAPLEN);
429 	else
430 		margin = 0;
431 
432 	/* Initialize abbreviation checks. */
433 	abcnt = ab_turnoff = 0;
434 	abb = F_ISSET(gp, G_ABBREV) &&
435 	    LF_ISSET(TXT_MAPINPUT) ? AB_INWORD : AB_NOTSET;
436 
437 	/*
438 	 * Set up the dot command.  Dot commands are done by saving the actual
439 	 * characters and then reevaluating them so that things like wrapmargin
440 	 * can change between the insert and the replay.
441 	 *
442 	 * !!!
443 	 * Historically, vi did not remap or reabbreviate replayed input.  (It
444 	 * did beep at you if you changed an abbreviation and then replayed the
445 	 * input.  We're not that compatible.)  We don't have to do anything to
446 	 * avoid remapping, as we're not getting characters from the terminal
447 	 * routines.  Turn the abbreviation check off.
448 	 *
449 	 * XXX
450 	 * It would be nice if we could swallow backspaces and such, but it's
451 	 * not all that easy to do.  What we can do is turn off the common
452 	 * error messages during the replay.  Otherwise, when the user enters
453 	 * an illegal command, e.g., "Ia<erase><erase><erase><erase>b<escape>",
454 	 * and then does a '.', they get a list of error messages after command
455 	 * completion.
456 	 */
457 	rcol = 0;
458 	if (LF_ISSET(TXT_REPLAY)) {
459 		abb = AB_NOTSET;
460 		LF_CLR(TXT_RECORD);
461 	}
462 
463 	/* Other text input mode setup. */
464 	quote = Q_NOTSET;
465 	carat = C_NOTSET;
466 	FL_INIT(is_flags,
467 	    LF_ISSET(TXT_SEARCHINCR) ? IS_RESTART | IS_RUNNING : 0);
468 	filec_redraw = hexcnt = showmatch = 0;
469 
470 	/* Initialize input flags. */
471 	ec_flags = LF_ISSET(TXT_MAPINPUT) ? EC_MAPINPUT : 0;
472 
473 	/* Refresh the screen. */
474 	UPDATE_POSITION(sp, tp);
475 	if (vs_refresh(sp, 1))
476 		return (1);
477 
478 	/* If it's dot, just do it now. */
479 	if (F_ISSET(vp, VC_ISDOT))
480 		goto replay;
481 
482 	/* Get an event. */
483 	evp = &ev;
484 next:	if (v_event_get(sp, evp, 0, ec_flags))
485 		return (1);
486 
487 	/*
488 	 * If file completion overwrote part of the screen and nothing else has
489 	 * been displayed, clean up.  We don't do this as part of the normal
490 	 * message resolution because we know the user is on the colon command
491 	 * line and there's no reason to enter explicit characters to continue.
492 	 */
493 	if (filec_redraw && !F_ISSET(sp, SC_SCR_EXWROTE)) {
494 		filec_redraw = 0;
495 
496 		fc.e_event = E_REPAINT;
497 		fc.e_flno = vip->totalcount >=
498 		    sp->rows ? 1 : sp->rows - vip->totalcount;
499 		fc.e_tlno = sp->rows;
500 		vip->linecount = vip->lcontinue = vip->totalcount = 0;
501 		(void)vs_repaint(sp, &fc);
502 		(void)vs_refresh(sp, 1);
503 	}
504 
505 	/* Deal with all non-character events. */
506 	switch (evp->e_event) {
507 	case E_CHARACTER:
508 		break;
509 	case E_ERR:
510 	case E_EOF:
511 		F_SET(sp, SC_EXIT_FORCE);
512 		return (1);
513 	case E_REPAINT:
514 		if (vs_repaint(sp, &ev))
515 			return (1);
516 		goto next;
517 	case E_WRESIZE:
518 		/* <resize> interrupts the input mode. */
519 		v_emsg(sp, NULL, VIM_WRESIZE);
520 		/* FALLTHROUGH */
521 	default:
522 		if (evp->e_event != E_INTERRUPT && evp->e_event != E_WRESIZE)
523 			v_event_err(sp, evp);
524 		/*
525 		 * !!!
526 		 * Historically, <interrupt> exited the user from text input
527 		 * mode or cancelled a colon command, and returned to command
528 		 * mode.  It also beeped the terminal, but that seems a bit
529 		 * excessive.
530 		 */
531 		/*
532 		 * If we are recording, morph into <escape> key so that
533 		 * we can repeat the command safely: there is no way to
534 		 * invalidate the repetition of an instance of a command,
535 		 * which would be the alternative possibility.
536 		 * If we are not recording (most likely on the command line),
537 		 * simply discard the input and return to command mode
538 		 * so that an INTERRUPT doesn't become for example a file
539 		 * completion request. -aymeric
540 		 */
541 		if (LF_ISSET(TXT_RECORD)) {
542 			evp->e_event = E_CHARACTER;
543 			evp->e_c = 033;
544 			evp->e_flags = 0;
545 			evp->e_value = K_ESCAPE;
546 			break;
547 		} else {
548 			tp->term = TERM_ESC;
549 			goto k_escape;
550 		}
551 	}
552 
553 	/*
554 	 * !!!
555 	 * If the first character of the input is a nul, replay the previous
556 	 * input.  (Historically, it's okay to replay non-existent input.)
557 	 * This was not documented as far as I know, and is a great test of vi
558 	 * clones.
559 	 */
560 	if (LF_ISSET(TXT_RECORD) && rcol == 0 && evp->e_c == '\0') {
561 		if (vip->rep == NULL)
562 			goto done;
563 
564 		abb = AB_NOTSET;
565 		LF_CLR(TXT_RECORD);
566 		LF_SET(TXT_REPLAY);
567 		goto replay;
568 	}
569 
570 	/*
571 	 * File name completion and colon command-line editing.   We don't
572 	 * have enough meta characters, so we expect people to overload
573 	 * them.  If the two characters are the same, then we do file name
574 	 * completion if the cursor is past the first column, and do colon
575 	 * command-line editing if it's not.
576 	 */
577 	if (quote == Q_NOTSET) {
578 		int L__cedit, L__filec;
579 
580 		L__cedit = L__filec = 0;
581 		if (LF_ISSET(TXT_CEDIT) && O_STR(sp, O_CEDIT) != NULL &&
582 		    O_STR(sp, O_CEDIT)[0] == evp->e_c)
583 			L__cedit = 1;
584 		if (LF_ISSET(TXT_FILEC) && O_STR(sp, O_FILEC) != NULL &&
585 		    O_STR(sp, O_FILEC)[0] == evp->e_c)
586 			L__filec = 1;
587 		if (L__cedit == 1 && (L__filec == 0 || tp->cno == tp->offset)) {
588 			tp->term = TERM_CEDIT;
589 			goto k_escape;
590 		}
591 		if (L__filec == 1) {
592 			if (txt_fc(sp, tp, &filec_redraw))
593 				goto err;
594 			goto resolve;
595 		}
596 	}
597 
598 	/* Abbreviation overflow check.  See comment in txt_abbrev(). */
599 #define	MAX_ABBREVIATION_EXPANSION	256
600 	if (F_ISSET(&evp->e_ch, CH_ABBREVIATED)) {
601 		if (++abcnt > MAX_ABBREVIATION_EXPANSION) {
602 			if (v_event_flush(sp, CH_ABBREVIATED))
603 				msgq(sp, M_ERR,
604 "191|Abbreviation exceeded expansion limit: characters discarded");
605 			abcnt = 0;
606 			if (LF_ISSET(TXT_REPLAY))
607 				goto done;
608 			goto resolve;
609 		}
610 	} else
611 		abcnt = 0;
612 
613 	/* Check to see if the character fits into the replay buffers. */
614 	if (LF_ISSET(TXT_RECORD)) {
615 		BINC_GOTO(sp, vip->rep,
616 		    vip->rep_len, (rcol + 1) * sizeof(EVENT));
617 		vip->rep[rcol++] = *evp;
618 	}
619 
620 replay:	if (LF_ISSET(TXT_REPLAY))
621 		evp = vip->rep + rcol++;
622 
623 	/* Wrapmargin check for leading space. */
624 	if (wm_skip) {
625 		wm_skip = 0;
626 		if (evp->e_c == ' ')
627 			goto resolve;
628 	}
629 
630 	/* If quoted by someone else, simply insert the character. */
631 	if (F_ISSET(&evp->e_ch, CH_QUOTED))
632 		goto insq_ch;
633 
634 	/*
635 	 * !!!
636 	 * If this character was quoted by a K_VLNEXT or a backslash, replace
637 	 * the placeholder (a carat or a backslash) with the new character.
638 	 * If it was quoted by a K_VLNEXT, we've already adjusted the cursor
639 	 * because it has to appear on top of the placeholder character.  If
640 	 * it was quoted by a backslash, adjust the cursor now, the cursor
641 	 * doesn't appear on top of it.  Historic practice in both cases.
642 	 *
643 	 * Skip tests for abbreviations; ":ab xa XA" followed by "ixa^V<space>"
644 	 * doesn't perform an abbreviation.  Special case, ^V^J (not ^V^M) is
645 	 * the same as ^J, historically.
646 	 */
647 	if (quote == Q_BTHIS || quote == Q_VTHIS) {
648 		FL_CLR(ec_flags, EC_QUOTED);
649 		if (LF_ISSET(TXT_MAPINPUT))
650 			FL_SET(ec_flags, EC_MAPINPUT);
651 
652 		if (quote == Q_BTHIS &&
653 		    (evp->e_value == K_VERASE || evp->e_value == K_VKILL)) {
654 			quote = Q_NOTSET;
655 			--tp->cno;
656 			++tp->owrite;
657 			goto insl_ch;
658 		}
659 		if (quote == Q_VTHIS && evp->e_value != K_NL) {
660 			quote = Q_NOTSET;
661 			goto insl_ch;
662 		}
663 		quote = Q_NOTSET;
664 	}
665 
666 	/*
667 	 * !!!
668 	 * Translate "<CH_HEX>[isxdigit()]*" to a character with a hex value:
669 	 * this test delimits the value by any non-hex character.  Offset by
670 	 * one, we use 0 to mean that we've found <CH_HEX>.
671 	 */
672 	if (hexcnt > 1 && !isxdigit(evp->e_c)) {
673 		hexcnt = 0;
674 		if (txt_hex(sp, tp))
675 			goto err;
676 	}
677 
678 	switch (evp->e_value) {
679 	case K_CR:				/* Carriage return. */
680 	case K_NL:				/* New line. */
681 		/* Return in script windows and the command line. */
682 k_cr:		if (LF_ISSET(TXT_CR)) {
683 			/*
684 			 * If this was a map, we may have not displayed
685 			 * the line.  Display it, just in case.
686 			 *
687 			 * If a script window and not the colon line,
688 			 * push a <cr> so it gets executed.
689 			 */
690 			if (LF_ISSET(TXT_INFOLINE)) {
691 				if (vs_change(sp, tp->lno, LINE_RESET))
692 					goto err;
693 			} else if (F_ISSET(sp, SC_SCRIPT))
694 				(void)v_event_push(sp, NULL, "\r", 1, CH_NOMAP);
695 
696 			/* Set term condition: if empty. */
697 			if (tp->cno <= tp->offset)
698 				tp->term = TERM_CR;
699 			/*
700 			 * Set term condition: if searching incrementally and
701 			 * the user entered a pattern, return a completed
702 			 * search, regardless if the entire pattern was found.
703 			 */
704 			if (FL_ISSET(is_flags, IS_RUNNING) &&
705 			    tp->cno >= tp->offset + 1)
706 				tp->term = TERM_SEARCH;
707 
708 			goto k_escape;
709 		}
710 
711 #define	LINE_RESOLVE {							\
712 		/*							\
713 		 * Handle abbreviations.  If there was one, discard the	\
714 		 * replay characters.					\
715 		 */							\
716 		if (abb == AB_INWORD &&					\
717 		    !LF_ISSET(TXT_REPLAY) && F_ISSET(gp, G_ABBREV)) {	\
718 			if (txt_abbrev(sp, tp, &evp->e_c,		\
719 			    LF_ISSET(TXT_INFOLINE), &tmp,		\
720 			    &ab_turnoff))				\
721 				goto err;				\
722 			if (tmp) {					\
723 				if (LF_ISSET(TXT_RECORD))		\
724 					rcol -= tmp + 1;		\
725 				goto resolve;				\
726 			}						\
727 		}							\
728 		if (abb != AB_NOTSET)					\
729 			abb = AB_NOTWORD;				\
730 		if (UNMAP_TST)						\
731 			txt_unmap(sp, tp, &ec_flags);			\
732 		/*							\
733 		 * Delete any appended cursor.  It's possible to get in	\
734 		 * situations where TXT_APPENDEOL is set but tp->insert	\
735 		 * is 0 when using the R command and all the characters	\
736 		 * are tp->owrite characters.				\
737 		 */							\
738 		if (LF_ISSET(TXT_APPENDEOL) && tp->insert > 0) {	\
739 			--tp->len;					\
740 			--tp->insert;					\
741 		}							\
742 }
743 		LINE_RESOLVE;
744 
745 		/*
746 		 * Save the current line information for restoration in
747 		 * txt_backup(), and set the line final length.
748 		 */
749 		tp->sv_len = tp->len;
750 		tp->sv_cno = tp->cno;
751 		tp->len = tp->cno;
752 
753 		/* Update the old line. */
754 		if (vs_change(sp, tp->lno, LINE_RESET))
755 			goto err;
756 
757 		/*
758 		 * Historic practice, when the autoindent edit option was set,
759 		 * was to delete <blank> characters following the inserted
760 		 * newline.  This affected the 'R', 'c', and 's' commands; 'c'
761 		 * and 's' retained the insert characters only, 'R' moved the
762 		 * overwrite and insert characters into the next TEXT structure.
763 		 * We keep track of the number of characters erased for the 'R'
764 		 * command so that the final resolution of the line is correct.
765 		 */
766 		tp->R_erase = 0;
767 		owrite = tp->owrite;
768 		insert = tp->insert;
769 		if (LF_ISSET(TXT_REPLACE) && owrite != 0) {
770 			for (p = tp->lb + tp->cno; owrite > 0 && isblank(*p);
771 			    ++p, --owrite, ++tp->R_erase);
772 			if (owrite == 0)
773 				for (; insert > 0 && isblank(*p);
774 				    ++p, ++tp->R_erase, --insert);
775 		} else {
776 			p = tp->lb + tp->cno + owrite;
777 			if (O_ISSET(sp, O_AUTOINDENT))
778 				for (; insert > 0 &&
779 				    isblank(*p); ++p, --insert);
780 			owrite = 0;
781 		}
782 
783 		/*
784 		 * !!!
785 		 * Create a new line and insert the new TEXT into the queue.
786 		 * DON'T insert until the old line has been updated, or the
787 		 * inserted line count in line.c:db_get() will be wrong.
788 		 */
789 		if ((ntp = text_init(sp, p,
790 		    insert + owrite, insert + owrite + 32)) == NULL)
791 			goto err;
792 		CIRCLEQ_INSERT_TAIL(&sp->tiq, ntp, q);
793 
794 		/* Set up bookkeeping for the new line. */
795 		ntp->insert = insert;
796 		ntp->owrite = owrite;
797 		ntp->lno = tp->lno + 1;
798 
799 		/*
800 		 * Reset the autoindent line value.  0^D keeps the autoindent
801 		 * line from changing, ^D changes the level, even if there were
802 		 * no characters in the old line.  Note, if using the current
803 		 * tp structure, use the cursor as the length, the autoindent
804 		 * characters may have been erased.
805 		 */
806 		if (LF_ISSET(TXT_AUTOINDENT)) {
807 			if (carat == C_NOCHANGE) {
808 				if (v_txt_auto(sp, OOBLNO, &ait, ait.ai, ntp))
809 					goto err;
810 				FREE_SPACE(sp, ait.lb, ait.lb_len);
811 			} else
812 				if (v_txt_auto(sp, OOBLNO, tp, tp->cno, ntp))
813 					goto err;
814 			carat = C_NOTSET;
815 		}
816 
817 		/* Reset the cursor. */
818 		ntp->cno = ntp->ai;
819 
820 		/*
821 		 * If we're here because wrapmargin was set and we've broken a
822 		 * line, there may be additional information (i.e. the start of
823 		 * a line) in the wmt structure.
824 		 */
825 		if (wm_set) {
826 			if (wmt.offset != 0 ||
827 			    wmt.owrite != 0 || wmt.insert != 0) {
828 #define	WMTSPACE	wmt.offset + wmt.owrite + wmt.insert
829 				BINC_GOTO(sp, ntp->lb,
830 				    ntp->lb_len, ntp->len + WMTSPACE + 32);
831 				memmove(ntp->lb + ntp->cno, wmt.lb, WMTSPACE);
832 				ntp->len += WMTSPACE;
833 				ntp->cno += wmt.offset;
834 				ntp->owrite = wmt.owrite;
835 				ntp->insert = wmt.insert;
836 			}
837 			wm_set = 0;
838 		}
839 
840 		/* New lines are TXT_APPENDEOL. */
841 		if (ntp->owrite == 0 && ntp->insert == 0) {
842 			BINC_GOTO(sp, ntp->lb, ntp->lb_len, ntp->len + 1);
843 			LF_SET(TXT_APPENDEOL);
844 			ntp->lb[ntp->cno] = CH_CURSOR;
845 			++ntp->insert;
846 			++ntp->len;
847 		}
848 
849 		/* Swap old and new TEXT's, and update the new line. */
850 		tp = ntp;
851 		if (vs_change(sp, tp->lno, LINE_INSERT))
852 			goto err;
853 
854 		goto resolve;
855 	case K_ESCAPE:				/* Escape. */
856 		if (!LF_ISSET(TXT_ESCAPE))
857 			goto ins_ch;
858 
859 		/* If we have a count, start replaying the input. */
860 		if (rcount > 1) {
861 			--rcount;
862 
863 			rcol = 0;
864 			abb = AB_NOTSET;
865 			LF_CLR(TXT_RECORD);
866 			LF_SET(TXT_REPLAY);
867 
868 			/*
869 			 * Some commands (e.g. 'o') need a <newline> for each
870 			 * repetition.
871 			 */
872 			if (LF_ISSET(TXT_ADDNEWLINE))
873 				goto k_cr;
874 
875 			/*
876 			 * The R command turns into the 'a' command after the
877 			 * first repetition.
878 			 */
879 			if (LF_ISSET(TXT_REPLACE)) {
880 				tp->insert = tp->owrite;
881 				tp->owrite = 0;
882 				LF_CLR(TXT_REPLACE);
883 			}
884 			goto replay;
885 		}
886 
887 		/* Set term condition: if empty. */
888 		if (tp->cno <= tp->offset)
889 			tp->term = TERM_ESC;
890 		/*
891 		 * Set term condition: if searching incrementally and the user
892 		 * entered a pattern, return a completed search, regardless if
893 		 * the entire pattern was found.
894 		 */
895 		if (FL_ISSET(is_flags, IS_RUNNING) && tp->cno >= tp->offset + 1)
896 			tp->term = TERM_SEARCH;
897 
898 k_escape:	LINE_RESOLVE;
899 
900 		/*
901 		 * Clean up for the 'R' command, restoring overwrite
902 		 * characters, and making them into insert characters.
903 		 */
904 		if (LF_ISSET(TXT_REPLACE))
905 			txt_Rresolve(sp, &sp->tiq, tp, len);
906 
907 		/*
908 		 * If there are any overwrite characters, copy down
909 		 * any insert characters, and decrement the length.
910 		 */
911 		if (tp->owrite) {
912 			if (tp->insert)
913 				memmove(tp->lb + tp->cno,
914 				    tp->lb + tp->cno + tp->owrite, tp->insert);
915 			tp->len -= tp->owrite;
916 		}
917 
918 		/*
919 		 * Optionally resolve the lines into the file.  If not
920 		 * resolving the lines into the file, end the line with
921 		 * a nul.  If the line is empty, then set the length to
922 		 * 0, the termination condition has already been set.
923 		 *
924 		 * XXX
925 		 * This is wrong, should pass back a length.
926 		 */
927 		if (LF_ISSET(TXT_RESOLVE)) {
928 			if (txt_resolve(sp, &sp->tiq, flags))
929 				goto err;
930 		} else {
931 			BINC_GOTO(sp, tp->lb, tp->lb_len, tp->len + 1);
932 			tp->lb[tp->len] = '\0';
933 		}
934 
935 		/*
936 		 * Set the return cursor position to rest on the last
937 		 * inserted character.
938 		 */
939 		if (tp->cno != 0)
940 			--tp->cno;
941 
942 		/* Update the last line. */
943 		if (vs_change(sp, tp->lno, LINE_RESET))
944 			return (1);
945 		goto done;
946 	case K_CARAT:			/* Delete autoindent chars. */
947 		if (tp->cno <= tp->ai && LF_ISSET(TXT_AUTOINDENT))
948 			carat = C_CARATSET;
949 		goto ins_ch;
950 	case K_ZERO:			/* Delete autoindent chars. */
951 		if (tp->cno <= tp->ai && LF_ISSET(TXT_AUTOINDENT))
952 			carat = C_ZEROSET;
953 		goto ins_ch;
954 	case K_CNTRLD:			/* Delete autoindent char. */
955 		/*
956 		 * If in the first column or no characters to erase, ignore
957 		 * the ^D (this matches historic practice).  If not doing
958 		 * autoindent or already inserted non-ai characters, it's a
959 		 * literal.  The latter test is done in the switch, as the
960 		 * CARAT forms are N + 1, not N.
961 		 */
962 		if (!LF_ISSET(TXT_AUTOINDENT))
963 			goto ins_ch;
964 		if (tp->cno == 0)
965 			goto resolve;
966 
967 		switch (carat) {
968 		case C_CARATSET:	/* ^^D */
969 			if (tp->ai == 0 || tp->cno > tp->ai + tp->offset + 1)
970 				goto ins_ch;
971 
972 			/* Save the ai string for later. */
973 			ait.lb = NULL;
974 			ait.lb_len = 0;
975 			BINC_GOTO(sp, ait.lb, ait.lb_len, tp->ai);
976 			memmove(ait.lb, tp->lb, tp->ai);
977 			ait.ai = ait.len = tp->ai;
978 
979 			carat = C_NOCHANGE;
980 			goto leftmargin;
981 		case C_ZEROSET:		/* 0^D */
982 			if (tp->ai == 0 || tp->cno > tp->ai + tp->offset + 1)
983 				goto ins_ch;
984 
985 			carat = C_NOTSET;
986 leftmargin:		tp->lb[tp->cno - 1] = ' ';
987 			tp->owrite += tp->cno - tp->offset;
988 			tp->ai = 0;
989 			tp->cno = tp->offset;
990 			break;
991 		case C_NOTSET:		/* ^D */
992 			if (tp->ai == 0 || tp->cno > tp->ai + tp->offset)
993 				goto ins_ch;
994 
995 			(void)txt_dent(sp, tp, 0);
996 			break;
997 		default:
998 			abort();
999 		}
1000 		break;
1001 	case K_VERASE:			/* Erase the last character. */
1002 		/* If can erase over the prompt, return. */
1003 		if (tp->cno <= tp->offset && LF_ISSET(TXT_BS)) {
1004 			tp->term = TERM_BS;
1005 			goto done;
1006 		}
1007 
1008 		/*
1009 		 * If at the beginning of the line, try and drop back to a
1010 		 * previously inserted line.
1011 		 */
1012 		if (tp->cno == 0) {
1013 			if ((ntp =
1014 			    txt_backup(sp, &sp->tiq, tp, &flags)) == NULL)
1015 				goto err;
1016 			tp = ntp;
1017 			break;
1018 		}
1019 
1020 		/* If nothing to erase, bell the user. */
1021 		if (tp->cno <= tp->offset) {
1022 			if (!LF_ISSET(TXT_REPLAY))
1023 				txt_nomorech(sp);
1024 			break;
1025 		}
1026 
1027 		/* Drop back one character. */
1028 		--tp->cno;
1029 
1030 		/*
1031 		 * Historically, vi didn't replace the erased characters with
1032 		 * <blank>s, presumably because it's easier to fix a minor
1033 		 * typing mistake and continue on if the previous letters are
1034 		 * already there.  This is a problem for incremental searching,
1035 		 * because the user can no longer tell where they are in the
1036 		 * colon command line because the cursor is at the last search
1037 		 * point in the screen.  So, if incrementally searching, erase
1038 		 * the erased characters from the screen.
1039 		 */
1040 		if (FL_ISSET(is_flags, IS_RUNNING))
1041 			tp->lb[tp->cno] = ' ';
1042 
1043 		/*
1044 		 * Increment overwrite, decrement ai if deleted.
1045 		 *
1046 		 * !!!
1047 		 * Historic vi did not permit users to use erase characters
1048 		 * to delete autoindent characters.  We do.  Eat hot death,
1049 		 * POSIX.
1050 		 */
1051 		++tp->owrite;
1052 		if (tp->cno < tp->ai)
1053 			--tp->ai;
1054 
1055 		/* Reset if we deleted an incremental search character. */
1056 		if (FL_ISSET(is_flags, IS_RUNNING))
1057 			FL_SET(is_flags, IS_RESTART);
1058 		break;
1059 	case K_VWERASE:			/* Skip back one word. */
1060 		/*
1061 		 * If at the beginning of the line, try and drop back to a
1062 		 * previously inserted line.
1063 		 */
1064 		if (tp->cno == 0) {
1065 			if ((ntp =
1066 			    txt_backup(sp, &sp->tiq, tp, &flags)) == NULL)
1067 				goto err;
1068 			tp = ntp;
1069 		}
1070 
1071 		/*
1072 		 * If at offset, nothing to erase so bell the user.
1073 		 */
1074 		if (tp->cno <= tp->offset) {
1075 			if (!LF_ISSET(TXT_REPLAY))
1076 				txt_nomorech(sp);
1077 			break;
1078 		}
1079 
1080 		/*
1081 		 * The first werase goes back to any autoindent column and the
1082 		 * second werase goes back to the offset.
1083 		 *
1084 		 * !!!
1085 		 * Historic vi did not permit users to use erase characters to
1086 		 * delete autoindent characters.
1087 		 */
1088 		if (tp->ai && tp->cno > tp->ai)
1089 			max = tp->ai;
1090 		else {
1091 			tp->ai = 0;
1092 			max = tp->offset;
1093 		}
1094 
1095 		/* Skip over trailing space characters. */
1096 		while (tp->cno > max && isblank(tp->lb[tp->cno - 1])) {
1097 			--tp->cno;
1098 			++tp->owrite;
1099 		}
1100 		if (tp->cno == max)
1101 			break;
1102 		/*
1103 		 * There are three types of word erase found on UNIX systems.
1104 		 * They can be identified by how the string /a/b/c is treated
1105 		 * -- as 1, 3, or 6 words.  Historic vi had two classes of
1106 		 * characters, and strings were delimited by them and
1107 		 * <blank>'s, so, 6 words.  The historic tty interface used
1108 		 * <blank>'s to delimit strings, so, 1 word.  The algorithm
1109 		 * offered in the 4.4BSD tty interface (as stty altwerase)
1110 		 * treats it as 3 words -- there are two classes of
1111 		 * characters, and strings are delimited by them and
1112 		 * <blank>'s.  The difference is that the type of the first
1113 		 * erased character erased is ignored, which is exactly right
1114 		 * when erasing pathname components.  The edit options
1115 		 * TXT_ALTWERASE and TXT_TTYWERASE specify the 4.4BSD tty
1116 		 * interface and the historic tty driver behavior,
1117 		 * respectively, and the default is the same as the historic
1118 		 * vi behavior.
1119 		 *
1120 		 * Overwrite erased characters if doing incremental search;
1121 		 * see comment above.
1122 		 */
1123 		if (LF_ISSET(TXT_TTYWERASE))
1124 			while (tp->cno > max) {
1125 				--tp->cno;
1126 				++tp->owrite;
1127 				if (FL_ISSET(is_flags, IS_RUNNING))
1128 					tp->lb[tp->cno] = ' ';
1129 				if (isblank(tp->lb[tp->cno - 1]))
1130 					break;
1131 			}
1132 		else {
1133 			if (LF_ISSET(TXT_ALTWERASE)) {
1134 				--tp->cno;
1135 				++tp->owrite;
1136 				if (FL_ISSET(is_flags, IS_RUNNING))
1137 					tp->lb[tp->cno] = ' ';
1138 				if (isblank(tp->lb[tp->cno - 1]))
1139 					break;
1140 			}
1141 			if (tp->cno > max)
1142 				tmp = inword(tp->lb[tp->cno - 1]);
1143 			while (tp->cno > max) {
1144 				--tp->cno;
1145 				++tp->owrite;
1146 				if (FL_ISSET(is_flags, IS_RUNNING))
1147 					tp->lb[tp->cno] = ' ';
1148 				if (tmp != inword(tp->lb[tp->cno - 1])
1149 				    || isblank(tp->lb[tp->cno - 1]))
1150 					break;
1151 			}
1152 		}
1153 
1154 		/* Reset if we deleted an incremental search character. */
1155 		if (FL_ISSET(is_flags, IS_RUNNING))
1156 			FL_SET(is_flags, IS_RESTART);
1157 		break;
1158 	case K_VKILL:			/* Restart this line. */
1159 		/*
1160 		 * !!!
1161 		 * If at the beginning of the line, try and drop back to a
1162 		 * previously inserted line.  Historic vi did not permit
1163 		 * users to go back to previous lines.
1164 		 */
1165 		if (tp->cno == 0) {
1166 			if ((ntp =
1167 			    txt_backup(sp, &sp->tiq, tp, &flags)) == NULL)
1168 				goto err;
1169 			tp = ntp;
1170 		}
1171 
1172 		/* If at offset, nothing to erase so bell the user. */
1173 		if (tp->cno <= tp->offset) {
1174 			if (!LF_ISSET(TXT_REPLAY))
1175 				txt_nomorech(sp);
1176 			break;
1177 		}
1178 
1179 		/*
1180 		 * First kill goes back to any autoindent and second kill goes
1181 		 * back to the offset.
1182 		 *
1183 		 * !!!
1184 		 * Historic vi did not permit users to use erase characters to
1185 		 * delete autoindent characters.
1186 		 */
1187 		if (tp->ai && tp->cno > tp->ai)
1188 			max = tp->ai;
1189 		else {
1190 			tp->ai = 0;
1191 			max = tp->offset;
1192 		}
1193 		tp->owrite += tp->cno - max;
1194 
1195 		/*
1196 		 * Overwrite erased characters if doing incremental search;
1197 		 * see comment above.
1198 		 */
1199 		if (FL_ISSET(is_flags, IS_RUNNING))
1200 			do {
1201 				tp->lb[--tp->cno] = ' ';
1202 			} while (tp->cno > max);
1203 		else
1204 			tp->cno = max;
1205 
1206 		/* Reset if we deleted an incremental search character. */
1207 		if (FL_ISSET(is_flags, IS_RUNNING))
1208 			FL_SET(is_flags, IS_RESTART);
1209 		break;
1210 	case K_CNTRLT:			/* Add autoindent characters. */
1211 		if (!LF_ISSET(TXT_CNTRLT))
1212 			goto ins_ch;
1213 		if (txt_dent(sp, tp, 1))
1214 			goto err;
1215 		goto ebuf_chk;
1216 	case K_RIGHTBRACE:
1217 	case K_RIGHTPAREN:
1218 		if (LF_ISSET(TXT_SHOWMATCH))
1219 			showmatch = 1;
1220 		goto ins_ch;
1221 	case K_BACKSLASH:		/* Quote next erase/kill. */
1222 		/*
1223 		 * !!!
1224 		 * Historic vi tried to make abbreviations after a backslash
1225 		 * escape work.  If you did ":ab x y", and inserted "x\^H",
1226 		 * (assuming the erase character was ^H) you got "x^H", and
1227 		 * no abbreviation was done.  If you inserted "x\z", however,
1228 		 * it tried to back up and do the abbreviation, i.e. replace
1229 		 * 'x' with 'y'.  The problem was it got it wrong, and you
1230 		 * ended up with "zy\".
1231 		 *
1232 		 * This is really hard to do (you have to remember the
1233 		 * word/non-word state, for example), and doesn't make any
1234 		 * sense to me.  Both backslash and the characters it
1235 		 * (usually) escapes will individually trigger the
1236 		 * abbreviation, so I don't see why the combination of them
1237 		 * wouldn't.  I don't expect to get caught on this one,
1238 		 * particularly since it never worked right, but I've been
1239 		 * wrong before.
1240 		 *
1241 		 * Do the tests for abbreviations, so ":ab xa XA",
1242 		 * "ixa\<K_VERASE>" performs the abbreviation.
1243 		 */
1244 		quote = Q_BNEXT;
1245 		goto insq_ch;
1246 	case K_VLNEXT:			/* Quote next character. */
1247 		evp->e_c = '^';
1248 		quote = Q_VNEXT;
1249 		/*
1250 		 * Turn on the quote flag so that the underlying routines
1251 		 * quote the next character where it's possible. Turn off
1252 		 * the input mapbiting flag so that we don't remap the next
1253 		 * character.
1254 		 */
1255 		FL_SET(ec_flags, EC_QUOTED);
1256 		FL_CLR(ec_flags, EC_MAPINPUT);
1257 
1258 		/*
1259 		 * !!!
1260 		 * Skip the tests for abbreviations, so ":ab xa XA",
1261 		 * "ixa^V<space>" doesn't perform the abbreviation.
1262 		 */
1263 		goto insl_ch;
1264 	case K_HEXCHAR:
1265 		hexcnt = 1;
1266 		goto insq_ch;
1267 	default:			/* Insert the character. */
1268 ins_ch:		/*
1269 		 * Historically, vi eliminated nul's out of hand.  If the
1270 		 * beautify option was set, it also deleted any unknown
1271 		 * ASCII value less than space (040) and the del character
1272 		 * (0177), except for tabs.  Unknown is a key word here.
1273 		 * Most vi documentation claims that it deleted everything
1274 		 * but <tab>, <nl> and <ff>, as that's what the original
1275 		 * 4BSD documentation said.  This is obviously wrong,
1276 		 * however, as <esc> would be included in that list.  What
1277 		 * we do is eliminate any unquoted, iscntrl() character that
1278 		 * wasn't a replay and wasn't handled specially, except
1279 		 * <tab> or <ff>.
1280 		 */
1281 		if (LF_ISSET(TXT_BEAUTIFY) && iscntrl(evp->e_c) &&
1282 		    evp->e_value != K_FORMFEED && evp->e_value != K_TAB) {
1283 			msgq(sp, M_BERR,
1284 			    "192|Illegal character; quote to enter");
1285 			if (LF_ISSET(TXT_REPLAY))
1286 				goto done;
1287 			break;
1288 		}
1289 
1290 insq_ch:	/*
1291 		 * If entering a non-word character after a word, check for
1292 		 * abbreviations.  If there was one, discard replay characters.
1293 		 * If entering a blank character, check for unmap commands,
1294 		 * as well.
1295 		 */
1296 		if (!inword(evp->e_c)) {
1297 			if (abb == AB_INWORD &&
1298 			    !LF_ISSET(TXT_REPLAY) && F_ISSET(gp, G_ABBREV)) {
1299 				if (txt_abbrev(sp, tp, &evp->e_c,
1300 				    LF_ISSET(TXT_INFOLINE), &tmp, &ab_turnoff))
1301 					goto err;
1302 				if (tmp) {
1303 					if (LF_ISSET(TXT_RECORD))
1304 						rcol -= tmp + 1;
1305 					goto resolve;
1306 				}
1307 			}
1308 			if (isblank(evp->e_c) && UNMAP_TST)
1309 				txt_unmap(sp, tp, &ec_flags);
1310 		}
1311 		if (abb != AB_NOTSET)
1312 			abb = inword(evp->e_c) ? AB_INWORD : AB_NOTWORD;
1313 
1314 insl_ch:	if (txt_insch(sp, tp, &evp->e_c, flags))
1315 			goto err;
1316 
1317 		/*
1318 		 * If we're using K_VLNEXT to quote the next character, then
1319 		 * we want the cursor to position itself on the ^ placeholder
1320 		 * we're displaying, to match historic practice.
1321 		 */
1322 		if (quote == Q_VNEXT) {
1323 			--tp->cno;
1324 			++tp->owrite;
1325 		}
1326 
1327 		/*
1328 		 * !!!
1329 		 * Translate "<CH_HEX>[isxdigit()]*" to a character with
1330 		 * a hex value: this test delimits the value by the max
1331 		 * number of hex bytes.  Offset by one, we use 0 to mean
1332 		 * that we've found <CH_HEX>.
1333 		 */
1334 		if (hexcnt != 0 && hexcnt++ == sizeof(CHAR_T) * 2 + 1) {
1335 			hexcnt = 0;
1336 			if (txt_hex(sp, tp))
1337 				goto err;
1338 		}
1339 
1340 		/*
1341 		 * Check to see if we've crossed the margin.
1342 		 *
1343 		 * !!!
1344 		 * In the historic vi, the wrapmargin value was figured out
1345 		 * using the display widths of the characters, i.e. <tab>
1346 		 * characters were counted as two characters if the list edit
1347 		 * option is set, but as the tabstop edit option number of
1348 		 * characters otherwise.  That's what the vs_column() function
1349 		 * gives us, so we use it.
1350 		 */
1351 		if (margin != 0) {
1352 			if (vs_column(sp, &tcol))
1353 				goto err;
1354 			if (tcol >= margin) {
1355 				if (txt_margin(sp, tp, &wmt, &tmp, flags))
1356 					goto err;
1357 				if (tmp) {
1358 					if (isblank(evp->e_c))
1359 						wm_skip = 1;
1360 					wm_set = 1;
1361 					goto k_cr;
1362 				}
1363 			}
1364 		}
1365 
1366 		/*
1367 		 * If we've reached the end of the buffer, then we need to
1368 		 * switch into insert mode.  This happens when there's a
1369 		 * change to a mark and the user puts in more characters than
1370 		 * the length of the motion.
1371 		 */
1372 ebuf_chk:	if (tp->cno >= tp->len) {
1373 			BINC_GOTO(sp, tp->lb, tp->lb_len, tp->len + 1);
1374 			LF_SET(TXT_APPENDEOL);
1375 
1376 			tp->lb[tp->cno] = CH_CURSOR;
1377 			++tp->insert;
1378 			++tp->len;
1379 		}
1380 
1381 		/* Step the quote state forward. */
1382 		if (quote != Q_NOTSET) {
1383 			if (quote == Q_BNEXT)
1384 				quote = Q_BTHIS;
1385 			if (quote == Q_VNEXT)
1386 				quote = Q_VTHIS;
1387 		}
1388 		break;
1389 	}
1390 
1391 #ifdef DEBUG
1392 	if (tp->cno + tp->insert + tp->owrite != tp->len) {
1393 		msgq(sp, M_ERR,
1394 		    "len %u != cno: %u ai: %u insert %u overwrite %u",
1395 		    tp->len, tp->cno, tp->ai, tp->insert, tp->owrite);
1396 		if (LF_ISSET(TXT_REPLAY))
1397 			goto done;
1398 		tp->len = tp->cno + tp->insert + tp->owrite;
1399 	}
1400 #endif
1401 
1402 resolve:/*
1403 	 * 1: If we don't need to know where the cursor really is and we're
1404 	 *    replaying text, keep going.
1405 	 */
1406 	if (margin == 0 && LF_ISSET(TXT_REPLAY))
1407 		goto replay;
1408 
1409 	/*
1410 	 * 2: Reset the line.  Don't bother unless we're about to wait on
1411 	 *    a character or we need to know where the cursor really is.
1412 	 *    We have to do this before showing matching characters so the
1413 	 *    user can see what they're matching.
1414 	 */
1415 	if ((margin != 0 || !KEYS_WAITING(sp)) &&
1416 	    vs_change(sp, tp->lno, LINE_RESET))
1417 		return (1);
1418 
1419 	/*
1420 	 * 3: If there aren't keys waiting, display the matching character.
1421 	 *    We have to do this before resolving any messages, otherwise
1422 	 *    the error message from a missing match won't appear correctly.
1423 	 */
1424 	if (showmatch) {
1425 		if (!KEYS_WAITING(sp) && txt_showmatch(sp, tp))
1426 			return (1);
1427 		showmatch = 0;
1428 	}
1429 
1430 	/*
1431 	 * 4: If there have been messages and we're not editing on the colon
1432 	 *    command line or doing file name completion, resolve them.
1433 	 */
1434 	if ((vip->totalcount != 0 || F_ISSET(gp, G_BELLSCHED)) &&
1435 	    !F_ISSET(sp, SC_TINPUT_INFO) && !filec_redraw &&
1436 	    vs_resolve(sp, NULL, 0))
1437 		return (1);
1438 
1439 	/*
1440 	 * 5: Refresh the screen if we're about to wait on a character or we
1441 	 *    need to know where the cursor really is.
1442 	 */
1443 	if (margin != 0 || !KEYS_WAITING(sp)) {
1444 		UPDATE_POSITION(sp, tp);
1445 		if (vs_refresh(sp, margin != 0))
1446 			return (1);
1447 	}
1448 
1449 	/* 6: Proceed with the incremental search. */
1450 	if (FL_ISSET(is_flags, IS_RUNNING) && txt_isrch(sp, vp, tp, &is_flags))
1451 		return (1);
1452 
1453 	/* 7: Next character... */
1454 	if (LF_ISSET(TXT_REPLAY))
1455 		goto replay;
1456 	goto next;
1457 
1458 done:	/* Leave input mode. */
1459 	F_CLR(sp, SC_TINPUT);
1460 
1461 	/* If recording for playback, save it. */
1462 	if (LF_ISSET(TXT_RECORD))
1463 		vip->rep_cnt = rcol;
1464 
1465 	/*
1466 	 * If not working on the colon command line, set the final cursor
1467 	 * position.
1468 	 */
1469 	if (!F_ISSET(sp, SC_TINPUT_INFO)) {
1470 		vp->m_final.lno = tp->lno;
1471 		vp->m_final.cno = tp->cno;
1472 	}
1473 	return (0);
1474 
1475 err:
1476 alloc_err:
1477 	F_CLR(sp, SC_TINPUT);
1478 	txt_err(sp, &sp->tiq);
1479 	return (1);
1480 }
1481 
1482 /*
1483  * txt_abbrev --
1484  *	Handle abbreviations.
1485  */
1486 static int
1487 txt_abbrev(sp, tp, pushcp, isinfoline, didsubp, turnoffp)
1488 	SCR *sp;
1489 	TEXT *tp;
1490 	CHAR_T *pushcp;
1491 	int isinfoline, *didsubp, *turnoffp;
1492 {
1493 	VI_PRIVATE *vip;
1494 	CHAR_T ch, *p;
1495 	SEQ *qp;
1496 	size_t len, off;
1497 
1498 	/* Check to make sure we're not at the start of an append. */
1499 	*didsubp = 0;
1500 	if (tp->cno == tp->offset)
1501 		return (0);
1502 
1503 	vip = VIP(sp);
1504 
1505 	/*
1506 	 * Find the start of the "word".
1507 	 *
1508 	 * !!!
1509 	 * We match historic practice, which, as far as I can tell, had an
1510 	 * off-by-one error.  The way this worked was that when the inserted
1511 	 * text switched from a "word" character to a non-word character,
1512 	 * vi would check for possible abbreviations.  It would then take the
1513 	 * type (i.e. word/non-word) of the character entered TWO characters
1514 	 * ago, and move backward in the text until reaching a character that
1515 	 * was not that type, or the beginning of the insert, the line, or
1516 	 * the file.  For example, in the string "abc<space>", when the <space>
1517 	 * character triggered the abbreviation check, the type of the 'b'
1518 	 * character was used for moving through the string.  Maybe there's a
1519 	 * reason for not using the first (i.e. 'c') character, but I can't
1520 	 * think of one.
1521 	 *
1522 	 * Terminate at the beginning of the insert or the character after the
1523 	 * offset character -- both can be tested for using tp->offset.
1524 	 */
1525 	off = tp->cno - 1;			/* Previous character. */
1526 	p = tp->lb + off;
1527 	len = 1;				/* One character test. */
1528 	if (off == tp->offset || isblank(p[-1]))
1529 		goto search;
1530 	if (inword(p[-1]))			/* Move backward to change. */
1531 		for (;;) {
1532 			--off; --p; ++len;
1533 			if (off == tp->offset || !inword(p[-1]))
1534 				break;
1535 		}
1536 	else
1537 		for (;;) {
1538 			--off; --p; ++len;
1539 			if (off == tp->offset ||
1540 			    inword(p[-1]) || isblank(p[-1]))
1541 				break;
1542 		}
1543 
1544 	/*
1545 	 * !!!
1546 	 * Historic vi exploded abbreviations on the command line.  This has
1547 	 * obvious problems in that unabbreviating the string can be extremely
1548 	 * tricky, particularly if the string has, say, an embedded escape
1549 	 * character.  Personally, I think it's a stunningly bad idea.  Other
1550 	 * examples of problems this caused in historic vi are:
1551 	 *	:ab foo bar
1552 	 *	:ab foo baz
1553 	 * results in "bar" being abbreviated to "baz", which wasn't what the
1554 	 * user had in mind at all.  Also, the commands:
1555 	 *	:ab foo bar
1556 	 *	:unab foo<space>
1557 	 * resulted in an error message that "bar" wasn't mapped.  Finally,
1558 	 * since the string was already exploded by the time the unabbreviate
1559 	 * command got it, all it knew was that an abbreviation had occurred.
1560 	 * Cleverly, it checked the replacement string for its unabbreviation
1561 	 * match, which meant that the commands:
1562 	 *	:ab foo1 bar
1563 	 *	:ab foo2 bar
1564 	 *	:unab foo2
1565 	 * unabbreviate "foo1", and the commands:
1566 	 *	:ab foo bar
1567 	 *	:ab bar baz
1568 	 * unabbreviate "foo"!
1569 	 *
1570 	 * Anyway, people neglected to first ask my opinion before they wrote
1571 	 * macros that depend on this stuff, so, we make this work as follows.
1572 	 * When checking for an abbreviation on the command line, if we get a
1573 	 * string which is <blank> terminated and which starts at the beginning
1574 	 * of the line, we check to see it is the abbreviate or unabbreviate
1575 	 * commands.  If it is, turn abbreviations off and return as if no
1576 	 * abbreviation was found.  Note also, minor trickiness, so that if
1577 	 * the user erases the line and starts another command, we turn the
1578 	 * abbreviations back on.
1579 	 *
1580 	 * This makes the layering look like a Nachos Supreme.
1581 	 */
1582 search:	if (isinfoline)
1583 		if (off == tp->ai || off == tp->offset)
1584 			if (ex_is_abbrev(p, len)) {
1585 				*turnoffp = 1;
1586 				return (0);
1587 			} else
1588 				*turnoffp = 0;
1589 		else
1590 			if (*turnoffp)
1591 				return (0);
1592 
1593 	/* Check for any abbreviations. */
1594 	if ((qp = seq_find(sp, NULL, NULL, p, len, SEQ_ABBREV, NULL)) == NULL)
1595 		return (0);
1596 
1597 	/*
1598 	 * Push the abbreviation onto the tty stack.  Historically, characters
1599 	 * resulting from an abbreviation expansion were themselves subject to
1600 	 * map expansions, O_SHOWMATCH matching etc.  This means the expanded
1601 	 * characters will be re-tested for abbreviations.  It's difficult to
1602 	 * know what historic practice in this case was, since abbreviations
1603 	 * were applied to :colon command lines, so entering abbreviations that
1604 	 * looped was tricky, although possible.  In addition, obvious loops
1605 	 * didn't work as expected.  (The command ':ab a b|ab b c|ab c a' will
1606 	 * silently only implement and/or display the last abbreviation.)
1607 	 *
1608 	 * This implementation doesn't recover well from such abbreviations.
1609 	 * The main input loop counts abbreviated characters, and, when it
1610 	 * reaches a limit, discards any abbreviated characters on the queue.
1611 	 * It's difficult to back up to the original position, as the replay
1612 	 * queue would have to be adjusted, and the line state when an initial
1613 	 * abbreviated character was received would have to be saved.
1614 	 */
1615 	ch = *pushcp;
1616 	if (v_event_push(sp, NULL, &ch, 1, CH_ABBREVIATED))
1617 		return (1);
1618 	if (v_event_push(sp, NULL, qp->output, qp->olen, CH_ABBREVIATED))
1619 		return (1);
1620 
1621 	/*
1622 	 * If the size of the abbreviation is larger than or equal to the size
1623 	 * of the original text, move to the start of the replaced characters,
1624 	 * and add their length to the overwrite count.
1625 	 *
1626 	 * If the abbreviation is smaller than the original text, we have to
1627 	 * delete the additional overwrite characters and copy down any insert
1628 	 * characters.
1629 	 */
1630 	tp->cno -= len;
1631 	if (qp->olen >= len)
1632 		tp->owrite += len;
1633 	else {
1634 		if (tp->insert)
1635 			memmove(tp->lb + tp->cno + qp->olen,
1636 			    tp->lb + tp->cno + tp->owrite + len, tp->insert);
1637 		tp->owrite += qp->olen;
1638 		tp->len -= len - qp->olen;
1639 	}
1640 
1641 	/*
1642 	 * We return the length of the abbreviated characters.  This is so
1643 	 * the calling routine can replace the replay characters with the
1644 	 * abbreviation.  This means that subsequent '.' commands will produce
1645 	 * the same text, regardless of intervening :[un]abbreviate commands.
1646 	 * This is historic practice.
1647 	 */
1648 	*didsubp = len;
1649 	return (0);
1650 }
1651 
1652 /*
1653  * txt_unmap --
1654  *	Handle the unmap command.
1655  */
1656 static void
1657 txt_unmap(sp, tp, ec_flagsp)
1658 	SCR *sp;
1659 	TEXT *tp;
1660 	u_int32_t *ec_flagsp;
1661 {
1662 	size_t len, off;
1663 	char *p;
1664 
1665 	/* Find the beginning of this "word". */
1666 	for (off = tp->cno - 1, p = tp->lb + off, len = 0;; --p, --off) {
1667 		if (isblank(*p)) {
1668 			++p;
1669 			break;
1670 		}
1671 		++len;
1672 		if (off == tp->ai || off == tp->offset)
1673 			break;
1674 	}
1675 
1676 	/*
1677 	 * !!!
1678 	 * Historic vi exploded input mappings on the command line.  See the
1679 	 * txt_abbrev() routine for an explanation of the problems inherent
1680 	 * in this.
1681 	 *
1682 	 * We make this work as follows.  If we get a string which is <blank>
1683 	 * terminated and which starts at the beginning of the line, we check
1684 	 * to see it is the unmap command.  If it is, we return that the input
1685 	 * mapping should be turned off.  Note also, minor trickiness, so that
1686 	 * if the user erases the line and starts another command, we go ahead
1687 	 * an turn mapping back on.
1688 	 */
1689 	if ((off == tp->ai || off == tp->offset) && ex_is_unmap(p, len))
1690 		FL_CLR(*ec_flagsp, EC_MAPINPUT);
1691 	else
1692 		FL_SET(*ec_flagsp, EC_MAPINPUT);
1693 }
1694 
1695 /*
1696  * txt_ai_resolve --
1697  *	When a line is resolved by <esc>, review autoindent characters.
1698  */
1699 static void
1700 txt_ai_resolve(sp, tp, changedp)
1701 	SCR *sp;
1702 	TEXT *tp;
1703 	int *changedp;
1704 {
1705 	u_long ts;
1706 	int del;
1707 	size_t cno, len, new, old, scno, spaces, tab_after_sp, tabs;
1708 	char *p;
1709 
1710 	*changedp = 0;
1711 
1712 	/*
1713 	 * If the line is empty, has an offset, or no autoindent
1714 	 * characters, we're done.
1715 	 */
1716 	if (!tp->len || tp->offset || !tp->ai)
1717 		return;
1718 
1719 	/*
1720 	 * If the length is less than or equal to the autoindent
1721 	 * characters, delete them.
1722 	 */
1723 	if (tp->len <= tp->ai) {
1724 		tp->ai = tp->cno = tp->len = 0;
1725 		return;
1726 	}
1727 
1728 	/*
1729 	 * The autoindent characters plus any leading <blank> characters
1730 	 * in the line are resolved into the minimum number of characters.
1731 	 * Historic practice.
1732 	 */
1733 	ts = O_VAL(sp, O_TABSTOP);
1734 
1735 	/* Figure out the last <blank> screen column. */
1736 	for (p = tp->lb, scno = 0, len = tp->len,
1737 	    spaces = tab_after_sp = 0; len-- && isblank(*p); ++p)
1738 		if (*p == '\t') {
1739 			if (spaces)
1740 				tab_after_sp = 1;
1741 			scno += COL_OFF(scno, ts);
1742 		} else {
1743 			++spaces;
1744 			++scno;
1745 		}
1746 
1747 	/*
1748 	 * If there are no spaces, or no tabs after spaces and less than
1749 	 * ts spaces, it's already minimal.
1750 	 */
1751 	if (!spaces || !tab_after_sp && spaces < ts)
1752 		return;
1753 
1754 	/* Count up spaces/tabs needed to get to the target. */
1755 	for (cno = 0, tabs = 0; cno + COL_OFF(cno, ts) <= scno; ++tabs)
1756 		cno += COL_OFF(cno, ts);
1757 	spaces = scno - cno;
1758 
1759 	/*
1760 	 * Figure out how many characters we're dropping -- if we're not
1761 	 * dropping any, it's already minimal, we're done.
1762 	 */
1763 	old = p - tp->lb;
1764 	new = spaces + tabs;
1765 	if (old == new)
1766 		return;
1767 
1768 	/* Shift the rest of the characters down, adjust the counts. */
1769 	del = old - new;
1770 	memmove(p - del, p, tp->len - old);
1771 	tp->len -= del;
1772 	tp->cno -= del;
1773 
1774 	/* Fill in space/tab characters. */
1775 	for (p = tp->lb; tabs--;)
1776 		*p++ = '\t';
1777 	while (spaces--)
1778 		*p++ = ' ';
1779 	*changedp = 1;
1780 }
1781 
1782 /*
1783  * v_txt_auto --
1784  *	Handle autoindent.  If aitp isn't NULL, use it, otherwise,
1785  *	retrieve the line.
1786  *
1787  * PUBLIC: int v_txt_auto __P((SCR *, recno_t, TEXT *, size_t, TEXT *));
1788  */
1789 int
1790 v_txt_auto(sp, lno, aitp, len, tp)
1791 	SCR *sp;
1792 	recno_t lno;
1793 	TEXT *aitp, *tp;
1794 	size_t len;
1795 {
1796 	size_t nlen;
1797 	char *p, *t;
1798 
1799 	if (aitp == NULL) {
1800 		/*
1801 		 * If the ex append command is executed with an address of 0,
1802 		 * it's possible to get here with a line number of 0.  Return
1803 		 * an indent of 0.
1804 		 */
1805 		if (lno == 0) {
1806 			tp->ai = 0;
1807 			return (0);
1808 		}
1809 		if (db_get(sp, lno, DBG_FATAL, &t, &len))
1810 			return (1);
1811 	} else
1812 		t = aitp->lb;
1813 
1814 	/* Count whitespace characters. */
1815 	for (p = t; len > 0; ++p, --len)
1816 		if (!isblank(*p))
1817 			break;
1818 
1819 	/* Set count, check for no indentation. */
1820 	if ((nlen = (p - t)) == 0)
1821 		return (0);
1822 
1823 	/* Make sure the buffer's big enough. */
1824 	BINC_RET(sp, tp->lb, tp->lb_len, tp->len + nlen);
1825 
1826 	/* Copy the buffer's current contents up. */
1827 	if (tp->len != 0)
1828 		memmove(tp->lb + nlen, tp->lb, tp->len);
1829 	tp->len += nlen;
1830 
1831 	/* Copy the indentation into the new buffer. */
1832 	memmove(tp->lb, t, nlen);
1833 
1834 	/* Set the autoindent count. */
1835 	tp->ai = nlen;
1836 	return (0);
1837 }
1838 
1839 /*
1840  * txt_backup --
1841  *	Back up to the previously edited line.
1842  */
1843 static TEXT *
1844 txt_backup(sp, tiqh, tp, flagsp)
1845 	SCR *sp;
1846 	TEXTH *tiqh;
1847 	TEXT *tp;
1848 	u_int32_t *flagsp;
1849 {
1850 	VI_PRIVATE *vip;
1851 	TEXT *ntp;
1852 
1853 	/* Get a handle on the previous TEXT structure. */
1854 	if ((ntp = tp->q.cqe_prev) == (void *)tiqh) {
1855 		if (!FL_ISSET(*flagsp, TXT_REPLAY))
1856 			msgq(sp, M_BERR,
1857 			    "193|Already at the beginning of the insert");
1858 		return (tp);
1859 	}
1860 
1861 	/* Bookkeeping. */
1862 	ntp->len = ntp->sv_len;
1863 
1864 	/* Handle appending to the line. */
1865 	vip = VIP(sp);
1866 	if (ntp->owrite == 0 && ntp->insert == 0) {
1867 		ntp->lb[ntp->len] = CH_CURSOR;
1868 		++ntp->insert;
1869 		++ntp->len;
1870 		FL_SET(*flagsp, TXT_APPENDEOL);
1871 	} else
1872 		FL_CLR(*flagsp, TXT_APPENDEOL);
1873 
1874 	/* Release the current TEXT. */
1875 	CIRCLEQ_REMOVE(tiqh, tp, q);
1876 	text_free(tp);
1877 
1878 	/* Update the old line on the screen. */
1879 	if (vs_change(sp, ntp->lno + 1, LINE_DELETE))
1880 		return (NULL);
1881 
1882 	/* Return the new/current TEXT. */
1883 	return (ntp);
1884 }
1885 
1886 /*
1887  * Text indentation is truly strange.  ^T and ^D do movements to the next or
1888  * previous shiftwidth value, i.e. for a 1-based numbering, with shiftwidth=3,
1889  * ^T moves a cursor on the 7th, 8th or 9th column to the 10th column, and ^D
1890  * moves it back.
1891  *
1892  * !!!
1893  * The ^T and ^D characters in historical vi had special meaning only when they
1894  * were the first characters entered after entering text input mode.  As normal
1895  * erase characters couldn't erase autoindent characters (^T in this case), it
1896  * meant that inserting text into previously existing text was strange -- ^T
1897  * only worked if it was the first keystroke(s), and then could only be erased
1898  * using ^D.  This implementation treats ^T specially anywhere it occurs in the
1899  * input, and permits the standard erase characters to erase the characters it
1900  * inserts.
1901  *
1902  * !!!
1903  * A fun test is to try:
1904  *	:se sw=4 ai list
1905  *	i<CR>^Tx<CR>^Tx<CR>^Tx<CR>^Dx<CR>^Dx<CR>^Dx<esc>
1906  * Historic vi loses some of the '$' marks on the line ends, but otherwise gets
1907  * it right.
1908  *
1909  * XXX
1910  * Technically, txt_dent should be part of the screen interface, as it requires
1911  * knowledge of character sizes, including <space>s, on the screen.  It's here
1912  * because it's a complicated little beast, and I didn't want to shove it down
1913  * into the screen.  It's probable that KEY_LEN will call into the screen once
1914  * there are screens with different character representations.
1915  *
1916  * txt_dent --
1917  *	Handle ^T indents, ^D outdents.
1918  *
1919  * If anything changes here, check the ex version to see if it needs similar
1920  * changes.
1921  */
1922 static int
1923 txt_dent(sp, tp, isindent)
1924 	SCR *sp;
1925 	TEXT *tp;
1926 	int isindent;
1927 {
1928 	CHAR_T ch;
1929 	u_long sw, ts;
1930 	size_t cno, current, spaces, target, tabs, off;
1931 	int ai_reset;
1932 
1933 	ts = O_VAL(sp, O_TABSTOP);
1934 	sw = O_VAL(sp, O_SHIFTWIDTH);
1935 
1936 	/*
1937 	 * Since we don't know what precedes the character(s) being inserted
1938 	 * (or deleted), the preceding whitespace characters must be resolved.
1939 	 * An example is a <tab>, which doesn't need a full shiftwidth number
1940 	 * of columns because it's preceded by <space>s.  This is easy to get
1941 	 * if the user sets shiftwidth to a value less than tabstop (or worse,
1942 	 * something for which tabstop isn't a multiple) and then uses ^T to
1943 	 * indent, and ^D to outdent.
1944 	 *
1945 	 * Figure out the current and target screen columns.  In the historic
1946 	 * vi, the autoindent column was NOT determined using display widths
1947 	 * of characters as was the wrapmargin column.  For that reason, we
1948 	 * can't use the vs_column() function, but have to calculate it here.
1949 	 * This is slow, but it's normally only on the first few characters of
1950 	 * a line.
1951 	 */
1952 	for (current = cno = 0; cno < tp->cno; ++cno)
1953 		current += tp->lb[cno] == '\t' ?
1954 		    COL_OFF(current, ts) : KEY_LEN(sp, tp->lb[cno]);
1955 
1956 	target = current;
1957 	if (isindent)
1958 		target += COL_OFF(target, sw);
1959 	else
1960 		target -= --target % sw;
1961 
1962 	/*
1963 	 * The AI characters will be turned into overwrite characters if the
1964 	 * cursor immediately follows them.  We test both the cursor position
1965 	 * and the indent flag because there's no single test.  (^T can only
1966 	 * be detected by the cursor position, and while we know that the test
1967 	 * is always true for ^D, the cursor can be in more than one place, as
1968 	 * "0^D" and "^D" are different.)
1969 	 */
1970 	ai_reset = !isindent || tp->cno == tp->ai + tp->offset;
1971 
1972 	/*
1973 	 * Back up over any previous <blank> characters, changing them into
1974 	 * overwrite characters (including any ai characters).  Then figure
1975 	 * out the current screen column.
1976 	 */
1977 	for (; tp->cno > tp->offset &&
1978 	    (tp->lb[tp->cno - 1] == ' ' || tp->lb[tp->cno - 1] == '\t');
1979 	    --tp->cno, ++tp->owrite);
1980 	for (current = cno = 0; cno < tp->cno; ++cno)
1981 		current += tp->lb[cno] == '\t' ?
1982 		    COL_OFF(current, ts) : KEY_LEN(sp, tp->lb[cno]);
1983 
1984 	/*
1985 	 * If we didn't move up to or past the target, it's because there
1986 	 * weren't enough characters to delete, e.g. the first character
1987 	 * of the line was a tp->offset character, and the user entered
1988 	 * ^D to move to the beginning of a line.  An example of this is:
1989 	 *
1990 	 *	:set ai sw=4<cr>i<space>a<esc>i^T^D
1991 	 *
1992 	 * Otherwise, count up the total spaces/tabs needed to get from the
1993 	 * beginning of the line (or the last non-<blank> character) to the
1994 	 * target.
1995 	 */
1996 	if (current >= target)
1997 		spaces = tabs = 0;
1998 	else {
1999 		for (cno = current,
2000 		    tabs = 0; cno + COL_OFF(cno, ts) <= target; ++tabs)
2001 			cno += COL_OFF(cno, ts);
2002 		spaces = target - cno;
2003 	}
2004 
2005 	/* If we overwrote ai characters, reset the ai count. */
2006 	if (ai_reset)
2007 		tp->ai = tabs + spaces;
2008 
2009 	/*
2010 	 * Call txt_insch() to insert each character, so that we get the
2011 	 * correct effect when we add a <tab> to replace N <spaces>.
2012 	 */
2013 	for (ch = '\t'; tabs > 0; --tabs)
2014 		(void)txt_insch(sp, tp, &ch, 0);
2015 	for (ch = ' '; spaces > 0; --spaces)
2016 		(void)txt_insch(sp, tp, &ch, 0);
2017 	return (0);
2018 }
2019 
2020 /*
2021  * txt_fc --
2022  *	File name completion.
2023  */
2024 static int
2025 txt_fc(sp, tp, redrawp)
2026 	SCR *sp;
2027 	TEXT *tp;
2028 	int *redrawp;
2029 {
2030 	struct stat sb;
2031 	ARGS **argv;
2032 	CHAR_T s_ch;
2033 	EXCMD cmd;
2034 	size_t indx, len, nlen, off;
2035 	int argc, trydir;
2036 	char *p, *t;
2037 
2038 	trydir = 0;
2039 	*redrawp = 0;
2040 
2041 	/*
2042 	 * Find the beginning of this "word" -- if we're at the beginning
2043 	 * of the line, it's a special case.
2044 	 */
2045 	if (tp->cno == 1) {
2046 		len = 0;
2047 		p = tp->lb;
2048 	} else
2049 retry:		for (len = 0,
2050 		    off = tp->cno - 1, p = tp->lb + off;; --off, --p) {
2051 			if (isblank(*p)) {
2052 				++p;
2053 				break;
2054 			}
2055 			++len;
2056 			if (off == tp->ai || off == tp->offset)
2057 				break;
2058 		}
2059 
2060 	/*
2061 	 * Get enough space for a wildcard character.
2062 	 *
2063 	 * XXX
2064 	 * This won't work for "foo\", since the \ will escape the expansion
2065 	 * character.  I'm not sure if that's a bug or not...
2066 	 */
2067 	off = p - tp->lb;
2068 	BINC_RET(sp, tp->lb, tp->lb_len, tp->len + 1);
2069 	p = tp->lb + off;
2070 
2071 	s_ch = p[len];
2072 	p[len] = '*';
2073 
2074 	/* Build an ex command, and call the ex expansion routines. */
2075 	ex_cinit(&cmd, 0, 0, OOBLNO, OOBLNO, 0, NULL);
2076 	if (argv_init(sp, &cmd))
2077 		return (1);
2078 	if (argv_exp2(sp, &cmd, p, len + 1)) {
2079 		p[len] = s_ch;
2080 		return (0);
2081 	}
2082 	argc = cmd.argc;
2083 	argv = cmd.argv;
2084 
2085 	p[len] = s_ch;
2086 
2087 	switch (argc) {
2088 	case 0:				/* No matches. */
2089 		if (!trydir)
2090 			(void)sp->gp->scr_bell(sp);
2091 		return (0);
2092 	case 1:				/* One match. */
2093 		/* If something changed, do the exchange. */
2094 		nlen = strlen(cmd.argv[0]->bp);
2095 		if (len != nlen || memcmp(cmd.argv[0]->bp, p, len))
2096 			break;
2097 
2098 		/* If haven't done a directory test, do it now. */
2099 		if (!trydir &&
2100 		    !stat(cmd.argv[0]->bp, &sb) && S_ISDIR(sb.st_mode)) {
2101 			p += len;
2102 			goto isdir;
2103 		}
2104 
2105 		/* If nothing changed, period, ring the bell. */
2106 		if (!trydir)
2107 			(void)sp->gp->scr_bell(sp);
2108 		return (0);
2109 	default:			/* Multiple matches. */
2110 		*redrawp = 1;
2111 		if (txt_fc_col(sp, argc, argv))
2112 			return (1);
2113 
2114 		/* Find the length of the shortest match. */
2115 		for (nlen = cmd.argv[0]->len; --argc > 0;) {
2116 			if (cmd.argv[argc]->len < nlen)
2117 				nlen = cmd.argv[argc]->len;
2118 			for (indx = 0; indx < nlen &&
2119 			    cmd.argv[argc]->bp[indx] == cmd.argv[0]->bp[indx];
2120 			    ++indx);
2121 			nlen = indx;
2122 		}
2123 		break;
2124 	}
2125 
2126 	/* Overwrite the expanded text first. */
2127 	for (t = cmd.argv[0]->bp; len > 0 && nlen > 0; --len, --nlen)
2128 		*p++ = *t++;
2129 
2130 	/* If lost text, make the remaining old text overwrite characters. */
2131 	if (len) {
2132 		tp->cno -= len;
2133 		tp->owrite += len;
2134 	}
2135 
2136 	/* Overwrite any overwrite characters next. */
2137 	for (; nlen > 0 && tp->owrite > 0; --nlen, --tp->owrite, ++tp->cno)
2138 		*p++ = *t++;
2139 
2140 	/* Shift remaining text up, and move the cursor to the end. */
2141 	if (nlen) {
2142 		off = p - tp->lb;
2143 		BINC_RET(sp, tp->lb, tp->lb_len, tp->len + nlen);
2144 		p = tp->lb + off;
2145 
2146 		tp->cno += nlen;
2147 		tp->len += nlen;
2148 
2149 		if (tp->insert != 0)
2150 			(void)memmove(p + nlen, p, tp->insert);
2151 		while (nlen--)
2152 			*p++ = *t++;
2153 	}
2154 
2155 	/* If a single match and it's a directory, retry it. */
2156 	if (argc == 1 && !stat(cmd.argv[0]->bp, &sb) && S_ISDIR(sb.st_mode)) {
2157 isdir:		if (tp->owrite == 0) {
2158 			off = p - tp->lb;
2159 			BINC_RET(sp, tp->lb, tp->lb_len, tp->len + 1);
2160 			p = tp->lb + off;
2161 			if (tp->insert != 0)
2162 				(void)memmove(p + 1, p, tp->insert);
2163 			++tp->len;
2164 		} else
2165 			--tp->owrite;
2166 
2167 		++tp->cno;
2168 		*p++ = '/';
2169 
2170 		trydir = 1;
2171 		goto retry;
2172 	}
2173 	return (0);
2174 }
2175 
2176 /*
2177  * txt_fc_col --
2178  *	Display file names for file name completion.
2179  */
2180 static int
2181 txt_fc_col(sp, argc, argv)
2182 	SCR *sp;
2183 	int argc;
2184 	ARGS **argv;
2185 {
2186 	ARGS **av;
2187 	CHAR_T *p;
2188 	GS *gp;
2189 	size_t base, cnt, col, colwidth, numrows, numcols, prefix, row;
2190 	int ac, nf, reset;
2191 
2192 	gp = sp->gp;
2193 
2194 	/* Trim any directory prefix common to all of the files. */
2195 	if ((p = strrchr(argv[0]->bp, '/')) == NULL)
2196 		prefix = 0;
2197 	else {
2198 		prefix = (p - argv[0]->bp) + 1;
2199 		for (ac = argc - 1, av = argv + 1; ac > 0; --ac, ++av)
2200 			if (av[0]->len < prefix ||
2201 			    memcmp(av[0]->bp, argv[0]->bp, prefix)) {
2202 				prefix = 0;
2203 				break;
2204 			}
2205 	}
2206 
2207 	/*
2208 	 * Figure out the column width for the longest name.  Output is done on
2209 	 * 6 character "tab" boundaries for no particular reason.  (Since we
2210 	 * don't output tab characters, we ignore the terminal's tab settings.)
2211 	 * Ignore the user's tab setting because we have no idea how reasonable
2212 	 * it is.
2213 	 */
2214 	for (ac = argc, av = argv, colwidth = 0; ac > 0; --ac, ++av) {
2215 		for (col = 0, p = av[0]->bp + prefix; *p != '\0'; ++p)
2216 			col += KEY_LEN(sp, *p);
2217 		if (col > colwidth)
2218 			colwidth = col;
2219 	}
2220 	colwidth += COL_OFF(colwidth, 6);
2221 
2222 	/*
2223 	 * Writing to the bottom line of the screen is always turned off when
2224 	 * SC_TINPUT_INFO is set.  Turn it back on, we know what we're doing.
2225 	 */
2226 	if (F_ISSET(sp, SC_TINPUT_INFO)) {
2227 		reset = 1;
2228 		F_CLR(sp, SC_TINPUT_INFO);
2229 	} else
2230 		reset = 0;
2231 
2232 #define	CHK_INTR							\
2233 	if (F_ISSET(gp, G_INTERRUPTED))					\
2234 		goto intr;
2235 
2236 	/* If the largest file name is too large, just print them. */
2237 	if (colwidth > sp->cols) {
2238 		for (ac = argc, av = argv; ac > 0; --ac, ++av) {
2239 			p = msg_print(sp, av[0]->bp + prefix, &nf);
2240 			(void)ex_printf(sp, "%s\n", p);
2241 			if (F_ISSET(gp, G_INTERRUPTED))
2242 				break;
2243 		}
2244 		if (nf)
2245 			FREE_SPACE(sp, p, 0);
2246 		CHK_INTR;
2247 	} else {
2248 		/* Figure out the number of columns. */
2249 		numcols = (sp->cols - 1) / colwidth;
2250 		if (argc > numcols) {
2251 			numrows = argc / numcols;
2252 			if (argc % numcols)
2253 				++numrows;
2254 		} else
2255 			numrows = 1;
2256 
2257 		/* Display the files in sorted order. */
2258 		for (row = 0; row < numrows; ++row) {
2259 			for (base = row, col = 0; col < numcols; ++col) {
2260 				p = msg_print(sp, argv[base]->bp + prefix, &nf);
2261 				cnt = ex_printf(sp, "%s", p);
2262 				if (nf)
2263 					FREE_SPACE(sp, p, 0);
2264 				CHK_INTR;
2265 				if ((base += numrows) >= argc)
2266 					break;
2267 				(void)ex_printf(sp,
2268 				    "%*s", (int)(colwidth - cnt), "");
2269 				CHK_INTR;
2270 			}
2271 			(void)ex_puts(sp, "\n");
2272 			CHK_INTR;
2273 		}
2274 		(void)ex_puts(sp, "\n");
2275 		CHK_INTR;
2276 	}
2277 	(void)ex_fflush(sp);
2278 
2279 	if (0) {
2280 intr:		F_CLR(gp, G_INTERRUPTED);
2281 	}
2282 	if (reset)
2283 		F_SET(sp, SC_TINPUT_INFO);
2284 
2285 	return (0);
2286 }
2287 
2288 /*
2289  * txt_emark --
2290  *	Set the end mark on the line.
2291  */
2292 static int
2293 txt_emark(sp, tp, cno)
2294 	SCR *sp;
2295 	TEXT *tp;
2296 	size_t cno;
2297 {
2298 	CHAR_T ch, *kp;
2299 	size_t chlen, nlen, olen;
2300 	char *p;
2301 
2302 	ch = CH_ENDMARK;
2303 
2304 	/*
2305 	 * The end mark may not be the same size as the current character.
2306 	 * Don't let the line shift.
2307 	 */
2308 	nlen = KEY_LEN(sp, ch);
2309 	if (tp->lb[cno] == '\t')
2310 		(void)vs_columns(sp, tp->lb, tp->lno, &cno, &olen);
2311 	else
2312 		olen = KEY_LEN(sp, tp->lb[cno]);
2313 
2314 	/*
2315 	 * If the line got longer, well, it's weird, but it's easy.  If
2316 	 * it's the same length, it's easy.  If it got shorter, we have
2317 	 * to fix it up.
2318 	 */
2319 	if (olen > nlen) {
2320 		BINC_RET(sp, tp->lb, tp->lb_len, tp->len + olen);
2321 		chlen = olen - nlen;
2322 		if (tp->insert != 0)
2323 			memmove(tp->lb + cno + 1 + chlen,
2324 			    tp->lb + cno + 1, tp->insert);
2325 
2326 		tp->len += chlen;
2327 		tp->owrite += chlen;
2328 		p = tp->lb + cno;
2329 		if (tp->lb[cno] == '\t')
2330 			for (cno += chlen; chlen--;)
2331 				*p++ = ' ';
2332 		else
2333 			for (kp = KEY_NAME(sp, tp->lb[cno]),
2334 			    cno += chlen; chlen--;)
2335 				*p++ = *kp++;
2336 	}
2337 	tp->lb[cno] = ch;
2338 	return (vs_change(sp, tp->lno, LINE_RESET));
2339 }
2340 
2341 /*
2342  * txt_err --
2343  *	Handle an error during input processing.
2344  */
2345 static void
2346 txt_err(sp, tiqh)
2347 	SCR *sp;
2348 	TEXTH *tiqh;
2349 {
2350 	recno_t lno;
2351 
2352 	/*
2353 	 * The problem with input processing is that the cursor is at an
2354 	 * indeterminate position since some input may have been lost due
2355 	 * to a malloc error.  So, try to go back to the place from which
2356 	 * the cursor started, knowing that it may no longer be available.
2357 	 *
2358 	 * We depend on at least one line number being set in the text
2359 	 * chain.
2360 	 */
2361 	for (lno = tiqh->cqh_first->lno;
2362 	    !db_exist(sp, lno) && lno > 0; --lno);
2363 
2364 	sp->lno = lno == 0 ? 1 : lno;
2365 	sp->cno = 0;
2366 
2367 	/* Redraw the screen, just in case. */
2368 	F_SET(sp, SC_SCR_REDRAW);
2369 }
2370 
2371 /*
2372  * txt_hex --
2373  *	Let the user insert any character value they want.
2374  *
2375  * !!!
2376  * This is an extension.  The pattern "^X[0-9a-fA-F]*" is a way
2377  * for the user to specify a character value which their keyboard
2378  * may not be able to enter.
2379  */
2380 static int
2381 txt_hex(sp, tp)
2382 	SCR *sp;
2383 	TEXT *tp;
2384 {
2385 	CHAR_T savec;
2386 	size_t len, off;
2387 	u_long value;
2388 	char *p, *wp;
2389 
2390 	/*
2391 	 * Null-terminate the string.  Since nul isn't a legal hex value,
2392 	 * this should be okay, and lets us use a local routine, which
2393 	 * presumably understands the character set, to convert the value.
2394 	 */
2395 	savec = tp->lb[tp->cno];
2396 	tp->lb[tp->cno] = 0;
2397 
2398 	/* Find the previous CH_HEX character. */
2399 	for (off = tp->cno - 1, p = tp->lb + off, len = 0;; --p, --off, ++len) {
2400 		if (*p == CH_HEX) {
2401 			wp = p + 1;
2402 			break;
2403 		}
2404 		/* Not on this line?  Shouldn't happen. */
2405 		if (off == tp->ai || off == tp->offset)
2406 			goto nothex;
2407 	}
2408 
2409 	/* If length of 0, then it wasn't a hex value. */
2410 	if (len == 0)
2411 		goto nothex;
2412 
2413 	/* Get the value. */
2414 	errno = 0;
2415 	value = strtol(wp, NULL, 16);
2416 	if (errno || value > MAX_CHAR_T) {
2417 nothex:		tp->lb[tp->cno] = savec;
2418 		return (0);
2419 	}
2420 
2421 	/* Restore the original character. */
2422 	tp->lb[tp->cno] = savec;
2423 
2424 	/* Adjust the bookkeeping. */
2425 	tp->cno -= len;
2426 	tp->len -= len;
2427 	tp->lb[tp->cno - 1] = value;
2428 
2429 	/* Copy down any overwrite characters. */
2430 	if (tp->owrite)
2431 		memmove(tp->lb + tp->cno, tp->lb + tp->cno + len, tp->owrite);
2432 
2433 	/* Copy down any insert characters. */
2434 	if (tp->insert)
2435 		memmove(tp->lb + tp->cno + tp->owrite,
2436 		    tp->lb + tp->cno + tp->owrite + len, tp->insert);
2437 
2438 	return (0);
2439 }
2440 
2441 /*
2442  * txt_insch --
2443  *
2444  * !!!
2445  * Historic vi did a special screen optimization for tab characters.  As an
2446  * example, for the keystrokes "iabcd<esc>0C<tab>", the tab overwrote the
2447  * rest of the string when it was displayed.
2448  *
2449  * Because early versions of this implementation redisplayed the entire line
2450  * on each keystroke, the "bcd" was pushed to the right as it ignored that
2451  * the user had "promised" to change the rest of the characters.  However,
2452  * the historic vi implementation had an even worse bug: given the keystrokes
2453  * "iabcd<esc>0R<tab><esc>", the "bcd" disappears, and magically reappears
2454  * on the second <esc> key.
2455  *
2456  * POSIX 1003.2 requires (will require) that this be fixed, specifying that
2457  * vi overwrite characters the user has committed to changing, on the basis
2458  * of the screen space they require, but that it not overwrite other characters.
2459  */
2460 static int
2461 txt_insch(sp, tp, chp, flags)
2462 	SCR *sp;
2463 	TEXT *tp;
2464 	CHAR_T *chp;
2465 	u_int flags;
2466 {
2467 	CHAR_T *kp, savech;
2468 	size_t chlen, cno, copydown, olen, nlen;
2469 	char *p;
2470 
2471 	/*
2472 	 * The 'R' command does one-for-one replacement, because there's
2473 	 * no way to know how many characters the user intends to replace.
2474 	 */
2475 	if (LF_ISSET(TXT_REPLACE)) {
2476 		if (tp->owrite) {
2477 			--tp->owrite;
2478 			tp->lb[tp->cno++] = *chp;
2479 			return (0);
2480 		}
2481 	} else if (tp->owrite) {		/* Overwrite a character. */
2482 		cno = tp->cno;
2483 
2484 		/*
2485 		 * If the old or new characters are tabs, then the length of the
2486 		 * display depends on the character position in the display.  We
2487 		 * don't even try to handle this here, just ask the screen.
2488 		 */
2489 		if (*chp == '\t') {
2490 			savech = tp->lb[cno];
2491 			tp->lb[cno] = '\t';
2492 			(void)vs_columns(sp, tp->lb, tp->lno, &cno, &nlen);
2493 			tp->lb[cno] = savech;
2494 		} else
2495 			nlen = KEY_LEN(sp, *chp);
2496 
2497 		/*
2498 		 * Eat overwrite characters until we run out of them or we've
2499 		 * handled the length of the new character.  If we only eat
2500 		 * part of an overwrite character, break it into its component
2501 		 * elements and display the remaining components.
2502 		 */
2503 		for (copydown = 0; nlen != 0 && tp->owrite != 0;) {
2504 			--tp->owrite;
2505 
2506 			if (tp->lb[cno] == '\t')
2507 				(void)vs_columns(sp,
2508 				    tp->lb, tp->lno, &cno, &olen);
2509 			else
2510 				olen = KEY_LEN(sp, tp->lb[cno]);
2511 
2512 			if (olen == nlen) {
2513 				nlen = 0;
2514 				break;
2515 			}
2516 			if (olen < nlen) {
2517 				++copydown;
2518 				nlen -= olen;
2519 			} else {
2520 				BINC_RET(sp,
2521 				    tp->lb, tp->lb_len, tp->len + olen);
2522 				chlen = olen - nlen;
2523 				memmove(tp->lb + cno + 1 + chlen,
2524 				    tp->lb + cno + 1, tp->owrite + tp->insert);
2525 
2526 				tp->len += chlen;
2527 				tp->owrite += chlen;
2528 				if (tp->lb[cno] == '\t')
2529 					for (p = tp->lb + cno + 1; chlen--;)
2530 						*p++ = ' ';
2531 				else
2532 					for (kp =
2533 					    KEY_NAME(sp, tp->lb[cno]) + nlen,
2534 					    p = tp->lb + cno + 1; chlen--;)
2535 						*p++ = *kp++;
2536 				nlen = 0;
2537 				break;
2538 			}
2539 		}
2540 
2541 		/*
2542 		 * If had to erase several characters, we adjust the total
2543 		 * count, and if there are any characters left, shift them
2544 		 * into position.
2545 		 */
2546 		if (copydown != 0 && (tp->len -= copydown) != 0)
2547 			memmove(tp->lb + cno, tp->lb + cno + copydown,
2548 			    tp->owrite + tp->insert + copydown);
2549 
2550 		/* If we had enough overwrite characters, we're done. */
2551 		if (nlen == 0) {
2552 			tp->lb[tp->cno++] = *chp;
2553 			return (0);
2554 		}
2555 	}
2556 
2557 	/* Check to see if the character fits into the input buffer. */
2558 	BINC_RET(sp, tp->lb, tp->lb_len, tp->len + 1);
2559 
2560 	++tp->len;
2561 	if (tp->insert) {			/* Insert a character. */
2562 		if (tp->insert == 1)
2563 			tp->lb[tp->cno + 1] = tp->lb[tp->cno];
2564 		else
2565 			memmove(tp->lb + tp->cno + 1,
2566 			    tp->lb + tp->cno, tp->owrite + tp->insert);
2567 	}
2568 	tp->lb[tp->cno++] = *chp;
2569 	return (0);
2570 }
2571 
2572 /*
2573  * txt_isrch --
2574  *	Do an incremental search.
2575  */
2576 static int
2577 txt_isrch(sp, vp, tp, is_flagsp)
2578 	SCR *sp;
2579 	VICMD *vp;
2580 	TEXT *tp;
2581 	u_int8_t *is_flagsp;
2582 {
2583 	MARK start;
2584 	recno_t lno;
2585 	u_int sf;
2586 
2587 	/* If it's a one-line screen, we don't do incrementals. */
2588 	if (IS_ONELINE(sp)) {
2589 		FL_CLR(*is_flagsp, IS_RUNNING);
2590 		return (0);
2591 	}
2592 
2593 	/*
2594 	 * If the user erases back to the beginning of the buffer, there's
2595 	 * nothing to search for.  Reset the cursor to the starting point.
2596 	 */
2597 	if (tp->cno <= 1) {
2598 		vp->m_final = vp->m_start;
2599 		return (0);
2600 	}
2601 
2602 	/*
2603 	 * If it's an RE quote character, and not quoted, ignore it until
2604 	 * we get another character.
2605 	 */
2606 	if (tp->lb[tp->cno - 1] == '\\' &&
2607 	    (tp->cno == 2 || tp->lb[tp->cno - 2] != '\\'))
2608 		return (0);
2609 
2610 	/*
2611 	 * If it's a magic shell character, and not quoted, reset the cursor
2612 	 * to the starting point.
2613 	 */
2614 	if (strchr(O_STR(sp, O_SHELLMETA), tp->lb[tp->cno - 1]) != NULL &&
2615 	    (tp->cno == 2 || tp->lb[tp->cno - 2] != '\\'))
2616 		vp->m_final = vp->m_start;
2617 
2618 	/*
2619 	 * If we see the search pattern termination character, then quit doing
2620 	 * an incremental search.  There may be more, e.g., ":/foo/;/bar/",
2621 	 * and we can't handle that incrementally.  Also, reset the cursor to
2622 	 * the original location, the ex search routines don't know anything
2623 	 * about incremental searches.
2624 	 */
2625 	if (tp->lb[0] == tp->lb[tp->cno - 1] &&
2626 	    (tp->cno == 2 || tp->lb[tp->cno - 2] != '\\')) {
2627 		vp->m_final = vp->m_start;
2628 		FL_CLR(*is_flagsp, IS_RUNNING);
2629 		return (0);
2630 	}
2631 
2632 	/*
2633 	 * Remember the input line and discard the special input map,
2634 	 * but don't overwrite the input line on the screen.
2635 	 */
2636 	lno = tp->lno;
2637 	F_SET(VIP(sp), VIP_S_MODELINE);
2638 	F_CLR(sp, SC_TINPUT | SC_TINPUT_INFO);
2639 	if (txt_map_end(sp))
2640 		return (1);
2641 
2642 	/*
2643 	 * Specify a starting point and search.  If we find a match, move to
2644 	 * it and refresh the screen.  If we didn't find the match, then we
2645 	 * beep the screen.  When searching from the original cursor position,
2646 	 * we have to move the cursor, otherwise, we don't want to move the
2647 	 * cursor in case the text at the current position continues to match.
2648 	 */
2649 	if (FL_ISSET(*is_flagsp, IS_RESTART)) {
2650 		start = vp->m_start;
2651 		sf = SEARCH_SET;
2652 	} else {
2653 		start = vp->m_final;
2654 		sf = SEARCH_INCR | SEARCH_SET;
2655 	}
2656 
2657 	if (tp->lb[0] == '/' ?
2658 	    !f_search(sp,
2659 	    &start, &vp->m_final, tp->lb + 1, tp->cno - 1, NULL, sf) :
2660 	    !b_search(sp,
2661 	    &start, &vp->m_final, tp->lb + 1, tp->cno - 1, NULL, sf)) {
2662 		sp->lno = vp->m_final.lno;
2663 		sp->cno = vp->m_final.cno;
2664 		FL_CLR(*is_flagsp, IS_RESTART);
2665 
2666 		if (!KEYS_WAITING(sp) && vs_refresh(sp, 0))
2667 			return (1);
2668 	} else
2669 		FL_SET(*is_flagsp, IS_RESTART);
2670 
2671 	/* Reinstantiate the special input map. */
2672 	if (txt_map_init(sp))
2673 		return (1);
2674 	F_CLR(VIP(sp), VIP_S_MODELINE);
2675 	F_SET(sp, SC_TINPUT | SC_TINPUT_INFO);
2676 
2677 	/* Reset the line number of the input line. */
2678 	tp->lno = TMAP[0].lno;
2679 
2680 	/*
2681 	 * If the colon command-line moved, i.e. the screen scrolled,
2682 	 * refresh the input line.
2683 	 *
2684 	 * XXX
2685 	 * We shouldn't be calling vs_line, here -- we need dirty bits
2686 	 * on entries in the SMAP array.
2687 	 */
2688 	if (lno != TMAP[0].lno) {
2689 		if (vs_line(sp, &TMAP[0], NULL, NULL))
2690 			return (1);
2691 		(void)sp->gp->scr_refresh(sp, 0);
2692 	}
2693 	return (0);
2694 }
2695 
2696 /*
2697  * txt_resolve --
2698  *	Resolve the input text chain into the file.
2699  */
2700 static int
2701 txt_resolve(sp, tiqh, flags)
2702 	SCR *sp;
2703 	TEXTH *tiqh;
2704 	u_int32_t flags;
2705 {
2706 	VI_PRIVATE *vip;
2707 	TEXT *tp;
2708 	recno_t lno;
2709 	int changed;
2710 
2711 	/*
2712 	 * The first line replaces a current line, and all subsequent lines
2713 	 * are appended into the file.  Resolve autoindented characters for
2714 	 * each line before committing it.  If the latter causes the line to
2715 	 * change, we have to redisplay it, otherwise the information cached
2716 	 * about the line will be wrong.
2717 	 */
2718 	vip = VIP(sp);
2719 	tp = tiqh->cqh_first;
2720 
2721 	if (LF_ISSET(TXT_AUTOINDENT))
2722 		txt_ai_resolve(sp, tp, &changed);
2723 	else
2724 		changed = 0;
2725 	if (db_set(sp, tp->lno, tp->lb, tp->len) ||
2726 	    changed && vs_change(sp, tp->lno, LINE_RESET))
2727 		return (1);
2728 
2729 	for (lno = tp->lno; (tp = tp->q.cqe_next) != (void *)&sp->tiq; ++lno) {
2730 		if (LF_ISSET(TXT_AUTOINDENT))
2731 			txt_ai_resolve(sp, tp, &changed);
2732 		else
2733 			changed = 0;
2734 		if (db_append(sp, 0, lno, tp->lb, tp->len) ||
2735 		    changed && vs_change(sp, tp->lno, LINE_RESET))
2736 			return (1);
2737 	}
2738 
2739 	/*
2740 	 * Clear the input flag, the look-aside buffer is no longer valid.
2741 	 * Has to be done as part of text resolution, or upon return we'll
2742 	 * be looking at incorrect data.
2743 	 */
2744 	F_CLR(sp, SC_TINPUT);
2745 
2746 	return (0);
2747 }
2748 
2749 /*
2750  * txt_showmatch --
2751  *	Show a character match.
2752  *
2753  * !!!
2754  * Historic vi tried to display matches even in the :colon command line.
2755  * I think not.
2756  */
2757 static int
2758 txt_showmatch(sp, tp)
2759 	SCR *sp;
2760 	TEXT *tp;
2761 {
2762 	GS *gp;
2763 	VCS cs;
2764 	MARK m;
2765 	int cnt, endc, startc;
2766 
2767 	gp = sp->gp;
2768 
2769 	/*
2770 	 * Do a refresh first, in case we haven't done one in awhile,
2771 	 * so the user can see what we're complaining about.
2772 	 */
2773 	UPDATE_POSITION(sp, tp);
2774 	if (vs_refresh(sp, 1))
2775 		return (1);
2776 
2777 	/*
2778 	 * We don't display the match if it's not on the screen.  Find
2779 	 * out what the first character on the screen is.
2780 	 */
2781 	if (vs_sm_position(sp, &m, 0, P_TOP))
2782 		return (1);
2783 
2784 	/* Initialize the getc() interface. */
2785 	cs.cs_lno = tp->lno;
2786 	cs.cs_cno = tp->cno - 1;
2787 	if (cs_init(sp, &cs))
2788 		return (1);
2789 	startc = (endc = cs.cs_ch)  == ')' ? '(' : '{';
2790 
2791 	/* Search for the match. */
2792 	for (cnt = 1;;) {
2793 		if (cs_prev(sp, &cs))
2794 			return (1);
2795 		if (cs.cs_flags != 0) {
2796 			if (cs.cs_flags == CS_EOF || cs.cs_flags == CS_SOF) {
2797 				msgq(sp, M_BERR,
2798 				    "Unmatched %s", KEY_NAME(sp, endc));
2799 				return (0);
2800 			}
2801 			continue;
2802 		}
2803 		if (cs.cs_ch == endc)
2804 			++cnt;
2805 		else if (cs.cs_ch == startc && --cnt == 0)
2806 			break;
2807 	}
2808 
2809 	/* If the match is on the screen, move to it. */
2810 	if (cs.cs_lno < m.lno || cs.cs_lno == m.lno && cs.cs_cno < m.cno)
2811 		return (0);
2812 	sp->lno = cs.cs_lno;
2813 	sp->cno = cs.cs_cno;
2814 	if (vs_refresh(sp, 1))
2815 		return (1);
2816 
2817 	/* Wait for timeout or character arrival. */
2818 	return (v_event_get(sp,
2819 	    NULL, O_VAL(sp, O_MATCHTIME) * 100, EC_TIMEOUT));
2820 }
2821 
2822 /*
2823  * txt_margin --
2824  *	Handle margin wrap.
2825  */
2826 static int
2827 txt_margin(sp, tp, wmtp, didbreak, flags)
2828 	SCR *sp;
2829 	TEXT *tp, *wmtp;
2830 	int *didbreak;
2831 	u_int32_t flags;
2832 {
2833 	VI_PRIVATE *vip;
2834 	size_t len, off;
2835 	char *p, *wp;
2836 
2837 	/* Find the nearest previous blank. */
2838 	for (off = tp->cno - 1, p = tp->lb + off, len = 0;; --off, --p, ++len) {
2839 		if (isblank(*p)) {
2840 			wp = p + 1;
2841 			break;
2842 		}
2843 
2844 		/*
2845 		 * If reach the start of the line, there's nowhere to break.
2846 		 *
2847 		 * !!!
2848 		 * Historic vi belled each time a character was entered after
2849 		 * crossing the margin until a space was entered which could
2850 		 * be used to break the line.  I don't as it tends to wake the
2851 		 * cats.
2852 		 */
2853 		if (off == tp->ai || off == tp->offset) {
2854 			*didbreak = 0;
2855 			return (0);
2856 		}
2857 	}
2858 
2859 	/*
2860 	 * Store saved information about the rest of the line in the
2861 	 * wrapmargin TEXT structure.
2862 	 *
2863 	 * !!!
2864 	 * The offset field holds the length of the current characters
2865 	 * that the user entered, but which are getting split to the new
2866 	 * line -- it's going to be used to set the cursor value when we
2867 	 * move to the new line.
2868 	 */
2869 	vip = VIP(sp);
2870 	wmtp->lb = p + 1;
2871 	wmtp->offset = len;
2872 	wmtp->insert = LF_ISSET(TXT_APPENDEOL) ?  tp->insert - 1 : tp->insert;
2873 	wmtp->owrite = tp->owrite;
2874 
2875 	/* Correct current bookkeeping information. */
2876 	tp->cno -= len;
2877 	if (LF_ISSET(TXT_APPENDEOL)) {
2878 		tp->len -= len + tp->owrite + (tp->insert - 1);
2879 		tp->insert = 1;
2880 	} else {
2881 		tp->len -= len + tp->owrite + tp->insert;
2882 		tp->insert = 0;
2883 	}
2884 	tp->owrite = 0;
2885 
2886 	/*
2887 	 * !!!
2888 	 * Delete any trailing whitespace from the current line.
2889 	 */
2890 	for (;; --p, --off) {
2891 		if (!isblank(*p))
2892 			break;
2893 		--tp->cno;
2894 		--tp->len;
2895 		if (off == tp->ai || off == tp->offset)
2896 			break;
2897 	}
2898 	*didbreak = 1;
2899 	return (0);
2900 }
2901 
2902 /*
2903  * txt_Rresolve --
2904  *	Resolve the input line for the 'R' command.
2905  */
2906 static void
2907 txt_Rresolve(sp, tiqh, tp, orig_len)
2908 	SCR *sp;
2909 	TEXTH *tiqh;
2910 	TEXT *tp;
2911 	const size_t orig_len;
2912 {
2913 	TEXT *ttp;
2914 	size_t input_len, retain;
2915 	char *p;
2916 
2917 	/*
2918 	 * Check to make sure that the cursor hasn't moved beyond
2919 	 * the end of the line.
2920 	 */
2921 	if (tp->owrite == 0)
2922 		return;
2923 
2924 	/*
2925 	 * Calculate how many characters the user has entered,
2926 	 * plus the blanks erased by <carriage-return>/<newline>s.
2927 	 */
2928 	for (ttp = tiqh->cqh_first, input_len = 0;;) {
2929 		input_len += ttp == tp ? tp->cno : ttp->len + ttp->R_erase;
2930 		if ((ttp = ttp->q.cqe_next) == (void *)&sp->tiq)
2931 			break;
2932 	}
2933 
2934 	/*
2935 	 * If the user has entered less characters than the original line
2936 	 * was long, restore any overwriteable characters to the original
2937 	 * characters.  These characters are entered as "insert characters",
2938 	 * because they're after the cursor and we don't want to lose them.
2939 	 * (This is okay because the R command has no insert characters.)
2940 	 * We set owrite to 0 so that the insert characters don't get copied
2941 	 * to somewhere else, which means that the line and the length have
2942 	 * to be adjusted here as well.
2943 	 *
2944 	 * We have to retrieve the original line because the original pinned
2945 	 * page has long since been discarded.  If it doesn't exist, that's
2946 	 * okay, the user just extended the file.
2947 	 */
2948 	if (input_len < orig_len) {
2949 		retain = MIN(tp->owrite, orig_len - input_len);
2950 		if (db_get(sp,
2951 		    tiqh->cqh_first->lno, DBG_FATAL | DBG_NOCACHE, &p, NULL))
2952 			return;
2953 		memcpy(tp->lb + tp->cno, p + input_len, retain);
2954 		tp->len -= tp->owrite - retain;
2955 		tp->owrite = 0;
2956 		tp->insert += retain;
2957 	}
2958 }
2959 
2960 /*
2961  * txt_nomorech --
2962  *	No more characters message.
2963  */
2964 static void
2965 txt_nomorech(sp)
2966 	SCR *sp;
2967 {
2968 	msgq(sp, M_BERR, "194|No more characters to erase");
2969 }
2970