Return to alloc.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin / sh

Annotation of coherent/d/bin/sh/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:        cp2 = (char *) f ? salloc(cp1-cp0) : balloc(cp1-cp0);
        !            28:        cp1 = cp2;
        !            29:        while (*cp1++=*cp0++)
        !            30:                ;
        !            31:        return (cp2);
        !            32: }
        !            33: 
        !            34: /*
        !            35:  * Create an argument list.
        !            36:  */
        !            37: char **
        !            38: makargl()
        !            39: {
        !            40:        register char **app;
        !            41: 
        !            42:        app = (char **)balloc((1+IALSIZE)*sizeof(char *));
        !            43:        app++;
        !            44:        app[-1] = (char *)IALSIZE;
        !            45:        app[0] = NULL;
        !            46:        return (app);
        !            47: }
        !            48: 
        !            49: /*
        !            50:  * Add an element to an argument list.
        !            51:  */
        !            52: char **
        !            53: addargl(app, sp)
        !            54: char **app;
        !            55: char *sp;
        !            56: {
        !            57:        char **napp;
        !            58:        register char **rapp;
        !            59:        register unsigned n, i;
        !            60: 
        !            61:        rapp = app;
        !            62:        n = (int)rapp[-1];
        !            63:        while (*rapp++ != NULL)
        !            64:                ;
        !            65:        if (rapp-app >= n) {
        !            66:                napp = (char **)balloc((1+n*2)*sizeof(char *));
        !            67:                napp++;
        !            68:                napp[-1] = (char *)(n*2);
        !            69:                for (i=0; i<n; i++)
        !            70:                        napp[i] = app[i];
        !            71:                napp[n-1] = sp;
        !            72:                napp[n] = NULL;
        !            73:                return (napp);
        !            74:        }
        !            75:        *rapp = NULL;
        !            76:        *--rapp = sp;
        !            77:        return (app);
        !            78: }
        !            79: 
        !            80: /*
        !            81:  * Save allocation position.
        !            82:  */
        !            83: BUF **
        !            84: savebuf()
        !            85: {
        !            86:        return (bufapp);
        !            87: }
        !            88: 
        !            89: /*
        !            90:  * Free everything allocated since passed allocation position
        !            91:  * was saved.
        !            92:  */
        !            93: freebuf(bpp)
        !            94: register char **bpp;
        !            95: {
        !            96:        *bufapp = buffp;
        !            97:        buffp = *bpp;
        !            98:        *bpp = NULL;
        !            99:        bufapp = bpp;
        !           100: }
        !           101: 
        !           102: /*
        !           103:  * Allocate a buffer 'n' bytes long.
        !           104:  * Add it onto the allocated buffer list.
        !           105:  */
        !           106: char *
        !           107: balloc(n)
        !           108: {
        !           109:        register BUF *bp, **bpp;
        !           110: 
        !           111:        bpp = &buffp;
        !           112:        for (;;) {
        !           113:                if ((bp=*bpp) == NULL) {
        !           114:                        bp = (BUF *) salloc(sizeof (BUF) + n);
        !           115:                        bp->b_size = n;
        !           116:                        break;
        !           117:                }
        !           118:                if (bp->b_size == n) {
        !           119:                        *bpp = bp->b_next;
        !           120:                        break;
        !           121:                }
        !           122:                bpp = &bp->b_next;
        !           123:        }
        !           124:        *bufapp = bp;
        !           125:        bufapp = &bp->b_next;
        !           126:        *bufapp = NULL;
        !           127:        return ((char *) bp + sizeof (BUF));
        !           128: }
        !           129: 
        !           130: /*
        !           131:  * Allocate 'n' bytes.
        !           132:  */
        !           133: char *
        !           134: salloc(n)
        !           135: {
        !           136:        register char *cp;
        !           137:        char    *malloc();
        !           138: 
        !           139:        if ((cp=malloc(n)) == NULL) {
        !           140:                prints("Out of memory\n");
        !           141:                reset(RNOSBRK);
        !           142:                NOTREACHED;
        !           143:        }
        !           144:        return (cp);
        !           145: }
        !           146: 
        !           147: /*
        !           148:  * Free something possibly allocated by 'salloc'.
        !           149:  *     notmem is part of our customised malloc package which
        !           150:  *     prevents freeing of static strings and automatic variables.
        !           151:  */
        !           152: sfree(cp)
        !           153: char *cp;
        !           154: {
        !           155:        if (notmem(cp))
        !           156:                return;
        !           157:        free(cp);
        !           158: }
        !           159: 
        !           160: /*
        !           161:  * Deallocate a vector.
        !           162:  */
        !           163: vfree(vecp)
        !           164: char **vecp;
        !           165: {
        !           166:        register char **vpp;
        !           167: 
        !           168:        if (notmem(vecp))
        !           169:                return;
        !           170:        for (vpp = vecp; *vpp!=NULL; vpp += 1)
        !           171:                sfree(*vpp);
        !           172:        sfree(vecp);
        !           173: }
        !           174: 
        !           175: char **
        !           176: vdupl(vecp)
        !           177: char **vecp;
        !           178: {
        !           179:        register char **vp, **nvp, **tvp;
        !           180: 
        !           181:        for (vp=vecp; *vp++ != NULL; );
        !           182:        tvp = nvp = (char **)salloc((vp - vecp) * sizeof *vp);
        !           183:        for (vp=vecp; *vp != NULL; )
        !           184:                *tvp++ = duplstr(*vp++, 1);
        !           185:        *tvp = NULL;
        !           186:        return (nvp);
        !           187: }
        !           188: 
        !           189: /* end of sh/alloc.c */

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