1
/* obstack.h - object stack macros
2
Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998,
4
Free Software Foundation, Inc.
7
NOTE: The canonical source of this file is maintained with the GNU C Library.
8
Bugs can be reported to bug-glibc@gnu.org.
10
This program is free software; you can redistribute it and/or modify it
11
under the terms of the GNU General Public License as published by the
12
Free Software Foundation; either version 2, or (at your option) any
15
This program is distributed in the hope that it will be useful,
16
but WITHOUT ANY WARRANTY; without even the implied warranty of
17
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18
GNU General Public License for more details.
20
You should have received a copy of the GNU General Public License
21
along with this program; if not, write to the Free Software
22
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
27
All the apparent functions defined here are macros. The idea
28
is that you would use these pre-tested macros to solve a
29
very specific set of problems, and they would run fast.
30
Caution: no side-effects in arguments please!! They may be
31
evaluated MANY times!!
33
These macros operate a stack of objects. Each object starts life
34
small, and may grow to maturity. (Consider building a word syllable
35
by syllable.) An object can move while it is growing. Once it has
36
been "finished" it never changes address again. So the "top of the
37
stack" is typically an immature growing object, while the rest of the
38
stack is of mature, fixed size and fixed address objects.
40
These routines grab large chunks of memory, using a function you
41
supply, called `obstack_chunk_alloc'. On occasion, they free chunks,
42
by calling `obstack_chunk_free'. You must define them and declare
43
them before using any obstack macros.
45
Each independent stack is represented by a `struct obstack'.
46
Each of the obstack macros expects a pointer to such a structure
47
as the first argument.
49
One motivation for this package is the problem of growing char strings
50
in symbol tables. Unless you are "fascist pig with a read-only mind"
51
--Gosper's immortal quote from HAKMEM item 154, out of context--you
52
would not like to put any arbitrary upper limit on the length of your
55
In practice this often means you will build many short symbols and a
56
few long symbols. At the time you are reading a symbol you don't know
57
how long it is. One traditional method is to read a symbol into a
58
buffer, realloc()ating the buffer every time you try to read a symbol
59
that is longer than the buffer. This is beaut, but you still will
60
want to copy the symbol from the buffer to a more permanent
61
symbol-table entry say about half the time.
63
With obstacks, you can work differently. Use one obstack for all symbol
64
names. As you read a symbol, grow the name in the obstack gradually.
65
When the name is complete, finalize it. Then, if the symbol exists already,
66
free the newly read name.
68
The way we do this is to take a large chunk, allocating memory from
69
low addresses. When you want to build a symbol in the chunk you just
70
add chars above the current "high water mark" in the chunk. When you
71
have finished adding chars, because you got to the end of the symbol,
72
you know how long the chars are, and you can create a new object.
73
Mostly the chars will not burst over the highest address of the chunk,
74
because you would typically expect a chunk to be (say) 100 times as
75
long as an average object.
77
In case that isn't clear, when we have enough chars to make up
78
the object, THEY ARE ALREADY CONTIGUOUS IN THE CHUNK (guaranteed)
79
so we just point to it where it lies. No moving of chars is
80
needed and this is the second win: potentially long strings need
81
never be explicitly shuffled. Once an object is formed, it does not
82
change its address during its lifetime.
84
When the chars burst over a chunk boundary, we allocate a larger
85
chunk, and then copy the partly formed object from the end of the old
86
chunk to the beginning of the new larger chunk. We then carry on
87
accreting characters to the end of the object as we normally would.
89
A special macro is provided to add a single char at a time to a
90
growing object. This allows the use of register variables, which
91
break the ordinary 'growth' macro.
94
We allocate large chunks.
95
We carve out one object at a time from the current chunk.
96
Once carved, an object never moves.
97
We are free to append data of any size to the currently
99
Exactly one object is growing in an obstack at any one time.
100
You can run one obstack per control block.
101
You may have as many control blocks as you dare.
102
Because of the way we do it, you can `unwind' an obstack
103
back to a previous state. (You may remove objects much
104
as you would with a stack.)
108
/* Don't do the contents of this file more than once. */
117
/* We use subtraction of (char *) 0 instead of casting to int
118
because on word-addressable machines a simple cast to int
119
may ignore the byte-within-word field of the pointer. */
122
# define __PTR_TO_INT(P) ((P) - (char *) 0)
126
# define __INT_TO_PTR(P) ((P) + (char *) 0)
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. */
135
#ifdef __PTRDIFF_TYPE__
136
# define PTR_INT_TYPE __PTRDIFF_TYPE__
138
# ifdef HAVE_STDDEF_H
140
# define PTR_INT_TYPE ptrdiff_t
142
# define PTR_INT_TYPE long
146
#if defined _LIBC || defined HAVE_STRING_H
148
# if defined __STDC__ && __STDC__
149
# define _obstack_memcpy(To, From, N) memcpy ((To), (From), (N))
151
# define _obstack_memcpy(To, From, N) memcpy ((To), (char *)(From), (N))
155
# define _obstack_memcpy(To, From, N) memcpy ((To), (char *)(From), (N))
157
# define _obstack_memcpy(To, From, N) bcopy ((char *)(From), (To), (N))
161
struct _obstack_chunk /* Lives at front of each chunk. */
163
char *limit; /* 1 past end of this chunk */
164
struct _obstack_chunk *prev; /* address of prior chunk or NULL */
165
char contents[4]; /* objects begin here */
168
struct obstack /* control current object in current chunk */
170
long chunk_size; /* preferred size to allocate chunks in */
171
struct _obstack_chunk *chunk; /* address of current struct obstack_chunk */
172
char *object_base; /* address of object we are building */
173
char *next_free; /* where to add next char to current object */
174
char *chunk_limit; /* address of char after current chunk */
175
PTR_INT_TYPE temp; /* Temporary for some macros. */
176
int alignment_mask; /* Mask of alignment for each object. */
177
#if defined __STDC__ && __STDC__
178
/* These prototypes vary based on `use_extra_arg', and we use
179
casts to the prototypeless function type in all assignments,
180
but having prototypes here quiets -Wstrict-prototypes. */
181
struct _obstack_chunk *(*chunkfun) (void *, long);
182
void (*freefun) (void *, struct _obstack_chunk *);
183
void *extra_arg; /* first arg for chunk alloc/dealloc funcs */
185
struct _obstack_chunk *(*chunkfun) (); /* User's fcn to allocate a chunk. */
186
void (*freefun) (); /* User's function to free a chunk. */
187
char *extra_arg; /* first arg for chunk alloc/dealloc funcs */
189
unsigned use_extra_arg:1; /* chunk alloc/dealloc funcs take extra arg */
190
unsigned maybe_empty_object:1;/* There is a possibility that the current
191
chunk contains a zero-length object. This
192
prevents freeing the chunk if we allocate
193
a bigger chunk to replace it. */
194
unsigned alloc_failed:1; /* No longer used, as we now call the failed
195
handler on error, but retained for binary
199
/* Declare the external functions we use; they are in obstack.c. */
201
#if defined __STDC__ && __STDC__
202
extern void _obstack_newchunk (struct obstack *, int);
203
extern void _obstack_free (struct obstack *, void *);
204
extern int _obstack_begin (struct obstack *, int, int,
205
void *(*) (long), void (*) (void *));
206
extern int _obstack_begin_1 (struct obstack *, int, int,
207
void *(*) (void *, long),
208
void (*) (void *, void *), void *);
209
extern int _obstack_memory_used (struct obstack *);
211
extern void _obstack_newchunk ();
212
extern void _obstack_free ();
213
extern int _obstack_begin ();
214
extern int _obstack_begin_1 ();
215
extern int _obstack_memory_used ();
218
#if defined __STDC__ && __STDC__
220
/* Do the function-declarations after the structs
221
but before defining the macros. */
223
void obstack_init (struct obstack *obstack);
225
void * obstack_alloc (struct obstack *obstack, int size);
227
void * obstack_copy (struct obstack *obstack, void *address, int size);
228
void * obstack_copy0 (struct obstack *obstack, void *address, int size);
230
void obstack_free (struct obstack *obstack, void *block);
232
void obstack_blank (struct obstack *obstack, int size);
234
void obstack_grow (struct obstack *obstack, void *data, int size);
235
void obstack_grow0 (struct obstack *obstack, void *data, int size);
237
void obstack_1grow (struct obstack *obstack, int data_char);
238
void obstack_ptr_grow (struct obstack *obstack, void *data);
239
void obstack_int_grow (struct obstack *obstack, int data);
241
void * obstack_finish (struct obstack *obstack);
243
int obstack_object_size (struct obstack *obstack);
245
int obstack_room (struct obstack *obstack);
246
void obstack_make_room (struct obstack *obstack, int size);
247
void obstack_1grow_fast (struct obstack *obstack, int data_char);
248
void obstack_ptr_grow_fast (struct obstack *obstack, void *data);
249
void obstack_int_grow_fast (struct obstack *obstack, int data);
250
void obstack_blank_fast (struct obstack *obstack, int size);
252
void * obstack_base (struct obstack *obstack);
253
void * obstack_next_free (struct obstack *obstack);
254
int obstack_alignment_mask (struct obstack *obstack);
255
int obstack_chunk_size (struct obstack *obstack);
256
int obstack_memory_used (struct obstack *obstack);
258
#endif /* __STDC__ */
260
/* Non-ANSI C cannot really support alternative functions for these macros,
261
so we do not declare them. */
263
/* Error handler called when `obstack_chunk_alloc' failed to allocate
264
more memory. This can be set to a user defined function. The
265
default action is to print a message and abort. */
266
#if defined __STDC__ && __STDC__
267
extern void (*obstack_alloc_failed_handler) (void);
269
extern void (*obstack_alloc_failed_handler) ();
272
/* Exit value used when `print_and_abort' is used. */
273
extern int obstack_exit_failure;
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. */
279
#define obstack_base(h) ((h)->object_base)
281
/* Size for allocating ordinary chunks. */
283
#define obstack_chunk_size(h) ((h)->chunk_size)
285
/* Pointer to next byte not yet allocated in current chunk. */
287
#define obstack_next_free(h) ((h)->next_free)
289
/* Mask specifying low bits that should be clear in address of an object. */
291
#define obstack_alignment_mask(h) ((h)->alignment_mask)
293
/* To prevent prototype warnings provide complete argument list in
294
standard C version. */
295
#if defined __STDC__ && __STDC__
297
# define obstack_init(h) \
298
_obstack_begin ((h), 0, 0, \
299
(void *(*) (long)) obstack_chunk_alloc, (void (*) (void *)) obstack_chunk_free)
301
# define obstack_begin(h, size) \
302
_obstack_begin ((h), (size), 0, \
303
(void *(*) (long)) obstack_chunk_alloc, (void (*) (void *)) obstack_chunk_free)
305
# define obstack_specify_allocation(h, size, alignment, chunkfun, freefun) \
306
_obstack_begin ((h), (size), (alignment), \
307
(void *(*) (long)) (chunkfun), (void (*) (void *)) (freefun))
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))
314
# define obstack_chunkfun(h, newchunkfun) \
315
((h) -> chunkfun = (struct _obstack_chunk *(*)(void *, long)) (newchunkfun))
317
# define obstack_freefun(h, newfreefun) \
318
((h) -> freefun = (void (*)(void *, struct _obstack_chunk *)) (newfreefun))
322
# define obstack_init(h) \
323
_obstack_begin ((h), 0, 0, \
324
(void *(*) ()) obstack_chunk_alloc, (void (*) ()) obstack_chunk_free)
326
# define obstack_begin(h, size) \
327
_obstack_begin ((h), (size), 0, \
328
(void *(*) ()) obstack_chunk_alloc, (void (*) ()) obstack_chunk_free)
330
# define obstack_specify_allocation(h, size, alignment, chunkfun, freefun) \
331
_obstack_begin ((h), (size), (alignment), \
332
(void *(*) ()) (chunkfun), (void (*) ()) (freefun))
334
# define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \
335
_obstack_begin_1 ((h), (size), (alignment), \
336
(void *(*) ()) (chunkfun), (void (*) ()) (freefun), (arg))
338
# define obstack_chunkfun(h, newchunkfun) \
339
((h) -> chunkfun = (struct _obstack_chunk *(*)()) (newchunkfun))
341
# define obstack_freefun(h, newfreefun) \
342
((h) -> freefun = (void (*)()) (newfreefun))
346
#define obstack_1grow_fast(h,achar) (*((h)->next_free)++ = achar)
348
#define obstack_blank_fast(h,n) ((h)->next_free += (n))
350
#define obstack_memory_used(h) _obstack_memory_used (h)
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
356
# if __GNUC__ < 2 || (__NeXT__ && !__GNUC_MINOR__)
357
# define __extension__
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. */
365
# define obstack_object_size(OBSTACK) \
367
({ struct obstack *__o = (OBSTACK); \
368
(unsigned) (__o->next_free - __o->object_base); })
370
# define obstack_room(OBSTACK) \
372
({ struct obstack *__o = (OBSTACK); \
373
(unsigned) (__o->chunk_limit - __o->next_free); })
375
# define obstack_make_room(OBSTACK,length) \
377
({ struct obstack *__o = (OBSTACK); \
378
int __len = (length); \
379
if (__o->chunk_limit - __o->next_free < __len) \
380
_obstack_newchunk (__o, __len); \
383
# define obstack_empty_p(OBSTACK) \
385
({ struct obstack *__o = (OBSTACK); \
386
(__o->chunk->prev == 0 && __o->next_free - __o->chunk->contents == 0); })
388
# define obstack_grow(OBSTACK,where,length) \
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; \
398
# define obstack_grow0(OBSTACK,where,length) \
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; \
409
# define obstack_1grow(OBSTACK,datum) \
411
({ struct obstack *__o = (OBSTACK); \
412
if (__o->next_free + 1 > __o->chunk_limit) \
413
_obstack_newchunk (__o, 1); \
414
*(__o->next_free)++ = (datum); \
417
/* These assume that the obstack alignment is good enough for pointers or ints,
418
and that the data added so far to the current object
419
shares that much alignment. */
421
# define obstack_ptr_grow(OBSTACK,datum) \
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)++ = ((void *)datum); \
429
# define obstack_int_grow(OBSTACK,datum) \
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)++ = ((int)datum); \
437
# define obstack_ptr_grow_fast(h,aptr) (*((void **) (h)->next_free)++ = (void *)aptr)
438
# define obstack_int_grow_fast(h,aint) (*((int *) (h)->next_free)++ = (int) aint)
440
# define obstack_blank(OBSTACK,length) \
442
({ struct obstack *__o = (OBSTACK); \
443
int __len = (length); \
444
if (__o->chunk_limit - __o->next_free < __len) \
445
_obstack_newchunk (__o, __len); \
446
__o->next_free += __len; \
449
# define obstack_alloc(OBSTACK,length) \
451
({ struct obstack *__h = (OBSTACK); \
452
obstack_blank (__h, (length)); \
453
obstack_finish (__h); })
455
# define obstack_copy(OBSTACK,where,length) \
457
({ struct obstack *__h = (OBSTACK); \
458
obstack_grow (__h, (where), (length)); \
459
obstack_finish (__h); })
461
# define obstack_copy0(OBSTACK,where,length) \
463
({ struct obstack *__h = (OBSTACK); \
464
obstack_grow0 (__h, (where), (length)); \
465
obstack_finish (__h); })
467
/* The local variable is named __o1 to avoid a name conflict
468
when obstack_blank is called. */
469
# define obstack_finish(OBSTACK) \
471
({ struct obstack *__o1 = (OBSTACK); \
473
value = (void *) __o1->object_base; \
474
if (__o1->next_free == value) \
475
__o1->maybe_empty_object = 1; \
477
= __INT_TO_PTR ((__PTR_TO_INT (__o1->next_free)+__o1->alignment_mask)\
478
& ~ (__o1->alignment_mask)); \
479
if (__o1->next_free - (char *)__o1->chunk \
480
> __o1->chunk_limit - (char *)__o1->chunk) \
481
__o1->next_free = __o1->chunk_limit; \
482
__o1->object_base = __o1->next_free; \
485
# define obstack_free(OBSTACK, OBJ) \
487
({ struct obstack *__o = (OBSTACK); \
488
void *__obj = (OBJ); \
489
if (__obj > (void *)__o->chunk && __obj < (void *)__o->chunk_limit) \
490
__o->next_free = __o->object_base = __obj; \
491
else (obstack_free) (__o, __obj); })
493
#else /* not __GNUC__ or not __STDC__ */
495
# define obstack_object_size(h) \
496
(unsigned) ((h)->next_free - (h)->object_base)
498
# define obstack_room(h) \
499
(unsigned) ((h)->chunk_limit - (h)->next_free)
501
# define obstack_empty_p(h) \
502
((h)->chunk->prev == 0 && (h)->next_free - (h)->chunk->contents == 0)
504
/* Note that the call to _obstack_newchunk is enclosed in (..., 0)
505
so that we can avoid having void expressions
506
in the arms of the conditional expression.
507
Casting the third operand to void was tried before,
508
but some compilers won't accept it. */
510
# define obstack_make_room(h,length) \
511
( (h)->temp = (length), \
512
(((h)->next_free + (h)->temp > (h)->chunk_limit) \
513
? (_obstack_newchunk ((h), (h)->temp), 0) : 0))
515
# define obstack_grow(h,where,length) \
516
( (h)->temp = (length), \
517
(((h)->next_free + (h)->temp > (h)->chunk_limit) \
518
? (_obstack_newchunk ((h), (h)->temp), 0) : 0), \
519
_obstack_memcpy ((h)->next_free, (where), (h)->temp), \
520
(h)->next_free += (h)->temp)
522
# define obstack_grow0(h,where,length) \
523
( (h)->temp = (length), \
524
(((h)->next_free + (h)->temp + 1 > (h)->chunk_limit) \
525
? (_obstack_newchunk ((h), (h)->temp + 1), 0) : 0), \
526
_obstack_memcpy ((h)->next_free, (where), (h)->temp), \
527
(h)->next_free += (h)->temp, \
528
*((h)->next_free)++ = 0)
530
# define obstack_1grow(h,datum) \
531
( (((h)->next_free + 1 > (h)->chunk_limit) \
532
? (_obstack_newchunk ((h), 1), 0) : 0), \
533
(*((h)->next_free)++ = (datum)))
535
# define obstack_ptr_grow(h,datum) \
536
( (((h)->next_free + sizeof (char *) > (h)->chunk_limit) \
537
? (_obstack_newchunk ((h), sizeof (char *)), 0) : 0), \
538
(*((char **) (((h)->next_free+=sizeof(char *))-sizeof(char *))) = ((char *) datum)))
540
# define obstack_int_grow(h,datum) \
541
( (((h)->next_free + sizeof (int) > (h)->chunk_limit) \
542
? (_obstack_newchunk ((h), sizeof (int)), 0) : 0), \
543
(*((int *) (((h)->next_free+=sizeof(int))-sizeof(int))) = ((int) datum)))
545
# define obstack_ptr_grow_fast(h,aptr) (*((char **) (h)->next_free)++ = (char *) aptr)
546
# define obstack_int_grow_fast(h,aint) (*((int *) (h)->next_free)++ = (int) aint)
548
# define obstack_blank(h,length) \
549
( (h)->temp = (length), \
550
(((h)->chunk_limit - (h)->next_free < (h)->temp) \
551
? (_obstack_newchunk ((h), (h)->temp), 0) : 0), \
552
((h)->next_free += (h)->temp))
554
# define obstack_alloc(h,length) \
555
(obstack_blank ((h), (length)), obstack_finish ((h)))
557
# define obstack_copy(h,where,length) \
558
(obstack_grow ((h), (where), (length)), obstack_finish ((h)))
560
# define obstack_copy0(h,where,length) \
561
(obstack_grow0 ((h), (where), (length)), obstack_finish ((h)))
563
# define obstack_finish(h) \
564
( ((h)->next_free == (h)->object_base \
565
? (((h)->maybe_empty_object = 1), 0) \
567
(h)->temp = __PTR_TO_INT ((h)->object_base), \
569
= __INT_TO_PTR ((__PTR_TO_INT ((h)->next_free)+(h)->alignment_mask) \
570
& ~ ((h)->alignment_mask)), \
571
(((h)->next_free - (char *) (h)->chunk \
572
> (h)->chunk_limit - (char *) (h)->chunk) \
573
? ((h)->next_free = (h)->chunk_limit) : 0), \
574
(h)->object_base = (h)->next_free, \
575
__INT_TO_PTR ((h)->temp))
577
# if defined __STDC__ && __STDC__
578
# define obstack_free(h,obj) \
579
( (h)->temp = (char *) (obj) - (char *) (h)->chunk, \
580
(((h)->temp > 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\
581
? (int) ((h)->next_free = (h)->object_base \
582
= (h)->temp + (char *) (h)->chunk) \
583
: (((obstack_free) ((h), (h)->temp + (char *) (h)->chunk), 0), 0)))
585
# define obstack_free(h,obj) \
586
( (h)->temp = (char *) (obj) - (char *) (h)->chunk, \
587
(((h)->temp > 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\
588
? (int) ((h)->next_free = (h)->object_base \
589
= (h)->temp + (char *) (h)->chunk) \
590
: (_obstack_free ((h), (h)->temp + (char *) (h)->chunk), 0)))
593
#endif /* not __GNUC__ or not __STDC__ */
599
#endif /* obstack.h */
added
removed
binutils/include/obstack.h
