source: trunk/src/emx/include/obstack.h@ 1506

Last change on this file since 1506 was 1506, checked in by bird, 21 years ago

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