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