![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to exec.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / pgrm / f77 / pass1.tahoe|
Return to exec.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / f77 / pass1.tahoe |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)exec.c 5.2 (Berkeley) 6/7/85";
9: #endif not lint
10:
11: /*
12: * exec.c
13: *
14: * Routines for handling the semantics of control structures.
15: * F77 compiler, pass 1.
16: *
17: * University of Utah CS Dept modification history:
18: *
19: * Revision 2.3 85/03/18 08:03:31 donn
20: * Hacks for conversions from type address to numeric type -- prevent addresses
21: * from being stored in shorts and prevent warnings about implicit conversions.
22: *
23: * Revision 2.2 84/09/03 23:18:30 donn
24: * When a DO loop had the same variable as its loop variable and its limit,
25: * the limit temporary was assigned to AFTER the original value of the variable
26: * was destroyed by assigning the initial value to the loop variable. I
27: * swapped the operands of a comparison and changed the direction of the
28: * operator... This only affected programs when optimizing. (This may not
29: * be enough if something alters the order of evaluation of side effects
30: * later on... sigh.)
31: *
32: * Revision 2.1 84/07/19 12:02:53 donn
33: * Changed comment headers for UofU.
34: *
35: * Revision 1.3 84/07/12 18:35:12 donn
36: * Added change to enddo() to detect open 'if' blocks at the ends of loops.
37: *
38: * Revision 1.2 84/06/08 11:22:53 donn
39: * Fixed bug in exdo() -- if a loop parameter contained an instance of the loop
40: * variable and the optimizer was off, the loop variable got converted to
41: * register before the parameters were processed and so the loop parameters
42: * were initialized from garbage in the register instead of the memory version
43: * of the loop variable.
44: *
45: */
46:
47: #include "defs.h"
48: #include "optim.h"
49:
50:
51: /* Logical IF codes
52: */
53:
54:
55: exif(p)
56: expptr p;
57: {
58: register int k;
59: pushctl(CTLIF);
60: ctlstack->elselabel = newlabel();
61:
62: if( ( k = (p = fixtype(p))->headblock.vtype) != TYLOGICAL)
63: {
64: if(k != TYERROR)
65: err("non-logical expression in IF statement");
66: frexpr(p);
67: }
68: else if (optimflag)
69: optbuff (SKIFN, p, ctlstack->elselabel, 0);
70: else
71: putif (p, ctlstack->elselabel);
72: }
73:
74:
75:
76: exelif(p)
77: expptr p;
78: {
79: int k,oldelse;
80:
81: if( ( k = (p = fixtype(p))->headblock.vtype) != TYLOGICAL)
82: {
83: if(k != TYERROR)
84: err("non-logical expression in IF statement");
85: frexpr(p);
86: }
87: else {
88: if(ctlstack->ctltype == CTLIF)
89: {
90: if(ctlstack->endlabel == 0) ctlstack->endlabel = newlabel();
91: oldelse=ctlstack->elselabel;
92: ctlstack->elselabel = newlabel();
93: if (optimflag)
94: {
95: optbuff (SKGOTO, 0, ctlstack->endlabel, 0);
96: optbuff (SKLABEL, 0, oldelse, 0);
97: optbuff (SKIFN, p, ctlstack->elselabel, 0);
98: }
99: else
100: {
101: putgoto (ctlstack->endlabel);
102: putlabel (oldelse);
103: putif (p, ctlstack->elselabel);
104: }
105: }
106: else execerr("elseif out of place", CNULL);
107: }
108: }
109:
110:
111:
112:
113:
114: exelse()
115: {
116: if(ctlstack->ctltype==CTLIF)
117: {
118: if(ctlstack->endlabel == 0)
119: ctlstack->endlabel = newlabel();
120: ctlstack->ctltype = CTLELSE;
121: if (optimflag)
122: {
123: optbuff (SKGOTO, 0, ctlstack->endlabel, 0);
124: optbuff (SKLABEL, 0, ctlstack->elselabel, 0);
125: }
126: else
127: {
128: putgoto (ctlstack->endlabel);
129: putlabel (ctlstack->elselabel);
130: }
131: }
132:
133: else execerr("else out of place", CNULL);
134: }
135:
136:
137: exendif()
138: {
139: if (ctlstack->ctltype == CTLIF)
140: {
141: if (optimflag)
142: {
143: optbuff (SKLABEL, 0, ctlstack->elselabel, 0);
144: if (ctlstack->endlabel)
145: optbuff (SKLABEL, 0, ctlstack->endlabel, 0);
146: }
147: else
148: {
149: putlabel (ctlstack->elselabel);
150: if (ctlstack->endlabel)
151: putlabel (ctlstack->endlabel);
152: }
153: popctl ();
154: }
155: else if (ctlstack->ctltype == CTLELSE)
156: {
157: if (optimflag)
158: optbuff (SKLABEL, 0, ctlstack->endlabel, 0);
159: else
160: putlabel (ctlstack->endlabel);
161: popctl ();
162: }
163: else
164: execerr("endif out of place", CNULL);
165: }
166:
167:
168:
169: LOCAL pushctl(code)
170: int code;
171: {
172: register int i;
173:
174: /* fprintf(diagfile,"old blklevel %d \n",blklevel); dmpframe(ctlstack); */
175: if(++ctlstack >= lastctl)
176: many("loops or if-then-elses", 'c');
177: ctlstack->ctltype = code;
178: for(i = 0 ; i < 4 ; ++i)
179: ctlstack->ctlabels[i] = 0;
180: ++blklevel;
181: }
182:
183:
184: LOCAL popctl()
185: {
186: if( ctlstack-- < ctls )
187: fatal("control stack empty");
188: --blklevel;
189: }
190:
191:
192:
193: LOCAL poplab()
194: {
195: register struct Labelblock *lp;
196:
197: for(lp = labeltab ; lp < highlabtab ; ++lp)
198: if(lp->labdefined)
199: {
200: /* mark all labels in inner blocks unreachable */
201: if(lp->blklevel > blklevel)
202: lp->labinacc = YES;
203: }
204: else if(lp->blklevel > blklevel)
205: {
206: /* move all labels referred to in inner blocks out a level */
207: lp->blklevel = blklevel;
208: }
209: }
210:
211:
212:
213: /* BRANCHING CODE
214: */
215:
216: exgoto(lab)
217: struct Labelblock *lab;
218: {
219: if (optimflag)
220: optbuff (SKGOTO, 0, lab->labelno, 0);
221: else
222: putgoto (lab->labelno);
223: }
224:
225:
226:
227:
228:
229:
230:
231: exequals(lp, rp)
232: register struct Primblock *lp;
233: register expptr rp;
234: {
235: register Namep np;
236:
237: if(lp->tag != TPRIM)
238: {
239: err("assignment to a non-variable");
240: frexpr(lp);
241: frexpr(rp);
242: }
243: else if(lp->namep->vclass!=CLVAR && lp->argsp)
244: {
245: if(parstate >= INEXEC)
246: err("assignment to an undimemsioned array");
247: else
248: mkstfunct(lp, rp);
249: }
250: else
251: {
252: np = (Namep) lp->namep;
253: if (np->vclass == CLPROC && np->vprocclass == PTHISPROC
254: && proctype == TYSUBR)
255: {
256: err("assignment to a subroutine name");
257: return;
258: }
259: if(parstate < INDATA)
260: enddcl();
261: if (optimflag)
262: optbuff (SKEQ, mkexpr(OPASSIGN, mklhs(lp), fixtype(rp)), 0, 0);
263: else
264: puteq (mklhs(lp), fixtype(rp));
265: }
266: }
267:
268:
269:
270: mkstfunct(lp, rp)
271: struct Primblock *lp;
272: expptr rp;
273: {
274: register struct Primblock *p;
275: register Namep np;
276: chainp args;
277:
278: if(parstate < INDATA)
279: {
280: enddcl();
281: parstate = INDATA;
282: }
283:
284: np = lp->namep;
285: if(np->vclass == CLUNKNOWN)
286: np->vclass = CLPROC;
287: else
288: {
289: dclerr("redeclaration of statement function", np);
290: return;
291: }
292: np->vprocclass = PSTFUNCT;
293: np->vstg = STGSTFUNCT;
294: impldcl(np);
295: args = (lp->argsp ? lp->argsp->listp : CHNULL);
296: np->varxptr.vstfdesc = mkchain(args , rp );
297:
298: for( ; args ; args = args->nextp)
299: if( args->datap->tag!=TPRIM ||
300: (p = (struct Primblock *) (args->datap) )->argsp ||
301: p->fcharp || p->lcharp )
302: err("non-variable argument in statement function definition");
303: else
304: {
305: args->datap = (tagptr) (p->namep);
306: vardcl(p->namep);
307: free(p);
308: }
309: }
310:
311:
312:
313: excall(name, args, nstars, labels)
314: Namep name;
315: struct Listblock *args;
316: int nstars;
317: struct Labelblock *labels[ ];
318: {
319: register expptr p;
320:
321: settype(name, TYSUBR, ENULL);
322: p = mkfunct( mkprim(name, args, CHNULL) );
323: p->exprblock.vtype = p->exprblock.leftp->headblock.vtype = TYINT;
324: if (nstars > 0)
325: if (optimflag)
326: optbuff (SKCMGOTO, p, nstars, labels);
327: else
328: putcmgo (p, nstars, labels);
329: else
330: if (optimflag)
331: optbuff (SKCALL, p, 0, 0);
332: else
333: putexpr (p);
334: }
335:
336:
337:
338: exstop(stop, p)
339: int stop;
340: register expptr p;
341: {
342: char *q;
343: int n;
344: expptr mkstrcon();
345:
346: if(p)
347: {
348: if( ! ISCONST(p) )
349: {
350: execerr("pause/stop argument must be constant", CNULL);
351: frexpr(p);
352: p = mkstrcon(0, CNULL);
353: }
354: else if( ISINT(p->constblock.vtype) )
355: {
356: q = convic(p->constblock.const.ci);
357: n = strlen(q);
358: if(n > 0)
359: {
360: p->constblock.const.ccp = copyn(n, q);
361: p->constblock.vtype = TYCHAR;
362: p->constblock.vleng = (expptr) ICON(n);
363: }
364: else
365: p = (expptr) mkstrcon(0, CNULL);
366: }
367: else if(p->constblock.vtype != TYCHAR)
368: {
369: execerr("pause/stop argument must be integer or string", CNULL);
370: p = (expptr) mkstrcon(0, CNULL);
371: }
372: }
373: else p = (expptr) mkstrcon(0, CNULL);
374:
375: if (optimflag)
376: optbuff ((stop ? SKSTOP : SKPAUSE), p, 0, 0);
377: else
378: putexpr (call1(TYSUBR, (stop ? "s_stop" : "s_paus"), p));
379: }
380:
381:
382: /* UCB DO LOOP CODE */
383:
384: #define DOINIT par[0]
385: #define DOLIMIT par[1]
386: #define DOINCR par[2]
387:
388: #define CONSTINIT const[0]
389: #define CONSTLIMIT const[1]
390: #define CONSTINCR const[2]
391:
392: #define VARSTEP 0
393: #define POSSTEP 1
394: #define NEGSTEP 2
395:
396:
397: exdo(range, spec)
398: int range;
399: chainp spec;
400:
401: {
402: register expptr p, q;
403: expptr q1;
404: register Namep np;
405: chainp cp;
406: register int i;
407: int dotype, incsign;
408: Addrp dovarp, dostgp;
409: expptr par[3];
410: expptr const[3];
411: Slotp doslot;
412:
413: pushctl(CTLDO);
414: dorange = ctlstack->dolabel = range;
415: np = (Namep) (spec->datap);
416: ctlstack->donamep = NULL;
417: if(np->vdovar)
418: {
419: errstr("nested loops with variable %s", varstr(VL,np->varname));
420: return;
421: }
422:
423: dovarp = mkplace(np);
424: dotype = dovarp->vtype;
425:
426: if( ! ONEOF(dotype, MSKINT|MSKREAL) )
427: {
428: err("bad type on DO variable");
429: return;
430: }
431:
432:
433: for(i=0 , cp = spec->nextp ; cp!=NULL && i<3 ; cp = cp->nextp)
434: {
435: p = fixtype((expptr) cpexpr((tagptr) q = cp->datap));
436: if(!ONEOF(p->headblock.vtype, MSKINT|MSKREAL) )
437: {
438: err("bad type on DO parameter");
439: return;
440: }
441:
442:
443: if (ISCONST(q))
444: const[i] = mkconv(dotype, q);
445: else
446: {
447: frexpr(q);
448: const[i] = NULL;
449: }
450:
451: par[i++] = mkconv(dotype, p);
452: }
453:
454: frchain(&spec);
455: switch(i)
456: {
457: case 0:
458: case 1:
459: err("too few DO parameters");
460: return;
461:
462: case 2:
463: DOINCR = (expptr) ICON(1);
464: CONSTINCR = ICON(1);
465:
466: case 3:
467: break;
468:
469: default:
470: err("too many DO parameters");
471: return;
472: }
473:
474: ctlstack->donamep = np;
475:
476: np->vdovar = YES;
477: if( !optimflag && enregister(np) )
478: {
479: /* stgp points to a storage version, varp to a register version */
480: dostgp = dovarp;
481: dovarp = mkplace(np);
482: }
483: else
484: dostgp = NULL;
485:
486: for (i = 0; i < 4; i++)
487: ctlstack->ctlabels[i] = newlabel();
488:
489: if( CONSTLIMIT )
490: ctlstack->domax = DOLIMIT;
491: else
492: ctlstack->domax = (expptr) mktemp(dotype, PNULL);
493:
494: if( CONSTINCR )
495: {
496: ctlstack->dostep = DOINCR;
497: if( (incsign = conssgn(CONSTINCR)) == 0)
498: err("zero DO increment");
499: ctlstack->dostepsign = (incsign > 0 ? POSSTEP : NEGSTEP);
500: }
501: else
502: {
503: ctlstack->dostep = (expptr) mktemp(dotype, PNULL);
504: ctlstack->dostepsign = VARSTEP;
505: }
506:
507: if (optimflag)
508: doslot = optbuff (SKDOHEAD,0,0,ctlstack);
509:
510: if( CONSTLIMIT && CONSTINIT && ctlstack->dostepsign!=VARSTEP)
511: {
512: if (optimflag)
513: optbuff (SKEQ,mkexpr(OPASSIGN,cpexpr(dovarp),cpexpr(DOINIT)),
514: 0,0);
515: else
516: puteq (cpexpr(dovarp), cpexpr(DOINIT));
517: if( ! onetripflag )
518: {
519: q = mkexpr(OPMINUS, cpexpr(CONSTLIMIT), cpexpr(CONSTINIT));
520: if((incsign * conssgn(q)) == -1)
521: {
522: warn("DO range never executed");
523: if (optimflag)
524: optbuff (SKGOTO,0,ctlstack->endlabel,0);
525: else
526: putgoto (ctlstack->endlabel);
527: }
528: frexpr(q);
529: }
530: }
531:
532:
533: else if (ctlstack->dostepsign != VARSTEP && !onetripflag)
534: {
535: if (CONSTLIMIT)
536: q = (expptr) cpexpr(ctlstack->domax);
537: else
538: q = mkexpr(OPASSIGN, cpexpr(ctlstack->domax), DOLIMIT);
539: q1 = mkexpr(OPASSIGN, cpexpr(dovarp), DOINIT);
540: q = mkexpr( (ctlstack->dostepsign == POSSTEP ? OPGE : OPLE),
541: q, q1);
542: if (optimflag)
543: optbuff (SKIFN,q, ctlstack->endlabel,0);
544: else
545: putif (q, ctlstack->endlabel);
546: }
547: else
548: {
549: if (!CONSTLIMIT)
550: if (optimflag)
551: optbuff (SKEQ,
552: mkexpr(OPASSIGN,cpexpr(ctlstack->domax),DOLIMIT),0,0);
553: else
554: puteq (cpexpr(ctlstack->domax), DOLIMIT);
555: q = DOINIT;
556: if (!onetripflag)
557: q = mkexpr(OPMINUS, q,
558: mkexpr(OPASSIGN, cpexpr(ctlstack->dostep),
559: DOINCR) );
560: if (optimflag)
561: optbuff (SKEQ,mkexpr(OPASSIGN,cpexpr(dovarp), q),0,0);
562: else
563: puteq (cpexpr(dovarp), q);
564: if (onetripflag && ctlstack->dostepsign == VARSTEP)
565: if (optimflag)
566: optbuff (SKEQ,
567: mkexpr(OPASSIGN,cpexpr(ctlstack->dostep),DOINCR),0,0);
568: else
569: puteq (cpexpr(ctlstack->dostep), DOINCR);
570: }
571:
572: if (ctlstack->dostepsign == VARSTEP)
573: {
574: expptr incr,test;
575: if (onetripflag)
576: if (optimflag)
577: optbuff (SKGOTO,0,ctlstack->dobodylabel,0);
578: else
579: putgoto (ctlstack->dobodylabel);
580: else
581: if (optimflag)
582: optbuff (SKIFN,mkexpr(OPGE, cpexpr(ctlstack->dostep), ICON(0)),
583: ctlstack->doneglabel,0);
584: else
585: putif (mkexpr(OPGE, cpexpr(ctlstack->dostep), ICON(0)),
586: ctlstack->doneglabel);
587: if (optimflag)
588: optbuff (SKLABEL,0,ctlstack->doposlabel,0);
589: else
590: putlabel (ctlstack->doposlabel);
591: incr = mkexpr(OPPLUSEQ, cpexpr(dovarp), cpexpr(ctlstack->dostep));
592: test = mkexpr(OPLE, incr, cpexpr(ctlstack->domax));
593: if (optimflag)
594: optbuff (SKIFN,test, ctlstack->endlabel,0);
595: else
596: putif (test, ctlstack->endlabel);
597: }
598:
599: if (optimflag)
600: optbuff (SKLABEL,0,ctlstack->dobodylabel,0);
601: else
602: putlabel (ctlstack->dobodylabel);
603: if (dostgp)
604: {
605: if (optimflag)
606: optbuff (SKEQ,mkexpr(OPASSIGN,dostgp, dovarp),0,0);
607: else
608: puteq (dostgp, dovarp);
609: }
610: else
611: frexpr(dovarp);
612: if (optimflag)
613: doslot->nullslot = optbuff (SKNULL,0,0,0);
614:
615: frexpr(CONSTINIT);
616: frexpr(CONSTLIMIT);
617: frexpr(CONSTINCR);
618: }
619:
620:
621: enddo(here)
622: int here;
623:
624: {
625: register struct Ctlframe *q;
626: Namep np;
627: Addrp ap, rv;
628: expptr t;
629: register int i;
630: Slotp doslot;
631:
632: while (here == dorange)
633: {
634: while (ctlstack->ctltype == CTLIF || ctlstack->ctltype == CTLELSE)
635: {
636: execerr("missing endif", CNULL);
637: exendif();
638: }
639:
640: if (np = ctlstack->donamep)
641: {
642: rv = mkplace (np);
643:
644: t = mkexpr(OPPLUSEQ, cpexpr(rv), cpexpr(ctlstack->dostep) );
645:
646: if (optimflag)
647: doslot = optbuff (SKENDDO,0,0,ctlstack);
648:
649: if (ctlstack->dostepsign == VARSTEP)
650: if (optimflag)
651: {
652: optbuff (SKIFN,
653: mkexpr(OPLE, cpexpr(ctlstack->dostep), ICON(0)),
654: ctlstack->doposlabel,0);
655: optbuff (SKLABEL,0,ctlstack->doneglabel,0);
656: optbuff (SKIFN,mkexpr(OPLT, t, ctlstack->domax),
657: ctlstack->dobodylabel,0);
658: }
659: else
660: {
661: putif (mkexpr(OPLE, cpexpr(ctlstack->dostep), ICON(0)),
662: ctlstack->doposlabel);
663: putlabel (ctlstack->doneglabel);
664: putif (mkexpr(OPLT, t, ctlstack->domax),
665: ctlstack->dobodylabel);
666: }
667: else
668: {
669: int op;
670: op = (ctlstack->dostepsign == POSSTEP ? OPGT : OPLT);
671: if (optimflag)
672: optbuff (SKIFN, mkexpr(op,t,ctlstack->domax),
673: ctlstack->dobodylabel,0);
674: else
675: putif (mkexpr(op, t, ctlstack->domax),
676: ctlstack->dobodylabel);
677: }
678: if (optimflag)
679: optbuff (SKLABEL,0,ctlstack->endlabel,0);
680: else
681: putlabel (ctlstack->endlabel);
682:
683: if (ap = memversion(np))
684: {
685: if (optimflag)
686: optbuff (SKEQ,mkexpr(OPASSIGN,ap, rv),0,0);
687: else
688: puteq (ap, rv);
689: }
690: else
691: frexpr(rv);
692: for (i = 0; i < 4; i++)
693: ctlstack->ctlabels[i] = 0;
694: if (!optimflag)
695: deregister(ctlstack->donamep);
696: ctlstack->donamep->vdovar = NO;
697: if (optimflag)
698: doslot->nullslot = optbuff (SKNULL,0,0,0);
699: }
700:
701: popctl();
702: poplab();
703:
704: dorange = 0;
705: for (q = ctlstack; q >= ctls; --q)
706: if (q->ctltype == CTLDO)
707: {
708: dorange = q->dolabel;
709: break;
710: }
711: }
712: }
713:
714:
715: exassign(vname, labelval)
716: Namep vname;
717: struct Labelblock *labelval;
718: {
719: Addrp p;
720: expptr mkaddcon();
721:
722: p = mkplace(vname);
723: #if SZADDR > SZSHORT
724: if( p->vtype == TYSHORT )
725: err("insufficient precision in ASSIGN variable");
726: else
727: #endif
728: if( ! ONEOF(p->vtype, MSKINT|MSKADDR) )
729: err("noninteger assign variable");
730: else
731: {
732: if (optimflag)
733: optbuff (SKASSIGN, p, labelval->labelno, 0);
734: else
735: puteq (p, intrconv(p->vtype, mkaddcon(labelval->labelno)));
736: }
737: }
738:
739:
740:
741: exarif(expr, neglab, zerlab, poslab)
742: expptr expr;
743: struct Labelblock *neglab, *zerlab, *poslab;
744: {
745: register int lm, lz, lp;
746: struct Labelblock *labels[3];
747:
748: lm = neglab->labelno;
749: lz = zerlab->labelno;
750: lp = poslab->labelno;
751: expr = fixtype(expr);
752:
753: if( ! ONEOF(expr->headblock.vtype, MSKINT|MSKREAL) )
754: {
755: err("invalid type of arithmetic if expression");
756: frexpr(expr);
757: }
758: else
759: {
760: if(lm == lz)
761: exar2(OPLE, expr, lm, lp);
762: else if(lm == lp)
763: exar2(OPNE, expr, lm, lz);
764: else if(lz == lp)
765: exar2(OPGE, expr, lz, lm);
766: else
767: if (optimflag)
768: {
769: labels[0] = neglab;
770: labels[1] = zerlab;
771: labels[2] = poslab;
772: optbuff (SKARIF, expr, 0, labels);
773: }
774: else
775: prarif(expr, lm, lz, lp);
776: }
777: }
778:
779:
780:
781: LOCAL exar2 (op, e, l1, l2)
782: int op;
783: expptr e;
784: int l1,l2;
785: {
786: if (optimflag)
787: {
788: optbuff (SKIFN, mkexpr(op, e, ICON(0)), l2, 0);
789: optbuff (SKGOTO, 0, l1, 0);
790: }
791: else
792: {
793: putif (mkexpr(op, e, ICON(0)), l2);
794: putgoto (l1);
795: }
796: }
797:
798:
799: exreturn(p)
800: register expptr p;
801: {
802: if(procclass != CLPROC)
803: warn("RETURN statement in main or block data");
804: if(p && (proctype!=TYSUBR || procclass!=CLPROC) )
805: {
806: err("alternate return in nonsubroutine");
807: p = 0;
808: }
809:
810: if(p)
811: if (optimflag)
812: optbuff (SKRETURN, p, retlabel, 0);
813: else
814: {
815: putforce (TYINT, p);
816: putgoto (retlabel);
817: }
818: else
819: if (optimflag)
820: optbuff (SKRETURN, p,
821: (proctype==TYSUBR ? ret0label : retlabel), 0);
822: else
823: putgoto (proctype==TYSUBR ? ret0label : retlabel);
824: }
825:
826:
827:
828: exasgoto(labvar)
829: struct Hashentry *labvar;
830: {
831: register Addrp p;
832:
833: p = mkplace(labvar);
834: if( ! ISINT(p->vtype) )
835: err("assigned goto variable must be integer");
836: else
837: if (optimflag)
838: optbuff (SKASGOTO, p, 0, 0);
839: else
840: putbranch (p);
841: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.