Return to get_tuple.c CVS log

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

Annotation of 42BSD/ingres/source/iutil/get_tuple.c, revision 1.1

1.1     ! root        1: # include      <ingres.h>
        !             2: # include      <access.h>
        !             3: # include      <symbol.h>
        !             4: # include      <sccs.h>
        !             5: 
        !             6: SCCSID(@(#)get_tuple.c 7.1     2/5/81)
        !             7: 
        !             8: /*
        !             9: **     Routine associated with getting a tuple out of
        !            10: **     the current buffer.
        !            11: */
        !            12: 
        !            13: 
        !            14: /*
        !            15: **     Get_tuple - take the tuple specified
        !            16: **     by tid and move it to "tuple"
        !            17: */
        !            18: 
        !            19: get_tuple(d, tid, tuple)
        !            20: register DESC  *d;
        !            21: TID            *tid;
        !            22: char           *tuple;
        !            23: {
        !            24:        register char   *cp;
        !            25:        char            *get_addr();
        !            26: 
        !            27:        cp = get_addr(tid);
        !            28: 
        !            29:        if (d->reldum.relspec < 0)
        !            30:                uncomp_tup(d, cp, tuple);       /* compressed tuple */
        !            31:        else
        !            32:                bmove(cp, tuple, d->reldum.relwid);     /* uncompressed tuple */
        !            33: }
        !            34: /*
        !            35: **     Getint_tuple - get the tuple specified by
        !            36: **     tid. If possible avoid moving the tuple.
        !            37: **     Return value is address of tuple.
        !            38: */
        !            39: 
        !            40: char *
        !            41: getint_tuple(d, tid, tuple)
        !            42: register DESC  *d;
        !            43: TID            *tid;
        !            44: char           *tuple;
        !            45: {
        !            46:        register char   *cp, *ret;
        !            47:        extern char     *get_addr();
        !            48: 
        !            49:        cp = get_addr(tid);
        !            50: 
        !            51:        if (d->reldum.relspec < 0)
        !            52:        {
        !            53:                ret = tuple;
        !            54:                uncomp_tup(d, cp, ret); /* compressed tuple */
        !            55:        }
        !            56:        else
        !            57:                ret = cp;                       /* uncompressed tuple */
        !            58:        return (ret);
        !            59: }
        !            60: /*
        !            61: **     Routine to compute the address of a tuple
        !            62: **     within the current buffer.
        !            63: **     Syserr if specified tuple deleted.
        !            64: */
        !            65: 
        !            66: char *
        !            67: get_addr(tid)
        !            68: register TID   *tid;
        !            69: {
        !            70:        register int    offset;
        !            71: 
        !            72:        offset = Acc_head->linetab[-(tid->line_id & I1MASK)];
        !            73:        if (offset == 0)
        !            74:        {
        !            75:                syserr("get_addr rel=%ld tid=%ld", Acc_head->rel_tupid, *(long *)tid);
        !            76:        }
        !            77: #      ifdef xATR3
        !            78:        if (offset < 0 || offset > PGSIZE)
        !            79:                syserr("get_addr: offset=%d\n");
        !            80: #      endif
        !            81:        return (((char *) Acc_head) + offset);
        !            82: }
        !            83: /*
        !            84: **     Uncompress - decompress the tuple at address cp
        !            85: **     according to descriptor.
        !            86: */
        !            87: 
        !            88: uncomp_tup(d, cp, tuple)
        !            89: register DESC  *d;
        !            90: char           *cp;
        !            91: char           *tuple;
        !            92: {
        !            93:        register char   *src, *dst;
        !            94:        int             i, j;
        !            95: 
        !            96:        dst = tuple;
        !            97:        src = cp;
        !            98: 
        !            99:        /* for each domain, copy and blank pad if char */
        !           100:        for (i = 1; i <= d->reldum.relatts; i++)
        !           101:        {
        !           102:                j = d->relfrml[i] & I1MASK;
        !           103:                if (d->relfrmt[i] == CHAR)
        !           104:                {
        !           105:                        while (j--)
        !           106:                        {
        !           107:                                if ((*dst++ = *src++) == NULL)
        !           108:                                {
        !           109:                                        /* back up one */
        !           110:                                        dst--;
        !           111:                                        j++;
        !           112:                                        break;
        !           113:                                }
        !           114:                        }
        !           115: 
        !           116:                        /* blank pad if necessary */
        !           117:                        while (j-- > 0)
        !           118:                                *dst++ = ' ';
        !           119:                }
        !           120:                else
        !           121:                {
        !           122:                        while (j--)
        !           123:                                *dst++ = *src++;
        !           124:                }
        !           125:        }
        !           126: }
        !           127: /*
        !           128: **     Check if a line number is valid.
        !           129: **     If linenumber is illegal return AMINVL_ERR
        !           130: **     if Line has been deleted return 2
        !           131: **     else return 0
        !           132: */
        !           133: 
        !           134: invalid(tid)
        !           135: register TID   *tid;
        !           136: {
        !           137:        register int    i;
        !           138: 
        !           139:        i = tid->line_id & I1MASK;
        !           140: 
        !           141:        if (i >= Acc_head->nxtlino)
        !           142:                return (acc_err(AMINVL_ERR));
        !           143: 
        !           144:        if (Acc_head->linetab[-i] == 0)
        !           145:                return (2);
        !           146: 
        !           147:        return (0);
        !           148: }

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