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