Return to alloc.c CVS log

Up to [MW Coherent from dump] / coherent / b / bin / sh.420

Annotation of coherent/b/bin/sh.420/alloc.c, revision 1.1

1.1     ! root        1: /* sh/alloc.c */
        !             2: 
        !             3: #include "sh.h"
        !             4: 
        !             5: extern char    *malloc();
        !             6: 
        !             7: /*
        !             8:  * Externals.
        !             9:  */
        !            10: BUF    *bufap = NULL;                  /* Head of allocation list */
        !            11: BUF    *buffp = NULL;                  /* Tail of free list */
        !            12: BUF    **bufapp = &bufap;              /* Tail of allocation list */
        !            13: 
        !            14: /*
        !            15:  * Given a string, return a pointer to a copy of it.  If 'f'
        !            16:  * is set, don't add it onto the free list.
        !            17:  */
        !            18: char *
        !            19: duplstr(cp0, f)
        !            20: register char *cp0;
        !            21: {
        !            22:        register char *cp1, *cp2;
        !            23: 
        !            24:        cp1 = cp0;
        !            25:        while (*cp1++)
        !            26:                ;
        !            27: #if 0
        !            28:        cp2 = (char *) f ? salloc (cp1 - cp0) : balloc (cp1 - cp0);
        !            29: #else
        !            30:        if ((char *) f)
        !            31:                cp2 = salloc (cp1 - cp0);
        !            32:        else    
        !            33:                cp2 = balloc (cp1 - cp0);
        !            34: #endif
        !            35:        cp1 = cp2;
        !            36:        while (*cp1++=*cp0++)
        !            37:                ;
        !            38:        return (cp2);
        !            39: }
        !            40: 
        !            41: /*
        !            42:  * Create an argument list.
        !            43:  */
        !            44: char **
        !            45: makargl()
        !            46: {
        !            47:        register char **app;
        !            48: 
        !            49:        app = (char **)balloc((1+IALSIZE)*sizeof(char *));
        !            50:        app++;
        !            51:        app[-1] = (char *)IALSIZE;
        !            52:        app[0] = NULL;
        !            53:        return (app);
        !            54: }
        !            55: 
        !            56: /*
        !            57:  * Add an element to an argument list.
        !            58:  */
        !            59: char **
        !            60: addargl(app, sp)
        !            61: char **app;
        !            62: char *sp;
        !            63: {
        !            64:        char **napp;
        !            65:        register char **rapp;
        !            66:        register unsigned n, i;
        !            67: 
        !            68:        rapp = app;
        !            69:        n = (int)rapp[-1];
        !            70:        while (*rapp++ != NULL)
        !            71:                ;
        !            72:        if (rapp-app >= n) {
        !            73:                napp = (char **)balloc((1+n*2)*sizeof(char *));
        !            74:                napp++;
        !            75:                napp[-1] = (char *)(n*2);
        !            76:                for (i=0; i<n; i++)
        !            77:                        napp[i] = app[i];
        !            78:                napp[n-1] = sp;
        !            79:                napp[n] = NULL;
        !            80:                return (napp);
        !            81:        }
        !            82:        *rapp = NULL;
        !            83:        *--rapp = sp;
        !            84:        return (app);
        !            85: }
        !            86: 
        !            87: /*
        !            88:  * Save allocation position.
        !            89:  */
        !            90: BUF **
        !            91: savebuf()
        !            92: {
        !            93:        return (bufapp);
        !            94: }
        !            95: 
        !            96: /*
        !            97:  * Free everything allocated since passed allocation position
        !            98:  * was saved.
        !            99:  */
        !           100: freebuf(bpp)
        !           101: register BUF **bpp;
        !           102: {
        !           103:        *bufapp = buffp;
        !           104:        buffp = *bpp;
        !           105:        *bpp = NULL;
        !           106:        bufapp = bpp;
        !           107: }
        !           108: 
        !           109: /*
        !           110:  * Allocate a buffer 'n' bytes long.
        !           111:  * Add it onto the allocated buffer list.
        !           112:  */
        !           113: char *
        !           114: balloc(n)
        !           115: {
        !           116:        register BUF *bp, **bpp;
        !           117: 
        !           118:        bpp = &buffp;
        !           119:        for (;;) {
        !           120:                if ((bp=*bpp) == NULL) {
        !           121:                        bp = (BUF *) salloc(sizeof (BUF) + n);
        !           122:                        bp->b_size = n;
        !           123:                        break;
        !           124:                }
        !           125:                if (bp->b_size == n) {
        !           126:                        *bpp = bp->b_next;
        !           127:                        break;
        !           128:                }
        !           129:                bpp = &bp->b_next;
        !           130:        }
        !           131:        *bufapp = bp;
        !           132:        bufapp = &bp->b_next;
        !           133:        *bufapp = NULL;
        !           134:        return ((char *) bp + sizeof (BUF));
        !           135: }
        !           136: 
        !           137: /*
        !           138:  * Allocate 'n' bytes.
        !           139:  */
        !           140: char *
        !           141: salloc(n)
        !           142: {
        !           143:        register char *cp;
        !           144:        char    *malloc();
        !           145: 
        !           146:        if ((cp=malloc(n)) == NULL) {
        !           147:                prints("Out of memory\n");
        !           148:                reset(RNOSBRK);
        !           149:                NOTREACHED;
        !           150:        }
        !           151: 
        !           152:        return (cp);
        !           153: }
        !           154: 
        !           155: /*
        !           156:  * Free something possibly allocated by 'salloc'.
        !           157:  *     notmem is part of our customised malloc package which
        !           158:  *     prevents freeing of static strings and automatic variables.
        !           159:  */
        !           160: sfree(cp)
        !           161: char *cp;
        !           162: {
        !           163: #if 0
        !           164:        if (cp != NULL && notmem(cp)) {
        !           165:                fprintf (stderr, "freeing \"%s\" at %x\n", cp, cp);
        !           166:                return;
        !           167:        }
        !           168: #endif
        !           169:        free(cp);
        !           170: }
        !           171: 
        !           172: #ifdef ALLOC_DEBUG
        !           173: /*
        !           174:  * For allocation debugging.
        !           175:  */
        !           176: 
        !           177: void alloc_alloc (debug) struct alloc_debug * debug; {
        !           178:        if (++ debug->count > debug->maxcount) {
        !           179:                debug->maxcount = debug->count;
        !           180:                fprintf (stderr, "%s:%d\n", debug->name, debug->count);
        !           181:        }
        !           182: }
        !           183: 
        !           184: #endif
        !           185: 
        !           186: ALLOC_COUNT (vector)
        !           187: 
        !           188: /*
        !           189:  * Deallocate a vector.
        !           190:  */
        !           191: vfree(vecp)
        !           192: char **vecp;
        !           193: {
        !           194:        register char **vpp;
        !           195: 
        !           196:        if (notmem(vecp))
        !           197:                return;
        !           198:        for (vpp = vecp; *vpp!=NULL; vpp += 1)
        !           199:                sfree(*vpp);
        !           200:        sfree(vecp);
        !           201:        ALLOC_FREE (vector)
        !           202: }
        !           203: 
        !           204: char **
        !           205: vdupl(vecp)
        !           206: char **vecp;
        !           207: {
        !           208:        register char **vp, **nvp, **tvp;
        !           209: 
        !           210:        for (vp=vecp; *vp++ != NULL; );
        !           211:        tvp = nvp = (char **)salloc((vp - vecp) * sizeof *vp);
        !           212:        for (vp=vecp; *vp != NULL; )
        !           213:                *tvp++ = duplstr(*vp++, 1);
        !           214:        *tvp = NULL;
        !           215:        ALLOC_ALLOC (vector);
        !           216:        return (nvp);
        !           217: }
        !           218: 
        !           219: /* end of sh/alloc.c */

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