![[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 [MW Coherent from dump] / coherent / b / bin / sh.420|
Return to alloc.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / sh.420 |
1.1 root 1: /* sh/alloc.c */
2:
3: #include "sh.h"
4:
5: extern char *malloc();
6:
7: /*
8: * Externals.
9: */
10: BUF *bufap = NULL; /* Head of allocation list */
11: BUF *buffp = NULL; /* Tail of free list */
12: BUF **bufapp = &bufap; /* Tail of allocation list */
13:
14: /*
15: * Given a string, return a pointer to a copy of it. If 'f'
16: * is set, don't add it onto the free list.
17: */
18: char *
19: duplstr(cp0, f)
20: register char *cp0;
21: {
22: register char *cp1, *cp2;
23:
24: cp1 = cp0;
25: while (*cp1++)
26: ;
27: #if 0
28: cp2 = (char *) f ? salloc (cp1 - cp0) : balloc (cp1 - cp0);
29: #else
30: if ((char *) f)
31: cp2 = salloc (cp1 - cp0);
32: else
33: cp2 = balloc (cp1 - cp0);
34: #endif
35: cp1 = cp2;
36: while (*cp1++=*cp0++)
37: ;
38: return (cp2);
39: }
40:
41: /*
42: * Create an argument list.
43: */
44: char **
45: makargl()
46: {
47: register char **app;
48:
49: app = (char **)balloc((1+IALSIZE)*sizeof(char *));
50: app++;
51: app[-1] = (char *)IALSIZE;
52: app[0] = NULL;
53: return (app);
54: }
55:
56: /*
57: * Add an element to an argument list.
58: */
59: char **
60: addargl(app, sp)
61: char **app;
62: char *sp;
63: {
64: char **napp;
65: register char **rapp;
66: register unsigned n, i;
67:
68: rapp = app;
69: n = (int)rapp[-1];
70: while (*rapp++ != NULL)
71: ;
72: if (rapp-app >= n) {
73: napp = (char **)balloc((1+n*2)*sizeof(char *));
74: napp++;
75: napp[-1] = (char *)(n*2);
76: for (i=0; i<n; i++)
77: napp[i] = app[i];
78: napp[n-1] = sp;
79: napp[n] = NULL;
80: return (napp);
81: }
82: *rapp = NULL;
83: *--rapp = sp;
84: return (app);
85: }
86:
87: /*
88: * Save allocation position.
89: */
90: BUF **
91: savebuf()
92: {
93: return (bufapp);
94: }
95:
96: /*
97: * Free everything allocated since passed allocation position
98: * was saved.
99: */
100: freebuf(bpp)
101: register BUF **bpp;
102: {
103: *bufapp = buffp;
104: buffp = *bpp;
105: *bpp = NULL;
106: bufapp = bpp;
107: }
108:
109: /*
110: * Allocate a buffer 'n' bytes long.
111: * Add it onto the allocated buffer list.
112: */
113: char *
114: balloc(n)
115: {
116: register BUF *bp, **bpp;
117:
118: bpp = &buffp;
119: for (;;) {
120: if ((bp=*bpp) == NULL) {
121: bp = (BUF *) salloc(sizeof (BUF) + n);
122: bp->b_size = n;
123: break;
124: }
125: if (bp->b_size == n) {
126: *bpp = bp->b_next;
127: break;
128: }
129: bpp = &bp->b_next;
130: }
131: *bufapp = bp;
132: bufapp = &bp->b_next;
133: *bufapp = NULL;
134: return ((char *) bp + sizeof (BUF));
135: }
136:
137: /*
138: * Allocate 'n' bytes.
139: */
140: char *
141: salloc(n)
142: {
143: register char *cp;
144: char *malloc();
145:
146: if ((cp=malloc(n)) == NULL) {
147: prints("Out of memory\n");
148: reset(RNOSBRK);
149: NOTREACHED;
150: }
151:
152: return (cp);
153: }
154:
155: /*
156: * Free something possibly allocated by 'salloc'.
157: * notmem is part of our customised malloc package which
158: * prevents freeing of static strings and automatic variables.
159: */
160: sfree(cp)
161: char *cp;
162: {
163: #if 0
164: if (cp != NULL && notmem(cp)) {
165: fprintf (stderr, "freeing \"%s\" at %x\n", cp, cp);
166: return;
167: }
168: #endif
169: free(cp);
170: }
171:
172: #ifdef ALLOC_DEBUG
173: /*
174: * For allocation debugging.
175: */
176:
177: void alloc_alloc (debug) struct alloc_debug * debug; {
178: if (++ debug->count > debug->maxcount) {
179: debug->maxcount = debug->count;
180: fprintf (stderr, "%s:%d\n", debug->name, debug->count);
181: }
182: }
183:
184: #endif
185:
186: ALLOC_COUNT (vector)
187:
188: /*
189: * Deallocate a vector.
190: */
191: vfree(vecp)
192: char **vecp;
193: {
194: register char **vpp;
195:
196: if (notmem(vecp))
197: return;
198: for (vpp = vecp; *vpp!=NULL; vpp += 1)
199: sfree(*vpp);
200: sfree(vecp);
201: ALLOC_FREE (vector)
202: }
203:
204: char **
205: vdupl(vecp)
206: char **vecp;
207: {
208: register char **vp, **nvp, **tvp;
209:
210: for (vp=vecp; *vp++ != NULL; );
211: tvp = nvp = (char **)salloc((vp - vecp) * sizeof *vp);
212: for (vp=vecp; *vp != NULL; )
213: *tvp++ = duplstr(*vp++, 1);
214: *tvp = NULL;
215: ALLOC_ALLOC (vector);
216: return (nvp);
217: }
218:
219: /* end of sh/alloc.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.