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