/usr/src/bin/ed/main.c

Bug Summary

File:	src/bin/ed/main.c
Warning:	line 972, column 11 Array access (from variable 'buf') results in a null pointer dereference
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name main.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/bin/ed/obj -resource-dir /usr/local/lib/clang/13.0.0 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/bin/ed/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/bin/ed/main.c
1/*	$OpenBSD: main.c,v 1.66 2019/06/28 13:34:59 deraadt Exp $	*/
2/*	$NetBSD: main.c,v 1.3 1995/03/21 09:04:44 cgd Exp $	*/

4/* main.c: This file contains the main control and user-interface routines
 for the ed line editor. */
6/*-
* Copyright (c) 1993 Andrew Moore, Talke Studio.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

32/*
* CREDITS
*
*	This program is based on the editor algorithm described in
*	Brian W. Kernighan and P. J. Plauger's book "Software Tools
*	in Pascal," Addison-Wesley, 1981.
*
*	The buffering algorithm is attributed to Rodney Ruddock of
*	the University of Guelph, Guelph, Ontario.
*
*/

44#include <sys/ioctl.h>
45#include <sys/stat.h>
46#include <sys/wait.h>

48#include <ctype.h>
49#include <err.h>
50#include <errno(*__errno()).h>
51#include <limits.h>
52#include <pwd.h>
53#include <regex.h>
54#include <setjmp.h>
55#include <signal.h>
56#include <stdio.h>
57#include <stdlib.h>
58#include <string.h>
59#include <unistd.h>

61#include "ed.h"

63void signal_hup(int);
64void signal_int(int);
65void handle_winch(int);

67static int next_addr(void);
68static int check_addr_range(int, int);
69static int get_matching_node_addr(regex_t *, int);
70static char *get_filename(int);
71static int get_shell_command(void);
72static int append_lines(int);
73static int join_lines(int, int);
74static int move_lines(int);
75static int copy_lines(int);
76static int mark_line_node(line_t *, int);
77static int get_marked_node_addr(int);
78static line_t *dup_line_node(line_t *);

80sigjmp_buf env;

82/* static buffers */
83static char errmsg[PATH_MAX1024 + 40];	/* error message buffer */
84static char *shcmd;		/* shell command buffer */
85static int shcmdsz;		/* shell command buffer size */
86static int shcmdi;		/* shell command buffer index */
87static char old_filename[PATH_MAX1024];	/* default filename */

89/* global buffers */
90char *ibuf;			/* ed command-line buffer */
91int ibufsz;			/* ed command-line buffer size */
92char *ibufp;			/* pointer to ed command-line buffer */

94/* global flags */
95int garrulous = 0;		/* if set, print all error messages */
96int isbinary;			/* if set, buffer contains ASCII NULs */
97int isglobal;			/* if set, doing a global command */
98int modified;			/* if set, buffer modified since last write */
99int scripted = 0;		/* if set, suppress diagnostics */
100int interactive = 0;		/* if set, we are in interactive mode */

102volatile sig_atomic_t mutex = 0;  /* if set, signals set flags */
103volatile sig_atomic_t sighup = 0; /* if set, sighup received while mutex set */
104volatile sig_atomic_t sigint = 0; /* if set, sigint received while mutex set */

106/* if set, signal handlers are enabled */
107volatile sig_atomic_t sigactive = 0;

109int current_addr;		/* current address in editor buffer */
110int addr_last;			/* last address in editor buffer */
111int lineno;			/* script line number */
112static char *prompt;		/* command-line prompt */
113static char *dps = "*";		/* default command-line prompt */

115static const char usage[] = "usage: %s [-] [-s] [-p string] [file]\n";

117static char *home;		/* home directory */

119void
120seterrmsg(char *s)
121{
strlcpy(errmsg, s, sizeof(errmsg));
123}

125/* ed: line editor */
126int
127main(volatile int argc, char ** volatile argv)
128{
int c, n;
int status = 0;

if (pledge("stdio rpath wpath cpath proc exec tty", NULL((void *)0)) == -1)
err(1, "pledge");

home = getenv("HOME");

137top:
while ((c = getopt(argc, argv, "p:sx")) != -1)
switch (c) {
case 'p':				/* set prompt */
	dps = prompt = optarg;
	break;
case 's':				/* run script */
	scripted = 1;
	break;
case 'x':				/* use crypt */
	fprintf(stderr(&__sF[2]), "crypt unavailable\n?\n");
	break;
default:
	fprintf(stderr(&__sF[2]), usage, argv[0]);
	exit(1);
}
argv += optind;
argc -= optind;
if (argc && **argv == '-') {
scripted = 1;
if (argc > 1) {
	optind = 1;
	goto top;
}
argv++;
argc--;
}

if (!(interactive = isatty(0))) {
struct stat sb;

/* assert: pipes show up as fifo's when fstat'd */
if (fstat(STDIN_FILENO0, &sb) || !S_ISFIFO(sb.st_mode)((sb.st_mode & 0170000) == 0010000)) {
	if (lseek(STDIN_FILENO0, 0, SEEK_CUR1)) {
		interactive = 1;
		setvbuf(stdout(&__sF[1]), NULL((void *)0), _IOLBF1, 0);
	}
}
}

/* assert: reliable signals! */
if (isatty(STDIN_FILENO0)) {
handle_winch(SIGWINCH28);
signal(SIGWINCH28, handle_winch);
}
signal(SIGHUP1, signal_hup);
signal(SIGQUIT3, SIG_IGN(void (*)(int))1);
signal(SIGINT2, signal_int);
if (sigsetjmp(env, 1)) {
status = -1;
fputs("\n?\n", stderr(&__sF[2]));
seterrmsg("interrupt");
} else {
init_buffers();
sigactive = 1;			/* enable signal handlers */
if (argc && **argv) {
	if (read_file(*argv, 0) < 0 && !interactive)
		quit(2);
	else if (**argv != '!')
		strlcpy(old_filename, *argv,
		    sizeof old_filename);
} else if (argc) {
	fputs("?\n", stderr(&__sF[2]));
	if (**argv == '\0')
		seterrmsg("invalid filename");
	if (!interactive)
		quit(2);
}
}
for (;;) {
if (status < 0 && garrulous)
	fprintf(stderr(&__sF[2]), "%s\n", errmsg);
if (prompt) {
	fputs(prompt, stdout(&__sF[1]));
	fflush(stdout(&__sF[1]));
}
if ((n = get_tty_line()) < 0) {
	status = ERR(-2);
	continue;
} else if (n == 0) {
	if (modified && !scripted) {
		fputs("?\n", stderr(&__sF[2]));
		seterrmsg("warning: file modified");
		if (!interactive) {
			if (garrulous)
				fprintf(stderr(&__sF[2]),
				    "script, line %d: %s\n",
				    lineno, errmsg);
			quit(2);
		}
		clearerr(stdin)(!__isthreaded ? ((void)(((&__sF[0]))->_flags &= ~
(0x0040|0x0020))) : (clearerr)((&__sF[0])));
		modified = 0;
		status = EMOD(-3);
		continue;
	} else
		quit(0);
} else if (ibuf[n - 1] != '\n') {
	/* discard line */
	seterrmsg("unexpected end-of-file");
	clearerr(stdin)(!__isthreaded ? ((void)(((&__sF[0]))->_flags &= ~
(0x0040|0x0020))) : (clearerr)((&__sF[0])));
	status = ERR(-2);
	continue;
}
isglobal = 0;
if ((status = extract_addr_range()) >= 0 &&
    (status = exec_command()) >= 0)
	if (!status || (status &&
	    (status = display_lines(current_addr, current_addr,
		status)) >= 0))
		continue;
switch (status) {
case EOF(-1):
	quit(0);
	break;
case EMOD(-3):
	modified = 0;
	fputs("?\n", stderr(&__sF[2]));		/* give warning */
	seterrmsg("warning: file modified");
	if (!interactive) {
		if (garrulous)
			fprintf(stderr(&__sF[2]),
			    "script, line %d: %s\n",
			    lineno, errmsg);
		quit(2);
	}
	break;
case FATAL(-4):
	if (!interactive) {
		if (garrulous)
			fprintf(stderr(&__sF[2]),
			    "script, line %d: %s\n",
			    lineno, errmsg);
	} else if (garrulous)
		fprintf(stderr(&__sF[2]), "%s\n", errmsg);
	quit(3);
	break;
default:
	fputs("?\n", stderr(&__sF[2]));
	if (!interactive) {
		if (garrulous)
			fprintf(stderr(&__sF[2]),
			    "script, line %d: %s\n",
			    lineno, errmsg);
		quit(2);
	}
	break;
}
}
/*NOTREACHED*/
286}

288int first_addr, second_addr, addr_cnt;

290/* extract_addr_range: get line addresses from the command buffer until an
 illegal address is seen; return status */
292int
293extract_addr_range(void)
294{
int addr;

addr_cnt = 0;
first_addr = second_addr = current_addr;
while ((addr = next_addr()) >= 0) {
addr_cnt++;
first_addr = second_addr;
second_addr = addr;
if (*ibufp != ',' && *ibufp != ';')
	break;
else if (*ibufp++ == ';')
	current_addr = addr;
}
if ((addr_cnt = min(addr_cnt, 2)((addr_cnt) < (2) ? (addr_cnt) : (2))) == 1 || second_addr != addr)
first_addr = second_addr;
return (addr == ERR(-2)) ? ERR(-2) : 0;
311}


314#define	SKIP_BLANKS()do { while (isspace((unsigned char)*ibufp) && *ibufp !=
 '\n') ibufp++; } while (0) \
do { \
while (isspace((unsigned char)*ibufp) && *ibufp != '\n') \
	ibufp++; \
} while (0)

320#define MUST_BE_FIRST()do { if (!first) { seterrmsg("invalid address"); return (-2);
 } } while (0) \
do { \
if (!first) { \
	seterrmsg("invalid address"); \
	return ERR(-2); \
} \
} while (0)


329/*  next_addr: return the next line address in the command buffer */
330static int
331next_addr(void)
332{
char *hd;
int addr = current_addr;
int n;
int first = 1;
int c;

SKIP_BLANKS()do { while (isspace((unsigned char)*ibufp) && *ibufp !=
 '\n') ibufp++; } while (0);
for (hd = ibufp;; first = 0)
switch ((c = (unsigned char)*ibufp)) {
case '+':
case '\t':
case ' ':
case '-':
case '^':
	ibufp++;
	SKIP_BLANKS()do { while (isspace((unsigned char)*ibufp) && *ibufp !=
 '\n') ibufp++; } while (0);
	if (isdigit((unsigned char)*ibufp)) {
		STRTOI(n, ibufp){ long l = strtol(ibufp, &ibufp, 10); if (l <= (-2147483647
 -1) || l >= 2147483647) { seterrmsg("number out of range"
); n = 0; return (-2); } else n = (int)l; };
		addr += (c == '-' || c == '^') ? -n : n;
	} else if (!isspace(c))
		addr += (c == '-' || c == '^') ? -1 : 1;
	break;
case '0': case '1': case '2':
case '3': case '4': case '5':
case '6': case '7': case '8': case '9':
	MUST_BE_FIRST()do { if (!first) { seterrmsg("invalid address"); return (-2);
 } } while (0);
	STRTOI(addr, ibufp){ long l = strtol(ibufp, &ibufp, 10); if (l <= (-2147483647
 -1) || l >= 2147483647) { seterrmsg("number out of range"
); addr = 0; return (-2); } else addr = (int)l; };
	break;
case '.':
case '$':
	MUST_BE_FIRST()do { if (!first) { seterrmsg("invalid address"); return (-2);
 } } while (0);
	ibufp++;
	addr = (c == '.') ? current_addr : addr_last;
	break;
case '/':
case '?':
	MUST_BE_FIRST()do { if (!first) { seterrmsg("invalid address"); return (-2);
 } } while (0);
	if ((addr = get_matching_node_addr(
	    get_compiled_pattern(), c == '/')) < 0)
		return ERR(-2);
	else if (c == *ibufp)
		ibufp++;
	break;
case '\'':
	MUST_BE_FIRST()do { if (!first) { seterrmsg("invalid address"); return (-2);
 } } while (0);
	ibufp++;
	if ((addr = get_marked_node_addr((unsigned char)*ibufp++)) < 0)
		return ERR(-2);
	break;
case '%':
case ',':
case ';':
	if (first) {
		ibufp++;
		addr_cnt++;
		second_addr = (c == ';') ? current_addr : 1;
		if ((addr = next_addr()) < 0)
			addr = addr_last;
		break;
	}
	/* FALLTHROUGH */
default:
	if (ibufp == hd)
		return EOF(-1);
	else if (addr < 0 || addr_last < addr) {
		seterrmsg("invalid address");
		return ERR(-2);
	} else
		return addr;
}
/* NOTREACHED */
404}


407/* GET_THIRD_ADDR: get a legal address from the command buffer */
408#define GET_THIRD_ADDR(addr)do { int ol1, ol2; ol1 = first_addr; ol2 = second_addr; if (extract_addr_range
() < 0) return (-2); else if (addr_cnt == 0) { seterrmsg("destination expected"
); return (-2); } else if (second_addr < 0 || addr_last <
 second_addr) { seterrmsg("invalid address"); return (-2); } addr
 = second_addr; first_addr = ol1; second_addr = ol2; } while (
0) \
do { \
int ol1, ol2; \
\
ol1 = first_addr; \
ol2 = second_addr; \
if (extract_addr_range() < 0) \
	return ERR(-2); \
else if (addr_cnt == 0) { \
	seterrmsg("destination expected"); \
	return ERR(-2); \
} else if (second_addr < 0 || addr_last < second_addr) { \
	seterrmsg("invalid address"); \
	return ERR(-2); \
} \
addr = second_addr; \
first_addr = ol1; \
second_addr = ol2; \
} while (0)


429/* GET_COMMAND_SUFFIX: verify the command suffix in the command buffer */
430#define GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0) \
do { \
int done = 0; \
do { \
	switch (*ibufp) { \
	case 'p': \
		gflag |= GPR002; \
		ibufp++; \
		break; \
	case 'l': \
		gflag |= GLS004; \
		ibufp++; \
		break; \
	case 'n': \
		gflag |= GNP010; \
		ibufp++; \
		break; \
	default: \
		done++; \
	} \
} while (!done); \
if (*ibufp++ != '\n') { \
	seterrmsg("invalid command suffix"); \
	return ERR(-2); \
} \
} while (0)

457/* sflags */
458#define SGG001 001		/* complement previous global substitute suffix */
459#define SGP002 002		/* complement previous print suffix */
460#define SGR004 004		/* use last regex instead of last pat */
461#define SGF010 010		/* repeat last substitution */

463int patlock = 0;	/* if set, pattern not freed by get_compiled_pattern() */

465volatile sig_atomic_t rows = 22;	/* scroll length: ws_row - 2 */
466volatile sig_atomic_t cols = 72;	/* wrap column */

468/* exec_command: execute the next command in command buffer; return print
 request, if any */
470int
471exec_command(void)
472{
extern int u_current_addr;
extern int u_addr_last;

static regex_t *pat = NULL((void *)0);
static int sgflag = 0;
static int sgnum = 0;

regex_t *tpat;
char *fnp;
int gflag = 0;
int sflags = 0;
int addr = 0;
int n = 0;
int c;

SKIP_BLANKS()do { while (isspace((unsigned char)*ibufp) && *ibufp !=
 '\n') ibufp++; } while (0);
switch ((c = (unsigned char)*ibufp++)) {
case 'a':
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if (!isglobal) clear_undo_stack();
if (append_lines(second_addr) < 0)
	return ERR(-2);
break;
case 'c':
if (check_addr_range(current_addr, current_addr) < 0)
	return ERR(-2);
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if (!isglobal) clear_undo_stack();
if (delete_lines(first_addr, second_addr) < 0 ||
    append_lines(current_addr) < 0)
	return ERR(-2);
break;
case 'd':
if (check_addr_range(current_addr, current_addr) < 0)
	return ERR(-2);
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if (!isglobal) clear_undo_stack();
if (delete_lines(first_addr, second_addr) < 0)
	return ERR(-2);
else if ((addr = INC_MOD(current_addr, addr_last)((current_addr) + 1 > (addr_last) ? 0 : (current_addr) + 1
)) != 0)
	current_addr = addr;
break;
case 'e':
if (modified && !scripted)
	return EMOD(-3);
/* FALLTHROUGH */
case 'E':
if (addr_cnt > 0) {
	seterrmsg("unexpected address");
	return ERR(-2);
} else if (!isspace((unsigned char)*ibufp)) {
	seterrmsg("unexpected command suffix");
	return ERR(-2);
} else if ((fnp = get_filename(1)) == NULL((void *)0))
	return ERR(-2);
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if (delete_lines(1, addr_last) < 0)
	return ERR(-2);
clear_undo_stack();
if (close_sbuf() < 0)
	return ERR(-2);
else if (open_sbuf() < 0)
	return FATAL(-4);
if (read_file(fnp, 0) < 0)
	return ERR(-2);
clear_undo_stack();
modified = 0;
u_current_addr = u_addr_last = -1;
break;
case 'f':
if (addr_cnt > 0) {
	seterrmsg("unexpected address");
	return ERR(-2);
} else if (!isspace((unsigned char)*ibufp)) {
	seterrmsg("unexpected command suffix");
	return ERR(-2);
} else if ((fnp = get_filename(1)) == NULL((void *)0))
	return ERR(-2);
else if (*fnp == '!') {
	seterrmsg("invalid redirection");
	return ERR(-2);
}
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
puts(strip_escapes(fnp));
break;
case 'g':
case 'v':
case 'G':
case 'V':
if (isglobal) {
	seterrmsg("cannot nest global commands");
	return ERR(-2);
} else if (check_addr_range(1, addr_last) < 0)
	return ERR(-2);
else if (build_active_list(c == 'g' || c == 'G') < 0)
	return ERR(-2);
else if ((n = (c == 'G' || c == 'V')))
	GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
isglobal++;
if (exec_global(n, gflag) < 0)
	return ERR(-2);
break;
case 'h':
if (addr_cnt > 0) {
	seterrmsg("unexpected address");
	return ERR(-2);
}
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if (*errmsg) fprintf(stderr(&__sF[2]), "%s\n", errmsg);
break;
case 'H':
if (addr_cnt > 0) {
	seterrmsg("unexpected address");
	return ERR(-2);
}
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if ((garrulous = 1 - garrulous) && *errmsg)
	fprintf(stderr(&__sF[2]), "%s\n", errmsg);
break;
case 'i':
if (second_addr == 0) {
	second_addr = 1;
}
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if (!isglobal) clear_undo_stack();
if (append_lines(second_addr - 1) < 0)
	return ERR(-2);
break;
case 'j':
if (check_addr_range(current_addr, current_addr + 1) < 0)
	return ERR(-2);
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if (!isglobal) clear_undo_stack();
if (first_addr != second_addr &&
    join_lines(first_addr, second_addr) < 0)
	return ERR(-2);
break;
case 'k':
c = (unsigned char)*ibufp++;
if (second_addr == 0) {
	seterrmsg("invalid address");
	return ERR(-2);
}
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if (mark_line_node(get_addressed_line_node(second_addr), c) < 0)
	return ERR(-2);
break;
case 'l':
if (check_addr_range(current_addr, current_addr) < 0)
	return ERR(-2);
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if (display_lines(first_addr, second_addr, gflag | GLS004) < 0)
	return ERR(-2);
gflag = 0;
break;
case 'm':
if (check_addr_range(current_addr, current_addr) < 0)
	return ERR(-2);
GET_THIRD_ADDR(addr)do { int ol1, ol2; ol1 = first_addr; ol2 = second_addr; if (extract_addr_range
() < 0) return (-2); else if (addr_cnt == 0) { seterrmsg("destination expected"
); return (-2); } else if (second_addr < 0 || addr_last <
 second_addr) { seterrmsg("invalid address"); return (-2); } addr
 = second_addr; first_addr = ol1; second_addr = ol2; } while (
0);
if (first_addr <= addr && addr < second_addr) {
	seterrmsg("invalid destination");
	return ERR(-2);
}
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if (!isglobal) clear_undo_stack();
if (move_lines(addr) < 0)
	return ERR(-2);
break;
case 'n':
if (check_addr_range(current_addr, current_addr) < 0)
	return ERR(-2);
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if (display_lines(first_addr, second_addr, gflag | GNP010) < 0)
	return ERR(-2);
gflag = 0;
break;
case 'p':
if (check_addr_range(current_addr, current_addr) < 0)
	return ERR(-2);
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if (display_lines(first_addr, second_addr, gflag | GPR002) < 0)
	return ERR(-2);
gflag = 0;
break;
case 'P':
if (addr_cnt > 0) {
	seterrmsg("unexpected address");
	return ERR(-2);
}
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
prompt = prompt ? NULL((void *)0) : optarg ? optarg : dps;
break;
case 'q':
case 'Q':
if (addr_cnt > 0) {
	seterrmsg("unexpected address");
	return ERR(-2);
}
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
gflag =  (modified && !scripted && c == 'q') ? EMOD(-3) : EOF(-1);
break;
case 'r':
if (!isspace((unsigned char)*ibufp)) {
	seterrmsg("unexpected command suffix");
	return ERR(-2);
} else if (addr_cnt == 0)
	second_addr = addr_last;
if ((fnp = get_filename(0)) == NULL((void *)0))
	return ERR(-2);
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if (!isglobal) clear_undo_stack();
if ((addr = read_file(fnp, second_addr)) < 0)
	return ERR(-2);
else if (addr)
	modified = 1;
break;
case 's':
do {
	switch (*ibufp) {
	case '\n':
		sflags |=SGF010;
		break;
	case 'g':
		sflags |= SGG001;
		ibufp++;
		break;
	case 'p':
		sflags |= SGP002;
		ibufp++;
		break;
	case 'r':
		sflags |= SGR004;
		ibufp++;
		break;
	case '0': case '1': case '2': case '3': case '4':
	case '5': case '6': case '7': case '8': case '9':
		STRTOI(sgnum, ibufp){ long l = strtol(ibufp, &ibufp, 10); if (l <= (-2147483647
 -1) || l >= 2147483647) { seterrmsg("number out of range"
); sgnum = 0; return (-2); } else sgnum = (int)l; };
		sflags |= SGF010;
		sgflag &= ~GSG020;		/* override GSG */
		break;
	default:
		if (sflags) {
			seterrmsg("invalid command suffix");
			return ERR(-2);
		}
	}
} while (sflags && *ibufp != '\n');
if (sflags && !pat) {
	seterrmsg("no previous substitution");
	return ERR(-2);
} else if (sflags & SGG001)
	sgnum = 0;		/* override numeric arg */
if (*ibufp != '\n' && *(ibufp + 1) == '\n') {
	seterrmsg("invalid pattern delimiter");
	return ERR(-2);
}
tpat = pat;
SPL1()mutex++;
if ((!sflags || (sflags & SGR004)) &&
    (tpat = get_compiled_pattern()) == NULL((void *)0)) {
 	SPL0()do { if (--mutex == 0) { if (sighup) handle_hup(1); if (sigint
) handle_int(2); } } while (0);
	return ERR(-2);
} else if (tpat != pat) {
	if (pat) {
		regfree(pat);
		free(pat);
	}
	pat = tpat;
	patlock = 1;		/* reserve pattern */
}
SPL0()do { if (--mutex == 0) { if (sighup) handle_hup(1); if (sigint
) handle_int(2); } } while (0);
if (!sflags && extract_subst_tail(&sgflag, &sgnum) < 0)
	return ERR(-2);
else if (isglobal)
	sgflag |= GLB001;
else
	sgflag &= ~GLB001;
if (sflags & SGG001)
	sgflag ^= GSG020;
if (sflags & SGP002) {
	sgflag ^= GPR002;
	sgflag &= ~(GLS004 | GNP010);
}
do {
	switch (*ibufp) {
	case 'p':
		sgflag |= GPR002;
		ibufp++;
		break;
	case 'l':
		sgflag |= GLS004;
		ibufp++;
		break;
	case 'n':
		sgflag |= GNP010;
		ibufp++;
		break;
	default:
		n++;
	}
} while (!n);
if (check_addr_range(current_addr, current_addr) < 0)
	return ERR(-2);
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if (!isglobal) clear_undo_stack();
if (search_and_replace(pat, sgflag, sgnum) < 0)
	return ERR(-2);
break;
case 't':
if (check_addr_range(current_addr, current_addr) < 0)
	return ERR(-2);
GET_THIRD_ADDR(addr)do { int ol1, ol2; ol1 = first_addr; ol2 = second_addr; if (extract_addr_range
() < 0) return (-2); else if (addr_cnt == 0) { seterrmsg("destination expected"
); return (-2); } else if (second_addr < 0 || addr_last <
 second_addr) { seterrmsg("invalid address"); return (-2); } addr
 = second_addr; first_addr = ol1; second_addr = ol2; } while (
0);
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if (!isglobal) clear_undo_stack();
if (copy_lines(addr) < 0)
	return ERR(-2);
break;
case 'u':
if (addr_cnt > 0) {
	seterrmsg("unexpected address");
	return ERR(-2);
}
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if (pop_undo_stack() < 0)
	return ERR(-2);
break;
case 'w':
case 'W':
if ((n = *ibufp) == 'q' || n == 'Q') {
	gflag = EOF(-1);
	ibufp++;
}
if (!isspace((unsigned char)*ibufp)) {
	seterrmsg("unexpected command suffix");
	return ERR(-2);
} else if ((fnp = get_filename(0)) == NULL((void *)0))
	return ERR(-2);
if (addr_cnt == 0 && !addr_last)
	first_addr = second_addr = 0;
else if (check_addr_range(1, addr_last) < 0)
	return ERR(-2);
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if ((addr = write_file(fnp, (c == 'W') ? "a" : "w",
    first_addr, second_addr)) < 0)
	return ERR(-2);
else if (addr == addr_last && *fnp != '!')
	modified = 0;
else if (modified && !scripted && n == 'q')
	gflag = EMOD(-3);
break;
case 'x':
if (addr_cnt > 0) {
	seterrmsg("unexpected address");
	return ERR(-2);
}
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
seterrmsg("crypt unavailable");
return ERR(-2);
case 'z':
first_addr = 1;
if (check_addr_range(first_addr, current_addr + 1) < 0)
	return ERR(-2);
else if ('0' < *ibufp && *ibufp <= '9')
	STRTOI(rows, ibufp){ long l = strtol(ibufp, &ibufp, 10); if (l <= (-2147483647
 -1) || l >= 2147483647) { seterrmsg("number out of range"
); rows = 0; return (-2); } else rows = (int)l; };
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if (display_lines(second_addr, min(addr_last,((addr_last) < (second_addr + rows) ? (addr_last) : (second_addr
 + rows))
    second_addr + rows)((addr_last) < (second_addr + rows) ? (addr_last) : (second_addr
 + rows)), gflag) < 0)
	return ERR(-2);
gflag = 0;
break;
case '=':
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
printf("%d\n", addr_cnt ? second_addr : addr_last);
break;
case '!':
if (addr_cnt > 0) {
	seterrmsg("unexpected address");
	return ERR(-2);
} else if ((sflags = get_shell_command()) < 0)
	return ERR(-2);
GET_COMMAND_SUFFIX()do { int done = 0; do { switch (*ibufp) { case 'p': gflag |= 002
; ibufp++; break; case 'l': gflag |= 004; ibufp++; break; case
 'n': gflag |= 010; ibufp++; break; default: done++; } } while
 (!done); if (*ibufp++ != '\n') { seterrmsg("invalid command suffix"
); return (-2); } } while (0);
if (sflags) printf("%s\n", shcmd + 1);
system(shcmd + 1);
if (!scripted) printf("!\n");
break;
case '\n':
first_addr = 1;
if (check_addr_range(first_addr, current_addr + 1) < 0
 || display_lines(second_addr, second_addr, 0) < 0)
	return ERR(-2);
break;
default:
seterrmsg("unknown command");
return ERR(-2);
}
return gflag;
869}


872/* check_addr_range: return status of address range check */
873static int
874check_addr_range(int n, int m)
875{
if (addr_cnt == 0) {
first_addr = n;
second_addr = m;
}
if (first_addr > second_addr || 1 > first_addr ||
   second_addr > addr_last) {
seterrmsg("invalid address");
return ERR(-2);
}
return 0;
886}


889/* get_matching_node_addr: return the address of the next line matching a
 pattern in a given direction.  wrap around begin/end of editor buffer if
 necessary */
892static int
893get_matching_node_addr(regex_t *pat, int dir)
894{
char *s;
int n = current_addr;
line_t *lp;

if (!pat) return ERR(-2);
do {
if ((n = dir ? INC_MOD(n, addr_last)((n) + 1 > (addr_last) ? 0 : (n) + 1) : DEC_MOD(n, addr_last)((n) - 1 < 0 ? (addr_last) : (n) - 1))) {
	lp = get_addressed_line_node(n);
	if ((s = get_sbuf_line(lp)) == NULL((void *)0))
		return ERR(-2);
	if (isbinary)
		NUL_TO_NEWLINE(s, lp->len)translit_text(s, lp->len, '\0', '\n');
	if (!regexec(pat, s, 0, NULL((void *)0), 0))
		return n;
}
} while (n != current_addr);
seterrmsg("no match");
return  ERR(-2);
913}


916/* get_filename: return pointer to copy of filename in the command buffer */
917static char *
918get_filename(int save)
919{
static char filename[PATH_MAX1024];
char *p;
int n;

if (*ibufp != '\n') {
SKIP_BLANKS()do { while (isspace((unsigned char)*ibufp) && *ibufp !=
 '\n') ibufp++; } while (0);
if (*ibufp == '\n') {
	seterrmsg("invalid filename");
	return NULL((void *)0);
} else if ((ibufp = get_extended_line(&n, 1)) == NULL((void *)0))
	return NULL((void *)0);
else if (*ibufp == '!') {
	ibufp++;
	if ((n = get_shell_command()) < 0)
		return NULL((void *)0);
	if (n) printf("%s\n", shcmd + 1);
	return shcmd;
} else if (n >= PATH_MAX1024 - 1) {
	seterrmsg("filename too long");
	return NULL((void *)0);
}
} else {
if (*old_filename == '\0') {
	seterrmsg("no current filename");
	return  NULL((void *)0);
}
return old_filename;
}

p = save ? old_filename : *old_filename ? filename : old_filename;
for (n = 0; *ibufp != '\n';)
p[n++] = *ibufp++;
p[n] = '\0';
return p;
954}


957/* get_shell_command: read a shell command from stdin; return substitution
 status */
959static int
960get_shell_command(void)
961{
static char *buf = NULL((void *)0);
1
'buf' initialized to a null pointer value→
static int n = 0;

char *s;			/* substitution char pointer */
int i = 0;
int j = 0;

if ((s = ibufp = get_extended_line(&j, 1)) == NULL((void *)0))
2
←
Assuming the condition is false→
3
←
Taking false branch→
return ERR(-2);
REALLOC(buf, n, j + 1, ERR)if ((j + 1) > (n)) { int ti = (n); char *ts; mutex++; if (
(ts = realloc((buf), ti += (((j + 1)) > (512) ? ((j + 1)) :
 (512)))) == ((void *)0)) { perror(((void *)0)); seterrmsg("out of memory"
); do { if (--mutex == 0) { if (sighup) handle_hup(1); if (sigint
) handle_int(2); } } while (0); return (-2); } (n) = ti; (buf
) = ts; do { if (--mutex == 0) { if (sighup) handle_hup(1); if
 (sigint) handle_int(2); } } while (0); };
4
←
Assuming the condition is false→
5
←
Taking false branch→
buf[i++] = '!';			/* prefix command w/ bang */
6
←
Array access (from variable 'buf') results in a null pointer dereference
while (*ibufp != '\n')
switch (*ibufp) {
default:
	REALLOC(buf, n, i + 2, ERR)if ((i + 2) > (n)) { int ti = (n); char *ts; mutex++; if (
(ts = realloc((buf), ti += (((i + 2)) > (512) ? ((i + 2)) :
 (512)))) == ((void *)0)) { perror(((void *)0)); seterrmsg("out of memory"
); do { if (--mutex == 0) { if (sighup) handle_hup(1); if (sigint
) handle_int(2); } } while (0); return (-2); } (n) = ti; (buf
) = ts; do { if (--mutex == 0) { if (sighup) handle_hup(1); if
 (sigint) handle_int(2); } } while (0); };
	buf[i++] = *ibufp;
	if (*ibufp++ == '\\')
		buf[i++] = *ibufp++;
	break;
case '!':
	if (s != ibufp) {
		REALLOC(buf, n, i + 1, ERR)if ((i + 1) > (n)) { int ti = (n); char *ts; mutex++; if (
(ts = realloc((buf), ti += (((i + 1)) > (512) ? ((i + 1)) :
 (512)))) == ((void *)0)) { perror(((void *)0)); seterrmsg("out of memory"
); do { if (--mutex == 0) { if (sighup) handle_hup(1); if (sigint
) handle_int(2); } } while (0); return (-2); } (n) = ti; (buf
) = ts; do { if (--mutex == 0) { if (sighup) handle_hup(1); if
 (sigint) handle_int(2); } } while (0); };
		buf[i++] = *ibufp++;
	}
	else if (shcmd == NULL((void *)0))
	{
		seterrmsg("no previous command");
		return ERR(-2);
	} else {
		REALLOC(buf, n, i + shcmdi, ERR)if ((i + shcmdi) > (n)) { int ti = (n); char *ts; mutex++;
 if ((ts = realloc((buf), ti += (((i + shcmdi)) > (512) ? (
(i + shcmdi)) : (512)))) == ((void *)0)) { perror(((void *)0)
); seterrmsg("out of memory"); do { if (--mutex == 0) { if (sighup
) handle_hup(1); if (sigint) handle_int(2); } } while (0); return
 (-2); } (n) = ti; (buf) = ts; do { if (--mutex == 0) { if (sighup
) handle_hup(1); if (sigint) handle_int(2); } } while (0); };
		for (s = shcmd + 1; s < shcmd + shcmdi;)
			buf[i++] = *s++;
		s = ibufp++;
	}
	break;
case '%':
	if (*old_filename  == '\0') {
		seterrmsg("no current filename");
		return ERR(-2);
	}
	j = strlen(s = strip_escapes(old_filename));
	REALLOC(buf, n, i + j, ERR)if ((i + j) > (n)) { int ti = (n); char *ts; mutex++; if (
(ts = realloc((buf), ti += (((i + j)) > (512) ? ((i + j)) :
 (512)))) == ((void *)0)) { perror(((void *)0)); seterrmsg("out of memory"
); do { if (--mutex == 0) { if (sighup) handle_hup(1); if (sigint
) handle_int(2); } } while (0); return (-2); } (n) = ti; (buf
) = ts; do { if (--mutex == 0) { if (sighup) handle_hup(1); if
 (sigint) handle_int(2); } } while (0); };
	while (j--)
		buf[i++] = *s++;
	s = ibufp++;
	break;
}
if (i == 1) {
seterrmsg("no command");
return ERR(-2);
}
REALLOC(shcmd, shcmdsz, i + 1, ERR)if ((i + 1) > (shcmdsz)) { int ti = (shcmdsz); char *ts; mutex
++; if ((ts = realloc((shcmd), ti += (((i + 1)) > (512) ? (
(i + 1)) : (512)))) == ((void *)0)) { perror(((void *)0)); seterrmsg
("out of memory"); do { if (--mutex == 0) { if (sighup) handle_hup
(1); if (sigint) handle_int(2); } } while (0); return (-2); }
 (shcmdsz) = ti; (shcmd) = ts; do { if (--mutex == 0) { if (sighup
) handle_hup(1); if (sigint) handle_int(2); } } while (0); };
memcpy(shcmd, buf, i);
shcmd[shcmdi = i] = '\0';
return *s == '!' || *s == '%';
1017}


1020/* append_lines: insert text from stdin to after line n; stop when either a
 single period is read or EOF; return status */
1022static int
1023append_lines(int n)
1024{
int l;
char *lp = ibuf;
char *eot;
undo_t *up = NULL((void *)0);

for (current_addr = n;;) {
if (!isglobal) {
	if ((l = get_tty_line()) < 0)
		return ERR(-2);
	else if (l == 0 || ibuf[l - 1] != '\n') {
		clearerr(stdin)(!__isthreaded ? ((void)(((&__sF[0]))->_flags &= ~
(0x0040|0x0020))) : (clearerr)((&__sF[0])));
		return  l ? EOF(-1) : 0;
	}
	lp = ibuf;
} else if (*(lp = ibufp) == '\0')
	return 0;
else {
	while (*ibufp++ != '\n')
		;
	l = ibufp - lp;
}
if (l == 2 && lp[0] == '.' && lp[1] == '\n') {
	return 0;
}
eot = lp + l;
SPL1()mutex++;
do {
	if ((lp = put_sbuf_line(lp)) == NULL((void *)0)) {
		SPL0()do { if (--mutex == 0) { if (sighup) handle_hup(1); if (sigint
) handle_int(2); } } while (0);
		return ERR(-2);
	} else if (up)
		up->t = get_addressed_line_node(current_addr);
	else if ((up = push_undo_stack(UADD0, current_addr,
	    current_addr)) == NULL((void *)0)) {
		SPL0()do { if (--mutex == 0) { if (sighup) handle_hup(1); if (sigint
) handle_int(2); } } while (0);
		return ERR(-2);
	}
} while (lp != eot);
modified = 1;
SPL0()do { if (--mutex == 0) { if (sighup) handle_hup(1); if (sigint
) handle_int(2); } } while (0);
}
/* NOTREACHED */
1067}


1070/* join_lines: replace a range of lines with the joined text of those lines */
1071static int
1072join_lines(int from, int to)
1073{
static char *buf = NULL((void *)0);
static int n;

char *s;
int size = 0;
line_t *bp, *ep;

ep = get_addressed_line_node(INC_MOD(to, addr_last)((to) + 1 > (addr_last) ? 0 : (to) + 1));
bp = get_addressed_line_node(from);
for (; bp != ep; bp = bp->q_forw) {
if ((s = get_sbuf_line(bp)) == NULL((void *)0))
	return ERR(-2);
REALLOC(buf, n, size + bp->len, ERR)if ((size + bp->len) > (n)) { int ti = (n); char *ts; mutex
++; if ((ts = realloc((buf), ti += (((size + bp->len)) >
 (512) ? ((size + bp->len)) : (512)))) == ((void *)0)) { perror
(((void *)0)); seterrmsg("out of memory"); do { if (--mutex ==
 0) { if (sighup) handle_hup(1); if (sigint) handle_int(2); }
 } while (0); return (-2); } (n) = ti; (buf) = ts; do { if (--
mutex == 0) { if (sighup) handle_hup(1); if (sigint) handle_int
(2); } } while (0); };
memcpy(buf + size, s, bp->len);
size += bp->len;
}
REALLOC(buf, n, size + 2, ERR)if ((size + 2) > (n)) { int ti = (n); char *ts; mutex++; if
 ((ts = realloc((buf), ti += (((size + 2)) > (512) ? ((size
 + 2)) : (512)))) == ((void *)0)) { perror(((void *)0)); seterrmsg
("out of memory"); do { if (--mutex == 0) { if (sighup) handle_hup
(1); if (sigint) handle_int(2); } } while (0); return (-2); }
 (n) = ti; (buf) = ts; do { if (--mutex == 0) { if (sighup) handle_hup
(1); if (sigint) handle_int(2); } } while (0); };
memcpy(buf + size, "\n", 2);
if (delete_lines(from, to) < 0)
return ERR(-2);
current_addr = from - 1;
SPL1()mutex++;
if (put_sbuf_line(buf) == NULL((void *)0) ||
   push_undo_stack(UADD0, current_addr, current_addr) == NULL((void *)0)) {
SPL0()do { if (--mutex == 0) { if (sighup) handle_hup(1); if (sigint
) handle_int(2); } } while (0);
return ERR(-2);
}
modified = 1;
SPL0()do { if (--mutex == 0) { if (sighup) handle_hup(1); if (sigint
) handle_int(2); } } while (0);
return 0;
1104}


1107/* move_lines: move a range of lines */
1108static int
1109move_lines(int addr)
1110{
line_t *b1, *a1, *b2, *a2;
int n = INC_MOD(second_addr, addr_last)((second_addr) + 1 > (addr_last) ? 0 : (second_addr) + 1);
int p = first_addr - 1;
int done = (addr == first_addr - 1 || addr == second_addr);

SPL1()mutex++;
if (done) {
a2 = get_addressed_line_node(n);
b2 = get_addressed_line_node(p);
current_addr = second_addr;
} else if (push_undo_stack(UMOV2, p, n) == NULL((void *)0) ||
   push_undo_stack(UMOV2, addr, INC_MOD(addr, addr_last)((addr) + 1 > (addr_last) ? 0 : (addr) + 1)) == NULL((void *)0)) {
SPL0()do { if (--mutex == 0) { if (sighup) handle_hup(1); if (sigint
) handle_int(2); } } while (0);
return ERR(-2);
} else {
a1 = get_addressed_line_node(n);
if (addr < first_addr) {
	b1 = get_addressed_line_node(p);
	b2 = get_addressed_line_node(addr);
			/* this get_addressed_line_node last! */
} else {
	b2 = get_addressed_line_node(addr);
	b1 = get_addressed_line_node(p);
			/* this get_addressed_line_node last! */
}
a2 = b2->q_forw;
REQUE(b2, b1->q_forw)(b2)->q_forw = (b1->q_forw), (b1->q_forw)->q_back
 = (b2);
REQUE(a1->q_back, a2)(a1->q_back)->q_forw = (a2), (a2)->q_back = (a1->
q_back);
REQUE(b1, a1)(b1)->q_forw = (a1), (a1)->q_back = (b1);
current_addr = addr + ((addr < first_addr) ?
    second_addr - first_addr + 1 : 0);
}
if (isglobal)
unset_active_nodes(b2->q_forw, a2);
modified = 1;
SPL0()do { if (--mutex == 0) { if (sighup) handle_hup(1); if (sigint
) handle_int(2); } } while (0);
return 0;
1148}


1151/* copy_lines: copy a range of lines; return status */
1152static int
1153copy_lines(int addr)
1154{
line_t *lp, *np = get_addressed_line_node(first_addr);
undo_t *up = NULL((void *)0);
int n = second_addr - first_addr + 1;
int m = 0;

current_addr = addr;
if (first_addr <= addr && addr < second_addr) {
n =  addr - first_addr + 1;
m = second_addr - addr;
}
for (; n > 0; n=m, m=0, np = get_addressed_line_node(current_addr + 1))
for (; n-- > 0; np = np->q_forw) {
	SPL1()mutex++;
	if ((lp = dup_line_node(np)) == NULL((void *)0)) {
		SPL0()do { if (--mutex == 0) { if (sighup) handle_hup(1); if (sigint
) handle_int(2); } } while (0);
		return ERR(-2);
	}
	add_line_node(lp);
	if (up)
		up->t = lp;
	else if ((up = push_undo_stack(UADD0, current_addr,
	    current_addr)) == NULL((void *)0)) {
		SPL0()do { if (--mutex == 0) { if (sighup) handle_hup(1); if (sigint
) handle_int(2); } } while (0);
		return ERR(-2);
	}
	modified = 1;
	SPL0()do { if (--mutex == 0) { if (sighup) handle_hup(1); if (sigint
) handle_int(2); } } while (0);
}
return 0;
1184}


1187/* delete_lines: delete a range of lines */
1188int
1189delete_lines(int from, int to)
1190{
line_t *n, *p;

SPL1()mutex++;
if (push_undo_stack(UDEL1, from, to) == NULL((void *)0)) {
SPL0()do { if (--mutex == 0) { if (sighup) handle_hup(1); if (sigint
) handle_int(2); } } while (0);
return ERR(-2);
}
n = get_addressed_line_node(INC_MOD(to, addr_last)((to) + 1 > (addr_last) ? 0 : (to) + 1));
p = get_addressed_line_node(from - 1);
			/* this get_addressed_line_node last! */
if (isglobal)
unset_active_nodes(p->q_forw, n);
REQUE(p, n)(p)->q_forw = (n), (n)->q_back = (p);
addr_last -= to - from + 1;
current_addr = from - 1;
modified = 1;
SPL0()do { if (--mutex == 0) { if (sighup) handle_hup(1); if (sigint
) handle_int(2); } } while (0);
return 0;
1209}


1212/* display_lines: print a range of lines to stdout */
1213int
1214display_lines(int from, int to, int gflag)
1215{
line_t *bp;
line_t *ep;
char *s;

if (!from) {
seterrmsg("invalid address");
return ERR(-2);
}
ep = get_addressed_line_node(INC_MOD(to, addr_last)((to) + 1 > (addr_last) ? 0 : (to) + 1));
bp = get_addressed_line_node(from);
for (; bp != ep; bp = bp->q_forw) {
if ((s = get_sbuf_line(bp)) == NULL((void *)0))
	return ERR(-2);
if (put_tty_line(s, bp->len, current_addr = from++, gflag) < 0)
	return ERR(-2);
}
return 0;
1233}


1236#define MAXMARK26 26			/* max number of marks */

1238static line_t *mark[MAXMARK26];		/* line markers */
1239static int markno;			/* line marker count */

1241/* mark_line_node: set a line node mark */
1242static int
1243mark_line_node(line_t *lp, int n)
1244{
if (!islower(n)) {
seterrmsg("invalid mark character");
return ERR(-2);
} else if (mark[n - 'a'] == NULL((void *)0))
markno++;
mark[n - 'a'] = lp;
return 0;
1252}


1255/* get_marked_node_addr: return address of a marked line */
1256static int
1257get_marked_node_addr(int n)
1258{
if (!islower(n)) {
seterrmsg("invalid mark character");
return ERR(-2);
}
return get_line_node_addr(mark[n - 'a']);
1264}


1267/* unmark_line_node: clear line node mark */
1268void
1269unmark_line_node(line_t *lp)
1270{
int i;

for (i = 0; markno && i < MAXMARK26; i++)
if (mark[i] == lp) {
	mark[i] = NULL((void *)0);
	markno--;
}
1278}


1281/* dup_line_node: return a pointer to a copy of a line node */
1282static line_t *
1283dup_line_node(line_t *lp)
1284{
line_t *np;

if ((np = malloc(sizeof(line_t))) == NULL((void *)0)) {
perror(NULL((void *)0));
seterrmsg("out of memory");
return NULL((void *)0);
}
np->seek = lp->seek;
np->len = lp->len;
return np;
1295}


1298/* has_trailing_escape:  return the parity of escapes preceding a character
 in a string */
1300int
1301has_trailing_escape(char *s, char *t)
1302{
  return (s == t || *(t - 1) != '\\') ? 0 : !has_trailing_escape(s, t - 1);
1304}


1307/* strip_escapes: return copy of escaped string of at most length PATH_MAX */
1308char *
1309strip_escapes(char *s)
1310{
static char *file = NULL((void *)0);
static int filesz = 0;

int i = 0;

REALLOC(file, filesz, PATH_MAX, NULL)if ((1024) > (filesz)) { int ti = (filesz); char *ts; mutex
++; if ((ts = realloc((file), ti += (((1024)) > (512) ? ((
1024)) : (512)))) == ((void *)0)) { perror(((void *)0)); seterrmsg
("out of memory"); do { if (--mutex == 0) { if (sighup) handle_hup
(1); if (sigint) handle_int(2); } } while (0); return ((void *
)0); } (filesz) = ti; (file) = ts; do { if (--mutex == 0) { if
 (sighup) handle_hup(1); if (sigint) handle_int(2); } } while
 (0); };
/* assert: no trailing escape */
while ((file[i++] = (*s == '\\') ? *++s : *s) != '\0' &&
      i < PATH_MAX1024-1)
s++;
file[PATH_MAX1024-1] = '\0';
return file;
1323}


1326void
1327signal_hup(int signo)
1328{
int save_errno = errno(*__errno());

if (mutex)
sighup = 1;
else
handle_hup(signo);
errno(*__errno()) = save_errno;
1336}


1339void
1340signal_int(int signo)
1341{
int save_errno = errno(*__errno());

if (mutex)
sigint = 1;
else
handle_int(signo);
errno(*__errno()) = save_errno;
1349}


1352void
1353handle_hup(int signo)
1354{
char hup[PATH_MAX1024];

if (!sigactive)
quit(1);		/* XXX signal race */
sighup = 0;
/* XXX signal race */
if (addr_last && write_file("ed.hup", "w", 1, addr_last) < 0 &&
   home != NULL((void *)0) && home[0] == '/') {
if (strlcpy(hup, home, sizeof(hup)) < sizeof(hup) &&
    strlcat(hup, "/ed.hup", sizeof(hup)) < sizeof(hup))
	write_file(hup, "w", 1, addr_last);
}
_exit(2);
1368}


1371void
1372handle_int(int signo)
1373{
if (!sigactive)
_exit(1);
sigint = 0;
siglongjmp(env, -1);
1378}


1381void
1382handle_winch(int signo)
1383{
int save_errno = errno(*__errno());
struct winsize ws;		/* window size structure */

if (ioctl(STDIN_FILENO0, TIOCGWINSZ((unsigned long)0x40000000 | ((sizeof(struct winsize) & 0x1fff
) << 16) | ((('t')) << 8) | ((104))), &ws) == 0) {
if (ws.ws_row > 2)
	rows = ws.ws_row - 2;
if (ws.ws_col > 8)
	cols = ws.ws_col - 8;
}
errno(*__errno()) = save_errno;
1394}