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