Return to talloc.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin / cc / c / common

Annotation of coherent/d/bin/cc/c/common/talloc.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * C compiler.
        !             3:  * Tree space sub-allocator.
        !             4:  */
        !             5: #ifdef   vax
        !             6: #include "INC$LIB:cc0.h"
        !             7: #else
        !             8: #include "cc0.h"
        !             9: #endif
        !            10: 
        !            11: /*
        !            12:  * Tree space management.
        !            13:  */
        !            14: struct tree_space {
        !            15:        struct tree_space *ts_link;
        !            16:        char *ts_ptr;
        !            17:        char *ts_end;
        !            18:        char ts_base[];
        !            19: } *ts_bp, *ts_cp;
        !            20: int ts_size;
        !            21: 
        !            22: /*
        !            23:  * Allocate some space from the tree area.
        !            24:  * Always allocate the size of a tree node,
        !            25:  * the other uses are too few and far between
        !            26:  * to bother with.
        !            27:  * Abort the compiler if no space to get.
        !            28:  * To make life a lot easier for the rest of the world,
        !            29:  * tree space is zeroed.
        !            30:  */
        !            31: extern char *malloc();
        !            32: char *talloc()
        !            33: {
        !            34:        register char *p;
        !            35:        register int n;
        !            36: 
        !            37:        n = ts_size;
        !            38:        if (ts_cp->ts_ptr == ts_cp->ts_end) {
        !            39:            if (ts_cp->ts_link == NULL) {
        !            40:                if ((ts_cp->ts_link = malloc(sizeof(*ts_bp)+n*128)) == NULL)
        !            41:                    cfatal("out of space in tree node allocator");
        !            42:                ts_cp->ts_link->ts_link = NULL;
        !            43:            }
        !            44:            ts_cp = ts_cp->ts_link;
        !            45:            ts_cp->ts_ptr = ts_cp->ts_base;
        !            46:            ts_cp->ts_end = ts_cp->ts_base+n*128;
        !            47:        }
        !            48:        p = ts_cp->ts_ptr += n;
        !            49:        while (--n >= 0) *--p = 0;
        !            50:        return (p);
        !            51: }
        !            52: 
        !            53: /*
        !            54:  * Clear tree space.
        !            55:  * If tsize == ts_size then reset the tree allocator.
        !            56:  * If tsize != ts_size then free all space allocated
        !            57:  * and if tsize != 0 then reallocate with new granularity.
        !            58:  * tsize is the size of the tree nodes allocated.
        !            59:  */
        !            60: newtree(tsize) int tsize;
        !            61: {
        !            62:        if (tsize != ts_size) {
        !            63:                while (ts_bp != NULL) {
        !            64:                        ts_cp = ts_bp;
        !            65:                        ts_bp = ts_bp->ts_link;
        !            66:                        free(ts_cp);
        !            67:                }
        !            68:                if (ts_size = tsize) {
        !            69:                    if ((ts_bp = malloc(sizeof(*ts_bp) + ts_size*128)) == NULL)
        !            70:                        cfatal("no space in tree allocator");
        !            71:                    ts_bp->ts_link = NULL;
        !            72:                } else {
        !            73:                    ts_bp = NULL;
        !            74:                }
        !            75:        }
        !            76:        if (ts_cp = ts_bp) {
        !            77:                ts_cp->ts_ptr = ts_cp->ts_base;
        !            78:                ts_cp->ts_end = ts_cp->ts_base+ts_size*128;
        !            79:        }
        !            80: }
        !            81: 
        !            82: /*
        !            83:  * Reset tree space to saved location.
        !            84:  * Used to parse #if expressions in mid-expression.
        !            85:  */
        !            86: treset(p) char *p;
        !            87: {
        !            88:        for (ts_cp = ts_bp; ts_cp != NULL; ts_cp = ts_cp->ts_link)
        !            89:                if (ts_cp->ts_base <= p && p <= ts_cp->ts_end)
        !            90:                        break;
        !            91:        if (ts_cp == NULL) cbotch("tree reset");
        !            92:        ts_cp->ts_ptr = p;
        !            93: }
        !            94: 

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