[unix-history] / usr / src / cmd / yacc / y3.c

# include "dextern"

	/* important local variables */
int lastred;  /* the number of the last reduction of a state */
int defact[NSTATES];  /* the default actions of states */

output(){ /* print the output for the states */

	int i, k, c;
	register struct wset *u, *v;

	fprintf( ftable, "short yyexca[] ={\n" );

	SLOOP(i) { /* output the stuff for state i */
		nolook = !(tystate[i]==MUSTLOOKAHEAD);
		closure(i);
		/* output actions */
		nolook = 1;
		aryfil( temp1, ntokens+nnonter+1, 0 );
		WSLOOP(wsets,u){
			c = *( u->pitem );
			if( c>1 && c<NTBASE && temp1[c]==0 ) {
				WSLOOP(u,v){
					if( c == *(v->pitem) ) putitem( v->pitem+1, (struct looksets *)0 );
					}
				temp1[c] = state(c);
				}
			else if( c > NTBASE && temp1[ (c -= NTBASE) + ntokens ] == 0 ){
				temp1[ c+ntokens ] = amem[indgo[i]+c];
				}
			}

		if( i == 1 ) temp1[1] = ACCEPTCODE;

		/* now, we have the shifts; look at the reductions */

		lastred = 0;
		WSLOOP(wsets,u){
			c = *( u->pitem );
			if( c<=0 ){ /* reduction */
				lastred = -c;
				TLOOP(k){
					if( BIT(u->ws.lset,k) ){
						  if( temp1[k] == 0 ) temp1[k] = c;
						  else if( temp1[k]<0 ){ /* reduce/reduce conflict */
						    if( foutput!=NULL )
						      fprintf( foutput,
						        "\n%d: reduce/reduce conflict (red'ns %d and %d ) on %s",
						        i, -temp1[k], lastred, symnam(k) );
						    if( -temp1[k] > lastred ) temp1[k] = -lastred;
						    ++zzrrconf;
						    }
						  else { /* potential shift/reduce conflict */
							precftn( lastred, k, i );
							}
						}
					}
				}
			}
		wract(i);
		}

	fprintf( ftable, "\t};\n" );

	wdef( "YYNPROD", nprod );

	}

int pkdebug = 0;
apack(p, n ) int *p;{ /* pack state i from temp1 into amem */
	int off;
	register *pp, *qq, *rr;
	int *q, *r;

	/* we don't need to worry about checking because we
	   we will only look entries known to be there... */

	/* eliminate leading and trailing 0's */

	q = p+n;
	for( pp=p,off=0 ; *pp==0 && pp<=q; ++pp,--off ) /* VOID */ ;
	if( pp > q ) return(0);  /* no actions */
	p = pp;

	/* now, find a place for the elements from p to q, inclusive */

	r = &amem[ACTSIZE-1];
	for( rr=amem; rr<=r; ++rr,++off ){  /* try rr */
		for( qq=rr,pp=p ; pp<=q ; ++pp,++qq){
			if( *pp != 0 ){
				if( *pp != *qq && *qq != 0 ) goto nextk;
				}
			}

		/* we have found an acceptable k */

		if( pkdebug && foutput!=NULL ) fprintf( foutput, "off = %d, k = %d\n", off, rr-amem );

		for( qq=rr,pp=p; pp<=q; ++pp,++qq ){
			if( *pp ){
				if( qq > r ) error( "action table overflow" );
				if( qq>memp ) memp = qq;
				*qq = *pp;
				}
			}
		if( pkdebug && foutput!=NULL ){
			for( pp=amem; pp<= memp; pp+=10 ){
				fprintf( foutput, "\t");
				for( qq=pp; qq<=pp+9; ++qq ) fprintf( foutput, "%d ", *qq );
				fprintf( foutput, "\n");
				}
			}
		return( off );

		nextk: ;
		}
	error("no space in action table" );
	/* NOTREACHED */
	}

go2out(){ /* output the gotos for the nontermninals */
	int i, j, k, best, count, cbest, times;

	fprintf( ftemp, "$\n" );  /* mark begining of gotos */

	for( i=1; i<=nnonter; ++i ) {
		go2gen(i);

		/* find the best one to make default */

		best = -1;
		times = 0;

		for( j=0; j<=nstate; ++j ){ /* is j the most frequent */
			if( tystate[j] == 0 ) continue;
			if( tystate[j] == best ) continue;

			/* is tystate[j] the most frequent */

			count = 0;
			cbest = tystate[j];

			for( k=j; k<=nstate; ++k ) if( tystate[k]==cbest ) ++count;

			if( count > times ){
				best = cbest;
				times = count;
				}
			}

		/* best is now the default entry */

		zzgobest += (times-1);
		for( j=0; j<=nstate; ++j ){
			if( tystate[j] != 0 && tystate[j]!=best ){
				fprintf( ftemp, "%d,%d,", j, tystate[j] );
				zzgoent += 1;
				}
			}

		/* now, the default */

		zzgoent += 1;
		fprintf( ftemp, "%d\n", best );

		}


	}

int g2debug = 0;
go2gen(c){ /* output the gotos for nonterminal c */

	int i, work, cc;
	struct item *p, *q;


	/* first, find nonterminals with gotos on c */

	aryfil( temp1, nnonter+1, 0 );
	temp1[c] = 1;

	work = 1;
	while( work ){
		work = 0;
		PLOOP(0,i){
			if( (cc=prdptr[i][1]-NTBASE) >= 0 ){ /* cc is a nonterminal */
				if( temp1[cc] != 0 ){ /* cc has a goto on c */
					cc = *prdptr[i]-NTBASE; /* thus, the left side of production i does too */
					if( temp1[cc] == 0 ){
						  work = 1;
						  temp1[cc] = 1;
						  }
					}
				}
			}
		}

	/* now, we have temp1[c] = 1 if a goto on c in closure of cc */

	if( g2debug && foutput!=NULL ){
		fprintf( foutput, "%s: gotos on ", nontrst[c].name );
		NTLOOP(i) if( temp1[i] ) fprintf( foutput, "%s ", nontrst[i].name);
		fprintf( foutput, "\n");
		}

	/* now, go through and put gotos into tystate */

	aryfil( tystate, nstate, 0 );
	SLOOP(i){
		ITMLOOP(i,p,q){
			if( (cc= *p->pitem) >= NTBASE ){
				if( temp1[cc -= NTBASE] ){ /* goto on c is possible */
					tystate[i] = amem[indgo[i]+c];
					break;
					}
				}
			}
		}
	}

precftn(r,t,s){ /* decide a shift/reduce conflict by precedence.
	/* r is a rule number, t a token number */
	/* the conflict is in state s */
	/* temp1[t] is changed to reflect the action */

	int lp,lt, action;

	lp = levprd[r];
	lt = toklev[t];
	if( PLEVEL(lt) == 0 || PLEVEL(lp) == 0 ) {
		/* conflict */
		if( foutput != NULL ) fprintf( foutput, "\n%d: shift/reduce conflict (shift %d, red'n %d) on %s",
						s, temp1[t], r, symnam(t) );
		++zzsrconf;
		return;
		}
	if( PLEVEL(lt) == PLEVEL(lp) ) action = ASSOC(lt);
	else if( PLEVEL(lt) > PLEVEL(lp) ) action = RASC;  /* shift */
	else action = LASC;  /* reduce */

	switch( action ){

	case BASC:  /* error action */
		temp1[t] = ERRCODE;
		return;

	case LASC:  /* reduce */
		temp1[t] = -r;
		return;

		}
	}

wract(i){ /* output state i */
	/* temp1 has the actions, lastred the default */
	int p, p0, p1;
	int ntimes, tred, count, j;
	int flag;

	/* find the best choice for lastred */

	lastred = 0;
	ntimes = 0;
	TLOOP(j){
		if( temp1[j] >= 0 ) continue;
		if( temp1[j]+lastred == 0 ) continue;
		/* count the number of appearances of temp1[j] */
		count = 0;
		tred = -temp1[j];
		levprd[tred] |= REDFLAG;
		TLOOP(p){
			if( temp1[p]+tred == 0 ) ++count;
			}
		if( count >ntimes ){
			lastred = tred;
			ntimes = count;
			}
		}

	/* for error recovery, arrange that, if there is a shift on the
	/* error recovery token, `error', that the default be the error action */
	if( temp1[1] > 0 ) lastred = 0;

	/* clear out entries in temp1 which equal lastred */
	TLOOP(p) if( temp1[p]+lastred == 0 )temp1[p]=0;

	wrstate(i);
	defact[i] = lastred;

	flag = 0;
	TLOOP(p0){
		if( (p1=temp1[p0])!=0 ) {
			if( p1 < 0 ){
				p1 = -p1;
				goto exc;
				}
			else if( p1 == ACCEPTCODE ) {
				p1 = -1;
				goto exc;
				}
			else if( p1 == ERRCODE ) {
				p1 = 0;
				goto exc;
			exc:
				if( flag++ == 0 ) fprintf( ftable, "-1, %d,\n", i );
				fprintf( ftable, "\t%d, %d,\n", tokset[p0].value, p1 );
				++zzexcp;
				}
			else {
				fprintf( ftemp, "%d,%d,", tokset[p0].value, p1 );
				++zzacent;
				}
			}
		}
	if( flag ) {
		defact[i] = -2;
		fprintf( ftable, "\t-2, %d,\n", lastred );
		}
	fprintf( ftemp, "\n" );
	return;
	}

wrstate(i){ /* writes state i */
	register j0,j1;
	register struct item *pp, *qq;
	register struct wset *u;

	if( foutput == NULL ) return;
	fprintf( foutput, "\nstate %d\n",i);
	ITMLOOP(i,pp,qq) fprintf( foutput, "\t%s\n", writem(pp->pitem));
	if( tystate[i] == MUSTLOOKAHEAD ){
		/* print out empty productions in closure */
		WSLOOP( wsets+(pstate[i+1]-pstate[i]), u ){
			if( *(u->pitem) < 0 ) fprintf( foutput, "\t%s\n", writem(u->pitem) );
			}
		}

	/* check for state equal to another */

	TLOOP(j0) if( (j1=temp1[j0]) != 0 ){
		fprintf( foutput, "\n\t%s  ", symnam(j0) );
		if( j1>0 ){ /* shift, error, or accept */
			if( j1 == ACCEPTCODE ) fprintf( foutput,  "accept" );
			else if( j1 == ERRCODE ) fprintf( foutput, "error" );
			else fprintf( foutput,  "shift %d", j1 );
			}
		else fprintf( foutput, "reduce %d",-j1 );
		}

	/* output the final production */

	if( lastred ) fprintf( foutput, "\n\t.  reduce %d\n\n", lastred );
	else fprintf( foutput, "\n\t.  error\n\n" );

	/* now, output nonterminal actions */

	j1 = ntokens;
	for( j0 = 1; j0 <= nnonter; ++j0 ){
		if( temp1[++j1] ) fprintf( foutput, "\t%s  goto %d\n", symnam( j0+NTBASE), temp1[j1] );
		}

	}

wdef( s, n ) char *s; { /* output a definition of s to the value n */
	fprintf( ftable, "# define %s %d\n", s, n );
	}

warray( s, v, n ) char *s; int *v, n; {

	register i;

	fprintf( ftable, "short %s[]={\n", s );
	for( i=0; i<n; ){
		if( i%10 == 0 ) fprintf( ftable, "\n" );
		fprintf( ftable, "%4d", v[i] );
		if( ++i == n ) fprintf( ftable, " };\n" );
		else fprintf( ftable, "," );
		}
	}

hideprod(){
	/* in order to free up the mem and amem arrays for the optimizer,
	/* and still be able to output yyr1, etc., after the sizes of
	/* the action array is known, we hide the nonterminals
	/* derived by productions in levprd.
	*/

	register i, j;

	j = 0;
	levprd[0] = 0;
	PLOOP(1,i){
		if( !(levprd[i] & REDFLAG) ){
			++j;
			if( foutput != NULL ){
				fprintf( foutput, "Rule not reduced:   %s\n", writem( prdptr[i] ) );
				}
			}
		levprd[i] = *prdptr[i] - NTBASE;
		}
	if( j ) fprintf( stdout, "%d rules never reduced\n", j );
	}
Commit	Line	Data
337dae54 TL	1	# include "dextern"
	2
	3	/* important local variables */
	4	int lastred; /* the number of the last reduction of a state */
	5	int defact[NSTATES]; /* the default actions of states */
	6
	7	output(){ /* print the output for the states */
	8
	9	int i, k, c;
	10	register struct wset u, v;
	11
	12	fprintf( ftable, "short yyexca[] ={\n" );
	13
	14	SLOOP(i) { /* output the stuff for state i */
	15	nolook = !(tystate[i]==MUSTLOOKAHEAD);
	16	closure(i);
	17	/* output actions */
	18	nolook = 1;
	19	aryfil( temp1, ntokens+nnonter+1, 0 );
	20	WSLOOP(wsets,u){
	21	c = *( u->pitem );
	22	if( c>1 && c<NTBASE && temp1[c]==0 ) {
	23	WSLOOP(u,v){
	24	if( c == (v->pitem) ) putitem( v->pitem+1, (struct looksets )0 );
	25	}
	26	temp1[c] = state(c);
	27	}
	28	else if( c > NTBASE && temp1[ (c -= NTBASE) + ntokens ] == 0 ){
	29	temp1[ c+ntokens ] = amem[indgo[i]+c];
	30	}
	31	}
	32
	33	if( i == 1 ) temp1[1] = ACCEPTCODE;
	34
	35	/* now, we have the shifts; look at the reductions */
	36
	37	lastred = 0;
	38	WSLOOP(wsets,u){
	39	c = *( u->pitem );
	40	if( c<=0 ){ /* reduction */
	41	lastred = -c;
	42	TLOOP(k){
	43	if( BIT(u->ws.lset,k) ){
	44	if( temp1[k] == 0 ) temp1[k] = c;
	45	else if( temp1[k]<0 ){ /* reduce/reduce conflict */
	46	if( foutput!=NULL )
	47	fprintf( foutput,
	48	"\n%d: reduce/reduce conflict (red'ns %d and %d ) on %s",
	49	i, -temp1[k], lastred, symnam(k) );
	50	if( -temp1[k] > lastred ) temp1[k] = -lastred;
	51	++zzrrconf;
	52	}
	53	else { /* potential shift/reduce conflict */
	54	precftn( lastred, k, i );
	55	}
	56	}
	57	}
	58	}
	59	}
	60	wract(i);
	61	}
	62
	63	fprintf( ftable, "\t};\n" );
	64
65	wdef( "YYNPROD", nprod );
66
67	}
68
69	int pkdebug = 0;
70	apack(p, n ) int p;{ / pack state i from temp1 into amem */
71	int off;
72	register pp, qq, *rr;
73	int q, r;
74
75	/* we don't need to worry about checking because we
76	we will only look entries known to be there... */
77
78	/* eliminate leading and trailing 0's */
79
80	q = p+n;
81	for( pp=p,off=0 ; pp==0 && pp<=q; ++pp,--off ) / VOID */ ;
82	if( pp > q ) return(0); /* no actions */
83	p = pp;
84
85	/* now, find a place for the elements from p to q, inclusive */
86
87	r = &amem[ACTSIZE-1];
88	for( rr=amem; rr<=r; ++rr,++off ){ /* try rr */
89	for( qq=rr,pp=p ; pp<=q ; ++pp,++qq){
90	if( *pp != 0 ){
91	if( pp != qq && *qq != 0 ) goto nextk;
92	}
93	}
94
95	/* we have found an acceptable k */
96
97	if( pkdebug && foutput!=NULL ) fprintf( foutput, "off = %d, k = %d\n", off, rr-amem );
98
99	for( qq=rr,pp=p; pp<=q; ++pp,++qq ){
100	if( *pp ){
101	if( qq > r ) error( "action table overflow" );
102	if( qq>memp ) memp = qq;
103	qq = pp;
104	}
105	}
106	if( pkdebug && foutput!=NULL ){
107	for( pp=amem; pp<= memp; pp+=10 ){
108	fprintf( foutput, "\t");
109	for( qq=pp; qq<=pp+9; ++qq ) fprintf( foutput, "%d ", *qq );
110	fprintf( foutput, "\n");
111	}
112	}
113	return( off );
114
115	nextk: ;
116	}
117	error("no space in action table" );
118	/* NOTREACHED */
119	}
120
121	go2out(){ /* output the gotos for the nontermninals */
122	int i, j, k, best, count, cbest, times;
123
124	fprintf( ftemp, "$\n" ); /* mark begining of gotos */
125
126	for( i=1; i<=nnonter; ++i ) {
127	go2gen(i);
128
129	/* find the best one to make default */
130
131	best = -1;
132	times = 0;
133
134	for( j=0; j<=nstate; ++j ){ /* is j the most frequent */
135	if( tystate[j] == 0 ) continue;
136	if( tystate[j] == best ) continue;
137
138	/* is tystate[j] the most frequent */
139
140	count = 0;
141	cbest = tystate[j];
142
143	for( k=j; k<=nstate; ++k ) if( tystate[k]==cbest ) ++count;
144
145	if( count > times ){
146	best = cbest;
147	times = count;
148	}
149	}
150
151	/* best is now the default entry */
152
153	zzgobest += (times-1);
154	for( j=0; j<=nstate; ++j ){
155	if( tystate[j] != 0 && tystate[j]!=best ){
156	fprintf( ftemp, "%d,%d,", j, tystate[j] );
157	zzgoent += 1;
158	}
159	}
160
161	/* now, the default */
162
163	zzgoent += 1;
164	fprintf( ftemp, "%d\n", best );
165
166	}
167
168
169
170	}
171
172	int g2debug = 0;
173	go2gen(c){ /* output the gotos for nonterminal c */
174
175	int i, work, cc;
176	struct item p, q;
177
178
179	/* first, find nonterminals with gotos on c */
180
181	aryfil( temp1, nnonter+1, 0 );
182	temp1[c] = 1;
183
184	work = 1;
185	while( work ){
186	work = 0;
187	PLOOP(0,i){
188	if( (cc=prdptr[i][1]-NTBASE) >= 0 ){ /* cc is a nonterminal */
189	if( temp1[cc] != 0 ){ /* cc has a goto on c */
190	cc = prdptr[i]-NTBASE; / thus, the left side of production i does too */
191	if( temp1[cc] == 0 ){
192	work = 1;
193	temp1[cc] = 1;
194	}
195	}
196	}
197	}
198	}
199
200	/* now, we have temp1[c] = 1 if a goto on c in closure of cc */
201
202	if( g2debug && foutput!=NULL ){
203	fprintf( foutput, "%s: gotos on ", nontrst[c].name );
204	NTLOOP(i) if( temp1[i] ) fprintf( foutput, "%s ", nontrst[i].name);
205	fprintf( foutput, "\n");
206	}
207
208	/* now, go through and put gotos into tystate */
209
210	aryfil( tystate, nstate, 0 );
211	SLOOP(i){
212	ITMLOOP(i,p,q){
213	if( (cc= *p->pitem) >= NTBASE ){
214	if( temp1[cc -= NTBASE] ){ /* goto on c is possible */
215	tystate[i] = amem[indgo[i]+c];
216	break;
217	}
218	}
219	}
220	}
221	}
222
223	precftn(r,t,s){ /* decide a shift/reduce conflict by precedence.
224	/* r is a rule number, t a token number */
225	/* the conflict is in state s */
226	/* temp1[t] is changed to reflect the action */
227
228	int lp,lt, action;
229
230	lp = levprd[r];
231	lt = toklev[t];
232	if( PLEVEL(lt) == 0 \|\| PLEVEL(lp) == 0 ) {
233	/* conflict */
234	if( foutput != NULL ) fprintf( foutput, "\n%d: shift/reduce conflict (shift %d, red'n %d) on %s",
235	s, temp1[t], r, symnam(t) );
236	++zzsrconf;
237	return;
238	}
239	if( PLEVEL(lt) == PLEVEL(lp) ) action = ASSOC(lt);
240	else if( PLEVEL(lt) > PLEVEL(lp) ) action = RASC; /* shift */
241	else action = LASC; /* reduce */
242
243	switch( action ){
244
245	case BASC: /* error action */
246	temp1[t] = ERRCODE;
247	return;
248
249	case LASC: /* reduce */
250	temp1[t] = -r;
251	return;
252
253	}
254	}
255
256	wract(i){ /* output state i */
257	/* temp1 has the actions, lastred the default */
258	int p, p0, p1;
259	int ntimes, tred, count, j;
260	int flag;
261
262	/* find the best choice for lastred */
263
264	lastred = 0;
265	ntimes = 0;
266	TLOOP(j){
267	if( temp1[j] >= 0 ) continue;
268	if( temp1[j]+lastred == 0 ) continue;
269	/* count the number of appearances of temp1[j] */
270	count = 0;
271	tred = -temp1[j];
272	levprd[tred] \|= REDFLAG;
273	TLOOP(p){
274	if( temp1[p]+tred == 0 ) ++count;
275	}
276	if( count >ntimes ){
277	lastred = tred;
278	ntimes = count;
279	}
280	}
281
282	/* for error recovery, arrange that, if there is a shift on the
283	/* error recovery token, `error', that the default be the error action */
284	if( temp1[1] > 0 ) lastred = 0;
285
286	/* clear out entries in temp1 which equal lastred */
287	TLOOP(p) if( temp1[p]+lastred == 0 )temp1[p]=0;
288
289	wrstate(i);
290	defact[i] = lastred;
291
292	flag = 0;
293	TLOOP(p0){
294	if( (p1=temp1[p0])!=0 ) {
295	if( p1 < 0 ){
296	p1 = -p1;
297	goto exc;
298	}
299	else if( p1 == ACCEPTCODE ) {
300	p1 = -1;
301	goto exc;
302	}
303	else if( p1 == ERRCODE ) {
304	p1 = 0;
305	goto exc;
306	exc:
307	if( flag++ == 0 ) fprintf( ftable, "-1, %d,\n", i );
308	fprintf( ftable, "\t%d, %d,\n", tokset[p0].value, p1 );
309	++zzexcp;
310	}
311	else {
312	fprintf( ftemp, "%d,%d,", tokset[p0].value, p1 );
313	++zzacent;
314	}
315	}
316	}
317	if( flag ) {
318	defact[i] = -2;
319	fprintf( ftable, "\t-2, %d,\n", lastred );
320	}
321	fprintf( ftemp, "\n" );
322	return;
323	}
324
325	wrstate(i){ /* writes state i */
326	register j0,j1;
327	register struct item pp, qq;
328	register struct wset *u;
329
330	if( foutput == NULL ) return;
331	fprintf( foutput, "\nstate %d\n",i);
332	ITMLOOP(i,pp,qq) fprintf( foutput, "\t%s\n", writem(pp->pitem));
333	if( tystate[i] == MUSTLOOKAHEAD ){
334	/* print out empty productions in closure */
335	WSLOOP( wsets+(pstate[i+1]-pstate[i]), u ){
336	if( *(u->pitem) < 0 ) fprintf( foutput, "\t%s\n", writem(u->pitem) );
337	}
338	}
339
340	/* check for state equal to another */
341
342	TLOOP(j0) if( (j1=temp1[j0]) != 0 ){
343	fprintf( foutput, "\n\t%s ", symnam(j0) );
344	if( j1>0 ){ /* shift, error, or accept */
345	if( j1 == ACCEPTCODE ) fprintf( foutput, "accept" );
346	else if( j1 == ERRCODE ) fprintf( foutput, "error" );
347	else fprintf( foutput, "shift %d", j1 );
348	}
349	else fprintf( foutput, "reduce %d",-j1 );
350	}
351
352	/* output the final production */
353
354	if( lastred ) fprintf( foutput, "\n\t. reduce %d\n\n", lastred );
355	else fprintf( foutput, "\n\t. error\n\n" );
356
357	/* now, output nonterminal actions */
358
359	j1 = ntokens;
360	for( j0 = 1; j0 <= nnonter; ++j0 ){
361	if( temp1[++j1] ) fprintf( foutput, "\t%s goto %d\n", symnam( j0+NTBASE), temp1[j1] );
362	}
363
364	}
365
366	wdef( s, n ) char s; { / output a definition of s to the value n */
367	fprintf( ftable, "# define %s %d\n", s, n );
368	}
369
370	warray( s, v, n ) char s; int v, n; {
371
372	register i;
373
374	fprintf( ftable, "short %s[]={\n", s );
375	for( i=0; i<n; ){
376	if( i%10 == 0 ) fprintf( ftable, "\n" );
377	fprintf( ftable, "%4d", v[i] );
378	if( ++i == n ) fprintf( ftable, " };\n" );
379	else fprintf( ftable, "," );
380	}
381	}
382
383	hideprod(){
384	/* in order to free up the mem and amem arrays for the optimizer,
385	/* and still be able to output yyr1, etc., after the sizes of
386	/* the action array is known, we hide the nonterminals
387	/* derived by productions in levprd.
388	*/
389
390	register i, j;
391
392	j = 0;
393	levprd[0] = 0;
394	PLOOP(1,i){
395	if( !(levprd[i] & REDFLAG) ){
396	++j;
397	if( foutput != NULL ){
398	fprintf( foutput, "Rule not reduced: %s\n", writem( prdptr[i] ) );
399	}
400	}
401	levprd[i] = *prdptr[i] - NTBASE;
402	}
403	if( j ) fprintf( stdout, "%d rules never reduced\n", j );
404	}