![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to eval.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 eval.c CVS log | Up to [Research Unix] / researchv10no / cmd / lcc / c |
1.1 root 1: /* C compiler & debugger: expression evaluation */
2:
3: #include "c.h"
4:
5: typedef struct {
6: Tree p; /* associated tree */
7: Value r; /* the register */
8: } Register;
9: static char *errcode; /* evaluation error string */
10: static int nextr;
11: static Register regs[30];
12:
13: dclproto(static Value *eval,(Tree))
14: dclproto(static Value *treereg,(Tree))
15:
16: /* evaluate - evaluate tree p */
17: Symbol evaluate(p) Tree p; {
18: static struct symbol sym;
19:
20: nextr = 1;
21: errcode = 0;
22: sym.u.c.v = *eval(p);
23: if (errcode)
24: return 0;
25: sym.type = p->type;
26: return &sym;
27: }
28:
29: /* eval - recursively evaluate tree p, return allocated register */
30: static Value *eval(p) Tree p; {
31: Value *r, *r1 = 0, *r2 = 0;
32: Tree left, right;
33:
34: if (r = treereg(p))
35: return r;
36: if (nextr > sizeof regs/sizeof regs[0]) {
37: error("expression too complicated\n");
38: return ®s[0].r;
39: }
40: regs[nextr].p = p;
41: r = ®s[nextr++].r;
42: switch (generic(p->op)) { /* control flow operators */
43: case AND:
44: r1 = eval(p->kids[0]);
45: if (r1->i)
46: r1 = eval(p->kids[1]);
47: r->i = r1->i;
48: return r;
49: case COND:
50: r = eval(p->kids[0]);
51: r1 = eval(p->kids[r->i ? 1 : 2]);
52: *r = *r1;
53: return r;
54: case NOT:
55: r1 = eval(p->kids[0]);
56: r->i = !r1->i;
57: return r;
58: case OR:
59: r1 = eval(p->kids[0]);
60: if (r1->i == 0)
61: r1 = eval(p->kids[1]);
62: r->i = r1->i;
63: return r;
64: }
65: if (left = p->kids[0])
66: r1 = eval(left);
67: if (right = p->kids[1])
68: r2 = eval(right);
69: switch (p->op) {
70: case ADD+D: r->d = r1->d + r2->d; break;
71: case ADD+F: r->f = r1->f + r2->f; break;
72: case ADD+I: r->i = r1->i + r2->i; break;
73: case ADD+P:
74: if (isptr(left->type))
75: r->s = r1->s + r2->i;
76: else
77: r->s = r1->i + r2->s;
78: break;
79: case ADD+U: r->u = r1->u + r2->u; break;
80: case ADDRF+P:
81: case ADDRG+P:
82: case ADDRL+P: goto bad;
83: case ARG+B:
84: case ARG+C:
85: case ARG+D:
86: case ARG+F:
87: case ARG+I:
88: case ARG+P:
89: case ARG+S: goto bad;
90: case ASGN+B:
91: case ASGN+C:
92: case ASGN+D:
93: case ASGN+F:
94: case ASGN+I:
95: case ASGN+P:
96: case ASGN+S: goto bad;
97: case BAND+I: r->i = r1->i&r2->i; break;
98: case BAND+U: r->u = r1->u&r2->u; break;
99: case BCOM+U: r->u = ~r1->u; break;
100: case BOR+I: r->i = r1->i|r2->i; break;
101: case BOR+U: r->u = r1->u|r2->u; break;
102: case BXOR+I: r->i = r1->i^r2->i; break;
103: case BXOR+U: r->u = r1->u^r2->u; break;
104: case CALL+B:
105: case CALL+D:
106: case CALL+F:
107: case CALL+I:
108: case CALL+V: goto bad;
109: case CNST+C:
110: case CNST+D:
111: case CNST+F:
112: case CNST+I:
113: case CNST+P:
114: case CNST+S:
115: case CNST+U: *r = p->u.v; break;
116: case CVC+I: r->i = r1->sc; break;
117: case CVC+U: r->u = r1->uc; break;
118: case CVD+F: r->f = r1->d; break;
119: case CVD+I: r->i = r1->d; break;
120: case CVD+U: r->u = r1->d; break;
121: case CVF+D: r->d = r1->f; break;
122: case CVI+C: r->sc = r1->i; break;
123: case CVI+D: r->d = r1->i; break;
124: case CVI+S: r->ss = r1->i; break;
125: case CVI+U: r->u = r1->i; break;
126: case CVP+U: r->u = (unsigned)r1->p; break;
127: case CVS+I: r->i = r1->ss; break;
128: case CVS+U: r->u = r1->us; break;
129: case CVU+C: r->uc = r1->u; break;
130: case CVU+D: r->d = r1->u; break;
131: case CVU+I: r->i = r1->u; break;
132: case CVU+P: r->p = (char *)r1->u; break;
133: case CVU+S: r->us = r1->u; break;
134: case DIV+D:
135: if (r2->d == 0.0)
136: errcode = "division by 0.0";
137: else
138: r->d = r1->d/r2->d;
139: break;
140: case DIV+F:
141: if (r2->f == 0.0)
142: errcode = "division by 0";
143: else
144: r->f = r1->f/r2->f;
145: break;
146: case DIV+I:
147: if (r2->i == 0)
148: errcode = "division by 0";
149: else
150: r->i = r1->i/r2->i;
151: break;
152: case DIV+U:
153: if (r2->u == 0)
154: errcode = "division by 0";
155: else
156: r->u = r1->u/r2->u;
157: break;
158: case EQ+D: r->i = r1->d == r2->d; break;
159: case EQ+F: r->i = r1->f == r2->f; break;
160: case EQ+I: r->i = r1->i == r2->i; break;
161: case EQ+U: r->i = r1->u == r2->u; break;
162: case FIELD: goto bad;
163: case GE+D: r->i = r1->d >= r2->d; break;
164: case GE+F: r->i = r1->f >= r2->f; break;
165: case GE+I: r->i = r1->i >= r2->i; break;
166: case GE+U: r->i = r1->u >= r2->u; break;
167: case GT+D: r->i = r1->d > r2->d; break;
168: case GT+F: r->i = r1->f > r2->f; break;
169: case GT+I: r->i = r1->i > r2->i; break;
170: case GT+U: r->i = r1->u > r2->u; break;
171: case INDIR+B:
172: case INDIR+C:
173: case INDIR+D:
174: case INDIR+F:
175: case INDIR+I:
176: case INDIR+P:
177: case INDIR+S: goto bad;
178: case JUMP+V:
179: fatal("eval", "unexpected %s operator\n", "JUMP+V");
180: case LE+D: r->i = r1->d <= r2->d; break;
181: case LE+F: r->i = r1->f <= r2->f; break;
182: case LE+I: r->i = r1->i <= r2->i; break;
183: case LE+U: r->i = r1->u <= r2->u; break;
184: case LSH+I: r->i = r1->i<<r2->i; break;
185: case LSH+U: r->u = r1->u<<r2->u; break;
186: case LT+D: r->i = r1->d < r2->d; break;
187: case LT+F: r->i = r1->f < r2->f; break;
188: case LT+I: r->i = r1->i < r2->i; break;
189: case LT+U: r->i = r1->u < r2->u; break;
190: case MOD+I:
191: if (r2->i == 0)
192: errcode = "division by 0";
193: else
194: r->i = r1->i%r2->i;
195: break;
196: case MOD+U:
197: if (r2->u == 0)
198: errcode = "division by 0";
199: else
200: r->u = r1->u%r2->u;
201: break;
202: case MUL+D: r->d = r1->d*r2->d; break;
203: case MUL+F: r->f = r1->f*r2->f; break;
204: case MUL+I: r->i = r1->i*r2->i; break;
205: case MUL+U: r->u = r1->u*r2->u; break;
206: case NE+D: r->i = r1->d != r2->d; break;
207: case NE+F: r->i = r1->f != r2->f; break;
208: case NE+I: r->i = r1->i != r2->i; break;
209: case NE+U: r->i = r1->u != r2->i; break;
210: case NEG+D: r->d = -r1->d; break;
211: case NEG+F: r->f = -r1->f; break;
212: case NEG+I: r->i = -r1->i; break;
213: case RET+B:
214: case RET+D:
215: case RET+F:
216: case RET+I:
217: case RET+V: goto bad;
218: case RIGHT: r->d = r2->d; break;
219: case RSH+I: r->i = r1->i>>r2->i; break;
220: case RSH+U: r->u = r1->u>>r2->u; break;
221: case SUB+D: r->d = r1->d - r2->d; break;
222: case SUB+F: r->f = r1->f - r2->f; break;
223: case SUB+I: r->i = r1->i - r2->i; break;
224: case SUB+P: r->i = r1->s - r2->s; break;
225: case SUB+U: r->u = r1->u - r2->u; break;
226: default: bad:
227: fatal("eval", "unknown operator %d\n", p->op);
228: }
229: return r;
230: }
231:
232: /* treereg - return register associated with tree p or 0 */
233: static Value *treereg(p) Tree p; {
234: int i;
235:
236: for (i = 0; i < nextr; i++)
237: if (regs[i].p == p)
238: return ®s[i].r;
239: return 0;
240: }
241:
242: /* vtoa - return string for the constant v of type ty */
243: char *vtoa(ty, v) Type ty; Value v; {
244: static char buf[MAXLINE];
245:
246: ty = unqual(ty);
247: switch (ty->op) {
248: case CHAR:
249: sprint(buf, "%d", v.uc);
250: break;
251: case SHORT:
252: sprint(buf, "%d", v.ss);
253: break;
254: case INT:
255: sprint(buf, "%d", v.i);
256: break;
257: case UNSIGNED:
258: if ((v.u&~0x7fff) == 0)
259: sprint(buf, "%d", v.u);
260: else
261: sprint(buf, "0x%x", v.u);
262: break;
263: case FLOAT:
264: if (v.f == 0.0)
265: return "0";
266: sprintf(buf, "%.*g", 8, v.f);
267: break;
268: case DOUBLE:
269: if (v.d == 0.0)
270: return "0";
271: sprintf(buf, "%.*g", 18, v.d);
272: break;
273: case ARRAY:
274: if (ty->type->op == CHAR)
275: return v.s;
276: /* else fall thru */
277: case POINTER: case FUNCTION:
278: if (((unsigned)v.p&~0x7fff) == 0)
279: sprint(buf, "%d", v.p);
280: else
281: sprint(buf, "0x%x", v.p);
282: break;
283: default:
284: assert(0);
285: }
286: return buf;
287: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.