source: trunk/src/sed/lib/obstack.h@ 1077

Last change on this file since 1077 was 599, checked in by bird, 19 years ago

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