Return to rnum.c CVS log

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

Annotation of 42BSD/ingres/source/decomp/rnum.c, revision 1.1.1.1

1.1       root        1: # include      <ingres.h>
                      2: # include      "globs.h"
                      3: # include      <sccs.h>
                      4: 
                      5: SCCSID(@(#)rnum.c      7.1     2/5/81)
                      6: 
                      7: 
                      8: /*
                      9: **     Internal numbers are used in decomp to
                     10: **     represent relation names. The numbers
                     11: **     from 0 to FIRSTNUM-1 refer to the names
                     12: **     stored in De.de_name_table[].
                     13: **
                     14: **     The number from FIRSTNUM to LASTNUM have
                     15: **     names which are computed from aa, ab, etc.
                     16: */
                     17: 
                     18: 
                     19: 
                     20: 
                     21: /*
                     22: **     Assign an internal number rnum to name.
                     23: */
                     24: 
                     25: rnum_assign(name)
                     26: char   *name;
                     27: {
                     28:        register int    i;
                     29: 
                     30:        for (i = 0; i < FIRSTNUM; i++)
                     31:                if (De.de_num_used[i] == 0)
                     32:                {
                     33:                        bmove(name, De.de_name_table[i], MAXNAME);
                     34:                        De.de_num_used[i]++;
                     35:                        return (i);
                     36:                }
                     37:        syserr("rnum_assign:no room");
                     38:        return (-1);
                     39: }
                     40: /*
                     41: **     Allocate the next available name
                     42: */
                     43: 
                     44: rnum_alloc()
                     45: {
                     46:        register int    i;
                     47:        register char   *cp;
                     48: 
                     49:        cp = &De.de_num_used[FIRSTNUM];
                     50:        for (i = FIRSTNUM; i < LASTNUM; i++)
                     51:                if (*cp++ == 0)
                     52:                {
                     53:                        --cp;
                     54:                        (*cp)++;
                     55:                        return (i);
                     56:                }
                     57:        syserr("no free names");
                     58:        return (-1);
                     59: }
                     60: /*
                     61: **     Convert internal relation number
                     62: **     to its real name. Guarantee '\0' at end.
                     63: */
                     64: 
                     65: char *
                     66: rnum_convert(num)
                     67: int    num;
                     68: {
                     69:        register int    i;
                     70:        register char   *ret, *cp;
                     71:        static char     temp[MAXNAME+1];
                     72:        extern char     *Fileset;
                     73:        extern char     *concat();
                     74: 
                     75:        i = num;
                     76:        if (i > LASTNUM || De.de_num_used[i] == 0)
                     77:                syserr("no name for %d", i);
                     78: 
                     79:        ret = temp;
                     80: 
                     81:        if (i < FIRSTNUM)
                     82:        {
                     83:                bmove(De.de_name_table[i], ret, MAXNAME);
                     84:        }
                     85:        else
                     86:        {
                     87:                /* compute temp name */
                     88:                cp = concat("_SYS", Fileset, ret);
                     89:                pad(ret, MAXNAME);
                     90:                i -= FIRSTNUM;
                     91:                *cp++ = i/26 + 'a';
                     92:                *cp = i%26 + 'a';
                     93:        }
                     94:        return (ret);
                     95: }
                     96: /*
                     97: **     Remove a num from the used list
                     98: */
                     99: 
                    100: rnum_remove(num)
                    101: int    num;
                    102: {
                    103:        register char   *cp;
                    104: 
                    105:        cp = &De.de_num_used[num];
                    106: 
                    107:        if (*cp == 0)
                    108:                syserr("cant remove %d", num);
                    109:        *cp = 0;
                    110: }
                    111: /*
                    112: **     returns number of largest assigned temp number.
                    113: **     zero if none
                    114: */
                    115: 
                    116: rnum_last()
                    117: {
                    118:        register int    i;
                    119: 
                    120:        for (i = LASTNUM - 1; i >= FIRSTNUM; i--)
                    121:        {
                    122:                if (De.de_num_used[i])
                    123:                {
                    124:                        return (i);
                    125:                }
                    126:        }
                    127: 
                    128:        return (0);
                    129: }
                    130: /*
                    131: **     Predicate to check whether rnum is a temporary relation or not
                    132: */
                    133: 
                    134: rnum_temp(rnum)
                    135: int    rnum;
                    136: {
                    137:        register int    i;
                    138: 
                    139:        i = rnum;
                    140: 
                    141:        return (i >= FIRSTNUM || bequal("_SYS", rnum_convert(i), 4));
                    142: }
                    143: /*
                    144: **     Clear tag fields from previous query
                    145: */
                    146: 
                    147: rnum_init()
                    148: {
                    149:        register char   *cp;
                    150:        register int    i;
                    151: 
                    152:        cp = De.de_num_used;
                    153:        i = FIRSTNUM;
                    154:        while (--i)
                    155:                *cp++ = 0;
                    156: }

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