Ticket #1186: obstack.h

File obstack.h, 22.4 KB (added by bchesneau@…, 20 years ago)

files/obstack.h

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