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