1/* obstack.c - subroutines used implicitly by object stack macros 2 Copyright (C) 1988-1994,96,97,98,99 Free Software Foundation, Inc. 3 4 This file is part of the GNU C Library. Its master source is NOT part of 5 the C library, however. The master source lives in /gd/gnu/lib. 6 7 The GNU C Library is free software; you can redistribute it and/or 8 modify it under the terms of the GNU Library General Public License as 9 published by the Free Software Foundation; either version 2 of the 10 License, or (at your option) any later version. 11 12 The GNU C Library is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 Library General Public License for more details. 16 17 You should have received a copy of the GNU Library General Public 18 License along with the GNU C Library; see the file COPYING.LIB. If not, 19 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, 20 Boston, MA 02111-1307, USA. */ 21 22#ifdef HAVE_CONFIG_H 23#include <config.h> 24#endif 25 26#include "obstack.h" 27 28/* NOTE BEFORE MODIFYING THIS FILE: This version number must be 29 incremented whenever callers compiled using an old obstack.h can no 30 longer properly call the functions in this obstack.c. */ 31#define OBSTACK_INTERFACE_VERSION 1 32 33/* Comment out all this code if we are using the GNU C Library, and are not 34 actually compiling the library itself, and the installed library 35 supports the same library interface we do. This code is part of the GNU 36 C Library, but also included in many other GNU distributions. Compiling 37 and linking in this code is a waste when using the GNU C library 38 (especially if it is a shared library). Rather than having every GNU 39 program understand `configure --with-gnu-libc' and omit the object 40 files, it is simpler to just do this in the source for each such file. */ 41 42#include <stdio.h> /* Random thing to get __GNU_LIBRARY__. */ 43#if !defined (_LIBC) && defined (__GNU_LIBRARY__) && __GNU_LIBRARY__ > 1 44#include <gnu-versions.h> 45#if _GNU_OBSTACK_INTERFACE_VERSION == OBSTACK_INTERFACE_VERSION 46#define ELIDE_CODE 47#endif 48#endif 49 50 51#ifndef ELIDE_CODE 52 53 54#if defined (__STDC__) && __STDC__ 55#define POINTER void * 56#else 57#define POINTER char * 58#endif 59 60/* Determine default alignment. */ 61struct fooalign {char x; double d;}; 62#define DEFAULT_ALIGNMENT \ 63 ((PTR_INT_TYPE) ((char *) &((struct fooalign *) 0)->d - (char *) 0)) 64/* If malloc were really smart, it would round addresses to DEFAULT_ALIGNMENT. 65 But in fact it might be less smart and round addresses to as much as 66 DEFAULT_ROUNDING. So we prepare for it to do that. */ 67union fooround {long x; double d;}; 68#define DEFAULT_ROUNDING (sizeof (union fooround)) 69 70/* When we copy a long block of data, this is the unit to do it with. 71 On some machines, copying successive ints does not work; 72 in such a case, redefine COPYING_UNIT to `long' (if that works) 73 or `char' as a last resort. */ 74#ifndef COPYING_UNIT 75#define COPYING_UNIT int 76#endif 77 78 79/* The functions allocating more room by calling `obstack_chunk_alloc' 80 jump to the handler pointed to by `obstack_alloc_failed_handler'. 81 This can be set to a user defined function which should either 82 abort gracefully or use longjump - but shouldn't return. This 83 variable by default points to the internal function 84 `print_and_abort'. */ 85#if defined (__STDC__) && __STDC__ 86static void print_and_abort (void); 87void (*obstack_alloc_failed_handler) (void) = print_and_abort; 88#else 89static void print_and_abort (); 90void (*obstack_alloc_failed_handler) () = print_and_abort; 91#endif 92 93/* Exit value used when `print_and_abort' is used. */ 94#if defined __GNU_LIBRARY__ || defined HAVE_STDLIB_H 95#include <stdlib.h> 96#endif 97#ifndef EXIT_FAILURE 98#define EXIT_FAILURE 1 99#endif 100int obstack_exit_failure = EXIT_FAILURE; 101 102/* The non-GNU-C macros copy the obstack into this global variable 103 to avoid multiple evaluation. */ 104 105struct obstack *_obstack; 106 107/* Define a macro that either calls functions with the traditional malloc/free 108 calling interface, or calls functions with the mmalloc/mfree interface 109 (that adds an extra first argument), based on the state of use_extra_arg. 110 For free, do not use ?:, since some compilers, like the MIPS compilers, 111 do not allow (expr) ? void : void. */ 112 113#if defined (__STDC__) && __STDC__ 114#define CALL_CHUNKFUN(h, size) \ 115 (((h) -> use_extra_arg) \ 116 ? (*(h)->chunkfun) ((h)->extra_arg, (size)) \ 117 : (*(struct _obstack_chunk *(*) (long)) (h)->chunkfun) ((size))) 118 119#define CALL_FREEFUN(h, old_chunk) \ 120 do { \ 121 if ((h) -> use_extra_arg) \ 122 (*(h)->freefun) ((h)->extra_arg, (old_chunk)); \ 123 else \ 124 (*(void (*) (void *)) (h)->freefun) ((old_chunk)); \ 125 } while (0) 126#else 127#define CALL_CHUNKFUN(h, size) \ 128 (((h) -> use_extra_arg) \ 129 ? (*(h)->chunkfun) ((h)->extra_arg, (size)) \ 130 : (*(struct _obstack_chunk *(*) ()) (h)->chunkfun) ((size))) 131 132#define CALL_FREEFUN(h, old_chunk) \ 133 do { \ 134 if ((h) -> use_extra_arg) \ 135 (*(h)->freefun) ((h)->extra_arg, (old_chunk)); \ 136 else \ 137 (*(void (*) ()) (h)->freefun) ((old_chunk)); \ 138 } while (0) 139#endif 140 141 142/* Initialize an obstack H for use. Specify chunk size SIZE (0 means default). 143 Objects start on multiples of ALIGNMENT (0 means use default). 144 CHUNKFUN is the function to use to allocate chunks, 145 and FREEFUN the function to free them. 146 147 Return nonzero if successful, calls obstack_alloc_failed_handler if 148 allocation fails. */ 149 150int 151_obstack_begin (h, size, alignment, chunkfun, freefun) 152 struct obstack *h; 153 int size; 154 int alignment; 155#if defined (__STDC__) && __STDC__ 156 POINTER (*chunkfun) (long); 157 void (*freefun) (void *); 158#else 159 POINTER (*chunkfun) (); 160 void (*freefun) (); 161#endif 162{ 163 register struct _obstack_chunk *chunk; /* points to new chunk */ 164 165 if (alignment == 0) 166 alignment = (int) DEFAULT_ALIGNMENT; 167 if (size == 0) 168 /* Default size is what GNU malloc can fit in a 4096-byte block. */ 169 { 170 /* 12 is sizeof (mhead) and 4 is EXTRA from GNU malloc. 171 Use the values for range checking, because if range checking is off, 172 the extra bytes won't be missed terribly, but if range checking is on 173 and we used a larger request, a whole extra 4096 bytes would be 174 allocated. 175 176 These number are irrelevant to the new GNU malloc. I suspect it is 177 less sensitive to the size of the request. */ 178 int extra = ((((12 + DEFAULT_ROUNDING - 1) & ~(DEFAULT_ROUNDING - 1)) 179 + 4 + DEFAULT_ROUNDING - 1) 180 & ~(DEFAULT_ROUNDING - 1)); 181 size = 4096 - extra; 182 } 183 184#if defined (__STDC__) && __STDC__ 185 h->chunkfun = (struct _obstack_chunk * (*)(void *, long)) chunkfun; 186 h->freefun = (void (*) (void *, struct _obstack_chunk *)) freefun; 187#else 188 h->chunkfun = (struct _obstack_chunk * (*)()) chunkfun; 189 h->freefun = freefun; 190#endif 191 h->chunk_size = size; 192 h->alignment_mask = alignment - 1; 193 h->use_extra_arg = 0; 194 195 chunk = h->chunk = CALL_CHUNKFUN (h, h -> chunk_size); 196 if (!chunk) 197 (*obstack_alloc_failed_handler) (); 198 h->next_free = h->object_base = chunk->contents; 199 h->chunk_limit = chunk->limit 200 = (char *) chunk + h->chunk_size; 201 chunk->prev = 0; 202 /* The initial chunk now contains no empty object. */ 203 h->maybe_empty_object = 0; 204 h->alloc_failed = 0; 205 return 1; 206} 207 208int 209_obstack_begin_1 (h, size, alignment, chunkfun, freefun, arg) 210 struct obstack *h; 211 int size; 212 int alignment; 213#if defined (__STDC__) && __STDC__ 214 POINTER (*chunkfun) (POINTER, long); 215 void (*freefun) (POINTER, POINTER); 216#else 217 POINTER (*chunkfun) (); 218 void (*freefun) (); 219#endif 220 POINTER arg; 221{ 222 register struct _obstack_chunk *chunk; /* points to new chunk */ 223 224 if (alignment == 0) 225 alignment = (int) DEFAULT_ALIGNMENT; 226 if (size == 0) 227 /* Default size is what GNU malloc can fit in a 4096-byte block. */ 228 { 229 /* 12 is sizeof (mhead) and 4 is EXTRA from GNU malloc. 230 Use the values for range checking, because if range checking is off, 231 the extra bytes won't be missed terribly, but if range checking is on 232 and we used a larger request, a whole extra 4096 bytes would be 233 allocated. 234 235 These number are irrelevant to the new GNU malloc. I suspect it is 236 less sensitive to the size of the request. */ 237 int extra = ((((12 + DEFAULT_ROUNDING - 1) & ~(DEFAULT_ROUNDING - 1)) 238 + 4 + DEFAULT_ROUNDING - 1) 239 & ~(DEFAULT_ROUNDING - 1)); 240 size = 4096 - extra; 241 } 242 243#if defined(__STDC__) && __STDC__ 244 h->chunkfun = (struct _obstack_chunk * (*)(void *,long)) chunkfun; 245 h->freefun = (void (*) (void *, struct _obstack_chunk *)) freefun; 246#else 247 h->chunkfun = (struct _obstack_chunk * (*)()) chunkfun; 248 h->freefun = freefun; 249#endif 250 h->chunk_size = size; 251 h->alignment_mask = alignment - 1; 252 h->extra_arg = arg; 253 h->use_extra_arg = 1; 254 255 chunk = h->chunk = CALL_CHUNKFUN (h, h -> chunk_size); 256 if (!chunk) 257 (*obstack_alloc_failed_handler) (); 258 h->next_free = h->object_base = chunk->contents; 259 h->chunk_limit = chunk->limit 260 = (char *) chunk + h->chunk_size; 261 chunk->prev = 0; 262 /* The initial chunk now contains no empty object. */ 263 h->maybe_empty_object = 0; 264 h->alloc_failed = 0; 265 return 1; 266} 267 268/* Allocate a new current chunk for the obstack *H 269 on the assumption that LENGTH bytes need to be added 270 to the current object, or a new object of length LENGTH allocated. 271 Copies any partial object from the end of the old chunk 272 to the beginning of the new one. */ 273 274void 275_obstack_newchunk (h, length) 276 struct obstack *h; 277 int length; 278{ 279 register struct _obstack_chunk *old_chunk = h->chunk; 280 register struct _obstack_chunk *new_chunk; 281 register long new_size; 282 register long obj_size = h->next_free - h->object_base; 283 register long i; 284 long already; 285 286 /* Compute size for new chunk. */ 287 new_size = (obj_size + length) + (obj_size >> 3) + 100; 288 if (new_size < h->chunk_size) 289 new_size = h->chunk_size; 290 291 /* Allocate and initialize the new chunk. */ 292 new_chunk = CALL_CHUNKFUN (h, new_size); 293 if (!new_chunk) 294 (*obstack_alloc_failed_handler) (); 295 h->chunk = new_chunk; 296 new_chunk->prev = old_chunk; 297 new_chunk->limit = h->chunk_limit = (char *) new_chunk + new_size; 298 299 /* Move the existing object to the new chunk. 300 Word at a time is fast and is safe if the object 301 is sufficiently aligned. */ 302 if (h->alignment_mask + 1 >= DEFAULT_ALIGNMENT) 303 { 304 for (i = obj_size / sizeof (COPYING_UNIT) - 1; 305 i >= 0; i--) 306 ((COPYING_UNIT *)new_chunk->contents)[i] 307 = ((COPYING_UNIT *)h->object_base)[i]; 308 /* We used to copy the odd few remaining bytes as one extra COPYING_UNIT, 309 but that can cross a page boundary on a machine 310 which does not do strict alignment for COPYING_UNITS. */ 311 already = obj_size / sizeof (COPYING_UNIT) * sizeof (COPYING_UNIT); 312 } 313 else 314 already = 0; 315 /* Copy remaining bytes one by one. */ 316 for (i = already; i < obj_size; i++) 317 new_chunk->contents[i] = h->object_base[i]; 318 319 /* If the object just copied was the only data in OLD_CHUNK, 320 free that chunk and remove it from the chain. 321 But not if that chunk might contain an empty object. */ 322 if (h->object_base == old_chunk->contents && ! h->maybe_empty_object) 323 { 324 new_chunk->prev = old_chunk->prev; 325 CALL_FREEFUN (h, old_chunk); 326 } 327 328 h->object_base = new_chunk->contents; 329 h->next_free = h->object_base + obj_size; 330 /* The new chunk certainly contains no empty object yet. */ 331 h->maybe_empty_object = 0; 332} 333 334/* Return nonzero if object OBJ has been allocated from obstack H. 335 This is here for debugging. 336 If you use it in a program, you are probably losing. */ 337 338#if defined (__STDC__) && __STDC__ 339/* Suppress -Wmissing-prototypes warning. We don't want to declare this in 340 obstack.h because it is just for debugging. */ 341int _obstack_allocated_p (struct obstack *h, POINTER obj); 342#endif 343 344int 345_obstack_allocated_p (h, obj) 346 struct obstack *h; 347 POINTER obj; 348{ 349 register struct _obstack_chunk *lp; /* below addr of any objects in this chunk */ 350 register struct _obstack_chunk *plp; /* point to previous chunk if any */ 351 352 lp = (h)->chunk; 353 /* We use >= rather than > since the object cannot be exactly at 354 the beginning of the chunk but might be an empty object exactly 355 at the end of an adjacent chunk. */ 356 while (lp != 0 && ((POINTER) lp >= obj || (POINTER) (lp)->limit < obj)) 357 { 358 plp = lp->prev; 359 lp = plp; 360 } 361 return lp != 0; 362} 363 364/* Free objects in obstack H, including OBJ and everything allocate 365 more recently than OBJ. If OBJ is zero, free everything in H. */ 366 367#undef obstack_free 368 369/* This function has two names with identical definitions. 370 This is the first one, called from non-ANSI code. */ 371 372void 373_obstack_free (h, obj) 374 struct obstack *h; 375 POINTER obj; 376{ 377 register struct _obstack_chunk *lp; /* below addr of any objects in this chunk */ 378 register struct _obstack_chunk *plp; /* point to previous chunk if any */ 379 380 lp = h->chunk; 381 /* We use >= because there cannot be an object at the beginning of a chunk. 382 But there can be an empty object at that address 383 at the end of another chunk. */ 384 while (lp != 0 && ((POINTER) lp >= obj || (POINTER) (lp)->limit < obj)) 385 { 386 plp = lp->prev; 387 CALL_FREEFUN (h, lp); 388 lp = plp; 389 /* If we switch chunks, we can't tell whether the new current 390 chunk contains an empty object, so assume that it may. */ 391 h->maybe_empty_object = 1; 392 } 393 if (lp) 394 { 395 h->object_base = h->next_free = (char *) (obj); 396 h->chunk_limit = lp->limit; 397 h->chunk = lp; 398 } 399 else if (obj != 0) 400 /* obj is not in any of the chunks! */ 401 abort (); 402} 403 404/* This function is used from ANSI code. */ 405 406void 407obstack_free (h, obj) 408 struct obstack *h; 409 POINTER obj; 410{ 411 register struct _obstack_chunk *lp; /* below addr of any objects in this chunk */ 412 register struct _obstack_chunk *plp; /* point to previous chunk if any */ 413 414 lp = h->chunk; 415 /* We use >= because there cannot be an object at the beginning of a chunk. 416 But there can be an empty object at that address 417 at the end of another chunk. */ 418 while (lp != 0 && ((POINTER) lp >= obj || (POINTER) (lp)->limit < obj)) 419 { 420 plp = lp->prev; 421 CALL_FREEFUN (h, lp); 422 lp = plp; 423 /* If we switch chunks, we can't tell whether the new current 424 chunk contains an empty object, so assume that it may. */ 425 h->maybe_empty_object = 1; 426 } 427 if (lp) 428 { 429 h->object_base = h->next_free = (char *) (obj); 430 h->chunk_limit = lp->limit; 431 h->chunk = lp; 432 } 433 else if (obj != 0) 434 /* obj is not in any of the chunks! */ 435 abort (); 436} 437 438int 439_obstack_memory_used (h) 440 struct obstack *h; 441{ 442 register struct _obstack_chunk* lp; 443 register int nbytes = 0; 444 445 for (lp = h->chunk; lp != 0; lp = lp->prev) 446 { 447 nbytes += lp->limit - (char *) lp; 448 } 449 return nbytes; 450} 451 452/* Define the error handler. */ 453#ifndef _ 454# ifdef HAVE_LIBINTL_H 455# include <libintl.h> 456# ifndef _ 457# define _(Str) gettext (Str) 458# endif 459# else 460# define _(Str) (Str) 461# endif 462#endif 463#if defined _LIBC && defined USE_IN_LIBIO 464# include <libio/iolibio.h> 465# define fputs(s, f) _IO_fputs (s, f) 466#endif 467 468static void 469print_and_abort () 470{ 471 fputs (_("memory exhausted"), stderr); 472 fputc ('\n', stderr); 473 exit (obstack_exit_failure); 474} 475 476#if 0 477/* These are now turned off because the applications do not use it 478 and it uses bcopy via obstack_grow, which causes trouble on sysV. */ 479 480/* Now define the functional versions of the obstack macros. 481 Define them to simply use the corresponding macros to do the job. */ 482 483#if defined (__STDC__) && __STDC__ 484/* These function definitions do not work with non-ANSI preprocessors; 485 they won't pass through the macro names in parentheses. */ 486 487/* The function names appear in parentheses in order to prevent 488 the macro-definitions of the names from being expanded there. */ 489 490POINTER (obstack_base) (obstack) 491 struct obstack *obstack; 492{ 493 return obstack_base (obstack); 494} 495 496POINTER (obstack_next_free) (obstack) 497 struct obstack *obstack; 498{ 499 return obstack_next_free (obstack); 500} 501 502int (obstack_object_size) (obstack) 503 struct obstack *obstack; 504{ 505 return obstack_object_size (obstack); 506} 507 508int (obstack_room) (obstack) 509 struct obstack *obstack; 510{ 511 return obstack_room (obstack); 512} 513 514int (obstack_make_room) (obstack, length) 515 struct obstack *obstack; 516 int length; 517{ 518 return obstack_make_room (obstack, length); 519} 520 521void (obstack_grow) (obstack, pointer, length) 522 struct obstack *obstack; 523 POINTER pointer; 524 int length; 525{ 526 obstack_grow (obstack, pointer, length); 527} 528 529void (obstack_grow0) (obstack, pointer, length) 530 struct obstack *obstack; 531 POINTER pointer; 532 int length; 533{ 534 obstack_grow0 (obstack, pointer, length); 535} 536 537void (obstack_1grow) (obstack, character) 538 struct obstack *obstack; 539 int character; 540{ 541 obstack_1grow (obstack, character); 542} 543 544void (obstack_blank) (obstack, length) 545 struct obstack *obstack; 546 int length; 547{ 548 obstack_blank (obstack, length); 549} 550 551void (obstack_1grow_fast) (obstack, character) 552 struct obstack *obstack; 553 int character; 554{ 555 obstack_1grow_fast (obstack, character); 556} 557 558void (obstack_blank_fast) (obstack, length) 559 struct obstack *obstack; 560 int length; 561{ 562 obstack_blank_fast (obstack, length); 563} 564 565POINTER (obstack_finish) (obstack) 566 struct obstack *obstack; 567{ 568 return obstack_finish (obstack); 569} 570 571POINTER (obstack_alloc) (obstack, length) 572 struct obstack *obstack; 573 int length; 574{ 575 return obstack_alloc (obstack, length); 576} 577 578POINTER (obstack_copy) (obstack, pointer, length) 579 struct obstack *obstack; 580 POINTER pointer; 581 int length; 582{ 583 return obstack_copy (obstack, pointer, length); 584} 585 586POINTER (obstack_copy0) (obstack, pointer, length) 587 struct obstack *obstack; 588 POINTER pointer; 589 int length; 590{ 591 return obstack_copy0 (obstack, pointer, length); 592} 593 594#endif /* __STDC__ */ 595 596#endif /* 0 */ 597 598#endif /* !ELIDE_CODE */ 599