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

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.