Return to realloc.c CVS log

Up to [MW Coherent from dump] / coherent / b / lib / libc / gen / old

Annotation of coherent/b/lib/libc/gen/old/realloc.c, revision 1.1

1.1     ! root        1: /* realloc fits unix version 5 requirments 
        !             2:  * knows format of malloc list.
        !             3:  */
        !             4: 
        !             5: #include <stdio.h>
        !             6: #include <malloc.h>
        !             7: 
        !             8: extern struct mblock   *_a_scanp;      /* search starts here */
        !             9: 
        !            10: static
        !            11: qmove(cp, ptr, sizem)
        !            12: register unsigned sizem, *cp, *ptr;
        !            13: {
        !            14:        for(; sizem > 0; sizem--)
        !            15:                *ptr++ = *cp++;
        !            16: }
        !            17: 
        !            18: /* realloc function */
        !            19: char *
        !            20: realloc(cp, size)
        !            21: register char *cp;
        !            22: unsigned size;
        !            23: {
        !            24:        register unsigned len, siz, nlen;
        !            25:        register struct mblock *ptr, *nptr;
        !            26: 
        !            27:        siz = roundup(size + sizeof(unsigned), POW2);
        !            28:        if(siz < size)
        !            29:                return(NULL);
        !            30:        len = realsize((ptr = cp - sizeof(unsigned))->blksize);
        !            31:        ptr->blksize = len;             /* mark used */
        !            32:        if(len >= siz) {                /* request to shrink */
        !            33:                if((len -= siz) > LEASTFREE) {
        !            34:                        ptr->blksize = siz;
        !            35:                        ptr = siz + adr(ptr);
        !            36:                        ptr->blksize = (len|FREE);
        !            37:                }
        !            38:                return(cp);
        !            39:        }
        !            40:        /* request to grow */
        !            41:        nptr = adr(ptr) + len;
        !            42:        if((isfree(nlen = nptr->blksize)) &&
        !            43:           ((nlen+=len) > siz)) { /*next block free and big enough */
        !            44:                if((nlen - siz) > LEASTFREE) {
        !            45:                        ptr->blksize = siz;
        !            46:                        ptr = siz + adr(ptr);
        !            47:                        ptr->blksize = nlen - siz;
        !            48:                }
        !            49:                else {
        !            50:                        ptr->blksize = realsize(nlen);
        !            51:                        ptr = realsize(nlen) + adr(ptr);
        !            52:                }
        !            53:                if(nptr==_a_scanp)
        !            54:                        _a_scanp=ptr;
        !            55:                return(cp);
        !            56:        }
        !            57:        if(NULL == (ptr = malloc(size)))
        !            58:                return(NULL);
        !            59:        qmove(cp, ptr, len/sizeof(unsigned) - 1);
        !            60:        free(cp);
        !            61:        return(ptr);
        !            62: }

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