![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stmt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / lcc / c|
Return to stmt.c CVS log | Up to [Research Unix] / researchv10no / cmd / lcc / c |
1.1 root 1: /* C compiler: statement parsing */
2:
3: #include "c.h"
4:
5: #define SWITCHSIZE 512 /* initial size of switch arrays */
6:
7: float density = 0.5; /* minimum switch density */
8: float refinc = 1.0; /* amount by which ref field is incremented */
9:
10: static struct equate { /* deferred equates: */
11: Symbol new; /* new label, i.e., label being defined */
12: Symbol old; /* old label */
13: struct equate *oldlink; /* pointer to equate structure for old=x */
14: struct equate *link; /* next equate on list */
15: } *equlist; /* list of deferred equates */
16: struct swtch { /* switch statement data: */
17: Symbol sym; /* local holding the switch value */
18: int lab; /* label of selection code */
19: Symbol deflab; /* default label */
20: int ncases; /* number of cases */
21: int size; /* size of value & label arrays */
22: int *values; /* value, label pairs */
23: Symbol *labels;
24: };
25:
26: dclproto(static void branch,(int));
27: dclproto(static void caselabel,(struct swtch *, int, int));
28: dclproto(static void cmp,(int, Symbol, int, int));
29: dclproto(static void dostmt,(int, struct swtch *, int));
30: dclproto(static int foldcond,(Tree, Tree));
31: dclproto(static void forstmt,(int, struct swtch *, int));
32: dclproto(static void ifstmt,(int, int, struct swtch *, int));
33: dclproto(static Symbol localaddr,(Tree));
34: dclproto(static void stmtlabel,(char *));
35: dclproto(static int swcode,(struct swtch *, int *, int, int, int));
36: dclproto(static void swgen,(struct swtch *));
37: dclproto(static void swstmt,(int, int, int));
38: dclproto(static void visit,(struct equate *));
39: dclproto(static void whilestmt,(int, struct swtch *, int));
40:
41: /* branch - jump to lab */
42: static void branch(lab) {
43: Code cp;
44:
45: walk(0, 0, 0);
46: for (cp = codelist; cp->kind < Label; )
47: cp = cp->prev;
48: if (lab)
49: while (cp->kind == Label && islabel(cp->u.node)
50: && cp->u.node->syms[0]->u.l.label != lab) {
51: Symbol old = findlabel(lab);
52: equatelab(cp->u.node->syms[0], old);
53: old->ref++;
54: if (cp->prev->next = cp->next)
55: cp->next->prev = cp->prev;
56: else
57: codelist = cp->prev;
58: do
59: cp = cp->prev;
60: while (cp->kind < Label);
61: }
62: if (cp->kind != Jump) {
63: code(Jump);
64: codelist->u.node = lab ? jump(lab) : (Node)0;
65: }
66: /* else do nothing and thus delete dead branch */
67: }
68:
69: /* caselabel - add a label to the current switch list */
70: static void caselabel(swp, val, lab) struct swtch *swp; {
71: int k;
72:
73: if (swp->ncases >= swp->size) {
74: int *vals = swp->values;
75: Symbol *labs = swp->labels;
76: swp->size *= 2;
77: swp->values = (int *) talloc(swp->size*sizeof (int));
78: swp->labels = (Symbol *) talloc(swp->size*sizeof (Symbol));
79: for (k = 0; k < swp->ncases; k++) {
80: swp->values[k] = vals[k];
81: swp->labels[k] = labs[k];
82: }
83: }
84: for (k = swp->ncases; k > 0 && swp->values[k-1] >= val; k--) {
85: swp->values[k] = swp->values[k-1];
86: swp->labels[k] = swp->labels[k-1];
87: }
88: if (k < swp->ncases && swp->values[k] == val)
89: error("duplicate case label `%d'\n", val);
90: swp->values[k] = val;
91: swp->labels[k] = findlabel(lab);
92: ++swp->ncases;
93: if (Aflag >= 2 && swp->ncases == 258)
94: warning("more than 257 cases in a switch statement\n");
95: }
96:
97: /* cmp - generate code for `if (p op n) goto lab' for integer n */
98: static void cmp(op, p, n, lab) Symbol p; {
99: listnodes(eqnode(op, cast(idnode(p), inttype), constnode(n, inttype)), lab, 0);
100: }
101:
102: /* definelab - define a label */
103: void definelab(lab) {
104: Code cp;
105:
106: walk(0, 0, 0);
107: code(Label);
108: codelist->u.node = newnode(LABEL+V, 0, 0, findlabel(lab));
109: for (cp = codelist; cp->kind <= Label; )
110: cp = cp->prev;
111: while (cp->kind == Jump && cp->u.node && cp->u.node->kids[0]
112: && cp->u.node->kids[0]->op == ADDRG+P
113: && cp->u.node->kids[0]->syms[0]->u.l.label == lab) {
114: cp->u.node->kids[0]->syms[0]->ref--;
115: assert(cp->next);
116: cp->prev->next = cp->next;
117: cp->next->prev = cp->prev;
118: cp = cp->prev;
119: }
120: }
121:
122: /* definept - define an execution point n: current token at current pc */
123: Code definept(p) Coordinate *p; {
124: int n;
125: Code cp = code(Defpoint);
126:
127: cp->u.point.src = p ? *p : src;
128: cp->u.point.point = npoints;
129: if (ncalled > 0 && (n = findcount(src.file, src.x, src.y)) >= 0)
130: refinc = n/ncalled + 1;
131: if (glevel > 2)
132: locus(identifiers, &cp->u.point.src);
133: if (events.points) {
134: Tree e = 0;
135: apply(events.points, (Generic)&cp->u.point.src, (Generic)&e);
136: if (e)
137: listnodes(e, 0, 0);
138: }
139: return cp;
140: }
141:
142: /* dostmt - do statement while ( expression ) */
143: static void dostmt(lab, swp, lev) struct swtch *swp; {
144: refinc *= 10;
145: t = gettok();
146: definelab(lab);
147: statement(lab, swp, lev);
148: definelab(lab + 1);
149: expect(WHILE);
150: expect('(');
151: definept(0);
152: walk(conditional(')'), lab, 0);
153: if (findlabel(lab + 2)->ref)
154: definelab(lab + 2);
155: }
156:
157: /* equatelab - add new=old to list of deferred equates */
158: void equatelab(new, old) Symbol new, old; {
159: struct equate *e = (struct equate *) talloc(sizeof *e);
160:
161: e->new = new;
162: e->old = old;
163: e->oldlink = 0;
164: e->link = equlist;
165: equlist = e;
166: for (e = e->link; e; e = e->link)
167: if (e->old == new)
168: e->oldlink = equlist;
169: else if (e->new == old)
170: equlist->oldlink = e;
171: }
172:
173: /* flushequ - flush deferred equates */
174: void flushequ() {
175: for ( ; equlist; equlist = equlist->link)
176: visit(equlist);
177: }
178:
179: /* foldcond - check if initial test in for(e1;e2;e3) S is necessary */
180: static int foldcond(e1, e2) Tree e1, e2; {
181: Opcode op = generic(e2->op);
182: Symbol v;
183:
184: if (e1 == 0 || e2 == 0)
185: return 0;
186: if (generic(e1->op) == ASGN && isaddrop(e1->kids[0]->op)
187: && generic(e1->kids[1]->op) == CNST) {
188: v = e1->kids[0]->u.sym;
189: e1 = e1->kids[1];
190: } else
191: return 0;
192: if ((op==LE || op==LT || op==EQ || op==NE || op==GT || op==GE)
193: && generic(e2->kids[0]->op) == INDIR
194: && e2->kids[0]->kids[0]->u.sym == v
195: && e2->kids[1]->op == e1->op) {
196: e1 = simplify(op, e2->type, e1, e2->kids[1]);
197: if (e1->op == CNST+I)
198: return e1->u.v.i;
199: }
200: return 0;
201: }
202:
203: /* forstmt - for ( [expr1] ; [expr2] ; [expr3] ) statement */
204: static void forstmt(lab, swp, lev) struct swtch *swp; {
205: Tree e1, e2, e3;
206: Coordinate pt2, pt3;
207: static char follow[] = { IF, ID, '}', 0 };
208:
209: e1 = e2 = e3 = 0;
210: t = gettok();
211: expect('(');
212: definept(0);
213: if (kind[t] == ID)
214: e1 = expr0(';');
215: else
216: expect(';');
217: walk(e1, 0, 0);
218: pt2 = src;
219: refinc *= 10;
220: if (kind[t] == ID)
221: e2 = texpr(conditional, ';');
222: else
223: expect(';');
224: pt3 = src;
225: if (kind[t] == ID)
226: e3 = texpr(expr0, ')');
227: else
228: test(')', follow);
229: if (glevel == 2) { /* e1; L: if (!e2) goto L+2; S; L+1: e3; goto L; L+2: */
230: definelab(lab);
231: definept(&pt2);
232: if (e2)
233: walk(e2, 0, lab + 2);
234: statement(lab, swp, lev);
235: definelab(lab + 1);
236: definept(&pt3);
237: if (e3)
238: walk(e3, 0, 0);
239: branch(lab);
240: } else { /* e1; goto L+3; L: S; L+1: e3; L+3: if (e2) goto L; L+2: */
241: int once = 0;
242: if (e2) {
243: once = foldcond(e1, e2);
244: if (!once)
245: branch(lab + 3);
246: }
247: definelab(lab);
248: statement(lab, swp, lev);
249: definelab(lab + 1);
250: definept(&pt3);
251: if (e3)
252: walk(e3, 0, 0);
253: if (e2) {
254: if (!once)
255: definelab(lab + 3);
256: definept(&pt2);
257: walk(e2, lab, 0);
258: } else {
259: definept(&pt2);
260: branch(lab);
261: }
262: }
263: if (findlabel(lab + 2)->ref)
264: definelab(lab + 2);
265: }
266:
267: /* ifstmt - if ( expression ) statement [ else statement ] */
268: static void ifstmt(lab, loop, swp, lev) struct swtch *swp; {
269: t = gettok();
270: expect('(');
271: definept(0);
272: walk(conditional(')'), 0, lab);
273: refinc /= 2;
274: statement(loop, swp, lev);
275: if (t == ELSE) {
276: branch(lab + 1);
277: t = gettok();
278: definelab(lab);
279: statement(loop, swp, lev);
280: if (findlabel(lab + 1)->ref)
281: definelab(lab + 1);
282: } else
283: definelab(lab);
284: }
285:
286: /* localaddr - returns q if p yields the address of local/parameter q; otherwise returns 0 */
287: static Symbol localaddr(p) Tree p; {
288: if (p == 0)
289: return 0;
290: switch (generic(p->op)) {
291: case INDIR: case CALL: case ARG:
292: return 0;
293: case ADDRL: case ADDRF:
294: return p->u.sym;
295: case RIGHT: case ASGN:
296: if (p->kids[1])
297: return localaddr(p->kids[1]);
298: return localaddr(p->kids[0]);
299: case COND: {
300: Symbol q;
301: if (p->kids[1] && (q = localaddr(p->kids[1])))
302: return q;
303: return localaddr(p->kids[2]);
304: }
305: default: {
306: Symbol q;
307: if (p->kids[0] && (q = localaddr(p->kids[0])))
308: return q;
309: return localaddr(p->kids[1]);
310: }
311: }
312: }
313:
314: /* retcode - return p from the current function */
315: void retcode(p, lab) Tree p; {
316: if (p == 0) {
317: if (events.returns)
318: apply(events.returns, (Generic)cfunc, (Generic)0);
319: p = tree(RET+V, voidtype, 0, 0);
320: } else {
321: Type ty;
322: p = pointer(p);
323: if (ty = assign(freturn(cfunc->type), p))
324: p = cast(p, ty);
325: else
326: error("illegal return type; found `%t' expected `%t'\n",
327: p->type, freturn(cfunc->type));
328: if (retv) {
329: if (p->op == RIGHT && p->kids[0]->op == CALL+B
330: && p->kids[1]->op == INDIR+B) {
331: p = p->kids[0];
332: p->kids[1] = idnode(retv);
333: } else
334: p = asgnnode(ASGN, rvalue(idnode(retv)), p);
335: walk(p, 0, 0);
336: if (events.returns)
337: apply(events.returns, (Generic)cfunc, (Generic)rvalue(idnode(retv)));
338: p = tree(RET+V, voidtype, 0, 0);
339: } else {
340: if (events.returns) {
341: Symbol t1 = genident(AUTO, p->type, level);
342: addlocal(t1);
343: walk(asgn(t1, p), 0, 0);
344: apply(events.returns, (Generic)cfunc, (Generic)idnode(t1));
345: p = idnode(t1);
346: }
347: p = cast(p, promote(p->type));
348: if (isptr(p->type)) {
349: Symbol q = localaddr(p);
350: if (q && (q->computed || q->generated))
351: warning("pointer to a %s is an illegal return value\n",
352: q->scope == PARAM ? "parameter" : "local");
353: else if (q)
354: warning("pointer to %s `%s' is an illegal return value\n",
355: q->scope == PARAM ? "parameter" : "local", q->name);
356: p = cast(p, unsignedtype);
357: }
358: p = tree(RET + widen(p->type), p->type, p, 0);
359: }
360: }
361: walk(p, 0, 0);
362: branch(lab);
363: }
364:
365: /* statement - parse statements */
366: void statement(loop, swp, lev) struct swtch *swp; {
367: int lab;
368: float ref = refinc;
369:
370: if (Aflag >= 2 && lev == 15)
371: warning("more than 15 levels of nested statements\n");
372: switch (t) {
373: case IF:
374: ifstmt(genlabel(2), loop, swp, lev + 1);
375: break;
376: case WHILE:
377: whilestmt(genlabel(3), swp, lev + 1);
378: break;
379: case DO:
380: dostmt(genlabel(3), swp, lev + 1);
381: expect(';');
382: break;
383: case FOR:
384: forstmt(genlabel(4), swp, lev + 1);
385: break;
386: case SWITCH:
387: swstmt(loop, genlabel(2), lev + 1);
388: break;
389: case CASE:
390: if (swp == 0)
391: error("illegal case label\n");
392: definelab(lab = genlabel(1));
393: while (t == CASE) {
394: static char follow[] = { IF, ID, 0 };
395: Tree p;
396: t = gettok();
397: p = constexpr(0);
398: if (generic(p->op) == CNST && isint(p->type)) {
399: if (swp) {
400: needconst++;
401: p = cast(p, swp->sym->type);
402: needconst--;
403: caselabel(swp, p->u.v.i, lab);
404: }
405: } else
406: error("case label must be a constant integer expression\n");
407: test(':', follow);
408: ntree = 0;
409: }
410: statement(loop, swp, lev);
411: break;
412: case DEFAULT:
413: if (swp)
414: if (swp->deflab)
415: error("extra default label\n");
416: else {
417: swp->deflab = findlabel(swp->lab);
418: definelab(swp->deflab->u.l.label);
419: }
420: else
421: error("illegal default label\n");
422: t = gettok();
423: expect(':');
424: statement(loop, swp, lev);
425: break;
426: case RETURN:
427: t = gettok();
428: definept(0);
429: if (t != ';')
430: if (freturn(cfunc->type) == voidtype) {
431: error("extraneous return value\n");
432: expr(0);
433: retcode(0, cfunc->u.f.label);
434: } else
435: retcode(expr(0), cfunc->u.f.label);
436: else {
437: if (freturn(cfunc->type) != voidtype
438: && (freturn(cfunc->type) != inttype || Aflag >= 1))
439: warning("missing return value\n");
440: retcode(0, cfunc->u.f.label);
441: }
442: expect(';');
443: break;
444: case BREAK:
445: walk(0, 0, 0);
446: if (swp && swp->lab > loop) {
447: definept(0);
448: branch(swp->lab + 1);
449: t = gettok();
450: expect(';');
451: break;
452: }
453: case CONTINUE:
454: walk(0, 0, 0);
455: definept(0);
456: if (loop)
457: branch(loop + (t == BREAK ? 2 : 1));
458: else
459: error("illegal %k statement\n", t);
460: t = gettok();
461: expect(';');
462: break;
463: case '{':
464: compound(loop, swp, lev + 1);
465: break;
466: case ';':
467: definept(0);
468: t = gettok();
469: break;
470: case GOTO:
471: walk(0, 0, 0);
472: definept(0);
473: t = gettok();
474: if (t == ID) {
475: Symbol p = lookup(token, labels[0]);
476: if (p == 0) {
477: p = install(token, &labels[0], 0);
478: p->u.l.label = genlabel(1);
479: p->u.l.equatedto = p;
480: p->src = src;
481: }
482: p->ref++;
483: use(p, src);
484: branch(p->u.l.label);
485: t = gettok();
486: } else
487: error("missing label in goto\n");
488: expect(';');
489: break;
490: case ID:
491: if (getchr() == ':') {
492: stmtlabel(token);
493: statement(loop, swp, lev);
494: break;
495: }
496: default:
497: definept(0);
498: if (kind[t] != ID) {
499: error("unrecognized statement\n");
500: t = gettok();
501: } else {
502: Tree e = expr0(0);
503: listnodes(e, 0, 0);
504: if (glevel > 1 || nodecount == 0 || nodecount > 200)
505: walk(0, 0, 0);
506: ntree = 0;
507: }
508: expect(';');
509: }
510: if (kind[t] != IF && kind[t] != ID && t != '}' && t != EOI) {
511: static char follow[] = { IF, ID, '}', 0 };
512: error("illegal statement termination\n");
513: skipto(0, follow);
514: }
515: refinc = ref;
516: }
517:
518: /* stmtlabel - label : */
519: static void stmtlabel(label) char *label; {
520: Symbol p;
521:
522: if ((p = lookup(label, labels[0])) == 0) {
523: p = install(label, &labels[0], 0);
524: p->u.l.label = genlabel(1);
525: p->u.l.equatedto = p;
526: }
527: if (p->defined)
528: error("redefinition of label `%s' previously defined at %w\n",
529: label, &p->src);
530: p->defined = 1;
531: p->src = src;
532: definelab(p->u.l.label);
533: t = gettok();
534: expect(':');
535: }
536:
537: /* swcode - generate switch decision code for buckets b[lb..ub] */
538: static int swcode(swp, b, lb, ub, n) struct swtch *swp; int b[]; {
539: int hilab, k, l, lolab, median, u, *v;
540:
541: v = swp->values;
542: median = ((float)v[b[lb]] + (float)v[b[ub+1]-1] + 1)/2;
543: for (l = lb, u = ub; l <= u; ) {
544: k = (l + u)/2;
545: if (v[b[k]] > median)
546: u = k - 1;
547: else if (v[b[k+1]-1] < median)
548: l = k + 1;
549: else
550: break;
551: }
552: if (l > u) { /* which of two buckets is closest to the median? */
553: l = b[k];
554: u = b[k+1] - 1;
555: if (median < v[l] && k > lb && v[l] - median > median - v[l-1])
556: k--;
557: else if (median > v[u] && k < ub && median - v[u] > v[u+1] - median)
558: k++;
559: }
560: l = b[k];
561: u = b[k+1] - 1;
562: lolab = hilab = swp->deflab->u.l.label;
563: if (k > lb) {
564: lolab = 0;
565: if (k < ub)
566: hilab = genlabel(1);
567: } else if (k < ub)
568: hilab = 0;
569: if (n == 0)
570: lolab = hilab = 0;
571: if (u - l + 1 <= 3) {
572: int i;
573: for (i = l; i <= u; i++)
574: cmp(EQ, swp->sym, swp->values[i], swp->labels[i]->u.l.label);
575: if (lolab && lolab == hilab)
576: branch(lolab);
577: else {
578: if (lolab)
579: cmp(LT, swp->sym, swp->values[l], lolab);
580: if (hilab)
581: cmp(GT, swp->sym, swp->values[u], hilab);
582: walk(0, 0, 0);
583: }
584: } else {
585: int lab = genlabel(2);
586: Tree e;
587: cmp(LT, swp->sym, swp->values[l], lolab ? lolab : lab);
588: cmp(GT, swp->sym, swp->values[u], hilab ? hilab : lab);
589: e = tree(ADDRG+P, ptr(voidptype), 0, 0);
590: e->u.sym = findlabel(lab + 1);
591: e->u.sym->sclass = STATIC;
592: e->u.sym->type = e->type;
593: walk(tree(JUMP, voidtype, rvalue((*opnode['+'])(ADD, e,
594: (*opnode['-'])(SUB, cast(idnode(swp->sym), inttype),
595: constnode(swp->values[l], inttype)))), 0), 0, 0);
596: definelab(lab + 1);
597: code(Switch);
598: codelist->u.swtch.sym = swp->sym;
599: codelist->u.swtch.deflab = swp->deflab;
600: codelist->u.swtch.size = u - l + 1;
601: codelist->u.swtch.values = &swp->values[l];
602: codelist->u.swtch.labels = &swp->labels[l];
603: branch(0);
604: definelab(lab);
605: if (swp->values[u] - swp->values[l] + 1 >= 10000)
606: warning("switch generates a huge table\n");
607: }
608: if (k > lb)
609: n = swcode(swp, b, lb, k - 1, n - 1);
610: if (k < ub) {
611: if (hilab)
612: definelab(hilab);
613: n = swcode(swp, b, k + 1, ub, n - 1);
614: }
615: return n;
616: }
617:
618: /* swgen - partition case labels into buckets, initiate code generation */
619: #define den(k,n) ((float)(k-buckets[n]+1)/(float)(v[k]-v[buckets[n]]+1))
620: static void swgen(swp) struct swtch *swp; {
621: int *buckets, k, n, *v;
622:
623: if (swp->ncases == 0)
624: return;
625: buckets = (int *) talloc((swp->ncases + 1)*sizeof *buckets);
626: v = swp->values;
627: n = 0;
628: for (k = 0; k < swp->ncases; k++, n++) {
629: buckets[n] = k;
630: while (n > 0) {
631: float d = den(k, n-1);
632: if (d < density || k < swp->ncases - 1 && d < den(k+1, n))
633: break;
634: n--;
635: }
636: }
637: buckets[n--] = swp->ncases;
638: swcode(swp, buckets, 0, n, n);
639: }
640:
641: /* swstmt - switch ( expression ) statement */
642: static void swstmt(loop, lab, lev) {
643: Tree e;
644: struct swtch sw;
645: Code head, tail;
646:
647: t = gettok();
648: expect('(');
649: definept(0);
650: e = expr(')');
651: if (!isint(e->type)) {
652: error("illegal type `%t' in switch expression\n", e->type);
653: e = retype(e, inttype);
654: }
655: e = cast(e, promote(e->type));
656: if (generic(e->op) == INDIR && isaddrop(e->kids[0]->op)
657: && e->kids[0]->u.sym->type == e->type && !isvolatile(e->kids[0]->u.sym->type)) {
658: sw.sym = e->kids[0]->u.sym;
659: walk(0, 0, 0);
660: } else {
661: sw.sym = genident(REGISTER, e->type, level);
662: addlocal(sw.sym);
663: walk(asgn(sw.sym, e), 0, 0);
664: }
665: code(Switch);
666: head = codelist;
667: sw.lab = lab;
668: sw.deflab = 0;
669: sw.ncases = 0;
670: sw.size = SWITCHSIZE;
671: sw.values = (int *) talloc(SWITCHSIZE*sizeof (int));
672: sw.labels = (Symbol *) talloc(SWITCHSIZE*sizeof (Symbol));
673: refinc /= 10;
674: statement(loop, &sw, lev);
675: if (sw.deflab == 0) {
676: sw.deflab = findlabel(lab);
677: definelab(lab);
678: if (sw.ncases == 0)
679: warning("switch statement with no cases\n");
680: }
681: if (findlabel(lab + 1)->ref)
682: definelab(lab + 1);
683: tail = codelist;
684: codelist = head->prev;
685: swgen(&sw);
686: branch(lab);
687: head->next->prev = codelist;
688: codelist->next = head->next;
689: codelist = tail;
690: }
691:
692: /* visit - equate p->new=p->old, equating predecessor first */
693: static void visit(p) struct equate *p; {
694: if (p && p->old) {
695: visit(p->oldlink);
696: p->new->u.l.equatedto = p->old->u.l.equatedto;
697: p->old = 0;
698: }
699: }
700:
701: /* whilestmt - while ( expression ) statement */
702: static void whilestmt(lab, swp, lev) struct swtch *swp; {
703: Coordinate pt;
704: Tree e;
705:
706: refinc *= 10;
707: t = gettok();
708: expect('(');
709: walk(0, 0, 0);
710: pt = src;
711: e = texpr(conditional, ')');
712: if (generic(e->op) == CNST || glevel == 2) {
713: /* L, L+1: if (!e) goto L+2; S; goto L; L+2: */
714: definelab(lab);
715: definelab(lab + 1);
716: definept(&pt);
717: walk(e, 0, lab + 2);
718: statement(lab, swp, lev);
719: branch(lab);
720: } else { /* goto L+1; L: S; L+1: if (E) goto L; L+2: */
721: branch(lab + 1);
722: definelab(lab);
723: statement(lab, swp, lev);
724: definelab(lab + 1);
725: definept(&pt);
726: walk(e, lab, 0);
727: }
728: if (findlabel(lab + 2)->ref)
729: definelab(lab + 2);
730: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.