Return to aq.c CVS log

Up to [CSRG BSD Unix] / 41BSD / cmd / apl

Annotation of 41BSD/cmd/apl/aq.c, revision 1.1

1.1     ! root        1: #
        !             2: /*
        !             3:  * C library -- alloc/free
        !             4:  */
        !             5: 
        !             6: #define        logical int
        !             7: 
        !             8: struct fb {
        !             9:        logical size;
        !            10:        char    *next;
        !            11: };
        !            12: 
        !            13: int    freelist[] = {
        !            14:        0,
        !            15:        -1,
        !            16: };
        !            17: logical        slop    = 2;
        !            18: 
        !            19: alloc(asize)
        !            20: logical asize;
        !            21: { return ( calloc ( 1 , asize ) ); }  
        !            22: /*{
        !            23:        register logical size;
        !            24:        register logical np;
        !            25:        register logical cp;
        !            26: 
        !            27:        if ((size = asize) == 0)
        !            28:                return(0);
        !            29:        size += 3;
        !            30:        size &= ~01;
        !            31:        for (;;) {
        !            32:                cp = freelist;
        !            33:                while ((np = cp->next) != -1) {
        !            34:                        if (np->size>=size) {
        !            35:                                if (size+slop >= np->size) {
        !            36:                                        cp->next = np->next;
        !            37:                                        return(&np->next);
        !            38:                                }
        !            39:                                cp = cp->next = np+size;
        !            40:                                cp->size = np->size - size;
        !            41:                                cp->next = np->next;
        !            42:                                np->size = size;
        !            43:                                return(&np->next);
        !            44:                        }
        !            45:                        cp = np;
        !            46:                }
        !            47:                return ( calloc ( 1 , asize ) ); 
        !            48: 
        !            49:                /* asize = size<1024? 1024: size;
        !            50:                if ((cp = sbrk(asize)) == -1) {
        !            51:                        error("workspace exceeded");
        !            52: 
        !            53:                }
        !            54:                cp->size = asize;
        !            55:                free(&cp->next); 
        !            56:        }
        !            57: }  */
        !            58: 
        !            59: 
        !            60: afree(aptr)
        !            61: char *aptr;
        !            62: {if ( aptr == 0 ) return;
        !            63: cfree ( aptr ); }  
        !            64: /* {
        !            65:        register logical ptr;
        !            66:        register logical cp;
        !            67:        register logical np;
        !            68: 
        !            69:        if (aptr == 0) return;
        !            70:        ptr = aptr-4;
        !            71:        cp = freelist;
        !            72:        while ((np = cp->next) < ptr)
        !            73:                cp = np;
        !            74:        if (ptr+ptr->size == np) {
        !            75:                ptr->size += np->size;
        !            76:                ptr->next = np->next;
        !            77:                np = ptr;
        !            78:        } else
        !            79:                ptr->next = np;
        !            80:        if (cp+cp->size == ptr) {
        !            81:                cp->size += ptr->size;
        !            82:                cp->next = ptr->next;
        !            83:        } else
        !            84:                cp->next = ptr;
        !            85: } */

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