Home | History | Annotate | Download | only in include
      1 /* obstack.h - object stack macros
      2    Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998,
      3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2008
      4    Free Software Foundation, Inc.
      5 
      6 
      7    NOTE: The canonical source of this file is maintained with the GNU C Library.
      8    Bugs can be reported to bug-glibc (at) gnu.org.
      9 
     10    This program is free software; you can redistribute it and/or modify it
     11    under the terms of the GNU General Public License as published by the
     12    Free Software Foundation; either version 2, or (at your option) any
     13    later version.
     14 
     15    This program is distributed in the hope that it will be useful,
     16    but WITHOUT ANY WARRANTY; without even the implied warranty of
     17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     18    GNU General Public License for more details.
     19 
     20    You should have received a copy of the GNU General Public License
     21    along with this program; if not, write to the Free Software
     22    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
     23    USA.  */
     24 
     25 /* Summary:
     26 
     27 All the apparent functions defined here are macros. The idea
     28 is that you would use these pre-tested macros to solve a
     29 very specific set of problems, and they would run fast.
     30 Caution: no side-effects in arguments please!! They may be
     31 evaluated MANY times!!
     32 
     33 These macros operate a stack of objects.  Each object starts life
     34 small, and may grow to maturity.  (Consider building a word syllable
     35 by syllable.)  An object can move while it is growing.  Once it has
     36 been "finished" it never changes address again.  So the "top of the
     37 stack" is typically an immature growing object, while the rest of the
     38 stack is of mature, fixed size and fixed address objects.
     39 
     40 These routines grab large chunks of memory, using a function you
     41 supply, called `obstack_chunk_alloc'.  On occasion, they free chunks,
     42 by calling `obstack_chunk_free'.  You must define them and declare
     43 them before using any obstack macros.
     44 
     45 Each independent stack is represented by a `struct obstack'.
     46 Each of the obstack macros expects a pointer to such a structure
     47 as the first argument.
     48 
     49 One motivation for this package is the problem of growing char strings
     50 in symbol tables.  Unless you are "fascist pig with a read-only mind"
     51 --Gosper's immortal quote from HAKMEM item 154, out of context--you
     52 would not like to put any arbitrary upper limit on the length of your
     53 symbols.
     54 
     55 In practice this often means you will build many short symbols and a
     56 few long symbols.  At the time you are reading a symbol you don't know
     57 how long it is.  One traditional method is to read a symbol into a
     58 buffer, realloc()ating the buffer every time you try to read a symbol
     59 that is longer than the buffer.  This is beaut, but you still will
     60 want to copy the symbol from the buffer to a more permanent
     61 symbol-table entry say about half the time.
     62 
     63 With obstacks, you can work differently.  Use one obstack for all symbol
     64 names.  As you read a symbol, grow the name in the obstack gradually.
     65 When the name is complete, finalize it.  Then, if the symbol exists already,
     66 free the newly read name.
     67 
     68 The way we do this is to take a large chunk, allocating memory from
     69 low addresses.  When you want to build a symbol in the chunk you just
     70 add chars above the current "high water mark" in the chunk.  When you
     71 have finished adding chars, because you got to the end of the symbol,
     72 you know how long the chars are, and you can create a new object.
     73 Mostly the chars will not burst over the highest address of the chunk,
     74 because you would typically expect a chunk to be (say) 100 times as
     75 long as an average object.
     76 
     77 In case that isn't clear, when we have enough chars to make up
     78 the object, THEY ARE ALREADY CONTIGUOUS IN THE CHUNK (guaranteed)
     79 so we just point to it where it lies.  No moving of chars is
     80 needed and this is the second win: potentially long strings need
     81 never be explicitly shuffled. Once an object is formed, it does not
     82 change its address during its lifetime.
     83 
     84 When the chars burst over a chunk boundary, we allocate a larger
     85 chunk, and then copy the partly formed object from the end of the old
     86 chunk to the beginning of the new larger chunk.  We then carry on
     87 accreting characters to the end of the object as we normally would.
     88 
     89 A special macro is provided to add a single char at a time to a
     90 growing object.  This allows the use of register variables, which
     91 break the ordinary 'growth' macro.
     92 
     93 Summary:
     94 	We allocate large chunks.
     95 	We carve out one object at a time from the current chunk.
     96 	Once carved, an object never moves.
     97 	We are free to append data of any size to the currently
     98 	  growing object.
     99 	Exactly one object is growing in an obstack at any one time.
    100 	You can run one obstack per control block.
    101 	You may have as many control blocks as you dare.
    102 	Because of the way we do it, you can `unwind' an obstack
    103 	  back to a previous state. (You may remove objects much
    104 	  as you would with a stack.)
    105 */
    106 
    107 
    108 /* Don't do the contents of this file more than once.  */
    109 
    110 #ifndef _OBSTACK_H
    111 #define _OBSTACK_H 1
    112 
    113 #ifdef __cplusplus
    114 extern "C" {
    115 #endif
    116 
    117 /* We use subtraction of (char *) 0 instead of casting to int
    119    because on word-addressable machines a simple cast to int
    120    may ignore the byte-within-word field of the pointer.  */
    121 
    122 #ifndef __PTR_TO_INT
    123 # define __PTR_TO_INT(P) ((P) - (char *) 0)
    124 #endif
    125 
    126 #ifndef __INT_TO_PTR
    127 # define __INT_TO_PTR(P) ((P) + (char *) 0)
    128 #endif
    129 
    130 /* We need the type of the resulting object.  If __PTRDIFF_TYPE__ is
    131    defined, as with GNU C, use that; that way we don't pollute the
    132    namespace with <stddef.h>'s symbols.  Otherwise, if <stddef.h> is
    133    available, include it and use ptrdiff_t.  In traditional C, long is
    134    the best that we can do.  */
    135 
    136 #ifdef __PTRDIFF_TYPE__
    137 # define PTR_INT_TYPE __PTRDIFF_TYPE__
    138 #else
    139 # ifdef HAVE_STDDEF_H
    140 #  include <stddef.h>
    141 #  define PTR_INT_TYPE ptrdiff_t
    142 # else
    143 #  define PTR_INT_TYPE long
    144 # endif
    145 #endif
    146 
    147 #if defined _LIBC || defined HAVE_STRING_H
    148 # include <string.h>
    149 # define _obstack_memcpy(To, From, N) memcpy ((To), (From), (N))
    150 #else
    151 # ifdef memcpy
    152 #  define _obstack_memcpy(To, From, N) memcpy ((To), (char *)(From), (N))
    153 # else
    154 #  define _obstack_memcpy(To, From, N) bcopy ((char *)(From), (To), (N))
    155 # endif
    156 #endif
    157 
    158 struct _obstack_chunk		/* Lives at front of each chunk. */
    159 {
    160   char  *limit;			/* 1 past end of this chunk */
    161   struct _obstack_chunk *prev;	/* address of prior chunk or NULL */
    162   char	contents[4];		/* objects begin here */
    163 };
    164 
    165 struct obstack		/* control current object in current chunk */
    166 {
    167   long	chunk_size;		/* preferred size to allocate chunks in */
    168   struct _obstack_chunk *chunk;	/* address of current struct obstack_chunk */
    169   char	*object_base;		/* address of object we are building */
    170   char	*next_free;		/* where to add next char to current object */
    171   char	*chunk_limit;		/* address of char after current chunk */
    172   PTR_INT_TYPE temp;		/* Temporary for some macros.  */
    173   int   alignment_mask;		/* Mask of alignment for each object. */
    174   /* These prototypes vary based on `use_extra_arg', and we use
    175      casts to the prototypeless function type in all assignments,
    176      but having prototypes here quiets -Wstrict-prototypes.  */
    177   struct _obstack_chunk *(*chunkfun) (void *, long);
    178   void (*freefun) (void *, struct _obstack_chunk *);
    179   void *extra_arg;		/* first arg for chunk alloc/dealloc funcs */
    180   unsigned use_extra_arg:1;	/* chunk alloc/dealloc funcs take extra arg */
    181   unsigned maybe_empty_object:1;/* There is a possibility that the current
    182 				   chunk contains a zero-length object.  This
    183 				   prevents freeing the chunk if we allocate
    184 				   a bigger chunk to replace it. */
    185   unsigned alloc_failed:1;	/* No longer used, as we now call the failed
    186 				   handler on error, but retained for binary
    187 				   compatibility.  */
    188 };
    189 
    190 /* Declare the external functions we use; they are in obstack.c.  */
    191 
    192 extern void _obstack_newchunk (struct obstack *, int);
    193 extern void _obstack_free (struct obstack *, void *);
    194 extern int _obstack_begin (struct obstack *, int, int,
    195 			    void *(*) (long), void (*) (void *));
    196 extern int _obstack_begin_1 (struct obstack *, int, int,
    197 			     void *(*) (void *, long),
    198 			     void (*) (void *, void *), void *);
    199 extern int _obstack_memory_used (struct obstack *);
    200 
    201 /* Do the function-declarations after the structs
    203    but before defining the macros.  */
    204 
    205 void obstack_init (struct obstack *obstack);
    206 
    207 void * obstack_alloc (struct obstack *obstack, int size);
    208 
    209 void * obstack_copy (struct obstack *obstack, void *address, int size);
    210 void * obstack_copy0 (struct obstack *obstack, void *address, int size);
    211 
    212 void obstack_free (struct obstack *obstack, void *block);
    213 
    214 void obstack_blank (struct obstack *obstack, int size);
    215 
    216 void obstack_grow (struct obstack *obstack, void *data, int size);
    217 void obstack_grow0 (struct obstack *obstack, void *data, int size);
    218 
    219 void obstack_1grow (struct obstack *obstack, int data_char);
    220 void obstack_ptr_grow (struct obstack *obstack, void *data);
    221 void obstack_int_grow (struct obstack *obstack, int data);
    222 
    223 void * obstack_finish (struct obstack *obstack);
    224 
    225 int obstack_object_size (struct obstack *obstack);
    226 
    227 int obstack_room (struct obstack *obstack);
    228 void obstack_make_room (struct obstack *obstack, int size);
    229 void obstack_1grow_fast (struct obstack *obstack, int data_char);
    230 void obstack_ptr_grow_fast (struct obstack *obstack, void *data);
    231 void obstack_int_grow_fast (struct obstack *obstack, int data);
    232 void obstack_blank_fast (struct obstack *obstack, int size);
    233 
    234 void * obstack_base (struct obstack *obstack);
    235 void * obstack_next_free (struct obstack *obstack);
    236 int obstack_alignment_mask (struct obstack *obstack);
    237 int obstack_chunk_size (struct obstack *obstack);
    238 int obstack_memory_used (struct obstack *obstack);
    239 
    240 /* Error handler called when `obstack_chunk_alloc' failed to allocate
    241    more memory.  This can be set to a user defined function.  The
    242    default action is to print a message and abort.  */
    243 extern void (*obstack_alloc_failed_handler) (void);
    244 
    245 /* Exit value used when `print_and_abort' is used.  */
    246 extern int obstack_exit_failure;
    247 
    248 /* Pointer to beginning of object being allocated or to be allocated next.
    250    Note that this might not be the final address of the object
    251    because a new chunk might be needed to hold the final size.  */
    252 
    253 #define obstack_base(h) ((h)->object_base)
    254 
    255 /* Size for allocating ordinary chunks.  */
    256 
    257 #define obstack_chunk_size(h) ((h)->chunk_size)
    258 
    259 /* Pointer to next byte not yet allocated in current chunk.  */
    260 
    261 #define obstack_next_free(h)	((h)->next_free)
    262 
    263 /* Mask specifying low bits that should be clear in address of an object.  */
    264 
    265 #define obstack_alignment_mask(h) ((h)->alignment_mask)
    266 
    267 /* To prevent prototype warnings provide complete argument list in
    268    standard C version.  */
    269 # define obstack_init(h) \
    270   _obstack_begin ((h), 0, 0, \
    271 		  (void *(*) (long)) obstack_chunk_alloc, (void (*) (void *)) obstack_chunk_free)
    272 
    273 # define obstack_begin(h, size) \
    274   _obstack_begin ((h), (size), 0, \
    275 		  (void *(*) (long)) obstack_chunk_alloc, (void (*) (void *)) obstack_chunk_free)
    276 
    277 # define obstack_specify_allocation(h, size, alignment, chunkfun, freefun) \
    278   _obstack_begin ((h), (size), (alignment), \
    279 		    (void *(*) (long)) (chunkfun), (void (*) (void *)) (freefun))
    280 
    281 # define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \
    282   _obstack_begin_1 ((h), (size), (alignment), \
    283 		    (void *(*) (void *, long)) (chunkfun), \
    284 		    (void (*) (void *, void *)) (freefun), (arg))
    285 
    286 # define obstack_chunkfun(h, newchunkfun) \
    287   ((h) -> chunkfun = (struct _obstack_chunk *(*)(void *, long)) (newchunkfun))
    288 
    289 # define obstack_freefun(h, newfreefun) \
    290   ((h) -> freefun = (void (*)(void *, struct _obstack_chunk *)) (newfreefun))
    291 
    292 #define obstack_1grow_fast(h,achar) (*((h)->next_free)++ = (achar))
    293 
    294 #define obstack_blank_fast(h,n) ((h)->next_free += (n))
    295 
    296 #define obstack_memory_used(h) _obstack_memory_used (h)
    297 
    298 #if defined __GNUC__ && defined __STDC__ && __STDC__
    300 /* NextStep 2.0 cc is really gcc 1.93 but it defines __GNUC__ = 2 and
    301    does not implement __extension__.  But that compiler doesn't define
    302    __GNUC_MINOR__.  */
    303 # if __GNUC__ < 2 || (__NeXT__ && !__GNUC_MINOR__)
    304 #  define __extension__
    305 # endif
    306 
    307 /* For GNU C, if not -traditional,
    308    we can define these macros to compute all args only once
    309    without using a global variable.
    310    Also, we can avoid using the `temp' slot, to make faster code.  */
    311 
    312 # define obstack_object_size(OBSTACK)					\
    313   __extension__								\
    314   ({ struct obstack *__o = (OBSTACK);					\
    315      (unsigned) (__o->next_free - __o->object_base); })
    316 
    317 # define obstack_room(OBSTACK)						\
    318   __extension__								\
    319   ({ struct obstack *__o = (OBSTACK);					\
    320      (unsigned) (__o->chunk_limit - __o->next_free); })
    321 
    322 # define obstack_make_room(OBSTACK,length)				\
    323 __extension__								\
    324 ({ struct obstack *__o = (OBSTACK);					\
    325    int __len = (length);						\
    326    if (__o->chunk_limit - __o->next_free < __len)			\
    327      _obstack_newchunk (__o, __len);					\
    328    (void) 0; })
    329 
    330 # define obstack_empty_p(OBSTACK)					\
    331   __extension__								\
    332   ({ struct obstack *__o = (OBSTACK);					\
    333      (__o->chunk->prev == 0 && __o->next_free - __o->chunk->contents == 0); })
    334 
    335 # define obstack_grow(OBSTACK,where,length)				\
    336 __extension__								\
    337 ({ struct obstack *__o = (OBSTACK);					\
    338    int __len = (length);						\
    339    if (__o->next_free + __len > __o->chunk_limit)			\
    340      _obstack_newchunk (__o, __len);					\
    341    _obstack_memcpy (__o->next_free, (where), __len);			\
    342    __o->next_free += __len;						\
    343    (void) 0; })
    344 
    345 # define obstack_grow0(OBSTACK,where,length)				\
    346 __extension__								\
    347 ({ struct obstack *__o = (OBSTACK);					\
    348    int __len = (length);						\
    349    if (__o->next_free + __len + 1 > __o->chunk_limit)			\
    350      _obstack_newchunk (__o, __len + 1);				\
    351    _obstack_memcpy (__o->next_free, (where), __len);			\
    352    __o->next_free += __len;						\
    353    *(__o->next_free)++ = 0;						\
    354    (void) 0; })
    355 
    356 # define obstack_1grow(OBSTACK,datum)					\
    357 __extension__								\
    358 ({ struct obstack *__o = (OBSTACK);					\
    359    if (__o->next_free + 1 > __o->chunk_limit)				\
    360      _obstack_newchunk (__o, 1);					\
    361    obstack_1grow_fast (__o, datum);					\
    362    (void) 0; })
    363 
    364 /* These assume that the obstack alignment is good enough for pointers or ints,
    365    and that the data added so far to the current object
    366    shares that much alignment.  */
    367 
    368 # define obstack_ptr_grow(OBSTACK,datum)				\
    369 __extension__								\
    370 ({ struct obstack *__o = (OBSTACK);					\
    371    if (__o->next_free + sizeof (void *) > __o->chunk_limit)		\
    372      _obstack_newchunk (__o, sizeof (void *));				\
    373    obstack_ptr_grow_fast (__o, datum); })
    374 
    375 # define obstack_int_grow(OBSTACK,datum)				\
    376 __extension__								\
    377 ({ struct obstack *__o = (OBSTACK);					\
    378    if (__o->next_free + sizeof (int) > __o->chunk_limit)		\
    379      _obstack_newchunk (__o, sizeof (int));				\
    380    obstack_int_grow_fast (__o, datum); })
    381 
    382 # define obstack_ptr_grow_fast(OBSTACK,aptr)				\
    383 __extension__								\
    384 ({ struct obstack *__o1 = (OBSTACK);					\
    385    *(const void **) __o1->next_free = (aptr);				\
    386    __o1->next_free += sizeof (const void *);				\
    387    (void) 0; })
    388 
    389 # define obstack_int_grow_fast(OBSTACK,aint)				\
    390 __extension__								\
    391 ({ struct obstack *__o1 = (OBSTACK);					\
    392    *(int *) __o1->next_free = (aint);					\
    393    __o1->next_free += sizeof (int);					\
    394    (void) 0; })
    395 
    396 # define obstack_blank(OBSTACK,length)					\
    397 __extension__								\
    398 ({ struct obstack *__o = (OBSTACK);					\
    399    int __len = (length);						\
    400    if (__o->chunk_limit - __o->next_free < __len)			\
    401      _obstack_newchunk (__o, __len);					\
    402    obstack_blank_fast (__o, __len);					\
    403    (void) 0; })
    404 
    405 # define obstack_alloc(OBSTACK,length)					\
    406 __extension__								\
    407 ({ struct obstack *__h = (OBSTACK);					\
    408    obstack_blank (__h, (length));					\
    409    obstack_finish (__h); })
    410 
    411 # define obstack_copy(OBSTACK,where,length)				\
    412 __extension__								\
    413 ({ struct obstack *__h = (OBSTACK);					\
    414    obstack_grow (__h, (where), (length));				\
    415    obstack_finish (__h); })
    416 
    417 # define obstack_copy0(OBSTACK,where,length)				\
    418 __extension__								\
    419 ({ struct obstack *__h = (OBSTACK);					\
    420    obstack_grow0 (__h, (where), (length));				\
    421    obstack_finish (__h); })
    422 
    423 /* The local variable is named __o1 to avoid a name conflict
    424    when obstack_blank is called.  */
    425 # define obstack_finish(OBSTACK)  					\
    426 __extension__								\
    427 ({ struct obstack *__o1 = (OBSTACK);					\
    428    void *value;								\
    429    value = (void *) __o1->object_base;					\
    430    if (__o1->next_free == value)					\
    431      __o1->maybe_empty_object = 1;					\
    432    __o1->next_free							\
    433      = __INT_TO_PTR ((__PTR_TO_INT (__o1->next_free)+__o1->alignment_mask)\
    434 		     & ~ (__o1->alignment_mask));			\
    435    if (__o1->next_free - (char *)__o1->chunk				\
    436        > __o1->chunk_limit - (char *)__o1->chunk)			\
    437      __o1->next_free = __o1->chunk_limit;				\
    438    __o1->object_base = __o1->next_free;					\
    439    value; })
    440 
    441 # define obstack_free(OBSTACK, OBJ)					\
    442 __extension__								\
    443 ({ struct obstack *__o = (OBSTACK);					\
    444    void *__obj = (void *) (OBJ);					\
    445    if (__obj > (void *)__o->chunk && __obj < (void *)__o->chunk_limit)  \
    446      __o->next_free = __o->object_base = (char *) __obj;		\
    447    else (obstack_free) (__o, __obj); })
    448 
    449 #else /* not __GNUC__ or not __STDC__ */
    451 
    452 # define obstack_object_size(h) \
    453  (unsigned) ((h)->next_free - (h)->object_base)
    454 
    455 # define obstack_room(h)		\
    456  (unsigned) ((h)->chunk_limit - (h)->next_free)
    457 
    458 # define obstack_empty_p(h) \
    459  ((h)->chunk->prev == 0 && (h)->next_free - (h)->chunk->contents == 0)
    460 
    461 /* Note that the call to _obstack_newchunk is enclosed in (..., 0)
    462    so that we can avoid having void expressions
    463    in the arms of the conditional expression.
    464    Casting the third operand to void was tried before,
    465    but some compilers won't accept it.  */
    466 
    467 # define obstack_make_room(h,length)					\
    468 ( (h)->temp = (length),							\
    469   (((h)->next_free + (h)->temp > (h)->chunk_limit)			\
    470    ? (_obstack_newchunk ((h), (h)->temp), 0) : 0))
    471 
    472 # define obstack_grow(h,where,length)					\
    473 ( (h)->temp = (length),							\
    474   (((h)->next_free + (h)->temp > (h)->chunk_limit)			\
    475    ? (_obstack_newchunk ((h), (h)->temp), 0) : 0),			\
    476   _obstack_memcpy ((h)->next_free, (where), (h)->temp),			\
    477   (h)->next_free += (h)->temp)
    478 
    479 # define obstack_grow0(h,where,length)					\
    480 ( (h)->temp = (length),							\
    481   (((h)->next_free + (h)->temp + 1 > (h)->chunk_limit)			\
    482    ? (_obstack_newchunk ((h), (h)->temp + 1), 0) : 0),			\
    483   _obstack_memcpy ((h)->next_free, (where), (h)->temp),			\
    484   (h)->next_free += (h)->temp,						\
    485   *((h)->next_free)++ = 0)
    486 
    487 # define obstack_1grow(h,datum)						\
    488 ( (((h)->next_free + 1 > (h)->chunk_limit)				\
    489    ? (_obstack_newchunk ((h), 1), 0) : 0),				\
    490   obstack_1grow_fast (h, datum))
    491 
    492 # define obstack_ptr_grow(h,datum)					\
    493 ( (((h)->next_free + sizeof (char *) > (h)->chunk_limit)		\
    494    ? (_obstack_newchunk ((h), sizeof (char *)), 0) : 0),		\
    495   obstack_ptr_grow_fast (h, datum))
    496 
    497 # define obstack_int_grow(h,datum)					\
    498 ( (((h)->next_free + sizeof (int) > (h)->chunk_limit)			\
    499    ? (_obstack_newchunk ((h), sizeof (int)), 0) : 0),			\
    500   obstack_int_grow_fast (h, datum))
    501 
    502 # define obstack_ptr_grow_fast(h,aptr)					\
    503   (((const void **) ((h)->next_free += sizeof (void *)))[-1] = (aptr))
    504 
    505 # define obstack_int_grow_fast(h,aint)					\
    506   (((int *) ((h)->next_free += sizeof (int)))[-1] = (aptr))
    507 
    508 # define obstack_blank(h,length)					\
    509 ( (h)->temp = (length),							\
    510   (((h)->chunk_limit - (h)->next_free < (h)->temp)			\
    511    ? (_obstack_newchunk ((h), (h)->temp), 0) : 0),			\
    512   obstack_blank_fast (h, (h)->temp))
    513 
    514 # define obstack_alloc(h,length)					\
    515  (obstack_blank ((h), (length)), obstack_finish ((h)))
    516 
    517 # define obstack_copy(h,where,length)					\
    518  (obstack_grow ((h), (where), (length)), obstack_finish ((h)))
    519 
    520 # define obstack_copy0(h,where,length)					\
    521  (obstack_grow0 ((h), (where), (length)), obstack_finish ((h)))
    522 
    523 # define obstack_finish(h)  						\
    524 ( ((h)->next_free == (h)->object_base					\
    525    ? (((h)->maybe_empty_object = 1), 0)					\
    526    : 0),								\
    527   (h)->temp = __PTR_TO_INT ((h)->object_base),				\
    528   (h)->next_free							\
    529     = __INT_TO_PTR ((__PTR_TO_INT ((h)->next_free)+(h)->alignment_mask)	\
    530 		    & ~ ((h)->alignment_mask)),				\
    531   (((h)->next_free - (char *) (h)->chunk				\
    532     > (h)->chunk_limit - (char *) (h)->chunk)				\
    533    ? ((h)->next_free = (h)->chunk_limit) : 0),				\
    534   (h)->object_base = (h)->next_free,					\
    535   (void *) __INT_TO_PTR ((h)->temp))
    536 
    537 # define obstack_free(h,obj)						\
    538 ( (h)->temp = (char *) (obj) - (char *) (h)->chunk,			\
    539   (((h)->temp > 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\
    540    ? (int) ((h)->next_free = (h)->object_base				\
    541 	    = (h)->temp + (char *) (h)->chunk)				\
    542    : (((obstack_free) ((h), (h)->temp + (char *) (h)->chunk), 0), 0)))
    543 
    544 #endif /* not __GNUC__ or not __STDC__ */
    545 
    546 #ifdef __cplusplus
    547 }	/* C++ */
    548 #endif
    549 
    550 #endif /* obstack.h */
    551