Return to alloc.c CVS log

Up to [Research Unix] / researchv10no / cmd / cfront / cfront2.00

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

1.1     ! root        1: /*ident        "@(#)ctrans:src/alloc.c 1.1.1.8" */
        !             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: 
        !            16: //int Nchunk;
        !            17: 
        !            18: //void print_free()
        !            19: //{
        !            20: //     fprintf(stderr,"free store: %d bytes alloc()=%d free()=%d\n",Nfree_store,Nal//loc, Nfree);
        !            21: //     fprintf(stderr,"%d chunks: %d (%d)\n",Nchunk,CHUNK,Nchunk*CHUNK);
        !            22: //}
        !            23: 
        !            24: 
        !            25: void* chunk(int i)     // get memory that is not to be freed
        !            26: {
        !            27:        register char* cp = malloc(i*CHUNK-8);
        !            28:        if (cp == 0) {                  // no space
        !            29:                free((char*)gtbl);      // get space for error message
        !            30: //             if (Nspy) print_free();
        !            31:                error('i',"free store exhausted");
        !            32:        }
        !            33: //     Nchunk += i;
        !            34: //     Nfree_store += i*CHUNK;
        !            35:        return cp;
        !            36: }
        !            37: 
        !            38: /*
        !            39: #ifdef __cplusplus
        !            40: #include <new.h>
        !            41: #define NEW_SIZE size_t
        !            42: #else
        !            43: #define NEW_SIZE long
        !            44: #endif
        !            45: */
        !            46: 
        !            47: // now __HAVE_SIZE_T defined in 2.0 malloc.h c++ header file
        !            48: #ifdef __HAVE_SIZE_T
        !            49: #include <new.h>
        !            50: #define NEW_SIZE size_t
        !            51: #else
        !            52: #define NEW_SIZE long
        !            53: #endif
        !            54: 
        !            55: void* operator new(NEW_SIZE sz)        // get memory that might be freed
        !            56: {
        !            57:        char* p = calloc((unsigned)sz,1);
        !            58: 
        !            59: //fprintf(stderr,"alloc(%d)->%d\n",sz,p);
        !            60:        if (p == 0) {                   // no space
        !            61:                free((char*)gtbl);      // get space for error message
        !            62: //             if (Nspy) print_free();
        !            63:                error('i',"free store exhausted");
        !            64:        }
        !            65: //     Nalloc++;
        !            66: //     Nfree_store += sz+sizeof(int*);
        !            67:        return p;
        !            68: }
        !            69: //int NFn, NFtn, NFbt, NFpv, NFf, NFe, NFs, NFc;
        !            70: 
        !            71: void operator delete (void* p)
        !            72: {
        !            73:        if (p == 0) return;
        !            74: 
        !            75: //fprintf(stderr,"free(%d) %d\n",p,((int*)p)[-1]-(int)p-1+sizeof(int*));
        !            76: 
        !            77: //if (Nspy) {
        !            78: //     Pname pp = (Pname) p;
        !            79: //     TOK t = pp->base;
        !            80: //     Nfree++;
        !            81: //     Nfree_store -= ((int*)p)[-1]-(int)p-1+sizeof(int*);
        !            82: //     switch (t) {    // can be fooled by character strings
        !            83: //     case INT: case CHAR: case TYPE: case VOID: case SHORT: case LONG:
        !            84: //     case FLOAT: case DOUBLE: case LDOUBLE: case COBJ: case EOBJ: case FIELD:
        !            85: //                     NFbt++; break;
        !            86: //
        !            87: //     case PTR: case VEC:
        !            88: //                     NFpv++; break;
        !            89: //
        !            90: //     case FCT:       NFf++; break;
        !            91: //
        !            92: //     case ICON: case CCON: case STRING: case FCON: case THIS:
        !            93: //                     NFc++; break;
        !            94: //     }
        !            95: //}
        !            96:        free((char*)p);
        !            97: }

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