![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to y5.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / yacc|
Return to y5.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / yacc |
1.1 root 1: /*
2: * write goto table and parsing table out to temp file
3: * to be picked up later by the optimizer
4: * at this point, the tables are fit to be processed by the C parser
5: */
6: #include "yacc.h"
7: #include <action.h>
8:
9: char *actns[] = {
10: "SHIFT",
11: "REDUCE",
12: "ACCEPT",
13: "ERROR"
14: };
15:
16: static int *uv;
17:
18: go2out()
19: {
20: register i;
21:
22: if( verbose )
23: fprintf(listout, "\n\nGoto table:\n\n");
24: uv = (int *)yalloc(nstates, sizeof *uv);
25: rewopt();
26: for(i=1; i<nnonterm; i++)
27: outgo2(i);
28: free(uv);
29: }
30:
31: outgo2(n)
32: {
33: extern yyredns, yygodef;
34: int max, sno, j;
35: struct sym *sp;
36: struct go2n g2;
37:
38:
39: sp = ntrmptr[n];
40: for(j=0; j<sp->s_nstates; j++)
41: uv[j] = 0;
42: max = 0;
43: for(j=0; j<sp->s_nstates; j++) {
44: sno = findnt( &states[sp->s_states[j]], n+NTBASE)->ng_st;
45: if( ++uv[sno] > uv[max] )
46: max = sno;
47: }
48: yygodef += uv[max];
49: g2.from = (YYGOTO<<YYACTSH) | n;
50: g2.to = sp->s_nstates - uv[max] + 1;
51: yyredns += g2.to;
52: fwrite(&g2, sizeof g2, 1, optout);
53: if( verbose )
54: fprintf(listout, "%s:\n\n", ntrmptr[n]->s_name);
55: for(j=0; j<sp->s_nstates; j++) {
56: sno = sp->s_states[j];
57: if( (g2.to=findnt(&states[sno], n+NTBASE)->ng_st) == max )
58: continue;
59: g2.from = sno;
60: if( verbose )
61: fprintf(listout, "\t%d\t%d\n", g2.from, g2.to);
62: fwrite(&g2, sizeof g2, 1, optout);
63: }
64: g2.from = YYOTHERS;
65: g2.to = max;
66: fwrite(&g2, sizeof g2, 1, optout);
67: if( verbose )
68: fprintf(listout, "\t.\t%d\n\n", max);
69: }
70:
71: paout()
72: {
73: register i;
74:
75: if( verbose )
76: fprintf(listout, "\n\nParsing action table:\n\n");
77: for(i=0; i<nstates; i++)
78: outstate(i);
79: }
80:
81: outstate(n)
82: {
83: extern yydefact, yypact;
84: register i, k;
85: register struct state *stp;
86: int size, max, errshift, pno, maxp, j, l;
87: struct lset shls, rdls;
88: struct actn rdact[MAXREDS], act;
89:
90: stp = &states[n];
91: zerolset(&shls);
92: for(i=0; i<stp->s_tgo; i++)
93: setbit(&shls, stp->s_tgos[i].tg_trm);
94: max = 0;
95: maxp = -1;
96: for(i=k=0; i<stp->s_nred; i++) {
97: pno = stp->s_reds[i].rd_prod->p_prodno;
98: copylset(&rdls, stp->s_reds[i].rd_lset);
99: resolve(n, i, &shls, &rdls);
100: size = 0;
101: for(j=first(&rdls); j>=0; j=next(&rdls, j)) {
102: for(l=0; l<k; l++)
103: if( rdact[l].a_chr==j ) {
104: redred(n, pno, rdact[l].a_no&YYAMASK, j);
105: goto nextj; /* C needs next <var> */
106: }
107: bounded(l, MAXREDS, "reductions");
108: rdact[k].a_chr = j;
109: rdact[k++].a_no = (YYREDACT<<YYACTSH) | pno;
110: size++;
111: nextj:
112: ;
113: }
114: if( size>max ) {
115: max = size;
116: maxp = pno;
117: }
118: }
119: if( bit(&shls, ERRNO) || maxp==0 ) /* shift on error or accept */
120: maxp = -1;
121:
122: /* count total number of actions */
123: size = k + lcount(&shls) + !bit(&shls,ERRNO); /* shifts+reds+default */
124: if( maxp >= 0 ) {
125: size -= max;
126: yydefact += max;
127: }
128: yypact += size;
129: act.a_chr = size;
130: act.a_no = (YYPACTION<<YYACTSH) | n;
131: if( verbose )
132: fprintf(listout, "State %d (size %d):\n\n", n, size);
133: fwrite(&act, sizeof act, 1, optout);
134:
135: /* now have shifts in shls redns in rdact */
136:
137: /* output shifts */
138: for(j=0; j<stp->s_tgo; j++) {
139: if( !bit(&shls, i = stp->s_tgos[j].tg_trm) )
140: continue;
141: if( i==ERRNO ) { /* will be made default */
142: errshift = stp->s_tgos[j].tg_st;
143: continue;
144: }
145: act.a_chr = i;
146: act.a_no = (YYSHIFTACT<<YYACTSH) | stp->s_tgos[j].tg_st;
147: wract(&act);
148: }
149:
150: /* output reductions */
151: for(i=0; i<k; i++) {
152: if( (pno = rdact[i].a_no&YYAMASK) == maxp )
153: continue;
154: if( pno==0 ) /* $accept -> start $end . */
155: rdact[i].a_no = YYACCEPTACT<<YYACTSH;
156: wract(&rdact[i]);
157: }
158:
159: /* default action */
160: act.a_chr = YYOTHERS;
161: if( bit(&shls, ERRNO) ) {
162: act.a_no = (YYSHIFTACT<<YYACTSH) | errshift;
163: } else if( maxp>=0 )
164: act.a_no = YYREDACT<<YYACTSH | maxp;
165: else
166: act.a_no = (YYERRACT<<YYACTSH);
167: wract(&act);
168: }
169:
170: wract(actp)
171: register struct actn *actp;
172: {
173: register unsigned actn;
174: actn = actp->a_no>>YYACTSH;
175: if( verbose ) {
176: fprintf(listout, "\t%s\t%s", actp->a_chr==YYOTHERS?".":
177: trmptr[actp->a_chr]->s_name, actns[actn]);
178: if( actn<=YYREDACT )
179: fprintf(listout, "\t%d", actp->a_no&YYAMASK);
180: fprintf(listout, "\n");
181: }
182: fwrite(actp, sizeof *actp, 1, optout);
183: }
184:
185: lcount(lp)
186: struct lset *lp;
187: {
188: register n, count;
189: register unsigned char *ucp;
190: extern unsigned char bcount[];
191:
192: count = 0;
193: ucp = lp->l_bits;
194: n = LSETSIZE;
195: do {
196: count += bcount[*ucp++];
197: } while (--n);
198: return(count);
199: }
200:
201: setdiff(ld, ls)
202: struct lset *ld, *ls;
203: {
204: register n;
205: register unsigned char *udcp, *uscp;
206:
207: n = LSETSIZE;
208: udcp = ld->l_bits;
209: uscp = ls->l_bits;
210: do {
211: *udcp++ &= ~ *uscp++;
212: } while (--n);
213: }
214:
215: setunion(ld, ls)
216: struct lset *ld, *ls;
217: {
218: register n;
219: register unsigned char *udcp, *uscp;
220:
221: n = LSETSIZE;
222: udcp = ld->l_bits;
223: uscp = ls->l_bits;
224: do {
225: *udcp++ |= *uscp++;
226: } while (--n);
227: }
228:
229: setint(ld, ls)
230: struct lset *ld, *ls;
231: {
232: register n;
233: register unsigned char *udcp, *uscp;
234:
235: n = LSETSIZE;
236: udcp = ld->l_bits;
237: uscp = ls->l_bits;
238: do {
239: *udcp++ &= *uscp++;
240: } while (--n);
241: }
242:
243: copylset(ld, ls)
244: struct lset *ld, *ls;
245: {
246: register n;
247: register unsigned char *udcp, *uscp;
248:
249: n = LSETSIZE;
250: udcp = ld->l_bits;
251: uscp = ls->l_bits;
252: do {
253: *udcp++ = *uscp++;
254: } while (--n);
255: }
256:
257: zerolset(ld)
258: struct lset *ld;
259: {
260: register n;
261: register unsigned char *udcp;
262:
263: n = LSETSIZE;
264: udcp = ld->l_bits;
265: do {
266: *udcp++ = 0;
267: } while (--n);
268: }
269:
270: resolve(sno, p, sls, rls)
271: int p;
272: struct lset *sls, *rls;
273: {
274: register i;
275: struct lset cls;
276: int todo;
277: struct prod *pp;
278: struct sym *tsp;
279:
280: copylset(&cls, sls);
281: setint(&cls, rls);
282: pp = states[sno].s_reds[p].rd_prod;
283: for(i=first(&cls); i>=0; i=next(&cls,i) ) { /* conflict on term i */
284: tsp = trmptr[i];
285: if( tsp->s_ass<=UNASSOC || pp->p_ass<=UNASSOC ) {
286: shiftred(sno, pp->p_prodno, i);
287: clrbit(rls, i);
288: continue;
289: /* conflict resolved in favour of shift */
290: }
291: if( pp->p_prc > tsp->s_prc )
292: todo = LASSOC;
293: else if( pp->p_prc < tsp->s_prc )
294: todo = RASSOC;
295: else
296: todo = tsp->s_ass;
297: switch( todo ) {
298: case LASSOC: /* reduce */
299: clrbit(sls, i);
300: break;
301:
302: case RASSOC:
303: clrbit(rls, i);
304: break;
305:
306: case UNASSOC: /* non-self associating op */
307: clrbit(rls, i);
308: clrbit(sls, i);
309: break;
310: }
311: }
312: }
313:
314: shiftred(sno, pn, tok)
315: {
316: register i;
317: struct state *stp;
318:
319: stp = &states[sno];
320: ++nsrconf;
321: if( !verbose )
322: return;
323: for(i=0; i<stp->s_tgo; i++)
324: if( stp->s_tgos[i].tg_trm==tok )
325: break;
326: fprintf(listout, "State %d: Shift/Reduce conflict ", sno);
327: fprintf(listout, "(shift %d, red'n %d) on %s\n",
328: stp->s_tgos[i].tg_st, pn, trmptr[tok]->s_name);
329: }
330:
331: redred(sno, pn1, pn2, tok)
332: {
333: struct state *stp;
334:
335: stp = &states[sno];
336: ++nrrconf;
337: if( !verbose )
338: return;
339: fprintf(listout, "State %d: Reduce/Reduce conflict ", sno);
340: fprintf(listout, "(red'n %d, red'n %d) on %s\n",
341: pn1, pn2, trmptr[tok]->s_name);
342: }
343:
344: clrbit(lp, n)
345: struct lset *lp;
346: register n;
347: {
348: register unsigned char *ucp;
349:
350: ucp = lp->l_bits;
351: ucp[n>>LOGCHAR] &= ~( 01 << (n & (NBCHAR-1)) );
352: }
353:
354: setbit(lp, n)
355: struct lset *lp;
356: register n;
357: {
358: register unsigned char *ucp;
359:
360: ucp = lp->l_bits;
361: ucp[n>>LOGCHAR] |= 01 << (n & (NBCHAR-1));
362: }
363:
364: bit(lp, n)
365: struct lset *lp;
366: register n;
367: {
368: register unsigned char *ucp;
369:
370: ucp = lp->l_bits;
371: return( (ucp[n>>LOGCHAR] >> (n&(NBCHAR-1))) & 01 );
372: }
373:
374: first(lp)
375: struct lset *lp;
376: {
377: return(next(lp,-1));
378: }
379:
380: next(lp, n)
381: struct lset *lp;
382: register n;
383: {
384: register w;
385: register unsigned char *ucp;
386: extern char ltab[];
387:
388: if( ++n >= LSETSIZE*NBCHAR )
389: return(-1);
390: ucp = lp->l_bits;
391: w = ucp[n >> LOGCHAR];
392: w &= ~ ( (01 << (n&(NBCHAR-1))) - 1);
393: n >>= LOGCHAR;
394: while (w == 0) {
395: if ( ++n >= LSETSIZE )
396: return(-1);
397: w = ucp[n];
398: }
399: return( (n<<LOGCHAR) + ltab[w] );
400: }
401:
402: struct ntgo *
403: findnt(stp, nt)
404: register struct state *stp;
405: {
406: register i;
407:
408: for(i=0; i<stp->s_ntgo; i++ )
409: if( stp->s_ntgos[i].ng_nt==nt )
410: return( &stp->s_ntgos[i] );
411: yyerror(NLNO|FATAL, "oops in findnt");
412: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.