Return to alloc.c CVS log

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

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

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

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