![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to trees.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / lib / mip|
Return to trees.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / lib / mip |
1.1 root 1: #ifndef lint
2: static char *sccsid ="@(#)trees.c 4.36 (Berkeley) 5/11/88";
3: #endif
4:
5: # include "pass1.h"
6:
7: # include <setjmp.h>
8:
9: int bdebug = 0;
10: int adebug = 0;
11: extern ddebug;
12: extern eprint();
13:
14: /* corrections when in violation of lint */
15:
16: /* some special actions, used in finding the type of nodes */
17: # define NCVT 01
18: # define PUN 02
19: # define TYPL 04
20: # define TYPR 010
21: # define TYMATCH 040
22: # define LVAL 0100
23: # define CVTO 0200
24: # define CVTL 0400
25: # define CVTR 01000
26: # define PTMATCH 02000
27: # define OTHER 04000
28: # define NCVTR 010000
29:
30: #ifndef BUG1
31: printact(t, acts)
32: NODE *t;
33: int acts;
34: {
35: static struct actions {
36: int a_bit;
37: char *a_name;
38: } actions[] = {
39: { PUN, "PUN" },
40: { CVTL, "CVTL" },
41: { CVTR, "CVTR" },
42: { TYPL, "TYPL" },
43: { TYPR, "TYPR" },
44: { TYMATCH, "TYMATCH" },
45: { PTMATCH, "PTMATCH" },
46: { LVAL, "LVAL" },
47: { CVTO, "CVTO" },
48: { NCVT, "NCVT" },
49: { OTHER, "OTHER" },
50: { NCVTR, "NCVTR" },
51: { 0 }
52: };
53: register struct actions *p;
54: char *sep = " ";
55:
56: printf("actions");
57: for (p = actions; p->a_name; p++)
58: if (p->a_bit & acts) {
59: printf("%s%s", sep, p->a_name);
60: sep = "|";
61: }
62: if (!bdebug) {
63: printf(" for:\n");
64: fwalk(t, eprint, 0);
65: } else
66: putchar('\n');
67: }
68: #endif
69:
70: /* node conventions:
71:
72: NAME: rval>0 is stab index for external
73: rval<0 is -inlabel number
74: lval is offset in bits
75: ICON: lval has the value
76: rval has the STAB index, or - label number,
77: if a name whose address is in the constant
78: rval = NONAME means no name
79: REG: rval is reg. identification cookie
80:
81: */
82:
83: NODE *
84: buildtree( o, l, r ) register NODE *l, *r; {
85: register NODE *p, *q;
86: register actions;
87: register opty;
88: register struct symtab *sp;
89: register NODE *lr, *ll;
90: NODE *fixargs();
91: int i;
92:
93: # ifndef BUG1
94: if( bdebug ) printf( "buildtree( %s, %o, %o )\n", opst[o], l, r );
95: # endif
96: opty = optype(o);
97:
98: /* check for constants */
99:
100: if( opty == UTYPE && l->in.op == ICON ){
101:
102: switch( o ){
103:
104: case NOT:
105: if( hflag ) werror( "constant argument to NOT" );
106: case UNARY MINUS:
107: case COMPL:
108: if( conval( l, o, l ) ) return(l);
109: break;
110:
111: }
112: }
113:
114: else if( opty == UTYPE && (l->in.op == FCON || l->in.op == DCON) ){
115:
116: switch( o ){
117:
118: case NOT:
119: if( hflag ) werror( "constant argument to NOT" );
120: if( l->in.op == FCON )
121: l->tn.lval = l->fpn.fval == 0.0;
122: else
123: l->tn.lval = l->dpn.dval == 0.0;
124: l->tn.rval = NONAME;
125: l->in.op = ICON;
126: l->fn.csiz = l->in.type = INT;
127: l->fn.cdim = 0;
128: return(l);
129: case UNARY MINUS:
130: if( l->in.op == FCON )
131: l->fpn.fval = -l->fpn.fval;
132: else
133: l->dpn.dval = -l->dpn.dval;
134: return(l);
135: }
136: }
137:
138: else if( o==QUEST && l->in.op==ICON ) {
139: l->in.op = FREE;
140: r->in.op = FREE;
141: if( l->tn.lval ){
142: tfree( r->in.right );
143: return( r->in.left );
144: }
145: else {
146: tfree( r->in.left );
147: return( r->in.right );
148: }
149: }
150:
151: else if( (o==ANDAND || o==OROR) && (l->in.op==ICON||r->in.op==ICON) ) goto ccwarn;
152:
153: else if( opty == BITYPE && l->in.op == ICON && r->in.op == ICON ){
154:
155: switch( o ){
156:
157: case ULT:
158: case UGT:
159: case ULE:
160: case UGE:
161: case LT:
162: case GT:
163: case LE:
164: case GE:
165: case EQ:
166: case NE:
167: if( l->in.type == ENUMTY && r->in.type == ENUMTY ){
168: p = block( o, l, r, INT, 0, INT );
169: chkpun( p );
170: p->in.op = FREE;
171: }
172:
173: case ANDAND:
174: case OROR:
175: case CBRANCH:
176:
177: ccwarn:
178: if( hflag ) werror( "constant in conditional context" );
179:
180: case PLUS:
181: case MINUS:
182: case MUL:
183: case DIV:
184: case MOD:
185: case AND:
186: case OR:
187: case ER:
188: case LS:
189: case RS:
190: if( conval( l, o, r ) ) {
191: r->in.op = FREE;
192: return(l);
193: }
194: break;
195: }
196: }
197: else if (opty == BITYPE &&
198: (l->in.op == FCON || l->in.op == DCON || l->in.op == ICON) &&
199: (r->in.op == FCON || r->in.op == DCON || r->in.op == ICON)) {
200: if (o == PLUS || o == MINUS || o == MUL || o == DIV) {
201: extern int fpe_count;
202: extern jmp_buf gotfpe;
203:
204: fpe_count = 0;
205: if (setjmp(gotfpe))
206: goto treatfpe;
207: if (l->in.op == ICON)
208: l->dpn.dval = l->tn.lval;
209: else if (l->in.op == FCON)
210: l->dpn.dval = l->fpn.fval;
211: if (r->in.op == ICON)
212: r->dpn.dval = r->tn.lval;
213: else if (r->in.op == FCON)
214: r->dpn.dval = r->fpn.fval;
215: switch (o) {
216:
217: case PLUS:
218: l->dpn.dval += r->dpn.dval;
219: break;
220:
221: case MINUS:
222: l->dpn.dval -= r->dpn.dval;
223: break;
224:
225: case MUL:
226: l->dpn.dval *= r->dpn.dval;
227: break;
228:
229: case DIV:
230: if (r->dpn.dval == 0)
231: uerror("division by 0.");
232: else
233: l->dpn.dval /= r->dpn.dval;
234: break;
235: }
236: treatfpe:
237: if (fpe_count > 0) {
238: uerror("floating point exception in constant expression");
239: l->dpn.dval = 1.0; /* Fairly harmless */
240: }
241: fpe_count = -1;
242: l->in.op = DCON;
243: l->in.type = l->fn.csiz = DOUBLE;
244: r->in.op = FREE;
245: return (l);
246: }
247: }
248:
249: /* it's real; we must make a new node */
250:
251: p = block( o, l, r, INT, 0, INT );
252:
253: actions = opact(p);
254: #ifndef BUG1
255: if (adebug)
256: printact(p, actions);
257: #endif
258:
259: if( actions&LVAL ){ /* check left descendent */
260: if( notlval(p->in.left) ) {
261: uerror( "illegal lvalue operand of assignment operator" );
262: }
263: }
264:
265: if( actions & NCVTR ){
266: p->in.left = pconvert( p->in.left );
267: }
268: else if( !(actions & NCVT ) ){
269: switch( opty ){
270:
271: case BITYPE:
272: p->in.right = pconvert( p->in.right );
273: case UTYPE:
274: p->in.left = pconvert( p->in.left );
275:
276: }
277: }
278:
279: if( (actions&PUN) && (o!=CAST||cflag) ){
280: chkpun(p);
281: }
282:
283: if( actions & (TYPL|TYPR) ){
284:
285: q = (actions&TYPL) ? p->in.left : p->in.right;
286:
287: p->in.type = q->in.type;
288: p->fn.cdim = q->fn.cdim;
289: p->fn.csiz = q->fn.csiz;
290: }
291:
292: if( actions & CVTL ) p = convert( p, CVTL );
293: if( actions & CVTR ) p = convert( p, CVTR );
294: if( actions & TYMATCH ) p = tymatch(p);
295: if( actions & PTMATCH ) p = ptmatch(p);
296:
297: if( actions & OTHER ){
298: l = p->in.left;
299: r = p->in.right;
300:
301: switch(o){
302:
303: case NAME:
304: sp = &stab[idname];
305: if( sp->stype == UNDEF ){
306: #ifndef FLEXNAMES
307: uerror( "%.8s undefined", sp->sname );
308: #else
309: uerror( "%s undefined", sp->sname );
310: #endif
311: /* make p look reasonable */
312: p->in.type = p->fn.csiz = INT;
313: p->fn.cdim = 0;
314: p->tn.rval = idname;
315: p->tn.lval = 0;
316: defid( p, SNULL );
317: break;
318: }
319: p->in.type = sp->stype;
320: p->fn.cdim = sp->dimoff;
321: p->fn.csiz = sp->sizoff;
322: p->tn.lval = 0;
323: p->tn.rval = idname;
324: /* special case: MOETY is really an ICON... */
325: if( p->in.type == MOETY ){
326: p->tn.rval = NONAME;
327: p->tn.lval = sp->offset;
328: p->fn.cdim = 0;
329: p->in.type = ENUMTY;
330: p->in.op = ICON;
331: }
332: break;
333:
334: case ICON:
335: p->in.type = INT;
336: p->fn.cdim = 0;
337: p->fn.csiz = INT;
338: break;
339:
340: case STRING:
341: p->in.op = NAME;
342: p->in.type = CHAR+ARY;
343: p->tn.lval = 0;
344: p->tn.rval = NOLAB;
345: p->fn.cdim = curdim;
346: p->fn.csiz = CHAR;
347: break;
348:
349: case FCON:
350: p->tn.lval = 0;
351: p->tn.rval = 0;
352: p->in.type = FLOAT;
353: p->fn.cdim = 0;
354: p->fn.csiz = FLOAT;
355: break;
356:
357: case DCON:
358: p->tn.lval = 0;
359: p->tn.rval = 0;
360: p->in.type = DOUBLE;
361: p->fn.cdim = 0;
362: p->fn.csiz = DOUBLE;
363: break;
364:
365: case STREF:
366: /* p->x turned into *(p+offset) */
367: /* rhs must be a name; check correctness */
368:
369: i = r->tn.rval;
370: if( i<0 || ((sp= &stab[i])->sclass != MOS && sp->sclass != MOU && !(sp->sclass&FIELD)) ){
371: uerror( "member of structure or union required" );
372: }else
373: /* if this name is non-unique, find right one */
374: if( stab[i].sflags & SNONUNIQ &&
375: (l->in.type==PTR+STRTY || l->in.type == PTR+UNIONTY) &&
376: (l->fn.csiz +1) >= 0 ){
377: /* nonunique name && structure defined */
378: char * memnam, * tabnam;
379: int j;
380: int memi;
381: j=dimtab[l->fn.csiz+1];
382: for( ; (memi=dimtab[j]) >= 0; ++j ){
383: tabnam = stab[memi].sname;
384: memnam = stab[i].sname;
385: # ifndef BUG1
386: if( ddebug>1 ){
387: #ifndef FLEXNAMES
388: printf("member %.8s==%.8s?\n",
389: #else
390: printf("member %s==%s?\n",
391: #endif
392: memnam, tabnam);
393: }
394: # endif
395: if( stab[memi].sflags & SNONUNIQ ){
396: #ifndef FLEXNAMES
397: register k;
398: for( k=0; k<NCHNAM; ++k ){
399: if(*memnam++!=*tabnam)
400: goto next;
401: if(!*tabnam++) break;
402: }
403: #else
404: if (memnam != tabnam)
405: goto next;
406: #endif
407: r->tn.rval = i = memi;
408: break;
409: }
410: next: continue;
411: }
412: if( memi < 0 )
413: #ifndef FLEXNAMES
414: uerror("illegal member use: %.8s",
415: #else
416: uerror("illegal member use: %s",
417: #endif
418: stab[i].sname);
419: }
420: else {
421: register j;
422: if( l->in.type != PTR+STRTY && l->in.type != PTR+UNIONTY ){
423: if( stab[i].sflags & SNONUNIQ ){
424: uerror( "nonunique name demands struct/union or struct/union pointer" );
425: }
426: else werror( "struct/union or struct/union pointer required" );
427: }
428: else if( (j=l->fn.csiz+1)<0 ) cerror( "undefined structure or union" );
429: else if( !chkstr( i, dimtab[j], DECREF(l->in.type) ) ){
430: #ifndef FLEXNAMES
431: werror( "illegal member use: %.8s", stab[i].sname );
432: #else
433: werror( "illegal member use: %s", stab[i].sname );
434: #endif
435: }
436: }
437:
438: p = stref( p );
439: break;
440:
441: case UNARY MUL:
442: if( l->in.op == UNARY AND ){
443: p->in.op = l->in.op = FREE;
444: p = l->in.left;
445: }
446: if( !ISPTR(l->in.type))uerror("illegal indirection");
447: p->in.type = DECREF(l->in.type);
448: p->fn.cdim = l->fn.cdim;
449: p->fn.csiz = l->fn.csiz;
450: break;
451:
452: case UNARY AND:
453: switch( l->in.op ){
454:
455: case UNARY MUL:
456: p->in.op = l->in.op = FREE;
457: p = l->in.left;
458: case NAME:
459: p->in.type = INCREF( l->in.type );
460: p->fn.cdim = l->fn.cdim;
461: p->fn.csiz = l->fn.csiz;
462: break;
463:
464: case COMOP:
465: lr = buildtree( UNARY AND, l->in.right, NIL );
466: p->in.op = l->in.op = FREE;
467: p = buildtree( COMOP, l->in.left, lr );
468: break;
469:
470: case QUEST:
471: lr = buildtree( UNARY AND, l->in.right->in.right, NIL );
472: ll = buildtree( UNARY AND, l->in.right->in.left, NIL );
473: p->in.op = l->in.op = l->in.right->in.op = FREE;
474: p = buildtree( QUEST, l->in.left, buildtree( COLON, ll, lr ) );
475: break;
476:
477: # ifdef ADDROREG
478: case OREG:
479: /* OREG was built in clocal()
480: * for an auto or formal parameter
481: * now its address is being taken
482: * local code must unwind it
483: * back to PLUS/MINUS REG ICON
484: * according to local conventions
485: */
486: {
487: extern NODE * addroreg();
488: p->in.op = FREE;
489: p = addroreg( l );
490: }
491: break;
492:
493: # endif
494: default:
495: uerror( "unacceptable operand of &" );
496: break;
497: }
498: break;
499:
500: case LS:
501: case RS:
502: if( l->in.type == CHAR || l->in.type == SHORT )
503: p->in.type = INT;
504: else if( l->in.type == UCHAR || l->in.type == USHORT )
505: p->in.type = UNSIGNED;
506: else
507: p->in.type = l->in.type;
508: case ASG LS:
509: case ASG RS:
510: if( r->in.type != INT )
511: p->in.right = r = makety(r, INT, 0, INT );
512: break;
513:
514: case RETURN:
515: case ASSIGN:
516: case CAST:
517: /* structure assignment */
518: /* take the addresses of the two sides; then make an
519: /* operator using STASG and
520: /* the addresses of left and right */
521:
522: {
523: register TWORD t;
524: register d, s;
525:
526: if( l->fn.csiz != r->fn.csiz ) uerror( "assignment of different structures" );
527:
528: r = buildtree( UNARY AND, r, NIL );
529: t = r->in.type;
530: d = r->fn.cdim;
531: s = r->fn.csiz;
532:
533: l = block( STASG, l, r, t, d, s );
534:
535: if( o == RETURN ){
536: p->in.op = FREE;
537: p = l;
538: break;
539: }
540:
541: p->in.op = UNARY MUL;
542: p->in.left = l;
543: p->in.right = NIL;
544: break;
545: }
546: case COLON:
547: /* structure colon */
548:
549: if( l->fn.csiz != r->fn.csiz ) uerror( "type clash in conditional" );
550: break;
551:
552: case CALL:
553: p->in.right = r = fixargs( p->in.right );
554: case UNARY CALL:
555: if( !ISPTR(l->in.type)) uerror("illegal function");
556: p->in.type = DECREF(l->in.type);
557: if( !ISFTN(p->in.type)) uerror("illegal function");
558: p->in.type = DECREF( p->in.type );
559: p->fn.cdim = l->fn.cdim;
560: p->fn.csiz = l->fn.csiz;
561: if( l->in.op == UNARY AND && l->in.left->in.op == NAME &&
562: l->in.left->tn.rval >= 0 && l->in.left->tn.rval != NONAME &&
563: ( (i=stab[l->in.left->tn.rval].sclass) == FORTRAN || i==UFORTRAN ) ){
564: p->in.op += (FORTCALL-CALL);
565: }
566: if( p->in.type == STRTY || p->in.type == UNIONTY ){
567: /* function returning structure */
568: /* make function really return ptr to str., with * */
569:
570: p->in.op += STCALL-CALL;
571: p->in.type = INCREF( p->in.type );
572: p = buildtree( UNARY MUL, p, NIL );
573:
574: }
575: break;
576:
577: default:
578: cerror( "other code %d", o );
579: }
580:
581: }
582:
583: if( actions & CVTO ) p = oconvert(p);
584: p = clocal(p);
585:
586: # ifndef BUG1
587: if( bdebug ) fwalk( p, eprint, 0 );
588: # endif
589:
590: return(p);
591:
592: }
593:
594: int fpe_count = -1;
595: jmp_buf gotfpe;
596:
597: fpe() {
598: if (fpe_count < 0)
599: cerror("floating point exception");
600: ++fpe_count;
601: longjmp(gotfpe, 1);
602: }
603:
604: /*
605: * Rewrite arguments in a function call.
606: * Structure arguments are massaged, single
607: * precision floating point constants are
608: * cast to double (to eliminate convert code).
609: */
610: NODE *
611: fixargs( p ) register NODE *p; {
612: int o = p->in.op;
613:
614: if( o == CM ){
615: p->in.left = fixargs( p->in.left );
616: p->in.right = fixargs( p->in.right );
617: return( p );
618: }
619:
620: if( p->in.type == STRTY || p->in.type == UNIONTY ){
621: p = block( STARG, p, NIL, p->in.type, p->fn.cdim, p->fn.csiz );
622: p->in.left = buildtree( UNARY AND, p->in.left, NIL );
623: p = clocal(p);
624: }
625: else if( o == FCON )
626: p = makety(p, DOUBLE, 0, 0);
627: return( p );
628: }
629:
630: chkstr( i, j, type ) TWORD type; {
631: /* is the MOS or MOU at stab[i] OK for strict reference by a ptr */
632: /* i has been checked to contain a MOS or MOU */
633: /* j is the index in dimtab of the members... */
634: int k, kk;
635:
636: extern int ddebug;
637:
638: # ifndef BUG1
639: #ifndef FLEXNAMES
640: if( ddebug > 1 ) printf( "chkstr( %.8s(%d), %d )\n", stab[i].sname, i, j );
641: #else
642: if( ddebug > 1 ) printf( "chkstr( %s(%d), %d )\n", stab[i].sname, i, j );
643: #endif
644: # endif
645: if( (k = j) < 0 ) uerror( "undefined structure or union" );
646: else {
647: for( ; (kk = dimtab[k] ) >= 0; ++k ){
648: if( kk >= SYMTSZ ){
649: cerror( "gummy structure" );
650: return(1);
651: }
652: if( kk == i ) return( 1 );
653: switch( stab[kk].stype ){
654:
655: case STRTY:
656: case UNIONTY:
657: if( type == STRTY ) continue; /* no recursive looking for strs */
658: if( hflag && chkstr( i, dimtab[stab[kk].sizoff+1], stab[kk].stype ) ){
659: if( stab[kk].sname[0] == '$' ) return(0); /* $FAKE */
660: werror(
661: #ifndef FLEXNAMES
662: "illegal member use: perhaps %.8s.%.8s?",
663: #else
664: "illegal member use: perhaps %s.%s?",
665: #endif
666: stab[kk].sname, stab[i].sname );
667: return(1);
668: }
669: }
670: }
671: }
672: return( 0 );
673: }
674:
675: conval( p, o, q ) register NODE *p, *q; {
676: /* apply the op o to the lval part of p; if binary, rhs is val */
677: /* works only on integer constants */
678: NODE *r;
679: int i, u;
680: CONSZ val;
681: TWORD utype;
682:
683: val = q->tn.lval;
684: u = ISUNSIGNED(p->in.type) || ISUNSIGNED(q->in.type);
685: if( u && (o==LE||o==LT||o==GE||o==GT)) o += (UGE-GE);
686:
687: if( p->tn.rval != NONAME && q->tn.rval != NONAME ) return(0);
688: if( q->tn.rval != NONAME && o!=PLUS ) return(0);
689: if( p->tn.rval != NONAME && o!=PLUS && o!=MINUS ) return(0);
690:
691: /* usual type conversions -- handle casts of constants */
692: #define ISLONG(t) ((t) == LONG || (t) == ULONG)
693: if (ISLONG(p->in.type) || ISLONG(q->in.type))
694: utype = u ? ULONG : LONG;
695: else
696: utype = u ? UNSIGNED : INT;
697: if( !ISPTR(p->in.type) && p->in.type != utype )
698: p = makety(p, utype, 0, (int)utype);
699: if( q->in.type != utype )
700: q = makety(q, utype, 0, (int)utype);
701:
702: switch( o ){
703:
704: case PLUS:
705: p->tn.lval += val;
706: if( p->tn.rval == NONAME ){
707: p->tn.rval = q->tn.rval;
708: p->in.type = q->in.type;
709: }
710: break;
711: case MINUS:
712: p->tn.lval -= val;
713: break;
714: case MUL:
715: p->tn.lval *= val;
716: break;
717: case DIV:
718: if( val == 0 ) uerror( "division by 0" );
719: else if ( u ) p->tn.lval = (unsigned) p->tn.lval / val;
720: else p->tn.lval /= val;
721: break;
722: case MOD:
723: if( val == 0 ) uerror( "division by 0" );
724: else if ( u ) p->tn.lval = (unsigned) p->tn.lval % val;
725: else p->tn.lval %= val;
726: break;
727: case AND:
728: p->tn.lval &= val;
729: break;
730: case OR:
731: p->tn.lval |= val;
732: break;
733: case ER:
734: p->tn.lval ^= val;
735: break;
736: case LS:
737: i = val;
738: p->tn.lval = p->tn.lval << i;
739: break;
740: case RS:
741: i = val;
742: if ( u ) p->tn.lval = (unsigned) p->tn.lval >> i;
743: else p->tn.lval = p->tn.lval >> i;
744: break;
745:
746: case UNARY MINUS:
747: p->tn.lval = - p->tn.lval;
748: break;
749: case COMPL:
750: p->tn.lval = ~p->tn.lval;
751: break;
752: case NOT:
753: p->tn.lval = !p->tn.lval;
754: break;
755: case LT:
756: p->tn.lval = p->tn.lval < val;
757: break;
758: case LE:
759: p->tn.lval = p->tn.lval <= val;
760: break;
761: case GT:
762: p->tn.lval = p->tn.lval > val;
763: break;
764: case GE:
765: p->tn.lval = p->tn.lval >= val;
766: break;
767: case ULT:
768: p->tn.lval = p->tn.lval < (unsigned) val;
769: break;
770: case ULE:
771: p->tn.lval = p->tn.lval <= (unsigned) val;
772: break;
773: case UGT:
774: p->tn.lval = p->tn.lval > (unsigned) val;
775: break;
776: case UGE:
777: p->tn.lval = p->tn.lval >= (unsigned) val;
778: break;
779: case EQ:
780: p->tn.lval = p->tn.lval == val;
781: break;
782: case NE:
783: p->tn.lval = p->tn.lval != val;
784: break;
785: default:
786: return(0);
787: }
788: return(1);
789: }
790:
791: chkpun(p) register NODE *p; {
792:
793: /* checks p for the existance of a pun */
794:
795: /* this is called when the op of p is ASSIGN, RETURN, CAST, COLON, or relational */
796:
797: /* one case is when enumerations are used: this applies only to lint */
798: /* in the other case, one operand is a pointer, the other integer type */
799: /* we check that this integer is in fact a constant zero... */
800:
801: /* in the case of ASSIGN, any assignment of pointer to integer is illegal */
802: /* this falls out, because the LHS is never 0 */
803:
804: register NODE *q;
805: register t1, t2;
806: register d1, d2;
807: int ref1, ref2;
808:
809: t1 = p->in.left->in.type;
810: t2 = p->in.right->in.type;
811:
812: if( t1==ENUMTY || t2==ENUMTY ) { /* check for enumerations */
813: /* rob pike says this is obnoxious...
814: if( logop( p->in.op ) && p->in.op != EQ && p->in.op != NE )
815: werror( "comparison of enums" ); */
816: if( t1==ENUMTY && t2==ENUMTY ) {
817: if ( p->in.left->fn.csiz!=p->in.right->fn.csiz )
818: werror( "enumeration type clash, operator %s", opst[p->in.op] );
819: return;
820: }
821: if ( t1 == ENUMTY ) t1 = INT;
822: if ( t2 == ENUMTY ) t2 = INT;
823: }
824:
825: ref1 = ISPTR(t1) || ISARY(t1);
826: ref2 = ISPTR(t2) || ISARY(t2);
827:
828: if( ref1 ^ ref2 ){
829: if( ref1 ) q = p->in.right;
830: else q = p->in.left;
831: if( q->in.op != ICON || q->tn.lval != 0 ){
832: werror( "illegal combination of pointer and integer, op %s",
833: opst[p->in.op] );
834: }
835: }
836: else if( ref1 ){
837: if( t1 == t2 ) {
838: if( p->in.left->fn.csiz != p->in.right->fn.csiz ) {
839: werror( "illegal structure pointer combination" );
840: return;
841: }
842: d1 = p->in.left->fn.cdim;
843: d2 = p->in.right->fn.cdim;
844: for( ;; ){
845: if( ISARY(t1) ){
846: if( dimtab[d1] != dimtab[d2] ){
847: werror( "illegal array size combination" );
848: return;
849: }
850: ++d1;
851: ++d2;
852: }
853: else if( !ISPTR(t1) ) break;
854: t1 = DECREF(t1);
855: }
856: }
857: else if( t1 != INCREF(UNDEF) && t2 != INCREF(UNDEF) )
858: werror( "illegal pointer combination" );
859: }
860:
861: }
862:
863: NODE *
864: stref( p ) register NODE *p; {
865:
866: TWORD t;
867: int d, s, dsc, align;
868: OFFSZ off;
869: register struct symtab *q;
870:
871: /* make p->x */
872: /* this is also used to reference automatic variables */
873:
874: q = &stab[p->in.right->tn.rval];
875: p->in.right->in.op = FREE;
876: p->in.op = FREE;
877: p = pconvert( p->in.left );
878:
879: /* make p look like ptr to x */
880:
881: if( !ISPTR(p->in.type)){
882: p->in.type = PTR+UNIONTY;
883: }
884:
885: t = INCREF( q->stype );
886: d = q->dimoff;
887: s = q->sizoff;
888:
889: p = makety( p, t, d, s );
890:
891: /* compute the offset to be added */
892:
893: off = q->offset;
894: dsc = q->sclass;
895:
896: if( dsc & FIELD ) { /* normalize offset */
897: align = ALINT;
898: s = INT;
899: off = (off/align)*align;
900: }
901: if( off != 0 ) p = clocal( block( PLUS, p, offcon( off, t, d, s ), t, d, s ) );
902:
903: p = buildtree( UNARY MUL, p, NIL );
904:
905: /* if field, build field info */
906:
907: if( dsc & FIELD ){
908: p = block( FLD, p, NIL, q->stype, 0, q->sizoff );
909: p->tn.rval = PKFIELD( dsc&FLDSIZ, q->offset%align );
910: }
911:
912: return( clocal(p) );
913: }
914:
915: notlval(p) register NODE *p; {
916:
917: /* return 0 if p an lvalue, 1 otherwise */
918:
919: again:
920:
921: switch( p->in.op ){
922:
923: case FLD:
924: p = p->in.left;
925: goto again;
926:
927: case UNARY MUL:
928: /* fix the &(a=b) bug, given that a and b are structures */
929: if( p->in.left->in.op == STASG ) return( 1 );
930: /* and the f().a bug, given that f returns a structure */
931: if( p->in.left->in.op == UNARY STCALL ||
932: p->in.left->in.op == STCALL ) return( 1 );
933: case NAME:
934: case OREG:
935: if( ISARY(p->in.type) || ISFTN(p->in.type) ) return(1);
936: case REG:
937: return(0);
938:
939: default:
940: return(1);
941:
942: }
943:
944: }
945:
946: NODE *
947: bcon( i ){ /* make a constant node with value i */
948: register NODE *p;
949:
950: p = block( ICON, NIL, NIL, INT, 0, INT );
951: p->tn.lval = i;
952: p->tn.rval = NONAME;
953: return( clocal(p) );
954: }
955:
956: NODE *
957: bpsize(p) register NODE *p; {
958: return( offcon( psize(p), p->in.type, p->fn.cdim, p->fn.csiz ) );
959: }
960:
961: OFFSZ
962: psize( p ) NODE *p; {
963: /* p is a node of type pointer; psize returns the
964: size of the thing pointed to */
965:
966: if( !ISPTR(p->in.type) ){
967: uerror( "pointer required");
968: return( SZINT );
969: }
970: /* note: no pointers to fields */
971: return( tsize( DECREF(p->in.type), p->fn.cdim, p->fn.csiz ) );
972: }
973:
974: NODE *
975: convert( p, f ) register NODE *p; {
976: /* convert an operand of p
977: f is either CVTL or CVTR
978: operand has type int, and is converted by the size of the other side
979: */
980:
981: register NODE *q, *r;
982:
983: q = (f==CVTL)?p->in.left:p->in.right;
984:
985: r = block( PMCONV,
986: q, bpsize(f==CVTL?p->in.right:p->in.left), INT, 0, INT );
987: r = clocal(r);
988: if( f == CVTL )
989: p->in.left = r;
990: else
991: p->in.right = r;
992: return(p);
993:
994: }
995:
996: #ifndef econvert
997: econvert( p ) register NODE *p; {
998:
999: /* change enums to ints, or appropriate types */
1000:
1001: register TWORD ty;
1002:
1003: if( (ty=BTYPE(p->in.type)) == ENUMTY || ty == MOETY ) {
1004: if( dimtab[ p->fn.csiz ] == SZCHAR ) ty = CHAR;
1005: else if( dimtab[ p->fn.csiz ] == SZINT ) ty = INT;
1006: else if( dimtab[ p->fn.csiz ] == SZSHORT ) ty = SHORT;
1007: else ty = LONG;
1008: ty = ctype( ty );
1009: p->fn.csiz = ty;
1010: MODTYPE(p->in.type,ty);
1011: if( p->in.op == ICON && ty != LONG ) p->in.type = p->fn.csiz = INT;
1012: }
1013: }
1014: #endif
1015:
1016: NODE *
1017: pconvert( p ) register NODE *p; {
1018:
1019: /* if p should be changed into a pointer, do so */
1020:
1021: if( ISARY( p->in.type) ){
1022: p->in.type = DECREF( p->in.type );
1023: ++p->fn.cdim;
1024: return( buildtree( UNARY AND, p, NIL ) );
1025: }
1026: if( ISFTN( p->in.type) )
1027: return( buildtree( UNARY AND, p, NIL ) );
1028:
1029: return( p );
1030: }
1031:
1032: NODE *
1033: oconvert(p) register NODE *p; {
1034: /* convert the result itself: used for pointer and unsigned */
1035:
1036: switch(p->in.op) {
1037:
1038: case LE:
1039: case LT:
1040: case GE:
1041: case GT:
1042: if( ISUNSIGNED(p->in.left->in.type) || ISUNSIGNED(p->in.right->in.type) ) p->in.op += (ULE-LE);
1043: case EQ:
1044: case NE:
1045: return( p );
1046:
1047: case MINUS:
1048: return( clocal( block( PVCONV,
1049: p, bpsize(p->in.left), INT, 0, INT ) ) );
1050: }
1051:
1052: cerror( "illegal oconvert: %d", p->in.op );
1053:
1054: return(p);
1055: }
1056:
1057: NODE *
1058: ptmatch(p) register NODE *p; {
1059:
1060: /* makes the operands of p agree; they are
1061: either pointers or integers, by this time */
1062: /* with MINUS, the sizes must be the same */
1063: /* with COLON, the types must be the same */
1064:
1065: TWORD t1, t2, t;
1066: int o, d2, d, s2, s;
1067:
1068: o = p->in.op;
1069: t = t1 = p->in.left->in.type;
1070: t2 = p->in.right->in.type;
1071: d = p->in.left->fn.cdim;
1072: d2 = p->in.right->fn.cdim;
1073: s = p->in.left->fn.csiz;
1074: s2 = p->in.right->fn.csiz;
1075:
1076: switch( o ){
1077:
1078: case ASSIGN:
1079: case RETURN:
1080: case CAST:
1081: { break; }
1082:
1083: case MINUS:
1084: { if( psize(p->in.left) != psize(p->in.right) ){
1085: uerror( "illegal pointer subtraction");
1086: }
1087: break;
1088: }
1089: case COLON:
1090: { if( t1 != t2 ) uerror( "illegal types in :");
1091: break;
1092: }
1093: default: /* must work harder: relationals or comparisons */
1094:
1095: if( !ISPTR(t1) ){
1096: t = t2;
1097: d = d2;
1098: s = s2;
1099: break;
1100: }
1101: if( !ISPTR(t2) ){
1102: break;
1103: }
1104:
1105: /* both are pointers */
1106: if( talign(t2,s2) < talign(t,s) ){
1107: t = t2;
1108: s = s2;
1109: }
1110: break;
1111: }
1112:
1113: p->in.left = makety( p->in.left, t, d, s );
1114: p->in.right = makety( p->in.right, t, d, s );
1115: if( o!=MINUS && !logop(o) ){
1116:
1117: p->in.type = t;
1118: p->fn.cdim = d;
1119: p->fn.csiz = s;
1120: }
1121:
1122: return(clocal(p));
1123: }
1124:
1125: int tdebug = 0;
1126:
1127: NODE *
1128: tymatch(p) register NODE *p; {
1129:
1130: /* satisfy the types of various arithmetic binary ops */
1131:
1132: /* rules are:
1133: if assignment, type of LHS
1134: if any float or doubles, make double
1135: if any longs, make long
1136: otherwise, make int
1137: if either operand is unsigned, the result is...
1138: */
1139:
1140: register TWORD t1, t2, t, tu;
1141: register o, u;
1142:
1143: o = p->in.op;
1144:
1145: t1 = p->in.left->in.type;
1146: t2 = p->in.right->in.type;
1147: if( (t1==UNDEF || t2==UNDEF) && o!=CAST )
1148: uerror("void type illegal in expression");
1149:
1150: u = 0;
1151: if( ISUNSIGNED(t1) ){
1152: u = 1;
1153: t1 = DEUNSIGN(t1);
1154: }
1155: if( ISUNSIGNED(t2) ){
1156: u = 1;
1157: t2 = DEUNSIGN(t2);
1158: }
1159:
1160: if( ( t1 == CHAR || t1 == SHORT ) && o!= RETURN ) t1 = INT;
1161: if( t2 == CHAR || t2 == SHORT ) t2 = INT;
1162:
1163: #ifdef SPRECC
1164: if( t1 == DOUBLE || t2 == DOUBLE )
1165: t = DOUBLE;
1166: else if( t1 == FLOAT || t2 == FLOAT )
1167: t = FLOAT;
1168: #else
1169: if (t1 == DOUBLE || t1 == FLOAT || t2 == DOUBLE || t2 == FLOAT)
1170: t = DOUBLE;
1171: #endif
1172: else if( t1==LONG || t2==LONG ) t = LONG;
1173: else t = INT;
1174:
1175: if( o == ASSIGN || o == CAST || o == RETURN )
1176: {
1177: tu = p->in.left->in.type;
1178: t = t1;
1179: }
1180: else {
1181: tu = (u && UNSIGNABLE(t))?ENUNSIGN(t):t;
1182: }
1183:
1184: /* because expressions have values that are at least as wide
1185: as INT or UNSIGNED, the only conversions needed
1186: are those involving FLOAT/DOUBLE, and those
1187: from LONG to INT and ULONG to UNSIGNED */
1188:
1189: if( (t != t1 || (u && !ISUNSIGNED(p->in.left->in.type))) && ! asgop(o) )
1190: p->in.left = makety( p->in.left, tu, 0, (int)tu );
1191:
1192: if( t != t2 || (u && !ISUNSIGNED(p->in.right->in.type)) || o==CAST)
1193: if ( tu == ENUMTY ) {/* always asgop */
1194: p->in.right = makety( p->in.right, INT, 0, INT );
1195: p->in.right->in.type = tu;
1196: p->in.right->fn.cdim = p->in.left->fn.cdim;
1197: p->in.right->fn.csiz = p->in.left->fn.csiz;
1198: }
1199: else
1200: p->in.right = makety( p->in.right, tu, 0, (int)tu );
1201:
1202: if( asgop(o) ){
1203: p->in.type = p->in.left->in.type;
1204: p->fn.cdim = p->in.left->fn.cdim;
1205: p->fn.csiz = p->in.left->fn.csiz;
1206: }
1207: else if( !logop(o) ){
1208: p->in.type = tu;
1209: p->fn.cdim = 0;
1210: p->fn.csiz = t;
1211: }
1212:
1213: # ifndef BUG1
1214: if( tdebug ) printf( "tymatch(%o): %o %s %o => %o\n",p,t1,opst[o],t2,tu );
1215: # endif
1216:
1217: return(p);
1218: }
1219:
1220: NODE *
1221: makety( p, t, d, s ) register NODE *p; TWORD t; {
1222: /* make p into type t by inserting a conversion */
1223:
1224: if( p->in.type == ENUMTY && p->in.op == ICON ) econvert(p);
1225: if( t == p->in.type ){
1226: p->fn.cdim = d;
1227: p->fn.csiz = s;
1228: return( p );
1229: }
1230:
1231: if( t & TMASK ){
1232: /* non-simple type */
1233: return( block( PCONV, p, NIL, t, d, s ) );
1234: }
1235:
1236: if( p->in.op == ICON ){
1237: if (t == DOUBLE) {
1238: p->in.op = DCON;
1239: if (ISUNSIGNED(p->in.type))
1240: p->dpn.dval = (U_CONSZ) p->tn.lval;
1241: else
1242: p->dpn.dval = p->tn.lval;
1243: p->in.type = p->fn.csiz = t;
1244: return (clocal(p));
1245: }
1246: if (t == FLOAT) {
1247: p->in.op = FCON;
1248: if( ISUNSIGNED(p->in.type) ){
1249: p->fpn.fval = (U_CONSZ) p->tn.lval;
1250: }
1251: else {
1252: p->fpn.fval = p->tn.lval;
1253: }
1254:
1255: p->in.type = p->fn.csiz = t;
1256: return( clocal(p) );
1257: }
1258: }
1259: else if (p->in.op == FCON && t == DOUBLE) {
1260: double db;
1261:
1262: p->in.op = DCON;
1263: db = p->fpn.fval;
1264: p->dpn.dval = db;
1265: p->in.type = p->fn.csiz = t;
1266: return (clocal(p));
1267: } else if (p->in.op == DCON && t == FLOAT) {
1268: float fl;
1269:
1270: p->in.op = FCON;
1271: fl = p->dpn.dval;
1272: #ifdef notdef
1273: if (fl != p->dpn.dval)
1274: werror("float conversion loses precision");
1275: #endif
1276: p->fpn.fval = fl;
1277: p->in.type = p->fn.csiz = t;
1278: return (clocal(p));
1279: }
1280:
1281: return( clocal( block( SCONV, p, NIL, t, d, s ) ) );
1282:
1283: }
1284:
1285: NODE *
1286: block( o, l, r, t, d, s ) register NODE *l, *r; TWORD t; {
1287:
1288: register NODE *p;
1289:
1290: p = talloc();
1291: p->in.op = o;
1292: p->in.left = l;
1293: p->in.right = r;
1294: p->in.type = t;
1295: p->fn.cdim = d;
1296: p->fn.csiz = s;
1297: return(p);
1298: }
1299:
1300: icons(p) register NODE *p; {
1301: /* if p is an integer constant, return its value */
1302: int val;
1303:
1304: if( p->in.op != ICON ){
1305: uerror( "constant expected");
1306: val = 1;
1307: }
1308: else {
1309: val = p->tn.lval;
1310: if( val != p->tn.lval ) uerror( "constant too big for cross-compiler" );
1311: }
1312: tfree( p );
1313: return(val);
1314: }
1315:
1316: /* the intent of this table is to examine the
1317: operators, and to check them for
1318: correctness.
1319:
1320: The table is searched for the op and the
1321: modified type (where this is one of the
1322: types INT (includes char and short), LONG,
1323: DOUBLE (includes FLOAT), and POINTER
1324:
1325: The default action is to make the node type integer
1326:
1327: The actions taken include:
1328: PUN check for puns
1329: CVTL convert the left operand
1330: CVTR convert the right operand
1331: TYPL the type is determined by the left operand
1332: TYPR the type is determined by the right operand
1333: TYMATCH force type of left and right to match, by inserting conversions
1334: PTMATCH like TYMATCH, but for pointers
1335: LVAL left operand must be lval
1336: CVTO convert the op
1337: NCVT do not convert the operands
1338: OTHER handled by code
1339: NCVTR convert the left operand, not the right...
1340:
1341: */
1342:
1343: # define MINT 01 /* integer */
1344: # define MDBI 02 /* integer or double */
1345: # define MSTR 04 /* structure */
1346: # define MPTR 010 /* pointer */
1347: # define MPTI 020 /* pointer or integer */
1348: # define MENU 040 /* enumeration variable or member */
1349: # define MVOID 0100000 /* void type */
1350:
1351: opact( p ) NODE *p; {
1352:
1353: register mt12, mt1, mt2, o;
1354:
1355: mt1 = mt2 = mt12 = 0;
1356:
1357: switch( optype(o=p->in.op) ){
1358:
1359: case BITYPE:
1360: mt2 = moditype( p->in.right->in.type );
1361: case UTYPE:
1362: mt1 = moditype( p->in.left->in.type );
1363: break;
1364:
1365: }
1366:
1367: if( ((mt1 | mt2) & MVOID) &&
1368: o != COMOP &&
1369: o != COLON &&
1370: !(o == QUEST && (mt1 & MVOID) == 0) &&
1371: !(o == CAST && (mt1 & MVOID)) ){
1372: /* if lhs of RETURN is void, grammar will complain */
1373: if( o != RETURN )
1374: uerror( "value of void expression used" );
1375: return( NCVT );
1376: }
1377: mt12 = mt1 & mt2;
1378:
1379: switch( o ){
1380:
1381: case NAME :
1382: case STRING :
1383: case ICON :
1384: case FCON :
1385: case DCON :
1386: case CALL :
1387: case UNARY CALL:
1388: case UNARY MUL:
1389: { return( OTHER ); }
1390: case UNARY MINUS:
1391: if( mt1 & MENU ) return( 0 );
1392: if( mt1 & MDBI ) return( TYPL );
1393: break;
1394:
1395: case COMPL:
1396: if( mt1 & MENU ) return( 0 );
1397: if( mt1 & MINT ) return( TYPL );
1398: break;
1399:
1400: case UNARY AND:
1401: return( NCVT+OTHER );
1402: case INIT:
1403: case CM:
1404: return( 0 );
1405:
1406: case NOT:
1407: case CBRANCH:
1408: if( mt1 & MSTR ) break;
1409: return( 0 );
1410:
1411: case ANDAND:
1412: case OROR:
1413: if( (mt1 & MSTR) || (mt2 & MSTR) ) break;
1414: return( 0 );
1415:
1416: case MUL:
1417: case DIV:
1418: if( mt12 & MDBI ) return( TYMATCH );
1419: break;
1420:
1421: case MOD:
1422: case AND:
1423: case OR:
1424: case ER:
1425: if( mt12 & MINT ) return( TYMATCH );
1426: break;
1427:
1428: case LS:
1429: case RS:
1430: if( mt12 & MINT ) return( OTHER );
1431: break;
1432:
1433: case EQ:
1434: case NE:
1435: case LT:
1436: case LE:
1437: case GT:
1438: case GE:
1439: if( mt12 & MENU ) return( TYMATCH+NCVT+PUN );
1440: if( mt12 & MDBI ) return( TYMATCH+NCVT+CVTO );
1441: else if( mt12 & MPTR ) return( PTMATCH+PUN );
1442: else if( mt12 & MPTI ) return( PTMATCH+PUN );
1443: else break;
1444:
1445: case QUEST:
1446: case COMOP:
1447: if( mt2&MENU ) return( TYPR+NCVTR );
1448: return( TYPR );
1449:
1450: case STREF:
1451: return( NCVTR+OTHER );
1452:
1453: case FORCE:
1454: return( TYPL );
1455:
1456: case COLON:
1457: if( mt12 & MENU ) return( NCVT+PUN+TYMATCH );
1458: else if( mt12 & MDBI ) return( NCVT+TYMATCH );
1459: else if( mt12 & MPTR ) return( TYPL+PTMATCH+PUN );
1460: else if( (mt1&MINT) && (mt2&MPTR) ) return( TYPR+PUN );
1461: else if( (mt1&MPTR) && (mt2&MINT) ) return( TYPL+PUN );
1462: else if( mt12 & MSTR ) return( NCVT+TYPL+OTHER );
1463: else if( mt12 == MVOID ) return( NCVT+TYPL );
1464: break;
1465:
1466: case ASSIGN:
1467: case RETURN:
1468: if( mt12 & MSTR ) return( LVAL+NCVT+TYPL+OTHER );
1469: else if( mt12 & MENU ) return( LVAL+NCVT+TYPL+TYMATCH+PUN );
1470: case CAST:
1471: if(o==CAST && mt1==MVOID)return(TYPL+TYMATCH);
1472: else if( mt12 & MDBI ) return( TYPL+LVAL+NCVT+TYMATCH );
1473: else if( mt2 == MVOID &&
1474: ( p->in.right->in.op == CALL ||
1475: p->in.right->in.op == UNARY CALL)) break;
1476: else if( (mt1 & MPTR) && (mt2 & MPTI) )
1477: return( LVAL+PTMATCH+PUN );
1478: else if( mt12 & MPTI ) return( TYPL+LVAL+TYMATCH+PUN );
1479: break;
1480:
1481: case ASG LS:
1482: case ASG RS:
1483: if( mt12 & MINT ) return( TYPL+LVAL+OTHER );
1484: break;
1485:
1486: case ASG MUL:
1487: case ASG DIV:
1488: if( mt12 & MDBI ) return( LVAL+TYMATCH );
1489: break;
1490:
1491: case ASG MOD:
1492: case ASG AND:
1493: case ASG OR:
1494: case ASG ER:
1495: if( mt12 & MINT ) return( LVAL+TYMATCH );
1496: break;
1497:
1498: case ASG PLUS:
1499: case ASG MINUS:
1500: case INCR:
1501: case DECR:
1502: if( mt12 & MDBI ) return( TYMATCH+LVAL );
1503: else if( (mt1&MPTR) && (mt2&MINT) ) return( TYPL+LVAL+CVTR );
1504: break;
1505:
1506: case MINUS:
1507: if( mt12 & MPTR ) return( CVTO+PTMATCH+PUN );
1508: if( mt2 & MPTR ) break;
1509: case PLUS:
1510: if( mt12 & MDBI ) return( TYMATCH );
1511: else if( (mt1&MPTR) && (mt2&MINT) ) return( TYPL+CVTR );
1512: else if( (mt1&MINT) && (mt2&MPTR) ) return( TYPR+CVTL );
1513:
1514: }
1515: if( mt12 == MSTR )
1516: uerror( "%s is not a permitted struct/union operation", opst[o] );
1517: else
1518: uerror( "operands of %s have incompatible types", opst[o] );
1519: return( NCVT );
1520: }
1521:
1522: moditype( ty ) TWORD ty; {
1523:
1524: switch( ty ){
1525:
1526: case UNDEF:
1527: return( MVOID );
1528: case ENUMTY:
1529: case MOETY:
1530: return( MENU|MINT|MDBI|MPTI ); /* enums are ints */
1531:
1532: case STRTY:
1533: case UNIONTY:
1534: return( MSTR );
1535:
1536: case CHAR:
1537: case SHORT:
1538: case UCHAR:
1539: case USHORT:
1540: return( MINT|MPTI|MDBI );
1541: case UNSIGNED:
1542: case ULONG:
1543: case INT:
1544: case LONG:
1545: return( MINT|MDBI|MPTI );
1546: case FLOAT:
1547: case DOUBLE:
1548: return( MDBI );
1549: default:
1550: return( MPTR|MPTI );
1551:
1552: }
1553: }
1554:
1555: NODE *
1556: doszof( p ) register NODE *p; {
1557: /* do sizeof p */
1558: int i;
1559:
1560: /* whatever is the meaning of this if it is a bitfield? */
1561: i = tsize( p->in.type, p->fn.cdim, p->fn.csiz )/SZCHAR;
1562:
1563: tfree(p);
1564: if( i <= 0 ) werror( "sizeof returns 0" );
1565: return( bcon( i ) );
1566: }
1567:
1568: # ifndef BUG2
1569: eprint( p, down, a, b ) register NODE *p; int *a, *b; {
1570: register ty;
1571:
1572: *a = *b = down+1;
1573: while( down > 1 ){
1574: printf( "\t" );
1575: down -= 2;
1576: }
1577: if( down ) printf( " " );
1578:
1579: ty = optype( p->in.op );
1580:
1581: printf("%o) %s, ", p, opst[p->in.op] );
1582: if( ty == LTYPE ){
1583: printf( CONFMT, p->tn.lval );
1584: printf( ", %d, ", p->tn.rval );
1585: }
1586: tprint( p->in.type );
1587: printf( ", %d, %d\n", p->fn.cdim, p->fn.csiz );
1588: }
1589: # endif
1590:
1591: #ifndef PRTDCON
1592: prtdcon( p ) register NODE *p; {
1593: int o = p->in.op, i;
1594:
1595: if( o == DCON || o == FCON ){
1596: (void) locctr( DATA );
1597: defalign( o == DCON ? ALDOUBLE : ALFLOAT );
1598: deflab( i = getlab() );
1599: if( o == FCON )
1600: fincode( p->fpn.fval, SZFLOAT );
1601: else
1602: fincode( p->dpn.dval, SZDOUBLE );
1603: p->tn.lval = 0;
1604: p->tn.rval = -i;
1605: p->in.type = (o == DCON ? DOUBLE : FLOAT);
1606: p->in.op = NAME;
1607: }
1608: }
1609: #endif PRTDCON
1610:
1611:
1612: int edebug = 0;
1613: ecomp( p ) register NODE *p; {
1614: # ifndef BUG2
1615: if( edebug ) fwalk( p, eprint, 0 );
1616: # endif
1617: if( !reached ){
1618: werror( "statement not reached" );
1619: reached = 1;
1620: }
1621: p = optim(p);
1622: walkf( p, prtdcon );
1623: (void) locctr( PROG );
1624: ecode( p );
1625: tfree(p);
1626: }
1627:
1628: # ifdef STDPRTREE
1629: # ifndef ONEPASS
1630:
1631: prtree(p) register NODE *p; {
1632:
1633: register struct symtab *q;
1634: register ty;
1635:
1636: # ifdef MYPRTREE
1637: MYPRTREE(p); /* local action can be taken here; then return... */
1638: #endif
1639:
1640: ty = optype(p->in.op);
1641:
1642: printf( "%d\t", p->in.op );
1643:
1644: if( ty == LTYPE ) {
1645: printf( CONFMT, p->tn.lval );
1646: printf( "\t" );
1647: }
1648: if( ty != BITYPE ) {
1649: if( p->in.op == NAME || p->in.op == ICON ) printf( "0\t" );
1650: else printf( "%d\t", p->tn.rval );
1651: }
1652:
1653: printf( "%o\t", p->in.type );
1654:
1655: /* handle special cases */
1656:
1657: switch( p->in.op ){
1658:
1659: case NAME:
1660: case ICON:
1661: /* print external name */
1662: if( p->tn.rval == NONAME ) printf( "\n" );
1663: else if( p->tn.rval >= 0 ){
1664: q = &stab[p->tn.rval];
1665: printf( "%s\n", exname(q->sname) );
1666: }
1667: else { /* label */
1668: printf( LABFMT, -p->tn.rval );
1669: }
1670: break;
1671:
1672: case STARG:
1673: case STASG:
1674: case STCALL:
1675: case UNARY STCALL:
1676: /* print out size */
1677: /* use lhs size, in order to avoid hassles with the structure `.' operator */
1678:
1679: /* note: p->in.left not a field... */
1680: printf( CONFMT, (CONSZ) tsize( STRTY, p->in.left->fn.cdim, p->in.left->fn.csiz ) );
1681: printf( "\t%d\t\n", talign( STRTY, p->in.left->fn.csiz ) );
1682: break;
1683:
1684: default:
1685: printf( "\n" );
1686: }
1687:
1688: if( ty != LTYPE ) prtree( p->in.left );
1689: if( ty == BITYPE ) prtree( p->in.right );
1690:
1691: }
1692:
1693: # else
1694:
1695: p2tree(p) register NODE *p; {
1696: register ty;
1697:
1698: # ifdef MYP2TREE
1699: MYP2TREE(p); /* local action can be taken here; then return... */
1700: # endif
1701:
1702: ty = optype(p->in.op);
1703:
1704: switch( p->in.op ){
1705:
1706: case NAME:
1707: case ICON:
1708: #ifndef FLEXNAMES
1709: if( p->tn.rval == NONAME ) p->in.name[0] = '\0';
1710: #else
1711: if( p->tn.rval == NONAME ) p->in.name = "";
1712: #endif
1713: else if( p->tn.rval >= 0 ){ /* copy name from exname */
1714: register char *cp;
1715: cp = exname( stab[p->tn.rval].sname );
1716: #ifndef FLEXNAMES
1717: {
1718: register i;
1719: for( i=0; i<NCHNAM; ++i )
1720: p->in.name[i] = *cp++;
1721: }
1722: #else
1723: p->in.name = tstr(cp);
1724: #endif
1725: }
1726: #ifndef FLEXNAMES
1727: else sprintf( p->in.name, LABFMT, -p->tn.rval );
1728: #else
1729: else {
1730: char temp[32];
1731: sprintf( temp, LABFMT, -p->tn.rval );
1732: p->in.name = tstr(temp);
1733: }
1734: #endif
1735: break;
1736:
1737: case STARG:
1738: case STASG:
1739: case STCALL:
1740: case UNARY STCALL:
1741: /* set up size parameters */
1742: p->stn.stsize = (tsize(STRTY,p->in.left->fn.cdim,p->in.left->fn.csiz)+SZCHAR-1)/SZCHAR;
1743: p->stn.stalign = talign(STRTY,p->in.left->fn.csiz)/SZCHAR;
1744: break;
1745:
1746: case REG:
1747: rbusy( p->tn.rval, p->in.type );
1748: default:
1749: #ifndef FLEXNAMES
1750: p->in.name[0] = '\0';
1751: #else
1752: p->in.name = "";
1753: #endif
1754: }
1755:
1756: p->in.rall = NOPREF;
1757:
1758: if( ty != LTYPE ) p2tree( p->in.left );
1759: if( ty == BITYPE ) p2tree( p->in.right );
1760: }
1761:
1762: # endif
1763: # endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.