Return to usubr.c CVS log

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

Annotation of 43BSD/ingres/source/decomp/usubr.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      <access.h>
        !             6: # include      <pv.h>
        !             7: # include      "globs.h"
        !             8: # include      <sccs.h>
        !             9: 
        !            10: SCCSID(@(#)usubr.c     8.1     12/31/84)
        !            11: 
        !            12: 
        !            13: /*
        !            14: **     usubr.c
        !            15: **
        !            16: **     utility routines to handle setting up params, etc for DBU calls
        !            17: */
        !            18: 
        !            19: 
        !            20: 
        !            21: /*
        !            22:  *     generate domain names, formats
        !            23:  */
        !            24: domnam(lnp, pre)
        !            25: QTREE  **lnp;
        !            26: char   *pre;
        !            27: {
        !            28: 
        !            29:        register char   suf, *n;
        !            30:        char            name[MAXNAME];
        !            31:        char            *getformat();
        !            32:        register QTREE  **p;
        !            33: 
        !            34:        suf = '1';
        !            35:        for (n=name; *n++= *pre++;);
        !            36:        *n = '\0';
        !            37:        n--;
        !            38:        for (p = lnp; *p != NULL; p++)
        !            39:        {
        !            40:                *n = suf++;
        !            41:                setp(PV_STR, name);
        !            42:                setp(PV_STR, getformat(*p));
        !            43:        }
        !            44: }
        !            45: /*
        !            46: **     gets format in ascii from RESDOM or AOP node
        !            47: */
        !            48: static char *
        !            49: getformat(p)
        !            50: QTREE  *p;
        !            51: {
        !            52: 
        !            53:        static char     buf[10];
        !            54:        register char   *b;
        !            55: 
        !            56:        b = buf;
        !            57: 
        !            58:        *b++ = p->sym.value.sym_op.opfrmt;
        !            59:        itoa(p->sym.value.sym_op.opfrml & I1MASK, b);
        !            60:        return(buf);
        !            61: }
        !            62: /*
        !            63: **     makes list of nodes (depth first)
        !            64: */
        !            65: 
        !            66: lnode(nod, lnodv, count)
        !            67: QTREE  *nod, *lnodv[];
        !            68: int    count;
        !            69: {
        !            70:        register QTREE  *q;
        !            71:        register int    i;
        !            72: 
        !            73:        i = count;
        !            74:        q = nod;
        !            75: 
        !            76:        if (q && q->sym.type != TREE)
        !            77:        {
        !            78:                i = lnode(q->left, lnodv, i);
        !            79:                lnodv[i++] = q;
        !            80:        }
        !            81:        return(i);
        !            82: }
        !            83: /*
        !            84: **     Immediately destroys the relation if it is an _SYS
        !            85: */
        !            86: 
        !            87: dstr_rel(relnum)
        !            88: int    relnum;
        !            89: {
        !            90:        initp();
        !            91:        if (dstr_mark(relnum))
        !            92:                call_dbu(mdDESTROY, FALSE);
        !            93:        else
        !            94:                resetp();
        !            95: }
        !            96: /*
        !            97: **     Put relation on list of relations to be
        !            98: **     destroyed. A call to initp() must be
        !            99: **     made before any calls to dstr_mark().
        !           100: **
        !           101: **     A call to call_dbu will actually have
        !           102: **     the relations exterminated
        !           103: **
        !           104: **     Trace Flags:
        !           105: **             65
        !           106: */
        !           107: 
        !           108: dstr_mark(relnum)
        !           109: int    relnum;
        !           110: {
        !           111:        register char   *p;
        !           112:        char            *rnum_convert();
        !           113:        bool            dstr_flag;
        !           114: 
        !           115:        dstr_flag = FALSE;
        !           116:        if (rnum_temp(relnum))
        !           117:        {
        !           118:                p = rnum_convert(relnum);
        !           119: #              ifdef xDTR1
        !           120:                if (tTf(65, 4))
        !           121:                        printf("destroying %s\n", p);
        !           122: #              endif
        !           123:                setp(PV_STR, p);
        !           124:                specclose(relnum);      /* guarantee that relation is closed and descriptor destroyed */
        !           125:                rnum_remove(relnum);
        !           126:                dstr_flag = TRUE;       /* indicate that there are relations to be destroyed */
        !           127:        }
        !           128:        return(dstr_flag);
        !           129: }
        !           130: /*
        !           131: **     Make a temporary relation to match
        !           132: **     the target list of tree.
        !           133: **
        !           134: **     If rnum is positive, use it as the relation number,
        !           135: **     Otherwise allocate a new one.
        !           136: */
        !           137: 
        !           138: mak_t_rel(tree, prefix, rnum)
        !           139: QTREE  *tree;
        !           140: char   *prefix;
        !           141: int    rnum;
        !           142: {
        !           143:        QTREE           *lnodv[MAXDOM + 1];
        !           144:        register int    relnum;
        !           145: 
        !           146:        initp();
        !           147:        setp(PV_STR, "0");      /* initial relstat field */
        !           148:        relnum = rnum < 0 ? rnum_alloc() : rnum;
        !           149:        setp(PV_STR, rnum_convert(relnum));
        !           150:        lnodv[lnode(tree->left, lnodv, 0)] = NULL;
        !           151:        domnam(lnodv, prefix);
        !           152: 
        !           153:        call_dbu(mdCREATE, FALSE);
        !           154:        return (relnum);
        !           155: }
        !           156: 
        !           157: 
        !           158: QTREE **
        !           159: mksqlist(tree, var)
        !           160: QTREE  *tree;
        !           161: int    var;
        !           162: {
        !           163:        register QTREE  **sq;
        !           164:        register int    i;
        !           165:        static QTREE    *sqlist[MAXRANGE];
        !           166: 
        !           167:        sq = sqlist;
        !           168:        for (i = 0; i < MAXRANGE; i++)
        !           169:                *sq++ = 0;
        !           170: 
        !           171:        sqlist[var] = tree;
        !           172:        return (sqlist);
        !           173: }
        !           174: 
        !           175: 
        !           176: 
        !           177: 
        !           178: long
        !           179: rel_pages(tupcnt, width)
        !           180: long   tupcnt;
        !           181: int    width;
        !           182: {
        !           183:        register int    tups_p_page;
        !           184: 
        !           185:        tups_p_page = (PGSIZE - 12) / (width + 2);
        !           186:        return ((tupcnt + tups_p_page - 1) / tups_p_page);
        !           187: }

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