Imported Upstream version 050325upstream/050325upstream

1 files changed, 1442 insertions, 0 deletions

diff --git a/ex_vmain.c b/ex_vmain.c
new file mode 100644
index 0000000..ac07f92
--- /dev/null
+++ b/ex_vmain.c
@@ -0,0 +1,1442 @@
+/*
+ * This code contains changes by
+ *      Gunnar Ritter, Freiburg i. Br., Germany, 2002. All rights reserved.
+ *
+ * Conditions 1, 2, and 4 and the no-warranty notice below apply
+ * to these changes.
+ *
+ *
+ * Copyright (c) 1980, 1993
+ * 	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ * 	This product includes software developed by the University of
+ * 	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *
+ * Copyright(C) Caldera International Inc. 2001-2002. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *   Redistributions of source code and documentation must retain the
+ *    above copyright notice, this list of conditions and the following
+ *    disclaimer.
+ *   Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *   All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed or owned by Caldera
+ *      International, Inc.
+ *   Neither the name of Caldera International, Inc. nor the names of
+ *    other contributors may be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
+ * INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE
+ * LIABLE FOR ANY DIRECT, INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef	lint
+#ifdef	DOSCCS
+static char sccsid[] = "@(#)ex_vmain.c	1.29 (gritter) 2/17/05";
+#endif
+#endif
+
+/* from ex_vmain.c	7.7 (Berkeley) 6/7/85 */
+
+#include "ex.h"
+#include "ex_tty.h"
+#include "ex_vis.h"
+
+/*
+ * This is the main routine for visual.
+ * We here decode the count and possible named buffer specification
+ * preceding a command and interpret a few of the commands.
+ * Commands which involve a target (i.e. an operator) are decoded
+ * in the routine operate in ex_voperate.c.
+ */
+
+#define	forbid(a)	{ if (a) goto fonfon; }
+
+void 
+vmain(void)
+{
+	int c, cnt, i;
+	cell esave[TUBECOLS];
+	char *oglobp;
+	short d;
+	line *addr;
+	int ind, nlput;
+	int shouldpo = 0;
+	int onumber = 0, olist = 0;
+	void (*OPline)(int) = NULL;
+	int (*OPutchar)(int) = NULL;
+
+	CLOBBGRD(c);
+	CLOBBGRD(cnt);
+	CLOBBGRD(i);
+	CLOBBGRD(oglobp);
+	CLOBBGRD(addr);
+	CLOBBGRD(shouldpo);
+	CLOBBGRD(onumber);
+	CLOBBGRD(olist);
+	CLOBBGRD(OPline);
+	CLOBBGRD(OPutchar);
+
+	vch_mac = VC_NOTINMAC;
+
+	/*
+	 * If we started as a vi command (on the command line)
+	 * then go process initial commands (recover, next or tag).
+	 */
+	if (initev) {
+		oglobp = globp;
+		globp = initev;
+		hadcnt = cnt = 0;
+		i = tchng;
+		addr = dot;
+		goto doinit;
+	}
+
+	/*
+	 * NB:
+	 *
+	 * The current line is always in the line buffer linebuf,
+	 * and the cursor at the position cursor.  You should do
+	 * a vsave() before moving off the line to make sure the disk
+	 * copy is updated if it has changed, and a getDOT() to get
+	 * the line back if you mung linebuf.  The motion
+	 * routines in ex_vwind.c handle most of this.
+	 */
+	for (;;) {
+		/*
+		 * Decode a visual command.
+		 * First sync the temp file if there has been a reasonable
+		 * amount of change.  Clear state for decoding of next
+		 * command.
+		 */
+		TSYNC();
+		vglobp = 0;
+		vreg = 0;
+		hold = 0;
+		seenprompt = 1;
+		wcursor = 0;
+		Xhadcnt = hadcnt = 0;
+		Xcnt = cnt = 1;
+		splitw = 0;
+		if (i = holdupd) {
+			if (state == VISUAL)
+				ignore(peekkey());
+			holdupd = 0;
+/*
+			if (LINE(0) < ZERO) {
+				vclear();
+				vcnt = 0;
+				i = 3;
+			}
+*/
+			if (state != VISUAL) {
+				vcnt = 0;
+				vsave();
+				vrepaint(cursor);
+			} else if (i == 3)
+				vredraw(WTOP);
+			else
+				vsync(WTOP);
+			vfixcurs();
+		}
+
+		/*
+		 * Gobble up counts and named buffer specifications.
+		 */
+		for (;;) {
+looptop:
+#ifdef MDEBUG
+			if (trace)
+				fprintf(trace, "pc=%c",peekkey());
+#endif
+			if (xisdigit(peekkey()) && peekkey() != '0') {
+				hadcnt = 1;
+				cnt = vgetcnt();
+				forbid (cnt <= 0);
+			}
+			if (peekkey() != '"')
+				break;
+			ignore(getkey()), c = getkey();
+			/*
+			 * Buffer names be letters or digits.
+			 * But not '0' as that is the source of
+			 * an 'empty' named buffer spec in the routine
+			 * kshift (see ex_temp.c).
+			 */
+			forbid (c == '0' || !xisalpha(c) && !xisdigit(c));
+			vreg = c;
+		}
+reread:
+		/*
+		 * Come to reread from below after some macro expansions.
+		 * The call to map allows use of function key pads
+		 * by performing a terminal dependent mapping of inputs.
+		 */
+#ifdef MDEBUG
+		if (trace)
+			fprintf(trace,"pcb=%c,",peekkey());
+#endif
+		op = getkey();
+		maphopcnt = 0;
+		do {
+			/*
+			 * Keep mapping the char as long as it changes.
+			 * This allows for double mappings, e.g., q to #,
+			 * #1 to something else.
+			 */
+			c = op;
+			op = map(c,arrows);
+#ifdef MDEBUG
+			if (trace)
+				fprintf(trace,"pca=%c,",c);
+#endif
+			/*
+			 * Maybe the mapped to char is a count. If so, we have
+			 * to go back to the "for" to interpret it. Likewise
+			 * for a buffer name.
+			 */
+			if ((xisdigit(c) && c!='0') || c == '"') {
+				ungetkey(c);
+				goto looptop;
+			}
+			if (!value(REMAP)) {
+				c = op;
+				break;
+			}
+			if (++maphopcnt > 256)
+				error(catgets(catd, 1, 225,
+						"Infinite macro loop"));
+		} while (c != op);
+
+		/*
+		 * Begin to build an image of this command for possible
+		 * later repeat in the buffer workcmd.  It will be copied
+		 * to lastcmd by the routine setLAST
+		 * if/when completely specified.
+		 */
+		lastcp = workcmd;
+		if (!vglobp)
+			*lastcp++ = c;
+
+		/*
+		 * First level command decode.
+		 */
+		if (c == ATTN)
+			goto case_ATTN;
+		switch (c) {
+
+		/*
+		 * ^L		Clear screen e.g. after transmission error.
+		 */
+
+		/*
+		 * ^R		Retype screen, getting rid of @ lines.
+		 *		If in open, equivalent to ^L.
+		 *		On terminals where the right arrow key sends
+		 *		^L we make ^R act like ^L, since there is no
+		 *		way to get ^L.  These terminals (adm31, tvi)
+		 *		are intelligent so ^R is useless.  Soroc
+		 *		will probably foul this up, but nobody has
+		 *		one of them.
+		 */
+		case CTRL('l'):
+		case CTRL('r'):
+			if (c == CTRL('l') || (KR && *KR==CTRL('l'))) {
+				vclear();
+				vdirty(0, vcnt);
+			}
+			if (state != VISUAL) {
+				/*
+				 * Get a clean line, throw away the
+				 * memory of what is displayed now,
+				 * and move back onto the current line.
+				 */
+				vclean();
+				vcnt = 0;
+				vmoveto(dot, cursor, 0);
+				continue;
+			}
+			vredraw(WTOP);
+			/*
+			 * Weird glitch -- when we enter visual
+			 * in a very small window we may end up with
+			 * no lines on the screen because the line
+			 * at the top is too long.  This forces the screen
+			 * to be expanded to make room for it (after
+			 * we have printed @'s ick showing we goofed).
+			 */
+			if (vcnt == 0)
+				vrepaint(cursor);
+			vfixcurs();
+			continue;
+
+		/*
+		 * $		Escape just cancels the current command
+		 *		with a little feedback.
+		 */
+		case ESCAPE:
+			beep();
+			continue;
+
+		/*
+		 * @   		Macros. Bring in the macro and put it
+		 *		in vmacbuf, point vglobp there and punt.
+		 */
+		 case '@':
+			c = getesc();
+			if (c == 0)
+				continue;
+			if (c == '@')
+				c = lastmac;
+			if (xisupper(c))
+				c = xtolower(c);
+			forbid(!xislower(c));
+			lastmac = c;
+			vsave();
+			CATCH
+				char tmpbuf[BUFSIZ];
+
+				regbuf(c,tmpbuf,sizeof(vmacbuf));
+				macpush(tmpbuf, 1);
+			ONERR
+				lastmac = 0;
+				splitw = 0;
+				getDOT();
+				vrepaint(cursor);
+				continue;
+			ENDCATCH
+			vmacp = vmacbuf;
+			goto reread;
+
+		/*
+		 * .		Repeat the last (modifying) open/visual command.
+		 */
+		case '.':
+			/*
+			 * Check that there was a last command, and
+			 * take its count and named buffer unless they
+			 * were given anew.  Special case if last command
+			 * referenced a numeric named buffer -- increment
+			 * the number and go to a named buffer again.
+			 * This allows a sequence like "1pu.u.u...
+			 * to successively look for stuff in the kill chain
+			 * much as one does in EMACS with C-Y and M-Y.
+			 */
+			forbid (lastcmd[0] == 0);
+			if (hadcnt)
+				lastcnt = cnt;
+			if (vreg)
+				lastreg = vreg;
+			else if (xisdigit(lastreg) && lastreg < '9')
+				lastreg++;
+			vreg = lastreg;
+			cnt = lastcnt;
+			hadcnt = lasthad;
+			vglobp = lastcmd;
+			goto reread;
+
+		/*
+		 * ^U		Scroll up.  A count sticks around for
+		 *		future scrolls as the scroll amount.
+		 *		Attempt to hold the indentation from the
+		 *		top of the screen (in logical lines).
+		 *
+		 * BUG:		A ^U near the bottom of the screen
+		 *		on a dumb terminal (which can't roll back)
+		 *		causes the screen to be cleared and then
+		 *		redrawn almost as it was.  In this case
+		 *		one should simply move the cursor.
+		 */
+		case CTRL('u'):
+			if (hadcnt)
+				vSCROLL = cnt;
+			cnt = vSCROLL;
+			if (state == VISUAL)
+				ind = vcline, cnt += ind;
+			else
+				ind = 0;
+			vmoving = 0;
+			vup(cnt, ind, 1);
+			vnline(NOSTR);
+			continue;
+
+		/*
+		 * ^D		Scroll down.  Like scroll up.
+		 */
+		case CTRL('d'):
+#ifdef TRACE
+		if (trace)
+			fprintf(trace, "before vdown in ^D, dot=%d, wdot=%d, dol=%d\n", lineno(dot), lineno(wdot), lineno(dol));
+#endif
+			if (hadcnt)
+				vSCROLL = cnt;
+			cnt = vSCROLL;
+			if (state == VISUAL)
+				ind = vcnt - vcline - 1, cnt += ind;
+			else
+				ind = 0;
+			vmoving = 0;
+			vdown(cnt, ind, 1);
+#ifdef TRACE
+		if (trace)
+			fprintf(trace, "before vnline in ^D, dot=%d, wdot=%d, dol=%d\n", lineno(dot), lineno(wdot), lineno(dol));
+#endif
+			vnline(NOSTR);
+#ifdef TRACE
+		if (trace)
+			fprintf(trace, "after vnline in ^D, dot=%d, wdot=%d, dol=%d\n", lineno(dot), lineno(wdot), lineno(dol));
+#endif
+			continue;
+
+		/*
+		 * ^E		Glitch the screen down (one) line.
+		 *		Cursor left on same line in file.
+		 */
+		case CTRL('e'):
+			if (state != VISUAL)
+				continue;
+			if (!hadcnt)
+				cnt = 1;
+			/* Bottom line of file already on screen */
+			forbid(lineDOL()-lineDOT() <= vcnt-1-vcline);
+			ind = vcnt - vcline - 1 + cnt;
+			vdown(ind, ind, 1);
+			vnline(cursor);
+			continue;
+
+		/*
+		 * ^Y		Like ^E but up
+		 */
+		case CTRL('y'):
+			if (state != VISUAL)
+				continue;
+			if (!hadcnt)
+				cnt = 1;
+			forbid(lineDOT()-1<=vcline); /* line 1 already there */
+			ind = vcline + cnt;
+			vup(ind, ind, 1);
+			vnline(cursor);
+			continue;
+
+
+		/*
+		 * m		Mark position in mark register given
+		 *		by following letter.  Return is
+		 *		accomplished via ' or `; former
+		 *		to beginning of line where mark
+		 *		was set, latter to column where marked.
+		 */
+		case 'm':
+			/*
+			 * Getesc is generally used when a character
+			 * is read as a latter part of a command
+			 * to allow one to hit rubout/escape to cancel
+			 * what you have typed so far.  These characters
+			 * are mapped to 0 by the subroutine.
+			 */
+			c = getesc();
+			if (c == 0)
+				continue;
+
+			/*
+			 * Markreg checks that argument is a letter
+			 * and also maps ' and ` to the end of the range
+			 * to allow '' or `` to reference the previous
+			 * context mark.
+			 */
+			c = markreg(c);
+			forbid (c == 0);
+			vsave();
+			names[c - 'a'] = (*dot &~ 01);
+			ncols[c - 'a'] = cursor;
+			anymarks = 1;
+			continue;
+
+		/*
+		 * ^F		Window forwards, with 2 lines of continuity.
+		 *		Count repeats.
+		 */
+		case CTRL('f'):
+			vsave();
+			if (vcnt > 2) {
+				addr = dot + (vcnt - vcline) - 2 + (cnt-1)*basWLINES;
+				forbid(addr > dol);
+				dot = (line*)addr;
+				vcnt = vcline = 0;
+			}
+			vzop(0, 0, '+');
+			continue;
+
+		/*
+		 * ^B		Window backwards, with 2 lines of continuity.
+		 *		Inverse of ^F.
+		 */
+		case CTRL('b'):
+			vsave();
+			if (one + vcline != dot && vcnt > 2) {
+				addr = dot - vcline + 2 - (cnt-1)*basWLINES;
+				forbid (addr <= zero);
+				dot = (line*)addr;
+				vcnt = vcline = 0;
+			}
+			vzop(0, 0, '^');
+			continue;
+
+		/*
+		 * z		Screen adjustment, taking a following character:
+		 *			z<CR>		current line to top
+		 *			z<NL>		like z<CR>
+		 *			z-		current line to bottom
+		 *		also z+, z^ like ^F and ^B.
+		 *		A preceding count is line to use rather
+		 *		than current line.  A count between z and
+		 *		specifier character changes the screen size
+		 *		for the redraw.
+		 *
+		 */
+		case 'z':
+			if (state == VISUAL) {
+				i = vgetcnt();
+				if (i > 0)
+					vsetsiz(i);
+				c = getesc();
+				if (c == 0)
+					continue;
+			}
+			vsave();
+			vzop(hadcnt, cnt, c);
+			continue;
+
+		/*
+		 * Y		Yank lines, abbreviation for y_ or yy.
+		 *		Yanked lines can be put later if no
+		 *		changes intervene, or can be put in named
+		 *		buffers and put anytime in this session.
+		 */
+		case 'Y':
+			ungetkey('_');
+			c = 'y';
+			break;
+
+		/*
+		 * J		Join lines, 2 by default.  Count is number
+		 *		of lines to join (no join operator sorry.)
+		 */
+		case 'J':
+			forbid (dot == dol);
+			if (cnt == 1)
+				cnt = 2;
+			if (cnt > (i = dol - dot + 1))
+				cnt = i;
+			vsave();
+			vmacchng(1);
+			setLAST();
+			cursor = strend(linebuf);
+			vremote(cnt, join, 0);
+			notenam = "join";
+			vmoving = 0;
+			killU();
+			vreplace(vcline, cnt, 1);
+			if (!*cursor && cursor > linebuf)
+				cursor += skipleft(linebuf, cursor);
+			if (notecnt == 2)
+				notecnt = 0;
+			vrepaint(cursor);
+			continue;
+
+		/*
+		 * S		Substitute text for whole lines, abbrev for c_.
+		 *		Count is number of lines to change.
+		 */
+		case 'S':
+			ungetkey('_');
+			c = 'c';
+			break;
+
+		/*
+		 * O		Create a new line above current and accept new
+		 *		input text, to an escape, there.
+		 *		A count specifies, for dumb terminals when
+		 *		slowopen is not set, the number of physical
+		 *		line space to open on the screen.
+		 *
+		 * o		Like O, but opens lines below.
+		 */
+		case 'O':
+		case 'o':
+			vmacchng(1);
+			voOpen(c, cnt);
+			continue;
+
+		/*
+		 * C		Change text to end of line, short for c$.
+		 */
+		case 'C':
+			if (*cursor) {
+				ungetkey('$'), c = 'c';
+				break;
+			}
+			goto appnd;
+
+		/*
+		 * ~	Switch case of letter under cursor
+		 */
+		case '~':
+			vswitch(cnt);
+			continue;
+
+
+		/*
+		 * A		Append at end of line, short for $a.
+		 */
+		case 'A':
+			operate('$', 1);
+appnd:
+			c = 'a';
+			/* fall into ... */
+
+		/*
+		 * a		Appends text after cursor.  Text can continue
+		 *		through arbitrary number of lines.
+		 */
+		case 'a':
+			if (*cursor) {
+				if (state == HARDOPEN) {
+					int	c, n;
+					nextc(c, cursor, n);
+					putchar(c);
+					cursor += n;
+				} else
+					cursor += skipright(linebuf, cursor);
+			}
+			goto insrt;
+
+		/*
+		 * I		Insert at beginning of whitespace of line,
+		 *		short for ^i.
+		 */
+		case 'I':
+			operate('^', 1);
+			c = 'i';
+			/* fall into ... */
+
+		/*
+		 * R		Replace characters, one for one, by input
+		 *		(logically), like repeated r commands.
+		 *
+		 * BUG:		This is like the typeover mode of many other
+		 *		editors, and is only rarely useful.  Its
+		 *		implementation is a hack in a low level
+		 *		routine and it doesn't work very well, e.g.
+		 *		you can't move around within a R, etc.
+		 */
+		case 'R':
+			/* fall into... */
+
+		/*
+		 * i		Insert text to an escape in the buffer.
+		 *		Text is arbitrary.  This command reminds of
+		 *		the i command in bare teco.
+		 */
+		case 'i':
+insrt:
+			/*
+			 * Common code for all the insertion commands.
+			 * Save for redo, position cursor, prepare for append
+			 * at command and in visual undo.  Note that nothing
+			 * is doomed, unless R when all is, and save the
+			 * current line in a the undo temporary buffer.
+			 */
+			vmacchng(1);
+			setLAST();
+			vcursat(cursor);
+			prepapp();
+			vnoapp();
+			doomed = c == 'R' ? 10000 : 0;
+			if(FIXUNDO)
+				vundkind = VCHNG;
+			vmoving = 0;
+			CP(vutmp, linebuf);
+
+			/*
+			 * If this is a repeated command, then suppress
+			 * fake insert mode on dumb terminals which looks
+			 * ridiculous and wastes lots of time even at 9600B.
+			 */
+			if (vglobp)
+				hold = HOLDQIK;
+			vappend(c, cnt, 0);
+			continue;
+
+		/*
+		 * ^?		An attention, normally a ^?, just beeps.
+		 *		If you are a vi command within ex, then
+		 *		two ATTN's will drop you back to command mode.
+		 */
+case_ATTN:
+			beep();
+			if (initev || peekkey() != ATTN)
+				continue;
+			/* fall into... */
+
+		/*
+		 * ^\		A quit always gets command mode.
+		 */
+		case QUIT:
+			/*
+			 * Have to be careful if we were called
+			 *	g/xxx/vi
+			 * since a return will just start up again.
+			 * So we simulate an interrupt.
+			 */
+			if (inglobal)
+				onintr(SIGINT);
+			/* fall into... */
+
+#ifdef notdef
+		/*
+		 * q		Quit back to command mode, unless called as
+		 *		vi on command line in which case dont do it
+		 */
+		case 'q':	/* quit */
+			if (initev) {
+				vsave();
+				CATCH
+					error(catgets(catd, 1, 226,
+				"Q gets ex command mode, :q leaves vi"));
+				ENDCATCH
+				splitw = 0;
+				getDOT();
+				vrepaint(cursor);
+				continue;
+			}
+#endif
+			/* fall into... */
+
+		/*
+		 * Q		Is like q, but always gets to command mode
+		 *		even if command line invocation was as vi.
+		 */
+		case 'Q':
+			vsave();
+			/*
+			 * If we are in the middle of a macro, throw away
+			 * the rest and fix up undo.
+			 * This code copied from getbr().
+			 */
+			if (vmacp) {
+				vmacp = 0;
+				if (inopen == -1)	/* don't screw up undo for esc esc */
+					vundkind = VMANY;
+				inopen = 1;	/* restore old setting now that macro done */
+			}
+			return;
+
+
+		/*
+		 * ZZ		Like :x
+		 */
+		 case 'Z':
+			forbid(getkey() != 'Z');
+			oglobp = globp;
+			globp = "x";
+			vclrech(0);
+			goto gogo;
+			
+		/*
+		 * P		Put back text before cursor or before current
+		 *		line.  If text was whole lines goes back
+		 *		as whole lines.  If part of a single line
+		 *		or parts of whole lines splits up current
+		 *		line to form many new lines.
+		 *		May specify a named buffer, or the delete
+		 *		saving buffers 1-9.
+		 *
+		 * p		Like P but after rather than before.
+		 */
+		case 'P':
+		case 'p':
+			vmoving = 0;
+#ifdef notdef
+			forbid (!vreg && value(UNDOMACRO) && inopen < 0);
+#endif
+			/*
+			 * If previous delete was partial line, use an
+			 * append or insert to put it back so as to
+			 * use insert mode on intelligent terminals.
+			 */
+			if (!vreg && DEL[0]) {
+				forbid ((DEL[0] & (QUOTE|TRIM)) == OVERBUF);
+				vglobp = DEL;
+				ungetkey(c == 'p' ? 'a' : 'i');
+				goto reread;
+			}
+
+			/*
+			 * If a register wasn't specified, then make
+			 * sure there is something to put back.
+			 */
+			forbid (!vreg && unddol == dol);
+			/*
+			 * If we just did a macro the whole buffer is in
+			 * the undo save area.  We don't want to put THAT.
+			 */
+			forbid (vundkind == VMANY && undkind==UNDALL);
+			vsave();
+			vmacchng(1);
+			setLAST();
+			i = 0;
+			if (vreg && partreg(vreg) || !vreg && pkill[0]) {
+				/*
+				 * Restoring multiple lines which were partial
+				 * lines; will leave cursor in middle
+				 * of line after shoving restored text in to
+				 * split the current line.
+				 */
+				i++;
+				if (c == 'p' && *cursor)
+					cursor += skipright(linebuf, cursor);
+			} else {
+				/*
+				 * In whole line case, have to back up dot
+				 * for P; also want to clear cursor so
+				 * cursor will eventually be positioned
+				 * at the beginning of the first put line.
+				 */
+				cursor = 0;
+				if (c == 'P') {
+					dot--, vcline--;
+					c = 'p';
+				}
+			}
+			killU();
+
+			/*
+			 * The call to putreg can potentially
+			 * bomb since there may be nothing in a named buffer.
+			 * We thus put a catch in here.  If we didn't and
+			 * there was an error we would end up in command mode.
+			 */
+			addr = dol;	/* old dol */
+			CATCH
+				vremote(1, vreg ? putreg : put, vreg);
+			ONERR
+				if (vreg == -1) {
+					splitw = 0;
+					if (op == 'P')
+						dot++, vcline++;
+					goto pfixup;
+				}
+			ENDCATCH
+			splitw = 0;
+			nlput = dol - addr + 1;
+			if (!i) {
+				/*
+				 * Increment undap1, undap2 to make up
+				 * for their incorrect initialization in the
+				 * routine vremote before calling put/putreg.
+				 */
+				if (FIXUNDO)
+					undap1++, undap2++;
+				vcline++;
+				nlput--;
+
+				/*
+				 * After a put want current line first line,
+				 * and dot was made the last line put in code
+				 * run so far.  This is why we increment vcline
+				 * above and decrease dot here.
+				 */
+				dot -= nlput - 1;
+			}
+#ifdef TRACE
+			if (trace)
+				fprintf(trace, "vreplace(%d, %d, %d), undap1=%d, undap2=%d, dot=%d\n", vcline, i, nlput, lineno(undap1), lineno(undap2), lineno(dot));
+#endif
+			vreplace(vcline, i, nlput);
+			if (state != VISUAL) {
+				/*
+				 * Special case in open mode.
+				 * Force action on the screen when a single
+				 * line is put even if it is identical to
+				 * the current line, e.g. on YP; otherwise
+				 * you can't tell anything happened.
+				 */
+				vjumpto(dot, cursor, '.');
+				continue;
+			}
+pfixup:
+			vrepaint(cursor);
+			vfixcurs();
+			continue;
+
+		/*
+		 * ^^		Return to previous file.
+		 *		Like a :e #, and thus can be used after a
+		 *		"No Write" diagnostic.
+		 */
+		case CTRL('^'):
+			forbid (hadcnt);
+			vsave();
+			ckaw();
+			oglobp = globp;
+			if (value(AUTOWRITE))
+				globp = "e! #";
+			else
+				globp = "e #";
+			goto gogo;
+
+		/*
+		 * ^]		Takes word after cursor as tag, and then does
+		 *		tag command.  Read ``go right to''.
+		 */
+		case CTRL(']'):
+			grabtag();
+			oglobp = globp;
+			globp = "tag";
+			goto gogo;
+
+		/*
+		 * &		Like :&
+		 */
+		 case '&':
+			oglobp = globp;
+			globp = "&";
+			goto gogo;
+			
+		/*
+		 * ^G		Bring up a status line at the bottom of
+		 *		the screen, like a :file command.
+		 *
+		 * BUG:		Was ^S but doesn't work in cbreak mode
+		 */
+		case CTRL('g'):
+			oglobp = globp;
+			globp = "file";
+gogo:
+			addr = dot;
+			vsave();
+			goto doinit;
+
+#ifdef SIGTSTP
+		/*
+		 * ^Z:	suspend editor session and temporarily return
+		 * 	to shell.  Only works with Berkeley/IIASA process
+		 *	control in kernel.
+		 */
+		case CTRL('z'):
+			forbid(dosusp == 0 || !ldisc);
+			vsave();
+			oglobp = globp;
+			globp = "stop";
+			goto gogo;
+#endif
+
+		/*
+		 * :		Read a command from the echo area and
+		 *		execute it in command mode.
+		 */
+		case ':':
+			forbid (hadcnt);
+			vsave();
+			i = tchng;
+			addr = dot;
+			if (readecho(c)) {
+				esave[0] = 0;
+				goto fixup;
+			}
+			getDOT();
+			/*
+			 * Use the visual undo buffer to store the global
+			 * string for command mode, since it is idle right now.
+			 */
+			oglobp = globp;
+			CP(vutmp, genbuf+1);
+			globp = vutmp;
+doinit:
+			esave[0] = 0;
+			fixech();
+
+			/*
+			 * Have to finagle around not to lose last
+			 * character after this command (when run from ex
+			 * command mode).  This is clumsy.
+			 */
+			d = peekc; ungetchar(0);
+			if (shouldpo) {
+				/*
+				 * So after a "Hit return..." ":", we do
+				 * another "Hit return..." the next time
+				 */
+				pofix();
+				shouldpo = 0;
+			}
+			CATCH
+				/*
+				 * Save old values of options so we can
+				 * notice when they change; switch into
+				 * cooked mode so we are interruptible.
+				 */
+				onumber = value(NUMBER);
+				olist = value(LIST);
+				OPline = Pline;
+				OPutchar = Putchar;
+				commands(1, 1);
+				if (dot == zero && dol > zero)
+					dot = one;
+			ONERR
+				copy(esave, vtube[WECHO],
+						TUBECOLS * sizeof *esave);
+			ENDCATCH
+			fixol();
+			Pline = OPline;
+			Putchar = OPutchar;
+			ungetchar(d);
+			if (globp && tflag < 0) {
+				tflag = 0;
+				goto doinit;
+			}
+			globp = oglobp;
+
+			/*
+			 * If we ended up with no lines in the buffer, make
+			 * a line, and don't consider the buffer changed.
+			 */
+			if (dot == zero) {
+				fixzero();
+				/*synced();*/
+			}
+			splitw = 0;
+
+			/*
+			 * Special case: did list/number options change?
+			 */
+			if (onumber != value(NUMBER))
+				setnumb(value(NUMBER));
+			if (olist != value(LIST))
+				setlist(value(LIST));
+
+fixup:
+			/*
+			 * If a change occurred, other than
+			 * a write which clears changes, then
+			 * we should allow an undo even if .
+			 * didn't move.
+			 *
+			 * BUG: You can make this wrong by
+			 * tricking around with multiple commands
+			 * on one line of : escape, and including
+			 * a write command there, but its not
+			 * worth worrying about.
+			 */
+			if (FIXUNDO && tchng && tchng != i)
+				vundkind = VMANY, cursor = 0;
+
+			/*
+			 * If we are about to do another :, hold off
+			 * updating of screen.
+			 */
+			if (vcnt < 0 && Peekkey == ':') {
+				getDOT();
+				shouldpo = 1;
+				continue;
+			}
+			shouldpo = 0;
+
+			/*
+			 * In the case where the file being edited is
+			 * new; e.g. if the initial state hasn't been
+			 * saved yet, then do so now.
+			 */
+			if (unddol == truedol) {
+				vundkind = VNONE;
+				Vlines = lineDOL();
+				if (!inglobal)
+					savevis();
+				addr = zero;
+				vcnt = 0;
+				if (esave[0] == 0)
+					copy(esave, vtube[WECHO],
+						TUBECOLS * sizeof *esave);
+			}
+
+			/*
+			 * If the current line moved reset the cursor position.
+			 */
+			if (dot != addr) {
+				vmoving = 0;
+				cursor = 0;
+			}
+
+			/*
+			 * If current line is not on screen or if we are
+			 * in open mode and . moved, then redraw.
+			 */
+			i = vcline + (dot - addr);
+			if (i < 0 || i >= vcnt && i >= -vcnt || state != VISUAL && dot != addr) {
+				if (state == CRTOPEN)
+					vup1();
+				if (vcnt > 0)
+					vcnt = 0;
+				vjumpto(dot, (char *) 0, '.');
+			} else {
+				/*
+				 * Current line IS on screen.
+				 * If we did a [Hit return...] then
+				 * restore vcnt and clear screen if in visual
+				 */
+				vcline = i;
+				if (vcnt < 0) {
+					vcnt = -vcnt;
+					if (state == VISUAL)
+						vclear();
+					else if (state == CRTOPEN) {
+						vcnt = 0;
+					}
+				}
+
+				/*
+				 * Limit max value of vcnt based on $
+				 */
+				i = vcline + lineDOL() - lineDOT() + 1;
+				if (i < vcnt)
+					vcnt = i;
+				
+				/*
+				 * Dirty and repaint.
+				 */
+				vdirty(0, TLINES);
+				vrepaint(cursor);
+			}
+
+			/*
+			 * If in visual, put back the echo area
+			 * if it was clobberred.
+			 */
+			if (state == VISUAL) {
+				int sdc = destcol, sdl = destline;
+
+				splitw++;
+				vigoto(WECHO, 0);
+				for (i = 0; i < TUBECOLS - 1; i++) {
+					if (esave[i] == 0)
+						break;
+					vputchar(esave[i]);
+				}
+				splitw = 0;
+				vgoto(sdl, sdc);
+			}
+			continue;
+
+		/*
+		 * u		undo the last changing command.
+		 */
+		case 'u':
+			vundo(1);
+			continue;
+
+		/*
+		 * U		restore current line to initial state.
+		 */
+		case 'U':
+			vUndo();
+			continue;
+
+fonfon:
+			beep();
+			vmacp = 0;
+			inopen = 1;	/* might have been -1 */
+			continue;
+		}
+
+		/*
+		 * Rest of commands are decoded by the operate
+		 * routine.
+		 */
+		operate(c, cnt);
+	}
+}
+
+/*
+ * Grab the word after the cursor so we can look for it as a tag.
+ */
+void 
+grabtag(void)
+{
+	register char *cp, *dp;
+
+	cp = vpastwh(cursor);
+	if (*cp) {
+		dp = lasttag;
+		do {
+			if (dp < &lasttag[sizeof lasttag - 2])
+				*dp++ = *cp;
+			cp++;
+		} while (isalpha(*cp&0377) || isdigit(*cp&0377)
+				|| *cp == '_'
+#ifdef LISPCODE
+			|| (value(LISP) && *cp == '-')
+#endif /* LISPCODE */
+			);
+		*dp++ = 0;
+	}
+}
+
+/*
+ * Before appending lines, set up addr1 and
+ * the command mode undo information.
+ */
+void 
+prepapp(void)
+{
+
+	addr1 = dot;
+	deletenone();
+	addr1++;
+	appendnone();
+}
+
+/*
+ * Execute function f with the address bounds addr1
+ * and addr2 surrounding cnt lines starting at dot.
+ */
+void 
+vremote(int cnt, void (*f)(int), int arg)
+{
+	register int oing = inglobal;
+
+	addr1 = dot;
+	addr2 = dot + cnt - 1;
+	inglobal = 0;
+	if (FIXUNDO)
+		undap1 = undap2 = dot;
+	(*f)(arg);
+	inglobal = oing;
+	if (FIXUNDO)
+		vundkind = VMANY;
+	vmcurs = 0;
+}
+
+/*
+ * Save the current contents of linebuf, if it has changed.
+ */
+void 
+vsave(void)
+{
+	char temp[LBSIZE];
+
+	CP(temp, linebuf);
+	if (FIXUNDO && vundkind == VCHNG || vundkind == VCAPU) {
+		/*
+		 * If the undo state is saved in the temporary buffer
+		 * vutmp, then we sync this into the temp file so that
+		 * we will be able to undo even after we have moved off
+		 * the line.  It would be possible to associate a line
+		 * with vutmp but we assume that vutmp is only associated
+		 * with line dot (e.g. in case ':') above, so beware.
+		 */
+		prepapp();
+		CP(linebuf, vutmp);
+		putmark(dot);
+		vremote(1, yank, 0);
+		vundkind = VMCHNG;
+		notecnt = 0;
+		undkind = UNDCHANGE;
+	}
+	/*
+	 * Get the line out of the temp file and do nothing if it hasn't
+	 * changed.  This may seem like a loss, but the line will
+	 * almost always be in a read buffer so this may well avoid disk i/o.
+	 */
+	getDOT();
+	if (strcmp(linebuf, temp) == 0)
+		return;
+	strcLIN(temp);
+	putmark(dot);
+}
+
+#undef	forbid
+#define	forbid(a)	if (a) { beep(); return; }
+
+/*
+ * Do a z operation.
+ * Code here is rather long, and very uninteresting.
+ */
+void 
+vzop(int hadcnt, int cnt, register int c)
+{
+	register line *addr;
+
+	if (state != VISUAL) {
+		/*
+		 * Z from open; always like a z=.
+		 * This code is a mess and should be cleaned up.
+		 */
+		vmoveitup(1, 1);
+		vgoto(outline, 0);
+		ostop(normf);
+		setoutt();
+		addr2 = dot;
+		vclear();
+		destline = WECHO;
+		zop2(Xhadcnt ? Xcnt : value(WINDOW) - 1, '=');
+		if (state == CRTOPEN)
+			putnl();
+		putNFL();
+		termreset();
+		Outchar = vputchar;
+		ignore(ostart());
+		vcnt = 0;
+		outline = destline = 0;
+		vjumpto(dot, cursor, 0);
+		return;
+	}
+	if (hadcnt) {
+		addr = zero + cnt;
+		if (addr < one)
+			addr = one;
+		if (addr > dol)
+			addr = dol;
+		markit(addr);
+	} else
+		switch (c) {
+
+		case '+':
+			addr = dot + vcnt - vcline;
+			break;
+
+		case '^':
+			addr = dot - vcline - 1;
+			forbid (addr < one);
+			c = '-';
+			break;
+
+		default:
+			addr = dot;
+			break;
+		}
+	switch (c) {
+
+	case '.':
+	case '-':
+		break;
+
+	case '^':
+		forbid (addr <= one);
+		break;
+
+	case '+':
+		forbid (addr >= dol);
+		/* fall into ... */
+
+	case CR:
+	case NL:
+		c = CR;
+		break;
+
+	default:
+		beep();
+		return;
+	}
+	vmoving = 0;
+	vjumpto(addr, NOSTR, c);
+}
+
+cell *
+str2cell(cell *dst, register char *src)
+{
+	register cell *cp = dst;
+
+#ifdef	MB
+	if (mb_cur_max > 1) {
+		int	c, n;
+		do {
+			nextc(c, src, n);
+			src += n;
+			*cp++ = c;
+		} while (src[-n]);
+	} else
+#endif	/* MB */
+		while (*cp++ = *src++ & 0377);
+	return dst;
+}
+
+char *
+cell2str(char *dst, register cell *src)
+{
+	register char *cp = dst;
+
+	while (*cp++ = *src++);
+	return dst;
+}
+
+cell *
+cellcpy(cell *dst, register cell *src)
+{
+	register cell *cp = dst;
+
+	while (*cp++ = *src++);
+	return dst;
+}
+
+size_t 
+cellen(register cell *cp)
+{
+	register size_t sz = 0;
+
+	while (*cp++)
+		sz++;
+	return sz;
+}
+
+cell *
+cellcat(cell *dst, register cell *src)
+{
+	register cell *cp = dst;
+
+	while (*cp)
+		cp++;
+	cellcpy(cp, src);
+	return dst;
+}