Return to setvar.c CVS log

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

Annotation of 43BSD/ingres/source/decomp/setvar.c, revision 1.1.1.1

1.1       root        1: # include      <ingres.h>
                      2: # include      <aux.h>
                      3: # include      <tree.h>
                      4: # include      <symbol.h>
                      5: # include      "globs.h"
                      6: # include      <sccs.h>
                      7: 
                      8: SCCSID(@(#)setvar.c    8.1     12/31/84)
                      9: 
                     10: /*
                     11: ** SETVAR -- Routines to convert a VAR to a constant and back to a VAR
                     12: **
                     13: **     This file contains the routines for tuple substitution.
                     14: **
                     15: **     Setvar -- Make a VAR node reference its position in the tuple.
                     16: **
                     17: **     Clrvar -- Make the VAR node refer back to a VAR
                     18: */
                     19: /*
                     20: **  SETVAR
                     21: **
                     22: **     Var's are changed to reference their values in a tuple.
                     23: **     ROOT and AND nodes are changed to update the variable maps.
                     24: **
                     25: **     Trace Flags:
                     26: **             53
                     27: */
                     28: 
                     29: setvar(tree, var, intid, tuple)
                     30: register QTREE         *tree;
                     31: int            var;
                     32: TID            *intid;
                     33: char           *tuple;
                     34: {
                     35:        register int    mask, nvc;
                     36:        DESC            *readopen();
                     37:        extern QTREE    *ckvar();
                     38: 
                     39:        if (tree == NULL) 
                     40:                return;
                     41:        switch (tree->sym.type)
                     42:        {
                     43:          case VAR:
                     44:                if ((tree=ckvar(tree))->sym.value.sym_var.varno == var)
                     45:                {
                     46: #                      ifdef xDTR1
                     47:                        if (tTf(53, 0))
                     48:                        {
                     49:                                printf("setvar:%d;tree:", var);
                     50:                                nodepr(tree);
                     51:                        }
                     52: #                      endif
                     53:                        if (tree->sym.value.sym_var.attno)
                     54:                                tree->sym.value.sym_var.valptr =
                     55:                                    (ANYTYPE *) (tuple + readopen(var)->reloff[tree->sym.value.sym_var.attno]);
                     56:                        else
                     57:                                tree->sym.value.sym_var.valptr = (ANYTYPE *) intid;
                     58:                }
                     59:                return;
                     60: 
                     61:          case ROOT:
                     62:          case AND:
                     63:                mask = 01 << var;
                     64:                nvc = tree->sym.value.sym_root.tvarc;
                     65:                if (tree->sym.value.sym_root.lvarm & mask)
                     66:                {
                     67:                        setvar(tree->left, var, intid, tuple);
                     68:                        tree->sym.value.sym_root.lvarm &=  ~mask;
                     69:                        --tree->sym.value.sym_root.lvarc;
                     70:                        nvc = tree->sym.value.sym_root.tvarc - 1;
                     71:                }
                     72:                if (tree->sym.value.sym_root.rvarm & mask)
                     73:                {
                     74:                        setvar(tree->right, var, intid, tuple);
                     75:                        tree->sym.value.sym_root.rvarm &=  ~mask;
                     76:                        nvc = tree->sym.value.sym_root.tvarc - 1;
                     77:                }
                     78:                tree->sym.value.sym_root.tvarc = nvc;
                     79:                return;
                     80: 
                     81:          default:
                     82:                setvar(tree->left, var, intid, tuple);
                     83:                setvar(tree->right, var, intid, tuple);
                     84:                return;
                     85:        }
                     86: }
                     87: /*
                     88: **     Clearvar is the opposite of setvar. For
                     89: **     each occurence of var1 in the tree, clear
                     90: **     the valptr.
                     91: */
                     92: 
                     93: clearvar(tree, var)
                     94: register QTREE *tree;
                     95: register int   var;
                     96: {
                     97:        extern QTREE    *ckvar();
                     98: 
                     99:        if (tree == NULL)
                    100:                return;
                    101: 
                    102:        if (tree->sym.type == VAR)
                    103:        {
                    104:                if ((tree = ckvar(tree))->sym.value.sym_var.varno == var)
                    105:                        tree->sym.value.sym_var.valptr = 0;
                    106:                return;
                    107:        }
                    108:        clearvar(tree->left, var);
                    109:        clearvar(tree->right, var);
                    110: }

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