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