process.c revision 115831 
1/*-
2 * Copyright (c) 1992 Diomidis Spinellis.
3 * Copyright (c) 1992, 1993, 1994
4 *	The Regents of the University of California.  All rights reserved.
5 *
6 * This code is derived from software contributed to Berkeley by
7 * Diomidis Spinellis of Imperial College, University of London.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 *    notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 *    notice, this list of conditions and the following disclaimer in the
16 *    documentation and/or other materials provided with the distribution.
17 * 3. All advertising materials mentioning features or use of this software
18 *    must display the following acknowledgement:
19 *	This product includes software developed by the University of
20 *	California, Berkeley and its contributors.
21 * 4. Neither the name of the University nor the names of its contributors
22 *    may be used to endorse or promote products derived from this software
23 *    without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * SUCH DAMAGE.
36 */
37
38#include <sys/cdefs.h>
39__FBSDID("$FreeBSD: head/usr.bin/sed/process.c 115831 2003-06-04 15:31:55Z fanf $");
40
41#ifndef lint
42static const char sccsid[] = "@(#)process.c	8.6 (Berkeley) 4/20/94";
43#endif
44
45#include <sys/types.h>
46#include <sys/stat.h>
47#include <sys/ioctl.h>
48#include <sys/uio.h>
49
50#include <ctype.h>
51#include <err.h>
52#include <errno.h>
53#include <fcntl.h>
54#include <limits.h>
55#include <regex.h>
56#include <stdio.h>
57#include <stdlib.h>
58#include <string.h>
59#include <unistd.h>
60
61#include "defs.h"
62#include "extern.h"
63
64static SPACE HS, PS, SS;
65#define	pd		PS.deleted
66#define	ps		PS.space
67#define	psl		PS.len
68#define	hs		HS.space
69#define	hsl		HS.len
70
71static __inline int	 applies(struct s_command *);
72static void		 flush_appends(void);
73static void		 lputs(char *);
74static __inline int	 regexec_e(regex_t *, const char *, int, int, size_t);
75static void		 regsub(SPACE *, char *, char *);
76static int		 substitute(struct s_command *);
77
78struct s_appends *appends;	/* Array of pointers to strings to append. */
79static int appendx;		/* Index into appends array. */
80int appendnum;			/* Size of appends array. */
81
82static int lastaddr;		/* Set by applies if last address of a range. */
83static int sdone;		/* If any substitutes since last line input. */
84				/* Iov structure for 'w' commands. */
85static regex_t *defpreg;
86size_t maxnsub;
87regmatch_t *match;
88
89#define OUT(s) { fwrite(s, sizeof(u_char), psl, stdout); putchar('\n'); }
90
91void
92process()
93{
94	struct s_command *cp;
95	SPACE tspace;
96	size_t len, oldpsl = 0;
97	char *p;
98
99	p = NULL;
100
101	for (linenum = 0; mf_fgets(&PS, REPLACE);) {
102		pd = 0;
103top:
104		cp = prog;
105redirect:
106		while (cp != NULL) {
107			if (!applies(cp)) {
108				cp = cp->next;
109				continue;
110			}
111			switch (cp->code) {
112			case '{':
113				cp = cp->u.c;
114				goto redirect;
115			case 'a':
116				if (appendx >= appendnum)
117					if ((appends = realloc(appends,
118					    sizeof(struct s_appends) *
119					    (appendnum *= 2))) == NULL)
120						err(1, "realloc");
121				appends[appendx].type = AP_STRING;
122				appends[appendx].s = cp->t;
123				appends[appendx].len = strlen(cp->t);
124				appendx++;
125				break;
126			case 'b':
127				cp = cp->u.c;
128				goto redirect;
129			case 'c':
130				pd = 1;
131				psl = 0;
132				if (cp->a2 == NULL || lastaddr)
133					(void)printf("%s", cp->t);
134				break;
135			case 'd':
136				pd = 1;
137				goto new;
138			case 'D':
139				if (pd)
140					goto new;
141				if (psl == 0 ||
142				    (p = memchr(ps, '\n', psl)) == NULL) {
143					pd = 1;
144					goto new;
145				} else {
146					psl -= (p + 1) - ps;
147					memmove(ps, p + 1, psl);
148					goto top;
149				}
150			case 'g':
151				cspace(&PS, hs, hsl, REPLACE);
152				break;
153			case 'G':
154				cspace(&PS, "\n", 1, 0);
155				cspace(&PS, hs, hsl, 0);
156				break;
157			case 'h':
158				cspace(&HS, ps, psl, REPLACE);
159				break;
160			case 'H':
161				cspace(&HS, "\n", 1, 0);
162				cspace(&HS, ps, psl, 0);
163				break;
164			case 'i':
165				(void)printf("%s", cp->t);
166				break;
167			case 'l':
168				lputs(ps);
169				break;
170			case 'n':
171				if (!nflag && !pd)
172					OUT(ps)
173				flush_appends();
174				if (!mf_fgets(&PS, REPLACE))
175					exit(0);
176				pd = 0;
177				break;
178			case 'N':
179				flush_appends();
180				cspace(&PS, "\n", 1, 0);
181				if (!mf_fgets(&PS, 0))
182					exit(0);
183				break;
184			case 'p':
185				if (pd)
186					break;
187				OUT(ps)
188				break;
189			case 'P':
190				if (pd)
191					break;
192				if (psl != 0 &&
193				    (p = memchr(ps, '\n', psl)) != NULL) {
194					oldpsl = psl;
195					psl = p - ps;
196				}
197				OUT(ps)
198				if (p != NULL)
199					psl = oldpsl;
200				break;
201			case 'q':
202				if (!nflag && !pd)
203					OUT(ps)
204				flush_appends();
205				exit(0);
206			case 'r':
207				if (appendx >= appendnum)
208					if ((appends = realloc(appends,
209					    sizeof(struct s_appends) *
210					    (appendnum *= 2))) == NULL)
211						err(1, "realloc");
212				appends[appendx].type = AP_FILE;
213				appends[appendx].s = cp->t;
214				appends[appendx].len = strlen(cp->t);
215				appendx++;
216				break;
217			case 's':
218				sdone |= substitute(cp);
219				break;
220			case 't':
221				if (sdone) {
222					sdone = 0;
223					cp = cp->u.c;
224					goto redirect;
225				}
226				break;
227			case 'w':
228				if (pd)
229					break;
230				if (cp->u.fd == -1 && (cp->u.fd = open(cp->t,
231				    O_WRONLY|O_APPEND|O_CREAT|O_TRUNC,
232				    DEFFILEMODE)) == -1)
233					err(1, "%s", cp->t);
234				if (write(cp->u.fd, ps, psl) != psl ||
235				    write(cp->u.fd, "\n", 1) != 1)
236					err(1, "%s", cp->t);
237				break;
238			case 'x':
239				if (hs == NULL)
240					cspace(&HS, "", 0, REPLACE);
241				tspace = PS;
242				PS = HS;
243				HS = tspace;
244				break;
245			case 'y':
246				if (pd || psl == 0)
247					break;
248				for (p = ps, len = psl; len--; ++p)
249					*p = cp->u.y[(unsigned char)*p];
250				break;
251			case ':':
252			case '}':
253				break;
254			case '=':
255				(void)printf("%lu\n", linenum);
256			}
257			cp = cp->next;
258		} /* for all cp */
259
260new:		if (!nflag && !pd)
261			OUT(ps)
262		flush_appends();
263	} /* for all lines */
264}
265
266/*
267 * TRUE if the address passed matches the current program state
268 * (lastline, linenumber, ps).
269 */
270#define	MATCH(a)						\
271	(a)->type == AT_RE ? regexec_e((a)->u.r, ps, 0, 1, psl) :	\
272	    (a)->type == AT_LINE ? linenum == (a)->u.l : lastline()
273
274/*
275 * Return TRUE if the command applies to the current line.  Sets the inrange
276 * flag to process ranges.  Interprets the non-select (``!'') flag.
277 */
278static __inline int
279applies(cp)
280	struct s_command *cp;
281{
282	int r;
283
284	lastaddr = 0;
285	if (cp->a1 == NULL && cp->a2 == NULL)
286		r = 1;
287	else if (cp->a2)
288		if (cp->inrange) {
289			if (MATCH(cp->a2)) {
290				cp->inrange = 0;
291				lastaddr = 1;
292			}
293			r = 1;
294		} else if (MATCH(cp->a1)) {
295			/*
296			 * If the second address is a number less than or
297			 * equal to the line number first selected, only
298			 * one line shall be selected.
299			 *	-- POSIX 1003.2
300			 */
301			if (cp->a2->type == AT_LINE &&
302			    linenum >= cp->a2->u.l)
303				lastaddr = 1;
304			else
305				cp->inrange = 1;
306			r = 1;
307		} else
308			r = 0;
309	else
310		r = MATCH(cp->a1);
311	return (cp->nonsel ? ! r : r);
312}
313
314/*
315 * substitute --
316 *	Do substitutions in the pattern space.  Currently, we build a
317 *	copy of the new pattern space in the substitute space structure
318 *	and then swap them.
319 */
320static int
321substitute(cp)
322	struct s_command *cp;
323{
324	SPACE tspace;
325	regex_t *re;
326	regoff_t re_off, slen;
327	int lastempty, n;
328	char *s;
329
330	s = ps;
331	re = cp->u.s->re;
332	if (re == NULL) {
333		if (defpreg != NULL && cp->u.s->maxbref > defpreg->re_nsub) {
334			linenum = cp->u.s->linenum;
335			errx(1, "%lu: %s: \\%d not defined in the RE",
336					linenum, fname, cp->u.s->maxbref);
337		}
338	}
339	if (!regexec_e(re, s, 0, 0, psl))
340		return (0);
341
342  	SS.len = 0;				/* Clean substitute space. */
343  	slen = psl;
344  	n = cp->u.s->n;
345	lastempty = 1;
346
347  	switch (n) {
348  	case 0:					/* Global */
349  		do {
350			if (lastempty || match[0].rm_so != match[0].rm_eo) {
351				/* Locate start of replaced string. */
352				re_off = match[0].rm_so;
353				/* Copy leading retained string. */
354				cspace(&SS, s, re_off, APPEND);
355				/* Add in regular expression. */
356				regsub(&SS, s, cp->u.s->new);
357			}
358
359			/* Move past this match. */
360			if (match[0].rm_so != match[0].rm_eo) {
361				s += match[0].rm_eo;
362				slen -= match[0].rm_eo;
363				lastempty = 0;
364			} else {
365				if (match[0].rm_so == 0)
366					cspace(&SS, s, match[0].rm_so + 1,
367					    APPEND);
368				else
369					cspace(&SS, s + match[0].rm_so, 1,
370					    APPEND);
371				s += match[0].rm_so + 1;
372				slen -= match[0].rm_so + 1;
373				lastempty = 1;
374			}
375		} while (slen >= 0 && regexec_e(re, s, REG_NOTBOL, 0, slen));
376		/* Copy trailing retained string. */
377		if (slen > 0)
378			cspace(&SS, s, slen, APPEND);
379  		break;
380	default:				/* Nth occurrence */
381		while (--n) {
382			if (match[0].rm_eo == match[0].rm_so)
383				match[0].rm_eo = match[0].rm_so + 1;
384			s += match[0].rm_eo;
385			slen -= match[0].rm_eo;
386			if (slen < 0)
387				return (0);
388			if (!regexec_e(re, s, REG_NOTBOL, 0, slen))
389				return (0);
390		}
391		/* FALLTHROUGH */
392	case 1:					/* 1st occurrence */
393		/* Locate start of replaced string. */
394		re_off = match[0].rm_so + (s - ps);
395		/* Copy leading retained string. */
396		cspace(&SS, ps, re_off, APPEND);
397		/* Add in regular expression. */
398		regsub(&SS, s, cp->u.s->new);
399		/* Copy trailing retained string. */
400		s += match[0].rm_eo;
401		slen -= match[0].rm_eo;
402		cspace(&SS, s, slen, APPEND);
403		break;
404	}
405
406	/*
407	 * Swap the substitute space and the pattern space, and make sure
408	 * that any leftover pointers into stdio memory get lost.
409	 */
410	tspace = PS;
411	PS = SS;
412	SS = tspace;
413	SS.space = SS.back;
414
415	/* Handle the 'p' flag. */
416	if (cp->u.s->p)
417		OUT(ps)
418
419	/* Handle the 'w' flag. */
420	if (cp->u.s->wfile && !pd) {
421		if (cp->u.s->wfd == -1 && (cp->u.s->wfd = open(cp->u.s->wfile,
422		    O_WRONLY|O_APPEND|O_CREAT|O_TRUNC, DEFFILEMODE)) == -1)
423			err(1, "%s", cp->u.s->wfile);
424		if (write(cp->u.s->wfd, ps, psl) != psl ||
425		    write(cp->u.s->wfd, "\n", 1) != 1)
426			err(1, "%s", cp->u.s->wfile);
427	}
428	return (1);
429}
430
431/*
432 * Flush append requests.  Always called before reading a line,
433 * therefore it also resets the substitution done (sdone) flag.
434 */
435static void
436flush_appends()
437{
438	FILE *f;
439	int count, i;
440	char buf[8 * 1024];
441
442	for (i = 0; i < appendx; i++)
443		switch (appends[i].type) {
444		case AP_STRING:
445			fwrite(appends[i].s, sizeof(char), appends[i].len,
446			    stdout);
447			break;
448		case AP_FILE:
449			/*
450			 * Read files probably shouldn't be cached.  Since
451			 * it's not an error to read a non-existent file,
452			 * it's possible that another program is interacting
453			 * with the sed script through the filesystem.  It
454			 * would be truly bizarre, but possible.  It's probably
455			 * not that big a performance win, anyhow.
456			 */
457			if ((f = fopen(appends[i].s, "r")) == NULL)
458				break;
459			while ((count = fread(buf, sizeof(char), sizeof(buf), f)))
460				(void)fwrite(buf, sizeof(char), count, stdout);
461			(void)fclose(f);
462			break;
463		}
464	if (ferror(stdout))
465		errx(1, "stdout: %s", strerror(errno ? errno : EIO));
466	appendx = sdone = 0;
467}
468
469static void
470lputs(s)
471	char *s;
472{
473	int count;
474	const char *escapes;
475	char *p;
476	struct winsize win;
477	static int termwidth = -1;
478
479	if (termwidth == -1) {
480		if ((p = getenv("COLUMNS")) && *p != '\0')
481			termwidth = atoi(p);
482		else if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) == 0 &&
483		    win.ws_col > 0)
484			termwidth = win.ws_col;
485		else
486			termwidth = 60;
487	}
488
489	for (count = 0; *s; ++s) {
490		if (count + 5 >= termwidth) {
491			(void)printf("\\\n");
492			count = 0;
493		}
494		if (isprint((unsigned char)*s) && *s != '\\') {
495			(void)putchar(*s);
496			count++;
497		} else if (*s == '\n') {
498			(void)putchar('$');
499			(void)putchar('\n');
500			count = 0;
501		} else {
502			escapes = "\\\a\b\f\r\t\v";
503			(void)putchar('\\');
504			if ((p = strchr(escapes, *s))) {
505				(void)putchar("\\abfrtv"[p - escapes]);
506				count += 2;
507			} else {
508				(void)printf("%03o", *(u_char *)s);
509				count += 4;
510			}
511		}
512	}
513	(void)putchar('$');
514	(void)putchar('\n');
515	if (ferror(stdout))
516		errx(1, "stdout: %s", strerror(errno ? errno : EIO));
517}
518
519static __inline int
520regexec_e(preg, string, eflags, nomatch, slen)
521	regex_t *preg;
522	const char *string;
523	int eflags, nomatch;
524	size_t slen;
525{
526	int eval;
527
528	if (preg == NULL) {
529		if (defpreg == NULL)
530			errx(1, "first RE may not be empty");
531	} else
532		defpreg = preg;
533
534	/* Set anchors */
535	match[0].rm_so = 0;
536	match[0].rm_eo = slen;
537
538	eval = regexec(defpreg, string,
539	    nomatch ? 0 : maxnsub + 1, match, eflags | REG_STARTEND);
540	switch(eval) {
541	case 0:
542		return (1);
543	case REG_NOMATCH:
544		return (0);
545	}
546	errx(1, "RE error: %s", strregerror(eval, defpreg));
547	/* NOTREACHED */
548}
549
550/*
551 * regsub - perform substitutions after a regexp match
552 * Based on a routine by Henry Spencer
553 */
554static void
555regsub(sp, string, src)
556	SPACE *sp;
557	char *string, *src;
558{
559	int len, no;
560	char c, *dst;
561
562#define	NEEDSP(reqlen)							\
563	if (sp->len >= sp->blen - (reqlen) - 1) {			\
564		sp->blen += (reqlen) + 1024;				\
565		if ((sp->space = sp->back = realloc(sp->back, sp->blen)) \
566		    == NULL)						\
567			err(1, "realloc");				\
568		dst = sp->space + sp->len;				\
569	}
570
571	dst = sp->space + sp->len;
572	while ((c = *src++) != '\0') {
573		if (c == '&')
574			no = 0;
575		else if (c == '\\' && isdigit((unsigned char)*src))
576			no = *src++ - '0';
577		else
578			no = -1;
579		if (no < 0) {		/* Ordinary character. */
580 			if (c == '\\' && (*src == '\\' || *src == '&'))
581 				c = *src++;
582			NEEDSP(1);
583 			*dst++ = c;
584			++sp->len;
585 		} else if (match[no].rm_so != -1 && match[no].rm_eo != -1) {
586			len = match[no].rm_eo - match[no].rm_so;
587			NEEDSP(len);
588			memmove(dst, string + match[no].rm_so, len);
589			dst += len;
590			sp->len += len;
591		}
592	}
593	NEEDSP(1);
594	*dst = '\0';
595}
596
597/*
598 * aspace --
599 *	Append the source space to the destination space, allocating new
600 *	space as necessary.
601 */
602void
603cspace(sp, p, len, spflag)
604	SPACE *sp;
605	const char *p;
606	size_t len;
607	enum e_spflag spflag;
608{
609	size_t tlen;
610
611	/* Make sure SPACE has enough memory and ramp up quickly. */
612	tlen = sp->len + len + 1;
613	if (tlen > sp->blen) {
614		sp->blen = tlen + 1024;
615		if ((sp->space = sp->back = realloc(sp->back, sp->blen)) ==
616		    NULL)
617			err(1, "realloc");
618	}
619
620	if (spflag == REPLACE)
621		sp->len = 0;
622
623	memmove(sp->space + sp->len, p, len);
624
625	sp->space[sp->len += len] = '\0';
626}
627
628/*
629 * Close all cached opened files and report any errors
630 */
631void
632cfclose(cp, end)
633	struct s_command *cp, *end;
634{
635
636	for (; cp != end; cp = cp->next)
637		switch(cp->code) {
638		case 's':
639			if (cp->u.s->wfd != -1 && close(cp->u.s->wfd))
640				err(1, "%s", cp->u.s->wfile);
641			cp->u.s->wfd = -1;
642			break;
643		case 'w':
644			if (cp->u.fd != -1 && close(cp->u.fd))
645				err(1, "%s", cp->t);
646			cp->u.fd = -1;
647			break;
648		case '{':
649			cfclose(cp->u.c, cp->next);
650			break;
651		}
652}
653