Return to cplist.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / icon / rt

Annotation of 43BSD/contrib/icon/rt/cplist.c, revision 1.1

1.1     ! root        1: #include "../h/rt.h"
        !             2: 
        !             3: /*
        !             4:  * cplist(d1,d2,i,j) - copy sublist d1[i:j] into d2.
        !             5:  */
        !             6: 
        !             7: cplist(d1, d2, i, j)
        !             8: struct descrip *d1, *d2;
        !             9: int i, j;
        !            10:    {
        !            11:    register struct descrip *dp;
        !            12:    int size, nelem;
        !            13:    struct b_list *lp1, *lp2;
        !            14:    struct b_lelem *bp1, *bp2;
        !            15: 
        !            16:    /*
        !            17:     * Calculate the size of the sublist and fail if it's less than 0.
        !            18:     *  Also round nelem up to the minimum list block size.
        !            19:     */
        !            20:    size = nelem = j - i;
        !            21:    if (size < 0)
        !            22:       fail();
        !            23:    if (nelem < LISTBLKSIZE)
        !            24:       nelem = LISTBLKSIZE;
        !            25: 
        !            26:    /*
        !            27:     * Get pointers to the list and list elements for the source list
        !            28:     *  (bp1, lp1) and the sublist (bp2, lp2).
        !            29:     */
        !            30:    hneed(sizeof(struct b_list) + sizeof(struct b_lelem) +
        !            31:          nelem * sizeof(struct descrip));
        !            32:    lp1 = (struct b_list *) BLKLOC(*d1);
        !            33:    bp1 = (struct b_lelem *) BLKLOC(lp1->listhead);
        !            34:    lp2 = (struct b_list *) alclist(size);
        !            35:    bp2 = (struct b_lelem *) alclstb(nelem, 0, size);
        !            36:    lp2->listhead.type = lp2->listtail.type = D_LELEM;
        !            37:    BLKLOC(lp2->listhead) = BLKLOC(lp2->listtail) = (union block *) bp2;
        !            38:    dp = bp2->lslots;
        !            39: 
        !            40:    /*
        !            41:     * Locate the block containing element i in the source list.
        !            42:     */
        !            43:    if (size > 0) {
        !            44:       while (i > bp1->nused) {
        !            45:          i -= bp1->nused;
        !            46:          bp1 = (struct b_lelem *) BLKLOC(bp1->listnext);
        !            47:          }
        !            48:       }
        !            49: 
        !            50:    /*
        !            51:     * Copy elements from the source list into the sublist, moving to
        !            52:     *  the next list block in the source list when all elements in a
        !            53:     *  block have been copied.
        !            54:     */
        !            55:    while (size > 0) {
        !            56:       j = bp1->first + i - 1;
        !            57:       if (j >= bp1->nelem)
        !            58:          j -= bp1->nelem;
        !            59:       *dp++ = bp1->lslots[j];
        !            60:       if (++i > bp1->nused) {
        !            61:          i = 1;
        !            62:          bp1 = (struct b_lelem *) BLKLOC(bp1->listnext);
        !            63:          }
        !            64:       size--;
        !            65:       }
        !            66: 
        !            67:    /*
        !            68:     * Fix type and location fields for the new list.
        !            69:     */
        !            70:    d2->type = D_LIST;
        !            71:    BLKLOC(*d2) = (union block *) lp2;
        !            72:    }

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