![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to trace.expr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / trace|
Return to trace.expr.c CVS log | Up to [Research Unix] / researchv10no / cmd / trace |
1.1 root 1: #include <stdio.h>
2: #include <math.h>
3: #include "trace.h"
4: #include "trace.d"
5:
6: #define DEBUG 0
7:
8: #define setv 1
9: #define addeq 2
10: #define subeq 3
11: #define muleq 4
12: #define diveq 5
13: #define modeq 6
14: #define plus 7
15: #define minus 8
16: #define times 9
17: #define div 10
18: #define mod 11
19: #define power 12
20: #define uminus 13
21: #define gt 14
22: #define lt 15
23: #define ge 16
24: #define le 17
25: #define eq 18
26: #define ne 19
27: #define land 20
28: #define lor 21
29: #define lnot 22
30: #define princ 23
31: #define prdec 24
32: #define poinc 25
33: #define podec 26
34:
35: #define OP 0
36: #define NM 1
37:
38: #define unary(c) (c == uminus || c == lnot || c >= princ)
39: #define binary(c) !unary(c)
40:
41: extern struct REVPOL **expr;
42: extern int nexpr, nrvars, *globvars;
43: extern struct VARPARS *procpars;
44:
45: struct REVPOL *rev;
46: int curproc, revp;
47:
48: struct {
49: char how;
50: short whichvar;
51: short oldvalue;
52: } storewhere;
53:
54: evalexpr(n, pr, b)
55: struct FREEZE *b;
56: { int i;
57: if (n == NONE)
58: return 0;
59: if (n < 0 || n >= nexpr)
60: whoops("unknown expression");
61:
62: rev = expr[n];
63: revp = 0;
64: curproc = pr;
65: storewhere.how = 0;
66:
67: if ((i = getval()) < 0)
68: i += 3*MANY;
69: else
70: i -= 3*MANY; /* should return stripped constant */
71: #if DEBUG
72: fprintf(stderr, "evaluated expr %d, process %d, result %d\n", n, pr, i);
73: #endif
74:
75: b->whichvar = storewhere.whichvar;
76: b->oldvalue = storewhere.oldvalue;
77:
78: return storewhere.how;
79: }
80:
81: evalcond(n, pr)
82: { int i;
83: if (n < 0 || n >= nexpr)
84: { fprintf(stderr, "%d\n", n);
85: whoops("unknown expression - evalcond");
86: }
87:
88: rev = expr[n];
89: revp = 0;
90: curproc = pr;
91: storewhere.how = 0;
92:
93: if ((i = getval()) < 0)
94: i += 3*MANY;
95: else
96: i -= 3*MANY; /* should return stripped constant */
97: #if DEBUG
98: fprintf(stderr, "evaluated cond %d, process %d, result %d\n", n, pr, i);
99: #endif
100: if (storewhere.how != 0)
101: whoops("illegal assignment in expression");
102:
103: return i;
104: }
105:
106: unoper(c, n)
107: { int i = convert(n, curproc);
108: switch (c)
109: { case uminus: return (-i);
110: case lnot : return (!i);
111: case princ : remem(n); setvar(n, i+1); return i;
112: case prdec : remem(n); setvar(n, i-1); return i;
113: case poinc : remem(n); return setvar(n, i+1);
114: case podec : remem(n); return setvar(n, i-1);
115: default : whoops("unknown unary operator");
116: }
117: }
118:
119: bioper(c, n, m)
120: { int i, j;
121: double a, b;
122:
123: if (c != setv)
124: i = convert(n, curproc);
125: j = convert(m, curproc);
126: switch (c)
127: { case setv: remem(n); return setvar(n, j);
128: case addeq: remem(n); return setvar(n, i+j);
129: case subeq: remem(n); return setvar(n, i-j);
130: case muleq: remem(n); return setvar(n, i*j);
131: case diveq: remem(n); return setvar(n, i/j);
132: case modeq: remem(n); return setvar(n, i%j);
133: case plus: return (i+j);
134: case minus: return (i-j);
135: case times: return (i*j);
136: case div: return (i/j);
137: case mod: return (i%j);
138: case gt : return (i>j);
139: case lt : return (i<j);
140: case ge : return (i>=j);
141: case le : return (i<=j);
142: case eq : return (i==j);
143: case ne : return (i!=j);
144: case land: return (i&&j);
145: case lor: return (i||j);
146: default: whoops("unkown binary operator");
147: }
148: }
149:
150: getval()
151: { int tok = revp++;
152: int res;
153:
154: if (rev[tok].toktyp == NM)
155: res = rev[tok].tokval;
156: else
157: { if (unary(rev[tok].tokval))
158: res = unoper(rev[tok].tokval, getval());
159: else
160: res = bioper(rev[tok].tokval, getval(), getval());
161:
162: if (res < 0)
163: res -= 3*MANY;
164: else
165: res += 3*MANY;
166: }
167:
168: return res;
169: }
170:
171: setvar(which, v)
172: { int u = wapper(which, curproc);
173: int towhat = v;
174:
175: if (u >= 2*MANY || u < 0)
176: whoops("lhs of assignment not a variable");
177:
178: if (u < MANY)
179: { if (u >= nrvars)
180: { fprintf(stderr, "setvar %d %d %d\n", which, v, u);
181: whoops("illegal assignment");
182: }
183:
184: globvars[u] = (short) towhat;
185: }
186: else
187: { u -= MANY;
188: if (u >= (int) procpars[curproc].nrlvars)
189: whoops("unknown local variable");
190: procpars[curproc].lvarvals[u] = (short) towhat;
191: }
192:
193: return towhat;
194: }
195:
196: remem(u)
197: { if (storewhere.how != 0)
198: whoops("multiple assignment in expression");
199:
200: if (u < MANY)
201: {
202: #if DEBUG
203: fprintf(stderr, "setting global %d\n", u);
204: #endif
205: storewhere.whichvar = (short) u;
206: storewhere.oldvalue = globvars[u];
207: storewhere.how = GV;
208: }
209: else
210: { storewhere.whichvar = (short) u;
211:
212: u -= MANY;
213: #if DEBUG
214: fprintf(stderr, "setting local %d\n", u);
215: #endif
216: storewhere.oldvalue = procpars[curproc].lvarvals[u];
217: storewhere.how = LV;
218: }
219: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.