The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame^] | 1 | /* $NetBSD: memalloc.c,v 1.28 2003/08/07 09:05:34 agc 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.28 2003/08/07 09:05:34 agc 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 |
| 59 | ckmalloc(int 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 |
| 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 * |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 * |
| 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 * |
| 292 | makestrspace(void) |
| 293 | { |
| 294 | int len = stackblocksize() - sstrnleft; |
| 295 | growstackblock(); |
| 296 | sstrnleft = stackblocksize() - len; |
| 297 | return stackblock() + len; |
| 298 | } |
| 299 | |
| 300 | void |
| 301 | ungrabstackstr(char *s, char *p) |
| 302 | { |
| 303 | stacknleft += stacknxt - s; |
| 304 | stacknxt = s; |
| 305 | sstrnleft = stacknleft - (p - s); |
| 306 | |
| 307 | } |