lib/obstack.c

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