![[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 / optcfront|
Return to alloc.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / optcfront |
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.