[unix-history] / usr / src / cmd / sed / sed1.c

#include	<stdio.h>
#include "sed.h"

char	*trans[040]  = {
	"\\01",
	"\\02",
	"\\03",
	"\\04",
	"\\05",
	"\\06",
	"\\07",
	"<\b-",
	">\b-",
	"\n",
	"\\13",
	"\\14",
	"\\15",
	"\\16",
	"\\17",
	"\\20",
	"\\21",
	"\\22",
	"\\23",
	"\\24",
	"\\25",
	"\\26",
	"\\27",
	"\\30",
	"\\31",
	"\\32",
	"\\33",
	"\\34",
	"\\35",
	"\\36",
	"\\37"
};
char	rub[] = {"\177"};

execute(file)
char *file;
{
	register char *p1, *p2;
	register union reptr	*ipc;
	int	c;
	char	*execp;

	if (file) {
		if ((f = open(file, 0)) < 0) {
			fprintf(stderr, "Can't open %s\n", file);
		}
	} else
		f = 0;

	ebp = ibuf;
	cbp = ibuf;

	if(pending) {
		ipc = pending;
		pending = 0;
		goto yes;
	}

	for(;;) {
		if((execp = gline(linebuf)) == badp) {
			close(f);
			return;
		}
		spend = execp;

		for(ipc = ptrspace; ipc->command; ) {

			p1 = ipc->ad1;
			p2 = ipc->ad2;

			if(p1) {

				if(ipc->inar) {
					if(*p2 == CEND) {
						p1 = 0;
					} else if(*p2 == CLNUM) {
						c = p2[1];
						if(lnum > tlno[c]) {
							ipc->inar = 0;
							if(ipc->negfl)
								goto yes;
							ipc++;
							continue;
						}
						if(lnum == tlno[c]) {
							ipc->inar = 0;
						}
					} else if(match(p2, 0)) {
						ipc->inar = 0;
					}
				} else if(*p1 == CEND) {
					if(!dolflag) {
						if(ipc->negfl)
							goto yes;
						ipc++;
						continue;
					}

				} else if(*p1 == CLNUM) {
					c = p1[1];
					if(lnum != tlno[c]) {
						if(ipc->negfl)
							goto yes;
						ipc++;
						continue;
					}
					if(p2)
						ipc->inar = 1;
				} else if(match(p1, 0)) {
					if(p2)
						ipc->inar = 1;
				} else {
					if(ipc->negfl)
						goto yes;
					ipc++;
					continue;
				}
			}

			if(ipc->negfl) {
				ipc++;
				continue;
			}
	yes:
			command(ipc);

			if(delflag)
				break;

			if(jflag) {
				jflag = 0;
				if((ipc = ipc->lb1) == 0) {
					ipc = ptrspace;
					break;
				}
			} else
				ipc++;

		}
		if(!nflag && !delflag) {
			for(p1 = linebuf; p1 < spend; p1++)
				putc(*p1, stdout);
			putc('\n', stdout);
		}

		if(aptr > abuf) {
			arout();
		}

		delflag = 0;

	}
}
match(expbuf, gf)
char	*expbuf;
{
	register char	*p1, *p2, c;

	if(gf) {
		if(*expbuf)	return(0);
		p1 = linebuf;
		p2 = genbuf;
		while(*p1++ = *p2++);
		locs = p1 = loc2;
	} else {
		p1 = linebuf;
		locs = 0;
	}

	p2 = expbuf;
	if(*p2++) {
		loc1 = p1;
		if(*p2 == CCHR && p2[1] != *p1)
			return(0);
		return(advance(p1, p2));
	}

	/* fast check for first character */

	if(*p2 == CCHR) {
		c = p2[1];
		do {
			if(*p1 != c)
				continue;
			if(advance(p1, p2)) {
				loc1 = p1;
				return(1);
			}
		} while(*p1++);
		return(0);
	}

	do {
		if(advance(p1, p2)) {
			loc1 = p1;
			return(1);
		}
	} while(*p1++);
	return(0);
}
advance(alp, aep)
char	*alp, *aep;
{
	register char *lp, *ep, *curlp;
	char	c;
	char *bbeg;
	int	ct;

/*fprintf(stderr, "*lp = %c, %o\n*ep = %c, %o\n", *lp, *lp, *ep, *ep);	/*DEBUG*/

	lp = alp;
	ep = aep;
	for (;;) switch (*ep++) {

	case CCHR:
		if (*ep++ == *lp++)
			continue;
		return(0);

	case CDOT:
		if (*lp++)
			continue;
		return(0);

	case CNL:
	case CDOL:
		if (*lp == 0)
			continue;
		return(0);

	case CEOF:
		loc2 = lp;
		return(1);

	case CCL:
		c = *lp++ & 0177;
		if(ep[c>>3] & bittab[c & 07]) {
			ep += 16;
			continue;
		}
		return(0);

	case CBRA:
		braslist[*ep++] = lp;
		continue;

	case CKET:
		braelist[*ep++] = lp;
		continue;

	case CBACK:
		bbeg = braslist[*ep];
		ct = braelist[*ep++] - bbeg;

		if(ecmp(bbeg, lp, ct)) {
			lp += ct;
			continue;
		}
		return(0);

	case CBACK|STAR:
		bbeg = braslist[*ep];
		ct = braelist[*ep++] - bbeg;
		curlp = lp;
		while(ecmp(bbeg, lp, ct))
			lp += ct;

		while(lp >= curlp) {
			if(advance(lp, ep))	return(1);
			lp -= ct;
		}
		return(0);


	case CDOT|STAR:
		curlp = lp;
		while (*lp++);
		goto star;

	case CCHR|STAR:
		curlp = lp;
		while (*lp++ == *ep);
		ep++;
		goto star;

	case CCL|STAR:
		curlp = lp;
		do {
			c = *lp++ & 0177;
		} while(ep[c>>3] & bittab[c & 07]);
		ep += 16;
		goto star;

	star:
		if(--lp == curlp) {
			continue;
		}

		if(*ep == CCHR) {
			c = ep[1];
			do {
				if(*lp != c)
					continue;
				if(advance(lp, ep))
					return(1);
			} while(lp-- > curlp);
			return(0);
		}

		if(*ep == CBACK) {
			c = *(braslist[ep[1]]);
			do {
				if(*lp != c)
					continue;
				if(advance(lp, ep))
					return(1);
			} while(lp-- > curlp);
			return(0);
		}

		do {
			if(lp == locs)	break;
			if (advance(lp, ep))
				return(1);
		} while (lp-- > curlp);
		return(0);

	default:
		fprintf(stderr, "RE botch, %o\n", *--ep);
	}
}
substitute(ipc)
union reptr	*ipc;
{
	if(match(ipc->re1, 0) == 0)	return(0);

	sflag = 1;
	dosub(ipc->rhs);

	if(ipc->gfl) {
		while(*loc2) {
			if(match(ipc->re1, 1) == 0) break;
			dosub(ipc->rhs);
		}
	}
	return(1);
}

dosub(rhsbuf)
char	*rhsbuf;
{
	register char *lp, *sp, *rp;
	int c;

	lp = linebuf;
	sp = genbuf;
	rp = rhsbuf;
	while (lp < loc1)
		*sp++ = *lp++;
	while(c = *rp++) {
		if (c == '&') {
			sp = place(sp, loc1, loc2);
			continue;
		} else if (c&0200 && (c &= 0177) >= '1' && c < NBRA+'1') {
			sp = place(sp, braslist[c-'1'], braelist[c-'1']);
			continue;
		}
		*sp++ = c&0177;
		if (sp >= &genbuf[LBSIZE])
			fprintf(stderr, "output line too long.\n");
	}
	lp = loc2;
	loc2 = sp - genbuf + linebuf;
	while (*sp++ = *lp++)
		if (sp >= &genbuf[LBSIZE]) {
			fprintf(stderr, "Output line too long.\n");
		}
	lp = linebuf;
	sp = genbuf;
	while (*lp++ = *sp++);
	spend = lp-1;
}
char	*place(asp, al1, al2)
char	*asp, *al1, *al2;
{
	register char *sp, *l1, *l2;

	sp = asp;
	l1 = al1;
	l2 = al2;
	while (l1 < l2) {
		*sp++ = *l1++;
		if (sp >= &genbuf[LBSIZE])
			fprintf(stderr, "Output line too long.\n");
	}
	return(sp);
}

command(ipc)
union reptr	*ipc;
{
	register int	i;
	register char	*p1, *p2, *p3;
	char	*execp;


	switch(ipc->command) {

		case ACOM:
			*aptr++ = ipc;
			if(aptr >= &abuf[ABUFSIZE]) {
				fprintf(stderr, "Too many appends after line %ld\n",
					lnum);
			}
			*aptr = 0;
			break;

		case CCOM:
			delflag = 1;
			if(!ipc->inar || dolflag) {
				for(p1 = ipc->re1; *p1; )
					putc(*p1++, stdout);
				putc('\n', stdout);
			}
			break;
		case DCOM:
			delflag++;
			break;
		case CDCOM:
			p1 = p2 = linebuf;

			while(*p1 != '\n') {
				if(*p1++ == 0) {
					delflag++;
					return;
				}
			}

			p1++;
			while(*p2++ = *p1++);
			spend = p2-1;
			jflag++;
			break;

		case EQCOM:
			fprintf(stdout, "%ld\n", lnum);
			break;

		case GCOM:
			p1 = linebuf;
			p2 = holdsp;
			while(*p1++ = *p2++);
			spend = p1-1;
			break;

		case CGCOM:
			*spend++ = '\n';
			p1 = spend;
			p2 = holdsp;
			while(*p1++ = *p2++)
				if(p1 >= lbend)
					break;
			spend = p1-1;
			break;

		case HCOM:
			p1 = holdsp;
			p2 = linebuf;
			while(*p1++ = *p2++);
			hspend = p1-1;
			break;

		case CHCOM:
			*hspend++ = '\n';
			p1 = hspend;
			p2 = linebuf;
			while(*p1++ = *p2++)
				if(p1 >= hend)
					break;
			hspend = p1-1;
			break;

		case ICOM:
			for(p1 = ipc->re1; *p1; )
				putc(*p1++, stdout);
			putc('\n', stdout);
			break;

		case BCOM:
			jflag = 1;
			break;

		case LCOM:
			p1 = linebuf;
			p2 = genbuf;
			genbuf[72] = 0;
			while(*p1)
				if(*p1 >= 040) {
					if(*p1 == 0177) {
						p3 = rub;
						while(*p2++ = *p3++)
							if(p2 >= lcomend) {
								*p2 = '\\';
								fprintf(stdout, "%s\n", genbuf);
								p2 = genbuf;
							}
						p2--;
						p1++;
						continue;
					}
					*p2++ = *p1++;
					if(p2 >= lcomend) {
						*p2 = '\\';
						fprintf(stdout, "%s\n", genbuf);
						p2 = genbuf;
					}
				} else {
					p3 = trans[*p1-1];
					while(*p2++ = *p3++)
						if(p2 >= lcomend) {
							*p2 = '\\';
							fprintf(stdout, "%s\n", genbuf);
							p2 = genbuf;
						}
					p2--;
					p1++;
				}
			*p2 = 0;
			fprintf(stdout, "%s\n", genbuf);
			break;

		case NCOM:
			if(!nflag) {
				for(p1 = linebuf; p1 < spend; p1++)
					putc(*p1, stdout);
				putc('\n', stdout);
			}

			if(aptr > abuf)
				arout();
			if((execp = gline(linebuf)) == badp) {
				pending = ipc;
				delflag = 1;
				break;
			}
			spend = execp;

			break;
		case CNCOM:
			if(aptr > abuf)
				arout();
			*spend++ = '\n';
			if((execp = gline(spend)) == badp) {
				pending = ipc;
				delflag = 1;
				break;
			}
			spend = execp;
			break;

		case PCOM:
			for(p1 = linebuf; p1 < spend; p1++)
				putc(*p1, stdout);
			putc('\n', stdout);
			break;
		case CPCOM:
	cpcom:
			for(p1 = linebuf; *p1 != '\n' && *p1 != '\0'; )
				putc(*p1++, stdout);
			putc('\n', stdout);
			break;

		case QCOM:
			if(!nflag) {
				for(p1 = linebuf; p1 < spend; p1++)
					putc(*p1, stdout);
				putc('\n', stdout);
			}
			if(aptr > abuf)	arout();
			fclose(stdout);
			exit(0);
		case RCOM:

			*aptr++ = ipc;
			if(aptr >= &abuf[ABUFSIZE])
				fprintf(stderr, "Too many reads after line%ld\n",
					lnum);

			*aptr = 0;

			break;

		case SCOM:
			i = substitute(ipc);
			if(ipc->pfl && i)
				if(ipc->pfl == 1) {
					for(p1 = linebuf; p1 < spend; p1++)
						putc(*p1, stdout);
					putc('\n', stdout);
				}
				else
					goto cpcom;
			if(i && ipc->fcode)
				goto wcom;
			break;

		case TCOM:
			if(sflag == 0)	break;
			sflag = 0;
			jflag = 1;
			break;

		wcom:
		case WCOM:
			fprintf(ipc->fcode, "%s\n", linebuf);
			break;
		case XCOM:
			p1 = linebuf;
			p2 = genbuf;
			while(*p2++ = *p1++);
			p1 = holdsp;
			p2 = linebuf;
			while(*p2++ = *p1++);
			spend = p2 - 1;
			p1 = genbuf;
			p2 = holdsp;
			while(*p2++ = *p1++);
			hspend = p2 - 1;
			break;

		case YCOM:
			p1 = linebuf;
			p2 = ipc->re1;
			while(*p1 = p2[*p1])	p1++;
			break;
	}

}

char	*
gline(addr)
char	*addr;
{
	register char	*p1, *p2;
	register	c;
	p1 = addr;
	p2 = cbp;
	for (;;) {
		if (p2 >= ebp) {
			if ((c = read(f, ibuf, 512)) <= 0) {
				return(badp);
			}
			p2 = ibuf;
			ebp = ibuf+c;
		}
		if ((c = *p2++) == '\n') {
			if(p2 >=  ebp) {
				if((c = read(f, ibuf, 512)) <= 0) {
					close(f);
					if(eargc == 0)
							dolflag = 1;
				}

				p2 = ibuf;
				ebp = ibuf + c;
			}
			break;
		}
		if(c)
		if(p1 < lbend)
			*p1++ = c;
	}
	lnum++;
	*p1 = 0;
	cbp = p2;

	return(p1);
}
ecmp(a, b, count)
char	*a, *b;
{
	while(count--)
		if(*a++ != *b++)	return(0);
	return(1);
}

arout()
{
	register char	*p1;
	FILE	*fi;
	char	c;
	int	t;

	aptr = abuf - 1;
	while(*++aptr) {
		if((*aptr)->command == ACOM) {
			for(p1 = (*aptr)->re1; *p1; )
				putc(*p1++, stdout);
			putc('\n', stdout);
		} else {
			if((fi = fopen((*aptr)->re1, "r")) == NULL)
				continue;
			while((t = getc(fi)) != EOF) {
				c = t;
				putc(c, stdout);
			}
			fclose(fi);
		}
	}
	aptr = abuf;
	*aptr = 0;
}
Commit	Line	Data
663820b5 LM	1	#include <stdio.h>
	2	#include "sed.h"
	3
	4	char *trans[040] = {
	5	"\\01",
	6	"\\02",
	7	"\\03",
	8	"\\04",
	9	"\\05",
	10	"\\06",
	11	"\\07",
	12	"<\b-",
	13	">\b-",
	14	"\n",
	15	"\\13",
	16	"\\14",
	17	"\\15",
	18	"\\16",
	19	"\\17",
	20	"\\20",
	21	"\\21",
	22	"\\22",
	23	"\\23",
	24	"\\24",
	25	"\\25",
	26	"\\26",
	27	"\\27",
	28	"\\30",
	29	"\\31",
	30	"\\32",
	31	"\\33",
	32	"\\34",
	33	"\\35",
	34	"\\36",
	35	"\\37"
	36	};
	37	char rub[] = {"\177"};
	38
	39	execute(file)
	40	char *file;
	41	{
	42	register char p1, p2;
	43	register union reptr *ipc;
	44	int c;
	45	char *execp;
	46
	47	if (file) {
	48	if ((f = open(file, 0)) < 0) {
	49	fprintf(stderr, "Can't open %s\n", file);
	50	}
	51	} else
	52	f = 0;
	53
	54	ebp = ibuf;
	55	cbp = ibuf;
	56
	57	if(pending) {
	58	ipc = pending;
	59	pending = 0;
	60	goto yes;
	61	}
	62
	63	for(;;) {
	64	if((execp = gline(linebuf)) == badp) {
65	close(f);
66	return;
67	}
68	spend = execp;
69
70	for(ipc = ptrspace; ipc->command; ) {
71
72	p1 = ipc->ad1;
73	p2 = ipc->ad2;
74
75	if(p1) {
76
77	if(ipc->inar) {
78	if(*p2 == CEND) {
79	p1 = 0;
80	} else if(*p2 == CLNUM) {
81	c = p2[1];
82	if(lnum > tlno[c]) {
83	ipc->inar = 0;
84	if(ipc->negfl)
85	goto yes;
86	ipc++;
87	continue;
88	}
89	if(lnum == tlno[c]) {
90	ipc->inar = 0;
91	}
92	} else if(match(p2, 0)) {
93	ipc->inar = 0;
94	}
95	} else if(*p1 == CEND) {
96	if(!dolflag) {
97	if(ipc->negfl)
98	goto yes;
99	ipc++;
100	continue;
101	}
102
103	} else if(*p1 == CLNUM) {
104	c = p1[1];
105	if(lnum != tlno[c]) {
106	if(ipc->negfl)
107	goto yes;
108	ipc++;
109	continue;
110	}
111	if(p2)
112	ipc->inar = 1;
113	} else if(match(p1, 0)) {
114	if(p2)
115	ipc->inar = 1;
116	} else {
117	if(ipc->negfl)
118	goto yes;
119	ipc++;
120	continue;
121	}
122	}
123
124	if(ipc->negfl) {
125	ipc++;
126	continue;
127	}
128	yes:
129	command(ipc);
130
131	if(delflag)
132	break;
133
134	if(jflag) {
135	jflag = 0;
136	if((ipc = ipc->lb1) == 0) {
137	ipc = ptrspace;
138	break;
139	}
140	} else
141	ipc++;
142
143	}
144	if(!nflag && !delflag) {
145	for(p1 = linebuf; p1 < spend; p1++)
146	putc(*p1, stdout);
147	putc('\n', stdout);
148	}
149
150	if(aptr > abuf) {
151	arout();
152	}
153
154	delflag = 0;
155
156	}
157	}
158	match(expbuf, gf)
159	char *expbuf;
160	{
161	register char p1, p2, c;
162
163	if(gf) {
164	if(*expbuf) return(0);
165	p1 = linebuf;
166	p2 = genbuf;
167	while(p1++ = p2++);
168	locs = p1 = loc2;
169	} else {
170	p1 = linebuf;
171	locs = 0;
172	}
173
174	p2 = expbuf;
175	if(*p2++) {
176	loc1 = p1;
177	if(p2 == CCHR && p2[1] != p1)
178	return(0);
179	return(advance(p1, p2));
180	}
181
182	/* fast check for first character */
183
184	if(*p2 == CCHR) {
185	c = p2[1];
186	do {
187	if(*p1 != c)
188	continue;
189	if(advance(p1, p2)) {
190	loc1 = p1;
191	return(1);
192	}
193	} while(*p1++);
194	return(0);
195	}
196
197	do {
198	if(advance(p1, p2)) {
199	loc1 = p1;
200	return(1);
201	}
202	} while(*p1++);
203	return(0);
204	}
205	advance(alp, aep)
206	char alp, aep;
207	{
208	register char lp, ep, *curlp;
209	char c;
210	char *bbeg;
211	int ct;
212
213	/fprintf(stderr, "lp = %c, %o\nep = %c, %o\n", lp, lp, ep, ep); /DEBUG*/
214
215	lp = alp;
216	ep = aep;
217	for (;;) switch (*ep++) {
218
219	case CCHR:
220	if (ep++ == lp++)
221	continue;
222	return(0);
223
224	case CDOT:
225	if (*lp++)
226	continue;
227	return(0);
228
229	case CNL:
230	case CDOL:
231	if (*lp == 0)
232	continue;
233	return(0);
234
235	case CEOF:
236	loc2 = lp;
237	return(1);
238
239	case CCL:
240	c = *lp++ & 0177;
241	if(ep[c>>3] & bittab[c & 07]) {
242	ep += 16;
243	continue;
244	}
245	return(0);
246
247	case CBRA:
248	braslist[*ep++] = lp;
249	continue;
250
251	case CKET:
252	braelist[*ep++] = lp;
253	continue;
254
255	case CBACK:
256	bbeg = braslist[*ep];
257	ct = braelist[*ep++] - bbeg;
258
259	if(ecmp(bbeg, lp, ct)) {
260	lp += ct;
261	continue;
262	}
263	return(0);
264
265	case CBACK\|STAR:
266	bbeg = braslist[*ep];
267	ct = braelist[*ep++] - bbeg;
268	curlp = lp;
269	while(ecmp(bbeg, lp, ct))
270	lp += ct;
271
272	while(lp >= curlp) {
273	if(advance(lp, ep)) return(1);
274	lp -= ct;
275	}
276	return(0);
277
278
279	case CDOT\|STAR:
280	curlp = lp;
281	while (*lp++);
282	goto star;
283
284	case CCHR\|STAR:
285	curlp = lp;
286	while (lp++ == ep);
287	ep++;
288	goto star;
289
290	case CCL\|STAR:
291	curlp = lp;
292	do {
293	c = *lp++ & 0177;
294	} while(ep[c>>3] & bittab[c & 07]);
295	ep += 16;
296	goto star;
297
298	star:
299	if(--lp == curlp) {
300	continue;
301	}
302
303	if(*ep == CCHR) {
304	c = ep[1];
305	do {
306	if(*lp != c)
307	continue;
308	if(advance(lp, ep))
309	return(1);
310	} while(lp-- > curlp);
311	return(0);
312	}
313
314	if(*ep == CBACK) {
315	c = *(braslist[ep[1]]);
316	do {
317	if(*lp != c)
318	continue;
319	if(advance(lp, ep))
320	return(1);
321	} while(lp-- > curlp);
322	return(0);
323	}
324
325	do {
326	if(lp == locs) break;
327	if (advance(lp, ep))
328	return(1);
329	} while (lp-- > curlp);
330	return(0);
331
332	default:
333	fprintf(stderr, "RE botch, %o\n", *--ep);
334	}
335	}
336	substitute(ipc)
337	union reptr *ipc;
338	{
339	if(match(ipc->re1, 0) == 0) return(0);
340
341	sflag = 1;
342	dosub(ipc->rhs);
343
344	if(ipc->gfl) {
345	while(*loc2) {
346	if(match(ipc->re1, 1) == 0) break;
347	dosub(ipc->rhs);
348	}
349	}
350	return(1);
351	}
352
353	dosub(rhsbuf)
354	char *rhsbuf;
355	{
356	register char lp, sp, *rp;
357	int c;
358
359	lp = linebuf;
360	sp = genbuf;
361	rp = rhsbuf;
362	while (lp < loc1)
363	sp++ = lp++;
364	while(c = *rp++) {
365	if (c == '&') {
366	sp = place(sp, loc1, loc2);
367	continue;
368	} else if (c&0200 && (c &= 0177) >= '1' && c < NBRA+'1') {
369	sp = place(sp, braslist[c-'1'], braelist[c-'1']);
370	continue;
371	}
372	*sp++ = c&0177;
373	if (sp >= &genbuf[LBSIZE])
374	fprintf(stderr, "output line too long.\n");
375	}
376	lp = loc2;
377	loc2 = sp - genbuf + linebuf;
378	while (sp++ = lp++)
379	if (sp >= &genbuf[LBSIZE]) {
380	fprintf(stderr, "Output line too long.\n");
381	}
382	lp = linebuf;
383	sp = genbuf;
384	while (lp++ = sp++);
385	spend = lp-1;
386	}
387	char *place(asp, al1, al2)
388	char asp, al1, *al2;
389	{
390	register char sp, l1, *l2;
391
392	sp = asp;
393	l1 = al1;
394	l2 = al2;
395	while (l1 < l2) {
396	sp++ = l1++;
397	if (sp >= &genbuf[LBSIZE])
398	fprintf(stderr, "Output line too long.\n");
399	}
400	return(sp);
401	}
402
403	command(ipc)
404	union reptr *ipc;
405	{
406	register int i;
407	register char p1, p2, *p3;
408	char *execp;
409
410
411	switch(ipc->command) {
412
413	case ACOM:
414	*aptr++ = ipc;
415	if(aptr >= &abuf[ABUFSIZE]) {
416	fprintf(stderr, "Too many appends after line %ld\n",
417	lnum);
418	}
419	*aptr = 0;
420	break;
421
422	case CCOM:
423	delflag = 1;
424	if(!ipc->inar \|\| dolflag) {
425	for(p1 = ipc->re1; *p1; )
426	putc(*p1++, stdout);
427	putc('\n', stdout);
428	}
429	break;
430	case DCOM:
431	delflag++;
432	break;
433	case CDCOM:
434	p1 = p2 = linebuf;
435
436	while(*p1 != '\n') {
437	if(*p1++ == 0) {
438	delflag++;
439	return;
440	}
441	}
442
443	p1++;
444	while(p2++ = p1++);
445	spend = p2-1;
446	jflag++;
447	break;
448
449	case EQCOM:
450	fprintf(stdout, "%ld\n", lnum);
451	break;
452
453	case GCOM:
454	p1 = linebuf;
455	p2 = holdsp;
456	while(p1++ = p2++);
457	spend = p1-1;
458	break;
459
460	case CGCOM:
461	*spend++ = '\n';
462	p1 = spend;
463	p2 = holdsp;
464	while(p1++ = p2++)
465	if(p1 >= lbend)
466	break;
467	spend = p1-1;
468	break;
469
470	case HCOM:
471	p1 = holdsp;
472	p2 = linebuf;
473	while(p1++ = p2++);
474	hspend = p1-1;
475	break;
476
477	case CHCOM:
478	*hspend++ = '\n';
479	p1 = hspend;
480	p2 = linebuf;
481	while(p1++ = p2++)
482	if(p1 >= hend)
483	break;
484	hspend = p1-1;
485	break;
486
487	case ICOM:
488	for(p1 = ipc->re1; *p1; )
489	putc(*p1++, stdout);
490	putc('\n', stdout);
491	break;
492
493	case BCOM:
494	jflag = 1;
495	break;
496
497	case LCOM:
498	p1 = linebuf;
499	p2 = genbuf;
500	genbuf[72] = 0;
501	while(*p1)
502	if(*p1 >= 040) {
503	if(*p1 == 0177) {
504	p3 = rub;
505	while(p2++ = p3++)
506	if(p2 >= lcomend) {
507	*p2 = '\\';
508	fprintf(stdout, "%s\n", genbuf);
509	p2 = genbuf;
510	}
511	p2--;
512	p1++;
513	continue;
514	}
515	p2++ = p1++;
516	if(p2 >= lcomend) {
517	*p2 = '\\';
518	fprintf(stdout, "%s\n", genbuf);
519	p2 = genbuf;
520	}
521	} else {
522	p3 = trans[*p1-1];
523	while(p2++ = p3++)
524	if(p2 >= lcomend) {
525	*p2 = '\\';
526	fprintf(stdout, "%s\n", genbuf);
527	p2 = genbuf;
528	}
529	p2--;
530	p1++;
531	}
532	*p2 = 0;
533	fprintf(stdout, "%s\n", genbuf);
534	break;
535
536	case NCOM:
537	if(!nflag) {
538	for(p1 = linebuf; p1 < spend; p1++)
539	putc(*p1, stdout);
540	putc('\n', stdout);
541	}
542
543	if(aptr > abuf)
544	arout();
545	if((execp = gline(linebuf)) == badp) {
546	pending = ipc;
547	delflag = 1;
548	break;
549	}
550	spend = execp;
551
552	break;
553	case CNCOM:
554	if(aptr > abuf)
555	arout();
556	*spend++ = '\n';
557	if((execp = gline(spend)) == badp) {
558	pending = ipc;
559	delflag = 1;
560	break;
561	}
562	spend = execp;
563	break;
564
565	case PCOM:
566	for(p1 = linebuf; p1 < spend; p1++)
567	putc(*p1, stdout);
568	putc('\n', stdout);
569	break;
570	case CPCOM:
571	cpcom:
572	for(p1 = linebuf; p1 != '\n' && p1 != '\0'; )
573	putc(*p1++, stdout);
574	putc('\n', stdout);
575	break;
576
577	case QCOM:
578	if(!nflag) {
579	for(p1 = linebuf; p1 < spend; p1++)
580	putc(*p1, stdout);
581	putc('\n', stdout);
582	}
583	if(aptr > abuf) arout();
584	fclose(stdout);
585	exit(0);
586	case RCOM:
587
588	*aptr++ = ipc;
589	if(aptr >= &abuf[ABUFSIZE])
590	fprintf(stderr, "Too many reads after line%ld\n",
591	lnum);
592
593	*aptr = 0;
594
595	break;
596
597	case SCOM:
598	i = substitute(ipc);
599	if(ipc->pfl && i)
600	if(ipc->pfl == 1) {
601	for(p1 = linebuf; p1 < spend; p1++)
602	putc(*p1, stdout);
603	putc('\n', stdout);
604	}
605	else
606	goto cpcom;
607	if(i && ipc->fcode)
608	goto wcom;
609	break;
610
611	case TCOM:
612	if(sflag == 0) break;
613	sflag = 0;
614	jflag = 1;
615	break;
616
617	wcom:
618	case WCOM:
619	fprintf(ipc->fcode, "%s\n", linebuf);
620	break;
621	case XCOM:
622	p1 = linebuf;
623	p2 = genbuf;
624	while(p2++ = p1++);
625	p1 = holdsp;
626	p2 = linebuf;
627	while(p2++ = p1++);
628	spend = p2 - 1;
629	p1 = genbuf;
630	p2 = holdsp;
631	while(p2++ = p1++);
632	hspend = p2 - 1;
633	break;
634
635	case YCOM:
636	p1 = linebuf;
637	p2 = ipc->re1;
638	while(p1 = p2[p1]) p1++;
639	break;
640	}
641
642	}
643
644	char *
645	gline(addr)
646	char *addr;
647	{
648	register char p1, p2;
649	register c;
650	p1 = addr;
651	p2 = cbp;
652	for (;;) {
653	if (p2 >= ebp) {
654	if ((c = read(f, ibuf, 512)) <= 0) {
655	return(badp);
656	}
657	p2 = ibuf;
658	ebp = ibuf+c;
659	}
660	if ((c = *p2++) == '\n') {
661	if(p2 >= ebp) {
662	if((c = read(f, ibuf, 512)) <= 0) {
663	close(f);
664	if(eargc == 0)
665	dolflag = 1;
666	}
667
668	p2 = ibuf;
669	ebp = ibuf + c;
670	}
671	break;
672	}
673	if(c)
674	if(p1 < lbend)
675	*p1++ = c;
676	}
677	lnum++;
678	*p1 = 0;
679	cbp = p2;
680
681	return(p1);
682	}
683	ecmp(a, b, count)
684	char a, b;
685	{
686	while(count--)
687	if(a++ != b++) return(0);
688	return(1);
689	}
690
691	arout()
692	{
693	register char *p1;
694	FILE *fi;
695	char c;
696	int t;
697
698	aptr = abuf - 1;
699	while(*++aptr) {
700	if((*aptr)->command == ACOM) {
701	for(p1 = (aptr)->re1; p1; )
702	putc(*p1++, stdout);
703	putc('\n', stdout);
704	} else {
705	if((fi = fopen((*aptr)->re1, "r")) == NULL)
706	continue;
707	while((t = getc(fi)) != EOF) {
708	c = t;
709	putc(c, stdout);
710	}
711	fclose(fi);
712	}
713	}
714	aptr = abuf;
715	*aptr = 0;
716	}
717