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