xref: /minix/bin/sh/memalloc.c (revision d90bee97)
1 /*	$NetBSD: memalloc.c,v 1.29 2008/02/15 17:26:06 matt Exp $	*/
2 
3 /*-
4  * Copyright (c) 1991, 1993
5  *	The Regents of the University of California.  All rights reserved.
6  *
7  * This code is derived from software contributed to Berkeley by
8  * Kenneth Almquist.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. Neither the name of the University nor the names of its contributors
19  *    may be used to endorse or promote products derived from this software
20  *    without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  */
34 
35 #include <sys/cdefs.h>
36 #ifndef lint
37 #if 0
38 static char sccsid[] = "@(#)memalloc.c	8.3 (Berkeley) 5/4/95";
39 #else
40 __RCSID("$NetBSD: memalloc.c,v 1.29 2008/02/15 17:26:06 matt Exp $");
41 #endif
42 #endif /* not lint */
43 
44 #include <stdlib.h>
45 #include <unistd.h>
46 
47 #include "shell.h"
48 #include "output.h"
49 #include "memalloc.h"
50 #include "error.h"
51 #include "machdep.h"
52 #include "mystring.h"
53 
54 /*
55  * Like malloc, but returns an error when out of space.
56  */
57 
58 pointer
ckmalloc(size_t nbytes)59 ckmalloc(size_t nbytes)
60 {
61 	pointer p;
62 
63 	p = malloc(nbytes);
64 	if (p == NULL)
65 		error("Out of space");
66 	return p;
67 }
68 
69 
70 /*
71  * Same for realloc.
72  */
73 
74 pointer
ckrealloc(pointer p,int nbytes)75 ckrealloc(pointer p, int nbytes)
76 {
77 	p = realloc(p, nbytes);
78 	if (p == NULL)
79 		error("Out of space");
80 	return p;
81 }
82 
83 
84 /*
85  * Make a copy of a string in safe storage.
86  */
87 
88 char *
savestr(const char * s)89 savestr(const char *s)
90 {
91 	char *p;
92 
93 	p = ckmalloc(strlen(s) + 1);
94 	scopy(s, p);
95 	return p;
96 }
97 
98 
99 /*
100  * Parse trees for commands are allocated in lifo order, so we use a stack
101  * to make this more efficient, and also to avoid all sorts of exception
102  * handling code to handle interrupts in the middle of a parse.
103  *
104  * The size 504 was chosen because the Ultrix malloc handles that size
105  * well.
106  */
107 
108 #define MINSIZE 504		/* minimum size of a block */
109 
110 struct stack_block {
111 	struct stack_block *prev;
112 	char space[MINSIZE];
113 };
114 
115 struct stack_block stackbase;
116 struct stack_block *stackp = &stackbase;
117 struct stackmark *markp;
118 char *stacknxt = stackbase.space;
119 int stacknleft = MINSIZE;
120 int sstrnleft;
121 int herefd = -1;
122 
123 pointer
stalloc(int nbytes)124 stalloc(int nbytes)
125 {
126 	char *p;
127 
128 	nbytes = SHELL_ALIGN(nbytes);
129 	if (nbytes > stacknleft) {
130 		int blocksize;
131 		struct stack_block *sp;
132 
133 		blocksize = nbytes;
134 		if (blocksize < MINSIZE)
135 			blocksize = MINSIZE;
136 		INTOFF;
137 		sp = ckmalloc(sizeof(struct stack_block) - MINSIZE + blocksize);
138 		sp->prev = stackp;
139 		stacknxt = sp->space;
140 		stacknleft = blocksize;
141 		stackp = sp;
142 		INTON;
143 	}
144 	p = stacknxt;
145 	stacknxt += nbytes;
146 	stacknleft -= nbytes;
147 	return p;
148 }
149 
150 
151 void
stunalloc(pointer p)152 stunalloc(pointer p)
153 {
154 	if (p == NULL) {		/*DEBUG */
155 		write(2, "stunalloc\n", 10);
156 		abort();
157 	}
158 	stacknleft += stacknxt - (char *)p;
159 	stacknxt = p;
160 }
161 
162 
163 
164 void
setstackmark(struct stackmark * mark)165 setstackmark(struct stackmark *mark)
166 {
167 	mark->stackp = stackp;
168 	mark->stacknxt = stacknxt;
169 	mark->stacknleft = stacknleft;
170 	mark->marknext = markp;
171 	markp = mark;
172 }
173 
174 
175 void
popstackmark(struct stackmark * mark)176 popstackmark(struct stackmark *mark)
177 {
178 	struct stack_block *sp;
179 
180 	INTOFF;
181 	markp = mark->marknext;
182 	while (stackp != mark->stackp) {
183 		sp = stackp;
184 		stackp = sp->prev;
185 		ckfree(sp);
186 	}
187 	stacknxt = mark->stacknxt;
188 	stacknleft = mark->stacknleft;
189 	INTON;
190 }
191 
192 
193 /*
194  * When the parser reads in a string, it wants to stick the string on the
195  * stack and only adjust the stack pointer when it knows how big the
196  * string is.  Stackblock (defined in stack.h) returns a pointer to a block
197  * of space on top of the stack and stackblocklen returns the length of
198  * this block.  Growstackblock will grow this space by at least one byte,
199  * possibly moving it (like realloc).  Grabstackblock actually allocates the
200  * part of the block that has been used.
201  */
202 
203 void
growstackblock(void)204 growstackblock(void)
205 {
206 	int newlen = SHELL_ALIGN(stacknleft * 2 + 100);
207 
208 	if (stacknxt == stackp->space && stackp != &stackbase) {
209 		struct stack_block *oldstackp;
210 		struct stackmark *xmark;
211 		struct stack_block *sp;
212 
213 		INTOFF;
214 		oldstackp = stackp;
215 		sp = stackp;
216 		stackp = sp->prev;
217 		sp = ckrealloc((pointer)sp,
218 		    sizeof(struct stack_block) - MINSIZE + newlen);
219 		sp->prev = stackp;
220 		stackp = sp;
221 		stacknxt = sp->space;
222 		stacknleft = newlen;
223 
224 		/*
225 		 * Stack marks pointing to the start of the old block
226 		 * must be relocated to point to the new block
227 		 */
228 		xmark = markp;
229 		while (xmark != NULL && xmark->stackp == oldstackp) {
230 			xmark->stackp = stackp;
231 			xmark->stacknxt = stacknxt;
232 			xmark->stacknleft = stacknleft;
233 			xmark = xmark->marknext;
234 		}
235 		INTON;
236 	} else {
237 		char *oldspace = stacknxt;
238 		int oldlen = stacknleft;
239 		char *p = stalloc(newlen);
240 
241 		(void)memcpy(p, oldspace, oldlen);
242 		stacknxt = p;			/* free the space */
243 		stacknleft += newlen;		/* we just allocated */
244 	}
245 }
246 
247 void
grabstackblock(int len)248 grabstackblock(int len)
249 {
250 	len = SHELL_ALIGN(len);
251 	stacknxt += len;
252 	stacknleft -= len;
253 }
254 
255 /*
256  * The following routines are somewhat easier to use than the above.
257  * The user declares a variable of type STACKSTR, which may be declared
258  * to be a register.  The macro STARTSTACKSTR initializes things.  Then
259  * the user uses the macro STPUTC to add characters to the string.  In
260  * effect, STPUTC(c, p) is the same as *p++ = c except that the stack is
261  * grown as necessary.  When the user is done, she can just leave the
262  * string there and refer to it using stackblock().  Or she can allocate
263  * the space for it using grabstackstr().  If it is necessary to allow
264  * someone else to use the stack temporarily and then continue to grow
265  * the string, the user should use grabstack to allocate the space, and
266  * then call ungrabstr(p) to return to the previous mode of operation.
267  *
268  * USTPUTC is like STPUTC except that it doesn't check for overflow.
269  * CHECKSTACKSPACE can be called before USTPUTC to ensure that there
270  * is space for at least one character.
271  */
272 
273 char *
growstackstr(void)274 growstackstr(void)
275 {
276 	int len = stackblocksize();
277 	if (herefd >= 0 && len >= 1024) {
278 		xwrite(herefd, stackblock(), len);
279 		sstrnleft = len - 1;
280 		return stackblock();
281 	}
282 	growstackblock();
283 	sstrnleft = stackblocksize() - len - 1;
284 	return stackblock() + len;
285 }
286 
287 /*
288  * Called from CHECKSTRSPACE.
289  */
290 
291 char *
makestrspace(void)292 makestrspace(void)
293 {
294 	int len = stackblocksize() - sstrnleft;
295 	growstackblock();
296 	sstrnleft = stackblocksize() - len;
297 	return stackblock() + len;
298 }
299 
300 void
ungrabstackstr(char * s,char * p)301 ungrabstackstr(char *s, char *p)
302 {
303 	stacknleft += stacknxt - s;
304 	stacknxt = s;
305 	sstrnleft = stacknleft - (p - s);
306 
307 }
308