![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to alloc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / xptcfront|
Return to alloc.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / xptcfront |
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.