1: /* obstack.c - subroutines used implicitly by object stack macros
    2:    Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998,
    3:    1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
    4:    This file is part of the GNU C Library.
    5: 
    6:    The GNU C Library is free software; you can redistribute it and/or
    7:    modify it under the terms of the GNU Lesser General Public
    8:    License as published by the Free Software Foundation; either
    9:    version 2.1 of the License, or (at your option) any later version.
   10: 
   11:    The GNU C Library is distributed in the hope that it will be useful,
   12:    but WITHOUT ANY WARRANTY; without even the implied warranty of
   13:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   14:    Lesser General Public License for more details.
   15: 
   16:    You should have received a copy of the GNU Lesser General Public
   17:    License along with the GNU C Library; if not, write to the Free
   18:    Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   19:    Boston, MA 02110-1301, USA.  */
   20: 
   21: 
   22: #ifdef HAVE_CONFIG_H
   23: # include <config.h>
   24: #endif
   25: 
   26: #ifdef _LIBC
   27: # include <obstack.h>
   28: # include <shlib-compat.h>
   29: #else
   30: # include "obstack.h"
   31: #endif
   32: 
   33: /* NOTE BEFORE MODIFYING THIS FILE: This version number must be
   34:    incremented whenever callers compiled using an old obstack.h can no
   35:    longer properly call the functions in this obstack.c.  */
   36: #define OBSTACK_INTERFACE_VERSION 1
   37: 
   38: /* Comment out all this code if we are using the GNU C Library, and are not
   39:    actually compiling the library itself, and the installed library
   40:    supports the same library interface we do.  This code is part of the GNU
   41:    C Library, but also included in many other GNU distributions.  Compiling
   42:    and linking in this code is a waste when using the GNU C library
   43:    (especially if it is a shared library).  Rather than having every GNU
   44:    program understand `configure --with-gnu-libc' and omit the object
   45:    files, it is simpler to just do this in the source for each such file.  */
   46: 
   47: #include <stdio.h>              /* Random thing to get __GNU_LIBRARY__.  */
   48: #if !defined _LIBC && defined __GNU_LIBRARY__ && __GNU_LIBRARY__ > 1
   49: # include <gnu-versions.h>
   50: # if _GNU_OBSTACK_INTERFACE_VERSION == OBSTACK_INTERFACE_VERSION
   51: #  define ELIDE_CODE
   52: # endif
   53: #endif
   54: 
   55: #include <stddef.h>
   56: 
   57: #ifndef ELIDE_CODE
   58: 
   59: 
   60: # if HAVE_INTTYPES_H
   61: #  include <inttypes.h>
   62: # endif
   63: # if HAVE_STDINT_H || defined _LIBC
   64: #  include <stdint.h>
   65: # endif
   66: 
   67: /* Determine default alignment.  */
   68: union fooround
   69: {
   70:   uintmax_t i;
   71:   long double d;
   72:   void *p;
   73: };
   74: struct fooalign
   75: {
   76:   char c;
   77:   union fooround u;
   78: };
   79: /* If malloc were really smart, it would round addresses to DEFAULT_ALIGNMENT.
   80:    But in fact it might be less smart and round addresses to as much as
   81:    DEFAULT_ROUNDING.  So we prepare for it to do that.  */
   82: enum
   83:   {
   84:     DEFAULT_ALIGNMENT = offsetof (struct fooalign, u),
   85:     DEFAULT_ROUNDING = sizeof (union fooround)
   86:   };
   87: 
   88: /* When we copy a long block of data, this is the unit to do it with.
   89:    On some machines, copying successive ints does not work;
   90:    in such a case, redefine COPYING_UNIT to `long' (if that works)
   91:    or `char' as a last resort.  */
   92: # ifndef COPYING_UNIT
   93: #  define COPYING_UNIT int
   94: # endif
   95: 
   96: 
   97: /* The functions allocating more room by calling `obstack_chunk_alloc'
   98:    jump to the handler pointed to by `obstack_alloc_failed_handler'.
   99:    This can be set to a user defined function which should either
  100:    abort gracefully or use longjump - but shouldn't return.  This
  101:    variable by default points to the internal function
  102:    `print_and_abort'.  */
  103: static void print_and_abort (void);
  104: void (*obstack_alloc_failed_handler) (void) = print_and_abort;
  105: 
  106: /* Exit value used when `print_and_abort' is used.  */
  107: # include <stdlib.h>
  108: # ifdef _LIBC
  109: int obstack_exit_failure = EXIT_FAILURE;
  110: # else
  111: #  include "exitfail.h"
  112: #  define obstack_exit_failure exit_failure
  113: # endif
  114: 
  115: # ifdef _LIBC
  116: #  if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_3_4)
  117: /* A looong time ago (before 1994, anyway; we're not sure) this global variable
  118:    was used by non-GNU-C macros to avoid multiple evaluation.  The GNU C
  119:    library still exports it because somebody might use it.  */
  120: struct obstack *_obstack_compat;
  121: compat_symbol (libc, _obstack_compat, _obstack, GLIBC_2_0);
  122: #  endif
  123: # endif
  124: 
  125: /* Define a macro that either calls functions with the traditional malloc/free
  126:    calling interface, or calls functions with the mmalloc/mfree interface
  127:    (that adds an extra first argument), based on the state of use_extra_arg.
  128:    For free, do not use ?:, since some compilers, like the MIPS compilers,
  129:    do not allow (expr) ? void : void.  */
  130: 
  131: # define CALL_CHUNKFUN(h, size) \
  132:   (((h) -> use_extra_arg) \
  133:    ? (*(h)->chunkfun) ((h)->extra_arg, (size)) \
  134:    : (*(struct _obstack_chunk *(*) (long)) (h)->chunkfun) ((size)))
  135: 
  136: # define CALL_FREEFUN(h, old_chunk) \
  137:   do { \
  138:     if ((h) -> use_extra_arg) \
  139:       (*(h)->freefun) ((h)->extra_arg, (old_chunk)); \
  140:     else \
  141:       (*(void (*) (void *)) (h)->freefun) ((old_chunk)); \
  142:   } while (0)
  143: 
  144: ^L
  145: /* Initialize an obstack H for use.  Specify chunk size SIZE (0 means default).
  146:    Objects start on multiples of ALIGNMENT (0 means use default).
  147:    CHUNKFUN is the function to use to allocate chunks,
  148:    and FREEFUN the function to free them.
  149: 
  150:    Return nonzero if successful, calls obstack_alloc_failed_handler if
  151:    allocation fails.  */
  152: 
  153: int
  154: _obstack_begin (struct obstack *h,
  155:                 int size, int alignment,
  156:                 void *(*chunkfun) (long),
  157:                 void (*freefun) (void *))
  158: {
  159:   register struct _obstack_chunk *chunk; /* points to new chunk */
  160: 
  161:   if (alignment == 0)
  162:     alignment = DEFAULT_ALIGNMENT;
  163:   if (size == 0)
  164:     /* Default size is what GNU malloc can fit in a 4096-byte block.  */
  165:     {
  166:       /* 12 is sizeof (mhead) and 4 is EXTRA from GNU malloc.
  167:          Use the values for range checking, because if range checking is off,
  168:          the extra bytes won't be missed terribly, but if range checking is on
  169:          and we used a larger request, a whole extra 4096 bytes would be
  170:          allocated.
  171: 
  172:          These number are irrelevant to the new GNU malloc.  I suspect it is
  173:          less sensitive to the size of the request.  */
  174:       int extra = ((((12 + DEFAULT_ROUNDING - 1) & ~(DEFAULT_ROUNDING - 1))
  175:                     + 4 + DEFAULT_ROUNDING - 1)
  176:                    & ~(DEFAULT_ROUNDING - 1));
  177:       size = 4096 - extra;
  178:     }
  179: 
  180:   h->chunkfun = (struct _obstack_chunk * (*)(void *, long)) chunkfun;
  181:   h->freefun = (void (*) (void *, struct _obstack_chunk *)) freefun;
  182:   h->chunk_size = size;
  183:   h->alignment_mask = alignment - 1;
  184:   h->use_extra_arg = 0;
  185: 
  186:   chunk = h->chunk = CALL_CHUNKFUN (h, h -> chunk_size);
  187:   if (!chunk)
  188:     (*obstack_alloc_failed_handler) ();
  189:   h->next_free = h->object_base = __PTR_ALIGN ((char *) chunk, chunk->contents,
  190:                                                alignment - 1);
  191:   h->chunk_limit = chunk->limit
  192:     = (char *) chunk + h->chunk_size;
  193:   chunk->prev = 0;
  194:   /* The initial chunk now contains no empty object.  */
  195:   h->maybe_empty_object = 0;
  196:   h->alloc_failed = 0;
  197:   return 1;
  198: }
  199: 
  200: int
  201: _obstack_begin_1 (struct obstack *h, int size, int alignment,
  202:                   void *(*chunkfun) (void *, long),
  203:                   void (*freefun) (void *, void *),
  204:                   void *arg)
  205: {
  206:   register struct _obstack_chunk *chunk; /* points to new chunk */
  207: 
  208:   if (alignment == 0)
  209:     alignment = DEFAULT_ALIGNMENT;
  210:   if (size == 0)
  211:     /* Default size is what GNU malloc can fit in a 4096-byte block.  */
  212:     {
  213:       /* 12 is sizeof (mhead) and 4 is EXTRA from GNU malloc.
  214:          Use the values for range checking, because if range checking is off,
  215:          the extra bytes won't be missed terribly, but if range checking is on
  216:          and we used a larger request, a whole extra 4096 bytes would be
  217:          allocated.
  218: 
  219:          These number are irrelevant to the new GNU malloc.  I suspect it is
  220:          less sensitive to the size of the request.  */
  221:       int extra = ((((12 + DEFAULT_ROUNDING - 1) & ~(DEFAULT_ROUNDING - 1))
  222:                     + 4 + DEFAULT_ROUNDING - 1)
  223:                    & ~(DEFAULT_ROUNDING - 1));
  224:       size = 4096 - extra;
  225:     }
  226: 
  227:   h->chunkfun = (struct _obstack_chunk * (*)(void *,long)) chunkfun;
  228:   h->freefun = (void (*) (void *, struct _obstack_chunk *)) freefun;
  229:   h->chunk_size = size;
  230:   h->alignment_mask = alignment - 1;
  231:   h->extra_arg = arg;
  232:   h->use_extra_arg = 1;
  233: 
  234:   chunk = h->chunk = CALL_CHUNKFUN (h, h -> chunk_size);
  235:   if (!chunk)
  236:     (*obstack_alloc_failed_handler) ();
  237:   h->next_free = h->object_base = __PTR_ALIGN ((char *) chunk, chunk->contents,
  238:                                                alignment - 1);
  239:   h->chunk_limit = chunk->limit
  240:     = (char *) chunk + h->chunk_size;
  241:   chunk->prev = 0;
  242:   /* The initial chunk now contains no empty object.  */
  243:   h->maybe_empty_object = 0;
  244:   h->alloc_failed = 0;
  245:   return 1;
  246: }
  247: 
  248: /* Allocate a new current chunk for the obstack *H
  249:    on the assumption that LENGTH bytes need to be added
  250:    to the current object, or a new object of length LENGTH allocated.
  251:    Copies any partial object from the end of the old chunk
  252:    to the beginning of the new one.  */
  253: 
  254: void
  255: _obstack_newchunk (struct obstack *h, int length)
  256: {
  257:   register struct _obstack_chunk *old_chunk = h->chunk;
  258:   register struct _obstack_chunk *new_chunk;
  259:   register long new_size;
  260:   register long obj_size = h->next_free - h->object_base;
  261:   register long i;
  262:   long already;
  263:   char *object_base;
  264: 
  265:   /* Compute size for new chunk.  */
  266:   new_size = (obj_size + length) + (obj_size >> 3) + h->alignment_mask + 100;
  267:   if (new_size < h->chunk_size)
  268:     new_size = h->chunk_size;
  269: 
  270:   /* Allocate and initialize the new chunk.  */
  271:   new_chunk = CALL_CHUNKFUN (h, new_size);
  272:   if (!new_chunk)
  273:     (*obstack_alloc_failed_handler) ();
  274:   h->chunk = new_chunk;
  275:   new_chunk->prev = old_chunk;
  276:   new_chunk->limit = h->chunk_limit = (char *) new_chunk + new_size;
  277: 
  278:   /* Compute an aligned object_base in the new chunk */
  279:   object_base =
  280:     __PTR_ALIGN ((char *) new_chunk, new_chunk->contents, h->alignment_mask);
  281: 
  282:   /* Move the existing object to the new chunk.
  283:      Word at a time is fast and is safe if the object
  284:      is sufficiently aligned.  */
  285:   if (h->alignment_mask + 1 >= DEFAULT_ALIGNMENT)
  286:     {
  287:       for (i = obj_size / sizeof (COPYING_UNIT) - 1;
  288:            i >= 0; i--)
  289:         ((COPYING_UNIT *)object_base)[i]
  290:           = ((COPYING_UNIT *)h->object_base)[i];
  291:       /* We used to copy the odd few remaining bytes as one extra COPYING_UNIT,
  292:          but that can cross a page boundary on a machine
  293:          which does not do strict alignment for COPYING_UNITS.  */
  294:       already = obj_size / sizeof (COPYING_UNIT) * sizeof (COPYING_UNIT);
  295:     }
  296:   else
  297:     already = 0;
  298:   /* Copy remaining bytes one by one.  */
  299:   for (i = already; i < obj_size; i++)
  300:     object_base[i] = h->object_base[i];
  301: 
  302:   /* If the object just copied was the only data in OLD_CHUNK,
  303:      free that chunk and remove it from the chain.
  304:      But not if that chunk might contain an empty object.  */
  305:   if (! h->maybe_empty_object
  306:       && (h->object_base
  307:           == __PTR_ALIGN ((char *) old_chunk, old_chunk->contents,
  308:                           h->alignment_mask)))
  309:     {
  310:       new_chunk->prev = old_chunk->prev;
  311:       CALL_FREEFUN (h, old_chunk);
  312:     }
  313: 
  314:   h->object_base = object_base;
  315:   h->next_free = h->object_base + obj_size;
  316:   /* The new chunk certainly contains no empty object yet.  */
  317:   h->maybe_empty_object = 0;
  318: }
  319: # ifdef _LIBC
  320: libc_hidden_def (_obstack_newchunk)
  321: # endif
  322: 
  323: /* Return nonzero if object OBJ has been allocated from obstack H.
  324:    This is here for debugging.
  325:    If you use it in a program, you are probably losing.  */
  326: 
  327: /* Suppress -Wmissing-prototypes warning.  We don't want to declare this in
  328:    obstack.h because it is just for debugging.  */
  329: int _obstack_allocated_p (struct obstack *h, void *obj);
  330: 
  331: int
  332: _obstack_allocated_p (struct obstack *h, void *obj)
  333: {
  334:   register struct _obstack_chunk *lp;   /* below addr of any objects in this chunk */
  335:   register struct _obstack_chunk *plp;  /* point to previous chunk if any */
  336: 
  337:   lp = (h)->chunk;
  338:   /* We use >= rather than > since the object cannot be exactly at
  339:      the beginning of the chunk but might be an empty object exactly
  340:      at the end of an adjacent chunk.  */
  341:   while (lp != 0 && ((void *) lp >= obj || (void *) (lp)->limit < obj))
  342:     {
  343:       plp = lp->prev;
  344:       lp = plp;
  345:     }
  346:   return lp != 0;
  347: }
  348: ^L
  349: /* Free objects in obstack H, including OBJ and everything allocate
  350:    more recently than OBJ.  If OBJ is zero, free everything in H.  */
  351: 
  352: # undef obstack_free
  353: 
  354: void
  355: obstack_free (struct obstack *h, void *obj)
  356: {
  357:   register struct _obstack_chunk *lp;   /* below addr of any objects in this chunk */
  358:   register struct _obstack_chunk *plp;  /* point to previous chunk if any */
  359: 
  360:   lp = h->chunk;
  361:   /* We use >= because there cannot be an object at the beginning of a chunk.
  362:      But there can be an empty object at that address
  363:      at the end of another chunk.  */
  364:   while (lp != 0 && ((void *) lp >= obj || (void *) (lp)->limit < obj))
  365:     {
  366:       plp = lp->prev;
  367:       CALL_FREEFUN (h, lp);
  368:       lp = plp;
  369:       /* If we switch chunks, we can't tell whether the new current
  370:          chunk contains an empty object, so assume that it may.  */
  371:       h->maybe_empty_object = 1;
  372:     }
  373:   if (lp)
  374:     {
  375:       h->object_base = h->next_free = (char *) (obj);
  376:       h->chunk_limit = lp->limit;
  377:       h->chunk = lp;
  378:     }
  379:   else if (obj != 0)
  380:     /* obj is not in any of the chunks! */
  381:     abort ();
  382: }
  383: 
  384: # ifdef _LIBC
  385: /* Older versions of libc used a function _obstack_free intended to be
  386:    called by non-GCC compilers.  */
  387: strong_alias (obstack_free, _obstack_free)
  388: # endif
  389: ^L
  390: int
  391: _obstack_memory_used (struct obstack *h)
  392: {
  393:   register struct _obstack_chunk* lp;
  394:   register int nbytes = 0;
  395: 
  396:   for (lp = h->chunk; lp != 0; lp = lp->prev)
  397:     {
  398:       nbytes += lp->limit - (char *) lp;
  399:     }
  400:   return nbytes;
  401: }
  402: ^L
  403: /* Define the error handler.  */
  404: # ifdef _LIBC
  405: #  include <libintl.h>
  406: # else
  407: #  include "gettext.h"
  408: # endif
  409: # ifndef _
  410: #  define _(msgid) gettext (msgid)
  411: # endif
  412: 
  413: # ifdef _LIBC
  414: #  include <libio/iolibio.h>
  415: # endif
  416: 
  417: # ifndef __attribute__
  418: /* This feature is available in gcc versions 2.5 and later.  */
  419: #  if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5)
  420: #   define __attribute__(Spec) /* empty */
  421: #  endif
  422: # endif
  423: 
  424: static void
  425: __attribute__ ((noreturn))
  426: print_and_abort (void)
  427: {
  428:   /* Don't change any of these strings.  Yes, it would be possible to add
  429:      the newline to the string and use fputs or so.  But this must not
  430:      happen because the "memory exhausted" message appears in other places
  431:      like this and the translation should be reused instead of creating
  432:      a very similar string which requires a separate translation.  */
  433: # ifdef _LIBC
  434:   (void) __fxprintf (NULL, "%s\n", _("memory exhausted"));
  435: # else
  436:   fprintf (stderr, "%s\n", _("memory exhausted"));
  437: # endif
  438:   exit (obstack_exit_failure);
  439: }
  440: 
  441: #endif  /* !ELIDE_CODE */