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