Return to rstruct.c CVS log

Up to [Research Unix] / researchv10dc / cmd / icon / src / iconx

Annotation of researchv10dc/cmd/icon/src/iconx/rstruct.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * File: rstruct.c
        !             3:  *  Contents: addmem, cplist, locate, memb
        !             4:  */
        !             5: 
        !             6: #include "../h/rt.h"
        !             7: /*
        !             8:  * addmem - add a new set element block in the correct spot in
        !             9:  *  the bucket chain.
        !            10:  */
        !            11: 
        !            12: addmem(ps,pe,pl)
        !            13: struct descrip *pl;
        !            14: struct b_set *ps;
        !            15: struct b_selem *pe;
        !            16:    {
        !            17:    ps->size++;
        !            18:    if (!ChkNull(*pl) ) {
        !            19:       BlkLoc(pe->clink) = BlkLoc(*pl);
        !            20:       pe->clink.dword = D_Selem;
        !            21:       }
        !            22:    BlkLoc(*pl) = (union block *) pe;
        !            23:    pl->dword = D_Selem;
        !            24:    }
        !            25: 
        !            26: 
        !            27: /*
        !            28:  * cplist(d1,d2,i,j) - copy sublist d1[i:j] into d2.
        !            29:  */
        !            30: 
        !            31: cplist(d1, d2, i, j)
        !            32: struct descrip *d1, *d2;
        !            33: word i, j;
        !            34:    {
        !            35:    register struct descrip *dp;
        !            36:    word size, nelem;
        !            37:    struct b_list *lp1, *lp2;
        !            38:    struct b_lelem *bp1, *bp2;
        !            39: 
        !            40:    /*
        !            41:     * Calculate the size of the sublist and fail if it's less than 0.
        !            42:     *  Also round nelem up to the minimum list block size.
        !            43:     */
        !            44:    size = nelem = j - i;
        !            45:    if (nelem < MinListSlots)
        !            46:       nelem = MinListSlots;
        !            47: 
        !            48:    /*
        !            49:     * Get pointers to the list and list elements for the source list
        !            50:     *  (bp1, lp1) and the sublist (bp2, lp2).
        !            51:     */
        !            52:    blkreq(sizeof(struct b_list) + sizeof(struct b_lelem) +
        !            53:          nelem * sizeof(struct descrip));
        !            54:    lp1 = (struct b_list *) BlkLoc(*d1);
        !            55:    bp1 = (struct b_lelem *) BlkLoc(lp1->listhead);
        !            56:    lp2 = (struct b_list *) alclist(size);
        !            57:    bp2 = (struct b_lelem *) alclstb(nelem, (word)0, size);
        !            58:    lp2->listhead.dword = lp2->listtail.dword = D_Lelem;
        !            59:    BlkLoc(lp2->listhead) = BlkLoc(lp2->listtail) = (union block *) bp2;
        !            60:    dp = bp2->lslots;
        !            61: 
        !            62:    /*
        !            63:     * Locate the block containing element i in the source list.
        !            64:     */
        !            65:    if (size > 0) {
        !            66:       while (i > bp1->nused) {
        !            67:          i -= bp1->nused;
        !            68:          bp1 = (struct b_lelem *) BlkLoc(bp1->listnext);
        !            69:          }
        !            70:       }
        !            71: 
        !            72:    /*
        !            73:     * Copy elements from the source list into the sublist, moving to
        !            74:     *  the next list block in the source list when all elements in a
        !            75:     *  block have been copied.
        !            76:     */
        !            77:    while (size > 0) {
        !            78:       j = bp1->first + i - 1;
        !            79:       if (j >= bp1->nelem)
        !            80:          j -= bp1->nelem;
        !            81:       *dp++ = bp1->lslots[j];
        !            82:       if (++i > bp1->nused) {
        !            83:          i = 1;
        !            84:          bp1 = (struct b_lelem *) BlkLoc(bp1->listnext);
        !            85:          }
        !            86:       size--;
        !            87:       }
        !            88: 
        !            89:    /*
        !            90:     * Fix type and location fields for the new list.
        !            91:     */
        !            92:    d2->dword = D_List;
        !            93:    BlkLoc(*d2) = (union block *) lp2;
        !            94:    }
        !            95: 
        !            96: 
        !            97: /*
        !            98:  * locate - returns 1 if obj is in the hash chain which
        !            99:  *  starts at ep in some set, returns 0 if not there
        !           100:  *  (used only in diff.c and inter.c).
        !           101:  */
        !           102: 
        !           103: locate(ep, obj)
        !           104: struct b_selem *ep, *obj;
        !           105:    {
        !           106:    while (ep != NULL) {
        !           107:       if (ep->hashnum > obj->hashnum)
        !           108:           return 0;
        !           109:       else if ((ep->hashnum == obj->hashnum) &&
        !           110:                  (equiv(&ep->setmem, &obj->setmem)))
        !           111:           return 1;
        !           112:       ep = (struct b_selem *) BlkLoc(ep->clink);
        !           113:       }
        !           114:    return 0;
        !           115:    }
        !           116: 
        !           117: 
        !           118: /*
        !           119:  * memb - sets res flag to 1 if x is a member of set S,
        !           120:  *  sets res flag to 0 if not.
        !           121:  *  Returns pointer to the descriptor which points to
        !           122:  *  the element (or which would point to it if it were
        !           123:  *  there).
        !           124:  */
        !           125: 
        !           126: struct descrip *memb(ps,x,hn,res)
        !           127: int *res;                              /* pointer to integer result flag */
        !           128: struct b_set *ps;
        !           129: struct descrip  *x;
        !           130: word hn;
        !           131:    {
        !           132:     register struct descrip *lp;
        !           133:     register struct b_selem  *pe;
        !           134:     extern int equiv();
        !           135: 
        !           136:    lp = &(ps->sbucks[SlotNum(hn,SSlots)]);
        !           137:    /*
        !           138:     * Look for x in the hash chain.
        !           139:     */
        !           140:    *res = 0;
        !           141:    while (BlkLoc(*lp) != NULL) {
        !           142:        pe = (struct b_selem *) BlkLoc(*lp);
        !           143:        if ( pe->hashnum > hn)          /* too far - it isn't there */
        !           144:          return lp;
        !           145:        else if (( pe->hashnum == hn ) && ( equiv(&pe->setmem, x )))  {
        !           146:          *res = 1;
        !           147:          return lp;
        !           148:          }
        !           149:    /*
        !           150:     * We haven't reached the right hashnumber yet or
        !           151:     *  the element isn't the right one so keep looking.
        !           152:     */
        !           153:       lp = &(pe->clink);
        !           154:    }
        !           155:    /*
        !           156:     *  At end of chain - not there.
        !           157:     */
        !           158:    return lp;
        !           159:    }

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