![[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 / d / bin / sh|
Return to alloc.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / sh |
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: cp2 = (char *) f ? salloc(cp1-cp0) : balloc(cp1-cp0);
28: cp1 = cp2;
29: while (*cp1++=*cp0++)
30: ;
31: return (cp2);
32: }
33:
34: /*
35: * Create an argument list.
36: */
37: char **
38: makargl()
39: {
40: register char **app;
41:
42: app = (char **)balloc((1+IALSIZE)*sizeof(char *));
43: app++;
44: app[-1] = (char *)IALSIZE;
45: app[0] = NULL;
46: return (app);
47: }
48:
49: /*
50: * Add an element to an argument list.
51: */
52: char **
53: addargl(app, sp)
54: char **app;
55: char *sp;
56: {
57: char **napp;
58: register char **rapp;
59: register unsigned n, i;
60:
61: rapp = app;
62: n = (int)rapp[-1];
63: while (*rapp++ != NULL)
64: ;
65: if (rapp-app >= n) {
66: napp = (char **)balloc((1+n*2)*sizeof(char *));
67: napp++;
68: napp[-1] = (char *)(n*2);
69: for (i=0; i<n; i++)
70: napp[i] = app[i];
71: napp[n-1] = sp;
72: napp[n] = NULL;
73: return (napp);
74: }
75: *rapp = NULL;
76: *--rapp = sp;
77: return (app);
78: }
79:
80: /*
81: * Save allocation position.
82: */
83: BUF **
84: savebuf()
85: {
86: return (bufapp);
87: }
88:
89: /*
90: * Free everything allocated since passed allocation position
91: * was saved.
92: */
93: freebuf(bpp)
94: register char **bpp;
95: {
96: *bufapp = buffp;
97: buffp = *bpp;
98: *bpp = NULL;
99: bufapp = bpp;
100: }
101:
102: /*
103: * Allocate a buffer 'n' bytes long.
104: * Add it onto the allocated buffer list.
105: */
106: char *
107: balloc(n)
108: {
109: register BUF *bp, **bpp;
110:
111: bpp = &buffp;
112: for (;;) {
113: if ((bp=*bpp) == NULL) {
114: bp = (BUF *) salloc(sizeof (BUF) + n);
115: bp->b_size = n;
116: break;
117: }
118: if (bp->b_size == n) {
119: *bpp = bp->b_next;
120: break;
121: }
122: bpp = &bp->b_next;
123: }
124: *bufapp = bp;
125: bufapp = &bp->b_next;
126: *bufapp = NULL;
127: return ((char *) bp + sizeof (BUF));
128: }
129:
130: /*
131: * Allocate 'n' bytes.
132: */
133: char *
134: salloc(n)
135: {
136: register char *cp;
137: char *malloc();
138:
139: if ((cp=malloc(n)) == NULL) {
140: prints("Out of memory\n");
141: reset(RNOSBRK);
142: NOTREACHED;
143: }
144: return (cp);
145: }
146:
147: /*
148: * Free something possibly allocated by 'salloc'.
149: * notmem is part of our customised malloc package which
150: * prevents freeing of static strings and automatic variables.
151: */
152: sfree(cp)
153: char *cp;
154: {
155: if (notmem(cp))
156: return;
157: free(cp);
158: }
159:
160: /*
161: * Deallocate a vector.
162: */
163: vfree(vecp)
164: char **vecp;
165: {
166: register char **vpp;
167:
168: if (notmem(vecp))
169: return;
170: for (vpp = vecp; *vpp!=NULL; vpp += 1)
171: sfree(*vpp);
172: sfree(vecp);
173: }
174:
175: char **
176: vdupl(vecp)
177: char **vecp;
178: {
179: register char **vp, **nvp, **tvp;
180:
181: for (vp=vecp; *vp++ != NULL; );
182: tvp = nvp = (char **)salloc((vp - vecp) * sizeof *vp);
183: for (vp=vecp; *vp != NULL; )
184: *tvp++ = duplstr(*vp++, 1);
185: *tvp = NULL;
186: return (nvp);
187: }
188:
189: /* end of sh/alloc.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.