![[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] / researchv10no / cmd / ccom / common|
Return to trees.c CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / common |
1.1 root 1: /* @(#) trees.c: 1.3 3/4/84 */
2:
3: # include "mfile1.h"
4:
5: /* some special actions, used in finding the type of nodes */
6: # define NCVT 01
7: # define PUN 02
8: # define TYPL 04
9: # define TYPR 010
10: # define TYMATCH 040
11: # define LVAL 0100
12: # define CVTO 0200
13: # define CVTL 0400
14: # define CVTR 01000
15: # define PTMATCH 02000
16: # define OTHER 04000
17: # define NCVTR 010000
18:
19: /* node conventions:
20: **
21: ** NAME: rval>0 is stab index for external
22: ** rval<0 is -inlabel number
23: ** lval is offset in address units
24: ** (NAME really means "STATIC VARIABLE")
25: ** ICON: lval has the value
26: ** rval has the STAB index, or - label number,
27: ** if a name whose address is in the constant
28: ** rval = NONAME means no name
29: ** VAUTO: automatic name: lval has offset in address units
30: ** VPARAM: parameter: lval has offset in address units
31: ** REG: rval is reg. number
32: **
33: */
34: extern int maxarg;
35: int onlywarn;
36:
37: TWORD
38: indtype( t )
39: register TWORD t;
40: {
41: /* return the type of an intermediate expression of type t */
42: switch( t )
43: {
44:
45: case CHAR:
46: case SHORT:
47: return( INT );
48:
49: case UCHAR:
50: case USHORT:
51: return( UNSIGNED );
52:
53: /*rick: no! case FLOAT:
54: /* return( DOUBLE );
55: */
56:
57: }
58: return( t );
59: }
60:
61: int bdebug = 0;
62: extern ddebug;
63:
64: # ifndef XI
65: NODE *
66: xicolon( l, r1, r2 ) register NODE *l, *r1, *r2;
67:
68: {
69: uerror( "syntax error: colon in subscript" );
70: tfree( r2 );
71: return( buildtree( LB, l, r1 ) );
72: }
73: # endif
74:
75: NODE *
76: buildtree( o, l, r )
77: register NODE *l, *r;
78: register o;
79: {
80: register NODE *p, *q;
81: register struct symtab *sp;
82: register NODE *lr, *ll;
83: register actions;
84: register opty;
85: int i, tlineno;
86:
87: # ifndef NODBG
88: if( bdebug )
89: printf( "buildtree( %s, %d, %d )\n", opst[o], l-node, r-node );
90: # endif
91:
92: /* special case to recognize subscripting explicitly */
93:
94: # ifdef XI
95: if( o == LB && l->tn.type == LONG )
96: return( xicolon( l, r, (NODE *) 0 ) );
97: # endif
98:
99: if( o == LB ) return( buildtree( STAR, buildtree( PLUS, l, r ), NIL ) );
100: opty = optype(o);
101:
102: /* check for constants */
103:
104: if( o == NOT && l->in.op == ICON && hflag )
105: {
106: werror( "constant argument to NOT" );
107: }
108:
109: else if( o==UNARY MINUS && l->in.op==FCON )
110: {
111: l->fpn.dval = -l->fpn.dval;
112: return(l);
113: }
114:
115: else if( o==QUEST && l->in.op==ICON && l->tn.rval==NONAME )
116: {
117: l->in.op = FREE;
118: r->in.op = FREE;
119: if( l->tn.lval )
120: {
121: tfree( r->in.right );
122: return( r->in.left );
123: }
124: else
125: {
126: tfree( r->in.left );
127: return( r->in.right );
128: }
129: }
130:
131: else if( (o==ANDAND || o==OROR) && (l->in.op==ICON||r->in.op==ICON) )
132: goto ccwarn;
133:
134: else if( opty == BITYPE && l->in.op == ICON && r->in.op == ICON )
135: {
136:
137: switch( o )
138: {
139:
140: case ULT:
141: case UGT:
142: case ULE:
143: case UGE:
144: case LT:
145: case GT:
146: case LE:
147: case GE:
148: case EQ:
149: case NE:
150: case ANDAND:
151: case OROR:
152: case CBRANCH:
153:
154: ccwarn:
155: if( hflag ) werror( "constant in conditional context" );
156: }
157: }
158: if (o == CBRANCH || o == QUEST) switch (BTYPE(l->in.type)) {
159: case STRTY:
160: case UNIONTY:
161: if (!ISPTR(l->in.type))
162: uerror("struct/union in conditional");
163: case ENUMTY:
164: break;
165: }
166:
167: /* we make a real node, and look for shrinking later */
168:
169: tlineno = lineno;
170: if (l && l->ln.lineno && l->ln.lineno < tlineno)
171: tlineno = l->ln.lineno;
172: if (r && r->ln.lineno && r->ln.lineno < tlineno)
173: tlineno = r->ln.lineno;
174: p = block( o, l, r, INT, 0, INT );
175:
176: actions = opact(p);
177: # ifdef MYOPACT
178: actions = MYOPACT(p,actions);
179: # endif
180:
181: if( actions&LVAL )
182: {
183: /* check left descendent */
184: if( notlval(p->in.left) )
185: {
186: uerror( "illegal lhs of assignment operator" );
187: }
188: }
189:
190: if( actions & NCVTR )
191: {
192: p->in.left = pconvert( p->in.left );
193: }
194: else if( !(actions & NCVT ) )
195: {
196: switch( opty )
197: {
198:
199: case BITYPE:
200: p->in.right = pconvert( p->in.right );
201: case UTYPE:
202: if( !(actions&LVAL) )
203: p->in.left = pconvert( p->in.left );
204:
205: }
206: }
207:
208: if( (actions&PUN) && (o!=CAST||cflag) )
209: {
210: chkpun(p);
211: }
212:
213: if( actions & (TYPL|TYPR) )
214: {
215:
216: q = (actions&TYPL) ? p->in.left : p->in.right;
217:
218: p->in.type = q->in.type;
219: p->fn.cdim = q->fn.cdim;
220: p->fn.csiz = q->fn.csiz;
221: }
222:
223: if( actions & CVTL ) p = convert( p, CVTL );
224: if( actions & CVTR ) p = convert( p, CVTR );
225:
226: if( actions & TYMATCH ) p = tymatch(p);
227: if( actions & PTMATCH ) p = ptmatch(p);
228:
229: if( actions & SPFLG ) p = clocal(p);
230:
231: if( actions & OTHER )
232: {
233: l = p->in.left;
234: r = p->in.right;
235:
236: switch(o)
237: {
238:
239: case NAME:
240: sp = &stab[idname];
241: if( sp->stype == UNDEF )
242: {
243: uerror( "%s undefined", sp->sname );
244: /* make p look reasonable */
245: p->in.type = p->fn.cdim = p->fn.csiz = INT;
246: p->tn.rval = idname;
247: p->tn.lval = 0;
248: defid( p, SNULL );
249: break;
250: }
251: #if defined(M32B) && defined(IMPREGAL)
252: p->in.pad[0] = '@'; /*mark as un-raname()'d*/
253: #endif
254: p->in.type = sp->stype;
255: p->fn.cdim = sp->dimoff;
256: p->fn.csiz = sp->sizoff;
257: /* special case: MOETY is really an ICON... */
258: if( p->in.type == MOETY )
259: {
260: p->tn.rval = NONAME;
261: p->tn.lval = sp->offset;
262: p->fn.cdim = 0;
263: p->in.type = ENUMTY;
264: p->in.op = ICON;
265: }
266: else
267: {
268: switch( sp->sclass )
269: {
270:
271: case AUTO:
272: p->in.op = VAUTO;
273: p->tn.rval = NONAME;
274: p->tn.lval = BITOOR(sp->offset);
275: break;
276:
277: case PARAM:
278: p->in.op = VPARAM;
279: p->tn.rval = NONAME;
280: p->tn.lval = BITOOR(sp->offset);
281: break;
282:
283: case REGISTER:
284: p->in.op = REG;
285: p->tn.lval = 0;
286: p->tn.rval = sp->offset;
287: break;
288:
289: case ULABEL:
290: case LABEL:
291: case STATIC:
292: if( sp->slevel != 0 )
293: {
294: p->tn.lval = 0;
295: p->tn.rval = -sp->offset;
296: break;
297: }
298: /* FALLTHRU */
299:
300: default:
301: p->tn.lval = 0;
302: p->tn.rval = idname;
303: }
304: }
305: break;
306:
307: case ICON:
308: p->in.type = INT;
309: p->fn.cdim = 0;
310: p->fn.csiz = INT;
311: break;
312:
313: case STRING:
314: p->in.op = NAME;
315: p->in.type = CHAR+ARY;
316: p->tn.lval = 0;
317: p->tn.rval = NOLAB;
318: p->fn.cdim = curdim;
319: p->fn.csiz = CHAR;
320: break;
321:
322: case FCON:
323: p->tn.lval = 0;
324: p->tn.rval = 0;
325: p->in.type = DOUBLE;
326: p->fn.cdim = 0;
327: p->fn.csiz = DOUBLE;
328: #ifdef MYFCON
329: MYFCON(p);
330: #endif
331: break;
332:
333: case STREF:
334: /* p->x turned into *(p+offset) */
335: /* rhs must be a name; check correctness */
336:
337: i = r->tn.rval;
338: if(i<0 || i>=SYMTSZ || ((sp= &stab[i])->sclass != MOS &&
339: sp->sclass != MOU && !(sp->sclass&FIELD)) )
340: {
341: uerror( "%s not struct/union member",
342: sp->sname);
343: break;
344: }
345: else
346: /* if this name is non-unique, find right one */
347: if( sp->sflags&SNONUNIQ && (l->in.type==PTR+STRTY ||
348: l->in.type == PTR+UNIONTY) &&
349: (l->fn.csiz+1) >= 0 )
350: {
351: /* nonunique name && structure defined */
352: char * memnam, * tabnam;
353: register j;
354: int memi;
355: j=dimtab[l->fn.csiz+1];
356: for( ; (memi=dimtab[j]) >= 0; ++j )
357: {
358: tabnam = stab[memi].sname;
359: memnam = stab[i].sname;
360: # ifndef NODBG
361: if( ddebug>1 )
362: {
363: printf("member %s==%s?\n",
364: memnam, tabnam);
365: }
366: # endif
367: if( stab[memi].sflags & SNONUNIQ )
368: {
369: if ( memnam != tabnam )
370: continue;
371: r->tn.rval = i = memi;
372: break;
373: }
374: continue;
375: }
376: if( memi < 0 )
377: uerror("%s not in this struct/union",
378: stab[i].sname);
379: }
380: else
381: {
382: register j;
383: if( l->in.type != PTR+STRTY &&
384: l->in.type != PTR+UNIONTY )
385: {
386: if( stab[i].sflags & SNONUNIQ )
387: {
388: uerror(
389: "nonunique name (%s) demands struct/union or struct/union pointer", stab[i].sname);
390: }
391: else uerror("%s needs reference to struct/union", sp->sname);
392: }
393: else if( (j=l->fn.csiz+1)<0 )
394: cerror( "undefined structure or union");
395: else if( !chkstr( i, dimtab[j],
396: DECREF(l->in.type) ) )
397: {
398: uerror("%s not in this struct/union",
399: sp->sname );
400: }
401: }
402: p = stref( p );
403: break;
404:
405: case STAR:
406: if( l->in.op == UNARY AND )
407: {
408: p->in.op = l->in.op = FREE;
409: p = l->in.left;
410: }
411: if( !ISPTR(l->in.type) ) uerror("illegal indirection");
412: p->in.type = DECREF(l->in.type);
413: p->fn.cdim = l->fn.cdim;
414: p->fn.csiz = l->fn.csiz;
415: break;
416:
417: case UNARY AND:
418: switch( l->in.op ) {
419: case CONV:
420: uerror("can't take address of cast");
421: break;
422: case STAR:
423: p->in.op = l->in.op = FREE;
424: p = l->in.left;
425: case NAME:
426: case VAUTO:
427: case VPARAM:
428: case TEMP:
429: case STCALL:
430: case UNARY STCALL:
431: refinc:
432: p->in.type = INCREF( l->in.type );
433: p->fn.cdim = l->fn.cdim;
434: p->fn.csiz = l->fn.csiz;
435: break;
436: case RNODE:
437: #ifdef TMPSRET
438: /* don't bother, let optim clean up */
439: if (simpstr(l->fn.cdim, l->fn.csiz) != STRTY)
440: goto refinc;
441: p->in.op = STAR;
442: p->in.type = STRTY;
443: p->fn.csiz = l->fn.csiz;
444: p->fn.cdim = l->fn.cdim;
445: l->in.op = FREE;
446: idname = lookup(hash(".stfake"), 0);
447: p->in.left = buildtree(NAME, NIL, NIL);
448: p->in.left->fn.csiz = p->fn.csiz;
449: p->in.left->fn.cdim = p->fn.cdim;
450: break;
451: #else
452: goto refinc;
453: #endif
454: case COMOP:
455: lr = buildtree( UNARY AND, l->in.right, NIL );
456: p->in.op = l->in.op = FREE;
457: p = buildtree( COMOP, l->in.left, lr );
458: break;
459: case QUEST:
460: lr = buildtree(UNARY AND,
461: l->in.right->in.right, NIL);
462: ll = buildtree(UNARY AND,
463: l->in.right->in.left, NIL);
464: p->in.op = l->in.op = l->in.right->in.op = FREE;
465: p = buildtree(QUEST, l->in.left,
466: buildtree( COLON, ll, lr));
467: break;
468: default:
469: uerror( "unacceptable operand of &" );
470: break;
471: }
472: break;
473: case RETURN:
474: case ASSIGN:
475: case CAST:
476: /* structure assignment */
477: /* take the addresses of the two sides; then make an
478: ** operator using STASG and
479: ** the addresses of left and right
480: */
481: {
482: register TWORD t;
483: register d, s, sz;
484:
485: if( l->fn.csiz != r->fn.csiz )
486: uerror(
487: "assignment of different structures" );
488:
489: r = buildtree( UNARY AND, r, NIL );
490: l = buildtree( UNARY AND, l, NIL );
491: t = r->in.type;
492: d = r->fn.cdim;
493: s = r->fn.csiz;
494: #ifdef ENDSTRUCT
495: sz = tsize( STRTY, d, s );
496: l = aadjust( l, sz );
497: r = aadjust( r, sz );
498: #endif
499:
500: l = block( STASG, l, r, t, d, s );
501:
502: if( o == RETURN )
503: {
504: p->in.op = FREE;
505: p = l;
506: break;
507: }
508:
509: p->in.op = STAR;
510: p->in.left = clocal(l);
511: p->in.right = NIL;
512: break;
513: }
514: case COLON:
515: if( l->fn.csiz != r->fn.csiz )
516: uerror( "type clash in ?:" );
517: break;
518:
519: case CALL:
520: i = 0;
521: p->in.right = r = strargs( p->in.right, &i );
522: if( i > maxarg ) maxarg = i;
523: case UNARY CALL:
524: if( !ISPTR(l->in.type)) uerror("call of non-function");
525: p->in.type = DECREF(l->in.type);
526: if( !ISFTN(p->in.type)) uerror("call of non-function");
527: p->in.type = DECREF( p->in.type );
528: p->fn.cdim = l->fn.cdim;
529: p->fn.csiz = l->fn.csiz;
530: if( l->in.op == UNARY AND &&
531: l->in.left->in.op == NAME &&
532: l->in.left->tn.rval >= 0 &&
533: l->in.left->tn.rval != NONAME &&
534: ((i=stab[l->in.left->tn.rval].sclass)==FORTRAN
535: || i == UFORTRAN ) )
536: {
537: p->in.op += (FORTCALL-CALL);
538: }
539: if( p->in.type == STRTY || p->in.type == UNIONTY )
540: {
541: /* function returning structure */
542: /* function really returns ptr with * */
543:
544: # ifdef ARGSRET
545: /* set aside argument space for return val */
546: i = tsize( p->in.type, p->fn.cdim, p->fn.csiz );
547: /* alignment??? */
548: if( i > maxarg ) maxarg = i;
549: # endif
550: p->in.op += STCALL-CALL;
551: p->in.type = INCREF( p->in.type );
552: p = buildtree( STAR, p, NIL );
553: break;
554: }
555:
556: /* fix up type of return value from call */
557: {
558: register TWORD t;
559: t = indtype( p->tn.type );
560: if( t != p->tn.type )
561: {
562: p->fn.csiz = p->tn.type = t;
563: }
564: /* pjw if (p->fn.type == FLOAT)
565: p->fn.type = p->fn.csiz = DOUBLE;
566: */ }
567: # ifdef ARGALLRET
568: /* set aside argument space for return val */
569: i = tsize( p->in.type, p->fn.cdim, p->fn.csiz );
570: /* alignment??? */
571: if( i > maxarg ) maxarg = i;
572: # endif
573: break;
574:
575: default:
576: cerror( "other code %d", o );
577: }
578:
579: }
580:
581: if( actions & CVTO ) p = oconvert(p);
582: p = clocal(conval(p));
583:
584: # ifndef NODBG
585: if( bdebug ) eprint(p);
586: # endif
587: p->ln.lineno = tlineno;
588: return(p);
589:
590: }
591:
592: NODE *
593: strargs( p, off )
594: register NODE *p;
595: register *off;
596: {
597: /* rewrite arguments */
598: /* allocate the arguments at *off, and update *off */
599: register TWORD t;
600: int workoff;
601:
602: t = p->fn.type;
603: if( p->in.op == CM )
604: {
605: #if defined(BACKARGS) && defined(BACKPARAM) || \
606: !defined(BACKARGS) && !defined(BACKPARAM)
607:
608: p->in.left = strargs( p->in.left, off );
609: p->in.right = strargs( p->in.right, off );
610:
611: #else
612:
613: p->in.right = strargs(p->in.right, off);
614: p->in.left = strargs(p->in.left, off);
615:
616: #endif
617: return( p );
618: }
619:
620: if (t == FLOAT)
621: p = makety(p, t = DOUBLE, 0, DOUBLE);
622: p = block( STARG, p, NIL, t, p->fn.cdim, p->fn.csiz );
623: if( t == STRTY || t == UNIONTY )
624: {
625: p->in.left = buildtree( UNARY AND, p->in.left, NIL );
626: }
627: else
628: {
629: p->in.op = FUNARG;
630: }
631:
632: /* SETOFF( *off, talign( t, p->fn.csiz ) ); */
633: SETOFF( *off, ALSTACK );
634: workoff = tsize( t, p->fn.cdim, p->fn.csiz );
635:
636: #ifdef BACKARGS
637: *off += workoff;
638: p->tn.rval = -*off;
639: #else
640: p->tn.rval = *off;
641: *off += workoff;
642: #endif
643: return( clocal(p) );
644: }
645:
646: chkstr( i, j, type )
647: register TWORD type;
648: register i,j;
649: {
650: /* is the MOS or MOU at stab[i] OK for strict reference by a ptr */
651: /* i has been checked to contain a MOS or MOU */
652: /* j is the index in dimtab of the members... */
653: register k, kk;
654:
655: extern int ddebug;
656:
657: # ifndef NODBG
658: if( ddebug > 1 ) printf( "chkstr( %s(%d), %d )\n", stab[i].sname, i, j );
659: # endif
660: if( (k = j) < 0 ) uerror( "undefined struct/union using %s", stab[i].sname);
661: else
662: {
663: for( ; (kk = dimtab[k] ) >= 0; ++k )
664: {
665: if( kk >= SYMTSZ )
666: {
667: cerror( "gummy structure" );
668: return(1);
669: }
670: if( kk == i ) return( 1 );
671: switch( stab[kk].stype )
672: {
673:
674: case STRTY:
675: case UNIONTY:
676: if( type == STRTY ) continue; /* no recursive looking for strs */
677: if( hflag && chkstr( i, dimtab[stab[kk].sizoff+1], stab[kk].stype ) )
678: {
679: if( stab[kk].sname[0] == '$' ) return(0); /* $FAKE */
680: werror(
681: "illegal member use: perhaps %s.%s?",
682: stab[kk].sname, stab[i].sname);
683: return(1);
684: }
685: }
686: }
687: }
688: return( 0 );
689: }
690:
691: NODE *
692: conval( p )
693: register NODE *p;
694: {
695: register NODE *l, *r;
696: register o, i, f, u;
697: register CONSZ val;
698:
699: f = (p->tn.type==FLOAT || p->tn.type == DOUBLE);
700: u = ISUNSIGNED(p->tn.type);
701:
702: switch( optype(o = p->tn.op) )
703: {
704: case BITYPE:
705: l = p->in.left;
706: r = p->in.right;
707: break;
708:
709: case UTYPE:
710: r = l = p->in.left;
711: break;
712:
713: case LTYPE:
714: return( p );
715: }
716:
717: if( l->tn.op != ( f ? FCON : ICON ) ) return( p );
718: if( r->tn.op != ( f ? FCON : ICON ) ) return( p );
719:
720: if( !f )
721: {
722: /* weed out unprofitable cases */
723: val = r->tn.lval;
724: if( l->tn.rval != NONAME && r->tn.rval != NONAME ) return(p);
725: if( r->tn.rval != NONAME && o!=PLUS ) return(p);
726: if( l->tn.rval != NONAME && o!=PLUS && o!=MINUS ) return(p);
727: }
728: else if( logop(o) ) return( p );
729:
730: switch( o )
731: {
732:
733: case PLUS:
734: if( f )
735: {
736: l->fpn.dval += r->fpn.dval;
737: break;
738: }
739: l->tn.lval += val;
740: if( l->tn.rval == NONAME )
741: {
742: l->tn.rval = r->tn.rval;
743: l->in.type = r->in.type;
744: }
745: break;
746:
747: case MINUS:
748: if( f ) l->fpn.dval -= r->fpn.dval;
749: else l->tn.lval -= val;
750: break;
751:
752: case MUL:
753: if( f ) l->fpn.dval *= r->fpn.dval;
754: else l->tn.lval *= val;
755: break;
756:
757: case DIV:
758: if( f )
759: {
760: if( r->fpn.dval == 0. ) uerror( "division by 0" );
761: else l->fpn.dval /= r->fpn.dval;
762: }
763: else
764: {
765: if( val == 0 ) uerror( "division by 0" );
766: else if( u )
767: l->tn.lval = (unsigned long)l->tn.lval / val;
768: else l->tn.lval /= val;
769: }
770: break;
771:
772: case MOD:
773: if( val == 0 ) uerror( "division by 0" );
774: else if( u ) l->tn.lval = (unsigned long)l->tn.lval % val;
775: else l->tn.lval %= val;
776: break;
777:
778: case AND:
779: l->tn.lval &= val;
780: break;
781:
782: case OR:
783: l->tn.lval |= val;
784: break;
785:
786: case ER:
787: l->tn.lval ^= val;
788: break;
789:
790: case LS:
791: i = val;
792: l->tn.lval = l->tn.lval << i;
793: break;
794:
795: case RS:
796: i = val;
797: if(i > 32) {
798: uerror("illegal shift");
799: break;
800: }
801: if( u ) l->tn.lval = (unsigned long)l->tn.lval >> i;
802: else l->tn.lval = l->tn.lval >> i;
803: break;
804:
805: case UNARY MINUS:
806: if( f ) l->fpn.dval = -l->fpn.dval;
807: else l->tn.lval = - l->tn.lval;
808: break;
809:
810: case COMPL:
811: l->tn.lval = ~l->tn.lval;
812: break;
813:
814: case NOT:
815: if( l->tn.type == FLOAT || l->tn.type == DOUBLE )
816: {
817: l->tn.op = ICON;
818: l->tn.lval = !l->fpn.dval;
819: }
820: else l->tn.lval = !l->tn.lval;
821: break;
822:
823: case LT:
824: l->tn.lval = l->tn.lval < val;
825: break;
826:
827: case LE:
828: l->tn.lval = l->tn.lval <= val;
829: break;
830:
831: case GT:
832: l->tn.lval = l->tn.lval > val;
833: break;
834:
835: case GE:
836: l->tn.lval = l->tn.lval >= val;
837: break;
838:
839: case ULT:
840: l->tn.lval = (l->tn.lval-val)<0;
841: break;
842:
843: case ULE:
844: l->tn.lval = (l->tn.lval-val)<=0;
845: break;
846:
847: case UGE:
848: l->tn.lval = (l->tn.lval-val)>=0;
849: break;
850:
851: case UGT:
852: l->tn.lval = (l->tn.lval-val)>0;
853: break;
854:
855: case EQ:
856: l->tn.lval = l->tn.lval == val;
857: break;
858:
859: case NE:
860: l->tn.lval = l->tn.lval != val;
861: break;
862:
863: default:
864: return(p);
865: }
866:
867: if( l != r ) r->tn.op = FREE; /* don't clobber unary answer */
868: l = makety( l, p->tn.type, p->fn.cdim, p->fn.csiz );
869: p->tn.op = FREE;
870: return( l );
871: }
872:
873: chkpun(p)
874: register NODE *p;
875: {
876: /* checks p for the existance of a pun */
877: /* this is called when the op of p is ASSIGN, RETURN, CAST, COLON,
878: ** or relational
879: */
880:
881: /* one case is when enumerations are used: this applies only to lint */
882: /* in the other case, one operand is a pointer, the other integer */
883: /* we check that this integer is in fact a constant zero... */
884: /* if it is, we redo the type of the 0 to match the other side */
885:
886: /* with ASSIGN, assignment of pointer to integer is illegal */
887: /* this falls out, because the LHS is never 0 */
888:
889: register NODE *q1, *q2;
890: register t1, t2;
891: register d1, d2;
892:
893: q1 = p->in.left;
894: q2 = p->in.right;
895: t1 = q1->in.type;
896: t2 = q2->in.type;
897:
898: if( t1==ENUMTY || t2==ENUMTY )
899: {
900: /* check for enumerations */
901: /*(pjw)if( logop( p->in.op ) && p->in.op != EQ && p->in.op != NE )
902: {
903: uerror( "illegal comparison of enums" );
904: return;
905: }*/
906: if( t1==ENUMTY && t2==ENUMTY && q1->fn.csiz==q2->fn.csiz )
907: return;
908: werror( "enumeration type clash, operator %s", opst[p->in.op] );
909: return;
910: }
911:
912: if( ISPTR(t1) || ISARY(t1) )
913: { /* switch roles: q1 should be non-pointer */
914: q1 = q2;
915: q2 = p->in.left;
916: }
917:
918: if( !ISPTR(q1->in.type) && !ISARY(q1->in.type) )
919: {
920: if( q1->in.op == ICON && q1->tn.lval == 0 && q1->tn.rval == NONAME )
921: { /* make the 0 have the type of the other side */
922: q1->fn.type = q2->fn.type;
923: q1->fn.cdim = q2->fn.cdim;
924: q1->fn.csiz = q2->fn.type;
925: }
926: else
927: {
928: combo( "pointer/integer", p );
929: }
930: return;
931: }
932: else
933: { /* q1 and q2 still mean left and right */
934: d1 = q1->fn.cdim;
935: d2 = q2->fn.cdim;
936: for( ;; )
937: {
938: if( t1 == t2 )
939: {
940: ;
941: if(q1->fn.csiz!=q2->fn.csiz)
942: {
943: combo( "structure pointer", p );
944: }
945: return;
946: }
947: /****** LINT Change: Turn on only if LINT is to be used with this pcc2 ******/
948: /* /* complain about pointer casts if cflag is set
949: /* /* (this implies that pflag is set)
950: /* */
951: /* if (p->in.op == CAST)
952: /* {
953: /* if (ISPTR(tl) && ISPTR(t2))
954: /* {
955: /* werror(
956: /* "pointer casts may be troublesome");
957: /* return;
958: /* }
959: /* }
960: /****************************************************************************/
961: if( ISARY(t1) || ISPTR(t1) )
962: {
963: if( !ISARY(t2) && !ISPTR(t2) ) break;
964: if( ISARY(t1) && ISARY(t2) &&
965: dimtab[d1] != dimtab[d2] )
966: {
967: combo( "array size", p );
968: return;
969: }
970: if( ISARY(t1) ) ++d1;
971: if( ISARY(t2) ) ++d2;
972: }
973: else break;
974: t1 = DECREF(t1);
975: t2 = DECREF(t2);
976: }
977: combo( "pointer", p );
978: }
979: }
980:
981: combo( s, p )
982: char *s;
983: NODE *p;
984: {
985: char buf[100];
986: sprintf( buf, "illegal %s combination, op %s", s, opst[p->tn.op] );
987: if(onlywarn)
988: werror(buf);
989: else
990: uerror(buf);
991: }
992:
993: NODE *
994: stref( p )
995: register NODE *p;
996: {
997: register TWORD t;
998: register d, s, dsc, align;
999: register OFFSZ off;
1000: register struct symtab *q;
1001:
1002: /* make p->x */
1003: /* this is also used to reference automatic variables */
1004: q = &stab[p->in.right->tn.rval];
1005: q->suse = -lineno;
1006: p->in.right->in.op = FREE;
1007: p->in.op = FREE;
1008: p = pconvert( p->in.left );
1009:
1010: /* make p look like ptr to x */
1011:
1012: if( !ISPTR(p->in.type))
1013: {
1014: p->in.type = PTR+UNIONTY;
1015: }
1016:
1017: t = INCREF( q->stype );
1018: d = q->dimoff;
1019: s = q->sizoff;
1020:
1021: p = makety( p, t, d, s );
1022:
1023: /* compute the offset to be added */
1024:
1025: off = q->offset;
1026: dsc = q->sclass;
1027:
1028: if( dsc & FIELD )
1029: {
1030: /* normalize offset */
1031: switch(q->stype)
1032: {
1033:
1034: case CHAR:
1035: case UCHAR:
1036: align = ALCHAR;
1037: s = CHAR;
1038: break;
1039:
1040: case SHORT:
1041: case USHORT:
1042: align = ALSHORT;
1043: s = SHORT;
1044: break;
1045:
1046: case ENUMTY:
1047: case INT:
1048: case UNSIGNED:
1049: align = ALINT;
1050: s = INT;
1051: break;
1052:
1053: # ifdef LONGFIELDS
1054: case LONG:
1055: case ULONG:
1056: align = ALLONG;
1057: s = LONG;
1058: break;
1059: # endif
1060:
1061: default:
1062: cerror( "undefined bit field type" );
1063: }
1064: off = (off/align)*align;
1065: }
1066: if( off != 0 )
1067: p = clocal( block( PLUS, p, offcon( off, t, d, s ), t, d, s ) );
1068:
1069: p = buildtree( STAR, p, NIL );
1070:
1071: /* if field, build field info */
1072:
1073: if( dsc & FIELD )
1074: {
1075: p = block( FLD, p, NIL, q->stype, 0, q->sizoff );
1076: p->tn.rval = PKFIELD( dsc&FLDSIZ, q->offset%align );
1077: }
1078: p = clocal(p);
1079: return(p);
1080: }
1081:
1082: notlval(p)
1083: register NODE *p;
1084: {
1085:
1086: /* return 0 if p an lvalue, 1 otherwise */
1087:
1088: again:
1089: switch( p->in.op )
1090: {
1091:
1092: case FLD:
1093: p = p->in.left;
1094: goto again;
1095:
1096: case STAR:
1097: /* is there a special case for structs? */
1098: case NAME:
1099: case VAUTO:
1100: case VPARAM:
1101: case RNODE:
1102: case QNODE:
1103: case SNODE:
1104: if( ISARY(p->in.type) || ISFTN(p->in.type) ) return(1);
1105: case REG:
1106: return(0);
1107:
1108: default:
1109: return(1);
1110:
1111: }
1112:
1113: }
1114:
1115: NODE *
1116: bcon( i )
1117: {
1118: /* make a constant node with value i */
1119: register NODE *p;
1120:
1121: p = block( ICON, NIL, NIL, INT, 0, INT );
1122: p->tn.lval = i;
1123: p->tn.rval = NONAME;
1124: return( clocal(p) );
1125: }
1126:
1127: NODE *
1128: bpsize(p)
1129: register NODE *p;
1130: {
1131: return( offcon( psize(p), p->in.type, p->fn.cdim, p->fn.csiz ) );
1132: }
1133:
1134: OFFSZ
1135: psize( p )
1136: register NODE *p;
1137: {
1138: /* p is a node of type pointer; psize returns the
1139: ** size of the thing pointed to
1140: */
1141:
1142: if( !ISPTR(p->in.type) )
1143: {
1144: uerror( "pointer required");
1145: return( SZINT );
1146: }
1147: /* note: no pointers to fields */
1148: return( tsize( DECREF(p->in.type), p->fn.cdim, p->fn.csiz ) );
1149: }
1150:
1151: NODE *
1152: unconvert( p, q )
1153: register NODE *p, *q;
1154: {
1155: /* p is divided by the size of q */
1156: /* q had better have type pointer */
1157:
1158: # ifdef MYPDIV
1159: return( clocal( block( PDIV, p, bpsize(q), INT, 0, INT ) ) );
1160: # else
1161: p = makety( p, PTRTYPE, 0, PTRTYPE );
1162: p = clocal( buildtree( DIV, p, bpsize(q) ) );
1163:
1164: return( makety( p, PTRTYPE, 0, PTRTYPE ) );
1165: # endif
1166: }
1167:
1168: NODE *
1169: convert( p, f )
1170: register NODE *p;
1171: register f;
1172: {
1173: /* convert an operand of p
1174: ** f is either CVTL or CVTR
1175: ** operand has type int, and is converted by the size of the other side
1176: */
1177:
1178: register NODE *q, *r;
1179:
1180: if( f == CVTL )
1181: {
1182: q = p->in.left;
1183: r = bpsize( p->in.right );
1184: }
1185: else
1186: {
1187: q = p->in.right;
1188: r = bpsize( p->in.left );
1189: }
1190: # ifdef MYPMUL
1191: r = clocal( block( PMUL, q, r, PTRTYPE, 0, PTRTYPE ) );
1192: # else
1193: /* if PTRTYPE is defined, make q this size; then, the MUL will be */
1194: q = makety( q, PTRTYPE, 0, PTRTYPE );
1195: r = clocal( buildtree( MUL, q, r ) );
1196: # endif
1197: if( f == CVTL )
1198: p->in.left = r;
1199: else
1200: p->in.right = r;
1201: return(p);
1202:
1203: }
1204:
1205: econvert( p )
1206: register NODE *p;
1207: {
1208:
1209: /* change enums to ints, or appropriate types */
1210:
1211: register TWORD ty;
1212:
1213: if( (ty=BTYPE(p->in.type)) == ENUMTY || ty == MOETY )
1214: {
1215: if( dimtab[ p->fn.csiz ] == SZCHAR ) ty = CHAR;
1216: else if( dimtab[ p->fn.csiz ] == SZINT ) ty = INT;
1217: else if( dimtab[ p->fn.csiz ] == SZSHORT ) ty = SHORT;
1218: else ty = LONG;
1219: ty = ctype( ty );
1220: p->fn.csiz = ty;
1221: MODTYPE(p->in.type,ty);
1222: if( p->in.op == ICON && ty != LONG )
1223: p->in.type = p->fn.csiz = INT;
1224: }
1225: }
1226:
1227: NODE *
1228: pconvert( p )
1229: register NODE *p;
1230: {
1231: register TWORD t;
1232:
1233: /* if p should be changed into a pointer, do so */
1234: /* also, widen p so it can be used as an operand */
1235:
1236: if( ISARY( p->in.type) )
1237: {
1238: p->in.type = DECREF( p->in.type );
1239: ++p->fn.cdim;
1240: return( buildtree( UNARY AND, p, NIL ) );
1241: }
1242: if( ISFTN( p->in.type) )
1243: return( buildtree( UNARY AND, p, NIL ) );
1244:
1245: t = indtype( p->tn.type );
1246: if( t == p->tn.type ) return( p );
1247: if( p->tn.op == CONV && cbigger( p ) )
1248: {
1249: p->tn.type = p->fn.csiz = t;
1250: }
1251: else p = makety( p, t, 0, (int) t );
1252: return( p );
1253: }
1254:
1255: bigsize( t )
1256: TWORD t;
1257: { /* return a type size for t */
1258: switch( t ) {
1259: case CHAR:
1260: case UCHAR:
1261: return( SZCHAR );
1262: case SHORT:
1263: case USHORT:
1264: return( SZSHORT );
1265: case VOID:
1266: case INT:
1267: case UNSIGNED:
1268: case ENUMTY:
1269: return( SZINT );
1270: case LONG:
1271: case ULONG:
1272: return( SZLONG );
1273: case FLOAT:
1274: return( SZLONG+1 ); /* must appear > long */
1275: case DOUBLE:
1276: return( SZLONG+2 );
1277: case STRTY:
1278: uerror("structure appears where arithmetic type required");
1279: return(0);
1280: case UNIONTY:
1281: uerror("union appears where arithmetic type required");
1282: return(0);
1283: }
1284:
1285: if( ISPTR(t) || ISARY(t) ) return( SZPOINT );
1286:
1287: cerror( "bad bigsize: 0%o", t );
1288: /*NOTREACHED*/
1289: }
1290:
1291: cbigger( p )
1292: register NODE *p;
1293: {
1294: /* returns 1 if the conversion op p makes things bigger */
1295:
1296: if( p->tn.op != CONV ) cerror( "cbigger" );
1297: if(p->tn.type == STRTY || p->tn.type == UNIONTY || p->tn.type == VOID) {
1298: uerror("trying to cast to a struct, void or union");
1299: return(0);
1300: }
1301: return( bigsize( p->tn.type ) > bigsize( p->in.left->tn.type ) );
1302: }
1303:
1304: NODE *
1305: oconvert(p)
1306: register NODE *p;
1307:
1308: {
1309: /* convert the result itself: used for pointer and unsigned */
1310: register TWORD t;
1311:
1312: switch(p->in.op)
1313: {
1314:
1315: case LE:
1316: case LT:
1317: case GE:
1318: case GT:
1319: t = p->in.left->in.type;
1320: if( ISUNSIGNED(t) || ISPTR(t) || ISARY(t) )
1321: {
1322: p->in.op += (ULE-LE);
1323: }
1324: else
1325: {
1326: t = p->in.right->in.type;
1327: if( ISUNSIGNED(t) || ISPTR(t) || ISARY(t) )
1328: {
1329: p->in.op += (ULE-LE);
1330: }
1331: }
1332: case EQ:
1333: case NE:
1334: case ULE:
1335: case ULT:
1336: case UGE:
1337: case UGT:
1338: return( p );
1339:
1340: case MINUS:
1341: return( unconvert( p, p->in.left ) );
1342: }
1343:
1344: cerror( "illegal oconvert: %d", p->in.op );
1345:
1346: return(p);
1347: }
1348:
1349: NODE *
1350: ptmatch(p)
1351: register NODE *p;
1352: {
1353:
1354: /* makes the operands of p agree; they are
1355: ** either pointers or integers, by this time
1356: */
1357: /* with MINUS, the sizes must be the same */
1358: /* with COLON, the types must be the same */
1359:
1360: register TWORD t1, t2, t;
1361: register o, d2, d, s2, s;
1362:
1363: o = p->in.op;
1364: t = t1 = p->in.left->in.type;
1365: t2 = p->in.right->in.type;
1366: d = p->in.left->fn.cdim;
1367: d2 = p->in.right->fn.cdim;
1368: s = p->in.left->fn.csiz;
1369: s2 = p->in.right->fn.csiz;
1370:
1371: switch( o )
1372: {
1373:
1374: case ASSIGN:
1375: case RETURN:
1376: case CAST:
1377: break;
1378:
1379: case MINUS:
1380: if( psize(p->in.left) != psize(p->in.right) )
1381: {
1382: uerror( "illegal pointer subtraction");
1383: }
1384: p->tn.type = p->fn.csiz = PTRTYPE;
1385: p->fn.cdim = 0;
1386: return( clocal(p) );
1387:
1388: case COLON:
1389: if( t1 != t2 ) uerror( "incompatible types in ?:");
1390: break;
1391:
1392: default:
1393: if( !ISPTR(t1) )
1394: {
1395: t = t2;
1396: d = d2;
1397: s = s2;
1398: break;
1399: }
1400: if( !ISPTR(t2) )
1401: {
1402: break;
1403: }
1404:
1405: /* both are pointers */
1406: if( talign(t2,s2) < talign(t,s) )
1407: {
1408: t = t2;
1409: s = s2;
1410: }
1411: break;
1412: }
1413:
1414: p->in.left = makety( p->in.left, t, d, s );
1415: p->in.right = makety( p->in.right, t, d, s );
1416: if( !logop(o) )
1417: {
1418: p->in.type = t;
1419: p->fn.cdim = d;
1420: p->fn.csiz = s;
1421: }
1422:
1423: return(clocal(p));
1424: }
1425:
1426: int tdebug = 0;
1427:
1428: NODE *
1429: tymatch(p)
1430: register NODE *p;
1431: {
1432:
1433: /* satisfy the types of various arithmetic binary ops */
1434:
1435: /* rules are:
1436: ** if any float or doubles, make double
1437: ** no, rick changes this rule to
1438: ** a. if any doubles, make double
1439: ** b. if both floats, make float
1440: ** c. if any floats, make double
1441: ** the rest proceed as usual
1442: ** if any longs, make long
1443: ** if any ints, make int
1444: ** if any shorts, make short
1445: ** otherwise, make char
1446: ** if either operand is unsigned, the result is...
1447: ** if a simple assignment, type = type of lhs
1448: ** if an asg. op, type = type of original lhs
1449: ** (under CONV, if any)
1450: ** pjw observes this is not right, for int /= double is wrong
1451: */
1452:
1453: register o;
1454: register TWORD t1, t2;
1455: TWORD t, tu;
1456: register NODE *l, *r;
1457: int u;
1458:
1459: o = p->in.op;
1460:
1461: t1 = (l=p->in.left)->in.type;
1462: t2 = (r=p->in.right)->in.type;
1463:
1464: /* constants have a kind of "flexible" type */
1465:
1466: if( r->tn.op == ICON && r->tn.rval == NONAME &&
1467: (t1==CHAR || t1==UCHAR || t1==SHORT || t1==USHORT) )
1468: {
1469: /* if the constant retains its value when cast to the
1470: ** type of the lhs, assume it has the lhs type
1471: */
1472: if( r->tn.lval == ccast( r->tn.lval, t1 ) )
1473: {
1474: r->in.type = t2 = t1;
1475: r->fn.cdim = l->fn.cdim;
1476: r->fn.csiz = l->fn.csiz;
1477: }
1478: }
1479:
1480: /* this is the opposite case from the above (it is too early
1481: to assume that constants are on the right) */
1482:
1483: if( l->tn.op == ICON && l->tn.rval == NONAME &&
1484: (t2==CHAR || t2==UCHAR || t2==SHORT || t2==USHORT) )
1485: {
1486: /* if the constant retains its value when cast to the
1487: ** type of the rhs, assume it has the rhs type
1488: */
1489: if( l->tn.lval == ccast( l->tn.lval, t2 ) )
1490: {
1491: l->in.type = t1 = t2;
1492: l->fn.cdim = r->fn.cdim;
1493: l->fn.csiz = r->fn.csiz;
1494: }
1495: }
1496: if( (t1==VOID || t2==VOID) && o!=CAST )
1497: uerror("void type illegal in expression");
1498:
1499: u = 0;
1500: if( ISUNSIGNED(t1) )
1501: {
1502: u = 1;
1503: t1 = DEUNSIGN(t1);
1504: }
1505: if( ISUNSIGNED(t2) )
1506: {
1507: u |= 2;
1508: t2 = DEUNSIGN(t2);
1509: }
1510: /*rick
1511: /* if( t1==DOUBLE || t1==FLOAT || t2==DOUBLE || t2==FLOAT ) t = DOUBLE;
1512: */
1513: /*pjw says enums are ints dammit */
1514: if(t1 == ENUMTY) t1 = INT;
1515: if(t2 == ENUMTY) t2 = INT;
1516: if (t1 == DOUBLE || t2 == DOUBLE) t = DOUBLE;
1517: else if (t1 == FLOAT && t2 == FLOAT) t = FLOAT;
1518: else if (t1 == FLOAT || t2 == FLOAT) t = DOUBLE;
1519: else if( t1==LONG || t2==LONG ) t = LONG;
1520: else if( t1==INT || t2==INT ) t = INT;
1521: else if( t1==SHORT || t2==SHORT ) t = SHORT;
1522: else t = CHAR;
1523:
1524: if( o == ASSIGN || o == CAST || o == RETURN )
1525: {
1526: tu = t1;
1527: if( o == RETURN )
1528: {
1529: if( tu==FLOAT ) tu = DOUBLE;
1530: else if( tu==CHAR || tu==SHORT ) tu = INT;
1531: }
1532: t = t1 = tu; /* t1 set to avoid lhs conversion */
1533: if( ISUNSIGNED(l->tn.type) ) u=1;
1534: else u=0;
1535: t2 = r->tn.type; /* back to reality... */
1536: }
1537: /* pjw says this is the wrong test, as int -= unsigned should be int
1538: tu = (u && UNSIGNABLE(t))?ENUNSIGN(t):t; */
1539: if(u && UNSIGNABLE(t) && !asgbinop(o))
1540: tu = ENUNSIGN(t);
1541: else if(asgbinop(o)) {
1542: tu = (u & 1? ENUNSIGN(t1): t1);
1543: /* a bunch of cases for x op= float */
1544: if((t2 == DOUBLE || t2 == FLOAT) && t1 != FLOAT && t1 != DOUBLE)
1545: tu = t2;
1546: }
1547: else
1548: tu = t;
1549: if( tu != t1 ) p->in.left = makety( l, tu, 0, (int)tu );
1550: if( tu != t2 ) p->in.right = makety( r, tu, 0, (int)tu );
1551:
1552: if( !logop(o) ) /* the type of the node = type of the operation */
1553: {
1554: p->in.type = tu;
1555: p->fn.cdim = 0;
1556: p->fn.csiz = t;
1557: }
1558:
1559: if( asgop(o) && p->in.left->tn.op == CONV )
1560: {
1561: /* original, unconverted type */
1562: /* this will get rewritten to A = A op B, in most cases */
1563: /* if the op is an unsigned op, change the lhs to unsigned */
1564: l = p->in.left->in.left;
1565: tu = l->in.type;
1566: if( u && (UNSIGNABLE(tu)) ) tu = ENUNSIGN(tu);
1567: p->in.type = l->in.type = tu;
1568: p->fn.cdim = l->fn.cdim;
1569: p->fn.csiz = l->fn.csiz;
1570: }
1571:
1572: # ifndef NODBG
1573: if( tdebug )
1574: {
1575: printf( "tymatch(%o): %o '%s' %o => %o\n",p,t1,opst[o],t2,tu );
1576: eprint(p);
1577: }
1578: # endif
1579:
1580: return(p);
1581: }
1582:
1583: NODE *
1584: makety( p, t, d, s )
1585: register NODE *p;
1586: register TWORD t;
1587: register d,s;
1588: {
1589: /* make p into type t by inserting a conversion */
1590: register TWORD pt;
1591:
1592: pt = p->in.type;
1593:
1594: if( pt == ENUMTY && p->in.op == ICON )
1595: {
1596: econvert(p);
1597: pt = p->in.type;
1598: }
1599:
1600: if( ISARY(pt) || ISFTN(pt) )
1601: {
1602: p = pconvert( p );
1603: pt = p->in.type;
1604: }
1605:
1606: if( t == pt || (p->tn.op == FCON && p->tn.rval == NONAME))
1607: {
1608: rew:
1609: p->fn.type = t;
1610: p->fn.cdim = d;
1611: p->fn.csiz = s;
1612: return( p );
1613: }
1614:
1615: if( t & TMASK )
1616: {
1617: /* non-simple type */
1618: if( ISPTR(pt) && p->in.op != STASG /*pjw*/
1619: # ifdef TWOPTRS
1620: && TWOPTRS(t) == TWOPTRS(pt)
1621: # endif
1622: )
1623: {
1624: /* don't generate CONV: just rewrite type */
1625: goto rew;
1626: }
1627:
1628: return( block( CONV, p, NIL, t, d, s ) );
1629: }
1630:
1631: if( p->in.op == ICON && p->tn.rval==NONAME )
1632: {
1633: if( t==DOUBLE||t==FLOAT )
1634: {
1635: p->in.op = FCON;
1636: if( ISUNSIGNED(pt) )
1637: {
1638: p->fpn.dval = /* (unsigned CONSZ) */ p->tn.lval;
1639: }
1640: else
1641: {
1642: p->fpn.dval = p->tn.lval;
1643: }
1644: goto rew;
1645: }
1646: p->tn.lval = ccast( p->tn.lval, t );
1647: goto rew;
1648: }
1649:
1650: /* double op ((double) (float op float)) => */
1651: /* double op ((double) float op (double) float) */
1652: /* recursively */
1653: /* don't push a conversion down the lhs of an assign op */
1654:
1655: if (pt == FLOAT && t == DOUBLE && optype(p->in.op) == BITYPE &&
1656: !asgop(p->in.op) && p->in.op != CALL)
1657: {
1658: p->in.left = makety(p->in.left, t, d, s);
1659: p->in.right = makety(p->in.right, t, d, s);
1660: goto rew;
1661: }
1662: return( block( CONV, p, NIL, t, d, s ) );
1663: }
1664:
1665: NODE *
1666: block( o, l, r, t, d, s )
1667: NODE *l, *r; TWORD t;
1668: {
1669:
1670: register NODE *p;
1671:
1672: p = talloc();
1673: p->in.op = o;
1674: p->in.left = l;
1675: p->in.right = r;
1676: p->in.type = t;
1677: p->ln.lineno = 0;
1678: p->fn.cdim = d;
1679: p->fn.csiz = s;
1680:
1681: /* for really heavy debugging
1682: printf( "block( %s, %d, %d, 0%o, %d, %d ) yields %d\n",
1683: opst[o], l-node, r-node, t, d, s, p-node );
1684: */
1685:
1686: return(p);
1687: }
1688:
1689: icons(p)
1690: register NODE *p;
1691: {
1692: /* if p is an integer constant, return its value */
1693: register val;
1694:
1695: if( p->in.op != ICON )
1696: {
1697: uerror( "integer constant expected");
1698: val = 1;
1699: }
1700: else
1701: {
1702: val = p->tn.lval;
1703: if( val != p->tn.lval )
1704: uerror( "constant too big for cross-compiler" );
1705: }
1706: tfree( p );
1707: return(val);
1708: }
1709:
1710: /* the intent of this table is to examine the
1711: ** operators, and to check them for
1712: ** correctness.
1713: **
1714: ** The table is searched for the op and the
1715: ** modified type (where this is one of the
1716: ** types INT (includes char and short), LONG,
1717: ** DOUBLE (includes FLOAT), and POINTER
1718: **
1719: ** The default action is to make the node type integer
1720: **
1721: ** The actions taken include:
1722: ** PUN check for puns
1723: ** CVTL convert the left operand
1724: ** CVTR convert the right operand
1725: ** TYPL the type is determined by the left operand
1726: ** TYPR the type is determined by the right operand
1727: ** TYMATCH force type of left and right to match, by inserting conversions
1728: ** PTMATCH like TYMATCH, but for pointers
1729: ** LVAL left operand must be lval
1730: ** CVTO convert the op
1731: ** NCVT do not convert the operands
1732: ** OTHER handled by code
1733: ** NCVTR convert the left operand, not the right...
1734: **
1735: */
1736:
1737: # define MINT 01 /* integer */
1738: # define MDBI 02 /* integer or double */
1739: # define MSTR 04 /* structure */
1740: # define MPTR 010 /* pointer */
1741: # define MPTI 020 /* pointer or integer */
1742: # define MENU 040 /* enumeration variable or member */
1743:
1744: opact( p )
1745: register NODE *p;
1746: {
1747: register mt12, mt1, mt2, o;
1748:
1749: mt12 = 0;
1750:
1751: switch( optype(o=p->in.op) )
1752: {
1753:
1754: case BITYPE:
1755: mt12=mt2 = moditype( p->in.right->in.type );
1756: case UTYPE:
1757: mt12 &= (mt1 = moditype( p->in.left->in.type ));
1758:
1759: }
1760:
1761: switch( o )
1762: {
1763:
1764: case NAME :
1765: case STRING :
1766: case ICON :
1767: case FCON :
1768: case CALL :
1769: case UNARY CALL:
1770: case STAR:
1771: {
1772: return( OTHER );
1773: }
1774: case UNARY MINUS:
1775: if( mt1 & MDBI ) return( TYPL );
1776: break;
1777:
1778: case COMPL:
1779: if( mt1 & MINT ) return( TYPL );
1780: break;
1781:
1782: case UNARY AND:
1783: {
1784: return( NCVT+OTHER );
1785: }
1786: case INIT:
1787: case CM:
1788: return( 0 );
1789: case NOT:
1790: case CBRANCH:
1791: case ANDAND:
1792: case OROR:
1793: return( NCVT );
1794:
1795: case MUL:
1796: case DIV:
1797: if( mt12 & MDBI ) return( TYMATCH );
1798: break;
1799:
1800: case MOD:
1801: case AND:
1802: case OR:
1803: case ER:
1804: case LS:
1805: case RS:
1806: if( mt12 & MINT ) return( TYMATCH );
1807: break;
1808:
1809: case EQ:
1810: case NE:
1811: case LT:
1812: case LE:
1813: case GT:
1814: case GE:
1815: if( (mt1&MENU)||(mt2&MENU) ) return( PTMATCH+PUN );
1816: if( mt12 & MDBI ) return( TYMATCH+CVTO );
1817: else if( mt12 & MPTR ) return( PTMATCH+PUN+CVTO );
1818: else if( mt12 & MPTI ) return( PTMATCH+PUN+CVTO );
1819: else break;
1820:
1821: case QUEST:
1822: case COMOP:
1823: return( TYPR+NCVTR );
1824:
1825: case STREF:
1826: return( NCVTR+OTHER );
1827:
1828: case COLON:
1829: if( mt12 & MENU ) return( NCVT+PUN+PTMATCH );
1830: else if( mt12 & MDBI ) return( TYMATCH );
1831: else if( mt12 & MPTR ) return( TYPL+PTMATCH+PUN );
1832: else if( (mt1&MINT) && (mt2&MPTR) ) return( TYPR+PUN );
1833: else if( (mt1&MPTR) && (mt2&MINT) ) return( TYPL+PUN );
1834: else if( mt12 & MSTR ) return( NCVT+TYPL+OTHER );
1835: break;
1836:
1837: case ASSIGN:
1838: case RETURN:
1839: if( mt12 & MSTR ) return( LVAL+NCVT+TYPL+OTHER );
1840: case CAST:
1841: if(o==CAST && mt1==0)return(TYPL+TYMATCH);
1842: if( mt12 & MDBI ) return( TYPL+LVAL+TYMATCH );
1843: else if( (mt1&MENU)||(mt2&MENU) )
1844: {
1845: return( LVAL+NCVT+TYPL+PTMATCH+PUN );
1846: }
1847: else if( mt12 == 0 ) break;
1848: else if( mt1 & MPTR ) return( LVAL+PTMATCH+PUN );
1849: else if( mt12 & MPTI ) return( TYPL+LVAL+TYMATCH+PUN );
1850: if(mt12 & MSTR) {
1851: uerror("no structure casts");
1852: return(NCVT);
1853: }
1854: break;
1855:
1856: case ASG MUL:
1857: case ASG DIV:
1858: if( mt12 & MDBI ) return( LVAL+TYMATCH );
1859: break;
1860:
1861: case ASG MOD:
1862: case ASG AND:
1863: case ASG OR:
1864: case ASG ER:
1865: case ASG LS:
1866: case ASG RS:
1867: if( mt12 & MINT ) return( LVAL+TYMATCH );
1868: break;
1869:
1870: case ASG PLUS:
1871: case ASG MINUS:
1872: case INCR:
1873: case DECR:
1874: if( mt12 & MDBI ) return( TYMATCH+LVAL );
1875: else if( (mt1&MPTR) && (mt2&MINT) ) return( TYPL+LVAL+CVTR );
1876: break;
1877:
1878: case MINUS:
1879: if( mt12 & MPTR ) return( CVTO+PTMATCH+PUN );
1880: if( mt2 & MPTR ) break;
1881: case PLUS:
1882: if( mt12 & MDBI ) return( TYMATCH );
1883: else if( (mt1&MPTR) && (mt2&MINT) ) return( TYPL+CVTR );
1884: else if( (mt1&MINT) && (mt2&MPTR) ) return( TYPR+CVTL );
1885: else break;
1886: /* special operators */
1887: case UOP0:
1888: case UOP1:
1889: case UOP2:
1890: case UOP3:
1891: case UOP4:
1892: case UOP5:
1893: case UOP6:
1894: case UOP7:
1895: case UOP8:
1896: case UOP9:
1897: return( TYPL );
1898: }
1899: uerror( "operands of %s have incompatible types", opst[o] );
1900: return( NCVT );
1901: }
1902:
1903: moditype( ty )
1904: register TWORD ty;
1905: {
1906:
1907: switch( ty )
1908: {
1909:
1910: case UNDEF:
1911: case VOID:
1912: return(0); /* type is void */
1913: case ENUMTY:
1914: case MOETY:
1915: /* pjw says enum is int return( MENU ); */
1916: return(MINT|MDBI|MPTI);
1917: case STRTY:
1918: case UNIONTY:
1919: return( MSTR );
1920:
1921: case CHAR:
1922: case SHORT:
1923: case UCHAR:
1924: case USHORT:
1925: return( MINT|MPTI|MDBI );
1926:
1927: case UNSIGNED:
1928: case ULONG:
1929: case INT:
1930: case LONG:
1931: return( MINT|MDBI|MPTI );
1932:
1933: case FLOAT:
1934: case DOUBLE:
1935: return( MDBI );
1936:
1937: default:
1938: return( MPTR|MPTI );
1939: }
1940: }
1941:
1942: # ifndef MYCCAST
1943: CONSZ
1944: ccast( v, t )
1945: register CONSZ v;
1946: register TWORD t;
1947: {
1948: /* cast value v into simple type t */
1949: /* must be done as it would be on the target machine */
1950:
1951: switch( t )
1952: {
1953:
1954: case CHAR:
1955: # ifdef CHSIGN
1956: if( v&ONEBIT(SZCHAR-1) )
1957: {
1958: return( v | ~BITMASK(SZCHAR) );
1959: }
1960: # endif
1961: case UCHAR:
1962: return( v & BITMASK(SZCHAR) );
1963:
1964: case SHORT:
1965: if( v&ONEBIT(SZSHORT-1) )
1966: {
1967: return( v | ~BITMASK(SZSHORT) );
1968: }
1969: case USHORT:
1970: return( v & BITMASK(SZSHORT) );
1971:
1972: case INT:
1973: if( v&ONEBIT(SZINT-1) )
1974: {
1975: return( v | ~BITMASK(SZINT) );
1976: }
1977: case UNSIGNED:
1978: return( v & BITMASK(SZINT) );
1979:
1980: default:
1981: return( v );
1982: }
1983: }
1984: # endif
1985:
1986:
1987: NODE *
1988: doszof( p )
1989: register NODE *p;
1990: {
1991: /* do sizeof p */
1992: register i;
1993:
1994: /* whatever is the meaning of this if it is a bitfield? */
1995: i = tsize( p->in.type, p->fn.cdim, p->fn.csiz )/SZCHAR;
1996:
1997: tfree(p);
1998: if( i <= 0 ) werror( "sizeof returns 0" );
1999: p = bcon(i);
2000: p->tn.type = UNSIGNED; /* damn dmr anyhow! */
2001: return( p );
2002: }
2003:
2004: # ifndef NODBG
2005: eprint(p)
2006: NODE *p;
2007: {
2008: printf("\n++++++++\n");
2009: e1print(p,"T");
2010: printf("---------\n");
2011: }
2012: e1print( p ,s)
2013: register NODE *p;
2014: char *s;
2015: {
2016: register ty, d;
2017: static down = 0;
2018:
2019: ty = optype( p->tn.op );
2020:
2021: if( ty == BITYPE )
2022: {
2023: ++down;
2024: e1print( p->in.right ,"R");
2025: --down;
2026: }
2027:
2028: for( d=down; d>1; d -= 2 ) printf( "\t" );
2029: if( d ) printf( " " );
2030:
2031: printf("%s=%d) %s, ", s, (int) (p-node), opst[p->in.op] );
2032: if( ty == LTYPE )
2033: {
2034: printf( "lval=%ld", p->tn.lval );
2035: printf( ", rval=%d, ", p->tn.rval );
2036: }
2037: printf("type=");
2038: tprint( p->in.type );
2039: printf( ", dim=%d, siz=%d\n", p->fn.cdim, p->fn.csiz );
2040: if( ty != LTYPE )
2041: {
2042: ++down;
2043: e1print( p->in.left ,"L");
2044: --down;
2045: }
2046: }
2047:
2048: tprint( t )
2049: register TWORD t;
2050: {
2051: /* output a nice description of the type of t */
2052: static char * tnames[] =
2053: {
2054: "undef",
2055: "farg",
2056: "char",
2057: "short",
2058: "int",
2059: "long",
2060: "float",
2061: "double",
2062: "strty",
2063: "unionty",
2064: "enumty",
2065: "moety",
2066: "uchar",
2067: "ushort",
2068: "unsigned",
2069: "ulong",
2070: "?", "?"
2071: };
2072:
2073: for(;; t = DECREF(t) )
2074: {
2075: if( ISPTR(t) ) printf( "PTR " );
2076: else if( ISFTN(t) ) printf( "FTN " );
2077: else if( ISARY(t) ) printf( "ARY " );
2078: else
2079: {
2080: printf( "%s", tnames[t] );
2081: return;
2082: }
2083: }
2084: }
2085: # endif
2086:
2087: # ifndef MYLOCCTR
2088: locctr(l)
2089: register l;
2090: {
2091: register temp, lt;
2092: /* look in locnames; print out the location counter name */
2093: /* null means use the next; all null, don't print */
2094: for( lt=l; lt<=STRNG && !locnames[lt]; ++lt )
2095: {
2096: /* EMPTY */
2097: }
2098: if( lt == curloc ) return( lt );
2099: temp = curloc;
2100: if( lt > STRNG ) lt = l;
2101: else printx( locnames[lt] );
2102: curloc = lt;
2103: return( temp );
2104: }
2105: # endif
2106:
2107: # ifndef NOFLOAT
2108:
2109: prtdcon( p )
2110: register NODE *p;
2111: {
2112: register i;
2113: register TWORD t;
2114:
2115: if( p->in.op == FCON )
2116: {
2117: locctr( DATA );
2118: t = p->tn.type;
2119: defalign( t==DOUBLE?ALDOUBLE:ALFLOAT );
2120: deflab( i = getlab() );
2121: fincode( p->fpn.dval, t==DOUBLE?SZDOUBLE:SZFLOAT );
2122: p->tn.lval = 0;
2123: p->tn.rval = -i;
2124: p->in.op = NAME;
2125: }
2126: if( (i = optype(p->in.op)) == BITYPE ) prtdcon( p->in.right );
2127: if( i != LTYPE ) prtdcon( p->in.left );
2128: }
2129: # endif
2130:
2131: # ifndef MYLABELS
2132: getlab()
2133: {
2134: static crslab = 10;
2135: return( ++crslab );
2136: }
2137: # endif
2138:
2139: int edebug = 0;
2140: ecomp( p )
2141: register NODE *p;
2142: {
2143: slineno = p->ln.lineno;
2144: # ifndef NODBG
2145: if( edebug ) eprint(p);
2146: # endif
2147: if( !reached )
2148: {
2149: werror( "statement not reached" );
2150: reached = 1;
2151: }
2152: # ifdef CLOCAL
2153: p = clocal(p);
2154: # endif
2155: p = optim(p);
2156: # ifndef NOFLOAT
2157: prtdcon(p);
2158: # endif
2159: locctr( PROG );
2160: ecode(p);
2161: tfree(p);
2162: }
2163:
2164: # ifndef MYECODE
2165: ecode( p )
2166: register NODE *p;
2167: {
2168: /* standard version of writing the tree nodes */
2169: if( nerrors ) return;
2170: # ifdef GDEBUG
2171: dbline();
2172: # endif
2173: p2tree( p );
2174: p2compile( p );
2175: }
2176: # endif
2177:
2178: # ifndef MYPRTREE
2179:
2180: # ifndef RNODNAME
2181: # define RNODNAME LABFMT
2182: # endif
2183:
2184: p2tree(p)
2185: register NODE *p;
2186: {
2187: register ty;
2188: register NODE *l;
2189: register o;
2190: char temp[32]; /* place to dump label stuff */
2191:
2192: # ifdef MYP2TREE
2193: MYP2TREE(p); /* local action can be taken here; then return... */
2194: # endif
2195:
2196: /* this routine sits painfully between pass1 and pass2 */
2197: ty = optype(o=p->in.op);
2198: p->tn.goal = 0; /* an illegal goal, just to clear it out */
2199: p->tn.type = ttype( p->tn.type ); /* type gets second-pass (bits) */
2200:
2201: switch( o )
2202: {
2203:
2204: case TEMP:
2205: case NAME:
2206: case ICON:
2207: case VAUTO:
2208: case VPARAM:
2209: if( p->tn.rval == NONAME )
2210: p->in.name = (char *) 0;
2211: else if( p->tn.rval >= 0 )
2212: {
2213: /* copy name from exname */
2214: register char *cp;
2215: cp = exname( stab[p->tn.rval].sname );
2216: p->in.name = tstr( cp );
2217: }
2218: else if( p->tn.rval == - strftn )
2219: {
2220: sprintf( temp, RNODNAME, -p->tn.rval );
2221: p->in.name = tstr( temp );
2222: }
2223: else
2224: {
2225: sprintf( temp, LABFMT, -p->tn.rval );
2226: p->in.name = tstr( temp );
2227: }
2228: break;
2229:
2230: case STARG:
2231: case STASG:
2232: case STCALL:
2233: case UNARY STCALL:
2234: /* set up size parameters */
2235: l = p->in.left;
2236: p->stn.stsize = tsize(STRTY,l->fn.cdim,l->fn.csiz);
2237: p->stn.stalign = talign(STRTY,l->fn.csiz);
2238: break;
2239:
2240: /* this should do something only if temporary regs are
2241: /* built into the tree by machine-dependent actions */
2242: case REG:
2243: rbusy( p->tn.rval, p->in.type );
2244: default:
2245: p->in.name = (char *) 0;
2246: }
2247:
2248: if( ty != LTYPE ) p2tree( p->in.left );
2249: if( ty == BITYPE ) p2tree( p->in.right );
2250: }
2251:
2252: # endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.