[unix-history] / usr / src / cmd / ex / ex.c

/* Copyright (c) 1980 Regents of the University of California */
static char *sccsid = "%W% %G%";
#include "ex.h"
#include "ex_argv.h"
#include "ex_temp.h"
#include "ex_tty.h"

#ifdef TRACE
char	tttrace[]	= { '/','d','e','v','/','t','t','y','x','x',0 };
#endif

/*
 * The code for ex is divided as follows:
 *
 * ex.c			Entry point and routines handling interrupt, hangup
 *			signals; initialization code.
 *
 * ex_addr.c		Address parsing routines for command mode decoding.
 *			Routines to set and check address ranges on commands.
 *
 * ex_cmds.c		Command mode command decoding.
 *
 * ex_cmds2.c		Subroutines for command decoding and processing of
 *			file names in the argument list.  Routines to print
 *			messages and reset state when errors occur.
 *
 * ex_cmdsub.c		Subroutines which implement command mode functions
 *			such as append, delete, join.
 *
 * ex_data.c		Initialization of options.
 *
 * ex_get.c		Command mode input routines.
 *
 * ex_io.c		General input/output processing: file i/o, unix
 *			escapes, filtering, source commands, preserving
 *			and recovering.
 *
 * ex_put.c		Terminal driving and optimizing routines for low-level
 *			output (cursor-positioning); output line formatting
 *			routines.
 *
 * ex_re.c		Global commands, substitute, regular expression
 *			compilation and execution.
 *
 * ex_set.c		The set command.
 *
 * ex_subr.c		Loads of miscellaneous subroutines.
 *
 * ex_temp.c		Editor buffer routines for main buffer and also
 *			for named buffers (Q registers if you will.)
 *
 * ex_tty.c		Terminal dependent initializations from termcap
 *			data base, grabbing of tty modes (at beginning
 *			and after escapes).
 *
 * ex_unix.c		Routines for the ! command and its variations.
 *
 * ex_v*.c		Visual/open mode routines... see ex_v.c for a
 *			guide to the overall organization.
 */

/*
 * Main procedure.  Process arguments and then
 * transfer control to the main command processing loop
 * in the routine commands.  We are entered as either "ex", "edit", "vi"
 * or "view" and the distinction is made here.  Actually, we are "vi" if
 * there is a 'v' in our name, "view" is there is a 'w', and "edit" if
 * there is a 'd' in our name.  For edit we just diddle options;
 * for vi we actually force an early visual command.
 */
main(ac, av)
	register int ac;
	register char *av[];
{
#ifndef VMUNIX
	char *erpath = EXSTRINGS;
#endif
	register char *cp;
	register int c;
	bool recov = 0;
	bool ivis;
	bool itag = 0;
	bool fast = 0;
	extern int onemt();
#ifdef TRACE
	register char *tracef;
#endif

	/*
	 * Immediately grab the tty modes so that we wont
	 * get messed up if an interrupt comes in quickly.
	 */
	gTTY(1);
#ifndef USG3TTY
	normf = tty.sg_flags;
#else
	normf = tty;
#endif
	ppid = getpid();
	/*
	 * Defend against d's, v's, w's, and a's in directories of
	 * path leading to our true name.
	 */
	av[0] = tailpath(av[0]);

	/*
	 * Figure out how we were invoked: ex, edit, vi, view.
	 */
	ivis = any('v', av[0]);	/* "vi" */
	if (any('w', av[0]))	/* "view" */
		value(READONLY) = 1;
	if (any('d', av[0])) {	/* "edit" */
		value(OPEN) = 0;
		value(REPORT) = 1;
		value(MAGIC) = 0;
	}

#ifndef VMUNIX
	/*
	 * For debugging take files out of . if name is a.out.
	 */
	if (av[0][0] == 'a')
		erpath = tailpath(erpath);
#endif
	/*
	 * Open the error message file.
	 */
	draino();
#ifndef VMUNIX
	erfile = open(erpath+4, 0);
	if (erfile < 0) {
		erfile = open(erpath, 0);
	}
#endif
	pstop();

	/*
	 * Initialize interrupt handling.
	 */
	oldhup = signal(SIGHUP, SIG_IGN);
	if (oldhup == SIG_DFL)
		signal(SIGHUP, onhup);
	oldquit = signal(SIGQUIT, SIG_IGN);
	ruptible = signal(SIGINT, SIG_IGN) == SIG_DFL;
	if (signal(SIGTERM, SIG_IGN) == SIG_DFL)
		signal(SIGTERM, onhup);
	if (signal(SIGEMT, SIG_IGN) == SIG_DFL)
		signal(SIGEMT, onemt);

	/*
	 * Initialize end of core pointers.
	 * Normally we avoid breaking back to fendcore after each
	 * file since this can be expensive (much core-core copying).
	 * If your system can scatter load processes you could do
	 * this as ed does, saving a little core, but it will probably
	 * not often make much difference.
	 */
	fendcore = (line *) sbrk(0);
	endcore = fendcore - 2;

	/*
	 * Process flag arguments.
	 */
	ac--, av++;
	while (ac && av[0][0] == '-') {
		c = av[0][1];
		if (c == 0) {
			hush = 1;
			value(AUTOPRINT) = 0;
			fast++;
		} else switch (c) {

		case 'R':
			value(READONLY) = 1;
			break;

#ifdef TRACE
		case 'T':
			if (av[0][2] == 0)
				tracef = "trace";
			else {
				tracef = tttrace;
				tracef[8] = av[0][2];
				if (tracef[8])
					tracef[9] = av[0][3];
				else
					tracef[9] = 0;
			}
			trace = fopen(tracef, "w");
			if (trace == NULL)
				printf("Trace create error\n");
			setbuf(trace, tracbuf);
			break;

#endif

#ifdef LISPCODE
		case 'l':
			value(LISP) = 1;
			value(SHOWMATCH) = 1;
			break;
#endif

		case 'r':
			recov++;
			break;

		case 't':
			if (ac > 1 && av[1][0] != '-') {
				ac--, av++;
				itag = 1;
				/* BUG: should check for too long tag. */
				CP(lasttag, av[0]);
			}
			break;

		case 'v':
			ivis = 1;
			break;

		case 'w':
			defwind = 0;
			if (av[0][2] == 0) defwind = 3;
			else for (cp = &av[0][2]; isdigit(*cp); cp++)
				defwind = 10*defwind + *cp - '0';
			break;

#ifdef CRYPT
		case 'x':
			/* -x: encrypted mode */
			xflag = 1;
			break;
#endif

		default:
			smerror("Unknown option %s\n", av[0]);
			break;
		}
		ac--, av++;
	}

#ifdef SIGTSTP
	if (!hush && signal(SIGTSTP, SIG_IGN) == SIG_DFL)
		signal(SIGTSTP, onsusp), dosusp++;
#endif

	if (ac && av[0][0] == '+') {
		firstpat = &av[0][1];
		ac--, av++;
	}

#ifdef CRYPT
	if(xflag){
		key = getpass(KEYPROMPT);
		kflag = crinit(key, perm);
	}
#endif

	/*
	 * If we are doing a recover and no filename
	 * was given, then execute an exrecover command with
	 * the -r option to type out the list of saved file names.
	 * Otherwise set the remembered file name to the first argument
	 * file name so the "recover" initial command will find it.
	 */
	if (recov) {
		if (ac == 0) {
			ppid = 0;
			setrupt();
			execl(EXRECOVER, "exrecover", "-r", 0);
			filioerr(EXRECOVER);
			exit(1);
		}
		CP(savedfile, *av++), ac--;
	}

	/*
	 * Initialize the argument list.
	 */
	argv0 = av;
	argc0 = ac;
	args0 = av[0];
	erewind();

	/*
	 * Initialize a temporary file (buffer) and
	 * set up terminal environment.  Read user startup commands.
	 */
	if (setexit() == 0) {
		setrupt();
		intty = isatty(0);
		value(PROMPT) = intty;
		if (cp = getenv("SHELL"))
			CP(shell, cp);
		if (fast || !intty)
			setterm("dumb");
		else {
			gettmode();
			if ((cp = getenv("TERM")) != 0 && *cp)
				setterm(cp);
		}
	}
	if (setexit() == 0 && !fast && intty)
		if ((globp = getenv("EXINIT")) && *globp)
			commands(1,1);
		else {
			globp = 0;
			if ((cp = getenv("HOME")) != 0 && *cp)
				source(strcat(strcpy(genbuf, cp), "/.exrc"), 1);
		}
	init();	/* moved after prev 2 chunks to fix directory option */

	/*
	 * Initial processing.  Handle tag, recover, and file argument
	 * implied next commands.  If going in as 'vi', then don't do
	 * anything, just set initev so we will do it later (from within
	 * visual).
	 */
	if (setexit() == 0) {
		if (recov)
			globp = "recover";
		else if (itag)
			globp = ivis ? "tag" : "tag|p";
		else if (argc)
			globp = "next";
		if (ivis)
			initev = globp;
		else if (globp) {
			inglobal = 1;
			commands(1, 1);
			inglobal = 0;
		}
	}

	/*
	 * Vi command... go into visual.
	 * Strange... everything in vi usually happens
	 * before we ever "start".
	 */
	if (ivis) {
		/*
		 * Don't have to be upward compatible with stupidity
		 * of starting editing at line $.
		 */
		if (dol > zero)
			dot = one;
		globp = "visual";
		if (setexit() == 0)
			commands(1, 1);
	}

	/*
	 * Clear out trash in state accumulated by startup,
	 * and then do the main command loop for a normal edit.
	 * If you quit out of a 'vi' command by doing Q or ^\,
	 * you also fall through to here.
	 */
	seenprompt = 1;
	ungetchar(0);
	globp = 0;
	initev = 0;
	setlastchar('\n');
	setexit();
	commands(0, 0);
	cleanup(1);
	exit(0);
}

/*
 * Initialization, before editing a new file.
 * Main thing here is to get a new buffer (in fileinit),
 * rest is peripheral state resetting.
 */
init()
{
	register int i;

	fileinit();
	dot = zero = truedol = unddol = dol = fendcore;
	one = zero+1;
	undkind = UNDNONE;
	chng = 0;
	edited = 0;
	for (i = 0; i <= 'z'-'a'+1; i++)
		names[i] = 1;
	anymarks = 0;
#ifdef CRYPT
        if(xflag) {
                xtflag = 1;
                makekey(key, tperm);
        }
#endif
}

/*
 * When a hangup occurs our actions are similar to a preserve
 * command.  If the buffer has not been [Modified], then we do
 * nothing but remove the temporary files and exit.
 * Otherwise, we sync the temp file and then attempt a preserve.
 * If the preserve succeeds, we unlink our temp files.
 * If the preserve fails, we leave the temp files as they are
 * as they are a backup even without preservation if they
 * are not removed.
 */
onhup()
{

	/*
	 * USG tty driver can send multiple HUP's!!
	 */
	signal(SIGINT, SIG_IGN);
	signal(SIGHUP, SIG_IGN);
	if (chng == 0) {
		cleanup(1);
		exit(0);
	}
	if (setexit() == 0) {
		if (preserve()) {
			cleanup(1);
			exit(0);
		}
	}
	exit(1);
}

/*
 * An interrupt occurred.  Drain any output which
 * is still in the output buffering pipeline.
 * Catch interrupts again.  Unless we are in visual
 * reset the output state (out of -nl mode, e.g).
 * Then like a normal error (with the \n before Interrupt
 * suppressed in visual mode).
 */
onintr()
{

#ifndef CBREAK
	signal(SIGINT, onintr);
#else
	signal(SIGINT, inopen ? vintr : onintr);
#endif
	draino();
	if (!inopen) {
		pstop();
		setlastchar('\n');
#ifdef CBREAK
	}
#else
	} else
		vraw();
#endif
	error("\nInterrupt" + inopen);
}

/*
 * If we are interruptible, enable interrupts again.
 * In some critical sections we turn interrupts off,
 * but not very often.
 */
setrupt()
{

	if (ruptible) {
#ifndef CBREAK
		signal(SIGINT, onintr);
#else
		signal(SIGINT, inopen ? vintr : onintr);
#endif
#ifdef SIGTSTP
		if (dosusp)
			signal(SIGTSTP, onsusp);
#endif
	}
}

preserve()
{

#ifdef VMUNIX
	tflush();
#endif
	synctmp();
	pid = fork();
	if (pid < 0)
		return (0);
	if (pid == 0) {
		close(0);
		dup(tfile);
		execl(EXPRESERVE, "expreserve", (char *) 0);
		exit(1);
	}
	waitfor();
	if (rpid == pid && status == 0)
		return (1);
	return (0);
}

#ifndef V6
exit(i)
	int i;
{

# ifdef TRACE
	if (trace)
		fclose(trace);
# endif
	_exit(i);
}
#endif

/*
 * Return last component of unix path name p.
 */
char *
tailpath(p)
register char *p;
{
	register char *r;

	for (r=p; *p; p++)
		if (*p == '/')
			r = p+1;
	return(r);
}
Commit	Line	Data
ed6059a7 BJ	1	/* Copyright (c) 1980 Regents of the University of California */
	2	static char *sccsid = "%W% %G%";
	3	#include "ex.h"
	4	#include "ex_argv.h"
	5	#include "ex_temp.h"
	6	#include "ex_tty.h"
	7
	8	#ifdef TRACE
	9	char tttrace[] = { '/','d','e','v','/','t','t','y','x','x',0 };
	10	#endif
	11
	12	/*
	13	* The code for ex is divided as follows:
	14	*
	15	* ex.c Entry point and routines handling interrupt, hangup
	16	* signals; initialization code.
	17	*
	18	* ex_addr.c Address parsing routines for command mode decoding.
	19	* Routines to set and check address ranges on commands.
	20	*
	21	* ex_cmds.c Command mode command decoding.
	22	*
	23	* ex_cmds2.c Subroutines for command decoding and processing of
	24	* file names in the argument list. Routines to print
	25	* messages and reset state when errors occur.
	26	*
	27	* ex_cmdsub.c Subroutines which implement command mode functions
	28	* such as append, delete, join.
	29	*
	30	* ex_data.c Initialization of options.
	31	*
	32	* ex_get.c Command mode input routines.
	33	*
	34	* ex_io.c General input/output processing: file i/o, unix
	35	* escapes, filtering, source commands, preserving
	36	* and recovering.
	37	*
	38	* ex_put.c Terminal driving and optimizing routines for low-level
	39	* output (cursor-positioning); output line formatting
	40	* routines.
	41	*
	42	* ex_re.c Global commands, substitute, regular expression
	43	* compilation and execution.
	44	*
	45	* ex_set.c The set command.
	46	*
	47	* ex_subr.c Loads of miscellaneous subroutines.
	48	*
	49	* ex_temp.c Editor buffer routines for main buffer and also
	50	* for named buffers (Q registers if you will.)
	51	*
	52	* ex_tty.c Terminal dependent initializations from termcap
	53	* data base, grabbing of tty modes (at beginning
	54	* and after escapes).
	55	*
	56	* ex_unix.c Routines for the ! command and its variations.
	57	*
	58	* ex_v*.c Visual/open mode routines... see ex_v.c for a
	59	* guide to the overall organization.
	60	*/
	61
	62	/*
	63	* Main procedure. Process arguments and then
	64	* transfer control to the main command processing loop
65	* in the routine commands. We are entered as either "ex", "edit", "vi"
66	* or "view" and the distinction is made here. Actually, we are "vi" if
67	* there is a 'v' in our name, "view" is there is a 'w', and "edit" if
68	* there is a 'd' in our name. For edit we just diddle options;
69	* for vi we actually force an early visual command.
70	*/
71	main(ac, av)
72	register int ac;
73	register char *av[];
74	{
75	#ifndef VMUNIX
76	char *erpath = EXSTRINGS;
77	#endif
78	register char *cp;
79	register int c;
80	bool recov = 0;
81	bool ivis;
82	bool itag = 0;
83	bool fast = 0;
84	extern int onemt();
85	#ifdef TRACE
86	register char *tracef;
87	#endif
88
89	/*
90	* Immediately grab the tty modes so that we wont
91	* get messed up if an interrupt comes in quickly.
92	*/
93	gTTY(1);
94	#ifndef USG3TTY
95	normf = tty.sg_flags;
96	#else
97	normf = tty;
98	#endif
99	ppid = getpid();
100	/*
101	* Defend against d's, v's, w's, and a's in directories of
102	* path leading to our true name.
103	*/
104	av[0] = tailpath(av[0]);
105
106	/*
107	* Figure out how we were invoked: ex, edit, vi, view.
108	*/
109	ivis = any('v', av[0]); /* "vi" */
110	if (any('w', av[0])) /* "view" */
111	value(READONLY) = 1;
112	if (any('d', av[0])) { /* "edit" */
113	value(OPEN) = 0;
114	value(REPORT) = 1;
115	value(MAGIC) = 0;
116	}
117
118	#ifndef VMUNIX
119	/*
120	* For debugging take files out of . if name is a.out.
121	*/
122	if (av[0][0] == 'a')
123	erpath = tailpath(erpath);
124	#endif
125	/*
126	* Open the error message file.
127	*/
128	draino();
129	#ifndef VMUNIX
130	erfile = open(erpath+4, 0);
131	if (erfile < 0) {
132	erfile = open(erpath, 0);
133	}
134	#endif
135	pstop();
136
137	/*
138	* Initialize interrupt handling.
139	*/
140	oldhup = signal(SIGHUP, SIG_IGN);
141	if (oldhup == SIG_DFL)
142	signal(SIGHUP, onhup);
143	oldquit = signal(SIGQUIT, SIG_IGN);
144	ruptible = signal(SIGINT, SIG_IGN) == SIG_DFL;
145	if (signal(SIGTERM, SIG_IGN) == SIG_DFL)
146	signal(SIGTERM, onhup);
147	if (signal(SIGEMT, SIG_IGN) == SIG_DFL)
148	signal(SIGEMT, onemt);
149
150	/*
151	* Initialize end of core pointers.
152	* Normally we avoid breaking back to fendcore after each
153	* file since this can be expensive (much core-core copying).
154	* If your system can scatter load processes you could do
155	* this as ed does, saving a little core, but it will probably
156	* not often make much difference.
157	*/
158	fendcore = (line *) sbrk(0);
159	endcore = fendcore - 2;
160
161	/*
162	* Process flag arguments.
163	*/
164	ac--, av++;
165	while (ac && av[0][0] == '-') {
166	c = av[0][1];
167	if (c == 0) {
168	hush = 1;
169	value(AUTOPRINT) = 0;
170	fast++;
171	} else switch (c) {
172
173	case 'R':
174	value(READONLY) = 1;
175	break;
176
177	#ifdef TRACE
178	case 'T':
179	if (av[0][2] == 0)
180	tracef = "trace";
181	else {
182	tracef = tttrace;
183	tracef[8] = av[0][2];
184	if (tracef[8])
185	tracef[9] = av[0][3];
186	else
187	tracef[9] = 0;
188	}
189	trace = fopen(tracef, "w");
190	if (trace == NULL)
191	printf("Trace create error\n");
192	setbuf(trace, tracbuf);
193	break;
194
195	#endif
196
197	#ifdef LISPCODE
198	case 'l':
199	value(LISP) = 1;
200	value(SHOWMATCH) = 1;
201	break;
202	#endif
203
204	case 'r':
205	recov++;
206	break;
207
208	case 't':
209	if (ac > 1 && av[1][0] != '-') {
210	ac--, av++;
211	itag = 1;
212	/* BUG: should check for too long tag. */
213	CP(lasttag, av[0]);
214	}
215	break;
216
217	case 'v':
218	ivis = 1;
219	break;
220
221	case 'w':
222	defwind = 0;
223	if (av[0][2] == 0) defwind = 3;
224	else for (cp = &av[0][2]; isdigit(*cp); cp++)
225	defwind = 10defwind + cp - '0';
226	break;
227
228	#ifdef CRYPT
229	case 'x':
230	/* -x: encrypted mode */
231	xflag = 1;
232	break;
233	#endif
234
235	default:
236	smerror("Unknown option %s\n", av[0]);
237	break;
238	}
239	ac--, av++;
240	}
241
242	#ifdef SIGTSTP
243	if (!hush && signal(SIGTSTP, SIG_IGN) == SIG_DFL)
244	signal(SIGTSTP, onsusp), dosusp++;
245	#endif
246
247	if (ac && av[0][0] == '+') {
248	firstpat = &av[0][1];
249	ac--, av++;
250	}
251
252	#ifdef CRYPT
253	if(xflag){
254	key = getpass(KEYPROMPT);
255	kflag = crinit(key, perm);
256	}
257	#endif
258
259	/*
260	* If we are doing a recover and no filename
261	* was given, then execute an exrecover command with
262	* the -r option to type out the list of saved file names.
263	* Otherwise set the remembered file name to the first argument
264	* file name so the "recover" initial command will find it.
265	*/
266	if (recov) {
267	if (ac == 0) {
268	ppid = 0;
269	setrupt();
270	execl(EXRECOVER, "exrecover", "-r", 0);
271	filioerr(EXRECOVER);
272	exit(1);
273	}
274	CP(savedfile, *av++), ac--;
275	}
276
277	/*
278	* Initialize the argument list.
279	*/
280	argv0 = av;
281	argc0 = ac;
282	args0 = av[0];
283	erewind();
284
285	/*
286	* Initialize a temporary file (buffer) and
287	* set up terminal environment. Read user startup commands.
288	*/
289	if (setexit() == 0) {
290	setrupt();
291	intty = isatty(0);
292	value(PROMPT) = intty;
293	if (cp = getenv("SHELL"))
294	CP(shell, cp);
295	if (fast \|\| !intty)
296	setterm("dumb");
297	else {
298	gettmode();
299	if ((cp = getenv("TERM")) != 0 && *cp)
300	setterm(cp);
301	}
302	}
303	if (setexit() == 0 && !fast && intty)
304	if ((globp = getenv("EXINIT")) && *globp)
305	commands(1,1);
306	else {
307	globp = 0;
308	if ((cp = getenv("HOME")) != 0 && *cp)
309	source(strcat(strcpy(genbuf, cp), "/.exrc"), 1);
310	}
311	init(); /* moved after prev 2 chunks to fix directory option */
312
313	/*
314	* Initial processing. Handle tag, recover, and file argument
315	* implied next commands. If going in as 'vi', then don't do
316	* anything, just set initev so we will do it later (from within
317	* visual).
318	*/
319	if (setexit() == 0) {
320	if (recov)
321	globp = "recover";
322	else if (itag)
323	globp = ivis ? "tag" : "tag\|p";
324	else if (argc)
325	globp = "next";
326	if (ivis)
327	initev = globp;
328	else if (globp) {
329	inglobal = 1;
330	commands(1, 1);
331	inglobal = 0;
332	}
333	}
334
335	/*
336	* Vi command... go into visual.
337	* Strange... everything in vi usually happens
338	* before we ever "start".
339	*/
340	if (ivis) {
341	/*
342	* Don't have to be upward compatible with stupidity
343	* of starting editing at line $.
344	*/
345	if (dol > zero)
346	dot = one;
347	globp = "visual";
348	if (setexit() == 0)
349	commands(1, 1);
350	}
351
352	/*
353	* Clear out trash in state accumulated by startup,
354	* and then do the main command loop for a normal edit.
355	* If you quit out of a 'vi' command by doing Q or ^\,
356	* you also fall through to here.
357	*/
358	seenprompt = 1;
359	ungetchar(0);
360	globp = 0;
361	initev = 0;
362	setlastchar('\n');
363	setexit();
364	commands(0, 0);
365	cleanup(1);
366	exit(0);
367	}
368
369	/*
370	* Initialization, before editing a new file.
371	* Main thing here is to get a new buffer (in fileinit),
372	* rest is peripheral state resetting.
373	*/
374	init()
375	{
376	register int i;
377
378	fileinit();
379	dot = zero = truedol = unddol = dol = fendcore;
380	one = zero+1;
381	undkind = UNDNONE;
382	chng = 0;
383	edited = 0;
384	for (i = 0; i <= 'z'-'a'+1; i++)
385	names[i] = 1;
386	anymarks = 0;
387	#ifdef CRYPT
388	if(xflag) {
389	xtflag = 1;
390	makekey(key, tperm);
391	}
392	#endif
393	}
394
395	/*
396	* When a hangup occurs our actions are similar to a preserve
397	* command. If the buffer has not been [Modified], then we do
398	* nothing but remove the temporary files and exit.
399	* Otherwise, we sync the temp file and then attempt a preserve.
400	* If the preserve succeeds, we unlink our temp files.
401	* If the preserve fails, we leave the temp files as they are
402	* as they are a backup even without preservation if they
403	* are not removed.
404	*/
405	onhup()
406	{
407
408	/*
409	* USG tty driver can send multiple HUP's!!
410	*/
411	signal(SIGINT, SIG_IGN);
412	signal(SIGHUP, SIG_IGN);
413	if (chng == 0) {
414	cleanup(1);
415	exit(0);
416	}
417	if (setexit() == 0) {
418	if (preserve()) {
419	cleanup(1);
420	exit(0);
421	}
422	}
423	exit(1);
424	}
425
426	/*
427	* An interrupt occurred. Drain any output which
428	* is still in the output buffering pipeline.
429	* Catch interrupts again. Unless we are in visual
430	* reset the output state (out of -nl mode, e.g).
431	* Then like a normal error (with the \n before Interrupt
432	* suppressed in visual mode).
433	*/
434	onintr()
435	{
436
437	#ifndef CBREAK
438	signal(SIGINT, onintr);
439	#else
440	signal(SIGINT, inopen ? vintr : onintr);
441	#endif
442	draino();
443	if (!inopen) {
444	pstop();
445	setlastchar('\n');
446	#ifdef CBREAK
447	}
448	#else
449	} else
450	vraw();
451	#endif
452	error("\nInterrupt" + inopen);
453	}
454
455	/*
456	* If we are interruptible, enable interrupts again.
457	* In some critical sections we turn interrupts off,
458	* but not very often.
459	*/
460	setrupt()
461	{
462
463	if (ruptible) {
464	#ifndef CBREAK
465	signal(SIGINT, onintr);
466	#else
467	signal(SIGINT, inopen ? vintr : onintr);
468	#endif
469	#ifdef SIGTSTP
470	if (dosusp)
471	signal(SIGTSTP, onsusp);
472	#endif
473	}
474	}
475
476	preserve()
477	{
478
479	#ifdef VMUNIX
480	tflush();
481	#endif
482	synctmp();
483	pid = fork();
484	if (pid < 0)
485	return (0);
486	if (pid == 0) {
487	close(0);
488	dup(tfile);
489	execl(EXPRESERVE, "expreserve", (char *) 0);
490	exit(1);
491	}
492	waitfor();
493	if (rpid == pid && status == 0)
494	return (1);
495	return (0);
496	}
497
498	#ifndef V6
499	exit(i)
500	int i;
501	{
502
503	# ifdef TRACE
504	if (trace)
505	fclose(trace);
506	# endif
507	_exit(i);
508	}
509	#endif
510
511	/*
512	* Return last component of unix path name p.
513	*/
514	char *
515	tailpath(p)
516	register char *p;
517	{
518	register char *r;
519
520	for (r=p; *p; p++)
521	if (*p == '/')
522	r = p+1;
523	return(r);
524	}