Return to alloc.c CVS log

Up to [Research Unix] / researchv10no / cmd / cfront / optcfront

Annotation of researchv10no/cmd/cfront/optcfront/alloc.c, revision 1.1

1.1     ! root        1: /*ident        "@(#)ctrans:src/alloc.c 1.5" */
        !             2: /**************************************************************************
        !             3: 
        !             4:         C++ source for cfront, the C++ compiler front-end
        !             5:         written in the computer science research center of Bell Labs
        !             6: 
        !             7:         Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !             8:         THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !             9: 
        !            10: alloc.c:
        !            11: 
        !            12: *****************************************************************************/
        !            13: #include "cfront.h"
        !            14: #include "size.h"
        !            15: #include "memory.h"
        !            16: 
        !            17: const int NBITE = (CHUNK-8)/sizeof(name)-1;
        !            18: const int EBITE = (CHUNK-8)/sizeof(expr)-1;
        !            19: const int SBITE = (CHUNK-8)/sizeof(stmt)-1;
        !            20: const int TBITE = (CHUNK-8)/sizeof(table)-1;
        !            21: const int VBITE = (CHUNK-8)/sizeof(vec)-1;
        !            22: const int FBITE = (CHUNK-8)/sizeof(fct)-1;
        !            23: const int PBITE = (CHUNK-8)/sizeof(ptr)-1;
        !            24: 
        !            25: #define  mzero(p,l)  memset(p,0,l)
        !            26: 
        !            27: void* chunk(int i)     // get memory that is not to be freed
        !            28: {
        !            29:        register char* cp = malloc(i*CHUNK-8);
        !            30:        if (cp == 0) {                  // no space
        !            31:                free((char*)gtbl);      // get space for error message
        !            32:                error('i',"free store exhausted");
        !            33:        }
        !            34:        return cp;
        !            35: }
        !            36: 
        !            37: #ifdef __HAVE_SIZE_T
        !            38: #include <new.h>
        !            39: #define NEW_SIZE size_t
        !            40: #else
        !            41: #define NEW_SIZE long
        !            42: #endif
        !            43: 
        !            44: void* operator new(NEW_SIZE sz)        // get memory that might be freed
        !            45: {
        !            46:        char* p = calloc((unsigned)sz,1);
        !            47: 
        !            48: //fprintf(stderr,"alloc(%d)->%d\n",sz,p);
        !            49: 
        !            50:        if (p == 0) {                   // no space
        !            51:                free((char*)gtbl);      // get space for error message
        !            52:                error('i',"free store exhausted");
        !            53:        }
        !            54:        return p;
        !            55: }
        !            56: 
        !            57: void operator delete (void* p)
        !            58: {
        !            59:        if (p == 0) return;
        !            60: 
        !            61: //fprintf(stderr,"free(%d) %d\n",p,((int*)p)[-1]-(int)p-1+sizeof(int*));
        !            62: 
        !            63:        free((char*)p);
        !            64: }
        !            65: 
        !            66: // class new and delete operators
        !            67: 
        !            68: void*
        !            69: expr::operator new(size_t sz)
        !            70: {
        !            71:        register Pexpr p;
        !            72: 
        !            73:         if ( (p=expr_free) == 0 ) {
        !            74:                 register Pexpr q = (Pexpr) chunk(1);
        !            75:                 for (p=expr_free=&q[EBITE-1]; q<p; p--) {
        !            76:                         p->e1 = p-1;
        !            77:                         DB(p->node::allocated=0);
        !            78:                }
        !            79:                (p+1)->e1 = 0;
        !            80:                DB(p->node::allocated=0);
        !            81:        }
        !            82:        else
        !            83:                expr_free = p->e1;
        !            84: 
        !            85:        mzero(p,sz);
        !            86:        return p;
        !            87: }
        !            88: 
        !            89: void
        !            90: expr::operator delete(void* vp, size_t)
        !            91: {
        !            92:        Pexpr p = (Pexpr)vp;
        !            93: 
        !            94:        DB( if(!p->node::allocated) error('i',"deleting unallocated expr:%k! -- id==%d",p->base,p->node::id);
        !            95:            p->node::allocated = 0;
        !            96:        );
        !            97:        p->e1 = expr_free;
        !            98:        expr_free = p;
        !            99:        vp = 0;
        !           100: }
        !           101: 
        !           102: void*
        !           103: stmt::operator new(size_t sz)
        !           104: {
        !           105:        register Pstmt p;
        !           106:        if ( (p=stmt_free) == 0 ) {
        !           107:                register Pstmt q = (Pstmt) chunk(1);
        !           108:                for (p=stmt_free=&q[SBITE-1]; q<p; p--) {
        !           109:                        p->s_list = p-1;
        !           110:                        DB(p->node::allocated=0);
        !           111:                }
        !           112:                (p+1)->s_list = 0;
        !           113:                DB(p->node::allocated=0);
        !           114:        }
        !           115:        else
        !           116:                stmt_free = p->s_list;
        !           117: 
        !           118:        mzero(p,sz);
        !           119:        return p;
        !           120: }
        !           121: 
        !           122: void
        !           123: stmt::operator delete(void* vp,size_t)
        !           124: {
        !           125:        Pstmt p = (Pstmt)vp;
        !           126:        DB( if(!p->node::allocated) error('i',"deleting unallocated stmt:%k! -- id==%d",p->base,p->node::id);
        !           127:            p->node::allocated = 0;
        !           128:        );
        !           129:        p->s_list = stmt_free;
        !           130:        stmt_free = p;
        !           131:        vp = 0;
        !           132: }
        !           133: 
        !           134: void*
        !           135: name::operator new(size_t sz)
        !           136: {
        !           137:        register Pname p;
        !           138: 
        !           139:        if ( (p=name_free) == 0 ) {
        !           140:                register Pname q = (Pname) chunk(1);
        !           141:                for (p=name_free=&q[NBITE-1]; q<p; p--) {
        !           142:                        p->n_tbl_list = p-1;
        !           143:                        DB(p->node::allocated=0);
        !           144:                }
        !           145:                (p+1)->n_tbl_list = 0;
        !           146:                DB(p->node::allocated=0);
        !           147:        }
        !           148:        else
        !           149:                name_free = p->n_tbl_list;
        !           150: 
        !           151:        mzero(p,sz);
        !           152:        return p;
        !           153: }
        !           154: 
        !           155: void
        !           156: name::operator delete(void* vp,size_t)
        !           157: {
        !           158:        Pname p = (Pname)vp;
        !           159:        DB( if(!p->node::allocated) error('i',"deleting unallocated name %s! -- id==%d",p->string?p->string:"???",p->node::id);
        !           160:            p->node::allocated = 0;
        !           161:        );
        !           162:        p->n_tbl_list = name_free;
        !           163:        name_free = p;
        !           164:        vp = 0;
        !           165: }
        !           166: 
        !           167: void*
        !           168: table::operator new(size_t sz)
        !           169: {
        !           170:        register Ptable p;
        !           171: 
        !           172:        if ( (p=table_free) == 0 ) {
        !           173:                register Ptable q = (Ptable) chunk(1);
        !           174:                for (p=table_free=&q[TBITE-1]; q<p; p--) {
        !           175:                        p->next = p-1;
        !           176:                        DB(p->node::allocated=0);
        !           177:                }
        !           178:                (p+1)->next = 0;
        !           179:                DB(p->node::allocated=0);
        !           180:        }
        !           181:        else
        !           182:                table_free = p->next;
        !           183: 
        !           184:        mzero(p, sz);
        !           185:        return p;
        !           186: }
        !           187: 
        !           188: void
        !           189: table::operator delete(void* vp,size_t)
        !           190: {
        !           191:        Ptable p = (Ptable)vp;
        !           192:        DB( if(!p->node::allocated) error('i',"deleting unallocated table %d! -- id==%d",p->base,p->node::id);
        !           193:            p->node::allocated = 0;
        !           194:        );
        !           195:        p->next = table_free;
        !           196:        table_free = p;
        !           197:        vp = 0;
        !           198: }
        !           199: 
        !           200: void*
        !           201: vec::operator new(size_t sz)
        !           202: {
        !           203:        register Pvec p;
        !           204: 
        !           205:        if ( (p=vec_free) == 0 ) {
        !           206:                register Pvec q = (Pvec) chunk(1);
        !           207:                for (p=vec_free=&q[VBITE-1]; q<p; p--) {
        !           208:                        p->tlist = p-1;
        !           209:                        DB(p->node::allocated=0);
        !           210:                }
        !           211:                (p+1)->tlist = 0;
        !           212:                DB(p->node::allocated=0);
        !           213:        }
        !           214:        else
        !           215:                vec_free = (Pvec) p->tlist;
        !           216: 
        !           217:        mzero(p, sz);
        !           218:        return p;
        !           219: }
        !           220: 
        !           221: void
        !           222: vec::operator delete(void* vp,size_t)
        !           223: {
        !           224:        Pvec p = (Pvec)vp;
        !           225:        DB( if(!p->node::allocated) error('i',"deleting unallocated vec %d! -- id==%d",p->base,p->node::id);
        !           226:            p->node::allocated = 0;
        !           227:        );
        !           228:        p->tlist = vec_free;
        !           229:        vec_free = p;
        !           230:        vp = 0;
        !           231: }
        !           232: 
        !           233: void*
        !           234: fct::operator new(size_t sz)
        !           235: {
        !           236:        register Pfct p;
        !           237: 
        !           238:        if ( (p=fct_free) == 0 ) {
        !           239:                register Pfct q = (Pfct) chunk(1);
        !           240:                for (p=fct_free=&q[FBITE-1]; q<p; p--) {
        !           241:                        p->tlist = p-1;
        !           242:                        DB(p->node::allocated=0);
        !           243:                }
        !           244:                (p+1)->tlist = 0;
        !           245:                DB(p->node::allocated=0);
        !           246:        }
        !           247:        else
        !           248:                fct_free = (Pfct) p->tlist;
        !           249: 
        !           250:        mzero(p, sz);
        !           251:        return p;
        !           252: }
        !           253: 
        !           254: void
        !           255: fct::operator delete(void* vp,size_t)
        !           256: {
        !           257:        Pfct p = (Pfct)vp;
        !           258:        DB( if(!p->node::allocated) error('i',"deleting unallocated fct %d! -- id==%d",p->base,p->node::id);
        !           259:            p->node::allocated = 0;
        !           260:        );
        !           261:        p->tlist = fct_free;
        !           262:        fct_free = p;
        !           263:        vp = 0;
        !           264: }
        !           265: 
        !           266: void*
        !           267: ptr::operator new(size_t sz)
        !           268: {
        !           269:        register Pptr p;
        !           270: 
        !           271: //error('d',"ptr new");
        !           272:        if ( (p=ptr_free) == 0 ) {
        !           273:                register Pptr q = (Pptr) chunk(1);
        !           274:                for (p=ptr_free=&q[PBITE-1]; q<p; p--) {
        !           275:                        p->tlist = p-1;
        !           276:                        DB(p->node::allocated=0);
        !           277:                }
        !           278:                (p+1)->tlist = 0;
        !           279:                DB(p->node::allocated=0);
        !           280:        }
        !           281:        else 
        !           282:                ptr_free = (Pptr) p->tlist;
        !           283: 
        !           284:        mzero(p, sz);
        !           285:        return p;
        !           286: }
        !           287: 
        !           288: void
        !           289: ptr::operator delete(void* vp,size_t)
        !           290: {
        !           291:        Pptr p = (Pptr)vp;
        !           292:        DB( if(!p->node::allocated) error('i',"deleting unallocated ptr %d! -- id==%d",p->base,p->node::id);
        !           293:            p->node::allocated = 0;
        !           294:        );
        !           295:        p->tlist = ptr_free;
        !           296:        ptr_free = p;
        !           297:        vp = 0;
        !           298: }

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