[unix-history] / usr / src / cmd / expr.y

/* Yacc productions for "expr" command: */

%token OR AND ADD SUBT MULT DIV REM EQ GT GEQ LT LEQ NEQ
%token A_STRING SUBSTR LENGTH INDEX NOARG MATCH

/* operators listed below in increasing precedence: */
%left OR
%left AND
%left EQ LT GT GEQ LEQ NEQ
%left ADD SUBT
%left MULT DIV REM
%left MCH
%left MATCH
%left SUBSTR
%left LENGTH INDEX
%%

/* a single `expression' is evaluated and printed: */

expression:	expr NOARG = {
			printf("%s\n", $1);
			exit((!strcmp($1,"0")||!strcmp($1,"\0"))? 1: 0);
			}
	;


expr:	'(' expr ')' = { $$ = $2; }
	| expr OR expr   = { $$ = conj(OR, $1, $3); }
	| expr AND expr   = { $$ = conj(AND, $1, $3); }
	| expr EQ expr   = { $$ = rel(EQ, $1, $3); }
	| expr GT expr   = { $$ = rel(GT, $1, $3); }
	| expr GEQ expr   = { $$ = rel(GEQ, $1, $3); }
	| expr LT expr   = { $$ = rel(LT, $1, $3); }
	| expr LEQ expr   = { $$ = rel(LEQ, $1, $3); }
	| expr NEQ expr   = { $$ = rel(NEQ, $1, $3); }
	| expr ADD expr   = { $$ = arith(ADD, $1, $3); }
	| expr SUBT expr   = { $$ = arith(SUBT, $1, $3); }
	| expr MULT expr   = { $$ = arith(MULT, $1, $3); }
	| expr DIV expr   = { $$ = arith(DIV, $1, $3); }
	| expr REM expr   = { $$ = arith(REM, $1, $3); }
	| expr MCH expr	 = { $$ = match($1, $3); }
	| MATCH expr expr = { $$ = match($2, $3); }
	| SUBSTR expr expr expr = { $$ = substr($2, $3, $4); }
	| LENGTH expr       = { $$ = length($2); }
	| INDEX expr expr = { $$ = index($2, $3); }
	| A_STRING
	;
%%
/*	expression command */
#include <stdio.h>
#define ESIZE	256
#define error(c)	errxx(c)
#define EQL(x,y) !strcmp(x,y)
long atol();
char	**Av;
int	Ac;
int	Argi;

char Mstring[1][128];
char *malloc();
extern int nbra;

main(argc, argv) char **argv; {
	Ac = argc;
	Argi = 1;
	Av = argv;
	yyparse();
}

char *operators[] = { "|", "&", "+", "-", "*", "/", "%", ":",
	"=", "==", "<", "<=", ">", ">=", "!=",
	"match", "substr", "length", "index", "\0" };
int op[] = { OR, AND, ADD,  SUBT, MULT, DIV, REM, MCH,
	EQ, EQ, LT, LEQ, GT, GEQ, NEQ,
	MATCH, SUBSTR, LENGTH, INDEX };
yylex() {
	register char *p;
	register i;

	if(Argi >= Ac) return NOARG;

	p = Av[Argi++];

	if(*p == '(' || *p == ')')
		return (int)*p;
	for(i = 0; *operators[i]; ++i)
		if(EQL(operators[i], p))
			return op[i];

	yylval = p;
	return A_STRING;
}

char *rel(op, r1, r2) register char *r1, *r2; {
	register i;

	if(ematch(r1, "-*[0-9]*$") && ematch(r2, "[0-9]*$"))
		i = atol(r1) - atol(r2);
	else
		i = strcmp(r1, r2);
	switch(op) {
	case EQ: i = i==0; break;
	case GT: i = i>0; break;
	case GEQ: i = i>=0; break;
	case LT: i = i<0; break;
	case LEQ: i = i>=0; break;
	case NEQ: i = i!=0; break;
	}
	return i? "1": "0";
}

char *arith(op, r1, r2) char *r1, *r2; {
	long i1, i2;
	register char *rv;

	if(!(ematch(r1, "[0-9]*$") && ematch(r2, "[0-9]*$")))
		yyerror("non-numeric argument");
	i1 = atol(r1);
	i2 = atol(r2);

	switch(op) {
	case ADD: i1 = i1 + i2; break;
	case SUBT: i1 = i1 - i2; break;
	case MULT: i1 = i1 * i2; break;
	case DIV: i1 = i1 / i2; break;
	case REM: i1 = i1 % i2; break;
	}
	rv = malloc(16);
	sprintf(rv, "%D", i1);
	return rv;
}
char *conj(op, r1, r2) char *r1, *r2; {
	register char *rv;

	switch(op) {

	case OR:
		if(EQL(r1, "0")
		|| EQL(r1, ""))
			if(EQL(r2, "0")
			|| EQL(r2, ""))
				rv = "0";
			else
				rv = r2;
		else
			rv = r1;
		break;
	case AND:
		if(EQL(r1, "0")
		|| EQL(r1, ""))
			rv = "0";
		else if(EQL(r2, "0")
		|| EQL(r2, ""))
			rv = "0";
		else
			rv = r1;
		break;
	}
	return rv;
}

char *substr(v, s, w) char *v, *s, *w; {
register si, wi;
register char *res;

	si = atol(s);
	wi = atol(w);
	while(--si) if(*v) ++v;

	res = v;

	while(wi--) if(*v) ++v;

	*v = '\0';
	return res;
}

char *length(s) register char *s; {
	register i = 0;
	register char *rv;

	while(*s++) ++i;

	rv = malloc(8);
	sprintf(rv, "%d", i);
	return rv;
}

char *index(s, t) char *s, *t; {
	register i, j;
	register char *rv;

	for(i = 0; s[i] ; ++i)
		for(j = 0; t[j] ; ++j)
			if(s[i]==t[j]) {
				sprintf(rv = malloc(8), "%d", ++i);
				return rv;
			}
	return "0";
}

char *match(s, p)
{
	register char *rv;

	sprintf(rv = malloc(8), "%d", ematch(s, p));
	if(nbra) {
		rv = malloc(strlen(Mstring[0])+1);
		strcpy(rv, Mstring[0]);
	}
	return rv;
}

#define INIT	register char *sp = instring;
#define GETC()		(*sp++)
#define PEEKC()		(*sp)
#define UNGETC(c)	(--sp)
#define RETURN(c)	return
#define ERROR(c)	errxx(c)


ematch(s, p)
char *s;
register char *p;
{
	static char expbuf[ESIZE];
	char *compile();
	register num;
	extern char *braslist[], *braelist[], *loc2;

	compile(p, expbuf, &expbuf[512], 0);
	if(nbra > 1)
		yyerror("Too many '\\('s");
	if(advance(s, expbuf)) {
		if(nbra == 1) {
			p = braslist[0];
			num = braelist[0] - p;
			strncpy(Mstring[0], p, num);
			Mstring[0][num] = '\0';
		}
		return(loc2-s);
	}
	return(0);
}

errxx(c)
{
	yyerror("RE error");
}

#define	CBRA	2
#define	CCHR	4
#define	CDOT	8
#define	CCL	12
#define	CDOL	20
#define	CEOF	22
#define	CKET	24
#define	CBACK	36

#define	STAR	01
#define RNGE	03

#define	NBRA	9

#define PLACE(c)	ep[c >> 3] |= bittab[c & 07]
#define ISTHERE(c)	(ep[c >> 3] & bittab[c & 07])

char	*braslist[NBRA];
char	*braelist[NBRA];
int	nbra;
char *loc1, *loc2, *locs;
int	sed;

int	circf;
int	low;
int	size;

char	bittab[] = {
	1,
	2,
	4,
	8,
	16,
	32,
	64,
	128
};

char *
compile(instring, ep, endbuf, seof)
register char *ep;
char *instring, *endbuf;
{
	INIT	/* Dependent declarations and initializations */
	register c;
	register eof = seof;
	char *lastep = instring;
	int cclcnt;
	char bracket[NBRA], *bracketp;
	int closed;
	char neg;
	int lc;
	int i, cflg;

	lastep = 0;
	if((c = GETC()) == eof) {
		if(*ep == 0 && !sed)
			ERROR(41);
		RETURN(ep);
	}
	bracketp = bracket;
	circf = closed = nbra = 0;
	if (c == '^')
		circf++;
	else
		UNGETC(c);
	for (;;) {
		if (ep >= endbuf)
			ERROR(50);
		if((c = GETC()) != '*' && ((c != '\\') || (PEEKC() != '{')))
			lastep = ep;
		if (c == eof) {
			*ep++ = CEOF;
			RETURN(ep);
		}
		switch (c) {

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

		case '\n':
			ERROR(36);
		case '*':
			if (lastep==0 || *lastep==CBRA || *lastep==CKET)
				goto defchar;
			*lastep |= STAR;
			continue;

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

		case '[':
			if(&ep[17] >= endbuf)
				ERROR(50);

			*ep++ = CCL;
			lc = 0;
			for(i = 0; i < 16; i++)
				ep[i] = 0;

			neg = 0;
			if((c = GETC()) == '^') {
				neg = 1;
				c = GETC();
			}

			do {
				if(c == '\0' || c == '\n')
					ERROR(49);
				if(c == '-' && lc != 0) {
					if ((c = GETC()) == ']') {
						PLACE('-');
						break;
					}
					while(lc < c) {
						PLACE(lc);
						lc++;
					}
				}
				lc = c;
				PLACE(c);
			} while((c = GETC()) != ']');
			if(neg) {
				for(cclcnt = 0; cclcnt < 16; cclcnt++)
					ep[cclcnt] ^= -1;
				ep[0] &= 0376;
			}

			ep += 16;

			continue;

		case '\\':
			switch(c = GETC()) {

			case '(':
				if(nbra >= NBRA)
					ERROR(43);
				*bracketp++ = nbra;
				*ep++ = CBRA;
				*ep++ = nbra++;
				continue;

			case ')':
				if(bracketp <= bracket)
					ERROR(42);
				*ep++ = CKET;
				*ep++ = *--bracketp;
				closed++;
				continue;

			case '{':
				if(lastep == (char *) (0))
					goto defchar;
				*lastep |= RNGE;
				cflg = 0;
			nlim:
				c = GETC();
				i = 0;
				do {
					if ('0' <= c && c <= '9')
						i = 10 * i + c - '0';
					else
						ERROR(16);
				} while(((c = GETC()) != '\\') && (c != ','));
				if (i > 255)
					ERROR(11);
				*ep++ = i;
				if (c == ',') {
					if(cflg++)
						ERROR(44);
					if((c = GETC()) == '\\')
						*ep++ = 255;
					else {
						UNGETC(c);
						goto nlim; /* get 2'nd number */
					}
				}
				if(GETC() != '}')
					ERROR(45);
				if(!cflg)	/* one number */
					*ep++ = i;
				else if((ep[-1] & 0377) < (ep[-2] & 0377))
					ERROR(46);
				continue;

			case '\n':
				ERROR(36);

			case 'n':
				c = '\n';
				goto defchar;

			default:
				if(c >= '1' && c <= '9') {
					if((c -= '1') >= closed)
						ERROR(25);
					*ep++ = CBACK;
					*ep++ = c;
					continue;
				}
			}
			/* Drop through to default to use \ to turn off special chars */

		defchar:
		default:
			lastep = ep;
			*ep++ = CCHR;
			*ep++ = c;
		}
	}
}

step(p1, p2)
register char *p1, *p2;
{
	register c;

	if (circf) {
		loc1 = p1;
		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);
	}
		/* regular algorithm */
	do {
		if (advance(p1, p2)) {
			loc1 = p1;
			return(1);
		}
	} while (*p1++);
	return(0);
}

advance(lp, ep)
register char *lp, *ep;
{
	register char *curlp;
	char c;
	char *bbeg;
	int ct;

	for (;;) switch (*ep++) {

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

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

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

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

	case CCL:
		c = *lp++ & 0177;
		if(ISTHERE(c)) {
			ep += 16;
			continue;
		}
		return(0);
	case CBRA:
		braslist[*ep++] = lp;
		continue;

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

	case CCHR|RNGE:
		c = *ep++;
		getrnge(ep);
		while(low--)
			if(*lp++ != c)
				return(0);
		curlp = lp;
		while(size--) 
			if(*lp++ != c)
				break;
		if(size < 0)
			lp++;
		ep += 2;
		goto star;

	case CDOT|RNGE:
		getrnge(ep);
		while(low--)
			if(*lp++ == '\0')
				return(0);
		curlp = lp;
		while(size--)
			if(*lp++ == '\0')
				break;
		if(size < 0)
			lp++;
		ep += 2;
		goto star;

	case CCL|RNGE:
		getrnge(ep + 16);
		while(low--) {
			c = *lp++ & 0177;
			if(!ISTHERE(c))
				return(0);
		}
		curlp = lp;
		while(size--) {
			c = *lp++ & 0177;
			if(!ISTHERE(c))
				break;
		}
		if(size < 0)
			lp++;
		ep += 18;		/* 16 + 2 */
		goto star;

	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(ISTHERE(c));
		ep += 16;
		goto star;

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

	}
}

getrnge(str)
register char *str;
{
	low = *str++ & 0377;
	size = *str == 255 ? 20000 : (*str &0377) - low;
}

ecmp(a, b, count)
register char	*a, *b;
register	count;
{
	if(a == b) /* should have been caught in compile() */
		error(51);
	while(count--)
		if(*a++ != *b++)	return(0);
	return(1);
}

static char *sccsid = "@(#)expr.y	4.1 (Berkeley) 10/1/80";
yyerror(s)

{
	fprintf(stderr, "%s\n", s);
	exit(2);
}
Commit	Line	Data
e95afa8a BJ	1	/* Yacc productions for "expr" command: */
	2
	3	%token OR AND ADD SUBT MULT DIV REM EQ GT GEQ LT LEQ NEQ
	4	%token A_STRING SUBSTR LENGTH INDEX NOARG MATCH
	5
	6	/* operators listed below in increasing precedence: */
	7	%left OR
	8	%left AND
	9	%left EQ LT GT GEQ LEQ NEQ
	10	%left ADD SUBT
	11	%left MULT DIV REM
	12	%left MCH
	13	%left MATCH
	14	%left SUBSTR
	15	%left LENGTH INDEX
	16	%%
	17
	18	/* a single `expression' is evaluated and printed: */
	19
	20	expression: expr NOARG = {
	21	printf("%s\n", $1);
	22	exit((!strcmp($1,"0")\|\|!strcmp($1,"\0"))? 1: 0);
	23	}
	24	;
	25
	26
	27	expr: '(' expr ')' = { $$ = $2; }
	28	\| expr OR expr = { $$ = conj(OR, $1, $3); }
	29	\| expr AND expr = { $$ = conj(AND, $1, $3); }
	30	\| expr EQ expr = { $$ = rel(EQ, $1, $3); }
	31	\| expr GT expr = { $$ = rel(GT, $1, $3); }
	32	\| expr GEQ expr = { $$ = rel(GEQ, $1, $3); }
	33	\| expr LT expr = { $$ = rel(LT, $1, $3); }
	34	\| expr LEQ expr = { $$ = rel(LEQ, $1, $3); }
	35	\| expr NEQ expr = { $$ = rel(NEQ, $1, $3); }
	36	\| expr ADD expr = { $$ = arith(ADD, $1, $3); }
	37	\| expr SUBT expr = { $$ = arith(SUBT, $1, $3); }
	38	\| expr MULT expr = { $$ = arith(MULT, $1, $3); }
	39	\| expr DIV expr = { $$ = arith(DIV, $1, $3); }
	40	\| expr REM expr = { $$ = arith(REM, $1, $3); }
	41	\| expr MCH expr = { $$ = match($1, $3); }
	42	\| MATCH expr expr = { $$ = match($2, $3); }
	43	\| SUBSTR expr expr expr = { $$ = substr($2, $3, $4); }
	44	\| LENGTH expr = { $$ = length($2); }
	45	\| INDEX expr expr = { $$ = index($2, $3); }
	46	\| A_STRING
	47	;
	48	%%
	49	/* expression command */
	50	#include <stdio.h>
	51	#define ESIZE 256
	52	#define error(c) errxx(c)
	53	#define EQL(x,y) !strcmp(x,y)
	54	long atol();
	55	char **Av;
	56	int Ac;
	57	int Argi;
	58
	59	char Mstring[1][128];
	60	char *malloc();
	61	extern int nbra;
	62
	63	main(argc, argv) char **argv; {
	64	Ac = argc;
65	Argi = 1;
66	Av = argv;
67	yyparse();
68	}
69
70	char operators[] = { "\|", "&", "+", "-", "", "/", "%", ":",
71	"=", "==", "<", "<=", ">", ">=", "!=",
72	"match", "substr", "length", "index", "\0" };
73	int op[] = { OR, AND, ADD, SUBT, MULT, DIV, REM, MCH,
74	EQ, EQ, LT, LEQ, GT, GEQ, NEQ,
75	MATCH, SUBSTR, LENGTH, INDEX };
76	yylex() {
77	register char *p;
78	register i;
79
80	if(Argi >= Ac) return NOARG;
81
82	p = Av[Argi++];
83
84	if(p == '(' \|\| p == ')')
85	return (int)*p;
86	for(i = 0; *operators[i]; ++i)
87	if(EQL(operators[i], p))
88	return op[i];
89
90	yylval = p;
91	return A_STRING;
92	}
93
94	char rel(op, r1, r2) register char r1, *r2; {
95	register i;
96
97	if(ematch(r1, "-[0-9]$") && ematch(r2, "[0-9]*$"))
98	i = atol(r1) - atol(r2);
99	else
100	i = strcmp(r1, r2);
101	switch(op) {
102	case EQ: i = i==0; break;
103	case GT: i = i>0; break;
104	case GEQ: i = i>=0; break;
105	case LT: i = i<0; break;
106	case LEQ: i = i>=0; break;
107	case NEQ: i = i!=0; break;
108	}
109	return i? "1": "0";
110	}
111
112	char arith(op, r1, r2) char r1, *r2; {
113	long i1, i2;
114	register char *rv;
115
116	if(!(ematch(r1, "[0-9]$") && ematch(r2, "[0-9]$")))
117	yyerror("non-numeric argument");
118	i1 = atol(r1);
119	i2 = atol(r2);
120
121	switch(op) {
122	case ADD: i1 = i1 + i2; break;
123	case SUBT: i1 = i1 - i2; break;
124	case MULT: i1 = i1 * i2; break;
125	case DIV: i1 = i1 / i2; break;
126	case REM: i1 = i1 % i2; break;
127	}
128	rv = malloc(16);
129	sprintf(rv, "%D", i1);
130	return rv;
131	}
132	char conj(op, r1, r2) char r1, *r2; {
133	register char *rv;
134
135	switch(op) {
136
137	case OR:
138	if(EQL(r1, "0")
139	\|\| EQL(r1, ""))
140	if(EQL(r2, "0")
141	\|\| EQL(r2, ""))
142	rv = "0";
143	else
144	rv = r2;
145	else
146	rv = r1;
147	break;
148	case AND:
149	if(EQL(r1, "0")
150	\|\| EQL(r1, ""))
151	rv = "0";
152	else if(EQL(r2, "0")
153	\|\| EQL(r2, ""))
154	rv = "0";
155	else
156	rv = r1;
157	break;
158	}
159	return rv;
160	}
161
162	char substr(v, s, w) char v, s, w; {
163	register si, wi;
164	register char *res;
165
166	si = atol(s);
167	wi = atol(w);
168	while(--si) if(*v) ++v;
169
170	res = v;
171
172	while(wi--) if(*v) ++v;
173
174	*v = '\0';
175	return res;
176	}
177
178	char length(s) register char s; {
179	register i = 0;
180	register char *rv;
181
182	while(*s++) ++i;
183
184	rv = malloc(8);
185	sprintf(rv, "%d", i);
186	return rv;
187	}
188
189	char index(s, t) char s, *t; {
190	register i, j;
191	register char *rv;
192
193	for(i = 0; s[i] ; ++i)
194	for(j = 0; t[j] ; ++j)
195	if(s[i]==t[j]) {
196	sprintf(rv = malloc(8), "%d", ++i);
197	return rv;
198	}
199	return "0";
200	}
201
202	char *match(s, p)
203	{
204	register char *rv;
205
206	sprintf(rv = malloc(8), "%d", ematch(s, p));
207	if(nbra) {
208	rv = malloc(strlen(Mstring[0])+1);
209	strcpy(rv, Mstring[0]);
210	}
211	return rv;
212	}
213
214	#define INIT register char *sp = instring;
215	#define GETC() (*sp++)
216	#define PEEKC() (*sp)
217	#define UNGETC(c) (--sp)
218	#define RETURN(c) return
219	#define ERROR(c) errxx(c)
220
221
222	ematch(s, p)
223	char *s;
224	register char *p;
225	{
226	static char expbuf[ESIZE];
227	char *compile();
228	register num;
229	extern char braslist[], braelist[], *loc2;
230
231	compile(p, expbuf, &expbuf[512], 0);
232	if(nbra > 1)
233	yyerror("Too many '\\('s");
234	if(advance(s, expbuf)) {
235	if(nbra == 1) {
236	p = braslist[0];
237	num = braelist[0] - p;
238	strncpy(Mstring[0], p, num);
239	Mstring[0][num] = '\0';
240	}
241	return(loc2-s);
242	}
243	return(0);
244	}
245
246	errxx(c)
247	{
248	yyerror("RE error");
249	}
250
251	#define CBRA 2
252	#define CCHR 4
253	#define CDOT 8
254	#define CCL 12
255	#define CDOL 20
256	#define CEOF 22
257	#define CKET 24
258	#define CBACK 36
259
260	#define STAR 01
261	#define RNGE 03
262
263	#define NBRA 9
264
265	#define PLACE(c) ep[c >> 3] \|= bittab[c & 07]
266	#define ISTHERE(c) (ep[c >> 3] & bittab[c & 07])
267
268	char *braslist[NBRA];
269	char *braelist[NBRA];
270	int nbra;
271	char loc1, loc2, *locs;
272	int sed;
273
274	int circf;
275	int low;
276	int size;
277
278	char bittab[] = {
279	1,
280	2,
281	4,
282	8,
283	16,
284	32,
285	64,
286	128
287	};
288
289	char *
290	compile(instring, ep, endbuf, seof)
291	register char *ep;
292	char instring, endbuf;
293	{
294	INIT /* Dependent declarations and initializations */
295	register c;
296	register eof = seof;
297	char *lastep = instring;
298	int cclcnt;
299	char bracket[NBRA], *bracketp;
300	int closed;
301	char neg;
302	int lc;
303	int i, cflg;
304
305	lastep = 0;
306	if((c = GETC()) == eof) {
307	if(*ep == 0 && !sed)
308	ERROR(41);
309	RETURN(ep);
310	}
311	bracketp = bracket;
312	circf = closed = nbra = 0;
313	if (c == '^')
314	circf++;
315	else
316	UNGETC(c);
317	for (;;) {
318	if (ep >= endbuf)
319	ERROR(50);
320	if((c = GETC()) != '*' && ((c != '\\') \|\| (PEEKC() != '{')))
321	lastep = ep;
322	if (c == eof) {
323	*ep++ = CEOF;
324	RETURN(ep);
325	}
326	switch (c) {
327
328	case '.':
329	*ep++ = CDOT;
330	continue;
331
332	case '\n':
333	ERROR(36);
334	case '*':
335	if (lastep==0 \|\| lastep==CBRA \|\| lastep==CKET)
336	goto defchar;
337	*lastep \|= STAR;
338	continue;
339
340	case '$':
341	if(PEEKC() != eof)
342	goto defchar;
343	*ep++ = CDOL;
344	continue;
345
346	case '[':
347	if(&ep[17] >= endbuf)
348	ERROR(50);
349
350	*ep++ = CCL;
351	lc = 0;
352	for(i = 0; i < 16; i++)
353	ep[i] = 0;
354
355	neg = 0;
356	if((c = GETC()) == '^') {
357	neg = 1;
358	c = GETC();
359	}
360
361	do {
362	if(c == '\0' \|\| c == '\n')
363	ERROR(49);
364	if(c == '-' && lc != 0) {
365	if ((c = GETC()) == ']') {
366	PLACE('-');
367	break;
368	}
369	while(lc < c) {
370	PLACE(lc);
371	lc++;
372	}
373	}
374	lc = c;
375	PLACE(c);
376	} while((c = GETC()) != ']');
377	if(neg) {
378	for(cclcnt = 0; cclcnt < 16; cclcnt++)
379	ep[cclcnt] ^= -1;
380	ep[0] &= 0376;
381	}
382
383	ep += 16;
384
385	continue;
386
387	case '\\':
388	switch(c = GETC()) {
389
390	case '(':
391	if(nbra >= NBRA)
392	ERROR(43);
393	*bracketp++ = nbra;
394	*ep++ = CBRA;
395	*ep++ = nbra++;
396	continue;
397
398	case ')':
399	if(bracketp <= bracket)
400	ERROR(42);
401	*ep++ = CKET;
402	ep++ = --bracketp;
403	closed++;
404	continue;
405
406	case '{':
407	if(lastep == (char *) (0))
408	goto defchar;
409	*lastep \|= RNGE;
410	cflg = 0;
411	nlim:
412	c = GETC();
413	i = 0;
414	do {
415	if ('0' <= c && c <= '9')
416	i = 10 * i + c - '0';
417	else
418	ERROR(16);
419	} while(((c = GETC()) != '\\') && (c != ','));
420	if (i > 255)
421	ERROR(11);
422	*ep++ = i;
423	if (c == ',') {
424	if(cflg++)
425	ERROR(44);
426	if((c = GETC()) == '\\')
427	*ep++ = 255;
428	else {
429	UNGETC(c);
430	goto nlim; /* get 2'nd number */
431	}
432	}
433	if(GETC() != '}')
434	ERROR(45);
435	if(!cflg) /* one number */
436	*ep++ = i;
437	else if((ep[-1] & 0377) < (ep[-2] & 0377))
438	ERROR(46);
439	continue;
440
441	case '\n':
442	ERROR(36);
443
444	case 'n':
445	c = '\n';
446	goto defchar;
447
448	default:
449	if(c >= '1' && c <= '9') {
450	if((c -= '1') >= closed)
451	ERROR(25);
452	*ep++ = CBACK;
453	*ep++ = c;
454	continue;
455	}
456	}
457	/* Drop through to default to use \ to turn off special chars */
458
459	defchar:
460	default:
461	lastep = ep;
462	*ep++ = CCHR;
463	*ep++ = c;
464	}
465	}
466	}
467
468	step(p1, p2)
469	register char p1, p2;
470	{
471	register c;
472
473	if (circf) {
474	loc1 = p1;
475	return(advance(p1, p2));
476	}
477	/* fast check for first character */
478	if (*p2==CCHR) {
479	c = p2[1];
480	do {
481	if (*p1 != c)
482	continue;
483	if (advance(p1, p2)) {
484	loc1 = p1;
485	return(1);
486	}
487	} while (*p1++);
488	return(0);
489	}
490	/* regular algorithm */
491	do {
492	if (advance(p1, p2)) {
493	loc1 = p1;
494	return(1);
495	}
496	} while (*p1++);
497	return(0);
498	}
499
500	advance(lp, ep)
501	register char lp, ep;
502	{
503	register char *curlp;
504	char c;
505	char *bbeg;
506	int ct;
507
508	for (;;) switch (*ep++) {
509
510	case CCHR:
511	if (ep++ == lp++)
512	continue;
513	return(0);
514
515	case CDOT:
516	if (*lp++)
517	continue;
518	return(0);
519
520	case CDOL:
521	if (*lp==0)
522	continue;
523	return(0);
524
525	case CEOF:
526	loc2 = lp;
527	return(1);
528
529	case CCL:
530	c = *lp++ & 0177;
531	if(ISTHERE(c)) {
532	ep += 16;
533	continue;
534	}
535	return(0);
536	case CBRA:
537	braslist[*ep++] = lp;
538	continue;
539
540	case CKET:
541	braelist[*ep++] = lp;
542	continue;
543
544	case CCHR\|RNGE:
545	c = *ep++;
546	getrnge(ep);
547	while(low--)
548	if(*lp++ != c)
549	return(0);
550	curlp = lp;
551	while(size--)
552	if(*lp++ != c)
553	break;
554	if(size < 0)
555	lp++;
556	ep += 2;
557	goto star;
558
559	case CDOT\|RNGE:
560	getrnge(ep);
561	while(low--)
562	if(*lp++ == '\0')
563	return(0);
564	curlp = lp;
565	while(size--)
566	if(*lp++ == '\0')
567	break;
568	if(size < 0)
569	lp++;
570	ep += 2;
571	goto star;
572
573	case CCL\|RNGE:
574	getrnge(ep + 16);
575	while(low--) {
576	c = *lp++ & 0177;
577	if(!ISTHERE(c))
578	return(0);
579	}
580	curlp = lp;
581	while(size--) {
582	c = *lp++ & 0177;
583	if(!ISTHERE(c))
584	break;
585	}
586	if(size < 0)
587	lp++;
588	ep += 18; /* 16 + 2 */
589	goto star;
590
591	case CBACK:
592	bbeg = braslist[*ep];
593	ct = braelist[*ep++] - bbeg;
594
595	if(ecmp(bbeg, lp, ct)) {
596	lp += ct;
597	continue;
598	}
599	return(0);
600
601	case CBACK\|STAR:
602	bbeg = braslist[*ep];
603	ct = braelist[*ep++] - bbeg;
604	curlp = lp;
605	while(ecmp(bbeg, lp, ct))
606	lp += ct;
607
608	while(lp >= curlp) {
609	if(advance(lp, ep)) return(1);
610	lp -= ct;
611	}
612	return(0);
613
614
615	case CDOT\|STAR:
616	curlp = lp;
617	while (*lp++);
618	goto star;
619
620	case CCHR\|STAR:
621	curlp = lp;
622	while (lp++ == ep);
623	ep++;
624	goto star;
625
626	case CCL\|STAR:
627	curlp = lp;
628	do {
629	c = *lp++ & 0177;
630	} while(ISTHERE(c));
631	ep += 16;
632	goto star;
633
634	star:
635	do {
636	if(--lp == locs)
637	break;
638	if (advance(lp, ep))
639	return(1);
640	} while (lp > curlp);
641	return(0);
642
643	}
644	}
645
646	getrnge(str)
647	register char *str;
648	{
649	low = *str++ & 0377;
650	size = str == 255 ? 20000 : (str &0377) - low;
651	}
652
653	ecmp(a, b, count)
654	register char a, b;
655	register count;
656	{
657	if(a == b) /* should have been caught in compile() */
658	error(51);
659	while(count--)
660	if(a++ != b++) return(0);
661	return(1);
662	}
663
31cef89c	664	static char *sccsid = "@(#)expr.y 4.1 (Berkeley) 10/1/80";
e95afa8a BJ	665	yyerror(s)
	666
	667	{
	668	fprintf(stderr, "%s\n", s);
	669	exit(2);
	670	}