![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to enode.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 enode.c CVS log | Up to [Research Unix] / researchv10no / cmd / lcc / c |
1.1 root 1: /* C compiler: type-checking and tree construction for expressions */
2:
3: #include "c.h"
4:
5: dclproto(static Tree addnode,(int, Tree, Tree));
6: dclproto(static Tree andnode,(int, Tree, Tree));
7: dclproto(static Type binary,(Type, Type));
8: dclproto(static Tree cmpnode,(int, Tree, Tree));
9: dclproto(static int compatible,(Type, Type));
10: dclproto(static Tree mulnode,(int, Tree, Tree));
11: dclproto(static Tree subnode,(int, Tree, Tree));
12:
13: dclproto(Tree (*opnode[]),(int, Tree, Tree)) = {
14: #define xx(a,b,c,d,e,f,g) e,
15: #include "token.h"
16: };
17:
18: /* addnode - construct tree for l + r */
19: static Tree addnode(op, l, r) Tree l, r; {
20: int n;
21: Type ty = inttype;
22:
23: if (isarith(l->type) && isarith(r->type)) {
24: ty = binary(l->type, r->type);
25: l = cast(l, ty);
26: r = cast(r, ty);
27: } else if (isptr(l->type) && isint(r->type))
28: return addnode(ADD, r, l);
29: else if (isptr(r->type) && isint(l->type)) {
30: ty = unqual(r->type);
31: if ((n = ty->type->size) == 0)
32: error("unknown size of type `%t'\n", ty->type);
33: l = cast(l, promote(l->type));
34: if (n > 1)
35: l = mulnode(MUL, constnode(n, inttype), l);
36: return simplify(ADD+P, ty, l, r);
37: } else
38: typeerror(op, l, r);
39: return simplify(op, ty, l, r);
40: }
41:
42: /* andnode - construct tree for l [&& ||] r */
43: static Tree andnode(op, l, r) Tree l, r; {
44: if (!isscalar(l->type) || !isscalar(r->type))
45: typeerror(op, l, r);
46: return simplify(op, inttype, cond(l), cond(r));
47: }
48:
49: /* asgnnode - construct tree for l = r */
50: Tree asgnnode(op, l, r) Tree l, r; {
51: Type aty, ty;
52:
53: r = pointer(r);
54: if ((ty = assign(l->type, r)) == 0) {
55: typeerror(ASGN, l, r);
56: if (r->type == voidtype)
57: r = retype(r, inttype);
58: ty = r->type;
59: }
60: if (l->op != FIELD)
61: l = lvalue(l);
62: aty = l->type;
63: if (isptr(aty))
64: aty = unqual(aty)->type;
65: if (isconst(aty) || (isstruct(aty) && unqual(aty)->u.sym->u.s.cfields))
66: if (isaddrop(l->op) && !l->u.sym->computed && !l->u.sym->generated)
67: error("assignment to const identifier `%s'\n", l->u.sym->name);
68: else
69: error("assignment to const location\n");
70: r = cast(r, ty);
71: if (l->op == FIELD && fieldsize(l->u.field) < 8*l->u.field->type->size)
72: if (isunsigned(l->u.field->type))
73: r = bitnode(BAND, r,
74: constnode(fieldmask(l->u.field), unsignedtype));
75: else {
76: int n = 8*l->u.field->type->size - fieldsize(l->u.field);
77: /*
78: * The value of assignment is the value of the left
79: * operand (sec. 3.3.16), which for bit fields is the
80: * same as extracting the field. When r is a constant,
81: * the explicit left shift below avoids overflow that
82: * would occur if shnode(LSH, ...) were used. The
83: * subsequent shnode(RSH, ...) will be signed and thus
84: * extend the sign bit correctly.
85: */
86: if (r->op == CNST+I)
87: r = constnode(r->u.v.i<<n, inttype);
88: else
89: r = shnode(LSH, r, constnode(n, inttype));
90: r = shnode(RSH, r, constnode(n, inttype));
91: }
92: if (isstruct(ty)) {
93: if (r->op == RIGHT && r->kids[0] && r->kids[0]->op == CALL+B
94: && isaddrop(l->op)) {
95: /*
96: * When x=f() where f returns a struct and x is a simple
97: * address, release the temporary generated to hold f's
98: * return value and use x in its place. The RIGHT tree
99: * assigned to r below returns x's address, and
100: * rvalue(r) hangs that tree under an INDIR+B,
101: * thus identifying the result as an lvalue.
102: */
103: r = r->kids[0]; /* CALL+B node */
104: release(r->kids[1]->u.sym);
105: r = tree(RIGHT, l->type,
106: tree(CALL+B, r->kids[0]->type, r->kids[0], l),
107: retype(isarray(l->u.sym->type) ? idnode(l->u.sym) : addrof(idnode(l->u.sym)), l->type));
108: return rvalue(r);
109: }
110: return tree(ASGN+B, ty, l, r);
111: }
112: return tree(op + (isunsigned(ty) ? I : ttob(ty)), ty, l, r);
113: }
114:
115: /* binary - usual arithmetic conversions, return target type */
116: static Type binary(xty, yty) Type xty, yty; {
117: if (isdouble(xty) || isdouble(yty))
118: return doubletype;
119: if (xty == floattype || yty == floattype)
120: return floattype;
121: if (isunsigned(xty) || isunsigned(yty))
122: return unsignedtype;
123: return inttype;
124: }
125:
126: /* bitnode - construct tree for l [& | ^ %] r */
127: Tree bitnode(op, l, r) Tree l, r; {
128: Type ty = inttype;
129:
130: if (isint(l->type) && isint(r->type)) {
131: ty = binary(l->type, r->type);
132: l = cast(l, ty);
133: r = cast(r, ty);
134: if (op != MOD) {
135: l = cast(l, unsignedtype);
136: r = cast(r, unsignedtype);
137: }
138: } else
139: typeerror(op, l, r);
140: if (op == MOD)
141: return simplify(op, ty, l, r);
142: return cast(simplify(op, unsignedtype, l, r), ty);
143: }
144:
145: /* callnode - construct call node to f, return type ty, arguments args */
146: Tree callnode(f, ty, args) Tree f, args; Type ty; {
147: Tree p;
148:
149: if (args)
150: f = tree(RIGHT, f->type, args, f);
151: if (isstruct(ty)) {
152: Symbol t1 = temporary(AUTO, unqual(ty));
153: if (ty->size == 0)
154: error("illegal use of incomplete type `%t'\n", ty);
155: p = tree(RIGHT, ty, tree(CALL+B, ty, f, lvalue(idnode(t1))),
156: idnode(t1));
157: } else {
158: Type rty = ty;
159: if (isenum(ty))
160: rty = unqual(ty)->type;
161: else if (isptr(ty))
162: rty = unsignedtype;
163: p = tree(CALL + widen(rty), rty, f, 0);
164: if (isptr(ty))
165: p = cast(p, ty);
166: }
167: return p;
168: }
169:
170: /* cmpnode - construct tree for l [< <= >= >] r */
171: static Tree cmpnode(op, l, r) Tree l, r; {
172: Type ty = unsignedtype;
173:
174: if (isarith(l->type) && isarith(r->type)) {
175: ty = binary(l->type, r->type);
176: l = cast(l, ty);
177: r = cast(r, ty);
178: } else if (compatible(l->type, r->type)) {
179: l = cast(l, ty);
180: r = cast(r, ty);
181: } else
182: typeerror(op, l, r);
183: return simplify(op + ttob(ty), inttype, l, r);
184: }
185:
186: /* compatible - are ty1 & ty2 sans qualifiers pointers to compatible object or incomplete types? */
187: static int compatible(ty1, ty2) Type ty1, ty2; {
188: if (isptr(ty1) && !isfunc(ty1->type) && isptr(ty2) && !isfunc(ty2->type)) {
189: do {
190: ty1 = unqual(ty1->type);
191: ty2 = unqual(ty2->type);
192: } while (isptr(ty1) && isptr(ty2));
193: return eqtype(ty1, ty2, 0);
194: }
195: return 0;
196: }
197:
198: /* condnode - build a tree for e ? l : r */
199: Tree condnode(e, l, r) Tree e, l, r; {
200: Symbol t1 = 0;
201: Type ty = 0, lty = l->type, rty = r->type;
202: Tree p;
203:
204: if (isarith(lty) && isarith(rty)) {
205: ty = binary(lty, rty);
206: l = cast(l, ty);
207: r = cast(r, ty);
208: } else if (eqtype(lty, rty, 1)
209: || isptr(lty) && isint(rty) && assign(lty, r))
210: ty = unqual(lty);
211: else if (isptr(rty) && isint(lty) && assign(rty, l))
212: ty = unqual(rty);
213: else if (isptr(lty) && isptr(rty)) {
214: lty = lty->type;
215: rty = rty->type;
216: if (unqual(lty) == voidtype || unqual(rty) == voidtype)
217: ty = voidtype;
218: else if (eqtype(unqual(lty), unqual(rty), 1))
219: ty = unqual(lty);
220: if (ty) {
221: if (isconst(lty) || isconst(rty))
222: ty = qual(CONST, ty);
223: if (isvolatile(lty) || isvolatile(rty))
224: ty = qual(VOLATILE, ty);
225: ty = ptr(ty);
226: }
227: }
228: if (ty == 0) {
229: typeerror(COND, l, r);
230: ty = inttype;
231: } else if (e->op == CNST+D || e->op == CNST+F) {
232: e = cast(e, doubletype);
233: return retype(e->u.v.d != 0.0 ? l : r, ty);
234: } else if (generic(e->op) == CNST) {
235: e = cast(e, unsignedtype);
236: return retype(e->u.v.u ? l : r, ty);
237: } else if (ty != voidtype && ty->size > 0) {
238: Opcode op = generic(e->op);
239: t1 = temporary(REGISTER, ty);
240: l = root(asgn(t1, l));
241: if (op != AND && op != OR && op != NOT && op != EQ && op != NE
242: && op != LE && op != LT && op != GE && op != GT && op != RIGHT
243: && r->op == CNST+I && r->u.v.i == 0
244: && assign(e->type, r)) {
245: /* e1?e2:0 => ((t1=e1,t1)?(t1=e2): ) */
246: e = tree(RIGHT, ty, asgn(t1, cast(e, ty)), idnode(t1));
247: r = 0;
248: } else
249: r = root(asgn(t1, r));
250: }
251: p = tree(COND, ty, cond(e), tree(RIGHT, ty, l, r));
252: p->u.sym = t1;
253: return p;
254: }
255:
256: /* constnode - return a tree for a constant n of type ty (int or unsigned) */
257: Tree constnode(n, ty) unsigned n; Type ty; {
258: Tree p;
259:
260: if (isarray(ty))
261: p = tree(CNST+P, atop(ty), 0, 0);
262: else
263: p = tree(CNST + ttob(ty), ty, 0, 0);
264: p->u.v.u = n;
265: return p;
266: }
267:
268: /* eqnode - construct tree for l [== !=] r */
269: Tree eqnode(op, l, r) Tree l, r; {
270: if (isint(l->type) && isptr(r->type))
271: return eqnode(op, r, l);
272: if (isptr(l->type) && isint(r->type)) {
273: l = cast(l, unsignedtype);
274: r = cast(r, unsignedtype);
275: if (r->op != CNST+U || r->u.v.u)
276: error("operands of %s have incompatible types\n",
277: op == EQ ? "==" : "!=");
278: return simplify(op + U, inttype, l, r);
279: }
280: if (isptr(l->type) && isptr(r->type) && eqtype(unqual(l->type), unqual(r->type), 1)
281: || isptr(l->type) && !isfunc(l->type->type)
282: && (isptr(r->type) && unqual(r->type->type) == voidtype)
283: || isptr(r->type) && !isfunc(r->type->type)
284: && (isptr(l->type) && unqual(l->type->type) == voidtype)) {
285: l = cast(l, unsignedtype);
286: r = cast(r, unsignedtype);
287: return simplify(op + U, inttype, l, r);
288: }
289: return cmpnode(op, l, r);
290: }
291:
292: /* mulnode - construct tree for l [* /] r */
293: static Tree mulnode(op, l, r) Tree l, r; {
294: Type ty = inttype;
295:
296: if (isarith(l->type) && isarith(r->type)) {
297: ty = binary(l->type, r->type);
298: l = cast(l, ty);
299: r = cast(r, ty);
300: } else
301: typeerror(op, l, r);
302: return simplify(op, ty, l, r);
303: }
304:
305: /* shnode - construct tree for l [>> <<] r */
306: Tree shnode(op, l, r) Tree l, r; {
307: Type ty = inttype;
308:
309: if (isint(l->type) && isint(r->type)) {
310: ty = promote(l->type);
311: l = cast(l, ty);
312: r = cast(r, inttype);
313: } else
314: typeerror(op, l, r);
315: return simplify(op, ty, l, r);
316: }
317:
318: /* subnode - construct tree for l - r */
319: static Tree subnode(op, l, r) Tree l, r; {
320: int n;
321: Type ty = inttype;
322:
323: if (isarith(l->type) && isarith(r->type)) {
324: ty = binary(l->type, r->type);
325: l = cast(l, ty);
326: r = cast(r, ty);
327: } else if (isptr(l->type) && !isfunc(l->type->type) && isint(r->type)) {
328: ty = unqual(l->type);
329: if ((n = ty->type->size) == 0)
330: error("unknown size of type `%t'\n", ty->type);
331: r = cast(r, promote(r->type));
332: if (n > 1)
333: r = mulnode(MUL, constnode(n, inttype), r);
334: return simplify(SUB+P, ty, l, r);
335: } else if (compatible(l->type, r->type)) {
336: if ((n = deref(l->type)->size) == 0)
337: error("unknown size of type `%t'\n", deref(l->type));
338: l = simplify(SUB+U, unsignedtype, cast(l, unsignedtype),
339: cast(r, unsignedtype));
340: return simplify(DIV+I, inttype, cast(l, inttype), constnode(n, inttype));
341: } else
342: typeerror(op, l, r);
343: return simplify(op, ty, l, r);
344: }
345:
346: /* typeerror - issue "operands of op have illegal types `l' and `r'" */
347: void typeerror(op, l, r) Tree l, r; {
348: int i;
349: static struct { Opcode op; char *name; } ops[] = {
350: ASGN, "=", INDIR, "*", NEG, "-",
351: ADD, "+", SUB, "-", LSH, "<<",
352: MOD, "%", RSH, ">>", BAND, "&",
353: BCOM, "~", BOR, "|", BXOR, "^",
354: DIV, "/", MUL, "*", EQ, "==",
355: GE, ">=", GT, ">", LE, "<=",
356: LT, "<", NE, "!=", AND, "&&",
357: NOT, "!", OR, "||", COND, "?:",
358: 0, 0
359: };
360:
361: op = generic(op);
362: for (i = 0; ops[i].op; i++)
363: if (op == ops[i].op)
364: break;
365: assert(ops[i].name);
366: if (r)
367: error("operands of %s have illegal types `%t' and `%t'\n",
368: ops[i].name, l->type, r->type);
369: else
370: error("operand of unary %s has illegal type `%t'\n", ops[i].name,
371: l->type);
372: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.