Return to mapvar.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ingres / source / decomp

Annotation of 42BSD/ingres/source/decomp/mapvar.c, revision 1.1

1.1     ! root        1: # include      <ingres.h>
        !             2: # include      <aux.h>
        !             3: # include      <tree.h>
        !             4: # include      <symbol.h>
        !             5: # include      <sccs.h>
        !             6: 
        !             7: SCCSID(@(#)mapvar.c    7.1     2/5/81)
        !             8: 
        !             9: /*
        !            10: **     MAPVAR -- construct variable maps for ROOT, AND, and AGHEAD nodes.
        !            11: **     tl is a flag  which indicates if the target list should
        !            12: **     be included in the mapping.  If tl = 0, it should; else it should not.
        !            13: **
        !            14: **     Trace Flags:
        !            15: **             52
        !            16: */
        !            17: 
        !            18: mapvar(t, tl)
        !            19: register QTREE *t;
        !            20: int            tl;
        !            21: {
        !            22:        register int    rmap, lmap;
        !            23:        extern QTREE    *ckvar();
        !            24: 
        !            25:        if (t == NULL)
        !            26:                return (NULL);
        !            27: 
        !            28: # ifdef xDTR3
        !            29:        if (tTf(52, 0))
        !            30:                printf("mapvar(%x) %c\n", t, t->sym.type);
        !            31: # endif xDTR3
        !            32: 
        !            33:        switch (t->sym.type)
        !            34:        {
        !            35:          case ROOT:
        !            36:          case AND:
        !            37:          case AGHEAD:
        !            38:                /* map the right side */
        !            39:                t->sym.value.sym_root.rvarm = rmap = mapvar(t->right, tl);
        !            40: 
        !            41:                /* map the left side or else use existing values */
        !            42:                if (tl == 0)
        !            43:                {
        !            44:                        t->sym.value.sym_root.lvarm = lmap = mapvar(t->left, tl);
        !            45:                        t->sym.value.sym_root.lvarc = bitcnt(lmap);
        !            46:                }
        !            47:                else
        !            48:                        lmap = t->sym.value.sym_root.lvarm;
        !            49: 
        !            50:                /* form map of both sides */
        !            51:                rmap |= lmap;
        !            52: 
        !            53:                /* compute total var count */
        !            54:                t->sym.value.sym_root.tvarc = bitcnt(rmap);
        !            55: 
        !            56:                return (rmap);
        !            57: 
        !            58:          case VAR:
        !            59:                if ((t = ckvar(t))->sym.value.sym_var.valptr)
        !            60:                        return (NULL);  /* var is a constant */
        !            61:                return (01 << t->sym.value.sym_var.varno);
        !            62:        }
        !            63: 
        !            64:        /* node is not a VAR, AND, ROOT, or AGHEAD */
        !            65:        return (mapvar(t->left, tl) | mapvar(t->right, tl));
        !            66: }

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