![[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.