![[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 [Research Unix] / researchv10no / cmd / lcc / c|
Return to expr.c CVS log | Up to [Research Unix] / researchv10no / cmd / lcc / c |
1.1 ! root 1: /* C compiler: expression parsing */ ! 2: ! 3: #include "c.h" ! 4: ! 5: static char prec[] = { ! 6: #define xx(a,b,c,d,e,f,g) c, ! 7: #include "token.h" ! 8: }; ! 9: static int oper[] = { ! 10: #define xx(a,b,c,d,e,f,g) d, ! 11: #include "token.h" ! 12: }; ! 13: dclproto(static Tree call,(Tree, Type, Coordinate)); ! 14: dclproto(static Tree expr2,(void)); ! 15: dclproto(static Tree expr3,(int)); ! 16: dclproto(static Tree nullcheck,(Tree)); ! 17: dclproto(static Tree postfix,(Tree)); ! 18: dclproto(static Tree prefix,(void)); ! 19: dclproto(static Tree primary,(void)); ! 20: dclproto(static Tree rightkid,(Tree)); ! 21: dclproto(static Tree value,(Tree)); ! 22: ! 23: /* addrof - address of p */ ! 24: Tree addrof(p) Tree p; { ! 25: Tree q = p; ! 26: ! 27: for (;;) ! 28: switch (generic(q->op)) { ! 29: case RIGHT: ! 30: assert(q->kids[0] || q->kids[1]); ! 31: q = q->kids[1] ? q->kids[1] : q->kids[0]; ! 32: continue; ! 33: case ASGN: ! 34: q = q->kids[1]; ! 35: continue; ! 36: case COND: { ! 37: Symbol t1 = q->u.sym; ! 38: q->u.sym = 0; ! 39: q = idnode(t1); ! 40: /* fall thru */ ! 41: } ! 42: case INDIR: ! 43: if (p == q) ! 44: return q->kids[0]; ! 45: q = q->kids[0]; ! 46: return tree(RIGHT, q->type, root(p), q); ! 47: default: ! 48: error("addressable object required\n"); ! 49: return value(p); ! 50: } ! 51: } ! 52: ! 53: /* asgn - generate tree for assignment of expr e to symbol p sans qualifiers */ ! 54: Tree asgn(p, e) Symbol p; Tree e; { ! 55: if (isarray(p->type)) ! 56: e = tree(ASGN+B, p->type, idnode(p), ! 57: tree(INDIR+B, e->type, e, 0)); ! 58: else { ! 59: Type ty = p->type; ! 60: p->type = unqual(p->type); ! 61: if (isstruct(p->type) && p->type->u.sym->u.s.cfields) { ! 62: p->type->u.sym->u.s.cfields = 0; ! 63: e = asgnnode(ASGN, idnode(p), e); ! 64: p->type->u.sym->u.s.cfields = 1; ! 65: } else ! 66: e = asgnnode(ASGN, idnode(p), e); ! 67: p->type = ty; ! 68: } ! 69: return e; ! 70: } ! 71: ! 72: /* assign - perform type-checking of assignment of p to variable of type xty */ ! 73: Type assign(xty, p) Type xty; Tree p; { ! 74: Type yty = unqual(p->type); ! 75: ! 76: if (yty->size == 0) ! 77: return 0; ! 78: xty = unqual(xty); ! 79: if (isenum(xty)) ! 80: xty = xty->type; ! 81: if (isarith(xty) && isarith(yty)) ! 82: return xty; ! 83: if (isstruct(xty) && xty == yty) ! 84: return xty; ! 85: if (isstruct(xty) && isstruct(yty) && extends(yty, xty)) ! 86: return xty; ! 87: if (isptr(xty) && isptr(yty)) { ! 88: Type lty = xty->type, rty = yty->type; ! 89: if (isstruct(lty) && isstruct(rty) && extends(rty, lty)) ! 90: return xty; ! 91: if (eqtype(lty, rty, 1) ! 92: || (eqtype(unqual(lty), unqual(rty), 1) ! 93: && ( !isconst(rty) || isconst(lty)) ! 94: && (!isvolatile(rty) || isvolatile(lty)))) ! 95: return yty; ! 96: if (xty == voidptype || unqual(lty) == voidtype ! 97: || yty == voidptype || unqual(rty) == voidtype) ! 98: return xty; ! 99: if (lty == inttype && isenum(rty) || rty == inttype && isenum(lty)) { ! 100: if (Aflag >= 1) ! 101: warning("assignment between `%t' and `%t' is compiler-dependent\n", ! 102: xty, yty); ! 103: return xty; ! 104: } ! 105: } ! 106: if (isptr(xty) && isint(p->type) && generic(p->op) == CNST ! 107: && cast(p, unsignedtype)->u.v.u == 0) ! 108: return xty; ! 109: return 0; ! 110: } ! 111: ! 112: /* call - parse function call to f, type fty */ ! 113: static Tree call(f, fty, src) Tree f; Type fty; Coordinate src; { ! 114: int n = 0; ! 115: Tree args = 0, r = 0; ! 116: Type *proto = fty->u.f.oldstyle ? (Type *)0 : fty->u.f.proto; ! 117: ! 118: if (hascall(f)) ! 119: r = f; ! 120: if (t != ')') ! 121: do { ! 122: Tree q = pointer(expr1(0)); ! 123: if (proto && *proto && *proto != voidtype) { ! 124: Type aty; ! 125: q = value(q); ! 126: if (aty = assign(*proto, q)) { ! 127: q = cast(q, aty); ! 128: if ((isint(q->type) || isenum(q->type)) ! 129: && q->type->size != inttype->size) ! 130: q = cast(q, promote(q->type)); ! 131: } else ! 132: error("type error in argument %d to %s; found `%t' expected `%t'\n", ! 133: n + 1, funcname(f), q->type, *proto); ! 134: proto++; ! 135: } else { ! 136: if (!fty->u.f.oldstyle && *proto == 0) ! 137: error("too many arguments to %s\n", funcname(f)); ! 138: q = value(q); ! 139: if (q->type == floattype) ! 140: q = cast(q, doubletype); ! 141: else if ((isint(q->type) || isenum(q->type)) ! 142: && q->type->size != inttype->size) ! 143: q = cast(q, promote(q->type)); ! 144: else if (isarray(q->type) || q->type->size == 0) ! 145: error("type error in argument %d to %s; `%t' is illegal\n", ! 146: n + 1, funcname(f), q->type); ! 147: } ! 148: if (IR->no_argb && isstruct(q->type)) { ! 149: Symbol t1; ! 150: if (q->op == RIGHT && q->kids[0] ! 151: && q->kids[0]->op == CALL+B) { ! 152: /* ! 153: * When the argument is f() where f ! 154: * returns a struct, simply use the ! 155: * temporary generated to hold f's ! 156: * return value. ! 157: */ ! 158: assert(q->kids[0]->kids[1]); ! 159: t1 = q->kids[0]->kids[1]->u.sym; ! 160: q = q->kids[0]; ! 161: } else { ! 162: t1 = temporary(AUTO, unqual(q->type)); ! 163: q = asgn(t1, q); ! 164: } ! 165: q = tree(RIGHT, ptr(q->type), root(q), lvalue(idnode(t1))); ! 166: } ! 167: if (q->type->size == 0) ! 168: q->type = inttype; ! 169: if (hascall(q)) ! 170: r = tree(RIGHT, voidtype, r, q); ! 171: args = tree(ARG + widen(q->type), q->type, q, args); ! 172: n++; ! 173: if (Aflag >= 2 && n == 32) ! 174: warning("more than 31 arguments in a call to %s\n", funcname(f)); ! 175: } while (t == ',' && (t = gettok())); ! 176: expect(')'); ! 177: if (proto && *proto && *proto != voidtype) ! 178: error("insufficient number of arguments to %s\n", funcname(f)); ! 179: if (r) ! 180: args = tree(RIGHT, voidtype, r, args); ! 181: if (events.calls) ! 182: apply(events.calls, (Generic)&src, (Generic)&f); ! 183: return callnode(f, freturn(fty), args); ! 184: } ! 185: ! 186: /* cast - cast expression p to type */ ! 187: Tree cast(p, type) Tree p; Type type; { ! 188: Field q; ! 189: Type pty, ty = unqual(type); ! 190: ! 191: p = value(p); ! 192: if (p->type == type) ! 193: return p; ! 194: pty = unqual(p->type); ! 195: if (pty == ty) ! 196: return retype(p, type); ! 197: if (pty == signedchar || pty == chartype) ! 198: p = simplify(CVC, inttype, p, 0); ! 199: else if (pty == shorttype) ! 200: p = simplify(CVS, inttype, p, 0); ! 201: else if (pty == longtype) ! 202: p = retype(p, inttype); ! 203: else if (pty == floattype) ! 204: p = simplify(CVF, doubletype, p, 0); ! 205: else if (pty == longdouble) ! 206: p = retype(p, doubletype); ! 207: else if (pty == unsignedchar) ! 208: p = simplify(CVC, unsignedtype, p, 0); ! 209: else if (pty == unsignedshort) ! 210: p = simplify(CVS, unsignedtype, p, 0); ! 211: else if (pty == unsignedlong) ! 212: p = retype(p, unsignedtype); ! 213: else if (isptr(pty)) { ! 214: if (isstruct(pty->type) && isptr(ty) && isstruct(ty->type) ! 215: && (q = extends(pty->type, ty->type))) ! 216: return simplify(ADD+P, ty, p, constnode(q->offset, inttype)); ! 217: if (isptr(ty)) { ! 218: if (isfunc(pty->type) && !isfunc(ty->type) ! 219: || !isfunc(pty->type) && isfunc(ty->type)) ! 220: warning("conversion from `%t' to `%t' is compiler-dependent\n", ! 221: p->type, ty); ! 222: return retype(p, type); ! 223: } ! 224: p = simplify(CVP, unsignedtype, p, 0); ! 225: } ! 226: else if (isstruct(pty) && isstruct(ty) && (q = extends(pty, ty))) ! 227: return rvalue(simplify(ADD+P, ptr(ty), addrof(p), ! 228: constnode(q->offset, inttype))); ! 229: pty = unqual(p->type); ! 230: if (pty == inttype || isenum(pty)) { ! 231: if (ty == floattype || ty == doubletype || ty == longdouble) ! 232: p = simplify(CVI, doubletype, p, 0); ! 233: else if (ty == unsignedtype || ty == unsignedchar ! 234: || ty == unsignedshort || ty == unsignedlong || isptr(ty)) ! 235: p = simplify(CVI, unsignedtype, p, 0); ! 236: } else if (pty == doubletype) { ! 237: if (ty == signedchar || ty == chartype || isenum(ty) ! 238: || ty == shorttype || ty == inttype || ty == longtype) ! 239: p = simplify(CVD, inttype, p, 0); ! 240: else if (ty == unsignedtype || ty == unsignedchar ! 241: || ty == unsignedshort || ty == unsignedlong || isptr(ty)) { ! 242: /* ! 243: * For (unsigned)d for double d, build ! 244: * d >= INT_MAX+1 ? (unsigned)(int)(d-(INT_MAX+1)) + INT_MAX+1 : ! 245: * (unsigned)(int)d ! 246: */ ! 247: Tree c = tree(CNST+D, doubletype, 0, 0); ! 248: c->u.v.d = (double)INT_MAX + 1; ! 249: p = condnode( ! 250: simplify(GE, doubletype, p, c), ! 251: (*opnode['+'])(ADD, ! 252: cast(cast(simplify(SUB, doubletype, p, c), inttype), unsignedtype), ! 253: constnode((unsigned)INT_MAX + 1, unsignedtype)), ! 254: simplify(CVD, inttype, p, 0)); ! 255: } ! 256: } else if (pty == unsignedtype) { ! 257: if (ty == signedchar || ty == chartype || isenum(ty) ! 258: || ty == shorttype || ty == inttype || ty == longtype) ! 259: p = simplify(CVU, inttype, p, 0); ! 260: else if (ty == floattype || ty == doubletype || ty == longdouble) { ! 261: /* ! 262: * For (double)u for unsigned u, build ! 263: * (int)u >= 0 ? (double)(int)u : (double)(int)u + UINT_MAX + 1 ! 264: */ ! 265: Tree u = simplify(CVU, inttype, p, 0); ! 266: p = tree(CNST+D, doubletype, 0, 0); ! 267: p->u.v.d = utod(UINT_MAX) + 1; ! 268: p = condnode( ! 269: simplify(GE, inttype, u, constnode(0, inttype)), ! 270: simplify(CVI, doubletype, u, 0), ! 271: (*opnode['+'])(ADD, simplify(CVI, doubletype, u, 0), p)); ! 272: } ! 273: } else ! 274: assert(0); ! 275: if (ty == signedchar || ty == chartype || ty == shorttype) ! 276: p = simplify(CVI, type, p, 0); ! 277: else if (ty == floattype) ! 278: p = simplify(CVD, type, p, 0); ! 279: else if (ty == unsignedchar || ty == unsignedshort || isptr(ty)) ! 280: p = simplify(CVU, type, p, 0); ! 281: else ! 282: p = retype(p, type); ! 283: return p; ! 284: } ! 285: ! 286: /* cond - check for conditional operator, add comparison if necessary */ ! 287: Tree cond(p) Tree p; { ! 288: Opcode op = generic(rightkid(p)->op); ! 289: ! 290: if (op == AND || op == OR || op == NOT || op == EQ || op == NE ! 291: || op == LE || op == LT || op == GE || op == GT) ! 292: return p; ! 293: p = pointer(p); ! 294: p = cast(p, promote(p->type)); ! 295: return (*opnode[NEQ])(NE, p, constnode(0, inttype)); ! 296: } ! 297: ! 298: /* conditional - parse expression and cast to conditional */ ! 299: Tree conditional(tok) { ! 300: Tree p = expr(tok); ! 301: ! 302: if (Aflag > 1 && isfunc(p->type)) ! 303: warning("%s used in a conditional expression\n", funcname(p)); ! 304: return cond(p); ! 305: } ! 306: ! 307: /* constexpr - parse a constant expression */ ! 308: Tree constexpr(tok) { ! 309: Tree p; ! 310: ! 311: needconst++; ! 312: p = expr1(tok); ! 313: needconst--; ! 314: return p; ! 315: } ! 316: ! 317: /* expr0 - parse an expression for side effect */ ! 318: Tree expr0(tok) { ! 319: return root(expr(tok)); ! 320: } ! 321: ! 322: /* expr - parse an expression */ ! 323: Tree expr(tok) { ! 324: Tree p = expr1(0); ! 325: ! 326: while (t == ',') { ! 327: Tree q; ! 328: t = gettok(); ! 329: q = pointer(expr1(0)); ! 330: if (generic(p->op) != CNST) ! 331: p = root(value(p)); ! 332: p = tree(RIGHT, q->type, p, q); ! 333: } ! 334: if (tok && t == tok) ! 335: t = gettok(); ! 336: else if (tok) { ! 337: static char follow[] = { IF, ID, '}', 0 }; ! 338: test(tok, follow); ! 339: } ! 340: return p; ! 341: } ! 342: ! 343: /* expr1 - parse assignments */ ! 344: Tree expr1(tok) { ! 345: Tree p = expr2(); ! 346: ! 347: while (t == '=' || (prec[t] >= 6 && prec[t] <= 8) ! 348: || (prec[t] >= 11 && prec[t] <= 13)) { ! 349: Opcode op = t; ! 350: t = gettok(); ! 351: if (oper[op] == ASGN) ! 352: p = asgnnode(ASGN, p, value(expr1(0))); ! 353: else { ! 354: expect('='); ! 355: p = incr(op, p, expr1(0)); ! 356: } ! 357: } ! 358: if (tok && t == tok) ! 359: t = gettok(); ! 360: else if (tok) { ! 361: static char follow[] = { IF, ID, 0 }; ! 362: test(tok, follow); ! 363: } ! 364: return p; ! 365: } ! 366: ! 367: /* expr2 - parse conditional expressions */ ! 368: static Tree expr2() { ! 369: Tree p = expr3(4); ! 370: ! 371: if (t == '?') { ! 372: Tree l, r; ! 373: if (Aflag > 1 && isfunc(p->type)) ! 374: warning("%s used in a conditional expression\n", funcname(p)); ! 375: p = pointer(p); ! 376: t = gettok(); ! 377: if (events.points) { ! 378: Tree e = 0; ! 379: apply(events.points, (Generic)&src, (Generic)&e); ! 380: l = right(e, pointer(expr(':'))); ! 381: e = 0; ! 382: apply(events.points, (Generic)&src, (Generic)&e); ! 383: r = right(e, pointer(expr2())); ! 384: } else { ! 385: l = pointer(expr(':')); ! 386: r = pointer(expr2()); ! 387: } ! 388: p = condnode(p, l, r); ! 389: } ! 390: return p; ! 391: } ! 392: ! 393: /* expr3 - parse expressions at precedence level k */ ! 394: static Tree expr3(k) { ! 395: int k1; ! 396: Tree p = prefix(); ! 397: ! 398: for (k1 = prec[t]; k1 >= k; k1--) ! 399: while (prec[t] == k1 && *cp != '=') { ! 400: Tree r; ! 401: Opcode op = t; ! 402: t = gettok(); ! 403: p = pointer(p); ! 404: if (events.points && (op == ANDAND || op == OROR)) { ! 405: Tree e = 0; ! 406: apply(events.points, (Generic)&src, (Generic)&e); ! 407: r = right(e, pointer(expr3(k1 + (k1>5)))); ! 408: } else ! 409: r = pointer(expr3(k1 + (k1>5))); ! 410: p = (*opnode[op])(oper[op], p, r); ! 411: } ! 412: return p; ! 413: } ! 414: ! 415: /* field - construct tree for reference to field name via p */ ! 416: Tree field(p, name) Tree p; char *name; { ! 417: Field q; ! 418: Type ty1, ty = p->type; ! 419: ! 420: if (isptr(ty)) ! 421: ty = deref(ty); ! 422: ty1 = ty; ! 423: ty = unqual(ty); ! 424: if (q = fieldref(name, ty)) { ! 425: ty = q->type; ! 426: if (isconst(ty1) && !isconst(ty)) ! 427: ty = qual(CONST, ty); ! 428: if (isvolatile(ty1) && !isvolatile(ty)) ! 429: ty = qual(VOLATILE, ty); ! 430: if (!isarray(q->type)) ! 431: ty = ptr(ty); ! 432: p = simplify(ADD+P, ty, p, constnode(q->offset, inttype)); ! 433: if (q->lsb) { ! 434: p = tree(FIELD, q->type, rvalue(p), 0); ! 435: p->u.field = q; ! 436: } else if (!isarray(q->type)) ! 437: p = rvalue(p); ! 438: } else { ! 439: error("unknown field `%s' of `%t'\n", name, ty); ! 440: p = rvalue(retype(p, ptr(inttype))); ! 441: } ! 442: return p; ! 443: } ! 444: ! 445: /* funcname - return name of function f or `a function' */ ! 446: char *funcname(f) Tree f; { ! 447: if (isaddrop(f->op)) ! 448: return stringf("`%s'", f->u.sym->name); ! 449: return "a function"; ! 450: } ! 451: ! 452: /* idnode - construct tree for reference to r-value of identifier p */ ! 453: Tree idnode(p) Symbol p; { ! 454: Opcode op; ! 455: Tree e; ! 456: Type ty = p->type ? unqual(p->type) : voidtype; ! 457: ! 458: p->ref += refinc; ! 459: if (p->scope == PARAM) { ! 460: if (IR->no_argb && isstruct(p->type)) { ! 461: e = tree(ADDRF+P, ptr(ptr(p->type)), 0, 0); ! 462: e->u.sym = p; ! 463: e = rvalue(e); ! 464: } else { ! 465: e = tree(ADDRF+P, ptr(p->type), 0, 0); ! 466: e->u.sym = p; ! 467: } ! 468: return rvalue(e); ! 469: } ! 470: if (p->scope == GLOBAL || p->sclass == STATIC || p->sclass == EXTERN) { ! 471: op = ADDRG+P; ! 472: if (isfunc(ty)) ! 473: p->addressed = 1; ! 474: } else ! 475: op = ADDRL+P; ! 476: if (isarray(ty) || isfunc(ty)) { ! 477: e = tree(op, p->type ? p->type : voidtype, 0, 0); ! 478: e->u.sym = p; ! 479: return e; ! 480: } else { ! 481: e = tree(op, ptr(p->type), 0, 0); ! 482: e->u.sym = p; ! 483: return rvalue(e); ! 484: } ! 485: } ! 486: ! 487: /* incr - construct tree for e1 op= e2 */ ! 488: Tree incr(op, e1, e2) Tree e1, e2; { ! 489: return asgnnode(ASGN, e1, (*opnode[op])(oper[op], e1, e2)); ! 490: } ! 491: ! 492: /* intexpr - parse a constant expression and return int value, default n */ ! 493: int intexpr(tok, n) { ! 494: Tree p = constexpr(tok); ! 495: ! 496: needconst++; ! 497: if (generic(p->op) == CNST && isint(p->type)) ! 498: n = cast(p, inttype)->u.v.i; ! 499: else ! 500: error("integer expression must be constant\n"); ! 501: needconst--; ! 502: return n; ! 503: } ! 504: ! 505: /* lvalue - check for lvalue, return pointer to lvalue tree */ ! 506: Tree lvalue(p) Tree p; { ! 507: if (generic(p->op) == INDIR) { ! 508: if (unqual(p->type) == voidtype) ! 509: warning("`%t' used as an lvalue\n", p->type); ! 510: return p->kids[0]; ! 511: } ! 512: error("lvalue required\n"); ! 513: return value(p); ! 514: } ! 515: ! 516: /* nullcheck - test if p null; build ((!p ? _YYnull(lineno) : ), p) */ ! 517: static Tree nullcheck(p) Tree p; { ! 518: Tree q, arg; ! 519: ! 520: if (needconst) ! 521: return p; ! 522: arg = tree(ARG+I, inttype, constnode(lineno, inttype), 0); ! 523: q = tree(COND, voidtype, ! 524: tree(NOT, inttype, cond(p), 0), ! 525: tree(RIGHT, inttype, callnode(pointer(idnode(YYnull)), voidtype, arg), 0)); ! 526: return tree(RIGHT, p->type, q, p); ! 527: } ! 528: ! 529: /* pointer - re-type `array of T', `T function' to `ptr to T', `ptr to T function', resp. */ ! 530: Tree pointer(p) Tree p; { ! 531: if (isarray(p->type) && (p->op != RIGHT || p->u.sym == 0)) ! 532: p = retype(p, atop(p->type)); ! 533: else if (isfunc(p->type)) ! 534: p = retype(p, ptr(p->type)); ! 535: return p; ! 536: } ! 537: ! 538: /* postfix - parse a postfix expresssion; p is the primary dag */ ! 539: static Tree postfix(p) Tree p; { ! 540: Tree q; ! 541: Type ty; ! 542: ! 543: for (;;) ! 544: switch (t) { ! 545: case INCR: case DECR: ! 546: p = tree(RIGHT, p->type, ! 547: tree(RIGHT, p->type, p, root(incr(t, p, constnode(1, inttype)))), ! 548: p); ! 549: t = gettok(); ! 550: continue; ! 551: case '[': ! 552: t = gettok(); ! 553: q = expr(']'); ! 554: if (YYnull) ! 555: if (isptr(p->type)) ! 556: p = nullcheck(p); ! 557: else if (isptr(q->type)) ! 558: q = nullcheck(q); ! 559: q = pointer(q); ! 560: p = (*opnode['+'])(ADD, pointer(p), q); ! 561: if (isptr(p->type) && isarray(p->type->type)) ! 562: p = retype(p, p->type->type); ! 563: else ! 564: p = rvalue(p); ! 565: continue; ! 566: case '(': { ! 567: Coordinate pt; ! 568: p = pointer(p); ! 569: if (isptr(p->type) && isfunc(p->type->type)) ! 570: ty = p->type->type; ! 571: else { ! 572: error("found `%t' expected a function\n", p->type); ! 573: ty = func(voidtype, 0, 1); ! 574: } ! 575: pt = src; ! 576: t = gettok(); ! 577: p = call(p, ty, pt); ! 578: continue; ! 579: } ! 580: case '.': ! 581: t = gettok(); ! 582: if (t == ID) { ! 583: if (isstruct(p->type)) { ! 584: q = addrof(p); ! 585: p = field(q, token); /* refme */ ! 586: q = rightkid(q); ! 587: if (isaddrop(q->op) && q->u.sym->temporary) { ! 588: p = tree(RIGHT, p->type, p, 0); ! 589: p->u.sym = q->u.sym; ! 590: } ! 591: } else ! 592: error("left operand of . has incompatible type `%t'\n", ! 593: p->type); ! 594: t = gettok(); ! 595: } else ! 596: error("field name expected\n"); ! 597: continue; ! 598: case DEREF: ! 599: t = gettok(); ! 600: p = pointer(p); ! 601: if (t == ID) { ! 602: if (isptr(p->type)) ! 603: ty = deref(p->type); ! 604: if (isptr(p->type) && isstruct(ty)) { ! 605: if (YYnull) ! 606: p = nullcheck(p); ! 607: p = field(p, token); /* refme */ ! 608: } else ! 609: error("left operand of -> has incompatible type `%t'\n", ! 610: p->type); ! 611: t = gettok(); ! 612: } else ! 613: error("field name expected\n"); ! 614: continue; ! 615: default: ! 616: return p; ! 617: } ! 618: } ! 619: ! 620: /* prefix - parse a prefix expression */ ! 621: static Tree prefix() { ! 622: Tree p; ! 623: ! 624: switch (t) { ! 625: case '*': ! 626: t = gettok(); ! 627: p = pointer(prefix()); ! 628: if (isptr(p->type) && (isfunc(p->type->type) || isarray(p->type->type))) { ! 629: p = retype(p, p->type->type); ! 630: break; ! 631: } ! 632: if (YYnull) ! 633: p = nullcheck(p); ! 634: p = rvalue(p); ! 635: break; ! 636: case '&': ! 637: t = gettok(); ! 638: p = prefix(); ! 639: if (isarray(p->type) || isfunc(p->type)) ! 640: p = retype(p, ptr(p->type)); ! 641: else ! 642: p = lvalue(p); ! 643: if (isaddrop(p->op)) ! 644: if (p->u.sym->sclass == REGISTER) ! 645: error("invalid operand of unary &; `%s' is declared register\n", ! 646: p->u.sym->name); ! 647: else ! 648: p->u.sym->addressed = 1; ! 649: break; ! 650: case '+': ! 651: t = gettok(); ! 652: p = pointer(prefix()); ! 653: if (isarith(p->type)) ! 654: p = cast(p, promote(p->type)); ! 655: else ! 656: typeerror(ADD, p, 0); ! 657: break; ! 658: case '-': ! 659: t = gettok(); ! 660: p = pointer(prefix()); ! 661: if (isarith(p->type)) { ! 662: p = cast(p, promote(p->type)); ! 663: if (isunsigned(p->type)) { ! 664: warning("unsigned operand of unary -\n"); ! 665: p = cast(simplify(NEG+I, inttype, cast(p, inttype), 0), unsignedtype); ! 666: } else ! 667: p = simplify(NEG + ttob(p->type), p->type, p, 0); ! 668: } else ! 669: typeerror(SUB, p, 0); ! 670: break; ! 671: case '~': ! 672: t = gettok(); ! 673: p = pointer(prefix()); ! 674: if (isint(p->type)) { ! 675: Type ty = promote(p->type); ! 676: p = simplify(BCOM, ty, cast(p, ty), 0); ! 677: } else ! 678: typeerror(BCOM, p, 0); ! 679: break; ! 680: case '!': ! 681: t = gettok(); ! 682: p = pointer(prefix()); ! 683: if (isscalar(p->type)) ! 684: p = simplify(NOT, inttype, cond(p), 0); ! 685: else ! 686: typeerror(NOT, p, 0); ! 687: break; ! 688: case INCR: case DECR: { ! 689: Opcode op = t; ! 690: t = gettok(); ! 691: p = incr(op, pointer(prefix()), constnode(1, inttype)); ! 692: break; ! 693: } ! 694: case SIZEOF: { ! 695: Type ty; ! 696: t = gettok(); ! 697: p = 0; ! 698: if (t == '(') { ! 699: t = gettok(); ! 700: if (kind[t] == CHAR || t == ID ! 701: && tsym && tsym->sclass == TYPEDEF) { ! 702: ty = typename(); ! 703: expect(')'); ! 704: } else if (t == SCON) { ! 705: ty = tsym->type; ! 706: t = gettok(); ! 707: expect(')'); ! 708: } else ! 709: p = postfix(expr(')')); ! 710: } else if (t == SCON) { ! 711: ty = tsym->type; ! 712: t = gettok(); ! 713: } else ! 714: p = prefix(); ! 715: if (p) ! 716: ty = p->type; ! 717: if (isfunc(ty) || ty->size == 0) ! 718: error("invalid type argument `%t' to `sizeof'\n", ty); ! 719: else if (p && p->op == FIELD) ! 720: error("`sizeof' applied to a bit field\n"); ! 721: p = constnode(ty->size, unsignedtype); ! 722: break; ! 723: } ! 724: case '(': ! 725: t = gettok(); ! 726: if (kind[t] == CHAR || t == ID ! 727: && tsym && tsym->sclass == TYPEDEF) { ! 728: Type ty, ty1 = typename(); ! 729: ty = unqual(ty1); ! 730: if (isenum(ty)) { ! 731: Type ty2 = ty->type; ! 732: if (isconst(ty1)) ! 733: ty2 = qual(CONST, ty2); ! 734: if (isvolatile(ty1)) ! 735: ty2 = qual(VOLATILE, ty2); ! 736: ty1 = ty2; ! 737: ty = ty->type; ! 738: } ! 739: expect(')'); ! 740: if (isstruct(ty) && t == '{') { ! 741: Symbol t1 = temporary(AUTO, ty); ! 742: if (Aflag >= 2) ! 743: warning("non-ANSI constructor for `%t'\n", ty); ! 744: p = tree(RIGHT, ty1, structexp(ty, t1), idnode(t1)); ! 745: break; ! 746: } ! 747: p = pointer(prefix()); ! 748: if ((isarith(p->type) || isenum(p->type)) && isarith(ty) ! 749: || isptr(ty) && (isptr(p->type) || isint(p->type) || isenum(p->type))) ! 750: p = cast(p, ty); ! 751: else if (isint(ty) && isptr(p->type)) { ! 752: if (Aflag >= 1 && ty->size < p->type->size) ! 753: warning("conversion from `%t' to `%t' is compiler-dependent\n", ! 754: p->type, ty); ! 755: p = cast(p, ty); ! 756: } else if (ty != voidtype) { ! 757: error("cast from `%t' to `%t' is illegal\n", ! 758: p->type, ty1); ! 759: ty1 = inttype; ! 760: } ! 761: p = retype(p, ty1); ! 762: if (/* ty != ty1 && generic(p->op) == CNST ! 763: || */ generic(p->op) == INDIR) ! 764: p = tree(RIGHT, ty, 0, p); ! 765: } else ! 766: p = postfix(expr(')')); ! 767: break; ! 768: default: ! 769: p = postfix(primary()); ! 770: } ! 771: return p; ! 772: } ! 773: ! 774: /* primary - parse a primary expression */ ! 775: static Tree primary() { ! 776: Tree p; ! 777: ! 778: switch (t) { ! 779: case ID: ! 780: if (tsym == 0) { ! 781: Symbol q = install(token, &identifiers, level < LOCAL); ! 782: q->src = src; ! 783: t = gettok(); ! 784: if (t == '(') { ! 785: Symbol r; ! 786: q->sclass = EXTERN; ! 787: q->type = func(inttype, (Type *)0, 1); ! 788: if (Aflag >= 1) ! 789: warning("missing prototype\n"); ! 790: (*IR->defsymbol)(q); ! 791: if (r = lookup(q->name, externals)) { ! 792: q->defined = r->defined; ! 793: q->temporary = r->temporary; ! 794: q->generated = r->generated; ! 795: q->computed = r->computed; ! 796: q->addressed = r->addressed; ! 797: } else { ! 798: r = install(q->name, &externals, 1); ! 799: r->src = q->src; ! 800: r->type = q->type; ! 801: r->sclass = EXTERN; ! 802: } ! 803: } else { ! 804: error("undeclared identifier `%s'\n", q->name); ! 805: q->sclass = AUTO; ! 806: q->type = inttype; ! 807: if (q->scope == GLOBAL) ! 808: (*IR->defsymbol)(q); ! 809: else ! 810: addlocal(q); ! 811: } ! 812: if (xref) ! 813: use(q, src); ! 814: return idnode(q); ! 815: } ! 816: if (xref) ! 817: use(tsym, src); ! 818: if (tsym->sclass == ENUM) ! 819: p = constnode(tsym->u.value, inttype); ! 820: else { ! 821: if (tsym->sclass == TYPEDEF) ! 822: error("illegal use of type name `%s'\n", tsym->name); ! 823: p = idnode(tsym); ! 824: } ! 825: break; ! 826: case ICON: case FCON: ! 827: p = tree(CNST + ttob(tsym->type), tsym->type, 0, 0); ! 828: p->u.v = tsym->u.c.v; ! 829: break; ! 830: case SCON: ! 831: tsym->u.c.v.p = stringn(tsym->u.c.v.p, tsym->type->size); ! 832: tsym = constant(tsym->type, tsym->u.c.v); ! 833: if (tsym->u.c.loc == 0) ! 834: tsym->u.c.loc = genident(STATIC, tsym->type, GLOBAL); ! 835: p = idnode(tsym->u.c.loc); ! 836: break; ! 837: case '(': ! 838: t = gettok(); ! 839: return expr(')'); ! 840: default: ! 841: error("illegal expression\n"); ! 842: p = constnode(0, inttype); ! 843: } ! 844: t = gettok(); ! 845: return p; ! 846: } ! 847: ! 848: /* promote - the usual integral promotions */ ! 849: Type promote(ty) Type ty; { ! 850: ty = unqual(ty); ! 851: if (isunsigned(ty) || ty == longtype) ! 852: return ty; ! 853: else if (isint(ty) || isenum(ty)) ! 854: return inttype; ! 855: return ty; ! 856: } ! 857: ! 858: /* right - return (RIGHT, q->type, root(p), q) or just root(p/q) if q/p==0 */ ! 859: Tree right(p, q) Tree p, q; { ! 860: assert(p || q); ! 861: if (p && q) ! 862: return tree(RIGHT, q->type, root(p), q); ! 863: return p ? p : q; ! 864: } ! 865: ! 866: /* rightkid - dereference RIGHT nodes to find ultimate offspring */ ! 867: static Tree rightkid(p) Tree p; { ! 868: while (p && p->op == RIGHT) { ! 869: assert(p->kids[0] || p->kids[1]); ! 870: p = p->kids[1] ? p->kids[1] : p->kids[0]; ! 871: } ! 872: assert(p); ! 873: return p; ! 874: } ! 875: ! 876: /* rvalue - convert p to an rvalue */ ! 877: Tree rvalue(p) Tree p; { ! 878: Type ty = deref(p->type); ! 879: ! 880: ty = unqual(ty); ! 881: return tree(INDIR + (isunsigned(ty) ? I : ttob(ty)), ty, p, 0); ! 882: } ! 883: ! 884: /* value - convert p from a conditional to a value, if necessary */ ! 885: static Tree value(p) Tree p; { ! 886: Opcode op = generic(rightkid(p)->op); ! 887: ! 888: if (op == AND || op == OR || op == NOT || op == EQ || op == NE ! 889: || op == LE || op == LT || op == GE || op == GT) ! 890: p = condnode(p, constnode(1, inttype), constnode(0, inttype)); ! 891: return p; ! 892: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.