Return to talloc.c CVS log

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

Annotation of coherent/b/bin/c/common/talloc.c, revision 1.1.1.1

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

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