![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to expr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / c / n0|
Return to expr.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / c / n0 |
1.1 ! root 1: /* ! 2: * n0/expr.c ! 3: * C compiler. ! 4: * Expressions et al. ! 5: */ ! 6: ! 7: #ifdef vax ! 8: #include "INC$LIB:cc0.h" ! 9: #else ! 10: #include "cc0.h" ! 11: #endif ! 12: ! 13: #define LOW 0 ! 14: #define HIGH 0177 ! 15: #define INARGS 0200 ! 16: ! 17: #define bcvint(p) bconvert((p), T_INT, NULL, NULL, NULL) ! 18: #define isfloat(t) ((t)==T_FLOAT || (t)==T_DOUBLE) ! 19: #define isshift(op) ((op)==ASHL || (op)==ASHR || (op)==SHL || (op)==SHR) ! 20: #define issgnint(t) ((t)== T_CHAR || (t)== T_SHORT || (t)== T_INT || (t)== T_LONG) ! 21: #define isunsint(t) ((t)==T_UCHAR || (t)==T_USHORT || (t)==T_UINT || (t)==T_ULONG) ! 22: ! 23: static char tclash[] = "type clash"; ! 24: ! 25: /* ! 26: * Read a tree. ! 27: * This is the top level routine that is called by the user. ! 28: * The mysterious call to "build" with opcode "NOP" is to get any function or ! 29: * array name conversions applied, even if the top of the tree is a term. ! 30: * Ditto for getting types converted to computables. ! 31: */ ! 32: TREE * ! 33: expr() ! 34: { ! 35: if (notvariant(VCPP)) { ! 36: bput(LINE); ! 37: iput((ival_t) line); ! 38: } ! 39: return build(NOP, tree(LOW), NULL); ! 40: } ! 41: ! 42: /* ! 43: * Read in a tree. ! 44: * The "n" argument is a firewall precedence. ! 45: * You continue reading until the precedence of the operator ! 46: * in the input is less than the priority "n". ! 47: * The "INARGS" flag is or'ed into the priority to indicate ! 48: * that the expression is an argument list, and that "," is special. ! 49: * Passing it in this unconventional way lets you pass a single ! 50: * parameter to "tree". ! 51: */ ! 52: TREE * ! 53: tree(n) ! 54: { ! 55: register TREE *lp, *rp; ! 56: register SYM *sp; ! 57: DIM *dp; ! 58: TREE *tp, *fp; ! 59: int c, d, op, p, isarray, isinargs; ! 60: ! 61: isinargs = 0; ! 62: if ((n&INARGS) != 0) { ! 63: ++isinargs; ! 64: n &= ~INARGS; ! 65: } ! 66: lp = term(); ! 67: for (;;) { ! 68: switch (s) { ! 69: ! 70: case LPAREN: ! 71: lex(); ! 72: rp = NULL; ! 73: if (s != RPAREN) ! 74: rp = tree(LOW|INARGS); ! 75: mustbe(RPAREN); ! 76: lp = build(CALL, lp, rp); ! 77: break; ! 78: ! 79: case LBRACK: ! 80: lex(); ! 81: lp = build(ADD, lp, tree(LOW)); ! 82: adjust(lp, lp->t_type, lp->t_dp, lp->t_ip); ! 83: lp = build(STAR, lp, NULL); ! 84: mustbe(RBRACK); ! 85: break; ! 86: ! 87: case DOT: ! 88: case ARROW: ! 89: lp = build((s==DOT?ADDR:NOP), lp, NULL); ! 90: if (lex() != ID) { ! 91: cerror("missing member"); ! 92: break; ! 93: } ! 94: sp = moslookup(lp); ! 95: if (bitcompat(T_PTR, tltype(lp)) == 0) ! 96: cerror("left side of \"%s\" not usable", ! 97: s==DOT?".":"->"); ! 98: if (sp==NULL || ((c=sp->s_class)!=C_MOS && c!=C_MOU)) { ! 99: cerror("member \"%s\" is not defined", id); ! 100: sp = fakedef(SL_MOS); ! 101: } else if (isvariant(VSMEMB)) ! 102: csmemb(lp, sp); ! 103: lex(); ! 104: tp = talloc(); ! 105: tp->t_op = ADD; ! 106: tp->t_lp = lp; ! 107: tp->t_rp = bicon(sp->s_value); ! 108: lp = tp; ! 109: isarray = 0; ! 110: dp = sp->s_dp; ! 111: if (dp!=NULL && dp->d_type==D_ARRAY) { ! 112: ++isarray; ! 113: dp = tdalloc(dp->d_dp, D_MOSAR, dp->d_bound); ! 114: } else ! 115: dp = tdalloc(dp, D_PTR, (sizeof_t)0); ! 116: adjust(lp, sp->s_type, dp, sp->s_ip); ! 117: if (!isarray) ! 118: lp = build(STAR, lp, NULL); ! 119: if (sp->s_width != 0) { ! 120: fp = talloc(); ! 121: fp->t_op = FIELD; ! 122: fp->t_type = lp->t_type; ! 123: fp->t_lp = lp; ! 124: fp->t_width = sp->s_width; ! 125: fp->t_base = sp->s_offset; ! 126: lp = fp; ! 127: } ! 128: break; ! 129: ! 130: case INCBEF: ! 131: case DECBEF: ! 132: op = s+INCAFT-INCBEF; ! 133: lex(); ! 134: lp = build(op, lp, bicon((ival_t)1)); ! 135: break; ! 136: ! 137: default: ! 138: if ((s==COMMA && ininit!=0 && isinargs==0) ! 139: || (s==COLON)) ! 140: goto out; ! 141: if (s<MIOBASE || s>=MDOBASE) ! 142: goto out; ! 143: d = opdope[s-MIOBASE]; ! 144: if ((p=(d&PRIO)) == 0) ! 145: goto out; ! 146: if (p<n || ((d&RAS)==0 && p==n)) ! 147: goto out; ! 148: if ((op = s) == QUEST) { ! 149: lex(); ! 150: rp = tree(LOW); ! 151: mustbe(COLON); ! 152: rp = build(COLON, rp, tree(--p)); ! 153: lp = build(QUEST, lp, rp); ! 154: break; ! 155: } ! 156: if (op==COMMA && isinargs!=0) ! 157: op = ARGLST; ! 158: lex(); ! 159: lp = build(op, lp, tree(p)); ! 160: } ! 161: } ! 162: out: ! 163: return lp; ! 164: } ! 165: ! 166: /* ! 167: * Check that a structure member is ! 168: * indeed a member of the left hand structure. ! 169: * If the member is untagged, don't object to any clash. ! 170: * The structure declaration reader sets the S_TAG bit ! 171: * in the flags word of all tagged structures. ! 172: */ ! 173: csmemb(lp, sp) ! 174: TREE *lp; ! 175: SYM *sp; ! 176: { ! 177: register INFO *ip; ! 178: register SYM *tsp; ! 179: register int type; ! 180: char *msg; ! 181: int i; ! 182: ! 183: type = lp->t_type; ! 184: if (lp->t_dp==NULL || lp->t_dp->d_type!=D_PTR ! 185: || type<T_STRUCT || type>T_FUNION) { ! 186: cstrict("potentially nonportable structure access"); ! 187: return; ! 188: } ! 189: if ((type==T_STRUCT || type==T_UNION) && (sp->s_flag&S_TAG)!=0) { ! 190: ip = lp->t_ip; ! 191: if (ip != NULL) { ! 192: for (i=0; i<ip->i_nsp && ip->i_sp[i]!=sp; ++i) ! 193: ; ! 194: if (i >= ip->i_nsp) { ! 195: tsp = taglookup(ip); ! 196: if (tsp != NULL) { ! 197: msg = (tsp->s_class == C_UTAG) ? "union" : "structure"; ! 198: if (tsp->s_id[0] != '.') ! 199: cstrict("%s \"%s\" does not contain member \"%s\"", ! 200: msg, tsp->s_id, sp->s_id); ! 201: else ! 202: cstrict("%s does not contain member \"%s\"", ! 203: msg, sp->s_id); ! 204: } ! 205: } ! 206: } ! 207: } ! 208: } ! 209: ! 210: /* ! 211: * Read a term. ! 212: * Handle all of the leaf nodes and the unary operations here. ! 213: */ ! 214: TREE * ! 215: term() ! 216: { ! 217: register TREE *tp; ! 218: register SYM *sp; ! 219: register int op; ! 220: TREE *cp; ! 221: DIM *dp; ! 222: int tt, lt, n; ! 223: ! 224: switch (op = s) { ! 225: ! 226: case ICON: ! 227: tp = bicon(ival); ! 228: tp->t_type = tval; ! 229: lex(); ! 230: break; ! 231: ! 232: case LCON: ! 233: tp = talloc(); ! 234: tp->t_op = LCON; ! 235: tp->t_type = tval; ! 236: tp->t_lval = lval; ! 237: lex(); ! 238: break; ! 239: ! 240: case DCON: ! 241: tp = talloc(); ! 242: tp->t_op = DCON; ! 243: tp->t_type = tval; ! 244: memcpy((char *)tp->t_dval, (char *)dval, sizeof(dval_t)); ! 245: lex(); ! 246: break; ! 247: ! 248: case STRING: ! 249: tp = bstring(); ! 250: break; ! 251: ! 252: case ID: ! 253: if ((sp=reflookup(SL_VAR)) == NULL) { ! 254: /* ! 255: * An undefined name followed by a "(" is declared ! 256: * to be a function that returns an integer. ! 257: * So says the manual. ! 258: */ ! 259: TOK *tp; ! 260: tp = idp; ! 261: if (spnextis('(')) { ! 262: setid(tp->t_id); ! 263: sp = deflookup(SL_VAR, 0); ! 264: dp = tackdim(NULL, D_FUNC, 0); ! 265: sp = declare(sp, C_CXT, T_INT, dp, NULL, 0); ! 266: } else ! 267: setid(tp->t_id); ! 268: if (sp == NULL) { ! 269: cerror("identifier \"%s\" is not defined", id); ! 270: sp = fakedef(SL_VAR); ! 271: } ! 272: } ! 273: tp = bid(sp); ! 274: lex(); ! 275: break; ! 276: ! 277: case LPAREN: ! 278: lex(); ! 279: if ((cp=cast()) != NULL) { ! 280: if (cp->t_type==T_FLOAT && cp->t_dp==NULL) ! 281: cp->t_type = T_DOUBLE; ! 282: cp->t_lp = build(NOP, tree(HIGH), NULL); ! 283: tt = tltype(cp); ! 284: lt = tltype(cp->t_lp); ! 285: if (tt == T_STRUCT) ! 286: cerror("cannot cast to structure or union"); ! 287: if (lt == T_STRUCT) ! 288: cerror("cannot cast structure or union"); ! 289: if (tt == T_PTR && isfloat(lt)) ! 290: cerror("cannot cast double to pointer"); ! 291: if (isfloat(tt) && lt == T_PTR) ! 292: cerror("cannot cast pointer to double"); ! 293: if (bitcompat(tt, lt)) { ! 294: tp = cp->t_lp; ! 295: adjust(tp, cp->t_type, cp->t_dp, cp->t_ip); ! 296: if (tp->t_op == CONVERT && tp->t_rp == NULL) ! 297: tp->t_op = CAST; ! 298: } else ! 299: tp = cp; ! 300: break; ! 301: } ! 302: n = ininit; ! 303: ininit = 0; ! 304: tp = tree(LOW); ! 305: ininit = n; ! 306: mustbe(RPAREN); ! 307: break; ! 308: ! 309: case SIZEOF: ! 310: lex(); ! 311: if (s == LPAREN) { ! 312: lex(); ! 313: if ((tp=cast()) == NULL) { ! 314: tp = tree(LOW); ! 315: mustbe(RPAREN); ! 316: } ! 317: } else ! 318: tp = tree(HIGH); ! 319: tp = build(SIZEOF, tp, NULL); ! 320: break; ! 321: ! 322: case NOT: ! 323: lex(); ! 324: tp = build(EQ, tree(HIGH), bicon((ival_t)0)); ! 325: break; ! 326: ! 327: case SUB: ! 328: op = NEG; ! 329: goto unary; ! 330: case ADD: /* Unary plus == no rearrangement FIX.ME */ ! 331: lex(); ! 332: tp = tree(HIGH); /* ignored for present */ ! 333: break; ! 334: op = POS; ! 335: goto unary; ! 336: case MUL: ! 337: op = STAR; ! 338: goto unary; ! 339: case AND: ! 340: op = ADDR; ! 341: goto unary; ! 342: case COM: ! 343: unary: ! 344: lex(); ! 345: tp = build(op, tree(HIGH), NULL); ! 346: break; ! 347: ! 348: case INCBEF: ! 349: case DECBEF: ! 350: lex(); ! 351: tp = build(op, tree(HIGH), bicon((ival_t)1)); ! 352: break; ! 353: ! 354: default: ! 355: cerror("error in expression syntax"); ! 356: while (s!=EOF && s!=SEMI && s!=LBRACE && s!=RBRACE) ! 357: skip(); ! 358: return bicon((ival_t)0); ! 359: } ! 360: return tp; ! 361: } ! 362: ! 363: /* ! 364: * Given an operator "op" and left and right subtrees "lp" and "rp", ! 365: * build a tree node, folding any constant expressions ! 366: * that can be folded, supplying any required type conversions. ! 367: * All of the conversions that are possible are added; ! 368: * the routine "transform" may remove some of them. ! 369: */ ! 370: TREE * ! 371: build(op, lp, rp) int op; TREE *lp; TREE *rp; ! 372: { ! 373: TREE *tp, *gtp, gt; ! 374: DIM *dp; ! 375: int rt, lt, d, cv; ! 376: sizeof_t ll, lr; ! 377: ! 378: if (op == SIZEOF) ! 379: return bzcon(tsize(lp)); ! 380: rt = T_NONE; ! 381: if (rp != NULL) { ! 382: chmos(rp); ! 383: rp = chfun(charray(rp)); ! 384: rt = tltype(rp); ! 385: } ! 386: chmos(lp); ! 387: lp = charray(lp); ! 388: if (op!=ADDR && op!=CALL) ! 389: lp = chfun(lp); ! 390: lt = tltype(lp); ! 391: if (op == NOP) ! 392: goto conversion; ! 393: /* ! 394: * Make sure that the operands are ! 395: * suitable as operands of the specified operation. ! 396: * Look mainly at the type, although some consideration ! 397: * is made of storage class. ! 398: */ ! 399: if (lt==T_VOID || rt==T_VOID) { ! 400: if ((op!=COMMA && op!=QUEST && op!=COLON) ! 401: || (op==COLON && lt!=rt) ! 402: || (op==QUEST && lt==T_VOID)) { ! 403: cerror("illegal operation on \"void\" type"); ! 404: lt = T_INT; ! 405: rt = T_INT; ! 406: } ! 407: } ! 408: if (op==ADDR && lp->t_op==REG) ! 409: cerror("cannot apply unary '&' to a register variable"); ! 410: if (op==ADDR && lp->t_op==FIELD) ! 411: cerror("cannot apply unary '&' to a bit field"); ! 412: if (op==ADDR && lp->t_op==GID && lp->t_seg==SALIEN) ! 413: cerror("cannot apply unary '&' to an alien function"); ! 414: d = opdope[op-MIOBASE]; ! 415: if ((d&RLVL) != 0 ! 416: && (lp->t_op<=DCON ! 417: || (lp->t_op>=MIOBASE && lp->t_op!=STAR && lp->t_op!=FIELD ! 418: && (lp->t_op!=CALL || lp->t_type!=T_STRUCT || lp->t_dp!=NULL) ! 419: ))) ! 420: cerror("lvalue required"); ! 421: if ((d&NFLT)!=0 && (isfloat(lt) || isfloat(rt))) ! 422: cerror("illegal use of floating point"); ! 423: if (((d&NPTL)!=0 && lt==T_PTR) || ((d&NPTR)!=0 && rt==T_PTR)) ! 424: cerror("illegal use of a pointer"); ! 425: if (((d&NSTL)!=0 && lt==T_STRUCT) || ((d&NSTR)!=0 && rt==T_STRUCT)) ! 426: cerror("illegal use of a structure or union"); ! 427: if ((d&RTOL) != 0) ! 428: truth(lp); ! 429: if ((d&RTOR) != 0) ! 430: truth(rp); ! 431: /* ! 432: * The operation may just fold away to nothing. ! 433: * If so, return a pointer to the new, constant tree node. ! 434: */ ! 435: if ((tp=fold0(op, lp, rp)) != NULL) ! 436: return tp; ! 437: /* ! 438: * Insert conversion nodes. ! 439: */ ! 440: conversion: ! 441: gt.t_op = CONVERT; ! 442: gt.t_dp = NULL; ! 443: gt.t_ip = NULL; ! 444: switch (op) { ! 445: ! 446: case QUEST: ! 447: if (rp->t_op != COLON) ! 448: cerror("mismatched conditional"); ! 449: /* Make sure the condition type 'lt' is computational. */ ! 450: gt.t_type = (cvdope[13 * (lt - T_CHAR) + lt - T_CHAR] & GOAL); ! 451: gt.t_dp = lp->t_dp; ! 452: gt.t_ip = lp->t_ip; ! 453: if (bitcompat(tltype(>), lt) == 0) ! 454: lp = bcvt(lp, >); ! 455: /* then fall through... */ ! 456: ! 457: case COMMA: ! 458: case ARGLST: ! 459: gt.t_type = rp->t_type; ! 460: gt.t_dp = rp->t_dp; ! 461: gt.t_ip = rp->t_ip; ! 462: break; ! 463: ! 464: case ANDAND: ! 465: case OROR: ! 466: case NOT: ! 467: gt.t_type = T_INT; ! 468: break; ! 469: ! 470: case CALL: ! 471: if ((dp = lp->t_dp)!=NULL && dp->d_type==D_FUNC) ! 472: gt.t_dp = dp->d_dp; ! 473: else if ((dp = lp->t_dp)!=NULL ! 474: && dp->d_type==D_PTR ! 475: && dp->d_dp->d_type==D_FUNC) { ! 476: cwarn("implicit '*' added to function call"); ! 477: lp = build(STAR, lp, NULL); ! 478: gt.t_dp = dp->d_dp->d_dp; ! 479: } else ! 480: cerror("call of non function"); ! 481: if (rp != NULL && rp->t_op != ARGLST) { ! 482: rp = build(NOP, rp, NULL); ! 483: rt = tltype(rp); ! 484: } ! 485: gt.t_type = lp->t_type; ! 486: gt.t_ip = lp->t_ip; ! 487: break; ! 488: ! 489: case STAR: ! 490: if ((dp = lp->t_dp)!=NULL && dp->d_type==D_PTR) ! 491: gt.t_dp = dp->d_dp; ! 492: else ! 493: cerror("indirection through non pointer"); ! 494: gt.t_type = lp->t_type; ! 495: gt.t_ip = lp->t_ip; ! 496: break; ! 497: ! 498: case ADDR: ! 499: gt.t_type = lp->t_type; ! 500: gt.t_dp = tdalloc(lp->t_dp, D_PTR, (sizeof_t)0); ! 501: gt.t_ip = lp->t_ip; ! 502: break; ! 503: ! 504: default: ! 505: if (rt == T_NONE) ! 506: rt = lt; ! 507: if (isshift(op)) { ! 508: /* ! 509: * Shift ops: convert right op to T_INT, ! 510: * read dope table accordingly. ! 511: */ ! 512: if (bitcompat(T_INT, rt) == 0) ! 513: rp = bcvint(rp); ! 514: rt = T_INT; ! 515: } ! 516: cv = cvdope[13*(lt-T_CHAR) + rt - T_CHAR]; ! 517: if (noconvert(op, lt, rt)) ! 518: cv &= ~(CVL|CVR|CVRA|CARA); ! 519: else if (isshift(op)) ! 520: cv &= ~(CVR|CVRA); ! 521: gt.t_type = cv&GOAL; ! 522: gt.t_rp = NULL; ! 523: if ((cv&(GTL|GTR)) != 0) { ! 524: gtp = ((cv>L)!=0) ? lp : rp; ! 525: gt.t_type = gtp->t_type; ! 526: gt.t_dp = gtp->t_dp; ! 527: gt.t_ip = gtp->t_ip; ! 528: if ((cv&(CVL|CVR|CVRA)) != 0) ! 529: gt.t_rp = bzcon(psize(gtp)); ! 530: } ! 531: if (gt.t_type == T_NONE && op!=NOP && lt!=T_VOID) ! 532: cerror(tclash); ! 533: if ((d&ASGN) != 0) { ! 534: gt.t_type = lp->t_type; ! 535: gt.t_dp = lp->t_dp; ! 536: gt.t_ip = lp->t_ip; ! 537: if (gt.t_dp == NULL) { ! 538: if (gt.t_type==T_CHAR ! 539: || gt.t_type==T_UCHAR ! 540: || gt.t_type==T_SHORT ! 541: || gt.t_type==T_ENUM ! 542: || gt.t_type==T_FENUM) ! 543: gt.t_type = T_INT; ! 544: if (gt.t_type == T_USHORT) ! 545: gt.t_type = T_UINT; ! 546: if (gt.t_type == T_FLOAT) ! 547: gt.t_type = T_DOUBLE; ! 548: } ! 549: /* ! 550: * The following ADIV and AREM type conversion code is somewhat bogus. ! 551: * The basic problem is that C requires "a op= b;" to give the same ! 552: * result as "a = a op b;". ! 553: * The code below makes sure that an unsigned right op remains unsigned, ! 554: * so the code tables can generate an unsigned op rather than a signed op. ! 555: * Actually, the problem is more general; "i *= 1.5;" should have the same ! 556: * effect as "i = (double)i * 1.5;" but it currently does "i *= (int) 1.5;". ! 557: * This code the most obvious inconsistencies, though. ! 558: */ ! 559: if ((cv&CVRA) != 0) { ! 560: if ((op == ADIV || op == AREM) ! 561: && issgnint(gt.t_type) && isunsint(rt)) { ! 562: gt.t_type = sgn2uns(gt.t_type); ! 563: rp = bcvt(rp, >); ! 564: gt.t_type = uns2sgn(gt.t_type); ! 565: } else ! 566: rp = bcvt(rp, >); ! 567: } else if ((cv&CARA) != 0) { ! 568: gt.t_op = CAST; ! 569: gt.t_rp = NULL; ! 570: rp = bcvt(rp, >); ! 571: } ! 572: } else { ! 573: if (op>=INCBEF && op<=DECAFT) ! 574: cv &= ~CVL; ! 575: if (op == COLON && lt != rt) { ! 576: if (lt == T_PTR) { ! 577: if (iszero(rp)) { ! 578: gt.t_op = CAST; ! 579: gt.t_rp = NULL; ! 580: } else ! 581: cerror(tclash); ! 582: } else if (rt == T_PTR) { ! 583: if (iszero(lp)) { ! 584: gt.t_op = CAST; ! 585: gt.t_rp = NULL; ! 586: } else ! 587: cerror(tclash); ! 588: } ! 589: } else if (op == COLON && lt==T_VOID && rt==T_VOID) ! 590: gt.t_type = T_VOID; ! 591: if ((cv&CVL) != 0) ! 592: lp = bcvt(lp, >); ! 593: if (op==SHL || op==SHR) { ! 594: gt.t_type = lp->t_type; ! 595: gt.t_dp = lp->t_dp; ! 596: gt.t_ip = lp->t_ip; ! 597: } else if (rp!=NULL && (cv&CVR)!=0) ! 598: rp = bcvt(rp, >); ! 599: if ((cv&UREL)!=0 && (op>=GT && op<=LT)) ! 600: op += UGT-GT; ! 601: if (op>=EQ && op<=ULT) { ! 602: gt.t_type = T_INT; ! 603: gt.t_dp = gt.t_ip = NULL; ! 604: } ! 605: } ! 606: } ! 607: if (op==NOP) ! 608: return lp; ! 609: tp = talloc(); ! 610: tp->t_op = op; ! 611: tp->t_type = gt.t_type; ! 612: tp->t_dp = gt.t_dp; ! 613: tp->t_ip = gt.t_ip; ! 614: tp->t_lp = lp; ! 615: tp->t_rp = rp; ! 616: if (lt==T_PTR && rt==T_PTR) { ! 617: if (op == ADD) ! 618: cerror("cannot add pointers"); ! 619: if (op == SUB) { ! 620: if ((ll=psize(lp)) != (lr=psize(rp))) ! 621: cerror("illegal subtraction of pointers"); ! 622: tp = bconvert(tp, T_INT, NULL, NULL, bzcon(ll)); ! 623: } ! 624: } ! 625: if (op==ASSIGN && lt==T_STRUCT && rt==T_STRUCT) { ! 626: notbook(); ! 627: if ((ll=tsize(lp)) != (lr=tsize(rp))) ! 628: cerror("illegal structure assignment"); ! 629: } ! 630: if (isvariant(VSPVAL) && lt != rt ! 631: && ((lt==T_PTR && !iszero(rp)) || (rt==T_PTR && !iszero(lp)))) { ! 632: if (op == ASSIGN) ! 633: cstrict("integer pointer pun"); ! 634: else if (op >= EQ && op <= ULT) ! 635: cstrict("integer pointer comparison"); ! 636: } ! 637: return tp; ! 638: } ! 639: ! 640: /* ! 641: * If the first entry in the dimensions of tree "tp" is a ! 642: * MOS array, stomp it into the pointer it truly is. ! 643: */ ! 644: chmos(tp) ! 645: TREE *tp; ! 646: { ! 647: register struct dim *dp; ! 648: ! 649: if ((dp = tp->t_dp)!=NULL && dp->d_type==D_MOSAR) { ! 650: dp->d_type = D_PTR; ! 651: dp->d_bound = 0; ! 652: } ! 653: } ! 654: ! 655: /* ! 656: * Read constant expression. ! 657: * Call the standard expression reader, and make sure that ! 658: * the folder has squashed it down to nothing. ! 659: * Return the value. ! 660: */ ! 661: ival_t ! 662: iconexpr() ! 663: { ! 664: register TREE *tp; ! 665: ! 666: tp = expr(); ! 667: while (tp->t_op == CAST || tp->t_op == CONVERT) ! 668: tp = tp->t_lp; ! 669: if (tp->t_op == ICON) ! 670: return tp->t_ival; ! 671: if (tp->t_op == LCON && (ival_t)tp->t_lval == tp->t_lval) ! 672: return (ival_t)tp->t_lval; ! 673: if (tp->t_op == ZCON && (ival_t)tp->t_zval == tp->t_zval) ! 674: return (ival_t)tp->t_zval; ! 675: cerror("int constant expression required"); ! 676: return (ival_t)0; ! 677: } ! 678: ! 679: /* ! 680: * Look for a constant zero of integral type. ! 681: */ ! 682: iszero(tp) ! 683: register TREE *tp; ! 684: { ! 685: register int op; ! 686: ! 687: if (tp != NULL) { ! 688: while ((op = tp->t_op) == CONVERT || op == CAST) ! 689: tp = tp->t_lp; ! 690: if (op == ICON && tp->t_ival == 0) ! 691: return 1; ! 692: if (op == LCON && tp->t_lval == 0L) ! 693: return 1; ! 694: } ! 695: return 0; ! 696: } ! 697: ! 698: /* ! 699: * Build a conversion node. ! 700: * Used by build and stat when bcvt is unsuitable. ! 701: */ ! 702: TREE * ! 703: bconvert(lp, gt, gdp, gip, rp) ! 704: TREE *lp, *rp; ! 705: DIM *gdp; ! 706: INFO *gip; ! 707: { ! 708: TREE t; ! 709: ! 710: t.t_op = CONVERT; ! 711: t.t_type = gt; ! 712: t.t_dp = gdp; ! 713: t.t_ip = gip; ! 714: t.t_rp = rp; ! 715: return bcvt(lp, &t); ! 716: } ! 717: ! 718: /* ! 719: * Build a conversion or cast node. ! 720: */ ! 721: TREE * ! 722: bcvt(lp, gtp) ! 723: TREE *lp, *gtp; ! 724: { ! 725: register TREE *tp; ! 726: ! 727: tp = lp; ! 728: tp = talloc(); ! 729: tp->t_op = gtp->t_op; ! 730: tp->t_type = gtp->t_type; ! 731: tp->t_dp = gtp->t_dp; ! 732: tp->t_ip = gtp->t_ip; ! 733: tp->t_lp = lp; ! 734: tp->t_rp = gtp->t_rp; ! 735: return tp; ! 736: } ! 737: ! 738: /* ! 739: * Given a pointer to its symbol table node, ! 740: * return a pointer to the tree node for an identifier. ! 741: * Enumeration tags get changed into integer constants here. ! 742: */ ! 743: TREE * ! 744: bid(sp) ! 745: register SYM *sp; ! 746: { ! 747: register TREE *tp; ! 748: ! 749: sp->s_flag |= S_USED; ! 750: if (sp->s_class == C_MOE) ! 751: return bicon(sp->s_value); ! 752: tp = talloc(); ! 753: switch (sp->s_class) { ! 754: ! 755: case C_AUTO: ! 756: tp->t_op = AID; ! 757: tp->t_offs = sp->s_value; ! 758: break; ! 759: ! 760: case C_PAUTO: ! 761: tp->t_op = PID; ! 762: tp->t_offs = sp->s_value; ! 763: break; ! 764: ! 765: case C_SIN: ! 766: tp->t_op = LID; ! 767: tp->t_seg = sp->s_seg; ! 768: tp->t_label = sp->s_value; ! 769: break; ! 770: ! 771: case C_REG: ! 772: tp->t_op = REG; ! 773: tp->t_reg = sp->s_value; ! 774: break; ! 775: ! 776: case C_GDEF: ! 777: case C_GREF: ! 778: case C_CXT: ! 779: case C_SEX: ! 780: tp->t_op = GID; ! 781: tp->t_seg = sp->s_seg; ! 782: tp->t_sp = sp; ! 783: break; ! 784: ! 785: default: ! 786: cerror("identifier \"%s\" not usable", sp->s_id); ! 787: tp->t_op = ICON; ! 788: tp->t_type = T_INT; ! 789: return tp; ! 790: } ! 791: tp->t_type = sp->s_type; ! 792: tp->t_dp = sp->s_dp; ! 793: tp->t_ip = sp->s_ip; ! 794: return tp; ! 795: } ! 796: ! 797: /* ! 798: * Build ICON tree node. ! 799: */ ! 800: TREE * ! 801: bicon(n) ival_t n; ! 802: { ! 803: register TREE *tp; ! 804: ! 805: tp = talloc(); ! 806: tp->t_op = ICON; ! 807: tp->t_type = T_INT; ! 808: tp->t_ival = n; ! 809: return tp; ! 810: } ! 811: ! 812: TREE * ! 813: bzcon(n) ! 814: sizeof_t n; ! 815: { ! 816: register TREE *tp; ! 817: ! 818: tp = talloc(); ! 819: tp->t_op = ZCON; ! 820: tp->t_type = T_UINT; ! 821: tp->t_zval = n; ! 822: return tp; ! 823: } ! 824: ! 825: /* ! 826: * Read in a string and hide it in the string section. ! 827: * Return a pointer to a local identifier node; ! 828: * the local identifier is planted at the start of the string. ! 829: * The type of the node is set to array of char. ! 830: */ ! 831: static ! 832: TREE * ! 833: bstring() ! 834: { ! 835: register TREE *tp; ! 836: register int c, nbb, nbs; ! 837: int old, lab, adj; ! 838: char bb[11]; ! 839: ! 840: old = newseg(SSTRN); ! 841: lab = here(); ! 842: nbb = nbs = adj = 0; ! 843: again: ! 844: instring = '"'; ! 845: while ((c=getmap('\"')) >= 0) { ! 846: ++nbs; ! 847: if (nbb >= 10) { /* Leave space for NUL */ ! 848: bsflush(bb, nbb); ! 849: nbb = 0; ! 850: } ! 851: bb[nbb++] = c; ! 852: } ! 853: instring = 0; ! 854: if (lex() == STRING) { /* e.g. "Hello " "world" */ ! 855: ++adj; ! 856: goto again; ! 857: } ! 858: bb[nbb++] = 0; ! 859: bsflush(bb, nbb); ! 860: if (adj) ! 861: notbook(); ! 862: newseg(old); ! 863: tp = talloc(); ! 864: tp->t_op = LID; ! 865: tp->t_type = T_CHAR; ! 866: tp->t_dp = tdalloc(NULL, D_ARRAY, (sizeof_t)nbs+1); ! 867: tp->t_label = lab; ! 868: tp->t_seg = SSTRN; ! 869: return tp; ! 870: } ! 871: ! 872: /* ! 873: * Dump out the string buffer. ! 874: */ ! 875: bsflush(bb, nbb) ! 876: register unsigned char *bb; ! 877: register int nbb; ! 878: { ! 879: bput(IBLOCK); ! 880: bput(nbb); ! 881: while (nbb--) ! 882: bput(*bb++); ! 883: } ! 884: ! 885: /* ! 886: * Make all the types and dims in a tree agree with the viewpoint at the top. ! 887: * This is used by casts and the code that builds up structure access trees. ! 888: */ ! 889: adjust(tp, t, dp, ip) ! 890: register TREE *tp; ! 891: register DIM *dp; ! 892: INFO *ip; ! 893: { ! 894: register int op; ! 895: ! 896: again: ! 897: tp->t_type = t; ! 898: tp->t_dp = dp; ! 899: tp->t_ip = ip; ! 900: if ((op = tp->t_op) == ADDR) { ! 901: if (dp==NULL || (dp->d_type!=D_PTR && dp->d_type!=D_MOSAR)) ! 902: return; ! 903: dp = dp->d_dp; ! 904: tp = tp->t_lp; ! 905: goto again; ! 906: } ! 907: if (op == STAR) { ! 908: dp = tdalloc(dp, D_PTR, (sizeof_t)0); ! 909: tp = tp->t_lp; ! 910: goto again; ! 911: } ! 912: if (dp!=NULL && dp->d_type==D_MOSAR) ! 913: dp = tdalloc(dp->d_dp, D_PTR, (sizeof_t)0); ! 914: if (op==CAST && bitcompat(tltype(tp), tltype(tp->t_lp))) { ! 915: tp = tp->t_lp; ! 916: goto again; ! 917: } ! 918: } ! 919: ! 920: /* ! 921: * If the tree "tp" is a pointer, ! 922: * return the size of the item to which the pointer points; ! 923: * if it is not a pointer, return 1. ! 924: */ ! 925: sizeof_t psize(tp) ! 926: register TREE *tp; ! 927: { ! 928: register DIM *dp; ! 929: register sizeof_t n; ! 930: ! 931: dp = tp->t_dp; ! 932: if (dp==NULL || dp->d_type!=D_PTR) ! 933: return 1; ! 934: tp->t_dp = dp->d_dp; ! 935: n = tsize(tp); ! 936: tp->t_dp = dp; ! 937: return n; ! 938: } ! 939: ! 940: /* ! 941: * Check if a tree has type "function returning ...". ! 942: * If it does, modify the tree to add the free "address of". ! 943: */ ! 944: TREE * ! 945: chfun(tp) ! 946: register TREE *tp; ! 947: { ! 948: register DIM *dp; ! 949: ! 950: dp = tp->t_dp; ! 951: if (dp!=NULL && dp->d_type==D_FUNC) { ! 952: tp = build(ADDR, tp, NULL); ! 953: adjust(tp, tp->t_type, tp->t_dp, tp->t_ip); ! 954: } ! 955: return tp; ! 956: } ! 957: ! 958: /* ! 959: * Check for arrays. ! 960: * Add the free '&' operation. ! 961: * We build the node ourselves (rather than calling build) ! 962: * to avoid a recursive call to this routine on ! 963: * a multidimensional structure. ! 964: */ ! 965: TREE * ! 966: charray(tp) ! 967: register TREE *tp; ! 968: { ! 969: register TREE *ap; ! 970: register DIM *dp; ! 971: ! 972: dp = tp->t_dp; ! 973: if (dp!=NULL && dp->d_type==D_ARRAY) { ! 974: ap = talloc(); ! 975: ap->t_op = ADDR; ! 976: ap->t_type = tp->t_type; ! 977: ap->t_dp = tdalloc(dp->d_dp, D_PTR, (sizeof_t)0); ! 978: ap->t_ip = tp->t_ip; ! 979: ap->t_lp = tp; ! 980: tp = ap; ! 981: adjust(tp, tp->t_type, tp->t_dp, tp->t_ip); ! 982: } ! 983: return tp; ! 984: } ! 985: ! 986: /* ! 987: * Given a tree node, get a type for the tree that is ! 988: * usable for indexing into the type conversion tables. ! 989: * All non-scalars are pointers. ! 990: * All structures and unions are structures. ! 991: * All enumerations are set right. ! 992: */ ! 993: tltype(tp) ! 994: register TREE *tp; ! 995: { ! 996: register int type; ! 997: ! 998: if (tp->t_dp != NULL) ! 999: return T_PTR; ! 1000: if ((type=tp->t_type) == T_FENUM) ! 1001: return T_INT; ! 1002: if (type == T_ENUM) ! 1003: return tp->t_ip->i_type; ! 1004: if (type > T_VOID) ! 1005: return T_STRUCT; ! 1006: return type; ! 1007: } ! 1008: ! 1009: /* ! 1010: * Check if two linear types are "bit compatable". ! 1011: */ ! 1012: bitcompat(t1, t2) ! 1013: { ! 1014: return noconvert(CAST, t1, t2); ! 1015: } ! 1016: ! 1017: /* ! 1018: * Allocate a new dim structure in the tree area. ! 1019: * Used to create pointers in the tree. ! 1020: */ ! 1021: DIM * ! 1022: tdalloc(p, t, b) ! 1023: DIM *p; ! 1024: int t; ! 1025: sizeof_t b; ! 1026: { ! 1027: register DIM *dp; ! 1028: ! 1029: dp = (struct dim *) talloc(); ! 1030: dp->d_dp = p; ! 1031: dp->d_type = t; ! 1032: dp->d_bound = b; ! 1033: return dp; ! 1034: } ! 1035: ! 1036: /* ! 1037: * Output a tree. ! 1038: */ ! 1039: tput(why, lab, tp) ! 1040: register why; ! 1041: register TREE *tp; ! 1042: { ! 1043: tp = transform(tp, why, -1); ! 1044: bput(why); ! 1045: if (why==TEXPR || why==FEXPR) ! 1046: iput((ival_t) lab); ! 1047: tput1(tp); ! 1048: } ! 1049: ! 1050: /* ! 1051: * Output a tree, part II. ! 1052: */ ! 1053: tput1(tp) ! 1054: register TREE *tp; ! 1055: { ! 1056: register int op; ! 1057: ! 1058: if (tp == NULL) { ! 1059: iput((ival_t) NIL); ! 1060: return; ! 1061: } ! 1062: op = tp->t_op; ! 1063: iput((ival_t) op); ! 1064: bput(tp->t_type); ! 1065: if (tp->t_type == BLK) ! 1066: iput((ival_t)tp->t_ip->i_size); ! 1067: switch (op) { ! 1068: ! 1069: case ICON: ! 1070: iput((ival_t) tp->t_ival); ! 1071: break; ! 1072: ! 1073: case LCON: ! 1074: lput(tp->t_lval); ! 1075: break; ! 1076: ! 1077: case ZCON: ! 1078: zput(tp->t_zval); ! 1079: break; ! 1080: ! 1081: case DCON: ! 1082: dput(tp->t_dval); /* An array */ ! 1083: break; ! 1084: ! 1085: case AID: ! 1086: case PID: ! 1087: case LID: ! 1088: case GID: ! 1089: zput(tp->t_offs); ! 1090: if (op==LID || op==GID) { ! 1091: bput(tp->t_seg); ! 1092: if (op == LID) ! 1093: iput((ival_t) tp->t_label); ! 1094: else ! 1095: nput(tp->t_sp->s_id); ! 1096: } ! 1097: break; ! 1098: ! 1099: case REG: ! 1100: iput((ival_t) tp->t_reg); ! 1101: break; ! 1102: ! 1103: case FIELD: ! 1104: bput(tp->t_width); ! 1105: bput(tp->t_base); ! 1106: tput1(tp->t_lp); ! 1107: break; ! 1108: ! 1109: default: ! 1110: tput1(tp->t_lp); ! 1111: tput1(tp->t_rp); ! 1112: } ! 1113: } ! 1114: ! 1115: /* end of n0/expr.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.