1 files changed, 696 insertions, 0 deletions

diff --git a/contrib/nvi/vi/v_ex.c b/contrib/nvi/vi/v_ex.c
new file mode 100644
index 0000000..359080c
--- /dev/null
+++ b/contrib/nvi/vi/v_ex.c
@@ -0,0 +1,696 @@
+/*-
+ * Copyright (c) 1992, 1993, 1994
+ *	The Regents of the University of California.  All rights reserved.
+ * Copyright (c) 1992, 1993, 1994, 1995, 1996
+ *	Keith Bostic.  All rights reserved.
+ *
+ * See the LICENSE file for redistribution information.
+ */
+
+#include "config.h"
+
+#ifndef lint
+static const char sccsid[] = "@(#)v_ex.c	10.42 (Berkeley) 6/28/96";
+#endif /* not lint */
+
+#include <sys/types.h>
+#include <sys/queue.h>
+#include <sys/time.h>
+
+#include <bitstring.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "../common/common.h"
+#include "vi.h"
+
+static int v_ecl __P((SCR *));
+static int v_ecl_init __P((SCR *));
+static int v_ecl_log __P((SCR *, TEXT *));
+static int v_ex_done __P((SCR *, VICMD *));
+static int v_exec_ex __P((SCR *, VICMD *, EXCMD *));
+
+/*
+ * v_again -- &
+ *	Repeat the previous substitution.
+ *
+ * PUBLIC: int v_again __P((SCR *, VICMD *));
+ */
+int
+v_again(sp, vp)
+	SCR *sp;
+	VICMD *vp;
+{
+	ARGS *ap[2], a;
+	EXCMD cmd;
+
+	ex_cinit(&cmd, C_SUBAGAIN, 2, vp->m_start.lno, vp->m_start.lno, 1, ap);
+	ex_cadd(&cmd, &a, "", 1);
+
+	return (v_exec_ex(sp, vp, &cmd));
+}
+
+/*
+ * v_exmode -- Q
+ *	Switch the editor into EX mode.
+ *
+ * PUBLIC: int v_exmode __P((SCR *, VICMD *));
+ */
+int
+v_exmode(sp, vp)
+	SCR *sp;
+	VICMD *vp;
+{
+	GS *gp;
+
+	gp = sp->gp;
+
+	/* Try and switch screens -- the screen may not permit it. */
+	if (gp->scr_screen(sp, SC_EX)) {
+		msgq(sp, M_ERR,
+		    "207|The Q command requires the ex terminal interface");
+		return (1);
+	}
+	(void)gp->scr_attr(sp, SA_ALTERNATE, 0);
+
+	/* Save the current cursor position. */
+	sp->frp->lno = sp->lno;
+	sp->frp->cno = sp->cno;
+	F_SET(sp->frp, FR_CURSORSET);
+
+	/* Switch to ex mode. */
+	F_CLR(sp, SC_VI | SC_SCR_VI);
+	F_SET(sp, SC_EX);
+
+	/* Move out of the vi screen. */
+	(void)ex_puts(sp, "\n");
+
+	return (0);
+}
+
+/*
+ * v_join -- [count]J
+ *	Join lines together.
+ *
+ * PUBLIC: int v_join __P((SCR *, VICMD *));
+ */
+int
+v_join(sp, vp)
+	SCR *sp;
+	VICMD *vp;
+{
+	EXCMD cmd;
+	int lno;
+
+	/*
+	 * YASC.
+	 * The general rule is that '#J' joins # lines, counting the current
+	 * line.  However, 'J' and '1J' are the same as '2J', i.e. join the
+	 * current and next lines.  This doesn't map well into the ex command
+	 * (which takes two line numbers), so we handle it here.  Note that
+	 * we never test for EOF -- historically going past the end of file
+	 * worked just fine.
+	 */
+	lno = vp->m_start.lno + 1;
+	if (F_ISSET(vp, VC_C1SET) && vp->count > 2)
+		lno = vp->m_start.lno + (vp->count - 1);
+
+	ex_cinit(&cmd, C_JOIN, 2, vp->m_start.lno, lno, 0, NULL);
+	return (v_exec_ex(sp, vp, &cmd));
+}
+
+/*
+ * v_shiftl -- [count]<motion
+ *	Shift lines left.
+ *
+ * PUBLIC: int v_shiftl __P((SCR *, VICMD *));
+ */
+int
+v_shiftl(sp, vp)
+	SCR *sp;
+	VICMD *vp;
+{
+	ARGS *ap[2], a;
+	EXCMD cmd;
+
+	ex_cinit(&cmd, C_SHIFTL, 2, vp->m_start.lno, vp->m_stop.lno, 0, ap);
+	ex_cadd(&cmd, &a, "<", 1);
+	return (v_exec_ex(sp, vp, &cmd));
+}
+
+/*
+ * v_shiftr -- [count]>motion
+ *	Shift lines right.
+ *
+ * PUBLIC: int v_shiftr __P((SCR *, VICMD *));
+ */
+int
+v_shiftr(sp, vp)
+	SCR *sp;
+	VICMD *vp;
+{
+	ARGS *ap[2], a;
+	EXCMD cmd;
+
+	ex_cinit(&cmd, C_SHIFTR, 2, vp->m_start.lno, vp->m_stop.lno, 0, ap);
+	ex_cadd(&cmd, &a, ">", 1);
+	return (v_exec_ex(sp, vp, &cmd));
+}
+
+/*
+ * v_suspend -- ^Z
+ *	Suspend vi.
+ *
+ * PUBLIC: int v_suspend __P((SCR *, VICMD *));
+ */
+int
+v_suspend(sp, vp)
+	SCR *sp;
+	VICMD *vp;
+{
+	ARGS *ap[2], a;
+	EXCMD cmd;
+
+	ex_cinit(&cmd, C_STOP, 0, OOBLNO, OOBLNO, 0, ap);
+	ex_cadd(&cmd, &a, "suspend", sizeof("suspend") - 1);
+	return (v_exec_ex(sp, vp, &cmd));
+}
+
+/*
+ * v_switch -- ^^
+ *	Switch to the previous file.
+ *
+ * PUBLIC: int v_switch __P((SCR *, VICMD *));
+ */
+int
+v_switch(sp, vp)
+	SCR *sp;
+	VICMD *vp;
+{
+	ARGS *ap[2], a;
+	EXCMD cmd;
+	char *name;
+
+	/*
+	 * Try the alternate file name, then the previous file
+	 * name.  Use the real name, not the user's current name.
+	 */
+	if ((name = sp->alt_name) == NULL) {
+		msgq(sp, M_ERR, "180|No previous file to edit");
+		return (1);
+	}
+
+	/* If autowrite is set, write out the file. */
+	if (file_m1(sp, 0, FS_ALL))
+		return (1);
+
+	ex_cinit(&cmd, C_EDIT, 0, OOBLNO, OOBLNO, 0, ap);
+	ex_cadd(&cmd, &a, name, strlen(name));
+	return (v_exec_ex(sp, vp, &cmd));
+}
+
+/*
+ * v_tagpush -- ^[
+ *	Do a tag search on the cursor keyword.
+ *
+ * PUBLIC: int v_tagpush __P((SCR *, VICMD *));
+ */
+int
+v_tagpush(sp, vp)
+	SCR *sp;
+	VICMD *vp;
+{
+	ARGS *ap[2], a;
+	EXCMD cmd;
+
+	ex_cinit(&cmd, C_TAG, 0, OOBLNO, 0, 0, ap);
+	ex_cadd(&cmd, &a, VIP(sp)->keyw, strlen(VIP(sp)->keyw));
+	return (v_exec_ex(sp, vp, &cmd));
+}
+
+/*
+ * v_tagpop -- ^T
+ *	Pop the tags stack.
+ *
+ * PUBLIC: int v_tagpop __P((SCR *, VICMD *));
+ */
+int
+v_tagpop(sp, vp)
+	SCR *sp;
+	VICMD *vp;
+{
+	EXCMD cmd;
+
+	ex_cinit(&cmd, C_TAGPOP, 0, OOBLNO, 0, 0, NULL);
+	return (v_exec_ex(sp, vp, &cmd));
+}
+
+/*
+ * v_filter -- [count]!motion command(s)
+ *	Run range through shell commands, replacing text.
+ *
+ * PUBLIC: int v_filter __P((SCR *, VICMD *));
+ */
+int
+v_filter(sp, vp)
+	SCR *sp;
+	VICMD *vp;
+{
+	EXCMD cmd;
+	TEXT *tp;
+
+	/*
+	 * !!!
+	 * Historical vi permitted "!!" in an empty file, and it's handled
+	 * as a special case in the ex_bang routine.  Don't modify this setup
+	 * without understanding that one.  In particular, note that we're
+	 * manipulating the ex argument structures behind ex's back.
+	 *
+	 * !!!
+	 * Historical vi did not permit the '!' command to be associated with
+	 * a non-line oriented motion command, in general, although it did
+	 * with search commands.  So, !f; and !w would fail, but !/;<CR>
+	 * would succeed, even if they all moved to the same location in the
+	 * current line.  I don't see any reason to disallow '!' using any of
+	 * the possible motion commands.
+	 *
+	 * !!!
+	 * Historical vi ran the last bang command if N or n was used as the
+	 * search motion.
+	 */
+	if (F_ISSET(vp, VC_ISDOT) ||
+	    ISCMD(vp->rkp, 'N') || ISCMD(vp->rkp, 'n')) {
+		ex_cinit(&cmd, C_BANG,
+		    2, vp->m_start.lno, vp->m_stop.lno, 0, NULL);
+		EXP(sp)->argsoff = 0;			/* XXX */
+
+		if (argv_exp1(sp, &cmd, "!", 1, 1))
+			return (1);
+		cmd.argc = EXP(sp)->argsoff;		/* XXX */
+		cmd.argv = EXP(sp)->args;		/* XXX */
+		return (v_exec_ex(sp, vp, &cmd));
+	}
+
+	/* Get the command from the user. */
+	if (v_tcmd(sp, vp,
+	    '!', TXT_BS | TXT_CR | TXT_ESCAPE | TXT_FILEC | TXT_PROMPT))
+		return (1);
+
+	/*
+	 * Check to see if the user changed their mind.
+	 *
+	 * !!!
+	 * Entering <escape> on an empty line was historically an error,
+	 * this implementation doesn't bother.
+	 */
+	tp = sp->tiq.cqh_first;
+	if (tp->term != TERM_OK) {
+		vp->m_final.lno = sp->lno;
+		vp->m_final.cno = sp->cno;
+		return (0);
+	}
+
+	/* Home the cursor. */
+	vs_home(sp);
+
+	ex_cinit(&cmd, C_BANG, 2, vp->m_start.lno, vp->m_stop.lno, 0, NULL);
+	EXP(sp)->argsoff = 0;			/* XXX */
+
+	if (argv_exp1(sp, &cmd, tp->lb + 1, tp->len - 1, 1))
+		return (1);
+	cmd.argc = EXP(sp)->argsoff;		/* XXX */
+	cmd.argv = EXP(sp)->args;		/* XXX */
+	return (v_exec_ex(sp, vp, &cmd));
+}
+
+/*
+ * v_event_exec --
+ *	Execute some command(s) based on an event.
+ *
+ * PUBLIC: int v_event_exec __P((SCR *, VICMD *));
+ */
+int
+v_event_exec(sp, vp)
+	SCR *sp;
+	VICMD *vp;
+{
+	EXCMD cmd;
+
+	switch (vp->ev.e_event) {
+	case E_QUIT:
+		ex_cinit(&cmd, C_QUIT, 0, OOBLNO, OOBLNO, 0, NULL);
+		break;
+	case E_WRITE:
+		ex_cinit(&cmd, C_WRITE, 0, OOBLNO, OOBLNO, 0, NULL);
+		break;
+	default:
+		abort();
+	}
+	return (v_exec_ex(sp, vp, &cmd));
+}
+
+/*
+ * v_exec_ex --
+ *	Execute an ex command.
+ */
+static int
+v_exec_ex(sp, vp, exp)
+	SCR *sp;
+	VICMD *vp;
+	EXCMD *exp;
+{
+	int rval;
+
+	rval = exp->cmd->fn(sp, exp);
+	return (v_ex_done(sp, vp) || rval);
+}
+
+/*
+ * v_ex -- :
+ *	Execute a colon command line.
+ *
+ * PUBLIC: int v_ex __P((SCR *, VICMD *));
+ */
+int
+v_ex(sp, vp)
+	SCR *sp;
+	VICMD *vp;
+{
+	GS *gp;
+	TEXT *tp;
+	int do_cedit, do_resolution, ifcontinue;
+
+	gp = sp->gp;
+
+	/*
+	 * !!!
+	 * If we put out more than a single line of messages, or ex trashes
+	 * the screen, the user may continue entering ex commands.  We find
+	 * this out when we do the screen/message resolution.  We can't enter
+	 * completely into ex mode however, because the user can elect to
+	 * return into vi mode by entering any key, i.e. we have to be in raw
+	 * mode.
+	 */
+	for (do_cedit = do_resolution = 0;;) {
+		/*
+		 * !!!
+		 * There may already be an ex command waiting to run.  If
+		 * so, we continue with it.
+		 */
+		if (!EXCMD_RUNNING(gp)) {
+			/* Get a command. */
+			if (v_tcmd(sp, vp, ':',
+			    TXT_BS | TXT_CEDIT | TXT_FILEC | TXT_PROMPT))
+				return (1);
+			tp = sp->tiq.cqh_first;
+
+			/*
+			 * If the user entered a single <esc>, they want to
+			 * edit their colon command history.  If they already
+			 * entered some text, move it into the edit history.
+			 */
+			if (tp->term == TERM_CEDIT) {
+				if (tp->len > 1 && v_ecl_log(sp, tp))
+					return (1);
+				do_cedit = 1;
+				break;
+			}
+
+			/* If the user didn't enter anything, return. */
+			if (tp->term == TERM_BS)
+				break;
+
+			/* Log the command. */
+			if (O_STR(sp, O_CEDIT) != NULL && v_ecl_log(sp, tp))
+				return (1);
+
+			/* Push a command on the command stack. */
+			if (ex_run_str(sp, NULL, tp->lb, tp->len, 0, 1))
+				return (1);
+		}
+
+		/* Home the cursor. */
+		vs_home(sp);
+
+		/*
+		 * !!!
+		 * If the editor wrote the screen behind curses back, put out
+		 * a <newline> so that we don't overwrite the user's command
+		 * with its output or the next want-to-continue? message.  This
+		 * doesn't belong here, but I can't find another place to put
+		 * it.  See, we resolved the output from the last ex command,
+		 * and the user entered another one.  This is the only place
+		 * where we have control before the ex command writes output.
+		 * We could get control in vs_msg(), but we have no way to know
+		 * if command didn't put out any output when we try and resolve
+		 * this command.  This fixes a bug where combinations of ex
+		 * commands, e.g. ":set<CR>:!date<CR>:set" didn't look right.
+		 */
+		if (F_ISSET(sp, SC_SCR_EXWROTE))
+			(void)putchar('\n');
+
+		/* Call the ex parser. */
+		(void)ex_cmd(sp);
+
+		/* Flush ex messages. */
+		(void)ex_fflush(sp);
+
+		/* Resolve any messages. */
+		if (vs_ex_resolve(sp, &ifcontinue))
+			return (1);
+
+		/*
+		 * Continue or return.  If continuing, make sure that we
+		 * eventually do resolution.
+		 */
+		if (!ifcontinue)
+			break;
+		do_resolution = 1;
+
+		/* If we're continuing, it's a new command. */
+		++sp->ccnt;
+	}
+
+	/*
+	 * If the user previously continued an ex command, we have to do
+	 * resolution to clean up the screen.  Don't wait, we already did
+	 * that.
+	 */
+	if (do_resolution) {
+		F_SET(sp, SC_EX_WAIT_NO);
+		if (vs_ex_resolve(sp, &ifcontinue))
+			return (1);
+	}
+
+	/* Cleanup from the ex command. */
+	if (v_ex_done(sp, vp))
+		return (1);
+
+	/* The user may want to edit their colon command history. */
+	if (do_cedit)
+		return (v_ecl(sp));
+
+	return (0);
+}
+
+/*
+ * v_ex_done --
+ *	Cleanup from an ex command.
+ */
+static int
+v_ex_done(sp, vp)
+	SCR *sp;
+	VICMD *vp;
+{
+	size_t len;
+
+	/*
+	 * The only cursor modifications are real, however, the underlying
+	 * line may have changed; don't trust anything.  This code has been
+	 * a remarkably fertile place for bugs.  Do a reality check on a
+	 * cursor value, and make sure it's okay.  If necessary, change it.
+	 * Ex keeps track of the line number, but it cares less about the
+	 * column and it may have disappeared.
+	 *
+	 * Don't trust ANYTHING.
+	 *
+	 * XXX
+	 * Ex will soon have to start handling the column correctly; see
+	 * the POSIX 1003.2 standard.
+	 */
+	if (db_eget(sp, sp->lno, NULL, &len, NULL)) {
+		sp->lno = 1;
+		sp->cno = 0;
+	} else if (sp->cno >= len)
+		sp->cno = len ? len - 1 : 0;
+
+	vp->m_final.lno = sp->lno;
+	vp->m_final.cno = sp->cno;
+
+	/*
+	 * Don't re-adjust the cursor after executing an ex command,
+	 * and ex movements are permanent.
+	 */
+	F_CLR(vp, VM_RCM_MASK);
+	F_SET(vp, VM_RCM_SET);
+
+	return (0);
+}
+
+/*
+ * v_ecl --
+ *	Start an edit window on the colon command-line commands.
+ */
+static int
+v_ecl(sp)
+	SCR *sp;
+{
+	GS *gp;
+	SCR *new;
+
+	/* Initialize the screen, if necessary. */
+	gp = sp->gp;
+	if (gp->ccl_sp == NULL && v_ecl_init(sp))
+		return (1);
+
+	/* Get a new screen. */
+	if (screen_init(gp, sp, &new))
+		return (1);
+	if (vs_split(sp, new, 1)) {
+		(void)screen_end(new);
+		return (1);
+	}
+
+	/* Attach to the screen. */
+	new->ep = gp->ccl_sp->ep;
+	++new->ep->refcnt;
+
+	new->frp = gp->ccl_sp->frp;
+	new->frp->flags = sp->frp->flags;
+
+	/* Move the cursor to the end. */
+	(void)db_last(new, &new->lno);
+	if (new->lno == 0)
+		new->lno = 1;
+
+	/* Remember the originating window. */
+	sp->ccl_parent = sp;
+
+	/* It's a special window. */
+	F_SET(new, SC_COMEDIT);
+
+	/* Set up the switch. */
+	sp->nextdisp = new;
+	F_SET(sp, SC_SSWITCH);
+	return (0);
+}
+
+/*
+ * v_ecl_exec --
+ *	Execute a command from a colon command-line window.
+ *
+ * PUBLIC: int v_ecl_exec __P((SCR *));
+ */
+int
+v_ecl_exec(sp)
+	SCR *sp;
+{
+	size_t len;
+	char *p;
+
+	if (db_get(sp, sp->lno, 0, &p, &len) && sp->lno == 1) {
+		v_emsg(sp, NULL, VIM_EMPTY);
+		return (1);
+	}
+	if (len == 0) {
+		msgq(sp, M_BERR, "307|No ex command to execute");
+		return (1);
+	}
+	
+	/* Push the command on the command stack. */
+	if (ex_run_str(sp, NULL, p, len, 0, 0))
+		return (1);
+
+	/* Set up the switch. */
+	sp->nextdisp = sp->ccl_parent;
+	F_SET(sp, SC_EXIT);
+	return (0);
+}
+
+/*
+ * v_ecl_log --
+ *	Log a command into the colon command-line log file.
+ */
+static int
+v_ecl_log(sp, tp)
+	SCR *sp;
+	TEXT *tp;
+{
+	EXF *save_ep;
+	recno_t lno;
+	int rval;
+
+	/* Initialize the screen, if necessary. */
+	if (sp->gp->ccl_sp == NULL && v_ecl_init(sp))
+		return (1);
+
+	/*
+	 * Don't log colon command window commands into the colon command
+	 * window...
+	 */
+	if (sp->ep == sp->gp->ccl_sp->ep)
+		return (0);
+
+	/*
+	 * XXX
+	 * Swap the current EXF with the colon command file EXF.  This
+	 * isn't pretty, but too many routines "know" that sp->ep points
+	 * to the current EXF.
+	 */
+	save_ep = sp->ep;
+	sp->ep = sp->gp->ccl_sp->ep;
+	if (db_last(sp, &lno)) {
+		sp->ep = save_ep;
+		return (1);
+	}
+	rval = db_append(sp, 0, lno, tp->lb, tp->len);
+	sp->ep = save_ep;
+	return (rval);
+}
+
+/*
+ * v_ecl_init --
+ *	Initialize the colon command-line log file.
+ */
+static int
+v_ecl_init(sp)
+	SCR *sp;
+{
+	FREF *frp;
+	GS *gp;
+
+	gp = sp->gp;
+
+	/* Get a temporary file. */
+	if ((frp = file_add(sp, NULL)) == NULL)
+		return (1);
+
+	/*
+	 * XXX
+	 * Create a screen -- the file initialization code wants one.
+	 */
+	if (screen_init(gp, sp, &gp->ccl_sp))
+		return (1);
+	if (file_init(gp->ccl_sp, frp, NULL, 0)) {
+		(void)screen_end(gp->ccl_sp);
+		return (1);
+	}
+
+	/* The underlying file isn't recoverable. */
+	F_CLR(gp->ccl_sp->ep, F_RCV_ON);
+
+	return (0);
+}