[unix-history] / usr / src / old / sed / sed0.c

/*	sed0.c	4.2	85/06/19	*/

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

struct label	*labtab = ltab;
char	CGMES[]	= "command garbled: %s\n";
char	TMMES[]	= "Too much text: %s\n";
char	LTL[]	= "Label too long: %s\n";
char	AD0MES[]	= "No addresses allowed: %s\n";
char	AD1MES[]	= "Only one address allowed: %s\n";
char	bittab[]  = {
		1,
		2,
		4,
		8,
		16,
		32,
		64,
		128
	};

main(argc, argv)
char	*argv[];
{

	eargc = argc;
	eargv = argv;

	badp = &bad;
	aptr = abuf;
	lab = labtab + 1;	/* 0 reserved for end-pointer */
	rep = ptrspace;
	rep->ad1 = respace;
	lbend = &linebuf[LBSIZE];
	hend = &holdsp[LBSIZE];
	lcomend = &genbuf[71];
	ptrend = &ptrspace[PTRSIZE];
	reend = &respace[RESIZE];
	labend = &labtab[LABSIZE];
	lnum = 0;
	pending = 0;
	depth = 0;
	spend = linebuf;
	hspend = holdsp;
	fcode[0] = stdout;
	nfiles = 1;

	if(eargc == 1)
		exit(0);


	while (--eargc > 0 && (++eargv)[0][0] == '-')
		switch (eargv[0][1]) {

		case 'n':
			nflag++;
			continue;

		case 'f':
			if(eargc-- <= 0)	exit(2);

			if((fin = fopen(*++eargv, "r")) == NULL) {
				fprintf(stderr, "Cannot open pattern-file: %s\n", *eargv);
				exit(2);
			}

			fcomp();
			fclose(fin);
			continue;

		case 'e':
			eflag++;
			fcomp();
			eflag = 0;
			continue;

		case 'g':
			gflag++;
			continue;

		default:
			fprintf(stdout, "Unknown flag: %c\n", eargv[0][1]);
			continue;
		}


	if(compfl == 0) {
		eargv--;
		eargc++;
		eflag++;
		fcomp();
		eargv++;
		eargc--;
		eflag = 0;
	}

	if(depth) {
		fprintf(stderr, "Too many {'s");
		exit(2);
	}

	labtab->address = rep;

	dechain();

/*	abort();	/*DEBUG*/

	if(eargc <= 0)
		execute((char *)NULL);
	else while(--eargc >= 0) {
		execute(*eargv++);
	}
	fclose(stdout);
	exit(0);
}
fcomp()
{

	register char	*p, *op, *tp;
	char	*address();
	union reptr	*pt, *pt1;
	int	i;
	struct label	*lpt;

	compfl = 1;
	op = lastre;

	if(rline(linebuf) < 0)	return;
	if(*linebuf == '#') {
		if(linebuf[1] == 'n')
			nflag = 1;
	}
	else {
		cp = linebuf;
		goto comploop;
	}

	for(;;) {
		if(rline(linebuf) < 0)	break;

		cp = linebuf;

comploop:
/*	fprintf(stdout, "cp: %s\n", cp);	/*DEBUG*/
		while(*cp == ' ' || *cp == '\t')	cp++;
		if(*cp == '\0' || *cp == '#')		continue;
		if(*cp == ';') {
			cp++;
			goto comploop;
		}

		p = address(rep->ad1);
		if(p == badp) {
			fprintf(stderr, CGMES, linebuf);
			exit(2);
		}

		if(p == rep->ad1) {
			if(op)
				rep->ad1 = op;
			else {
				fprintf(stderr, "First RE may not be null\n");
				exit(2);
			}
		} else if(p == 0) {
			p = rep->ad1;
			rep->ad1 = 0;
		} else {
			op = rep->ad1;
			if(*cp == ',' || *cp == ';') {
				cp++;
				if((rep->ad2 = p) > reend) {
					fprintf(stderr, TMMES, linebuf);
					exit(2);
				}
				p = address(rep->ad2);
				if(p == badp || p == 0) {
					fprintf(stderr, CGMES, linebuf);
					exit(2);
				}
				if(p == rep->ad2)
					rep->ad2 = op;
				else
					op = rep->ad2;

			} else
				rep->ad2 = 0;
		}

		if(p > reend) {
			fprintf(stderr, "Too much text: %s\n", linebuf);
			exit(2);
		}

		while(*cp == ' ' || *cp == '\t')	cp++;

swit:
		switch(*cp++) {

			default:
				fprintf(stderr, "Unrecognized command: %s\n", linebuf);
				exit(2);

			case '!':
				rep->negfl = 1;
				goto swit;

			case '{':
				rep->command = BCOM;
				rep->negfl = !(rep->negfl);
				cmpend[depth++] = &rep->lb1;
				if(++rep >= ptrend) {
					fprintf(stderr, "Too many commands: %s\n", linebuf);
					exit(2);
				}
				rep->ad1 = p;
				if(*cp == '\0')	continue;

				goto comploop;

			case '}':
				if(rep->ad1) {
					fprintf(stderr, AD0MES, linebuf);
					exit(2);
				}

				if(--depth < 0) {
					fprintf(stderr, "Too many }'s\n");
					exit(2);
				}
				*cmpend[depth] = rep;

				rep->ad1 = p;
				continue;

			case '=':
				rep->command = EQCOM;
				if(rep->ad2) {
					fprintf(stderr, AD1MES, linebuf);
					exit(2);
				}
				break;

			case ':':
				if(rep->ad1) {
					fprintf(stderr, AD0MES, linebuf);
					exit(2);
				}

				while(*cp++ == ' ');
				cp--;


				tp = lab->asc;
				while((*tp++ = *cp++))
					if(tp >= &(lab->asc[8])) {
						fprintf(stderr, LTL, linebuf);
						exit(2);
					}
				*--tp = '\0';

				if(lpt = search(lab)) {
					if(lpt->address) {
						fprintf(stderr, "Duplicate labels: %s\n", linebuf);
						exit(2);
					}
				} else {
					lab->chain = 0;
					lpt = lab;
					if(++lab >= labend) {
						fprintf(stderr, "Too many labels: %s\n", linebuf);
						exit(2);
					}
				}
				lpt->address = rep;
				rep->ad1 = p;

				continue;

			case 'a':
				rep->command = ACOM;
				if(rep->ad2) {
					fprintf(stderr, AD1MES, linebuf);
					exit(2);
				}
				if(*cp == '\\')	cp++;
				if(*cp++ != '\n') {
					fprintf(stderr, CGMES, linebuf);
					exit(2);
				}
				rep->re1 = p;
				p = text(rep->re1);
				break;
			case 'c':
				rep->command = CCOM;
				if(*cp == '\\')	cp++;
				if(*cp++ != ('\n')) {
					fprintf(stderr, CGMES, linebuf);
					exit(2);
				}
				rep->re1 = p;
				p = text(rep->re1);
				break;
			case 'i':
				rep->command = ICOM;
				if(rep->ad2) {
					fprintf(stderr, AD1MES, linebuf);
					exit(2);
				}
				if(*cp == '\\')	cp++;
				if(*cp++ != ('\n')) {
					fprintf(stderr, CGMES, linebuf);
					exit(2);
				}
				rep->re1 = p;
				p = text(rep->re1);
				break;

			case 'g':
				rep->command = GCOM;
				break;

			case 'G':
				rep->command = CGCOM;
				break;

			case 'h':
				rep->command = HCOM;
				break;

			case 'H':
				rep->command = CHCOM;
				break;

			case 't':
				rep->command = TCOM;
				goto jtcommon;

			case 'b':
				rep->command = BCOM;
jtcommon:
				while(*cp++ == ' ');
				cp--;

				if(*cp == '\0') {
					if(pt = labtab->chain) {
						while(pt1 = pt->lb1)
							pt = pt1;
						pt->lb1 = rep;
					} else
						labtab->chain = rep;
					break;
				}
				tp = lab->asc;
				while((*tp++ = *cp++))
					if(tp >= &(lab->asc[8])) {
						fprintf(stderr, LTL, linebuf);
						exit(2);
					}
				cp--;
				*--tp = '\0';

				if(lpt = search(lab)) {
					if(lpt->address) {
						rep->lb1 = lpt->address;
					} else {
						pt = lpt->chain;
						while(pt1 = pt->lb1)
							pt = pt1;
						pt->lb1 = rep;
					}
				} else {
					lab->chain = rep;
					lab->address = 0;
					if(++lab >= labend) {
						fprintf(stderr, "Too many labels: %s\n", linebuf);
						exit(2);
					}
				}
				break;

			case 'n':
				rep->command = NCOM;
				break;

			case 'N':
				rep->command = CNCOM;
				break;

			case 'p':
				rep->command = PCOM;
				break;

			case 'P':
				rep->command = CPCOM;
				break;

			case 'r':
				rep->command = RCOM;
				if(rep->ad2) {
					fprintf(stderr, AD1MES, linebuf);
					exit(2);
				}
				if(*cp++ != ' ') {
					fprintf(stderr, CGMES, linebuf);
					exit(2);
				}
				rep->re1 = p;
				p = text(rep->re1);
				break;

			case 'd':
				rep->command = DCOM;
				break;

			case 'D':
				rep->command = CDCOM;
				rep->lb1 = ptrspace;
				break;

			case 'q':
				rep->command = QCOM;
				if(rep->ad2) {
					fprintf(stderr, AD1MES, linebuf);
					exit(2);
				}
				break;

			case 'l':
				rep->command = LCOM;
				break;

			case 's':
				rep->command = SCOM;
				seof = *cp++;
				rep->re1 = p;
				p = compile(rep->re1);
				if(p == badp) {
					fprintf(stderr, CGMES, linebuf);
					exit(2);
				}
				if(p == rep->re1) {
					if(op)
					    rep->re1 = op;
					else {
					    fprintf(stderr, 
						"First RE may not be null\n");
					    exit(2);
					}
				} else {
					op = rep->re1;
				}

				if((rep->rhs = p) > reend) {
					fprintf(stderr, TMMES, linebuf);
					exit(2);
				}

				if((p = compsub(rep->rhs)) == badp) {
					fprintf(stderr, CGMES, linebuf);
					exit(2);
				}
				if(*cp == 'g') {
					cp++;
					rep->gfl++;
				} else if(gflag)
					rep->gfl++;

				if(*cp == 'p') {
					cp++;
					rep->pfl = 1;
				}

				if(*cp == 'P') {
					cp++;
					rep->pfl = 2;
				}

				if(*cp == 'w') {
					cp++;
					if(*cp++ !=  ' ') {
						fprintf(stderr, CGMES, linebuf);
						exit(2);
					}
					if(nfiles >= 10) {
						fprintf(stderr, "Too many files in w commands\n");
						exit(2);
					}

					text(fname[nfiles]);
					for(i = nfiles - 1; i >= 0; i--)
						if(cmp(fname[nfiles],fname[i]) == 0) {
							rep->fcode = fcode[i];
							goto done;
						}
					if((rep->fcode = fopen(fname[nfiles], "w")) == NULL) {
						fprintf(stderr, "cannot open %s\n", fname[nfiles]);
						exit(2);
					}
					fcode[nfiles++] = rep->fcode;
				}
				break;

			case 'w':
				rep->command = WCOM;
				if(*cp++ != ' ') {
					fprintf(stderr, CGMES, linebuf);
					exit(2);
				}
				if(nfiles >= 10){
					fprintf(stderr, "Too many files in w commands\n");
					exit(2);
				}

				text(fname[nfiles]);
				for(i = nfiles - 1; i >= 0; i--)
					if(cmp(fname[nfiles], fname[i]) == 0) {
						rep->fcode = fcode[i];
						goto done;
					}

				if((rep->fcode = fopen(fname[nfiles], "w")) == NULL) {
					fprintf(stderr, "Cannot create %s\n", fname[nfiles]);
					exit(2);
				}
				fcode[nfiles++] = rep->fcode;
				break;

			case 'x':
				rep->command = XCOM;
				break;

			case 'y':
				rep->command = YCOM;
				seof = *cp++;
				rep->re1 = p;
				p = ycomp(rep->re1);
				if(p == badp) {
					fprintf(stderr, CGMES, linebuf);
					exit(2);
				}
				if(p > reend) {
					fprintf(stderr, TMMES, linebuf);
					exit(2);
				}
				break;

		}
done:
		if(++rep >= ptrend) {
			fprintf(stderr, "Too many commands, last: %s\n", linebuf);
			exit(2);
		}

		rep->ad1 = p;

		if(*cp++ != '\0') {
			if(cp[-1] == ';')
				goto comploop;
			fprintf(stderr, CGMES, linebuf);
			exit(2);
		}

	}
	rep->command = 0;
	lastre = op;
}
char	*compsub(rhsbuf)
char	*rhsbuf;
{
	register char	*p, *q;

	p = rhsbuf;
	q = cp;
	for(;;) {
		if((*p = *q++) == '\\') {
			*p = *q++;
			if(*p > numbra + '0' && *p <= '9')
				return(badp);
			*p++ |= 0200;
			continue;
		}
		if(*p == seof) {
			*p++ = '\0';
			cp = q;
			return(p);
		}
		if(*p++ == '\0') {
			return(badp);
		}

	}
}

char *compile(expbuf)
char	*expbuf;
{
	register c;
	register char *ep, *sp;
	char	neg;
	char *lastep, *cstart;
	int cclcnt;
	int	closed;
	char	bracket[NBRA], *bracketp;

	if(*cp == seof) {
		cp++;
		return(expbuf);
	}

	ep = expbuf;
	lastep = 0;
	bracketp = bracket;
	closed = numbra = 0;
	sp = cp;
	if (*sp == '^') {
		*ep++ = 1;
		sp++;
	} else {
		*ep++ = 0;
	}
	for (;;) {
		if (ep >= &expbuf[ESIZE]) {
			cp = sp;
			return(badp);
		}
		if((c = *sp++) == seof) {
			if(bracketp != bracket) {
				cp = sp;
				return(badp);
			}
			cp = sp;
			*ep++ = CEOF;
			return(ep);
		}
		if(c != '*')
			lastep = ep;
		switch (c) {

		case '\\':
			if((c = *sp++) == '(') {
				if(numbra >= NBRA) {
					cp = sp;
					return(badp);
				}
				*bracketp++ = numbra;
				*ep++ = CBRA;
				*ep++ = numbra++;
				continue;
			}
			if(c == ')') {
				if(bracketp <= bracket) {
					cp = sp;
					return(badp);
				}
				*ep++ = CKET;
				*ep++ = *--bracketp;
				closed++;
				continue;
			}

			if(c >= '1' && c <= '9') {
				if((c -= '1') >= closed)
					return(badp);
	
				*ep++ = CBACK;
				*ep++ = c;
				continue;
			}
			if(c == '\n') {
				cp = sp;
				return(badp);
			}
			if(c == 'n') {
				c = '\n';
			}
			goto defchar;

		case '\0':
			continue;
		case '\n':
			cp = sp;
			return(badp);

		case '.':
			*ep++ = CDOT;
			continue;

		case '*':
			if (lastep == 0)
				goto defchar;
			if(*lastep == CKET) {
				cp = sp;
				return(badp);
			}
			*lastep |= STAR;
			continue;

		case '$':
			if (*sp != seof)
				goto defchar;
			*ep++ = CDOL;
			continue;

		case '[':
			if(&ep[17] >= &expbuf[ESIZE]) {
				fprintf(stderr, "RE too long: %s\n", linebuf);
				exit(2);
			}

			*ep++ = CCL;

			neg = 0;
			if((c = *sp++) == '^') {
				neg = 1;
				c = *sp++;
			}

			cstart = sp;
			do {
				if(c == '\0') {
					fprintf(stderr, CGMES, linebuf);
					exit(2);
				}
				if (c=='-' && sp>cstart && *sp!=']') {
					for (c = sp[-2]; c<*sp; c++)
						ep[c>>3] |= bittab[c&07];
				}
				if(c == '\\') {
					switch(c = *sp++) {
						case 'n':
							c = '\n';
							break;
					}
				}

				ep[c >> 3] |= bittab[c & 07];
			} while((c = *sp++) != ']');

			if(neg)
				for(cclcnt = 0; cclcnt < 16; cclcnt++)
					ep[cclcnt] ^= -1;
			ep[0] &= 0376;

			ep += 16;

			continue;

		defchar:
		default:
			*ep++ = CCHR;
			*ep++ = c;
		}
	}
}
rline(lbuf)
char	*lbuf;
{
	register char	*p, *q;
	register	t;
	static char	*saveq;

	p = lbuf - 1;

	if(eflag) {
		if(eflag > 0) {
			eflag = -1;
			if(eargc-- <= 0)
				exit(2);
			q = *++eargv;
			while(*++p = *q++) {
				if(*p == '\\') {
					if((*++p = *q++) == '\0') {
						saveq = 0;
						return(-1);
					} else
						continue;
				}
				if(*p == '\n') {
					*p = '\0';
					saveq = q;
					return(1);
				}
			}
			saveq = 0;
			return(1);
		}
		if((q = saveq) == 0)	return(-1);

		while(*++p = *q++) {
			if(*p == '\\') {
				if((*++p = *q++) == '0') {
					saveq = 0;
					return(-1);
				} else
					continue;
			}
			if(*p == '\n') {
				*p = '\0';
				saveq = q;
				return(1);
			}
		}
		saveq = 0;
		return(1);
	}

	while((t = getc(fin)) != EOF) {
		*++p = t;
		if(*p == '\\') {
			t = getc(fin);
			*++p = t;
		}
		else if(*p == '\n') {
			*p = '\0';
			return(1);
		}
	}
	*++p = '\0';
	return(-1);
}

char	*address(expbuf)
char	*expbuf;
{
	register char	*rcp;
	long	lno;

	if(*cp == '$') {
		cp++;
		*expbuf++ = CEND;
		*expbuf++ = CEOF;
		return(expbuf);
	}

	if(*cp == '/') {
		seof = '/';
		cp++;
		return(compile(expbuf));
	}

	rcp = cp;
	lno = 0;

	while(*rcp >= '0' && *rcp <= '9')
		lno = lno*10 + *rcp++ - '0';

	if(rcp > cp) {
		*expbuf++ = CLNUM;
		*expbuf++ = nlno;
		tlno[nlno++] = lno;
		if(nlno >= NLINES) {
			fprintf(stderr, "Too many line numbers\n");
			exit(2);
		}
		*expbuf++ = CEOF;
		cp = rcp;
		return(expbuf);
	}
	return(0);
}
cmp(a, b)
char	*a,*b;
{
	register char	*ra, *rb;

	ra = a - 1;
	rb = b - 1;

	while(*++ra == *++rb)
		if(*ra == '\0')	return(0);
	return(1);
}

char	*text(textbuf)
char	*textbuf;
{
	register char	*p, *q;

	p = textbuf;
	q = cp;
	while(*q == '\t' || *q == ' ')	q++;
	for(;;) {

		if((*p = *q++) == '\\')
			*p = *q++;
		if(*p == '\0') {
			cp = --q;
			return(++p);
		}
		if(*p == '\n') {
			while(*q == '\t' || *q == ' ')	q++;
		}
		p++;
	}
}


struct label	*search(ptr)
struct label	*ptr;
{
	struct label	*rp;

	rp = labtab;
	while(rp < ptr) {
		if(cmp(rp->asc, ptr->asc) == 0)
			return(rp);
		rp++;
	}

	return(0);
}


dechain()
{
	struct label	*lptr;
	union reptr	*rptr, *trptr;

	for(lptr = labtab; lptr < lab; lptr++) {

		if(lptr->address == 0) {
			fprintf(stderr, "Undefined label: %s\n", lptr->asc);
			exit(2);
		}

		if(lptr->chain) {
			rptr = lptr->chain;
			while(trptr = rptr->lb1) {
				rptr->lb1 = lptr->address;
				rptr = trptr;
			}
			rptr->lb1 = lptr->address;
		}
	}
}

char *ycomp(expbuf)
char	*expbuf;
{
	register char	c, *ep, *tsp;
	char	*sp;

	ep = expbuf;
	sp = cp;
	for(tsp = cp; *tsp != seof; tsp++) {
		if(*tsp == '\\')
			tsp++;
		if(*tsp == '\n')
			return(badp);
	}
	tsp++;

	while((c = *sp++ & 0177) != seof) {
		if(c == '\\' && *sp == 'n') {
			sp++;
			c = '\n';
		}
		if((ep[c] = *tsp++) == '\\' && *tsp == 'n') {
			ep[c] = '\n';
			tsp++;
		}
		if(ep[c] == seof || ep[c] == '\0')
			return(badp);
	}
	if(*tsp != seof)
		return(badp);
	cp = ++tsp;

	for(c = 0; !(c & 0200); c++)
		if(ep[c] == 0)
			ep[c] = c;

	return(ep + 0200);
}
Commit	Line	Data
a209ee10	1	/* sed0.c 4.2 85/06/19 */
e90a6148 RC	2
	3	#include <stdio.h>
	4	#include "sed.h"
	5
	6	struct label *labtab = ltab;
	7	char CGMES[] = "command garbled: %s\n";
	8	char TMMES[] = "Too much text: %s\n";
	9	char LTL[] = "Label too long: %s\n";
	10	char AD0MES[] = "No addresses allowed: %s\n";
	11	char AD1MES[] = "Only one address allowed: %s\n";
	12	char bittab[] = {
	13	1,
	14	2,
	15	4,
	16	8,
	17	16,
	18	32,
	19	64,
	20	128
	21	};
	22
	23	main(argc, argv)
	24	char *argv[];
	25	{
	26
	27	eargc = argc;
	28	eargv = argv;
	29
	30	badp = &bad;
	31	aptr = abuf;
	32	lab = labtab + 1; /* 0 reserved for end-pointer */
	33	rep = ptrspace;
	34	rep->ad1 = respace;
	35	lbend = &linebuf[LBSIZE];
	36	hend = &holdsp[LBSIZE];
	37	lcomend = &genbuf[71];
	38	ptrend = &ptrspace[PTRSIZE];
	39	reend = &respace[RESIZE];
	40	labend = &labtab[LABSIZE];
	41	lnum = 0;
	42	pending = 0;
	43	depth = 0;
	44	spend = linebuf;
	45	hspend = holdsp;
	46	fcode[0] = stdout;
	47	nfiles = 1;
	48
	49	if(eargc == 1)
	50	exit(0);
	51
	52
	53	while (--eargc > 0 && (++eargv)[0][0] == '-')
	54	switch (eargv[0][1]) {
	55
	56	case 'n':
	57	nflag++;
	58	continue;
	59
	60	case 'f':
	61	if(eargc-- <= 0) exit(2);
	62
	63	if((fin = fopen(*++eargv, "r")) == NULL) {
	64	fprintf(stderr, "Cannot open pattern-file: %s\n", *eargv);
	65	exit(2);
66	}
67
68	fcomp();
69	fclose(fin);
70	continue;
71
72	case 'e':
73	eflag++;
74	fcomp();
75	eflag = 0;
76	continue;
77
78	case 'g':
79	gflag++;
80	continue;
81
82	default:
83	fprintf(stdout, "Unknown flag: %c\n", eargv[0][1]);
84	continue;
85	}
86
87
88	if(compfl == 0) {
89	eargv--;
90	eargc++;
91	eflag++;
92	fcomp();
93	eargv++;
94	eargc--;
95	eflag = 0;
96	}
97
98	if(depth) {
99	fprintf(stderr, "Too many {'s");
100	exit(2);
101	}
102
103	labtab->address = rep;
104
105	dechain();
106
107	/* abort(); /DEBUG/
108
109	if(eargc <= 0)
110	execute((char *)NULL);
111	else while(--eargc >= 0) {
112	execute(*eargv++);
113	}
114	fclose(stdout);
115	exit(0);
116	}
117	fcomp()
118	{
119
120	register char p, op, *tp;
121	char *address();
122	union reptr pt, pt1;
123	int i;
124	struct label *lpt;
125
126	compfl = 1;
127	op = lastre;
128
129	if(rline(linebuf) < 0) return;
130	if(*linebuf == '#') {
131	if(linebuf[1] == 'n')
132	nflag = 1;
133	}
134	else {
135	cp = linebuf;
136	goto comploop;
137	}
138
139	for(;;) {
140	if(rline(linebuf) < 0) break;
141
142	cp = linebuf;
143
144	comploop:
145	/* fprintf(stdout, "cp: %s\n", cp); /DEBUG/
146	while(cp == ' ' \|\| cp == '\t') cp++;
147	if(cp == '\0' \|\| cp == '#') continue;
148	if(*cp == ';') {
149	cp++;
150	goto comploop;
151	}
152
153	p = address(rep->ad1);
154	if(p == badp) {
155	fprintf(stderr, CGMES, linebuf);
156	exit(2);
157	}
158
159	if(p == rep->ad1) {
160	if(op)
161	rep->ad1 = op;
162	else {
163	fprintf(stderr, "First RE may not be null\n");
164	exit(2);
165	}
166	} else if(p == 0) {
167	p = rep->ad1;
168	rep->ad1 = 0;
169	} else {
170	op = rep->ad1;
171	if(cp == ',' \|\| cp == ';') {
172	cp++;
173	if((rep->ad2 = p) > reend) {
174	fprintf(stderr, TMMES, linebuf);
175	exit(2);
176	}
177	p = address(rep->ad2);
178	if(p == badp \|\| p == 0) {
179	fprintf(stderr, CGMES, linebuf);
180	exit(2);
181	}
182	if(p == rep->ad2)
183	rep->ad2 = op;
184	else
185	op = rep->ad2;
186
187	} else
188	rep->ad2 = 0;
189	}
190
191	if(p > reend) {
192	fprintf(stderr, "Too much text: %s\n", linebuf);
193	exit(2);
194	}
195
196	while(cp == ' ' \|\| cp == '\t') cp++;
197
198	swit:
199	switch(*cp++) {
200
201	default:
202	fprintf(stderr, "Unrecognized command: %s\n", linebuf);
203	exit(2);
204
205	case '!':
206	rep->negfl = 1;
207	goto swit;
208
209	case '{':
210	rep->command = BCOM;
211	rep->negfl = !(rep->negfl);
212	cmpend[depth++] = &rep->lb1;
213	if(++rep >= ptrend) {
214	fprintf(stderr, "Too many commands: %s\n", linebuf);
215	exit(2);
216	}
217	rep->ad1 = p;
218	if(*cp == '\0') continue;
219
220	goto comploop;
221
222	case '}':
223	if(rep->ad1) {
224	fprintf(stderr, AD0MES, linebuf);
225	exit(2);
226	}
227
228	if(--depth < 0) {
229	fprintf(stderr, "Too many }'s\n");
230	exit(2);
231	}
232	*cmpend[depth] = rep;
233
234	rep->ad1 = p;
235	continue;
236
237	case '=':
238	rep->command = EQCOM;
239	if(rep->ad2) {
240	fprintf(stderr, AD1MES, linebuf);
241	exit(2);
242	}
243	break;
244
245	case ':':
246	if(rep->ad1) {
247	fprintf(stderr, AD0MES, linebuf);
248	exit(2);
249	}
250
251	while(*cp++ == ' ');
252	cp--;
253
254
255	tp = lab->asc;
256	while((tp++ = cp++))
257	if(tp >= &(lab->asc[8])) {
258	fprintf(stderr, LTL, linebuf);
259	exit(2);
260	}
261	*--tp = '\0';
262
263	if(lpt = search(lab)) {
264	if(lpt->address) {
265	fprintf(stderr, "Duplicate labels: %s\n", linebuf);
266	exit(2);
267	}
268	} else {
269	lab->chain = 0;
270	lpt = lab;
271	if(++lab >= labend) {
272	fprintf(stderr, "Too many labels: %s\n", linebuf);
273	exit(2);
274	}
275	}
276	lpt->address = rep;
277	rep->ad1 = p;
278
279	continue;
280
281	case 'a':
282	rep->command = ACOM;
283	if(rep->ad2) {
284	fprintf(stderr, AD1MES, linebuf);
285	exit(2);
286	}
287	if(*cp == '\\') cp++;
288	if(*cp++ != '\n') {
289	fprintf(stderr, CGMES, linebuf);
290	exit(2);
291	}
292	rep->re1 = p;
293	p = text(rep->re1);
294	break;
295	case 'c':
296	rep->command = CCOM;
297	if(*cp == '\\') cp++;
298	if(*cp++ != ('\n')) {
299	fprintf(stderr, CGMES, linebuf);
300	exit(2);
301	}
302	rep->re1 = p;
303	p = text(rep->re1);
304	break;
305	case 'i':
306	rep->command = ICOM;
307	if(rep->ad2) {
308	fprintf(stderr, AD1MES, linebuf);
309	exit(2);
310	}
311	if(*cp == '\\') cp++;
312	if(*cp++ != ('\n')) {
313	fprintf(stderr, CGMES, linebuf);
314	exit(2);
315	}
316	rep->re1 = p;
317	p = text(rep->re1);
318	break;
319
320	case 'g':
321	rep->command = GCOM;
322	break;
323
324	case 'G':
325	rep->command = CGCOM;
326	break;
327
328	case 'h':
329	rep->command = HCOM;
330	break;
331
332	case 'H':
333	rep->command = CHCOM;
334	break;
335
336	case 't':
337	rep->command = TCOM;
338	goto jtcommon;
339
340	case 'b':
341	rep->command = BCOM;
342	jtcommon:
343	while(*cp++ == ' ');
344	cp--;
345
346	if(*cp == '\0') {
347	if(pt = labtab->chain) {
348	while(pt1 = pt->lb1)
349	pt = pt1;
350	pt->lb1 = rep;
351	} else
352	labtab->chain = rep;
353	break;
354	}
355	tp = lab->asc;
356	while((tp++ = cp++))
357	if(tp >= &(lab->asc[8])) {
358	fprintf(stderr, LTL, linebuf);
359	exit(2);
360	}
361	cp--;
362	*--tp = '\0';
363
364	if(lpt = search(lab)) {
365	if(lpt->address) {
366	rep->lb1 = lpt->address;
367	} else {
368	pt = lpt->chain;
369	while(pt1 = pt->lb1)
370	pt = pt1;
371	pt->lb1 = rep;
372	}
373	} else {
374	lab->chain = rep;
375	lab->address = 0;
376	if(++lab >= labend) {
377	fprintf(stderr, "Too many labels: %s\n", linebuf);
378	exit(2);
379	}
380	}
381	break;
382
383	case 'n':
384	rep->command = NCOM;
385	break;
386
387	case 'N':
388	rep->command = CNCOM;
389	break;
390
391	case 'p':
392	rep->command = PCOM;
393	break;
394
395	case 'P':
396	rep->command = CPCOM;
397	break;
398
399	case 'r':
400	rep->command = RCOM;
401	if(rep->ad2) {
402	fprintf(stderr, AD1MES, linebuf);
403	exit(2);
404	}
405	if(*cp++ != ' ') {
406	fprintf(stderr, CGMES, linebuf);
407	exit(2);
408	}
409	rep->re1 = p;
410	p = text(rep->re1);
411	break;
412
413	case 'd':
414	rep->command = DCOM;
415	break;
416
417	case 'D':
418	rep->command = CDCOM;
419	rep->lb1 = ptrspace;
420	break;
421
422	case 'q':
423	rep->command = QCOM;
424	if(rep->ad2) {
425	fprintf(stderr, AD1MES, linebuf);
426	exit(2);
427	}
428	break;
429
430	case 'l':
431	rep->command = LCOM;
432	break;
433
434	case 's':
435	rep->command = SCOM;
436	seof = *cp++;
437	rep->re1 = p;
438	p = compile(rep->re1);
439	if(p == badp) {
440	fprintf(stderr, CGMES, linebuf);
441	exit(2);
442	}
443	if(p == rep->re1) {
a209ee10 JB	444	if(op)
	445	rep->re1 = op;
	446	else {
	447	fprintf(stderr,
	448	"First RE may not be null\n");
	449	exit(2);
	450	}
e90a6148 RC	451	} else {
	452	op = rep->re1;
	453	}
	454
	455	if((rep->rhs = p) > reend) {
	456	fprintf(stderr, TMMES, linebuf);
	457	exit(2);
	458	}
	459
	460	if((p = compsub(rep->rhs)) == badp) {
	461	fprintf(stderr, CGMES, linebuf);
	462	exit(2);
	463	}
	464	if(*cp == 'g') {
	465	cp++;
	466	rep->gfl++;
	467	} else if(gflag)
	468	rep->gfl++;
	469
	470	if(*cp == 'p') {
	471	cp++;
	472	rep->pfl = 1;
	473	}
	474
	475	if(*cp == 'P') {
	476	cp++;
	477	rep->pfl = 2;
	478	}
	479
	480	if(*cp == 'w') {
	481	cp++;
	482	if(*cp++ != ' ') {
	483	fprintf(stderr, CGMES, linebuf);
	484	exit(2);
	485	}
	486	if(nfiles >= 10) {
	487	fprintf(stderr, "Too many files in w commands\n");
	488	exit(2);
	489	}
	490
	491	text(fname[nfiles]);
	492	for(i = nfiles - 1; i >= 0; i--)
	493	if(cmp(fname[nfiles],fname[i]) == 0) {
	494	rep->fcode = fcode[i];
	495	goto done;
	496	}
	497	if((rep->fcode = fopen(fname[nfiles], "w")) == NULL) {
	498	fprintf(stderr, "cannot open %s\n", fname[nfiles]);
	499	exit(2);
	500	}
	501	fcode[nfiles++] = rep->fcode;
	502	}
	503	break;
	504
	505	case 'w':
	506	rep->command = WCOM;
	507	if(*cp++ != ' ') {
	508	fprintf(stderr, CGMES, linebuf);
	509	exit(2);
	510	}
	511	if(nfiles >= 10){
	512	fprintf(stderr, "Too many files in w commands\n");
	513	exit(2);
	514	}
515
516	text(fname[nfiles]);
517	for(i = nfiles - 1; i >= 0; i--)
518	if(cmp(fname[nfiles], fname[i]) == 0) {
519	rep->fcode = fcode[i];
520	goto done;
521	}
522
523	if((rep->fcode = fopen(fname[nfiles], "w")) == NULL) {
524	fprintf(stderr, "Cannot create %s\n", fname[nfiles]);
525	exit(2);
526	}
527	fcode[nfiles++] = rep->fcode;
528	break;
529
530	case 'x':
531	rep->command = XCOM;
532	break;
533
534	case 'y':
535	rep->command = YCOM;
536	seof = *cp++;
537	rep->re1 = p;
538	p = ycomp(rep->re1);
539	if(p == badp) {
540	fprintf(stderr, CGMES, linebuf);
541	exit(2);
542	}
543	if(p > reend) {
544	fprintf(stderr, TMMES, linebuf);
545	exit(2);
546	}
547	break;
548
549	}
550	done:
551	if(++rep >= ptrend) {
552	fprintf(stderr, "Too many commands, last: %s\n", linebuf);
553	exit(2);
554	}
555
556	rep->ad1 = p;
557
558	if(*cp++ != '\0') {
559	if(cp[-1] == ';')
560	goto comploop;
561	fprintf(stderr, CGMES, linebuf);
562	exit(2);
563	}
564
565	}
566	rep->command = 0;
567	lastre = op;
568	}
569	char *compsub(rhsbuf)
570	char *rhsbuf;
571	{
572	register char p, q;
573
574	p = rhsbuf;
575	q = cp;
576	for(;;) {
577	if((p = q++) == '\\') {
578	p = q++;
579	if(p > numbra + '0' && p <= '9')
580	return(badp);
581	*p++ \|= 0200;
582	continue;
583	}
584	if(*p == seof) {
585	*p++ = '\0';
586	cp = q;
587	return(p);
588	}
589	if(*p++ == '\0') {
590	return(badp);
591	}
592
593	}
594	}
595
596	char *compile(expbuf)
597	char *expbuf;
598	{
599	register c;
600	register char ep, sp;
601	char neg;
602	char lastep, cstart;
603	int cclcnt;
604	int closed;
605	char bracket[NBRA], *bracketp;
606
607	if(*cp == seof) {
608	cp++;
609	return(expbuf);
610	}
611
612	ep = expbuf;
613	lastep = 0;
614	bracketp = bracket;
615	closed = numbra = 0;
616	sp = cp;
617	if (*sp == '^') {
618	*ep++ = 1;
619	sp++;
620	} else {
621	*ep++ = 0;
622	}
623	for (;;) {
624	if (ep >= &expbuf[ESIZE]) {
625	cp = sp;
626	return(badp);
627	}
628	if((c = *sp++) == seof) {
629	if(bracketp != bracket) {
630	cp = sp;
631	return(badp);
632	}
633	cp = sp;
634	*ep++ = CEOF;
635	return(ep);
636	}
637	if(c != '*')
638	lastep = ep;
639	switch (c) {
640
641	case '\\':
642	if((c = *sp++) == '(') {
643	if(numbra >= NBRA) {
644	cp = sp;
645	return(badp);
646	}
647	*bracketp++ = numbra;
648	*ep++ = CBRA;
649	*ep++ = numbra++;
650	continue;
651	}
652	if(c == ')') {
653	if(bracketp <= bracket) {
654	cp = sp;
655	return(badp);
656	}
657	*ep++ = CKET;
658	ep++ = --bracketp;
659	closed++;
660	continue;
661	}
662
663	if(c >= '1' && c <= '9') {
664	if((c -= '1') >= closed)
665	return(badp);
666
667	*ep++ = CBACK;
668	*ep++ = c;
669	continue;
670	}
671	if(c == '\n') {
672	cp = sp;
673	return(badp);
674	}
675	if(c == 'n') {
676	c = '\n';
677	}
678	goto defchar;
679
680	case '\0':
681	continue;
682	case '\n':
683	cp = sp;
684	return(badp);
685
686	case '.':
687	*ep++ = CDOT;
688	continue;
689
690	case '*':
691	if (lastep == 0)
692	goto defchar;
693	if(*lastep == CKET) {
694	cp = sp;
695	return(badp);
696	}
697	*lastep \|= STAR;
698	continue;
699
700	case '$':
701	if (*sp != seof)
702	goto defchar;
703	*ep++ = CDOL;
704	continue;
705
706	case '[':
707	if(&ep[17] >= &expbuf[ESIZE]) {
708	fprintf(stderr, "RE too long: %s\n", linebuf);
709	exit(2);
710	}
711
712	*ep++ = CCL;
713
714	neg = 0;
715	if((c = *sp++) == '^') {
716	neg = 1;
717	c = *sp++;
718	}
719
720	cstart = sp;
721	do {
722	if(c == '\0') {
723	fprintf(stderr, CGMES, linebuf);
724	exit(2);
725	}
726	if (c=='-' && sp>cstart && *sp!=']') {
727	for (c = sp[-2]; c<*sp; c++)
728	ep[c>>3] \|= bittab[c&07];
729	}
730	if(c == '\\') {
731	switch(c = *sp++) {
732	case 'n':
733	c = '\n';
734	break;
735	}
736	}
737
738	ep[c >> 3] \|= bittab[c & 07];
739	} while((c = *sp++) != ']');
740
741	if(neg)
742	for(cclcnt = 0; cclcnt < 16; cclcnt++)
743	ep[cclcnt] ^= -1;
744	ep[0] &= 0376;
745
746	ep += 16;
747
748	continue;
749
750	defchar:
751	default:
752	*ep++ = CCHR;
753	*ep++ = c;
754	}
755	}
756	}
757	rline(lbuf)
758	char *lbuf;
759	{
760	register char p, q;
761	register t;
762	static char *saveq;
763
764	p = lbuf - 1;
765
766	if(eflag) {
767	if(eflag > 0) {
768	eflag = -1;
769	if(eargc-- <= 0)
770	exit(2);
771	q = *++eargv;
772	while(++p = q++) {
773	if(*p == '\\') {
774	if((++p = q++) == '\0') {
775	saveq = 0;
776	return(-1);
777	} else
778	continue;
779	}
780	if(*p == '\n') {
781	*p = '\0';
782	saveq = q;
783	return(1);
784	}
785	}
786	saveq = 0;
787	return(1);
788	}
789	if((q = saveq) == 0) return(-1);
790
791	while(++p = q++) {
792	if(*p == '\\') {
793	if((++p = q++) == '0') {
794	saveq = 0;
795	return(-1);
796	} else
797	continue;
798	}
799	if(*p == '\n') {
800	*p = '\0';
801	saveq = q;
802	return(1);
803	}
804	}
805	saveq = 0;
806	return(1);
807	}
808
809	while((t = getc(fin)) != EOF) {
810	*++p = t;
811	if(*p == '\\') {
812	t = getc(fin);
813	*++p = t;
814	}
815	else if(*p == '\n') {
816	*p = '\0';
817	return(1);
818	}
819	}
820	*++p = '\0';
821	return(-1);
822	}
823
824	char *address(expbuf)
825	char *expbuf;
826	{
827	register char *rcp;
828	long lno;
829
830	if(*cp == '$') {
831	cp++;
832	*expbuf++ = CEND;
833	*expbuf++ = CEOF;
834	return(expbuf);
835	}
836
837	if(*cp == '/') {
838	seof = '/';
839	cp++;
840	return(compile(expbuf));
841	}
842
843	rcp = cp;
844	lno = 0;
845
846	while(rcp >= '0' && rcp <= '9')
847	lno = lno10 + rcp++ - '0';
848
849	if(rcp > cp) {
850	*expbuf++ = CLNUM;
851	*expbuf++ = nlno;
852	tlno[nlno++] = lno;
853	if(nlno >= NLINES) {
854	fprintf(stderr, "Too many line numbers\n");
855	exit(2);
856	}
857	*expbuf++ = CEOF;
858	cp = rcp;
859	return(expbuf);
860	}
861	return(0);
862	}
863	cmp(a, b)
864	char a,b;
865	{
866	register char ra, rb;
867
868	ra = a - 1;
869	rb = b - 1;
870
871	while(++ra == ++rb)
872	if(*ra == '\0') return(0);
873	return(1);
874	}
875
876	char *text(textbuf)
877	char *textbuf;
878	{
879	register char p, q;
880
881	p = textbuf;
882	q = cp;
883	while(q == '\t' \|\| q == ' ') q++;
884	for(;;) {
885
886	if((p = q++) == '\\')
887	p = q++;
888	if(*p == '\0') {
889	cp = --q;
890	return(++p);
891	}
892	if(*p == '\n') {
893	while(q == '\t' \|\| q == ' ') q++;
894	}
895	p++;
896	}
897	}
898
899
900	struct label *search(ptr)
901	struct label *ptr;
902	{
903	struct label *rp;
904
905	rp = labtab;
906	while(rp < ptr) {
907	if(cmp(rp->asc, ptr->asc) == 0)
908	return(rp);
909	rp++;
910	}
911
912	return(0);
913	}
914
915
916	dechain()
917	{
918	struct label *lptr;
919	union reptr rptr, trptr;
920
921	for(lptr = labtab; lptr < lab; lptr++) {
922
923	if(lptr->address == 0) {
924	fprintf(stderr, "Undefined label: %s\n", lptr->asc);
925	exit(2);
926	}
927
928	if(lptr->chain) {
929	rptr = lptr->chain;
930	while(trptr = rptr->lb1) {
931	rptr->lb1 = lptr->address;
932	rptr = trptr;
933	}
934	rptr->lb1 = lptr->address;
935	}
936	}
937	}
938
939	char *ycomp(expbuf)
940	char *expbuf;
941	{
942	register char c, ep, tsp;
943	char *sp;
944
945	ep = expbuf;
946	sp = cp;
947	for(tsp = cp; *tsp != seof; tsp++) {
948	if(*tsp == '\\')
949	tsp++;
950	if(*tsp == '\n')
951	return(badp);
952	}
953	tsp++;
954
955	while((c = *sp++ & 0177) != seof) {
956	if(c == '\\' && *sp == 'n') {
957	sp++;
958	c = '\n';
959	}
960	if((ep[c] = tsp++) == '\\' && tsp == 'n') {
961	ep[c] = '\n';
962	tsp++;
963	}
964	if(ep[c] == seof \|\| ep[c] == '\0')
965	return(badp);
966	}
967	if(*tsp != seof)
968	return(badp);
969	cp = ++tsp;
970
971	for(c = 0; !(c & 0200); c++)
972	if(ep[c] == 0)
973	ep[c] = c;
974
975	return(ep + 0200);
976	}