Return to alloc.c CVS log

Up to [Research Unix] / researchv9 / cmd / sun / c2

Annotation of researchv9/cmd/sun/c2/alloc.c, revision 1.1.1.1

1.1       root        1: 
                      2: #ifndef lint
                      3: static char sccsid[] = "@(#)alloc.c 1.1 86/02/03 Copyr 1983 Sun Micro";
                      4: #endif
                      5: 
                      6: /*
                      7:  * Copyright (c) 1983 by Sun Microsystems, Inc.
                      8:  */
                      9: 
                     10: #include "as.h"
                     11: #include "c2.h"
                     12: 
                     13: char *malloc();
                     14: void freeoperand();
                     15: struct oper * freeoper;
                     16: struct optree * freeoptree;
                     17: 
                     18: 
                     19: #define NCHUNK 100     /* NODES at a time, for starters */
                     20: #define MAXCHUNK 1600  /* max value of 'allocsize' parameter */
                     21: NODE *
                     22: new(){
                     23:     NODE *p;
                     24:     static int allocsize = NCHUNK;
                     25:     static NODE z = { OP_COMMENT, SUBOP_Z /* rest zero */ };
                     26: 
                     27:     if (!freenodes){
                     28:        /* allocate new ones */
                     29:        register NODE * t;
                     30:        register int nnode;
                     31:        freenodes = (NODE *)malloc( (unsigned)(allocsize * sizeof *p));
                     32:        if (freenodes==NULL) 
                     33:                sys_error("cannot allocate %d new nodes", allocsize);
                     34:        /* put all on free list */
                     35:        for (t=freenodes, nnode=allocsize-1; --nnode; t++ )
                     36:            t->forw = t+1;
                     37:        t->forw = NULL;
                     38:        if (allocsize < MAXCHUNK)
                     39:            allocsize += allocsize; /* double allocation for next time */
                     40:     }
                     41:     p = freenodes;
                     42:     freenodes = p->forw;
                     43:     *p = z;
                     44:     p->lineno = line_no;
                     45:     return p;
                     46: }
                     47: 
                     48: NODE *
                     49: addnode( p ) 
                     50:     register NODE *p;
                     51: {
                     52:     p->back = first.back;
                     53:     p->back->forw = p;
                     54:     first.back = p;
                     55:     p->forw = &first;
                     56:     return p;
                     57: }
                     58: 
                     59: NODE *
                     60: deletenode( p )
                     61:     register NODE *p;
                     62: {
                     63:     NODE *pp = p->back;
                     64:     register int i;
                     65:     if (p->op == OP_FIRST)
                     66:        sys_error("deletenode: Freeing First\n");
                     67:     if (ISINSTRUC( p->op ) || ISPSEUDO( p->op ) )
                     68:        for (i=0; i<p->nref; i++)
                     69:            freeoperand( p->ref[i] );
                     70:     pp->forw = p->forw;
                     71:     p->forw->back = pp;
                     72:     p->forw = freenodes;
                     73:     freenodes = p;
                     74:     return pp;
                     75: }
                     76: 
                     77: 
                     78: struct oper * 
                     79: newoperand( o )
                     80:     struct oper *o;
                     81: {
                     82:     struct oper *p;
                     83:     static int allocsize = NCHUNK;
                     84: 
                     85:     if (!freeoper){
                     86:        /* allocate new ones */
                     87:        register struct oper * t;
                     88:        register int nnode;
                     89:        freeoper = (struct oper *)malloc( (unsigned)(allocsize * sizeof *p));
                     90:        if (freeoper==NULL) 
                     91:                sys_error("cannot allocate %d new operands", allocsize);
                     92:        /* put all on free list */
                     93:        for (t=freeoper, nnode=allocsize-1; --nnode; t++ )
                     94:            t->nsym_o = t+1;
                     95:        t->nsym_o = NULL;
                     96:        if (allocsize < MAXCHUNK)
                     97:            allocsize += allocsize; /* double allocation for next time */
                     98:     }
                     99:     p = freeoper;
                    100:     freeoper = p->nsym_o;
                    101:     *p = *o;
                    102:     return p;
                    103: }
                    104: 
                    105: void
                    106: freeoperand( o )
                    107:     struct oper *o;
                    108: {
                    109:     if (o==NULL) return;
                    110:     o->nsym_o = freeoper;
                    111:     freeoper = o;
                    112: }
                    113: 
                    114: void
                    115: freetree( o )
                    116:     struct optree *o;
                    117: {
                    118:     if (o==NULL) return;
                    119:     o->right_t = (struct oper *)freeoptree;
                    120:     freeoptree = o;
                    121: }
                    122: 
                    123: struct optree *
                    124: newtree()
                    125: {
                    126:     struct optree *p;
                    127:     static int allocsize = NCHUNK;
                    128: 
                    129:     if (!freeoptree){
                    130:        /* allocate new ones */
                    131:        register struct optree * t;
                    132:        register int nnode;
                    133:        freeoptree = (struct optree *)malloc( (unsigned)(allocsize * sizeof *p));
                    134:        if (freeoptree==NULL) 
                    135:                sys_error("cannot allocate %d new operand subtrees", allocsize);
                    136:        /* put all on free list */
                    137:        for (t=freeoptree, nnode=allocsize-1; --nnode; t++ )
                    138:            t->right_t = (struct oper *)(t+1);
                    139:        t->right_t = NULL;
                    140:        if (allocsize < MAXCHUNK)
                    141:            allocsize += allocsize; /* double allocation for next time */
                    142:     }
                    143:     p = freeoptree;
                    144:     freeoptree = (struct optree *)(p->right_t);
                    145:     return p;
                    146: }

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