Return to alc.c CVS log

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

Annotation of coherent/d/bin/tsort/alc.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include <sys/mdata.h>
        !             3: #include "tsort.h"
        !             4: 
        !             5: 
        !             6: #define BUMP   2048    /* twice minimum space to get from malloc */
        !             7: 
        !             8: 
        !             9: /*
        !            10:  *     Blockp is a pointer to a block of memory from which the
        !            11:  *     various allocation routines will get memory.  Blockc is
        !            12:  *     the number of bytes left in the block.  When these bytes
        !            13:  *     are all used up, then malloc is called for BUMP more
        !            14:  *     bytes.  This save malloc from going over all the small
        !            15:  *     blocks.
        !            16:  */
        !            17: 
        !            18: static char *blockp;
        !            19: static int blockc = 0;
        !            20: 
        !            21: 
        !            22: /*
        !            23:  *     Alloc functions exactly like malloc with two exceptions
        !            24:  *             1. It tries to get memory from blockp/blockc if
        !            25:  *                possible.
        !            26:  *             2. It never returns NULL, but instead exits with
        !            27:  *                an error message if there is no memory left.
        !            28:  */
        !            29: 
        !            30: static char *
        !            31: alloc(size)
        !            32: register unsigned size;
        !            33: {
        !            34:        register char *result;
        !            35:        char    *malloc();
        !            36: 
        !            37:        /*
        !            38:         * for alignment constraints.
        !            39:         */
        !            40:        size += ALSTRUCT - 1;
        !            41:        size -= size % ALSTRUCT;
        !            42:        if (blockc >= size) {
        !            43:                blockc -= size;
        !            44:                result = blockp;
        !            45:                blockp += size;
        !            46:                return (result);
        !            47:        }
        !            48:        if (size < BUMP / 2) {
        !            49:                result = (char *)malloc(size + BUMP);
        !            50:                blockp = result + size;
        !            51:                blockc = BUMP;
        !            52:        } else
        !            53:                result = (char *)malloc(size);
        !            54:        if (result == NULL)
        !            55:                die("out of memory");
        !            56:        return (result);
        !            57: }
        !            58: 
        !            59: 
        !            60: 
        !            61: /*
        !            62:  *     Newword returns a pointer to a word with the ancestors
        !            63:  *     field set to NULL and the name field set to "str".
        !            64:  */
        !            65: 
        !            66: struct word *
        !            67: newword(str)
        !            68: register char *str;
        !            69: {
        !            70:        register struct word *result;
        !            71: 
        !            72:        result = (struct word *) alloc( sizeof(struct word));
        !            73:        result->name = alloc(strlen(str) + 1);
        !            74:        strcpy(result->name, str);
        !            75:        result->ancestors = NULL;
        !            76:        return (result);
        !            77: }
        !            78: 
        !            79: 
        !            80: /*
        !            81:  *     Newwordl returns a pointer to a wordlist with the element
        !            82:  *     field set to "wrd".
        !            83:  */
        !            84: 
        !            85: struct wordlist *
        !            86: newwordl(wrd)
        !            87: register struct word *wrd;
        !            88: {
        !            89:        register struct wordlist *result;
        !            90: 
        !            91:        result = (struct wordlist *) alloc( sizeof(struct wordlist));
        !            92:        result->element = wrd;
        !            93:        return (result);
        !            94: }

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