Attachment #172616 for bug #195929

Lines 6-12 Link Here

(-)Makefile (-1 / +1 lines)
6	PROG= sed	6	PROG= sed
7	SRCS= compile.c main.c misc.c process.c	7	SRCS= compile.c main.c misc.c process.c
8		8
9	WARNS?= 2	9	WARNS?= 5
10		10
11	.if ${MK_TESTS} != "no"	11	.if ${MK_TESTS} != "no"
12	SUBDIR+= tests	12	SUBDIR+= tests




	int	lh_ref;
} *labels[LHSZ];

static const char	 *compile_addr(const char *, struct s_addr *);
static       char	 *compile_ccl(const char **, char *);
static const char	 *compile_delimited(const char *, char *, int);
static const char	 *compile_flags(const char *, struct s_subst *);
static const regex_t	 *compile_re(const char *, int);
static const char	 *compile_subst(const char *, struct s_subst *);
static       char	 *compile_text(size_t *);
static const char	 *compile_tr(const char *, struct s_tr **);
static struct s_command
		**compile_stream(struct s_command **);
static char	 *duptoeol(const char *, const char *, size_t *);
static void	  enterlabel(struct s_command *);
static struct s_command
		 *findlabel(const char *);
static void	  fixuplabel(struct s_command *, const struct s_command *);
static void	  uselabel(void);

/*

		err(1, "malloc");
}

#define EATSPACE() do {						\
	while (*p && isspace((unsigned char)*p))		\
		p++;						\
			p++;						\
	} while (0)

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

static struct s_command **
compile_stream(struct s_command **link)
{
	const char *p;
	static char lbuf[_POSIX2_LINE_MAX + 1];	/* To save stack */
	struct s_command *cmd, *cmd2, *stack;
	struct s_format *fp;
	char re[_POSIX2_LINE_MAX + 1];
	int naddr;				/* Number of addresses */

	stack = NULL;
	for (;;) {
		if ((p = cu_fgets(NULL)) == NULL) {
			if (stack != NULL)
				errx(1, "%lu: %s: unexpected EOF (pending }'s)",
							linenum, fname);
			return (link);
		}

semicolon:	EATSPACEN();
		switch (*p) {
		case '#': case '\0': case '\n':
			continue;	/* to next command-unit */
		case ';':
			p++;
			goto semicolon;
			}
		}

		if ((*link = cmd = malloc(sizeof(struct s_command))) == NULL)
			err(1, "malloc");
		link = &cmd->next;

			cmd->a1 = cmd->a2 = 0;

nonsel:		/* Now parse the command */
		if (*p == '\0' || *p == '\n')
			errx(1, "%lu: %s: command expected", linenum, fname);
		cmd->code = *p;
		for (fp = cmd_fmts; fp->code; fp++)

			if (fp->code == *p)
				break;
		if (!fp->code)
			errx(1, "%lu: %s: invalid command code %c (%s)", linenum, fname, *p, p);
		if (naddr > fp->naddr)
			errx(1,
				"%lu: %s: command %c expects up to %d address(es), found %d",

			goto nonsel;
		case GROUP:			/* { */
			p++;
			EATSPACEN();
			cmd->next = stack;
			stack = cmd;
			link = &cmd->u.c;
			if (*p != '\0' && *p != '\n')
				goto semicolon;
			break;
		case ENDGROUP:

			 * group is really just a noop.
			 */
			cmd->nonsel = 1;
			if (stack == NULL)
				errx(1, "%lu: %s: unexpected }", linenum, fname);
			cmd2 = stack;
			stack = cmd2->next;

			/*FALLTHROUGH*/
		case EMPTY:		/* d D g G h H l n N p P q x = \0 */
			p++;
			EATSPACEN();
			if (*p == ';') {
				p++;
				link = &cmd->next;
				goto semicolon;
			}
			if (*p != '\0' && *p != '\n')
				errx(1, "%lu: %s: extra characters at the end of %c command",
						linenum, fname, cmd->code);
			break;

				errx(1,
"%lu: %s: command %c expects \\ followed by text", linenum, fname, cmd->code);
			p++;
			EATSPACEN();
			if (*p != '\n')
				errx(1,
				"%lu: %s: extra characters (%c) after \\ at the end of %c command",
				linenum, fname, *p, cmd->code);
			cmd->t = compile_text(&cmd->tlen);
			break;
		case COMMENT:			/* \0 # */
			break;

			EATSPACE();
			if (*p == '\0')
				errx(1, "%lu: %s: filename expected", linenum, fname);
			cmd->t = duptoeol(p, "w command", &cmd->tlen);
			if (aflag)
				cmd->u.fd = -1;
			else if ((cmd->u.fd = open(cmd->t,
			    O_WRONLY|O_APPEND|O_CREAT|O_TRUNC,
			    DEFFILEMODE)) == -1)
				err(1, "%s", p);

			if (*p == '\0')
				errx(1, "%lu: %s: filename expected", linenum, fname);
			else
				cmd->t = duptoeol(p, "read command", &cmd->tlen);
			break;
		case BRANCH:			/* b t */
			p++;
			EATSPACEN();
			if (*p == '\0' || *p == '\n')
				cmd->t = NULL;
			else
				cmd->t = duptoeol(p, "branch", &cmd->tlen);
			break;
		case LABEL:			/* : */
			p++;
			EATSPACE();
			cmd->t = duptoeol(p, "label", &cmd->tlen);
			if (cmd->t[0] == '\0')
				errx(1, "%lu: %s: empty label", linenum, fname);
			enterlabel(cmd);
			break;
		case SUBST:			/* s */
			p++;
			if (*p == '\0' || *p == '\\' || *p == '\n')
				errx(1,
"%lu: %s: substitute pattern can not be delimited by newline or backslash",
					linenum, fname);

				errx(1,
				"%lu: %s: unterminated substitute pattern", linenum, fname);

			/* Compile RE with no case sensitivity temporarily */
			if (*re == '\0')
				cmd->u.s->re = NULL;
			else
				cmd->u.s->re = compile_re(re, 0);
			--p;
			p = compile_subst(p, cmd->u.s);
			p = compile_flags(p, cmd->u.s);

			if (*re != '\0')
			if (*re == '\0')
				cmd->u.s->re = NULL;
			else
				cmd->u.s->re = compile_re(re, cmd->u.s->icase);

			EATSPACE();

			if (*p == ';') {
				p++;
				link = &cmd->next;

 * in the case of a non-terminated string.  The character array d is filled
 * with the processed string.
 */
static const char *
compile_delimited(const char *p, char *d, int is_tr)
{
	char c;



/* compile_ccl: expand a POSIX character class */
static char *
compile_ccl(const char **sp, char *t)
{
	int c, d;
	const char *s = *sp;

	*t++ = *s++;
	if (*s == '^')

 * regular expression.
 * Cflags are passed to regcomp.
 */
static const regex_t *
compile_re(const char *re, int case_insensitive)
{
	regex_t *rep;
	int eval, flags;

 * point to a saved copy of it.  Nsub is the number of parenthesized regular
 * expressions.
 */
static const char *
compile_subst(const char *p, struct s_subst *s)
{
	static char lbuf[_POSIX2_LINE_MAX + 1];
	int asize, size;
	u_char ref;
	char c, *text, *op, *sp;
	int more = 0, sawesc = 0;

	c = *p++;			/* Terminator character */
	if (c == '\0')

	size = 0;
	do {
		op = sp = text + size;
		for (; *p != '\0' && *p != '\n'; p++) {
			if (*p == '\\' || sawesc) {
				/*
				 * If this is a continuation from the last

					 */
					sawesc = 1;
					p--;
					break;
				} else if (*p == '\n') {
					*sp++ = '\n';
					break;
				} else if (strchr("123456789", *p) != NULL) {
					*sp++ = '\\';
					ref = *p - '0';

					*sp++ = '\\';
			} else if (*p == c) {
				if (*++p == '\0' && more) {
					const char *nextp;

					nextp = cu_fgets(&more);
					if (nextp != NULL)
						p = nextp;
				}
				*sp++ = '\0';
				size += sp - op;

			if ((text = realloc(text, asize)) == NULL)
				err(1, "realloc");
		}
	} while ((p = cu_fgets(&more)));
	errx(1, "%lu: %s: unterminated substitute in regular expression",
			linenum, fname);
	/* NOTREACHED */

/*
 * Compile the flags of the s command
 */
static const char *
compile_flags(const char *p, struct s_subst *s)
{
	int gn;			/* True if we have seen g or n */
	unsigned long nval;
	char *q;

	s->n = 1;				/* Default */
	s->p = 0;

	s->wfd = -1;
	s->icase = 0;
	for (gn = 0;;) {
		EATSPACEN();			/* EXTENSION */
		switch (*p) {
		case 'g':
			if (gn)

"%lu: %s: more than one number or 'g' in substitute flags", linenum, fname);
			gn = 1;
			errno = 0;
			nval = strtol(p, &q, 10);
			if (errno == ERANGE || nval > INT_MAX)
				errx(1,
"%lu: %s: overflow in the 'N' substitute flag", linenum, fname);
			s->n = nval;
			p = q;
			continue;
		case 'w':
			p++;
#ifdef HISTORIC_PRACTICE

			}
#endif
			EATSPACE();
			s->wfile = duptoeol(p, "w flag", NULL);
			if (!aflag && (s->wfd = open(s->wfile,
			while (*p) {
				if (*p == '\n')
					break;
				if (q >= eq)
					err(1, "wfile too long");
				*q++ = *p++;
			}
			*q = '\0';
			if (q == wfile)
				errx(1, "%lu: %s: no wfile specified", linenum, fname);
			s->wfile = strdup(wfile);
			if (!aflag && (s->wfd = open(wfile,
			    O_WRONLY|O_APPEND|O_CREAT|O_TRUNC,
			    DEFFILEMODE)) == -1)
				err(1, "%s", s->wfile);
			return (p);
		default:
			errx(1, "%lu: %s: bad flag in substitute command: '%c' (%.10s)",
					linenum, fname, *p, p);
			break;
		}
		p++;

/*
 * Compile a translation set of strings into a lookup table.
 */
static const char *
compile_tr(const char *p, struct s_tr **py)
{
	struct s_tr *y;
	int i;

	mbstate_t mbs1, mbs2;

	if ((*py = y = malloc(sizeof(*y))) == NULL)
		err(1, "malloc");
	y->multis = NULL;
	y->nmultis = 0;


	op = old;
	oldlen = mbsrtowcs(NULL, &op, 0, NULL);
	if (oldlen == (size_t)-1)
		err(1, "mbsrtowcs");
	np = new;
	newlen = mbsrtowcs(NULL, &np, 0, NULL);
	if (newlen == (size_t)-1)
		err(1, "mbsrtowcs");
	if (newlen != oldlen)
		errx(1, "%lu: %s: transform strings are not the same length",
				linenum, fname);

				y->multis = realloc(y->multis,
				    (y->nmultis + 1) * sizeof(*y->multis));
				if (y->multis == NULL)
					err(1, "realloc");
				i = y->nmultis++;
				y->multis[i].fromlen = oclen;
				memcpy(y->multis[i].from, op, oclen);

 * Compile the text following an a or i command.
 */
static char *
compile_text(size_t *ptlen)
{
	int asize, esc_nl, size;
	char *text, *s;
	const char *p, *op;

	asize = 2 * _POSIX2_LINE_MAX + 1;
	if ((text = malloc(asize)) == NULL)
		err(1, "malloc");
	size = 0;
	while ((p = cu_fgets(NULL))) {
		op = s = text + size;
		EATSPACEN();
		EATSPACE();
		for (esc_nl = 0; *p != '\0'; p++) {
			if (*p == '\\' && p[1] != '\0' && *++p == '\n')
				esc_nl = 1;
			*s++ = *p;
			if (*p == '\n')
				break;
		}
		size += s - op;
		if (!esc_nl) {

		}
	}
	text[size] = '\0';
	if ((text = realloc(text, size + 1)) == NULL)
		err(1, "realloc");
	*ptlen = size;
	return (text);
}

/*

 * Get an address and return a pointer to the first character after
 * it.  Fill the structure pointed to according to the address.
 */
static const char *
compile_addr(const char *p, struct s_addr *a)
{
	char *end, re[_POSIX2_LINE_MAX + 1];
	int icase;

 *	Return a copy of all the characters up to \n or \0.
 */
static char *
duptoeol(const char *s, const char *ctype, size_t *ptlen)
{
	size_t len;
	int ws;
	char *p;
	const char *start;

	ws = 0;
	for (start = s; *s != '\0' && *s != '\n'; ++s)
		ws = isspace((unsigned char)*s);
	*s = '\0';
	if (ws)
		warnx("%lu: %s: whitespace after %s", linenum, fname, ctype);
	len = s - start;
	if ((p = malloc(len + 1)) == NULL)
		err(1, "malloc");
	memmove(p, start, len);
	p[len] = '\0';
	if (ptlen != NULL)
		*ptlen = len;
	return p;
}

/*

 * TODO: Remove } nodes
 */
static void
fixuplabel(struct s_command *cp, const struct s_command *end)
{

	for (; cp != end; cp = cp->next)

				break;
			}
			if ((cp->u.c = findlabel(cp->t)) == NULL)
				errx(1, "%lu: %s: %c: undefined label '%s'", linenum, fname, cp->code, cp->t);
			free(cp->t);
			break;
		case '{':

 * list cp.  L is excluded from the search.  Return NULL if not found.
 */
static struct s_command *
findlabel(const char *name)
{
	struct labhash *lh;
	const u_char *p;
	u_int h, c;

	for (h = 0, p = (const u_char *)name; (c = *p) != 0; p++)
		h = (h << 5) + h + c;
	for (lh = labels[h & LHMASK]; lh != NULL; lh = lh->lh_next) {
		if (lh->lh_hash == h && strcmp(name, lh->lh_cmd->t) == 0) {




	enum e_atype type;			/* Address type */
	union {
		u_long l;			/* Line number */
		const regex_t *r;		/* Regular expression */
	} u;
};


	int icase;				/* True if I flag */
	char *wfile;				/* NULL if no wfile */
	int wfd;				/* Cached file descriptor */
	const regex_t *re;			/* Regular expression */
	unsigned int maxbref;			/* Largest backreference. */
	u_long linenum;				/* Line number. */
	char *new;				/* Replacement text */

	struct s_addr *a1, *a2;			/* Start and end address */
	u_long startline;			/* Start line number or zero */
	char *t;				/* Text for : a c i r w */
	size_t tlen;
	union {
		struct s_command *c;		/* Command(s) for b t { */
		struct s_subst *s;		/* Substitute command */




extern FILE *infile, *outfile;
extern int rflags;	/* regex flags to use */

void	 cfclose(struct s_command *, const struct s_command *);
void	 compile(void);
void	 cspace(SPACE *, const char *, size_t, enum e_spflag);
const char *cu_fgets(int *);
int	 mf_fgets(SPACE *, enum e_spflag);
int	 lastline(void);
void	 process(void);
void	 resetstate(void);
char	*strregerror(int, const regex_t *);




struct s_compunit {
	struct s_compunit *next;
	enum e_cut {CU_FILE, CU_STRING} type;
	const char *s;			/* Pointer to string or fname */
};

/*

 * Linked list of files to be processed
 */
struct s_flist {
	const char *fname;
	struct s_flist *next;
};


static const char *inplace;	/* Inplace edit file extension. */
u_long linenum;

static void add_compunit(enum e_cut, const char *);
static void add_file(const char *);
static void usage(void);

int

main(int argc, char *argv[])
{
	int c, fflag;
	char *temp_arg;

	(void) setlocale(LC_ALL, "");


			break;
		case 'e':
			eflag = 1;
			add_compunit(CU_STRING, optarg);
				err(1, "malloc");
			strcpy(temp_arg, optarg);
			strcat(temp_arg, "\n");
			add_compunit(CU_STRING, temp_arg);
			break;
		case 'f':
			fflag = 1;

 * Like fgets, but go through the chain of compilation units chaining them
 * together.  Empty strings and files are ignored.
 */
const char *
cu_fgets(int *more)
{
	static enum {ST_EOF, ST_FILE, ST_STRING} state = ST_EOF;
	static FILE *f;		/* Current open file */
	static const char *s;	/* Current pointer inside string */
	static char string_ident[30], *lastresult;
	static size_t lastsize;
	char *p;
	const char *start;

again:
	switch (state) {

			goto again;
		}
	case ST_FILE:
		p = lastresult;
		if (getline(&p, &lastsize, f) != -1) {
			linenum++;
			if (linenum == 1 && p[0] == '#' && p[1] == 'n')
				nflag = 1;
			if (more != NULL)
				*more = !feof(f);
			return (lastresult = p);
		} else if (ferror(f))
			err(1, "%s", script->s);
		script = script->next;
		(void)fclose(f);
		state = ST_EOF;

	case ST_STRING:
		if (linenum == 0 && s[0] == '#' && s[1] == 'n')
			nflag = 1;
		else if (s[0] == '\0') {
			state = ST_EOF;
			script = script->next;
			goto again;
		}
		start = s;
		for (;;) {
			if (n-- <= 1) {
				*p = '\0';
				linenum++;
				if (more != NULL)
					*more = 1;
				return (buf);
			}
			switch (*s) {
			case '\0':
				state = ST_EOF;
				script = script->next;
				/* FALLTHROUGH */
					goto again;
				} else {
					script = script->next;
					*p = '\0';
					linenum++;
					if (more != NULL)
						*more = 0;
					return (buf);
				}
			case '\n':
				*p++ = '\n';
				*p = '\0';
				s++;
				linenum++;
				if (more != NULL)
					*more = 0;
				return (start);
			default:
				s++;
			}
		}
	}

				    sizeof(oldfname));
				len = strlcat(oldfname, inplace,
				    sizeof(oldfname));
				if ((size_t)len > sizeof(oldfname))
					errx(1, "%s: name too long", fname);
			}
			len = snprintf(tmpfname, sizeof(tmpfname),
			    "%s/.!%ld!%s", dirname(fname), (long)getpid(),
			    basename(fname));
			if ((size_t)len >= sizeof(tmpfname))
				errx(1, "%s: name too long", fname);
			unlink(tmpfname);
			if (outfile != NULL && outfile != stdout)

 * Add a compilation unit to the linked list
 */
static void
add_compunit(enum e_cut type, const char *s)
{
	struct s_compunit *cu;


 * Add a file to the linked list
 */
static void
add_file(const char *s)
{
	struct s_flist *fp;





 * the buffer).
 */
char *
strregerror(int errcode, const regex_t *preg)
{
	static char *oe;
	size_t s;

	if (oe != NULL)
		free(oe);
	s = regerror(errcode, preg, NULL, 0);
	if ((oe = realloc(oe, s)) == NULL)
		err(1, "realloc");
	(void)regerror(errcode, preg, oe, s);
	return (oe);
}




#define	hs		HS.space
#define	hsl		HS.len

static inline int	applies(struct s_command *);
static void		do_tr(const struct s_tr *);
static void		flush_appends(void);
static void		lputs(const char *, size_t);
static int		regexec_e(const regex_t *, const char *, int, int,
			    size_t, size_t);
static void		regsub(SPACE *, const char *, const char *);
static int		substitute(const struct s_command *);

struct s_appends *appends;	/* Array of pointers to strings to append. */
static int appendx;		/* Index into appends array. */

static int lastaddr;		/* Set by applies if last address of a range. */
static int sdone;		/* If any substitutes since last line input. */
				/* Iov structure for 'w' commands. */
static const regex_t *defpreg;
size_t maxnsub;
regmatch_t *match;


 *	and then swap them.
 */
static int
substitute(const struct s_command *cp)
{
	SPACE tspace;
	const regex_t *re;
	regoff_t slen;
	int lastempty, n;
	regoff_t le = 0;
	char *s;

	s = ps;

	    regexec_e(re, ps, REG_NOTBOL, 0, le, psl));

	/* Did not find the requested number of matches. */
	if (n > 0)
		return (0);

	/* Copy the trailing retained string. */

 *	Perform translation ('y' command) in the pattern space.
 */
static void
do_tr(const struct s_tr *y)
{
	SPACE tmp;
	char c, *p;

}

static void
lputs(const char *s, size_t len)
{
	static const char escapes[] = "\\\a\b\f\r\t\v";
	int c, col, width;

}

static int
regexec_e(const regex_t *preg, const char *string, int eflags, int nomatch,
	size_t start, size_t stop)
{
	int eval;

 * Based on a routine by Henry Spencer
 */
static void
regsub(SPACE *sp, const char *string, const char *src)
{
	int len, no;
	char c, *dst;

 * Close all cached opened files and report any errors
 */
void
cfclose(struct s_command *cp, const struct s_command *end)
{

	for (; cp != end; cp = cp->next)

Lines 6-12 Link Here

(-)tests/Makefile (-1 / +4 lines)
6	TAP_TESTS_SH+= multi_test	6	TAP_TESTS_SH+= multi_test
7	TEST_METADATA.multi_test+= required_files="/usr/share/dict/words"	7	TEST_METADATA.multi_test+= required_files="/usr/share/dict/words"
8	TAP_TESTS_SH+= inplace_race_test	8	TAP_TESTS_SH+= inplace_race_test
9		9	TAP_TESTS_SH= legacy_test
		10	TAP_TESTS_SH+= multi_test
		11	TEST_METADATA.multi_test+= required_files="/usr/share/dict/words"
		12	TAP_TESTS_SH+= inplace_race_test
10	FILESDIR= ${TESTSDIR}	13	FILESDIR= ${TESTSDIR}
11	FILES= hanoi.sed	14	FILES= hanoi.sed
12	FILES+= math.sed	15	FILES+= math.sed

Return to bug 195929

Lines 45-56 Link Here

(-)extern.h (-3 / +3 lines)
45	extern FILE infile, outfile;	45	extern FILE infile, outfile;
46	extern int rflags; /* regex flags to use */	46	extern int rflags; /* regex flags to use */
47		47
48	void cfclose(struct s_command , struct s_command );	48	void cfclose(struct s_command , const struct s_command );
49	void compile(void);	49	void compile(void);
50	void cspace(SPACE , const char , size_t, enum e_spflag);	50	void cspace(SPACE , const char , size_t, enum e_spflag);
51	char cu_fgets(char , int, int *);	51	const char cu_fgets(int );
52	int mf_fgets(SPACE *, enum e_spflag);	52	int mf_fgets(SPACE *, enum e_spflag);
53	int lastline(void);	53	int lastline(void);
54	void process(void);	54	void process(void);
55	void resetstate(void);	55	void resetstate(void);
56	char strregerror(int, regex_t );	56	char strregerror(int, const regex_t );

Lines 73-79 Link Here

(-)main.c (-45 / +31 lines)
73	struct s_compunit {	73	struct s_compunit {
74	struct s_compunit *next;	74	struct s_compunit *next;
75	enum e_cut {CU_FILE, CU_STRING} type;	75	enum e_cut {CU_FILE, CU_STRING} type;
76	char s; / Pointer to string or fname */	76	const char s; / Pointer to string or fname */
77	};	77	};
78		78
79	/*	79	/*
Lines 86-92 Link Here
86	* Linked list of files to be processed	86	* Linked list of files to be processed
87	*/	87	*/
88	struct s_flist {	88	struct s_flist {
89	char *fname;	89	const char *fname;
90	struct s_flist *next;	90	struct s_flist *next;
91	};	91	};
92		92
Lines 117-124 Link Here
117	static const char inplace; / Inplace edit file extension. */	117	static const char inplace; / Inplace edit file extension. */
118	u_long linenum;	118	u_long linenum;
119		119
120	static void add_compunit(enum e_cut, char *);	120	static void add_compunit(enum e_cut, const char *);
121	static void add_file(char *);	121	static void add_file(const char *);
122	static void usage(void);	122	static void usage(void);
123		123
124	int	124	int
Lines 125-131 Link Here
125	main(int argc, char *argv[])	125	main(int argc, char *argv[])
126	{	126	{
127	int c, fflag;	127	int c, fflag;
128	char *temp_arg;
129		128
130	(void) setlocale(LC_ALL, "");	129	(void) setlocale(LC_ALL, "");
131		130
Lines 147-157 Link Here
147	break;	146	break;
148	case 'e':	147	case 'e':
149	eflag = 1;	148	eflag = 1;
150	if ((temp_arg = malloc(strlen(optarg) + 2)) == NULL)	149	add_compunit(CU_STRING, optarg);
151	err(1, "malloc");
152	strcpy(temp_arg, optarg);
153	strcat(temp_arg, "\n");
154	add_compunit(CU_STRING, temp_arg);
155	break;	150	break;
156	case 'f':	151	case 'f':
157	fflag = 1;	152	fflag = 1;
Lines 214-227 Link Here
214	* Like fgets, but go through the chain of compilation units chaining them	209	* Like fgets, but go through the chain of compilation units chaining them
215	* together. Empty strings and files are ignored.	210	* together. Empty strings and files are ignored.
216	*/	211	*/
217	char *	212	const char *
218	cu_fgets(char buf, int n, int more)	213	cu_fgets(int *more)
219	{	214	{
220	static enum {ST_EOF, ST_FILE, ST_STRING} state = ST_EOF;	215	static enum {ST_EOF, ST_FILE, ST_STRING} state = ST_EOF;
221	static FILE f; / Current open file */	216	static FILE f; / Current open file */
222	static char s; / Current pointer inside string */	217	static const char s; / Current pointer inside string */
223	static char string_ident[30];	218	static char string_ident[30], *lastresult;
		219	static size_t lastsize;
224	char *p;	220	char *p;
		221	const char *start;
225		222
226	again:	223	again:
227	switch (state) {	224	switch (state) {
Lines 251-264 Link Here
251	goto again;	248	goto again;
252	}	249	}
253	case ST_FILE:	250	case ST_FILE:
254	if ((p = fgets(buf, n, f)) != NULL) {	251	p = lastresult;
		252	if (getline(&p, &lastsize, f) != -1) {
255	linenum++;	253	linenum++;
256	if (linenum == 1 && buf[0] == '#' && buf[1] == 'n')	254	if (linenum == 1 && p[0] == '#' && p[1] == 'n')
257	nflag = 1;	255	nflag = 1;
258	if (more != NULL)	256	if (more != NULL)
259	*more = !feof(f);	257	*more = !feof(f);
260	return (p);	258	return (lastresult = p);
261	}	259	} else if (ferror(f))
		260	err(1, "%s", script->s);
262	script = script->next;	261	script = script->next;
263	(void)fclose(f);	262	(void)fclose(f);
264	state = ST_EOF;	263	state = ST_EOF;
Lines 266-304 Link Here
266	case ST_STRING:	265	case ST_STRING:
267	if (linenum == 0 && s[0] == '#' && s[1] == 'n')	266	if (linenum == 0 && s[0] == '#' && s[1] == 'n')
268	nflag = 1;	267	nflag = 1;
269	p = buf;	268	else if (s[0] == '\0') {
		269	state = ST_EOF;
		270	script = script->next;
		271	goto again;
		272	}
		273	start = s;
270	for (;;) {	274	for (;;) {
271	if (n-- <= 1) {
272	*p = '\0';
273	linenum++;
274	if (more != NULL)
275	*more = 1;
276	return (buf);
277	}
278	switch (*s) {	275	switch (*s) {
279	case '\0':	276	case '\0':
280	state = ST_EOF;	277	state = ST_EOF;
281	if (s == script->s) {	278	script = script->next;
282	script = script->next;	279	/* FALLTHROUGH */
283	goto again;
284	} else {
285	script = script->next;
286	*p = '\0';
287	linenum++;
288	if (more != NULL)
289	*more = 0;
290	return (buf);
291	}
292	case '\n':	280	case '\n':
293	*p++ = '\n';
294	*p = '\0';
295	s++;	281	s++;
296	linenum++;	282	linenum++;
297	if (more != NULL)	283	if (more != NULL)
298	*more = 0;	284	*more = 0;
299	return (buf);	285	return (start);
300	default:	286	default:
301	p++ = s++;	287	s++;
302	}	288	}
303	}	289	}
304	}	290	}
Lines 400-412 Link Here
400	sizeof(oldfname));	386	sizeof(oldfname));
401	len = strlcat(oldfname, inplace,	387	len = strlcat(oldfname, inplace,
402	sizeof(oldfname));	388	sizeof(oldfname));
403	if (len > sizeof(oldfname))	389	if ((size_t)len > sizeof(oldfname))
404	errx(1, "%s: name too long", fname);	390	errx(1, "%s: name too long", fname);
405	}	391	}
406	len = snprintf(tmpfname, sizeof(tmpfname),	392	len = snprintf(tmpfname, sizeof(tmpfname),
407	"%s/.!%ld!%s", dirname(fname), (long)getpid(),	393	"%s/.!%ld!%s", dirname(fname), (long)getpid(),
408	basename(fname));	394	basename(fname));
409	if (len >= sizeof(tmpfname))	395	if ((size_t)len >= sizeof(tmpfname))
410	errx(1, "%s: name too long", fname);	396	errx(1, "%s: name too long", fname);
411	unlink(tmpfname);	397	unlink(tmpfname);
412	if (outfile != NULL && outfile != stdout)	398	if (outfile != NULL && outfile != stdout)
Lines 454-460 Link Here
454	* Add a compilation unit to the linked list	440	* Add a compilation unit to the linked list
455	*/	441	*/
456	static void	442	static void
457	add_compunit(enum e_cut type, char *s)	443	add_compunit(enum e_cut type, const char *s)
458	{	444	{
459	struct s_compunit *cu;	445	struct s_compunit *cu;
460		446
Lines 471-477 Link Here
471	* Add a file to the linked list	457	* Add a file to the linked list
472	*/	458	*/
473	static void	459	static void
474	add_file(char *s)	460	add_file(const char *s)
475	{	461	{
476	struct s_flist *fp;	462	struct s_flist *fp;
477		463

Lines 66-79 Link Here

(-)process.c (-18 / +18 lines)
66	#define hs HS.space	66	#define hs HS.space
67	#define hsl HS.len	67	#define hsl HS.len
68		68
69	static inline int applies(struct s_command *);	69	static inline int applies(struct s_command *);
70	static void do_tr(struct s_tr *);	70	static void do_tr(const struct s_tr *);
71	static void flush_appends(void);	71	static void flush_appends(void);
72	static void lputs(char *, size_t);	72	static void lputs(const char *, size_t);
73	static int regexec_e(regex_t , const char , int, int, size_t,	73	static int regexec_e(const regex_t , const char , int, int,
74	size_t);	74	size_t, size_t);
75	static void regsub(SPACE , char , char *);	75	static void regsub(SPACE , const char , const char *);
76	static int substitute(struct s_command *);	76	static int substitute(const struct s_command *);
77		77
78	struct s_appends appends; / Array of pointers to strings to append. */	78	struct s_appends appends; / Array of pointers to strings to append. */
79	static int appendx; /* Index into appends array. */	79	static int appendx; /* Index into appends array. */
Lines 82-88 Link Here
82	static int lastaddr; /* Set by applies if last address of a range. */	82	static int lastaddr; /* Set by applies if last address of a range. */
83	static int sdone; /* If any substitutes since last line input. */	83	static int sdone; /* If any substitutes since last line input. */
84	/* Iov structure for 'w' commands. */	84	/* Iov structure for 'w' commands. */
85	static regex_t *defpreg;	85	static const regex_t *defpreg;
86	size_t maxnsub;	86	size_t maxnsub;
87	regmatch_t *match;	87	regmatch_t *match;
88		88
Lines 366-378 Link Here
366	* and then swap them.	366	* and then swap them.
367	*/	367	*/
368	static int	368	static int
369	substitute(struct s_command *cp)	369	substitute(const struct s_command *cp)
370	{	370	{
371	SPACE tspace;	371	SPACE tspace;
372	regex_t *re;	372	const regex_t *re;
373	regoff_t slen;	373	regoff_t slen;
374	int lastempty, n;	374	int lastempty, n;
375	size_t le = 0;	375	regoff_t le = 0;
376	char *s;	376	char *s;
377		377
378	s = ps;	378	s = ps;
Lines 440-446 Link Here
440	regexec_e(re, ps, REG_NOTBOL, 0, le, psl));	440	regexec_e(re, ps, REG_NOTBOL, 0, le, psl));
441		441
442	/* Did not find the requested number of matches. */	442	/* Did not find the requested number of matches. */
443	if (n > 1)	443	if (n > 0)
444	return (0);	444	return (0);
445		445
446	/* Copy the trailing retained string. */	446	/* Copy the trailing retained string. */
Lines 477-483 Link Here
477	* Perform translation ('y' command) in the pattern space.	477	* Perform translation ('y' command) in the pattern space.
478	*/	478	*/
479	static void	479	static void
480	do_tr(struct s_tr *y)	480	do_tr(const struct s_tr *y)
481	{	481	{
482	SPACE tmp;	482	SPACE tmp;
483	char c, *p;	483	char c, *p;
Lines 566-572 Link Here
566	}	566	}
567		567
568	static void	568	static void
569	lputs(char *s, size_t len)	569	lputs(const char *s, size_t len)
570	{	570	{
571	static const char escapes[] = "\\\a\b\f\r\t\v";	571	static const char escapes[] = "\\\a\b\f\r\t\v";
572	int c, col, width;	572	int c, col, width;
Lines 646-652 Link Here
646	}	646	}
647		647
648	static int	648	static int
649	regexec_e(regex_t preg, const char string, int eflags, int nomatch,	649	regexec_e(const regex_t preg, const char string, int eflags, int nomatch,
650	size_t start, size_t stop)	650	size_t start, size_t stop)
651	{	651	{
652	int eval;	652	int eval;
Lines 678-684 Link Here
678	* Based on a routine by Henry Spencer	678	* Based on a routine by Henry Spencer
679	*/	679	*/
680	static void	680	static void
681	regsub(SPACE sp, char string, char *src)	681	regsub(SPACE sp, const char string, const char *src)
682	{	682	{
683	int len, no;	683	int len, no;
684	char c, *dst;	684	char c, *dst;
Lines 750-756 Link Here
750	* Close all cached opened files and report any errors	750	* Close all cached opened files and report any errors
751	*/	751	*/
752	void	752	void
753	cfclose(struct s_command cp, struct s_command end)	753	cfclose(struct s_command cp, const struct s_command end)
754	{	754	{
755		755
756	for (; cp != end; cp = cp->next)	756	for (; cp != end; cp = cp->next)

Lines 51-57 Link Here

(-)defs.h (-2 / +3 lines)
51	enum e_atype type; /* Address type */	51	enum e_atype type; /* Address type */
52	union {	52	union {
53	u_long l; /* Line number */	53	u_long l; /* Line number */
54	regex_t r; / Regular expression */	54	const regex_t r; / Regular expression */
55	} u;	55	} u;
56	};	56	};
57		57
Lines 64-70 Link Here
64	int icase; /* True if I flag */	64	int icase; /* True if I flag */
65	char wfile; / NULL if no wfile */	65	char wfile; / NULL if no wfile */
66	int wfd; /* Cached file descriptor */	66	int wfd; /* Cached file descriptor */
67	regex_t re; / Regular expression */	67	const regex_t re; / Regular expression */
68	unsigned int maxbref; /* Largest backreference. */	68	unsigned int maxbref; /* Largest backreference. */
69	u_long linenum; /* Line number. */	69	u_long linenum; /* Line number. */
70	char new; / Replacement text */	70	char new; / Replacement text */
Lines 94-99 Link Here
94	struct s_addr a1, a2; /* Start and end address */	94	struct s_addr a1, a2; /* Start and end address */
95	u_long startline; /* Start line number or zero */	95	u_long startline; /* Start line number or zero */
96	char t; / Text for : a c i r w */	96	char t; / Text for : a c i r w */
		97	size_t tlen;
97	union {	98	union {
98	struct s_command c; / Command(s) for b t { */	99	struct s_command c; / Command(s) for b t { */
99	struct s_subst s; / Substitute command */	100	struct s_subst s; / Substitute command */

Lines 56-71 Link Here

(-)misc.c (-5 / +3 lines)
56	* the buffer).	56	* the buffer).
57	*/	57	*/
58	char *	58	char *
59	strregerror(int errcode, regex_t *preg)	59	strregerror(int errcode, const regex_t *preg)
60	{	60	{
61	static char *oe;	61	static char *oe;
62	size_t s;	62	size_t s;
63		63
64	if (oe != NULL)
65	free(oe);
66	s = regerror(errcode, preg, NULL, 0);	64	s = regerror(errcode, preg, NULL, 0);
67	if ((oe = malloc(s)) == NULL)	65	if ((oe = realloc(oe, s)) == NULL)
68	err(1, "malloc");	66	err(1, "realloc");
69	(void)regerror(errcode, preg, oe, s);	67	(void)regerror(errcode, preg, oe, s);
70	return (oe);	68	return (oe);
71	}	69	}