Return to prepass.c CVS log

Up to [Research Unix] / researchv10no / cmd / ccom / common

Annotation of researchv10no/cmd/ccom/common/prepass.c, revision 1.1

1.1     ! root        1: /* prepass tries to turn the trees into basic blocks */
        !             2: /* eventually this is where p2compile will be */
        !             3: #include "mfile2.h"
        !             4: NODE *dup(), *chng1(), *seq(), *buildtree(), *dlabel();
        !             5: 
        !             6: NODE *
        !             7: prepass(p)
        !             8: NODE *p;
        !             9: {      int o;
        !            10:        NODE *r, *l;
        !            11:        if(!p)
        !            12:                return(p);
        !            13:        o = p->in.op;
        !            14:        if(o == ASSIGN && (r = p->in.right)->in.op == QUEST) {
        !            15:                if((l = p->in.left)->in.op == SNODE || l->in.op == RNODE)
        !            16:                        return(p);
        !            17:                p = chng1(p);
        !            18:        }
        !            19:        return(p);              
        !            20: }
        !            21: /* =(x ?(t :(a b))) -> (cbranch t l0), l0(jbr l1 =(x a)), l1(=(x b) */
        !            22: NODE *
        !            23: chng1(p)
        !            24: NODE *p;
        !            25: {      NODE *t, *a, *b, *x, *c1, *c2, *u, *v;
        !            26:        int l0, l1;
        !            27:        t = p->in.right->in.left;
        !            28:        a = p->in.right->in.right->in.left;
        !            29:        b = p->in.right->in.right->in.right;
        !            30:        x = p->in.left;
        !            31:        l0 = getlab();
        !            32:        l1 = getlab();
        !            33:        u = dup(p);
        !            34:        u->in.left = dup(x);
        !            35:        u->in.right = b;
        !            36:        v = dup(p);
        !            37:        v->in.left = dup(x);
        !            38:        v->in.right = a;
        !            39:        c2 = seq(dlabel(genbr(0, l1, v), l0), dlabel(u, l1));
        !            40:        c1 = seq(buildtree(CBRANCH, t, bcon(l0)), c2);
        !            41:        p->in.op = x->in.op = FREE;
        !            42:        p->in.right->in.op = p->in.right->in.right->in.op = FREE;
        !            43:        return(c1);
        !            44: }
        !            45: 
        !            46: NODE *
        !            47: dup(p)
        !            48: NODE *p;
        !            49: {      NODE *t;
        !            50:        t = talloc();
        !            51:        *t = *p;
        !            52:        return(t);
        !            53: }

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