main.c revision 228595 
1/* main.c: This file contains the main control and user-interface routines
2   for the ed line editor. */
3/*-
4 * Copyright (c) 1993 Andrew Moore, Talke Studio.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#ifndef lint
30#if 0
31static const char copyright[] =
32"@(#) Copyright (c) 1993 Andrew Moore, Talke Studio. \n\
33 All rights reserved.\n";
34#endif
35#endif /* not lint */
36
37#include <sys/cdefs.h>
38__FBSDID("$FreeBSD: head/bin/ed/main.c 228595 2011-12-16 21:12:23Z dim $");
39
40/*
41 * CREDITS
42 *
43 *	This program is based on the editor algorithm described in
44 *	Brian W. Kernighan and P. J. Plauger's book "Software Tools
45 *	in Pascal," Addison-Wesley, 1981.
46 *
47 *	The buffering algorithm is attributed to Rodney Ruddock of
48 *	the University of Guelph, Guelph, Ontario.
49 *
50 *	The cbc.c encryption code is adapted from
51 *	the bdes program by Matt Bishop of Dartmouth College,
52 *	Hanover, NH.
53 *
54 */
55
56#include <sys/types.h>
57
58#include <sys/ioctl.h>
59#include <sys/wait.h>
60#include <ctype.h>
61#include <locale.h>
62#include <pwd.h>
63#include <setjmp.h>
64
65#include "ed.h"
66
67
68#ifdef _POSIX_SOURCE
69sigjmp_buf env;
70#else
71jmp_buf env;
72#endif
73
74/* static buffers */
75char stdinbuf[1];		/* stdin buffer */
76char *shcmd;			/* shell command buffer */
77int shcmdsz;			/* shell command buffer size */
78int shcmdi;			/* shell command buffer index */
79char *ibuf;			/* ed command-line buffer */
80int ibufsz;			/* ed command-line buffer size */
81char *ibufp;			/* pointer to ed command-line buffer */
82
83/* global flags */
84int des = 0;			/* if set, use crypt(3) for i/o */
85int garrulous = 0;		/* if set, print all error messages */
86int isbinary;			/* if set, buffer contains ASCII NULs */
87int isglobal;			/* if set, doing a global command */
88int modified;			/* if set, buffer modified since last write */
89int mutex = 0;			/* if set, signals set "sigflags" */
90int red = 0;			/* if set, restrict shell/directory access */
91int scripted = 0;		/* if set, suppress diagnostics */
92int sigflags = 0;		/* if set, signals received while mutex set */
93int sigactive = 0;		/* if set, signal handlers are enabled */
94
95char old_filename[PATH_MAX] = "";	/* default filename */
96long current_addr;		/* current address in editor buffer */
97long addr_last;			/* last address in editor buffer */
98int lineno;			/* script line number */
99const char *prompt;		/* command-line prompt */
100const char *dps = "*";		/* default command-line prompt */
101
102const char usage[] = "usage: %s [-] [-sx] [-p string] [file]\n";
103
104/* ed: line editor */
105int
106main(volatile int argc, char ** volatile argv)
107{
108	int c, n;
109	long status = 0;
110
111	(void)setlocale(LC_ALL, "");
112
113	red = (n = strlen(argv[0])) > 2 && argv[0][n - 3] == 'r';
114top:
115	while ((c = getopt(argc, argv, "p:sx")) != -1)
116		switch(c) {
117		case 'p':				/* set prompt */
118			prompt = optarg;
119			break;
120		case 's':				/* run script */
121			scripted = 1;
122			break;
123		case 'x':				/* use crypt */
124#ifdef DES
125			des = get_keyword();
126#else
127			fprintf(stderr, "crypt unavailable\n?\n");
128#endif
129			break;
130
131		default:
132			fprintf(stderr, usage, red ? "red" : "ed");
133			exit(1);
134		}
135	argv += optind;
136	argc -= optind;
137	if (argc && **argv == '-') {
138		scripted = 1;
139		if (argc > 1) {
140			optind = 1;
141			goto top;
142		}
143		argv++;
144		argc--;
145	}
146	/* assert: reliable signals! */
147#ifdef SIGWINCH
148	handle_winch(SIGWINCH);
149	if (isatty(0)) signal(SIGWINCH, handle_winch);
150#endif
151	signal(SIGHUP, signal_hup);
152	signal(SIGQUIT, SIG_IGN);
153	signal(SIGINT, signal_int);
154#ifdef _POSIX_SOURCE
155	if ((status = sigsetjmp(env, 1)))
156#else
157	if ((status = setjmp(env)))
158#endif
159	{
160		fputs("\n?\n", stderr);
161		errmsg = "interrupt";
162	} else {
163		init_buffers();
164		sigactive = 1;			/* enable signal handlers */
165		if (argc && **argv && is_legal_filename(*argv)) {
166			if (read_file(*argv, 0) < 0 && !isatty(0))
167				quit(2);
168			else if (**argv != '!')
169				if (strlcpy(old_filename, *argv, sizeof(old_filename))
170				    >= sizeof(old_filename))
171					quit(2);
172		} else if (argc) {
173			fputs("?\n", stderr);
174			if (**argv == '\0')
175				errmsg = "invalid filename";
176			if (!isatty(0))
177				quit(2);
178		}
179	}
180	for (;;) {
181		if (status < 0 && garrulous)
182			fprintf(stderr, "%s\n", errmsg);
183		if (prompt) {
184			printf("%s", prompt);
185			fflush(stdout);
186		}
187		if ((n = get_tty_line()) < 0) {
188			status = ERR;
189			continue;
190		} else if (n == 0) {
191			if (modified && !scripted) {
192				fputs("?\n", stderr);
193				errmsg = "warning: file modified";
194				if (!isatty(0)) {
195					if (garrulous)
196						fprintf(stderr,
197						    "script, line %d: %s\n",
198						    lineno, errmsg);
199					quit(2);
200				}
201				clearerr(stdin);
202				modified = 0;
203				status = EMOD;
204				continue;
205			} else
206				quit(0);
207		} else if (ibuf[n - 1] != '\n') {
208			/* discard line */
209			errmsg = "unexpected end-of-file";
210			clearerr(stdin);
211			status = ERR;
212			continue;
213		}
214		isglobal = 0;
215		if ((status = extract_addr_range()) >= 0 &&
216		    (status = exec_command()) >= 0)
217			if (!status ||
218			    (status = display_lines(current_addr, current_addr,
219			        status)) >= 0)
220				continue;
221		switch (status) {
222		case EOF:
223			quit(0);
224		case EMOD:
225			modified = 0;
226			fputs("?\n", stderr);		/* give warning */
227			errmsg = "warning: file modified";
228			if (!isatty(0)) {
229				if (garrulous)
230					fprintf(stderr, "script, line %d: %s\n",
231					    lineno, errmsg);
232				quit(2);
233			}
234			break;
235		case FATAL:
236			if (!isatty(0)) {
237				if (garrulous)
238					fprintf(stderr, "script, line %d: %s\n",
239					    lineno, errmsg);
240			} else if (garrulous)
241				fprintf(stderr, "%s\n", errmsg);
242			quit(3);
243		default:
244			fputs("?\n", stderr);
245			if (!isatty(0)) {
246				if (garrulous)
247					fprintf(stderr, "script, line %d: %s\n",
248					    lineno, errmsg);
249				quit(2);
250			}
251			break;
252		}
253	}
254	/*NOTREACHED*/
255}
256
257long first_addr, second_addr, addr_cnt;
258
259/* extract_addr_range: get line addresses from the command buffer until an
260   illegal address is seen; return status */
261int
262extract_addr_range(void)
263{
264	long addr;
265
266	addr_cnt = 0;
267	first_addr = second_addr = current_addr;
268	while ((addr = next_addr()) >= 0) {
269		addr_cnt++;
270		first_addr = second_addr;
271		second_addr = addr;
272		if (*ibufp != ',' && *ibufp != ';')
273			break;
274		else if (*ibufp++ == ';')
275			current_addr = addr;
276	}
277	if ((addr_cnt = min(addr_cnt, 2)) == 1 || second_addr != addr)
278		first_addr = second_addr;
279	return (addr == ERR) ? ERR : 0;
280}
281
282
283#define SKIP_BLANKS() while (isspace((unsigned char)*ibufp) && *ibufp != '\n') ibufp++
284
285#define MUST_BE_FIRST() do {					\
286	if (!first) {						\
287		errmsg = "invalid address";			\
288		return ERR;					\
289	}							\
290} while (0)
291
292/*  next_addr: return the next line address in the command buffer */
293long
294next_addr(void)
295{
296	const char *hd;
297	long addr = current_addr;
298	long n;
299	int first = 1;
300	int c;
301
302	SKIP_BLANKS();
303	for (hd = ibufp;; first = 0)
304		switch (c = *ibufp) {
305		case '+':
306		case '\t':
307		case ' ':
308		case '-':
309		case '^':
310			ibufp++;
311			SKIP_BLANKS();
312			if (isdigit((unsigned char)*ibufp)) {
313				STRTOL(n, ibufp);
314				addr += (c == '-' || c == '^') ? -n : n;
315			} else if (!isspace((unsigned char)c))
316				addr += (c == '-' || c == '^') ? -1 : 1;
317			break;
318		case '0': case '1': case '2':
319		case '3': case '4': case '5':
320		case '6': case '7': case '8': case '9':
321			MUST_BE_FIRST();
322			STRTOL(addr, ibufp);
323			break;
324		case '.':
325		case '$':
326			MUST_BE_FIRST();
327			ibufp++;
328			addr = (c == '.') ? current_addr : addr_last;
329			break;
330		case '/':
331		case '?':
332			MUST_BE_FIRST();
333			if ((addr = get_matching_node_addr(
334			    get_compiled_pattern(), c == '/')) < 0)
335				return ERR;
336			else if (c == *ibufp)
337				ibufp++;
338			break;
339		case '\'':
340			MUST_BE_FIRST();
341			ibufp++;
342			if ((addr = get_marked_node_addr(*ibufp++)) < 0)
343				return ERR;
344			break;
345		case '%':
346		case ',':
347		case ';':
348			if (first) {
349				ibufp++;
350				addr_cnt++;
351				second_addr = (c == ';') ? current_addr : 1;
352				addr = addr_last;
353				break;
354			}
355			/* FALLTHROUGH */
356		default:
357			if (ibufp == hd)
358				return EOF;
359			else if (addr < 0 || addr_last < addr) {
360				errmsg = "invalid address";
361				return ERR;
362			} else
363				return addr;
364		}
365	/* NOTREACHED */
366}
367
368
369#ifdef BACKWARDS
370/* GET_THIRD_ADDR: get a legal address from the command buffer */
371#define GET_THIRD_ADDR(addr) \
372{ \
373	long ol1, ol2; \
374\
375	ol1 = first_addr, ol2 = second_addr; \
376	if (extract_addr_range() < 0) \
377		return ERR; \
378	else if (addr_cnt == 0) { \
379		errmsg = "destination expected"; \
380		return ERR; \
381	} else if (second_addr < 0 || addr_last < second_addr) { \
382		errmsg = "invalid address"; \
383		return ERR; \
384	} \
385	addr = second_addr; \
386	first_addr = ol1, second_addr = ol2; \
387}
388#else	/* BACKWARDS */
389/* GET_THIRD_ADDR: get a legal address from the command buffer */
390#define GET_THIRD_ADDR(addr) \
391{ \
392	long ol1, ol2; \
393\
394	ol1 = first_addr, ol2 = second_addr; \
395	if (extract_addr_range() < 0) \
396		return ERR; \
397	if (second_addr < 0 || addr_last < second_addr) { \
398		errmsg = "invalid address"; \
399		return ERR; \
400	} \
401	addr = second_addr; \
402	first_addr = ol1, second_addr = ol2; \
403}
404#endif
405
406
407/* GET_COMMAND_SUFFIX: verify the command suffix in the command buffer */
408#define GET_COMMAND_SUFFIX() { \
409	int done = 0; \
410	do { \
411		switch(*ibufp) { \
412		case 'p': \
413			gflag |= GPR, ibufp++; \
414			break; \
415		case 'l': \
416			gflag |= GLS, ibufp++; \
417			break; \
418		case 'n': \
419			gflag |= GNP, ibufp++; \
420			break; \
421		default: \
422			done++; \
423		} \
424	} while (!done); \
425	if (*ibufp++ != '\n') { \
426		errmsg = "invalid command suffix"; \
427		return ERR; \
428	} \
429}
430
431
432/* sflags */
433#define SGG 001		/* complement previous global substitute suffix */
434#define SGP 002		/* complement previous print suffix */
435#define SGR 004		/* use last regex instead of last pat */
436#define SGF 010		/* repeat last substitution */
437
438int patlock = 0;	/* if set, pattern not freed by get_compiled_pattern() */
439
440long rows = 22;		/* scroll length: ws_row - 2 */
441
442/* exec_command: execute the next command in command buffer; return print
443   request, if any */
444int
445exec_command(void)
446{
447	static pattern_t *pat = NULL;
448	static int sgflag = 0;
449	static long sgnum = 0;
450
451	pattern_t *tpat;
452	char *fnp;
453	int gflag = 0;
454	int sflags = 0;
455	long addr = 0;
456	int n = 0;
457	int c;
458
459	SKIP_BLANKS();
460	switch(c = *ibufp++) {
461	case 'a':
462		GET_COMMAND_SUFFIX();
463		if (!isglobal) clear_undo_stack();
464		if (append_lines(second_addr) < 0)
465			return ERR;
466		break;
467	case 'c':
468		if (check_addr_range(current_addr, current_addr) < 0)
469			return ERR;
470		GET_COMMAND_SUFFIX();
471		if (!isglobal) clear_undo_stack();
472		if (delete_lines(first_addr, second_addr) < 0 ||
473		    append_lines(current_addr) < 0)
474			return ERR;
475		break;
476	case 'd':
477		if (check_addr_range(current_addr, current_addr) < 0)
478			return ERR;
479		GET_COMMAND_SUFFIX();
480		if (!isglobal) clear_undo_stack();
481		if (delete_lines(first_addr, second_addr) < 0)
482			return ERR;
483		else if ((addr = INC_MOD(current_addr, addr_last)) != 0)
484			current_addr = addr;
485		break;
486	case 'e':
487		if (modified && !scripted)
488			return EMOD;
489		/* FALLTHROUGH */
490	case 'E':
491		if (addr_cnt > 0) {
492			errmsg = "unexpected address";
493			return ERR;
494		} else if (!isspace((unsigned char)*ibufp)) {
495			errmsg = "unexpected command suffix";
496			return ERR;
497		} else if ((fnp = get_filename()) == NULL)
498			return ERR;
499		GET_COMMAND_SUFFIX();
500		if (delete_lines(1, addr_last) < 0)
501			return ERR;
502		clear_undo_stack();
503		if (close_sbuf() < 0)
504			return ERR;
505		else if (open_sbuf() < 0)
506			return FATAL;
507		if (*fnp && *fnp != '!') strcpy(old_filename, fnp);
508#ifdef BACKWARDS
509		if (*fnp == '\0' && *old_filename == '\0') {
510			errmsg = "no current filename";
511			return ERR;
512		}
513#endif
514		if (read_file(*fnp ? fnp : old_filename, 0) < 0)
515			return ERR;
516		clear_undo_stack();
517		modified = 0;
518		u_current_addr = u_addr_last = -1;
519		break;
520	case 'f':
521		if (addr_cnt > 0) {
522			errmsg = "unexpected address";
523			return ERR;
524		} else if (!isspace((unsigned char)*ibufp)) {
525			errmsg = "unexpected command suffix";
526			return ERR;
527		} else if ((fnp = get_filename()) == NULL)
528			return ERR;
529		else if (*fnp == '!') {
530			errmsg = "invalid redirection";
531			return ERR;
532		}
533		GET_COMMAND_SUFFIX();
534		if (*fnp) strcpy(old_filename, fnp);
535		printf("%s\n", strip_escapes(old_filename));
536		break;
537	case 'g':
538	case 'v':
539	case 'G':
540	case 'V':
541		if (isglobal) {
542			errmsg = "cannot nest global commands";
543			return ERR;
544		} else if (check_addr_range(1, addr_last) < 0)
545			return ERR;
546		else if (build_active_list(c == 'g' || c == 'G') < 0)
547			return ERR;
548		else if ((n = (c == 'G' || c == 'V')))
549			GET_COMMAND_SUFFIX();
550		isglobal++;
551		if (exec_global(n, gflag) < 0)
552			return ERR;
553		break;
554	case 'h':
555		if (addr_cnt > 0) {
556			errmsg = "unexpected address";
557			return ERR;
558		}
559		GET_COMMAND_SUFFIX();
560		if (*errmsg) fprintf(stderr, "%s\n", errmsg);
561		break;
562	case 'H':
563		if (addr_cnt > 0) {
564			errmsg = "unexpected address";
565			return ERR;
566		}
567		GET_COMMAND_SUFFIX();
568		if ((garrulous = 1 - garrulous) && *errmsg)
569			fprintf(stderr, "%s\n", errmsg);
570		break;
571	case 'i':
572		if (second_addr == 0) {
573			errmsg = "invalid address";
574			return ERR;
575		}
576		GET_COMMAND_SUFFIX();
577		if (!isglobal) clear_undo_stack();
578		if (append_lines(second_addr - 1) < 0)
579			return ERR;
580		break;
581	case 'j':
582		if (check_addr_range(current_addr, current_addr + 1) < 0)
583			return ERR;
584		GET_COMMAND_SUFFIX();
585		if (!isglobal) clear_undo_stack();
586		if (first_addr != second_addr &&
587		    join_lines(first_addr, second_addr) < 0)
588			return ERR;
589		break;
590	case 'k':
591		c = *ibufp++;
592		if (second_addr == 0) {
593			errmsg = "invalid address";
594			return ERR;
595		}
596		GET_COMMAND_SUFFIX();
597		if (mark_line_node(get_addressed_line_node(second_addr), c) < 0)
598			return ERR;
599		break;
600	case 'l':
601		if (check_addr_range(current_addr, current_addr) < 0)
602			return ERR;
603		GET_COMMAND_SUFFIX();
604		if (display_lines(first_addr, second_addr, gflag | GLS) < 0)
605			return ERR;
606		gflag = 0;
607		break;
608	case 'm':
609		if (check_addr_range(current_addr, current_addr) < 0)
610			return ERR;
611		GET_THIRD_ADDR(addr);
612		if (first_addr <= addr && addr < second_addr) {
613			errmsg = "invalid destination";
614			return ERR;
615		}
616		GET_COMMAND_SUFFIX();
617		if (!isglobal) clear_undo_stack();
618		if (move_lines(addr) < 0)
619			return ERR;
620		break;
621	case 'n':
622		if (check_addr_range(current_addr, current_addr) < 0)
623			return ERR;
624		GET_COMMAND_SUFFIX();
625		if (display_lines(first_addr, second_addr, gflag | GNP) < 0)
626			return ERR;
627		gflag = 0;
628		break;
629	case 'p':
630		if (check_addr_range(current_addr, current_addr) < 0)
631			return ERR;
632		GET_COMMAND_SUFFIX();
633		if (display_lines(first_addr, second_addr, gflag | GPR) < 0)
634			return ERR;
635		gflag = 0;
636		break;
637	case 'P':
638		if (addr_cnt > 0) {
639			errmsg = "unexpected address";
640			return ERR;
641		}
642		GET_COMMAND_SUFFIX();
643		prompt = prompt ? NULL : optarg ? optarg : dps;
644		break;
645	case 'q':
646	case 'Q':
647		if (addr_cnt > 0) {
648			errmsg = "unexpected address";
649			return ERR;
650		}
651		GET_COMMAND_SUFFIX();
652		gflag =  (modified && !scripted && c == 'q') ? EMOD : EOF;
653		break;
654	case 'r':
655		if (!isspace((unsigned char)*ibufp)) {
656			errmsg = "unexpected command suffix";
657			return ERR;
658		} else if (addr_cnt == 0)
659			second_addr = addr_last;
660		if ((fnp = get_filename()) == NULL)
661			return ERR;
662		GET_COMMAND_SUFFIX();
663		if (!isglobal) clear_undo_stack();
664		if (*old_filename == '\0' && *fnp != '!')
665			strcpy(old_filename, fnp);
666#ifdef BACKWARDS
667		if (*fnp == '\0' && *old_filename == '\0') {
668			errmsg = "no current filename";
669			return ERR;
670		}
671#endif
672		if ((addr = read_file(*fnp ? fnp : old_filename, second_addr)) < 0)
673			return ERR;
674		else if (addr && addr != addr_last)
675			modified = 1;
676		break;
677	case 's':
678		do {
679			switch(*ibufp) {
680			case '\n':
681				sflags |=SGF;
682				break;
683			case 'g':
684				sflags |= SGG;
685				ibufp++;
686				break;
687			case 'p':
688				sflags |= SGP;
689				ibufp++;
690				break;
691			case 'r':
692				sflags |= SGR;
693				ibufp++;
694				break;
695			case '0': case '1': case '2': case '3': case '4':
696			case '5': case '6': case '7': case '8': case '9':
697				STRTOL(sgnum, ibufp);
698				sflags |= SGF;
699				sgflag &= ~GSG;		/* override GSG */
700				break;
701			default:
702				if (sflags) {
703					errmsg = "invalid command suffix";
704					return ERR;
705				}
706			}
707		} while (sflags && *ibufp != '\n');
708		if (sflags && !pat) {
709			errmsg = "no previous substitution";
710			return ERR;
711		} else if (sflags & SGG)
712			sgnum = 0;		/* override numeric arg */
713		if (*ibufp != '\n' && *(ibufp + 1) == '\n') {
714			errmsg = "invalid pattern delimiter";
715			return ERR;
716		}
717		tpat = pat;
718		SPL1();
719		if ((!sflags || (sflags & SGR)) &&
720		    (tpat = get_compiled_pattern()) == NULL) {
721		 	SPL0();
722			return ERR;
723		} else if (tpat != pat) {
724			if (pat) {
725				regfree(pat);
726				free(pat);
727			}
728			pat = tpat;
729			patlock = 1;		/* reserve pattern */
730		}
731		SPL0();
732		if (!sflags && extract_subst_tail(&sgflag, &sgnum) < 0)
733			return ERR;
734		else if (isglobal)
735			sgflag |= GLB;
736		else
737			sgflag &= ~GLB;
738		if (sflags & SGG)
739			sgflag ^= GSG;
740		if (sflags & SGP)
741			sgflag ^= GPR, sgflag &= ~(GLS | GNP);
742		do {
743			switch(*ibufp) {
744			case 'p':
745				sgflag |= GPR, ibufp++;
746				break;
747			case 'l':
748				sgflag |= GLS, ibufp++;
749				break;
750			case 'n':
751				sgflag |= GNP, ibufp++;
752				break;
753			default:
754				n++;
755			}
756		} while (!n);
757		if (check_addr_range(current_addr, current_addr) < 0)
758			return ERR;
759		GET_COMMAND_SUFFIX();
760		if (!isglobal) clear_undo_stack();
761		if (search_and_replace(pat, sgflag, sgnum) < 0)
762			return ERR;
763		break;
764	case 't':
765		if (check_addr_range(current_addr, current_addr) < 0)
766			return ERR;
767		GET_THIRD_ADDR(addr);
768		GET_COMMAND_SUFFIX();
769		if (!isglobal) clear_undo_stack();
770		if (copy_lines(addr) < 0)
771			return ERR;
772		break;
773	case 'u':
774		if (addr_cnt > 0) {
775			errmsg = "unexpected address";
776			return ERR;
777		}
778		GET_COMMAND_SUFFIX();
779		if (pop_undo_stack() < 0)
780			return ERR;
781		break;
782	case 'w':
783	case 'W':
784		if ((n = *ibufp) == 'q' || n == 'Q') {
785			gflag = EOF;
786			ibufp++;
787		}
788		if (!isspace((unsigned char)*ibufp)) {
789			errmsg = "unexpected command suffix";
790			return ERR;
791		} else if ((fnp = get_filename()) == NULL)
792			return ERR;
793		if (addr_cnt == 0 && !addr_last)
794			first_addr = second_addr = 0;
795		else if (check_addr_range(1, addr_last) < 0)
796			return ERR;
797		GET_COMMAND_SUFFIX();
798		if (*old_filename == '\0' && *fnp != '!')
799			strcpy(old_filename, fnp);
800#ifdef BACKWARDS
801		if (*fnp == '\0' && *old_filename == '\0') {
802			errmsg = "no current filename";
803			return ERR;
804		}
805#endif
806		if ((addr = write_file(*fnp ? fnp : old_filename,
807		    (c == 'W') ? "a" : "w", first_addr, second_addr)) < 0)
808			return ERR;
809		else if (addr == addr_last)
810			modified = 0;
811		else if (modified && !scripted && n == 'q')
812			gflag = EMOD;
813		break;
814	case 'x':
815		if (addr_cnt > 0) {
816			errmsg = "unexpected address";
817			return ERR;
818		}
819		GET_COMMAND_SUFFIX();
820#ifdef DES
821		des = get_keyword();
822		break;
823#else
824		errmsg = "crypt unavailable";
825		return ERR;
826#endif
827	case 'z':
828#ifdef BACKWARDS
829		if (check_addr_range(first_addr = 1, current_addr + 1) < 0)
830#else
831		if (check_addr_range(first_addr = 1, current_addr + !isglobal) < 0)
832#endif
833			return ERR;
834		else if ('0' < *ibufp && *ibufp <= '9')
835			STRTOL(rows, ibufp);
836		GET_COMMAND_SUFFIX();
837		if (display_lines(second_addr, min(addr_last,
838		    second_addr + rows), gflag) < 0)
839			return ERR;
840		gflag = 0;
841		break;
842	case '=':
843		GET_COMMAND_SUFFIX();
844		printf("%ld\n", addr_cnt ? second_addr : addr_last);
845		break;
846	case '!':
847		if (addr_cnt > 0) {
848			errmsg = "unexpected address";
849			return ERR;
850		} else if ((sflags = get_shell_command()) < 0)
851			return ERR;
852		GET_COMMAND_SUFFIX();
853		if (sflags) printf("%s\n", shcmd + 1);
854		system(shcmd + 1);
855		if (!scripted) printf("!\n");
856		break;
857	case '\n':
858#ifdef BACKWARDS
859		if (check_addr_range(first_addr = 1, current_addr + 1) < 0
860#else
861		if (check_addr_range(first_addr = 1, current_addr + !isglobal) < 0
862#endif
863		 || display_lines(second_addr, second_addr, 0) < 0)
864			return ERR;
865		break;
866	default:
867		errmsg = "unknown command";
868		return ERR;
869	}
870	return gflag;
871}
872
873
874/* check_addr_range: return status of address range check */
875int
876check_addr_range(long n, long m)
877{
878	if (addr_cnt == 0) {
879		first_addr = n;
880		second_addr = m;
881	}
882	if (first_addr > second_addr || 1 > first_addr ||
883	    second_addr > addr_last) {
884		errmsg = "invalid address";
885		return ERR;
886	}
887	return 0;
888}
889
890
891/* get_matching_node_addr: return the address of the next line matching a
892   pattern in a given direction.  wrap around begin/end of editor buffer if
893   necessary */
894long
895get_matching_node_addr(pattern_t *pat, int dir)
896{
897	char *s;
898	long n = current_addr;
899	line_t *lp;
900
901	if (!pat) return ERR;
902	do {
903	       if ((n = dir ? INC_MOD(n, addr_last) : DEC_MOD(n, addr_last))) {
904			lp = get_addressed_line_node(n);
905			if ((s = get_sbuf_line(lp)) == NULL)
906				return ERR;
907			if (isbinary)
908				NUL_TO_NEWLINE(s, lp->len);
909			if (!regexec(pat, s, 0, NULL, 0))
910				return n;
911	       }
912	} while (n != current_addr);
913	errmsg = "no match";
914	return  ERR;
915}
916
917
918/* get_filename: return pointer to copy of filename in the command buffer */
919char *
920get_filename(void)
921{
922	static char *file = NULL;
923	static int filesz = 0;
924
925	int n;
926
927	if (*ibufp != '\n') {
928		SKIP_BLANKS();
929		if (*ibufp == '\n') {
930			errmsg = "invalid filename";
931			return NULL;
932		} else if ((ibufp = get_extended_line(&n, 1)) == NULL)
933			return NULL;
934		else if (*ibufp == '!') {
935			ibufp++;
936			if ((n = get_shell_command()) < 0)
937				return NULL;
938			if (n)
939				printf("%s\n", shcmd + 1);
940			return shcmd;
941		} else if (n > PATH_MAX - 1) {
942			errmsg = "filename too long";
943			return  NULL;
944		}
945	}
946#ifndef BACKWARDS
947	else if (*old_filename == '\0') {
948		errmsg = "no current filename";
949		return  NULL;
950	}
951#endif
952	REALLOC(file, filesz, PATH_MAX, NULL);
953	for (n = 0; *ibufp != '\n';)
954		file[n++] = *ibufp++;
955	file[n] = '\0';
956	return is_legal_filename(file) ? file : NULL;
957}
958
959
960/* get_shell_command: read a shell command from stdin; return substitution
961   status */
962int
963get_shell_command(void)
964{
965	static char *buf = NULL;
966	static int n = 0;
967
968	char *s;			/* substitution char pointer */
969	int i = 0;
970	int j = 0;
971
972	if (red) {
973		errmsg = "shell access restricted";
974		return ERR;
975	} else if ((s = ibufp = get_extended_line(&j, 1)) == NULL)
976		return ERR;
977	REALLOC(buf, n, j + 1, ERR);
978	buf[i++] = '!';			/* prefix command w/ bang */
979	while (*ibufp != '\n')
980		switch (*ibufp) {
981		default:
982			REALLOC(buf, n, i + 2, ERR);
983			buf[i++] = *ibufp;
984			if (*ibufp++ == '\\')
985				buf[i++] = *ibufp++;
986			break;
987		case '!':
988			if (s != ibufp) {
989				REALLOC(buf, n, i + 1, ERR);
990				buf[i++] = *ibufp++;
991			}
992#ifdef BACKWARDS
993			else if (shcmd == NULL || *(shcmd + 1) == '\0')
994#else
995			else if (shcmd == NULL)
996#endif
997			{
998				errmsg = "no previous command";
999				return ERR;
1000			} else {
1001				REALLOC(buf, n, i + shcmdi, ERR);
1002				for (s = shcmd + 1; s < shcmd + shcmdi;)
1003					buf[i++] = *s++;
1004				s = ibufp++;
1005			}
1006			break;
1007		case '%':
1008			if (*old_filename  == '\0') {
1009				errmsg = "no current filename";
1010				return ERR;
1011			}
1012			j = strlen(s = strip_escapes(old_filename));
1013			REALLOC(buf, n, i + j, ERR);
1014			while (j--)
1015				buf[i++] = *s++;
1016			s = ibufp++;
1017			break;
1018		}
1019	REALLOC(shcmd, shcmdsz, i + 1, ERR);
1020	memcpy(shcmd, buf, i);
1021	shcmd[shcmdi = i] = '\0';
1022	return *s == '!' || *s == '%';
1023}
1024
1025
1026/* append_lines: insert text from stdin to after line n; stop when either a
1027   single period is read or EOF; return status */
1028int
1029append_lines(long n)
1030{
1031	int l;
1032	const char *lp = ibuf;
1033	const char *eot;
1034	undo_t *up = NULL;
1035
1036	for (current_addr = n;;) {
1037		if (!isglobal) {
1038			if ((l = get_tty_line()) < 0)
1039				return ERR;
1040			else if (l == 0 || ibuf[l - 1] != '\n') {
1041				clearerr(stdin);
1042				return  l ? EOF : 0;
1043			}
1044			lp = ibuf;
1045		} else if (*(lp = ibufp) == '\0')
1046			return 0;
1047		else {
1048			while (*ibufp++ != '\n')
1049				;
1050			l = ibufp - lp;
1051		}
1052		if (l == 2 && lp[0] == '.' && lp[1] == '\n') {
1053			return 0;
1054		}
1055		eot = lp + l;
1056		SPL1();
1057		do {
1058			if ((lp = put_sbuf_line(lp)) == NULL) {
1059				SPL0();
1060				return ERR;
1061			} else if (up)
1062				up->t = get_addressed_line_node(current_addr);
1063			else if ((up = push_undo_stack(UADD, current_addr,
1064			    current_addr)) == NULL) {
1065				SPL0();
1066				return ERR;
1067			}
1068		} while (lp != eot);
1069		modified = 1;
1070		SPL0();
1071	}
1072	/* NOTREACHED */
1073}
1074
1075
1076/* join_lines: replace a range of lines with the joined text of those lines */
1077int
1078join_lines(long from, long to)
1079{
1080	static char *buf = NULL;
1081	static int n;
1082
1083	char *s;
1084	int size = 0;
1085	line_t *bp, *ep;
1086
1087	ep = get_addressed_line_node(INC_MOD(to, addr_last));
1088	bp = get_addressed_line_node(from);
1089	for (; bp != ep; bp = bp->q_forw) {
1090		if ((s = get_sbuf_line(bp)) == NULL)
1091			return ERR;
1092		REALLOC(buf, n, size + bp->len, ERR);
1093		memcpy(buf + size, s, bp->len);
1094		size += bp->len;
1095	}
1096	REALLOC(buf, n, size + 2, ERR);
1097	memcpy(buf + size, "\n", 2);
1098	if (delete_lines(from, to) < 0)
1099		return ERR;
1100	current_addr = from - 1;
1101	SPL1();
1102	if (put_sbuf_line(buf) == NULL ||
1103	    push_undo_stack(UADD, current_addr, current_addr) == NULL) {
1104		SPL0();
1105		return ERR;
1106	}
1107	modified = 1;
1108	SPL0();
1109	return 0;
1110}
1111
1112
1113/* move_lines: move a range of lines */
1114int
1115move_lines(long addr)
1116{
1117	line_t *b1, *a1, *b2, *a2;
1118	long n = INC_MOD(second_addr, addr_last);
1119	long p = first_addr - 1;
1120	int done = (addr == first_addr - 1 || addr == second_addr);
1121
1122	SPL1();
1123	if (done) {
1124		a2 = get_addressed_line_node(n);
1125		b2 = get_addressed_line_node(p);
1126		current_addr = second_addr;
1127	} else if (push_undo_stack(UMOV, p, n) == NULL ||
1128	    push_undo_stack(UMOV, addr, INC_MOD(addr, addr_last)) == NULL) {
1129		SPL0();
1130		return ERR;
1131	} else {
1132		a1 = get_addressed_line_node(n);
1133		if (addr < first_addr) {
1134			b1 = get_addressed_line_node(p);
1135			b2 = get_addressed_line_node(addr);
1136					/* this get_addressed_line_node last! */
1137		} else {
1138			b2 = get_addressed_line_node(addr);
1139			b1 = get_addressed_line_node(p);
1140					/* this get_addressed_line_node last! */
1141		}
1142		a2 = b2->q_forw;
1143		REQUE(b2, b1->q_forw);
1144		REQUE(a1->q_back, a2);
1145		REQUE(b1, a1);
1146		current_addr = addr + ((addr < first_addr) ?
1147		    second_addr - first_addr + 1 : 0);
1148	}
1149	if (isglobal)
1150		unset_active_nodes(b2->q_forw, a2);
1151	modified = 1;
1152	SPL0();
1153	return 0;
1154}
1155
1156
1157/* copy_lines: copy a range of lines; return status */
1158int
1159copy_lines(long addr)
1160{
1161	line_t *lp, *np = get_addressed_line_node(first_addr);
1162	undo_t *up = NULL;
1163	long n = second_addr - first_addr + 1;
1164	long m = 0;
1165
1166	current_addr = addr;
1167	if (first_addr <= addr && addr < second_addr) {
1168		n =  addr - first_addr + 1;
1169		m = second_addr - addr;
1170	}
1171	for (; n > 0; n=m, m=0, np = get_addressed_line_node(current_addr + 1))
1172		for (; n-- > 0; np = np->q_forw) {
1173			SPL1();
1174			if ((lp = dup_line_node(np)) == NULL) {
1175				SPL0();
1176				return ERR;
1177			}
1178			add_line_node(lp);
1179			if (up)
1180				up->t = lp;
1181			else if ((up = push_undo_stack(UADD, current_addr,
1182			    current_addr)) == NULL) {
1183				SPL0();
1184				return ERR;
1185			}
1186			modified = 1;
1187			SPL0();
1188		}
1189	return 0;
1190}
1191
1192
1193/* delete_lines: delete a range of lines */
1194int
1195delete_lines(long from, long to)
1196{
1197	line_t *n, *p;
1198
1199	SPL1();
1200	if (push_undo_stack(UDEL, from, to) == NULL) {
1201		SPL0();
1202		return ERR;
1203	}
1204	n = get_addressed_line_node(INC_MOD(to, addr_last));
1205	p = get_addressed_line_node(from - 1);
1206					/* this get_addressed_line_node last! */
1207	if (isglobal)
1208		unset_active_nodes(p->q_forw, n);
1209	REQUE(p, n);
1210	addr_last -= to - from + 1;
1211	current_addr = from - 1;
1212	modified = 1;
1213	SPL0();
1214	return 0;
1215}
1216
1217
1218/* display_lines: print a range of lines to stdout */
1219int
1220display_lines(long from, long to, int gflag)
1221{
1222	line_t *bp;
1223	line_t *ep;
1224	char *s;
1225
1226	if (!from) {
1227		errmsg = "invalid address";
1228		return ERR;
1229	}
1230	ep = get_addressed_line_node(INC_MOD(to, addr_last));
1231	bp = get_addressed_line_node(from);
1232	for (; bp != ep; bp = bp->q_forw) {
1233		if ((s = get_sbuf_line(bp)) == NULL)
1234			return ERR;
1235		if (put_tty_line(s, bp->len, current_addr = from++, gflag) < 0)
1236			return ERR;
1237	}
1238	return 0;
1239}
1240
1241
1242#define MAXMARK 26			/* max number of marks */
1243
1244line_t	*mark[MAXMARK];			/* line markers */
1245int markno;				/* line marker count */
1246
1247/* mark_line_node: set a line node mark */
1248int
1249mark_line_node(line_t *lp, int n)
1250{
1251	if (!islower((unsigned char)n)) {
1252		errmsg = "invalid mark character";
1253		return ERR;
1254	} else if (mark[n - 'a'] == NULL)
1255		markno++;
1256	mark[n - 'a'] = lp;
1257	return 0;
1258}
1259
1260
1261/* get_marked_node_addr: return address of a marked line */
1262long
1263get_marked_node_addr(int n)
1264{
1265	if (!islower((unsigned char)n)) {
1266		errmsg = "invalid mark character";
1267		return ERR;
1268	}
1269	return get_line_node_addr(mark[n - 'a']);
1270}
1271
1272
1273/* unmark_line_node: clear line node mark */
1274void
1275unmark_line_node(line_t *lp)
1276{
1277	int i;
1278
1279	for (i = 0; markno && i < MAXMARK; i++)
1280		if (mark[i] == lp) {
1281			mark[i] = NULL;
1282			markno--;
1283		}
1284}
1285
1286
1287/* dup_line_node: return a pointer to a copy of a line node */
1288line_t *
1289dup_line_node(line_t *lp)
1290{
1291	line_t *np;
1292
1293	if ((np = (line_t *) malloc(sizeof(line_t))) == NULL) {
1294		fprintf(stderr, "%s\n", strerror(errno));
1295		errmsg = "out of memory";
1296		return NULL;
1297	}
1298	np->seek = lp->seek;
1299	np->len = lp->len;
1300	return np;
1301}
1302
1303
1304/* has_trailing_escape:  return the parity of escapes preceding a character
1305   in a string */
1306int
1307has_trailing_escape(char *s, char *t)
1308{
1309    return (s == t || *(t - 1) != '\\') ? 0 : !has_trailing_escape(s, t - 1);
1310}
1311
1312
1313/* strip_escapes: return copy of escaped string of at most length PATH_MAX */
1314char *
1315strip_escapes(char *s)
1316{
1317	static char *file = NULL;
1318	static int filesz = 0;
1319
1320	int i = 0;
1321
1322	REALLOC(file, filesz, PATH_MAX, NULL);
1323	while (i < filesz - 1	/* Worry about a possible trailing escape */
1324	       && (file[i++] = (*s == '\\') ? *++s : *s))
1325		s++;
1326	return file;
1327}
1328
1329
1330void
1331signal_hup(int signo)
1332{
1333	if (mutex)
1334		sigflags |= (1 << (signo - 1));
1335	else
1336		handle_hup(signo);
1337}
1338
1339
1340void
1341signal_int(int signo)
1342{
1343	if (mutex)
1344		sigflags |= (1 << (signo - 1));
1345	else
1346		handle_int(signo);
1347}
1348
1349
1350void
1351handle_hup(int signo)
1352{
1353	char *hup = NULL;		/* hup filename */
1354	char *s;
1355	char ed_hup[] = "ed.hup";
1356	int n;
1357
1358	if (!sigactive)
1359		quit(1);
1360	sigflags &= ~(1 << (signo - 1));
1361	if (addr_last && write_file(ed_hup, "w", 1, addr_last) < 0 &&
1362	    (s = getenv("HOME")) != NULL &&
1363	    (n = strlen(s)) + 8 <= PATH_MAX &&	/* "ed.hup" + '/' */
1364	    (hup = (char *) malloc(n + 10)) != NULL) {
1365		strcpy(hup, s);
1366		if (hup[n - 1] != '/')
1367			hup[n] = '/', hup[n+1] = '\0';
1368		strcat(hup, "ed.hup");
1369		write_file(hup, "w", 1, addr_last);
1370	}
1371	quit(2);
1372}
1373
1374
1375void
1376handle_int(int signo)
1377{
1378	if (!sigactive)
1379		quit(1);
1380	sigflags &= ~(1 << (signo - 1));
1381#ifdef _POSIX_SOURCE
1382	siglongjmp(env, -1);
1383#else
1384	longjmp(env, -1);
1385#endif
1386}
1387
1388
1389int cols = 72;				/* wrap column */
1390
1391void
1392handle_winch(int signo)
1393{
1394	int save_errno = errno;
1395
1396	struct winsize ws;		/* window size structure */
1397
1398	sigflags &= ~(1 << (signo - 1));
1399	if (ioctl(0, TIOCGWINSZ, (char *) &ws) >= 0) {
1400		if (ws.ws_row > 2) rows = ws.ws_row - 2;
1401		if (ws.ws_col > 8) cols = ws.ws_col - 8;
1402	}
1403	errno = save_errno;
1404}
1405
1406
1407/* is_legal_filename: return a legal filename */
1408int
1409is_legal_filename(char *s)
1410{
1411	if (red && (*s == '!' || !strcmp(s, "..") || strchr(s, '/'))) {
1412		errmsg = "shell access restricted";
1413		return 0;
1414	}
1415	return 1;
1416}
1417