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#if defined __STDC__ && __STDC__ 123# define __INT_TO_PTR(P) ((void *) ((P) + (char *) 0)) 124#else 125# define __INT_TO_PTR(P) ((P) + (char *) 0) 126#endif 127#endif 128 129/* We need the type of the resulting object. If __PTRDIFF_TYPE__ is 130 defined, as with GNU C, use that; that way we don't pollute the 131 namespace with <stddef.h>'s symbols. Otherwise, if <stddef.h> is 132 available, include it and use ptrdiff_t. In traditional C, long is 133 the best that we can do. */ 134 135#ifdef __PTRDIFF_TYPE__ 136# define PTR_INT_TYPE __PTRDIFF_TYPE__ 137#else 138# ifdef HAVE_STDDEF_H 139# include <stddef.h> 140# define PTR_INT_TYPE ptrdiff_t 141# else 142# define PTR_INT_TYPE long 143# endif 144#endif 145 146#if defined _LIBC || defined HAVE_STRING_H 147# include <string.h> 148# define _obstack_memcpy(To, From, N) memcpy ((To), (From), (N)) 149#else 150# ifdef memcpy 151# define _obstack_memcpy(To, From, N) memcpy ((To), (From), (N)) 152# else 153# define _obstack_memcpy(To, From, N) bcopy ((From), (To), (N)) 154# endif 155#endif 156 157struct _obstack_chunk /* Lives at front of each chunk. */ 158{ 159 char *limit; /* 1 past end of this chunk */ 160 struct _obstack_chunk *prev; /* address of prior chunk or NULL */ 161 char contents[4]; /* objects begin here */ 162}; 163 164struct obstack /* control current object in current chunk */ 165{ 166 long chunk_size; /* preferred size to allocate chunks in */ 167 struct _obstack_chunk *chunk; /* address of current struct obstack_chunk */ 168 char *object_base; /* address of object we are building */ 169 char *next_free; /* where to add next char to current object */ 170 char *chunk_limit; /* address of char after current chunk */ 171 PTR_INT_TYPE temp; /* Temporary for some macros. */ 172 int alignment_mask; /* Mask of alignment for each object. */ 173#if defined __STDC__ && __STDC__ 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#else 181 struct _obstack_chunk *(*chunkfun) (); /* User's fcn to allocate a chunk. */ 182 void (*freefun) (); /* User's function to free a chunk. */ 183 char *extra_arg; /* first arg for chunk alloc/dealloc funcs */ 184#endif 185 unsigned use_extra_arg:1; /* chunk alloc/dealloc funcs take extra arg */ 186 unsigned maybe_empty_object:1;/* There is a possibility that the current 187 chunk contains a zero-length object. This 188 prevents freeing the chunk if we allocate 189 a bigger chunk to replace it. */ 190 unsigned alloc_failed:1; /* No longer used, as we now call the failed 191 handler on error, but retained for binary 192 compatibility. */ 193}; 194 195/* Declare the external functions we use; they are in obstack.c. */ 196 197#if defined __STDC__ && __STDC__ 198extern void _obstack_newchunk (struct obstack *, int); 199extern void _obstack_free (struct obstack *, void *); 200extern int _obstack_begin (struct obstack *, int, int, 201 void *(*) (long), void (*) (void *)); 202extern int _obstack_begin_1 (struct obstack *, int, int, 203 void *(*) (void *, long), 204 void (*) (void *, void *), void *); 205extern int _obstack_memory_used (struct obstack *); 206#else 207extern void _obstack_newchunk (); 208extern void _obstack_free (); 209extern int _obstack_begin (); 210extern int _obstack_begin_1 (); 211extern int _obstack_memory_used (); 212#endif 213 214#if defined __STDC__ && __STDC__ 215 216/* Do the function-declarations after the structs 217 but before defining the macros. */ 218 219void obstack_init (struct obstack *obstack); 220 221void * obstack_alloc (struct obstack *obstack, int size); 222 223void * obstack_copy (struct obstack *obstack, const void *address, int size); 224void * obstack_copy0 (struct obstack *obstack, const void *address, int size); 225 226void obstack_free (struct obstack *obstack, void *block); 227 228void obstack_blank (struct obstack *obstack, int size); 229 230void obstack_grow (struct obstack *obstack, const void *data, int size); 231void obstack_grow0 (struct obstack *obstack, const void *data, int size); 232 233void obstack_1grow (struct obstack *obstack, int data_char); 234void obstack_ptr_grow (struct obstack *obstack, const void *data); 235void obstack_int_grow (struct obstack *obstack, int data); 236 237void * obstack_finish (struct obstack *obstack); 238 239int obstack_object_size (struct obstack *obstack); 240 241int obstack_room (struct obstack *obstack); 242void obstack_make_room (struct obstack *obstack, int size); 243void obstack_1grow_fast (struct obstack *obstack, int data_char); 244void obstack_ptr_grow_fast (struct obstack *obstack, const void *data); 245void obstack_int_grow_fast (struct obstack *obstack, int data); 246void obstack_blank_fast (struct obstack *obstack, int size); 247 248void * obstack_base (struct obstack *obstack); 249void * obstack_next_free (struct obstack *obstack); 250int obstack_alignment_mask (struct obstack *obstack); 251int obstack_chunk_size (struct obstack *obstack); 252int obstack_memory_used (struct obstack *obstack); 253 254#endif /* __STDC__ */ 255 256/* Non-ANSI C cannot really support alternative functions for these macros, 257 so we do not declare them. */ 258 259/* Error handler called when `obstack_chunk_alloc' failed to allocate 260 more memory. This can be set to a user defined function which 261 should either abort gracefully or use longjump - but shouldn't 262 return. The default action is to print a message and abort. */ 263#if defined __STDC__ && __STDC__ 264extern void (*obstack_alloc_failed_handler) (void); 265#else 266extern void (*obstack_alloc_failed_handler) (); 267#endif 268 269/* Exit value used when `print_and_abort' is used. */ 270extern int obstack_exit_failure; 271 272/* Pointer to beginning of object being allocated or to be allocated next. 273 Note that this might not be the final address of the object 274 because a new chunk might be needed to hold the final size. */ 275 276#define obstack_base(h) ((h)->object_base) 277 278/* Size for allocating ordinary chunks. */ 279 280#define obstack_chunk_size(h) ((h)->chunk_size) 281 282/* Pointer to next byte not yet allocated in current chunk. */ 283 284#define obstack_next_free(h) ((h)->next_free) 285 286/* Mask specifying low bits that should be clear in address of an object. */ 287 288#define obstack_alignment_mask(h) ((h)->alignment_mask) 289 290/* To prevent prototype warnings provide complete argument list in 291 standard C version. */ 292#if defined __STDC__ && __STDC__ 293 294# define obstack_init(h) \ 295 _obstack_begin ((h), 0, 0, \ 296 (void *(*) (long)) obstack_chunk_alloc, \ 297 (void (*) (void *)) obstack_chunk_free) 298 299# define obstack_begin(h, size) \ 300 _obstack_begin ((h), (size), 0, \ 301 (void *(*) (long)) obstack_chunk_alloc, \ 302 (void (*) (void *)) obstack_chunk_free) 303 304# define obstack_specify_allocation(h, size, alignment, chunkfun, freefun) \ 305 _obstack_begin ((h), (size), (alignment), \ 306 (void *(*) (long)) (chunkfun), \ 307 (void (*) (void *)) (freefun)) 308 309# define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \ 310 _obstack_begin_1 ((h), (size), (alignment), \ 311 (void *(*) (void *, long)) (chunkfun), \ 312 (void (*) (void *, void *)) (freefun), (arg)) 313 314# define obstack_chunkfun(h, newchunkfun) \ 315 ((h) -> chunkfun = (struct _obstack_chunk *(*)(void *, long)) (newchunkfun)) 316 317# define obstack_freefun(h, newfreefun) \ 318 ((h) -> freefun = (void (*)(void *, struct _obstack_chunk *)) (newfreefun)) 319 320#else 321 322# define obstack_init(h) \ 323 _obstack_begin ((h), 0, 0, \ 324 (void *(*) ()) obstack_chunk_alloc, \ 325 (void (*) ()) obstack_chunk_free) 326 327# define obstack_begin(h, size) \ 328 _obstack_begin ((h), (size), 0, \ 329 (void *(*) ()) obstack_chunk_alloc, \ 330 (void (*) ()) obstack_chunk_free) 331 332# define obstack_specify_allocation(h, size, alignment, chunkfun, freefun) \ 333 _obstack_begin ((h), (size), (alignment), \ 334 (void *(*) ()) (chunkfun), \ 335 (void (*) ()) (freefun)) 336 337# define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \ 338 _obstack_begin_1 ((h), (size), (alignment), \ 339 (void *(*) ()) (chunkfun), \ 340 (void (*) ()) (freefun), (arg)) 341 342# define obstack_chunkfun(h, newchunkfun) \ 343 ((h) -> chunkfun = (struct _obstack_chunk *(*)()) (newchunkfun)) 344 345# define obstack_freefun(h, newfreefun) \ 346 ((h) -> freefun = (void (*)()) (newfreefun)) 347 348#endif 349 350#define obstack_1grow_fast(h,achar) (*((h)->next_free)++ = achar) 351 352#define obstack_blank_fast(h,n) ((h)->next_free += (n)) 353 354#define obstack_memory_used(h) _obstack_memory_used (h) 355 356#if defined __GNUC__ && defined __STDC__ && __STDC__ 357/* NextStep 2.0 cc is really gcc 1.93 but it defines __GNUC__ = 2 and 358 does not implement __extension__. But that compiler doesn't define 359 __GNUC_MINOR__. */ 360# if __GNUC__ < 2 || (__NeXT__ && !__GNUC_MINOR__) 361# define __extension__ 362# endif 363 364/* For GNU C, if not -traditional, 365 we can define these macros to compute all args only once 366 without using a global variable. 367 Also, we can avoid using the `temp' slot, to make faster code. */ 368 369# define obstack_object_size(OBSTACK) \ 370 __extension__ \ 371 ({ struct obstack *__o = (OBSTACK); \ 372 (unsigned) (__o->next_free - __o->object_base); }) 373 374# define obstack_room(OBSTACK) \ 375 __extension__ \ 376 ({ struct obstack *__o = (OBSTACK); \ 377 (unsigned) (__o->chunk_limit - __o->next_free); }) 378 379# define obstack_make_room(OBSTACK,length) \ 380__extension__ \ 381({ struct obstack *__o = (OBSTACK); \ 382 int __len = (length); \ 383 if (__o->chunk_limit - __o->next_free < __len) \ 384 _obstack_newchunk (__o, __len); \ 385 (void) 0; }) 386 387# define obstack_empty_p(OBSTACK) \ 388 __extension__ \ 389 ({ struct obstack *__o = (OBSTACK); \ 390 (__o->chunk->prev == 0 && __o->next_free - __o->chunk->contents == 0); }) 391 392# define obstack_grow(OBSTACK,where,length) \ 393__extension__ \ 394({ struct obstack *__o = (OBSTACK); \ 395 int __len = (length); \ 396 if (__o->next_free + __len > __o->chunk_limit) \ 397 _obstack_newchunk (__o, __len); \ 398 _obstack_memcpy (__o->next_free, (where), __len); \ 399 __o->next_free += __len; \ 400 (void) 0; }) 401 402# define obstack_grow0(OBSTACK,where,length) \ 403__extension__ \ 404({ struct obstack *__o = (OBSTACK); \ 405 int __len = (length); \ 406 if (__o->next_free + __len + 1 > __o->chunk_limit) \ 407 _obstack_newchunk (__o, __len + 1); \ 408 _obstack_memcpy (__o->next_free, (where), __len); \ 409 __o->next_free += __len; \ 410 *(__o->next_free)++ = 0; \ 411 (void) 0; }) 412 413# define obstack_1grow(OBSTACK,datum) \ 414__extension__ \ 415({ struct obstack *__o = (OBSTACK); \ 416 if (__o->next_free + 1 > __o->chunk_limit) \ 417 _obstack_newchunk (__o, 1); \ 418 *(__o->next_free)++ = (datum); \ 419 (void) 0; }) 420 421/* These assume that the obstack alignment is good enough for pointers 422 or ints, and that the data added so far to the current object 423 shares that much alignment. */ 424 425# define obstack_ptr_grow(OBSTACK,datum) \ 426__extension__ \ 427({ struct obstack *__o = (OBSTACK); \ 428 if (__o->next_free + sizeof (void *) > __o->chunk_limit) \ 429 _obstack_newchunk (__o, sizeof (void *)); \ 430 *((void **)__o->next_free)++ = (datum); \ 431 (void) 0; }) 432 433# define obstack_int_grow(OBSTACK,datum) \ 434__extension__ \ 435({ struct obstack *__o = (OBSTACK); \ 436 if (__o->next_free + sizeof (int) > __o->chunk_limit) \ 437 _obstack_newchunk (__o, sizeof (int)); \ 438 *((int *)__o->next_free)++ = (datum); \ 439 (void) 0; }) 440 441# define obstack_ptr_grow_fast(h,aptr) \ 442 (*((void **) (h)->next_free)++ = (aptr)) 443 444# define obstack_int_grow_fast(h,aint) \ 445 (*((int *) (h)->next_free)++ = (aint)) 446 447# define obstack_blank(OBSTACK,length) \ 448__extension__ \ 449({ struct obstack *__o = (OBSTACK); \ 450 int __len = (length); \ 451 if (__o->chunk_limit - __o->next_free < __len) \ 452 _obstack_newchunk (__o, __len); \ 453 __o->next_free += __len; \ 454 (void) 0; }) 455 456# define obstack_alloc(OBSTACK,length) \ 457__extension__ \ 458({ struct obstack *__h = (OBSTACK); \ 459 obstack_blank (__h, (length)); \ 460 obstack_finish (__h); }) 461 462# define obstack_copy(OBSTACK,where,length) \ 463__extension__ \ 464({ struct obstack *__h = (OBSTACK); \ 465 obstack_grow (__h, (where), (length)); \ 466 obstack_finish (__h); }) 467 468# define obstack_copy0(OBSTACK,where,length) \ 469__extension__ \ 470({ struct obstack *__h = (OBSTACK); \ 471 obstack_grow0 (__h, (where), (length)); \ 472 obstack_finish (__h); }) 473 474/* The local variable is named __o1 to avoid a name conflict 475 when obstack_blank is called. */ 476# define obstack_finish(OBSTACK) \ 477__extension__ \ 478({ struct obstack *__o1 = (OBSTACK); \ 479 void *value; \ 480 value = (void *) __o1->object_base; \ 481 if (__o1->next_free == value) \ 482 __o1->maybe_empty_object = 1; \ 483 __o1->next_free \ 484 = __INT_TO_PTR ((__PTR_TO_INT (__o1->next_free)+__o1->alignment_mask)\ 485 & ~ (__o1->alignment_mask)); \ 486 if (__o1->next_free - (char *)__o1->chunk \ 487 > __o1->chunk_limit - (char *)__o1->chunk) \ 488 __o1->next_free = __o1->chunk_limit; \ 489 __o1->object_base = __o1->next_free; \ 490 value; }) 491 492# define obstack_free(OBSTACK, OBJ) \ 493__extension__ \ 494({ struct obstack *__o = (OBSTACK); \ 495 void *__obj = (OBJ); \ 496 if (__obj > (void *)__o->chunk && __obj < (void *)__o->chunk_limit) \ 497 __o->next_free = __o->object_base = (char *)__obj; \ 498 else (obstack_free) (__o, __obj); }) 499 500#else /* not __GNUC__ or not __STDC__ */ 501 502# define obstack_object_size(h) \ 503 (unsigned) ((h)->next_free - (h)->object_base) 504 505# define obstack_room(h) \ 506 (unsigned) ((h)->chunk_limit - (h)->next_free) 507 508# define obstack_empty_p(h) \ 509 ((h)->chunk->prev == 0 && (h)->next_free - (h)->chunk->contents == 0) 510 511/* Note that the call to _obstack_newchunk is enclosed in (..., 0) 512 so that we can avoid having void expressions 513 in the arms of the conditional expression. 514 Casting the third operand to void was tried before, 515 but some compilers won't accept it. */ 516 517# define obstack_make_room(h,length) \ 518( (h)->temp = (length), \ 519 (((h)->next_free + (h)->temp > (h)->chunk_limit) \ 520 ? (_obstack_newchunk ((h), (h)->temp), 0) : 0)) 521 522# define obstack_grow(h,where,length) \ 523( (h)->temp = (length), \ 524 (((h)->next_free + (h)->temp > (h)->chunk_limit) \ 525 ? (_obstack_newchunk ((h), (h)->temp), 0) : 0), \ 526 _obstack_memcpy ((h)->next_free, (where), (h)->temp), \ 527 (h)->next_free += (h)->temp) 528 529# define obstack_grow0(h,where,length) \ 530( (h)->temp = (length), \ 531 (((h)->next_free + (h)->temp + 1 > (h)->chunk_limit) \ 532 ? (_obstack_newchunk ((h), (h)->temp + 1), 0) : 0), \ 533 _obstack_memcpy ((h)->next_free, (where), (h)->temp), \ 534 (h)->next_free += (h)->temp, \ 535 *((h)->next_free)++ = 0) 536 537# define obstack_1grow(h,datum) \ 538( (((h)->next_free + 1 > (h)->chunk_limit) \ 539 ? (_obstack_newchunk ((h), 1), 0) : 0), \ 540 (*((h)->next_free)++ = (datum))) 541 542# define obstack_ptr_grow(h,datum) \ 543( (((h)->next_free + sizeof (char *) > (h)->chunk_limit) \ 544 ? (_obstack_newchunk ((h), sizeof (char *)), 0) : 0), \ 545 (*((const char **) (((h)->next_free+=sizeof(char *))-sizeof(char *))) = (datum))) 546 547# define obstack_int_grow(h,datum) \ 548( (((h)->next_free + sizeof (int) > (h)->chunk_limit) \ 549 ? (_obstack_newchunk ((h), sizeof (int)), 0) : 0), \ 550 (*((int *) (((h)->next_free+=sizeof(int))-sizeof(int))) = (datum))) 551 552# define obstack_ptr_grow_fast(h,aptr) \ 553 (*((const char **) (h)->next_free)++ = (aptr)) 554 555# define obstack_int_grow_fast(h,aint) \ 556 (*((int *) (h)->next_free)++ = (aint)) 557 558# define obstack_blank(h,length) \ 559( (h)->temp = (length), \ 560 (((h)->chunk_limit - (h)->next_free < (h)->temp) \ 561 ? (_obstack_newchunk ((h), (h)->temp), 0) : 0), \ 562 ((h)->next_free += (h)->temp)) 563 564# define obstack_alloc(h,length) \ 565 (obstack_blank ((h), (length)), obstack_finish ((h))) 566 567# define obstack_copy(h,where,length) \ 568 (obstack_grow ((h), (where), (length)), obstack_finish ((h))) 569 570# define obstack_copy0(h,where,length) \ 571 (obstack_grow0 ((h), (where), (length)), obstack_finish ((h))) 572 573# define obstack_finish(h) \ 574( ((h)->next_free == (h)->object_base \ 575 ? (((h)->maybe_empty_object = 1), 0) \ 576 : 0), \ 577 (h)->temp = __PTR_TO_INT ((h)->object_base), \ 578 (h)->next_free \ 579 = __INT_TO_PTR ((__PTR_TO_INT ((h)->next_free)+(h)->alignment_mask) \ 580 & ~ ((h)->alignment_mask)), \ 581 (((h)->next_free - (char *) (h)->chunk \ 582 > (h)->chunk_limit - (char *) (h)->chunk) \ 583 ? ((h)->next_free = (h)->chunk_limit) : 0), \ 584 (h)->object_base = (h)->next_free, \ 585 __INT_TO_PTR ((h)->temp)) 586 587# if defined __STDC__ && __STDC__ 588# define obstack_free(h,obj) \ 589( (h)->temp = (char *) (obj) - (char *) (h)->chunk, \ 590 (((h)->temp > 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\ 591 ? (int) ((h)->next_free = (h)->object_base \ 592 = (h)->temp + (char *) (h)->chunk) \ 593 : (((obstack_free) ((h), (h)->temp + (char *) (h)->chunk), 0), 0))) 594# else 595# define obstack_free(h,obj) \ 596( (h)->temp = (char *) (obj) - (char *) (h)->chunk, \ 597 (((h)->temp > 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\ 598 ? (int) ((h)->next_free = (h)->object_base \ 599 = (h)->temp + (char *) (h)->chunk) \ 600 : (_obstack_free ((h), (h)->temp + (char *) (h)->chunk), 0))) 601# endif 602 603#endif /* not __GNUC__ or not __STDC__ */ 604 605#ifdef __cplusplus 606} /* C++ */ 607#endif 608 609#endif /* obstack.h */ 610