![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to alc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / icon / rt|
Return to alc.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / icon / rt |
1.1 root 1: #include "../h/rt.h"
2: #include "../h/gc.h"
3: #include "../h/record.h"
4:
5: /*
6: * allocate - returns pointer to nbytes of free storage in heap.
7: */
8:
9: union block *allocate(nbytes)
10: int nbytes;
11: {
12: register unsigned fspace, *sloc;
13:
14: /*
15: * See if there is enough room in the heap.
16: */
17: fspace = maxheap - hpfree;
18: if (fspace < nbytes)
19: runerr(301, NULL);
20:
21: /*
22: * Decrement the free space in the heap by the number of bytes allocated
23: * and return the address of the first byte of the allocated block.
24: */
25: sloc = (unsigned *) hpfree;
26: heapneed -= nbytes;
27: hpfree = hpfree + nbytes;
28: return (union block *) (sloc);
29: }
30:
31: #ifdef LONGS
32: /*
33: * alclint - allocate a long integer block in the heap.
34: */
35:
36: struct b_int *alclint(val)
37: long val;
38: {
39: register struct b_int *blk;
40: extern union block *allocate();
41:
42: blk = allocate(sizeof(struct b_int));
43: blk->type = T_LONGINT;
44: blk->intval = val;
45: return (blk);
46: }
47: #endif LONGS
48: /*
49: * alcreal - allocate a real value in the heap.
50: */
51:
52: struct b_real *alcreal(val)
53: double val;
54: {
55: register struct b_real *blk;
56: extern union block *allocate();
57:
58: blk = (struct b_real *) allocate(sizeof(struct b_real));
59: blk->type = T_REAL;
60: blk->realval = val;
61: return (blk);
62: }
63:
64: /*
65: * alccset - allocate a cset in the heap.
66: */
67:
68: struct b_cset *alccset()
69: {
70: register struct b_cset *blk;
71: register i;
72: extern union block *allocate();
73:
74: blk = (struct b_cset *) allocate(sizeof(struct b_cset));
75: blk->type = T_CSET;
76: /*
77: * Zero out the bit array.
78: */
79: for (i = 0; i < CSETSIZE; i++)
80: blk->bits[i] = 0;
81: return (blk);
82: }
83:
84:
85: /*
86: * alcfile - allocate a file block in the heap.
87: */
88:
89: struct b_file *alcfile(fd, status, name)
90: FILE *fd;
91: int status;
92: struct descrip *name;
93: {
94: register struct b_file *blk;
95: extern union block *allocate();
96:
97: blk = (struct b_file *) allocate(sizeof(struct b_file));
98: blk->type = T_FILE;
99: blk->fd = fd;
100: blk->status = status;
101: blk->fname = *name;
102: return (blk);
103: }
104:
105: /*
106: * alcrecd - allocate record with nfield fields in the heap.
107: */
108:
109: struct b_record *alcrecd(nfields, recptr)
110: int nfields;
111: struct b_proc *recptr;
112: {
113: register struct b_record *blk;
114: register i, size;
115: extern union block *allocate();
116:
117: size = vsizeof(struct b_record) + nfields*sizeof(struct descrip);
118: blk = (struct b_record *) allocate(size);
119: blk->type = T_RECORD;
120: blk->size = size;
121: blk->recptr = recptr;
122: /*
123: * Assign &null to each field in the record.
124: */
125: for (i = 0; i < nfields; i++)
126: blk->fields[i] = nulldesc;
127: return (blk);
128: }
129:
130: /*
131: * alclist - allocate a list header block in the heap.
132: */
133:
134: struct b_list *alclist(size)
135: int size;
136: {
137: register struct b_list *blk;
138: extern union block *allocate();
139:
140: blk = (struct b_list *) allocate(sizeof(struct b_list));
141: blk->type = T_LIST;
142: blk->cursize = size;
143: blk->listhead = nulldesc;
144: return (blk);
145: }
146:
147: /*
148: * alclstb - allocate a list element block in the heap.
149: */
150:
151: struct b_lelem *alclstb(nelem, first, nused)
152: int nelem, first, nused;
153: {
154: register struct b_lelem *blk;
155: register int i, size;
156: extern union block *allocate();
157:
158: #ifdef MAXLISTSIZE
159: if (nelem >= MAXLISTSIZE)
160: runerr(205, NULL);
161: #endif MAXLISTSIZE
162: size = vsizeof(struct b_lelem)+nelem*sizeof(struct descrip);
163: blk = (struct b_lelem *) allocate(size);
164: blk->type = T_LELEM;
165: blk->size = size;
166: blk->nelem = nelem;
167: blk->first = first;
168: blk->nused = nused;
169: blk->listprev = nulldesc;
170: blk->listnext = nulldesc;
171: /*
172: * Set all elements to &null.
173: */
174: for (i = 0; i < nelem; i++)
175: blk->lslots[i] = nulldesc;
176: return (blk);
177: }
178:
179: /*
180: * alctable - allocate a table header block in the heap.
181: */
182:
183: struct b_table *alctable(def)
184: struct descrip *def;
185: {
186: register int i;
187: register struct b_table *blk;
188: extern union block *allocate();
189:
190: blk = (struct b_table *) allocate(sizeof(struct b_table));
191: blk->type = T_TABLE;
192: blk->cursize = 0;
193: blk->defvalue = *def;
194: /*
195: * Zero out the buckets.
196: */
197: for (i = 0; i < NBUCKETS; i++)
198: blk->buckets[i] = nulldesc;
199: return (blk);
200: }
201: /*
202: * alctelem - allocate a table element block in the heap.
203: */
204:
205: struct b_telem *alctelem()
206: {
207: register struct b_telem *blk;
208: extern union block *allocate();
209:
210: blk = (struct b_telem *) allocate(sizeof(struct b_telem));
211: blk->type = T_TELEM;
212: blk->hashnum = 0;
213: blk->blink = nulldesc;
214: blk->tref = nulldesc;
215: blk->tval = nulldesc;
216: return (blk);
217: }
218: #ifdef SETS
219:
220: /*
221: * alcset - allocate a set header heap block.
222: */
223:
224: struct b_set *alcset()
225: {
226: register int i;
227: register struct b_set *blk;
228: extern union block *allocate();
229:
230: blk = (struct b_set *) allocate(sizeof(struct b_set));
231: blk->type = T_SET;
232: blk->setsize = 0;
233: /*
234: * Zero out the buckets.
235: */
236: for (i = 0; i < NBUCKETS; i++)
237: blk->sbucks[i] = nulldesc;
238: return (blk);
239: }
240:
241: /*
242: * alcselem - allocate a set element heap block.
243: */
244:
245: struct b_selem *alcselem(mbr,hn)
246: int hn;
247: struct descrip *mbr;
248:
249: { register struct b_selem *blk;
250: extern union block *allocate();
251:
252: blk = (struct b_selem *) allocate(sizeof(struct b_selem));
253: blk->type = T_SELEM;
254: blk->sblink = nulldesc;
255: blk->setmem = *mbr;
256: blk->hnum = hn;
257: return (blk);
258: }
259: #endif SETS
260:
261: /*
262: * alcsubs - allocate a substring trapped variable in heap.
263: */
264:
265: struct b_tvsubs *alcsubs(len, pos, var)
266: int len, pos;
267: struct descrip *var;
268: {
269: register struct b_tvsubs *blk;
270: extern union block *allocate();
271:
272: blk = (struct b_tvsubs *) allocate(sizeof(struct b_tvsubs));
273: blk->type = T_TVSUBS;
274: blk->sslen = len;
275: blk->sspos = pos;
276: blk->ssvar = *var;
277: return (blk);
278: }
279:
280: /*
281: * alctvtbl - allocate a table element trapped variable block in the heap.
282: */
283:
284: struct b_tvtbl *alctvtbl(tbl, ref, hnum)
285: register struct descrip *tbl, *ref;
286: int hnum;
287: {
288: register struct b_tvtbl *blk;
289: extern union block *allocate();
290:
291: blk = (struct b_tvtbl *) allocate(sizeof(struct b_tvtbl));
292: blk->type = T_TVTBL;
293: blk->hashnum = hnum;
294: blk->tvtable = *tbl;
295: blk->tvtref = *ref;
296: blk->tvtval = nulldesc;
297: return (blk);
298: }
299:
300: /*
301: * alcstr - allocate a string in the string space.
302: */
303:
304: char *alcstr(s, slen)
305: register char *s;
306: register int slen;
307: {
308: register char *d;
309: char *ofree;
310:
311: /*
312: * See if there is enough room in the string space.
313: */
314: if (sfree + slen > estrings)
315: runerr(302, NULL);
316: strneed -= slen;
317: /*
318: * Copy the string into the string space, saving a pointer to its
319: * beginning. Note that s may be null, in which case the space is
320: * still to be allocated, but nothing is to be copied into it.
321: */
322: ofree = d = sfree;
323: if (s != NULL) {
324: while (slen-- > 0)
325: *d++ = *s++;
326: }
327: else
328: d += slen;
329: sfree = d;
330: return (ofree);
331: }
332:
333: /*
334: * alcestk - allocate a co-expression stack block.
335: */
336:
337: struct b_estack *alcestk()
338: {
339: struct b_estack *ep;
340:
341: if (esfree == NULL)
342: syserr("no expression stack space");
343: /*
344: * Locate the start of the block.
345: */
346: ep = (struct b_estack *) (esfree +
347: (stksize-sizeof(struct b_estack)/WORDSIZE));
348: /*
349: * Move co-expression stack free-list pointer to next stack.
350: */
351: esfree = (int *) *esfree;
352: ep->type = T_ESTACK;
353: return (ep);
354: }
355:
356: /*
357: * alceblk - allocate a co-expression heap block.
358: */
359:
360: struct b_eblock *alceblk(entry, na, nl)
361: int *entry, na, nl;
362: {
363: int size;
364: struct b_eblock *blk;
365: extern union block *allocate();
366:
367: size = vsizeof(struct b_eblock)+(na+nl+1)*sizeof(struct descrip);
368: blk = (struct b_eblock *) allocate(size);
369: blk->type = T_EBLOCK;
370: blk->size = size;
371: blk->ep = entry;
372: blk->numargs = na;
373: blk->numlocals = nl;
374: return (blk);
375: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.