Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/vi/build/../vi/v_ex.c	Lines:	0	196	0.0 %
Date:	2017-11-07	Branches:	0	101	0.0 %


/*	$OpenBSD: v_ex.c,v 1.13 2016/01/06 22:28:52 millert Exp $	*/

/*-
 * 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"

#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(SCR *);
static int v_ecl_init(SCR *);
static int v_ecl_log(SCR *, TEXT *);
static int v_ex_done(SCR *, VICMD *);
static int v_exec_ex(SCR *, VICMD *, EXCMD *);

/*
 * v_again -- &
 *	Repeat the previous substitution.
 *
 * PUBLIC: int v_again(SCR *, VICMD *);
 */
int
v_again(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(SCR *, VICMD *);
 */
int
v_exmode(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,
		    "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(SCR *, VICMD *);
 */
int
v_join(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(SCR *, VICMD *);
 */
int
v_shiftl(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(SCR *, VICMD *);
 */
int
v_shiftr(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(SCR *, VICMD *);
 */
int
v_suspend(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(SCR *, VICMD *);
 */
int
v_switch(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 (sp->alt_name == NULL) {
		msgq(sp, M_ERR, "No previous file to edit");
		return (1);
	}
	if ((name = strdup(sp->alt_name)) == NULL) {
		msgq(sp, M_SYSERR, NULL);
		return (1);
	}

	/* If autowrite is set, write out the file. */
	if (file_m1(sp, 0, FS_ALL)) {
		free(name);
		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(SCR *, VICMD *);
 */
int
v_tagpush(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(SCR *, VICMD *);
 */
int
v_tagpop(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(SCR *, VICMD *);
 */
int
v_filter(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 = TAILQ_FIRST(&sp->tiq);
	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(SCR *, VICMD *);
 */
int
v_event_exec(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(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(SCR *, VICMD *);
 */
int
v_ex(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 = TAILQ_FIRST(&sp->tiq);

			/*
			 * 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 changed their mind, return. */
			if (tp->term != TERM_OK)
				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(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(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(SCR *);
 */
int
v_ecl_exec(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, "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(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(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);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: v_ex.c,v 1.13 2016/01/06 22:28:52 millert Exp $ */
2
3			/*-
4			* Copyright (c) 1992, 1993, 1994
5			* The Regents of the University of California. All rights reserved.
6			* Copyright (c) 1992, 1993, 1994, 1995, 1996
7			* Keith Bostic. All rights reserved.
8			*
9			* See the LICENSE file for redistribution information.
10			*/
11
12			#include "config.h"
13
14			#include <sys/types.h>
15			#include <sys/queue.h>
16			#include <sys/time.h>
17
18			#include <bitstring.h>
19			#include <limits.h>
20			#include <stdio.h>
21			#include <stdlib.h>
22			#include <string.h>
23			#include <unistd.h>
24
25			#include "../common/common.h"
26			#include "vi.h"
27
28			static int v_ecl(SCR *);
29			static int v_ecl_init(SCR *);
30			static int v_ecl_log(SCR , TEXT );
31			static int v_ex_done(SCR , VICMD );
32			static int v_exec_ex(SCR , VICMD , EXCMD *);
33
34			/*
35			* v_again -- &
36			* Repeat the previous substitution.
37			*
38			* PUBLIC: int v_again(SCR , VICMD );
39			*/
40			int
41			v_again(SCR sp, VICMD vp)
42			{
43			ARGS *ap[2], a;
44			EXCMD cmd;
45
46			ex_cinit(&cmd, C_SUBAGAIN, 2, vp->m_start.lno, vp->m_start.lno, 1, ap);
47			ex_cadd(&cmd, &a, "", 1);
48
49			return (v_exec_ex(sp, vp, &cmd));
50			}
51
52			/*
53			* v_exmode -- Q
54			* Switch the editor into EX mode.
55			*
56			* PUBLIC: int v_exmode(SCR , VICMD );
57			*/
58			int
59			v_exmode(SCR sp, VICMD vp)
60			{
61			GS *gp;
62
63			gp = sp->gp;
64
65			/* Try and switch screens -- the screen may not permit it. */
66			if (gp->scr_screen(sp, SC_EX)) {
67			msgq(sp, M_ERR,
68			"The Q command requires the ex terminal interface");
69			return (1);
70			}
71			(void)gp->scr_attr(sp, SA_ALTERNATE, 0);
72
73			/* Save the current cursor position. */
74			sp->frp->lno = sp->lno;
75			sp->frp->cno = sp->cno;
76			F_SET(sp->frp, FR_CURSORSET);
77
78			/* Switch to ex mode. */
79			F_CLR(sp, SC_VI \| SC_SCR_VI);
80			F_SET(sp, SC_EX);
81
82			/* Move out of the vi screen. */
83			(void)ex_puts(sp, "\n");
84
85			return (0);
86			}
87
88			/*
89			* v_join -- [count]J
90			* Join lines together.
91			*
92			* PUBLIC: int v_join(SCR , VICMD );
93			*/
94			int
95			v_join(SCR sp, VICMD vp)
96			{
97			EXCMD cmd;
98			int lno;
99
100			/*
101			* YASC.
102			* The general rule is that '#J' joins # lines, counting the current
103			* line. However, 'J' and '1J' are the same as '2J', i.e. join the
104			* current and next lines. This doesn't map well into the ex command
105			* (which takes two line numbers), so we handle it here. Note that
106			* we never test for EOF -- historically going past the end of file
107			* worked just fine.
108			*/
109			lno = vp->m_start.lno + 1;
110			if (F_ISSET(vp, VC_C1SET) && vp->count > 2)
111			lno = vp->m_start.lno + (vp->count - 1);
112
113			ex_cinit(&cmd, C_JOIN, 2, vp->m_start.lno, lno, 0, NULL);
114			return (v_exec_ex(sp, vp, &cmd));
115			}
116
117			/*
118			* v_shiftl -- [count]<motion
119			* Shift lines left.
120			*
121			* PUBLIC: int v_shiftl(SCR , VICMD );
122			*/
123			int
124			v_shiftl(SCR sp, VICMD vp)
125			{
126			ARGS *ap[2], a;
127			EXCMD cmd;
128
129			ex_cinit(&cmd, C_SHIFTL, 2, vp->m_start.lno, vp->m_stop.lno, 0, ap);
130			ex_cadd(&cmd, &a, "<", 1);
131			return (v_exec_ex(sp, vp, &cmd));
132			}
133
134			/*
135			* v_shiftr -- [count]>motion
136			* Shift lines right.
137			*
138			* PUBLIC: int v_shiftr(SCR , VICMD );
139			*/
140			int
141			v_shiftr(SCR sp, VICMD vp)
142			{
143			ARGS *ap[2], a;
144			EXCMD cmd;
145
146			ex_cinit(&cmd, C_SHIFTR, 2, vp->m_start.lno, vp->m_stop.lno, 0, ap);
147			ex_cadd(&cmd, &a, ">", 1);
148			return (v_exec_ex(sp, vp, &cmd));
149			}
150
151			/*
152			* v_suspend -- ^Z
153			* Suspend vi.
154			*
155			* PUBLIC: int v_suspend(SCR , VICMD );
156			*/
157			int
158			v_suspend(SCR sp, VICMD vp)
159			{
160			ARGS *ap[2], a;
161			EXCMD cmd;
162
163			ex_cinit(&cmd, C_STOP, 0, OOBLNO, OOBLNO, 0, ap);
164			ex_cadd(&cmd, &a, "suspend", sizeof("suspend") - 1);
165			return (v_exec_ex(sp, vp, &cmd));
166			}
167
168			/*
169			* v_switch -- ^^
170			* Switch to the previous file.
171			*
172			* PUBLIC: int v_switch(SCR , VICMD );
173			*/
174			int
175			v_switch(SCR sp, VICMD vp)
176			{
177			ARGS *ap[2], a;
178			EXCMD cmd;
179			char *name;
180
181			/*
182			* Try the alternate file name, then the previous file
183			* name. Use the real name, not the user's current name.
184			*/
185			if (sp->alt_name == NULL) {
186			msgq(sp, M_ERR, "No previous file to edit");
187			return (1);
188			}
189			if ((name = strdup(sp->alt_name)) == NULL) {
190			msgq(sp, M_SYSERR, NULL);
191			return (1);
192			}
193
194			/* If autowrite is set, write out the file. */
195			if (file_m1(sp, 0, FS_ALL)) {
196			free(name);
197			return (1);
198			}
199
200			ex_cinit(&cmd, C_EDIT, 0, OOBLNO, OOBLNO, 0, ap);
201			ex_cadd(&cmd, &a, name, strlen(name));
202			return (v_exec_ex(sp, vp, &cmd));
203			}
204
205			/*
206			* v_tagpush -- ^[
207			* Do a tag search on the cursor keyword.
208			*
209			* PUBLIC: int v_tagpush(SCR , VICMD );
210			*/
211			int
212			v_tagpush(SCR sp, VICMD vp)
213			{
214			ARGS *ap[2], a;
215			EXCMD cmd;
216
217			ex_cinit(&cmd, C_TAG, 0, OOBLNO, 0, 0, ap);
218			ex_cadd(&cmd, &a, VIP(sp)->keyw, strlen(VIP(sp)->keyw));
219			return (v_exec_ex(sp, vp, &cmd));
220			}
221
222			/*
223			* v_tagpop -- ^T
224			* Pop the tags stack.
225			*
226			* PUBLIC: int v_tagpop(SCR , VICMD );
227			*/
228			int
229			v_tagpop(SCR sp, VICMD vp)
230			{
231			EXCMD cmd;
232
233			ex_cinit(&cmd, C_TAGPOP, 0, OOBLNO, 0, 0, NULL);
234			return (v_exec_ex(sp, vp, &cmd));
235			}
236
237			/*
238			* v_filter -- [count]!motion command(s)
239			* Run range through shell commands, replacing text.
240			*
241			* PUBLIC: int v_filter(SCR , VICMD );
242			*/
243			int
244			v_filter(SCR sp, VICMD vp)
245			{
246			EXCMD cmd;
247			TEXT *tp;
248
249			/*
250			* !!!
251			* Historical vi permitted "!!" in an empty file, and it's handled
252			* as a special case in the ex_bang routine. Don't modify this setup
253			* without understanding that one. In particular, note that we're
254			* manipulating the ex argument structures behind ex's back.
255			*
256			* !!!
257			* Historical vi did not permit the '!' command to be associated with
258			* a non-line oriented motion command, in general, although it did
259			* with search commands. So, !f; and !w would fail, but !/;<CR>
260			* would succeed, even if they all moved to the same location in the
261			* current line. I don't see any reason to disallow '!' using any of
262			* the possible motion commands.
263			*
264			* !!!
265			* Historical vi ran the last bang command if N or n was used as the
266			* search motion.
267			*/
268			if (F_ISSET(vp, VC_ISDOT) \|\|
269			ISCMD(vp->rkp, 'N') \|\| ISCMD(vp->rkp, 'n')) {
270			ex_cinit(&cmd, C_BANG,
271			2, vp->m_start.lno, vp->m_stop.lno, 0, NULL);
272			EXP(sp)->argsoff = 0; /* XXX */
273
274			if (argv_exp1(sp, &cmd, "!", 1, 1))
275			return (1);
276			cmd.argc = EXP(sp)->argsoff; /* XXX */
277			cmd.argv = EXP(sp)->args; /* XXX */
278			return (v_exec_ex(sp, vp, &cmd));
279			}
280
281			/* Get the command from the user. */
282			if (v_tcmd(sp, vp,
283			'!', TXT_BS \| TXT_CR \| TXT_ESCAPE \| TXT_FILEC \| TXT_PROMPT))
284			return (1);
285
286			/*
287			* Check to see if the user changed their mind.
288			*
289			* !!!
290			* Entering <escape> on an empty line was historically an error,
291			* this implementation doesn't bother.
292			*/
293			tp = TAILQ_FIRST(&sp->tiq);
294			if (tp->term != TERM_OK) {
295			vp->m_final.lno = sp->lno;
296			vp->m_final.cno = sp->cno;
297			return (0);
298			}
299
300			/* Home the cursor. */
301			vs_home(sp);
302
303			ex_cinit(&cmd, C_BANG, 2, vp->m_start.lno, vp->m_stop.lno, 0, NULL);
304			EXP(sp)->argsoff = 0; /* XXX */
305
306			if (argv_exp1(sp, &cmd, tp->lb + 1, tp->len - 1, 1))
307			return (1);
308			cmd.argc = EXP(sp)->argsoff; /* XXX */
309			cmd.argv = EXP(sp)->args; /* XXX */
310			return (v_exec_ex(sp, vp, &cmd));
311			}
312
313			/*
314			* v_event_exec --
315			* Execute some command(s) based on an event.
316			*
317			* PUBLIC: int v_event_exec(SCR , VICMD );
318			*/
319			int
320			v_event_exec(SCR sp, VICMD vp)
321			{
322			EXCMD cmd;
323
324			switch (vp->ev.e_event) {
325			case E_QUIT:
326			ex_cinit(&cmd, C_QUIT, 0, OOBLNO, OOBLNO, 0, NULL);
327			break;
328			case E_WRITE:
329			ex_cinit(&cmd, C_WRITE, 0, OOBLNO, OOBLNO, 0, NULL);
330			break;
331			default:
332			abort();
333			}
334			return (v_exec_ex(sp, vp, &cmd));
335			}
336
337			/*
338			* v_exec_ex --
339			* Execute an ex command.
340			*/
341			static int
342			v_exec_ex(SCR sp, VICMD vp, EXCMD *exp)
343			{
344			int rval;
345
346			rval = exp->cmd->fn(sp, exp);
347			return (v_ex_done(sp, vp) \|\| rval);
348			}
349
350			/*
351			* v_ex -- :
352			* Execute a colon command line.
353			*
354			* PUBLIC: int v_ex(SCR , VICMD );
355			*/
356			int
357			v_ex(SCR sp, VICMD vp)
358			{
359			GS *gp;
360			TEXT *tp;
361			int do_cedit, do_resolution, ifcontinue;
362
363			gp = sp->gp;
364
365			/*
366			* !!!
367			* If we put out more than a single line of messages, or ex trashes
368			* the screen, the user may continue entering ex commands. We find
369			* this out when we do the screen/message resolution. We can't enter
370			* completely into ex mode however, because the user can elect to
371			* return into vi mode by entering any key, i.e. we have to be in raw
372			* mode.
373			*/
374			for (do_cedit = do_resolution = 0;;) {
375			/*
376			* !!!
377			* There may already be an ex command waiting to run. If
378			* so, we continue with it.
379			*/
380			if (!EXCMD_RUNNING(gp)) {
381			/* Get a command. */
382			if (v_tcmd(sp, vp, ':',
383			TXT_BS \| TXT_CEDIT \| TXT_FILEC \| TXT_PROMPT))
384			return (1);
385			tp = TAILQ_FIRST(&sp->tiq);
386
387			/*
388			* If the user entered a single <esc>, they want to
389			* edit their colon command history. If they already
390			* entered some text, move it into the edit history.
391			*/
392			if (tp->term == TERM_CEDIT) {
393			if (tp->len > 1 && v_ecl_log(sp, tp))
394			return (1);
395			do_cedit = 1;
396			break;
397			}
398
399			/* If the user changed their mind, return. */
400			if (tp->term != TERM_OK)
401			break;
402
403			/* Log the command. */
404			if (O_STR(sp, O_CEDIT) != NULL && v_ecl_log(sp, tp))
405			return (1);
406
407			/* Push a command on the command stack. */
408			if (ex_run_str(sp, NULL, tp->lb, tp->len, 0, 1))
409			return (1);
410			}
411
412			/* Home the cursor. */
413			vs_home(sp);
414
415			/*
416			* !!!
417			* If the editor wrote the screen behind curses back, put out
418			* a <newline> so that we don't overwrite the user's command
419			* with its output or the next want-to-continue? message. This
420			* doesn't belong here, but I can't find another place to put
421			* it. See, we resolved the output from the last ex command,
422			* and the user entered another one. This is the only place
423			* where we have control before the ex command writes output.
424			* We could get control in vs_msg(), but we have no way to know
425			* if command didn't put out any output when we try and resolve
426			* this command. This fixes a bug where combinations of ex
427			* commands, e.g. ":set<CR>:!date<CR>:set" didn't look right.
428			*/
429			if (F_ISSET(sp, SC_SCR_EXWROTE))
430			(void)putchar('\n');
431
432			/* Call the ex parser. */
433			(void)ex_cmd(sp);
434
435			/* Flush ex messages. */
436			(void)ex_fflush(sp);
437
438			/* Resolve any messages. */
439			if (vs_ex_resolve(sp, &ifcontinue))
440			return (1);
441
442			/*
443			* Continue or return. If continuing, make sure that we
444			* eventually do resolution.
445			*/
446			if (!ifcontinue)
447			break;
448			do_resolution = 1;
449
450			/* If we're continuing, it's a new command. */
451			++sp->ccnt;
452			}
453
454			/*
455			* If the user previously continued an ex command, we have to do
456			* resolution to clean up the screen. Don't wait, we already did
457			* that.
458			*/
459			if (do_resolution) {
460			F_SET(sp, SC_EX_WAIT_NO);
461			if (vs_ex_resolve(sp, &ifcontinue))
462			return (1);
463			}
464
465			/* Cleanup from the ex command. */
466			if (v_ex_done(sp, vp))
467			return (1);
468
469			/* The user may want to edit their colon command history. */
470			if (do_cedit)
471			return (v_ecl(sp));
472
473			return (0);
474			}
475
476			/*
477			* v_ex_done --
478			* Cleanup from an ex command.
479			*/
480			static int
481			v_ex_done(SCR sp, VICMD vp)
482			{
483			size_t len;
484
485			/*
486			* The only cursor modifications are real, however, the underlying
487			* line may have changed; don't trust anything. This code has been
488			* a remarkably fertile place for bugs. Do a reality check on a
489			* cursor value, and make sure it's okay. If necessary, change it.
490			* Ex keeps track of the line number, but it cares less about the
491			* column and it may have disappeared.
492			*
493			* Don't trust ANYTHING.
494			*
495			* XXX
496			* Ex will soon have to start handling the column correctly; see
497			* the POSIX 1003.2 standard.
498			*/
499			if (db_eget(sp, sp->lno, NULL, &len, NULL)) {
500			sp->lno = 1;
501			sp->cno = 0;
502			} else if (sp->cno >= len)
503			sp->cno = len ? len - 1 : 0;
504
505			vp->m_final.lno = sp->lno;
506			vp->m_final.cno = sp->cno;
507
508			/*
509			* Don't re-adjust the cursor after executing an ex command,
510			* and ex movements are permanent.
511			*/
512			F_CLR(vp, VM_RCM_MASK);
513			F_SET(vp, VM_RCM_SET);
514
515			return (0);
516			}
517
518			/*
519			* v_ecl --
520			* Start an edit window on the colon command-line commands.
521			*/
522			static int
523			v_ecl(SCR *sp)
524			{
525			GS *gp;
526			SCR *new;
527
528			/* Initialize the screen, if necessary. */
529			gp = sp->gp;
530			if (gp->ccl_sp == NULL && v_ecl_init(sp))
531			return (1);
532
533			/* Get a new screen. */
534			if (screen_init(gp, sp, &new))
535			return (1);
536			if (vs_split(sp, new, 1)) {
537			(void)screen_end(new);
538			return (1);
539			}
540
541			/* Attach to the screen. */
542			new->ep = gp->ccl_sp->ep;
543			++new->ep->refcnt;
544
545			new->frp = gp->ccl_sp->frp;
546			new->frp->flags = sp->frp->flags;
547
548			/* Move the cursor to the end. */
549			(void)db_last(new, &new->lno);
550			if (new->lno == 0)
551			new->lno = 1;
552
553			/* Remember the originating window. */
554			sp->ccl_parent = sp;
555
556			/* It's a special window. */
557			F_SET(new, SC_COMEDIT);
558
559			/* Set up the switch. */
560			sp->nextdisp = new;
561			F_SET(sp, SC_SSWITCH);
562			return (0);
563			}
564
565			/*
566			* v_ecl_exec --
567			* Execute a command from a colon command-line window.
568			*
569			* PUBLIC: int v_ecl_exec(SCR *);
570			*/
571			int
572			v_ecl_exec(SCR *sp)
573			{
574			size_t len;
575			char *p;
576
577			if (db_get(sp, sp->lno, 0, &p, &len) && sp->lno == 1) {
578			v_emsg(sp, NULL, VIM_EMPTY);
579			return (1);
580			}
581			if (len == 0) {
582			msgq(sp, M_BERR, "No ex command to execute");
583			return (1);
584			}
585
586			/* Push the command on the command stack. */
587			if (ex_run_str(sp, NULL, p, len, 0, 0))
588			return (1);
589
590			/* Set up the switch. */
591			sp->nextdisp = sp->ccl_parent;
592			F_SET(sp, SC_EXIT);
593			return (0);
594			}
595
596			/*
597			* v_ecl_log --
598			* Log a command into the colon command-line log file.
599			*/
600			static int
601			v_ecl_log(SCR sp, TEXT tp)
602			{
603			EXF *save_ep;
604			recno_t lno;
605			int rval;
606
607			/* Initialize the screen, if necessary. */
608			if (sp->gp->ccl_sp == NULL && v_ecl_init(sp))
609			return (1);
610
611			/*
612			* Don't log colon command window commands into the colon command
613			* window...
614			*/
615			if (sp->ep == sp->gp->ccl_sp->ep)
616			return (0);
617
618			/*
619			* XXX
620			* Swap the current EXF with the colon command file EXF. This
621			* isn't pretty, but too many routines "know" that sp->ep points
622			* to the current EXF.
623			*/
624			save_ep = sp->ep;
625			sp->ep = sp->gp->ccl_sp->ep;
626			if (db_last(sp, &lno)) {
627			sp->ep = save_ep;
628			return (1);
629			}
630			rval = db_append(sp, 0, lno, tp->lb, tp->len);
631			sp->ep = save_ep;
632			return (rval);
633			}
634
635			/*
636			* v_ecl_init --
637			* Initialize the colon command-line log file.
638			*/
639			static int
640			v_ecl_init(SCR *sp)
641			{
642			FREF *frp;
643			GS *gp;
644
645			gp = sp->gp;
646
647			/* Get a temporary file. */
648			if ((frp = file_add(sp, NULL)) == NULL)
649			return (1);
650
651			/*
652			* XXX
653			* Create a screen -- the file initialization code wants one.
654			*/
655			if (screen_init(gp, sp, &gp->ccl_sp))
656			return (1);
657			if (file_init(gp->ccl_sp, frp, NULL, 0)) {
658			(void)screen_end(gp->ccl_sp);
659			return (1);
660			}
661
662			/* The underlying file isn't recoverable. */
663			F_CLR(gp->ccl_sp->ep, F_RCV_ON);
664
665			return (0);
666			}