Return to field.c CVS log

Up to [CSRG BSD Unix] / 43BSD / usr.bin / efl

Annotation of 43BSD/usr.bin/efl/field.c, revision 1.1.1.1

1.1       root        1: #include "defs"
                      2: 
                      3: 
                      4: 
                      5: ptr mkfield(q)
                      6: register ptr q;
                      7: {
                      8: register ptr p;
                      9: 
                     10: if(!instruct)
                     11:        goto err;
                     12: else if(q->upperb == 0)
                     13:        dclerr("must have upper bound in field spcification", "");
                     14: else
                     15:        {
                     16:        p = ALLOC(fieldspec);
                     17:        p->tag = TFIELD;
                     18:        if(q->lowerb)
                     19:                {
                     20:                p->flbound = q->lowerb;
                     21:                p->frange = mknode(TAROP,OPPLUS,mknode(TAROP,OPMINUS,
                     22:                                q->upperb, cpexpr(q->lowerb)),
                     23:                                mkconst(TYINT,"1") );
                     24:                }
                     25:        else    {
                     26:                p->flbound = mkconst(TYINT,"1");
                     27:                p->frange = q->upperb;
                     28:                }
                     29:        p->frange = simple(RVAL,p->frange);
                     30:        if(p->frange->tag != TCONST)
                     31:                {
                     32:                dclerr("field range must be constant", "");
                     33:                cfree(p);
                     34:                goto err;
                     35:                }
                     36:        cfree(q);
                     37:        return(p);
                     38:        }
                     39: 
                     40: err:
                     41:        cfree(q);
                     42:        return( errnode() );
                     43: }
                     44: 
                     45: 
                     46: 
                     47: 
                     48: 
                     49: ptr extrfield(p)
                     50: register ptr p;
                     51: {
                     52: register ptr t;
                     53: 
                     54: t = p->vtypep;
                     55: p->vtype = TYINT;
                     56: p->vtypep = 0;
                     57: 
                     58: if(t->frshift)
                     59:        p = mknode(TAROP,OPSLASH, p, cpexpr(t->frshift));
                     60: if(t->fanymore)
                     61:        p = mkcall(builtin(TYINT, "mod"), arg2(p, cpexpr(t->frange)) );
                     62: p = mknode(TAROP,OPPLUS, p, cpexpr(t->flbound));
                     63: return(p);
                     64: }
                     65: 
                     66: 
                     67: 
                     68: 
                     69: ptr setfield(e)
                     70: ptr e;
                     71: {
                     72: ptr lp, rp;
                     73: register ptr f, p;
                     74: int subt;
                     75: 
                     76: lp = cpexpr(e->leftp);
                     77: rp = e->rightp;
                     78: subt = e->subtype;
                     79: f = lp->vtypep;
                     80: lp->vtype = TYINT;
                     81: lp->vtypep = 0;
                     82: 
                     83: if(subt==OPPLUS || subt==OPMINUS)
                     84:        {
                     85:        if(f->frshift)
                     86:                rp = mknode(TAROP,OPSTAR,rp,cpexpr(f->frshift));
                     87:        }
                     88: else   {
                     89:        if(subt != OPASGN)
                     90:                {
                     91:                rp = mknode(TAROP,subt, extrfield(cpexpr(e->leftp)), rp);
                     92:                subt = OPASGN;
                     93:                }
                     94:        rp = coerce(TYINT,rp);
                     95:        if(f->flbound)
                     96:                rp = simple(RVAL, mknode(TAROP,OPMINUS,rp,cpexpr(f->flbound)) );
                     97:        
                     98:        if(f->frshift==0)
                     99:                {
                    100:                if(f->fanymore)
                    101:                        {
                    102:                        p = mknode(TAROP,OPSLASH,cpexpr(lp),cpexpr(f->frange));
                    103:                        p->needpar = YES;
                    104:                        p = mknode(TAROP,OPSTAR,cpexpr(f->frange),p);
                    105:                        rp = mknode(TAROP,OPPLUS,p,rp);
                    106:                        }
                    107:                }
                    108:        else if(f->fanymore==0)
                    109:                {
                    110:                rp = mknode(TAROP,OPSTAR,cpexpr(f->frshift),rp);
                    111:                p = mkcall(builtin(TYINT,"mod"),
                    112:                        arg2(cpexpr(lp),cpexpr(f->frshift)) );
                    113:                rp = mknode(TAROP,OPPLUS, p,rp);
                    114:                }
                    115:        else    {
                    116:                p = mknode(TAROP,OPSLASH,cpexpr(lp),cpexpr(f->frshift));
                    117:                p = mkcall(builtin(TYINT,"mod"), 
                    118:                        arg2(p, cpexpr(f->frange)) );
                    119:                if( rp->tag!=TCONST || !equals(rp->leftp, "0") )
                    120:                        p = mknode(TAROP,OPMINUS, p, rp);
                    121:                rp = mknode(TAROP,OPSTAR, cpexpr(f->frshift), p);
                    122:                rp = mknode(TAROP,OPMINUS, cpexpr(lp), rp);
                    123:                }
                    124:        }
                    125: frexpr( simple(LVAL, mknode(TASGNOP,subt,lp,rp) ));
                    126: return(extrfield(e->leftp));
                    127: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.