Return to trace.expr.c CVS log

Up to [Research Unix] / researchv8dc / cmd / trace

Annotation of researchv8dc/cmd/trace/trace.expr.c, revision 1.1

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.