Return to mem.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / pathalias

Annotation of 43BSD/contrib/pathalias/mem.c, revision 1.1

1.1     ! root        1: /* pathalias -- by steve bellovin, as told to peter honeyman */
        !             2: #ifndef lint
        !             3: static char    *sccsid = "@(#)mem.c    8.1 (down!honey) 86/01/19";
        !             4: #endif
        !             5: 
        !             6: #include "def.h"
        !             7: 
        !             8: /* imported */
        !             9: extern char *sbrk();
        !            10: 
        !            11: link   *
        !            12: newlink()
        !            13: {
        !            14:        link    *rval;
        !            15: 
        !            16:        if ((rval = (link * ) calloc(1, sizeof(link))) == 0)
        !            17:                nomem();
        !            18:        return(rval);
        !            19: }
        !            20: 
        !            21: node   *
        !            22: newnode()
        !            23: {
        !            24:        node    *rval;
        !            25: 
        !            26:        if ((rval = (node * ) calloc(1, sizeof(node))) == 0)
        !            27:                nomem();
        !            28:        Ncount++;
        !            29:        return(rval);
        !            30: }
        !            31: 
        !            32: char   *
        !            33: strsave(s)
        !            34: char   *s;
        !            35: {
        !            36:        char *r;
        !            37: 
        !            38:        if ((r = malloc((unsigned int) strlen(s) + 1)) == 0)
        !            39:                nomem();
        !            40:        (void) strcpy(r, s);
        !            41:        return(r);
        !            42: }
        !            43: 
        !            44: #ifndef strclear
        !            45: void
        !            46: strclear(dst, len)
        !            47: register char *dst;
        !            48: register int len;
        !            49: {
        !            50:        while (--len >= 0)
        !            51:                *dst++ = 0;
        !            52: }
        !            53: #endif /*strclear*/
        !            54: 
        !            55: node   **
        !            56: newtable(size)
        !            57: long   size;
        !            58: {
        !            59:        node    **rval;
        !            60: 
        !            61:        if ((rval = (node **) calloc(1, (unsigned int) (size * sizeof(*rval)))) == 0) 
        !            62:                nomem();
        !            63:        return(rval);
        !            64: }
        !            65: 
        !            66: freetable(t, size)
        !            67: node   **t;
        !            68: long   size;
        !            69: {
        !            70: #ifdef MYMALLOC
        !            71:        addtoheap((char *) t, (long) (size * sizeof(*t)));
        !            72: #else
        !            73:        free((char *) t);
        !            74: #endif
        !            75: }
        !            76: 
        !            77: nomem()
        !            78: {
        !            79:        fprintf(stderr, "%s: Out of memory (%ldk allocated)\n",
        !            80:                        ProgName, allocation());
        !            81:        badmagic(1);
        !            82: }
        !            83: 
        !            84: /* data space allocation -- main sets End very early */
        !            85: allocation()
        !            86: {
        !            87:        static char     *dataspace;
        !            88: 
        !            89:        if (dataspace == 0) {   /* first time */
        !            90:                dataspace = sbrk(0);            /* &end? */
        !            91:                return(0);
        !            92:        }
        !            93:        return((sbrk(0) - dataspace)/1024);
        !            94: }
        !            95: 
        !            96: #ifdef MYMALLOC
        !            97: 
        !            98: /* use c library malloc/calloc here, and here only */
        !            99: #undef malloc
        !           100: #undef calloc
        !           101: extern char *malloc(), *calloc();
        !           102: 
        !           103: /* allocate in MBUFSIZ chunks.  4k works ok (less 16 for malloc quirks). */
        !           104: #define MBUFSIZ (4 * 1024 - 16)
        !           105: 
        !           106: /* 
        !           107:  * mess with ALIGN at your peril.  longword (== 0 mod 4)
        !           108:  * alignment seems to work everywhere.
        !           109:  */
        !           110: 
        !           111: #define ALIGN 2
        !           112: 
        !           113: typedef struct heap heap;
        !           114: struct heap {
        !           115:        heap *h_next;
        !           116:        long h_size;
        !           117: };
        !           118: 
        !           119: static heap *Mheap;    /* not to be confused with a priority queue */
        !           120: 
        !           121: addtoheap(p, size)
        !           122: char *p;
        !           123: long size;
        !           124: {
        !           125:        int adjustment;
        !           126:        heap *pheap;
        !           127: 
        !           128:        /* p is aligned, but it doesn't hurt to check */
        !           129:        adjustment = align(p);
        !           130:        p += adjustment;
        !           131:        size -= adjustment;
        !           132: 
        !           133:        if (size < 1024)
        !           134:                return;         /* can't happen */
        !           135:        pheap = (heap *) p;     /* pheap is shorthand */
        !           136:        pheap->h_next = Mheap;
        !           137:        pheap->h_size = size;
        !           138:        Mheap = pheap;
        !           139: }
        !           140: 
        !           141: /*
        !           142:  * buffered malloc()
        !           143:  *     returns space initialized to 0.  calloc isn't used, since
        !           144:  *     strclear can be faster.
        !           145:  *
        !           146:  * free is ignored, except for very large objects,
        !           147:  * which are returned to the heap with addtoheap(). 
        !           148:  */
        !           149: 
        !           150: char   *
        !           151: mymalloc(n)
        !           152: register unsigned int  n;
        !           153: {
        !           154:        static long     size;           /* how much do we have on hand? */
        !           155:        static char     *mstash;        /* where is it?  (kept aligned) */
        !           156:        register char   *rval;
        !           157: 
        !           158:        n += align((char *) n); /* keep everything aligned */
        !           159:        if (n >= 1024) {                /* from hash table */
        !           160:                rval = malloc(n);       /* aligned */
        !           161:                strclear(rval, n);
        !           162:                return(rval);
        !           163:        }
        !           164:        
        !           165: 
        !           166:        if (n > size) {
        !           167:                /* look in the heap (already aligned) */
        !           168:                if (Mheap) {
        !           169:                        mstash = (char *) Mheap;
        !           170:                        size = Mheap->h_size;
        !           171:                        Mheap = Mheap->h_next;
        !           172:                } else {
        !           173:                        mstash = malloc(MBUFSIZ);       /* aligned */
        !           174:                        if (mstash == 0) {
        !           175:                                size = 0;
        !           176:                                return(0);
        !           177:                        }
        !           178:                        size = MBUFSIZ;
        !           179:                }
        !           180:                strclear(mstash, size);
        !           181:        }
        !           182:        rval = mstash;
        !           183:        mstash += n;
        !           184:        size -= n;
        !           185:        return(rval);
        !           186: }
        !           187: 
        !           188: /* what's the (mis-)alignment of n?  return the complement of (n mod 2^ALIGN) */
        !           189: align(n)
        !           190: char   *n;
        !           191: {
        !           192:        int     abits;  /* misalignment bits in n */
        !           193: 
        !           194:        abits = (int) n & ~(0xff << ALIGN) & 0xff;
        !           195:        if (abits == 0)
        !           196:                return(0);
        !           197:        return((1 << ALIGN) - abits);
        !           198: }
        !           199: 
        !           200: #endif /*MYMALLOC*/

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