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