|
334
|
1 /* obstack.c - subroutines used implicitly by object stack macros |
|
2475
|
2 Copyright (C) 1988-1994,96,97,98,99 Free Software Foundation, Inc. |
|
334
|
3 |
|
881
|
4 This file is part of the GNU C Library. Its master source is NOT part of |
|
|
5 the C library, however. The master source lives in /gd/gnu/lib. |
|
|
6 |
|
|
7 The GNU C Library is free software; you can redistribute it and/or |
|
|
8 modify it under the terms of the GNU Library General Public License as |
|
|
9 published by the Free Software Foundation; either version 2 of the |
|
|
10 License, or (at your option) any later version. |
|
334
|
11 |
|
881
|
12 The GNU C Library is distributed in the hope that it will be useful, |
|
|
13 but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
|
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
|
15 Library General Public License for more details. |
|
334
|
16 |
|
881
|
17 You should have received a copy of the GNU Library General Public |
|
|
18 License along with the GNU C Library; see the file COPYING.LIB. If not, |
|
|
19 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
|
|
20 Boston, MA 02111-1307, USA. */ |
|
334
|
21 |
|
2475
|
22 #ifdef HAVE_CONFIG_H |
|
|
23 # include <config.h> |
|
|
24 #endif |
|
|
25 |
|
334
|
26 #include "obstack.h" |
|
|
27 |
|
779
|
28 /* NOTE BEFORE MODIFYING THIS FILE: This version number must be |
|
|
29 incremented whenever callers compiled using an old obstack.h can no |
|
|
30 longer properly call the functions in this obstack.c. */ |
|
|
31 #define OBSTACK_INTERFACE_VERSION 1 |
|
334
|
32 |
|
|
33 /* Comment out all this code if we are using the GNU C Library, and are not |
|
779
|
34 actually compiling the library itself, and the installed library |
|
|
35 supports the same library interface we do. This code is part of the GNU |
|
|
36 C Library, but also included in many other GNU distributions. Compiling |
|
334
|
37 and linking in this code is a waste when using the GNU C library |
|
|
38 (especially if it is a shared library). Rather than having every GNU |
|
779
|
39 program understand `configure --with-gnu-libc' and omit the object |
|
|
40 files, it is simpler to just do this in the source for each such file. */ |
|
334
|
41 |
|
779
|
42 #include <stdio.h> /* Random thing to get __GNU_LIBRARY__. */ |
|
|
43 #if !defined (_LIBC) && defined (__GNU_LIBRARY__) && __GNU_LIBRARY__ > 1 |
|
2475
|
44 # include <gnu-versions.h> |
|
|
45 # if _GNU_OBSTACK_INTERFACE_VERSION == OBSTACK_INTERFACE_VERSION |
|
|
46 # define ELIDE_CODE |
|
|
47 # endif |
|
779
|
48 #endif |
|
|
49 |
|
|
50 |
|
|
51 #ifndef ELIDE_CODE |
|
334
|
52 |
|
|
53 |
|
2475
|
54 # if defined (__STDC__) && __STDC__ |
|
|
55 # define POINTER void * |
|
|
56 # else |
|
|
57 # define POINTER char * |
|
|
58 # endif |
|
334
|
59 |
|
|
60 /* Determine default alignment. */ |
|
|
61 struct fooalign {char x; double d;}; |
|
2475
|
62 # define DEFAULT_ALIGNMENT \ |
|
881
|
63 ((PTR_INT_TYPE) ((char *) &((struct fooalign *) 0)->d - (char *) 0)) |
|
334
|
64 /* If malloc were really smart, it would round addresses to DEFAULT_ALIGNMENT. |
|
|
65 But in fact it might be less smart and round addresses to as much as |
|
|
66 DEFAULT_ROUNDING. So we prepare for it to do that. */ |
|
|
67 union fooround {long x; double d;}; |
|
2475
|
68 # define DEFAULT_ROUNDING (sizeof (union fooround)) |
|
334
|
69 |
|
|
70 /* When we copy a long block of data, this is the unit to do it with. |
|
|
71 On some machines, copying successive ints does not work; |
|
|
72 in such a case, redefine COPYING_UNIT to `long' (if that works) |
|
|
73 or `char' as a last resort. */ |
|
2475
|
74 # ifndef COPYING_UNIT |
|
|
75 # define COPYING_UNIT int |
|
|
76 # endif |
|
334
|
77 |
|
881
|
78 |
|
|
79 /* The functions allocating more room by calling `obstack_chunk_alloc' |
|
|
80 jump to the handler pointed to by `obstack_alloc_failed_handler'. |
|
2475
|
81 This can be set to a user defined function which should either |
|
|
82 abort gracefully or use longjump - but shouldn't return. This |
|
|
83 variable by default points to the internal function |
|
881
|
84 `print_and_abort'. */ |
|
2475
|
85 # if defined (__STDC__) && __STDC__ |
|
881
|
86 static void print_and_abort (void); |
|
|
87 void (*obstack_alloc_failed_handler) (void) = print_and_abort; |
|
2475
|
88 # else |
|
881
|
89 static void print_and_abort (); |
|
|
90 void (*obstack_alloc_failed_handler) () = print_and_abort; |
|
2475
|
91 # endif |
|
881
|
92 |
|
|
93 /* Exit value used when `print_and_abort' is used. */ |
|
2475
|
94 # if defined __GNU_LIBRARY__ || defined HAVE_STDLIB_H |
|
|
95 # include <stdlib.h> |
|
|
96 # endif |
|
|
97 # ifndef EXIT_FAILURE |
|
|
98 # define EXIT_FAILURE 1 |
|
|
99 # endif |
|
881
|
100 int obstack_exit_failure = EXIT_FAILURE; |
|
|
101 |
|
334
|
102 /* The non-GNU-C macros copy the obstack into this global variable |
|
|
103 to avoid multiple evaluation. */ |
|
|
104 |
|
|
105 struct obstack *_obstack; |
|
|
106 |
|
|
107 /* Define a macro that either calls functions with the traditional malloc/free |
|
|
108 calling interface, or calls functions with the mmalloc/mfree interface |
|
|
109 (that adds an extra first argument), based on the state of use_extra_arg. |
|
|
110 For free, do not use ?:, since some compilers, like the MIPS compilers, |
|
|
111 do not allow (expr) ? void : void. */ |
|
|
112 |
|
2475
|
113 # if defined (__STDC__) && __STDC__ |
|
|
114 # define CALL_CHUNKFUN(h, size) \ |
|
881
|
115 (((h) -> use_extra_arg) \ |
|
|
116 ? (*(h)->chunkfun) ((h)->extra_arg, (size)) \ |
|
|
117 : (*(struct _obstack_chunk *(*) (long)) (h)->chunkfun) ((size))) |
|
|
118 |
|
2475
|
119 # define CALL_FREEFUN(h, old_chunk) \ |
|
881
|
120 do { \ |
|
|
121 if ((h) -> use_extra_arg) \ |
|
|
122 (*(h)->freefun) ((h)->extra_arg, (old_chunk)); \ |
|
|
123 else \ |
|
|
124 (*(void (*) (void *)) (h)->freefun) ((old_chunk)); \ |
|
|
125 } while (0) |
|
2475
|
126 # else |
|
|
127 # define CALL_CHUNKFUN(h, size) \ |
|
334
|
128 (((h) -> use_extra_arg) \ |
|
|
129 ? (*(h)->chunkfun) ((h)->extra_arg, (size)) \ |
|
779
|
130 : (*(struct _obstack_chunk *(*) ()) (h)->chunkfun) ((size))) |
|
334
|
131 |
|
2475
|
132 # define CALL_FREEFUN(h, old_chunk) \ |
|
334
|
133 do { \ |
|
|
134 if ((h) -> use_extra_arg) \ |
|
|
135 (*(h)->freefun) ((h)->extra_arg, (old_chunk)); \ |
|
|
136 else \ |
|
779
|
137 (*(void (*) ()) (h)->freefun) ((old_chunk)); \ |
|
334
|
138 } while (0) |
|
2475
|
139 # endif |
|
334
|
140 |
|
|
141 |
|
|
142 /* Initialize an obstack H for use. Specify chunk size SIZE (0 means default). |
|
|
143 Objects start on multiples of ALIGNMENT (0 means use default). |
|
|
144 CHUNKFUN is the function to use to allocate chunks, |
|
|
145 and FREEFUN the function to free them. |
|
|
146 |
|
2475
|
147 Return nonzero if successful, calls obstack_alloc_failed_handler if |
|
|
148 allocation fails. */ |
|
334
|
149 |
|
|
150 int |
|
|
151 _obstack_begin (h, size, alignment, chunkfun, freefun) |
|
|
152 struct obstack *h; |
|
|
153 int size; |
|
|
154 int alignment; |
|
2475
|
155 # if defined (__STDC__) && __STDC__ |
|
881
|
156 POINTER (*chunkfun) (long); |
|
|
157 void (*freefun) (void *); |
|
2475
|
158 # else |
|
334
|
159 POINTER (*chunkfun) (); |
|
|
160 void (*freefun) (); |
|
2475
|
161 # endif |
|
334
|
162 { |
|
881
|
163 register struct _obstack_chunk *chunk; /* points to new chunk */ |
|
334
|
164 |
|
|
165 if (alignment == 0) |
|
2475
|
166 alignment = (int) DEFAULT_ALIGNMENT; |
|
334
|
167 if (size == 0) |
|
|
168 /* Default size is what GNU malloc can fit in a 4096-byte block. */ |
|
|
169 { |
|
|
170 /* 12 is sizeof (mhead) and 4 is EXTRA from GNU malloc. |
|
|
171 Use the values for range checking, because if range checking is off, |
|
|
172 the extra bytes won't be missed terribly, but if range checking is on |
|
|
173 and we used a larger request, a whole extra 4096 bytes would be |
|
|
174 allocated. |
|
|
175 |
|
|
176 These number are irrelevant to the new GNU malloc. I suspect it is |
|
|
177 less sensitive to the size of the request. */ |
|
|
178 int extra = ((((12 + DEFAULT_ROUNDING - 1) & ~(DEFAULT_ROUNDING - 1)) |
|
|
179 + 4 + DEFAULT_ROUNDING - 1) |
|
|
180 & ~(DEFAULT_ROUNDING - 1)); |
|
|
181 size = 4096 - extra; |
|
|
182 } |
|
|
183 |
|
2475
|
184 # if defined (__STDC__) && __STDC__ |
|
881
|
185 h->chunkfun = (struct _obstack_chunk * (*)(void *, long)) chunkfun; |
|
|
186 h->freefun = (void (*) (void *, struct _obstack_chunk *)) freefun; |
|
2475
|
187 # else |
|
334
|
188 h->chunkfun = (struct _obstack_chunk * (*)()) chunkfun; |
|
|
189 h->freefun = freefun; |
|
2475
|
190 # endif |
|
334
|
191 h->chunk_size = size; |
|
|
192 h->alignment_mask = alignment - 1; |
|
|
193 h->use_extra_arg = 0; |
|
|
194 |
|
|
195 chunk = h->chunk = CALL_CHUNKFUN (h, h -> chunk_size); |
|
|
196 if (!chunk) |
|
881
|
197 (*obstack_alloc_failed_handler) (); |
|
334
|
198 h->next_free = h->object_base = chunk->contents; |
|
|
199 h->chunk_limit = chunk->limit |
|
|
200 = (char *) chunk + h->chunk_size; |
|
|
201 chunk->prev = 0; |
|
|
202 /* The initial chunk now contains no empty object. */ |
|
|
203 h->maybe_empty_object = 0; |
|
881
|
204 h->alloc_failed = 0; |
|
334
|
205 return 1; |
|
|
206 } |
|
|
207 |
|
|
208 int |
|
|
209 _obstack_begin_1 (h, size, alignment, chunkfun, freefun, arg) |
|
|
210 struct obstack *h; |
|
|
211 int size; |
|
|
212 int alignment; |
|
2475
|
213 # if defined (__STDC__) && __STDC__ |
|
881
|
214 POINTER (*chunkfun) (POINTER, long); |
|
|
215 void (*freefun) (POINTER, POINTER); |
|
2475
|
216 # else |
|
334
|
217 POINTER (*chunkfun) (); |
|
|
218 void (*freefun) (); |
|
2475
|
219 # endif |
|
334
|
220 POINTER arg; |
|
|
221 { |
|
881
|
222 register struct _obstack_chunk *chunk; /* points to new chunk */ |
|
334
|
223 |
|
|
224 if (alignment == 0) |
|
2475
|
225 alignment = (int) DEFAULT_ALIGNMENT; |
|
334
|
226 if (size == 0) |
|
|
227 /* Default size is what GNU malloc can fit in a 4096-byte block. */ |
|
|
228 { |
|
|
229 /* 12 is sizeof (mhead) and 4 is EXTRA from GNU malloc. |
|
|
230 Use the values for range checking, because if range checking is off, |
|
|
231 the extra bytes won't be missed terribly, but if range checking is on |
|
|
232 and we used a larger request, a whole extra 4096 bytes would be |
|
|
233 allocated. |
|
|
234 |
|
|
235 These number are irrelevant to the new GNU malloc. I suspect it is |
|
|
236 less sensitive to the size of the request. */ |
|
|
237 int extra = ((((12 + DEFAULT_ROUNDING - 1) & ~(DEFAULT_ROUNDING - 1)) |
|
|
238 + 4 + DEFAULT_ROUNDING - 1) |
|
|
239 & ~(DEFAULT_ROUNDING - 1)); |
|
|
240 size = 4096 - extra; |
|
|
241 } |
|
|
242 |
|
2475
|
243 # if defined(__STDC__) && __STDC__ |
|
881
|
244 h->chunkfun = (struct _obstack_chunk * (*)(void *,long)) chunkfun; |
|
|
245 h->freefun = (void (*) (void *, struct _obstack_chunk *)) freefun; |
|
2475
|
246 # else |
|
334
|
247 h->chunkfun = (struct _obstack_chunk * (*)()) chunkfun; |
|
|
248 h->freefun = freefun; |
|
2475
|
249 # endif |
|
334
|
250 h->chunk_size = size; |
|
|
251 h->alignment_mask = alignment - 1; |
|
|
252 h->extra_arg = arg; |
|
|
253 h->use_extra_arg = 1; |
|
|
254 |
|
|
255 chunk = h->chunk = CALL_CHUNKFUN (h, h -> chunk_size); |
|
|
256 if (!chunk) |
|
881
|
257 (*obstack_alloc_failed_handler) (); |
|
334
|
258 h->next_free = h->object_base = chunk->contents; |
|
|
259 h->chunk_limit = chunk->limit |
|
|
260 = (char *) chunk + h->chunk_size; |
|
|
261 chunk->prev = 0; |
|
|
262 /* The initial chunk now contains no empty object. */ |
|
|
263 h->maybe_empty_object = 0; |
|
881
|
264 h->alloc_failed = 0; |
|
334
|
265 return 1; |
|
|
266 } |
|
|
267 |
|
|
268 /* Allocate a new current chunk for the obstack *H |
|
|
269 on the assumption that LENGTH bytes need to be added |
|
|
270 to the current object, or a new object of length LENGTH allocated. |
|
|
271 Copies any partial object from the end of the old chunk |
|
|
272 to the beginning of the new one. */ |
|
|
273 |
|
|
274 void |
|
|
275 _obstack_newchunk (h, length) |
|
|
276 struct obstack *h; |
|
|
277 int length; |
|
|
278 { |
|
881
|
279 register struct _obstack_chunk *old_chunk = h->chunk; |
|
|
280 register struct _obstack_chunk *new_chunk; |
|
334
|
281 register long new_size; |
|
2475
|
282 register long obj_size = h->next_free - h->object_base; |
|
|
283 register long i; |
|
|
284 long already; |
|
334
|
285 |
|
|
286 /* Compute size for new chunk. */ |
|
|
287 new_size = (obj_size + length) + (obj_size >> 3) + 100; |
|
|
288 if (new_size < h->chunk_size) |
|
|
289 new_size = h->chunk_size; |
|
|
290 |
|
|
291 /* Allocate and initialize the new chunk. */ |
|
|
292 new_chunk = CALL_CHUNKFUN (h, new_size); |
|
|
293 if (!new_chunk) |
|
881
|
294 (*obstack_alloc_failed_handler) (); |
|
334
|
295 h->chunk = new_chunk; |
|
|
296 new_chunk->prev = old_chunk; |
|
|
297 new_chunk->limit = h->chunk_limit = (char *) new_chunk + new_size; |
|
|
298 |
|
|
299 /* Move the existing object to the new chunk. |
|
|
300 Word at a time is fast and is safe if the object |
|
|
301 is sufficiently aligned. */ |
|
|
302 if (h->alignment_mask + 1 >= DEFAULT_ALIGNMENT) |
|
|
303 { |
|
|
304 for (i = obj_size / sizeof (COPYING_UNIT) - 1; |
|
|
305 i >= 0; i--) |
|
|
306 ((COPYING_UNIT *)new_chunk->contents)[i] |
|
|
307 = ((COPYING_UNIT *)h->object_base)[i]; |
|
|
308 /* We used to copy the odd few remaining bytes as one extra COPYING_UNIT, |
|
|
309 but that can cross a page boundary on a machine |
|
|
310 which does not do strict alignment for COPYING_UNITS. */ |
|
|
311 already = obj_size / sizeof (COPYING_UNIT) * sizeof (COPYING_UNIT); |
|
|
312 } |
|
|
313 else |
|
|
314 already = 0; |
|
|
315 /* Copy remaining bytes one by one. */ |
|
|
316 for (i = already; i < obj_size; i++) |
|
|
317 new_chunk->contents[i] = h->object_base[i]; |
|
|
318 |
|
|
319 /* If the object just copied was the only data in OLD_CHUNK, |
|
|
320 free that chunk and remove it from the chain. |
|
|
321 But not if that chunk might contain an empty object. */ |
|
|
322 if (h->object_base == old_chunk->contents && ! h->maybe_empty_object) |
|
|
323 { |
|
|
324 new_chunk->prev = old_chunk->prev; |
|
|
325 CALL_FREEFUN (h, old_chunk); |
|
|
326 } |
|
|
327 |
|
|
328 h->object_base = new_chunk->contents; |
|
|
329 h->next_free = h->object_base + obj_size; |
|
|
330 /* The new chunk certainly contains no empty object yet. */ |
|
|
331 h->maybe_empty_object = 0; |
|
|
332 } |
|
|
333 |
|
|
334 /* Return nonzero if object OBJ has been allocated from obstack H. |
|
|
335 This is here for debugging. |
|
|
336 If you use it in a program, you are probably losing. */ |
|
|
337 |
|
2475
|
338 # if defined (__STDC__) && __STDC__ |
|
334
|
339 /* Suppress -Wmissing-prototypes warning. We don't want to declare this in |
|
|
340 obstack.h because it is just for debugging. */ |
|
|
341 int _obstack_allocated_p (struct obstack *h, POINTER obj); |
|
2475
|
342 # endif |
|
334
|
343 |
|
|
344 int |
|
|
345 _obstack_allocated_p (h, obj) |
|
|
346 struct obstack *h; |
|
|
347 POINTER obj; |
|
|
348 { |
|
881
|
349 register struct _obstack_chunk *lp; /* below addr of any objects in this chunk */ |
|
|
350 register struct _obstack_chunk *plp; /* point to previous chunk if any */ |
|
334
|
351 |
|
|
352 lp = (h)->chunk; |
|
|
353 /* We use >= rather than > since the object cannot be exactly at |
|
|
354 the beginning of the chunk but might be an empty object exactly |
|
881
|
355 at the end of an adjacent chunk. */ |
|
|
356 while (lp != 0 && ((POINTER) lp >= obj || (POINTER) (lp)->limit < obj)) |
|
334
|
357 { |
|
|
358 plp = lp->prev; |
|
|
359 lp = plp; |
|
|
360 } |
|
|
361 return lp != 0; |
|
|
362 } |
|
|
363 |
|
|
364 /* Free objects in obstack H, including OBJ and everything allocate |
|
|
365 more recently than OBJ. If OBJ is zero, free everything in H. */ |
|
|
366 |
|
2475
|
367 # undef obstack_free |
|
334
|
368 |
|
|
369 /* This function has two names with identical definitions. |
|
|
370 This is the first one, called from non-ANSI code. */ |
|
|
371 |
|
|
372 void |
|
|
373 _obstack_free (h, obj) |
|
|
374 struct obstack *h; |
|
|
375 POINTER obj; |
|
|
376 { |
|
881
|
377 register struct _obstack_chunk *lp; /* below addr of any objects in this chunk */ |
|
|
378 register struct _obstack_chunk *plp; /* point to previous chunk if any */ |
|
334
|
379 |
|
|
380 lp = h->chunk; |
|
|
381 /* We use >= because there cannot be an object at the beginning of a chunk. |
|
|
382 But there can be an empty object at that address |
|
|
383 at the end of another chunk. */ |
|
881
|
384 while (lp != 0 && ((POINTER) lp >= obj || (POINTER) (lp)->limit < obj)) |
|
334
|
385 { |
|
|
386 plp = lp->prev; |
|
|
387 CALL_FREEFUN (h, lp); |
|
|
388 lp = plp; |
|
|
389 /* If we switch chunks, we can't tell whether the new current |
|
|
390 chunk contains an empty object, so assume that it may. */ |
|
|
391 h->maybe_empty_object = 1; |
|
|
392 } |
|
|
393 if (lp) |
|
|
394 { |
|
881
|
395 h->object_base = h->next_free = (char *) (obj); |
|
334
|
396 h->chunk_limit = lp->limit; |
|
|
397 h->chunk = lp; |
|
|
398 } |
|
|
399 else if (obj != 0) |
|
|
400 /* obj is not in any of the chunks! */ |
|
|
401 abort (); |
|
|
402 } |
|
|
403 |
|
|
404 /* This function is used from ANSI code. */ |
|
|
405 |
|
|
406 void |
|
|
407 obstack_free (h, obj) |
|
|
408 struct obstack *h; |
|
|
409 POINTER obj; |
|
|
410 { |
|
881
|
411 register struct _obstack_chunk *lp; /* below addr of any objects in this chunk */ |
|
|
412 register struct _obstack_chunk *plp; /* point to previous chunk if any */ |
|
334
|
413 |
|
|
414 lp = h->chunk; |
|
|
415 /* We use >= because there cannot be an object at the beginning of a chunk. |
|
|
416 But there can be an empty object at that address |
|
|
417 at the end of another chunk. */ |
|
881
|
418 while (lp != 0 && ((POINTER) lp >= obj || (POINTER) (lp)->limit < obj)) |
|
334
|
419 { |
|
|
420 plp = lp->prev; |
|
|
421 CALL_FREEFUN (h, lp); |
|
|
422 lp = plp; |
|
|
423 /* If we switch chunks, we can't tell whether the new current |
|
|
424 chunk contains an empty object, so assume that it may. */ |
|
|
425 h->maybe_empty_object = 1; |
|
|
426 } |
|
|
427 if (lp) |
|
|
428 { |
|
881
|
429 h->object_base = h->next_free = (char *) (obj); |
|
334
|
430 h->chunk_limit = lp->limit; |
|
|
431 h->chunk = lp; |
|
|
432 } |
|
|
433 else if (obj != 0) |
|
|
434 /* obj is not in any of the chunks! */ |
|
|
435 abort (); |
|
|
436 } |
|
|
437 |
|
881
|
438 int |
|
|
439 _obstack_memory_used (h) |
|
|
440 struct obstack *h; |
|
|
441 { |
|
|
442 register struct _obstack_chunk* lp; |
|
|
443 register int nbytes = 0; |
|
|
444 |
|
|
445 for (lp = h->chunk; lp != 0; lp = lp->prev) |
|
|
446 { |
|
|
447 nbytes += lp->limit - (char *) lp; |
|
|
448 } |
|
|
449 return nbytes; |
|
|
450 } |
|
|
451 |
|
|
452 /* Define the error handler. */ |
|
2475
|
453 # ifndef _ |
|
|
454 # ifdef HAVE_LIBINTL_H |
|
|
455 # include <libintl.h> |
|
|
456 # ifndef _ |
|
|
457 # define _(Str) gettext (Str) |
|
|
458 # endif |
|
|
459 # else |
|
|
460 # define _(Str) (Str) |
|
881
|
461 # endif |
|
|
462 # endif |
|
2475
|
463 # if defined _LIBC && defined USE_IN_LIBIO |
|
|
464 # include <libio/iolibio.h> |
|
|
465 # define fputs(s, f) _IO_fputs (s, f) |
|
|
466 # endif |
|
881
|
467 |
|
|
468 static void |
|
|
469 print_and_abort () |
|
|
470 { |
|
2475
|
471 fputs (_("memory exhausted"), stderr); |
|
|
472 fputc ('\n', stderr); |
|
881
|
473 exit (obstack_exit_failure); |
|
|
474 } |
|
|
475 |
|
2475
|
476 # if 0 |
|
334
|
477 /* These are now turned off because the applications do not use it |
|
|
478 and it uses bcopy via obstack_grow, which causes trouble on sysV. */ |
|
|
479 |
|
|
480 /* Now define the functional versions of the obstack macros. |
|
|
481 Define them to simply use the corresponding macros to do the job. */ |
|
|
482 |
|
2475
|
483 # if defined (__STDC__) && __STDC__ |
|
334
|
484 /* These function definitions do not work with non-ANSI preprocessors; |
|
|
485 they won't pass through the macro names in parentheses. */ |
|
|
486 |
|
|
487 /* The function names appear in parentheses in order to prevent |
|
|
488 the macro-definitions of the names from being expanded there. */ |
|
|
489 |
|
|
490 POINTER (obstack_base) (obstack) |
|
|
491 struct obstack *obstack; |
|
|
492 { |
|
|
493 return obstack_base (obstack); |
|
|
494 } |
|
|
495 |
|
|
496 POINTER (obstack_next_free) (obstack) |
|
|
497 struct obstack *obstack; |
|
|
498 { |
|
|
499 return obstack_next_free (obstack); |
|
|
500 } |
|
|
501 |
|
|
502 int (obstack_object_size) (obstack) |
|
|
503 struct obstack *obstack; |
|
|
504 { |
|
|
505 return obstack_object_size (obstack); |
|
|
506 } |
|
|
507 |
|
|
508 int (obstack_room) (obstack) |
|
|
509 struct obstack *obstack; |
|
|
510 { |
|
|
511 return obstack_room (obstack); |
|
|
512 } |
|
|
513 |
|
881
|
514 int (obstack_make_room) (obstack, length) |
|
|
515 struct obstack *obstack; |
|
|
516 int length; |
|
|
517 { |
|
|
518 return obstack_make_room (obstack, length); |
|
|
519 } |
|
|
520 |
|
334
|
521 void (obstack_grow) (obstack, pointer, length) |
|
|
522 struct obstack *obstack; |
|
|
523 POINTER pointer; |
|
|
524 int length; |
|
|
525 { |
|
|
526 obstack_grow (obstack, pointer, length); |
|
|
527 } |
|
|
528 |
|
|
529 void (obstack_grow0) (obstack, pointer, length) |
|
|
530 struct obstack *obstack; |
|
|
531 POINTER pointer; |
|
|
532 int length; |
|
|
533 { |
|
|
534 obstack_grow0 (obstack, pointer, length); |
|
|
535 } |
|
|
536 |
|
|
537 void (obstack_1grow) (obstack, character) |
|
|
538 struct obstack *obstack; |
|
|
539 int character; |
|
|
540 { |
|
|
541 obstack_1grow (obstack, character); |
|
|
542 } |
|
|
543 |
|
|
544 void (obstack_blank) (obstack, length) |
|
|
545 struct obstack *obstack; |
|
|
546 int length; |
|
|
547 { |
|
|
548 obstack_blank (obstack, length); |
|
|
549 } |
|
|
550 |
|
|
551 void (obstack_1grow_fast) (obstack, character) |
|
|
552 struct obstack *obstack; |
|
|
553 int character; |
|
|
554 { |
|
|
555 obstack_1grow_fast (obstack, character); |
|
|
556 } |
|
|
557 |
|
|
558 void (obstack_blank_fast) (obstack, length) |
|
|
559 struct obstack *obstack; |
|
|
560 int length; |
|
|
561 { |
|
|
562 obstack_blank_fast (obstack, length); |
|
|
563 } |
|
|
564 |
|
|
565 POINTER (obstack_finish) (obstack) |
|
|
566 struct obstack *obstack; |
|
|
567 { |
|
|
568 return obstack_finish (obstack); |
|
|
569 } |
|
|
570 |
|
|
571 POINTER (obstack_alloc) (obstack, length) |
|
|
572 struct obstack *obstack; |
|
|
573 int length; |
|
|
574 { |
|
|
575 return obstack_alloc (obstack, length); |
|
|
576 } |
|
|
577 |
|
|
578 POINTER (obstack_copy) (obstack, pointer, length) |
|
|
579 struct obstack *obstack; |
|
|
580 POINTER pointer; |
|
|
581 int length; |
|
|
582 { |
|
|
583 return obstack_copy (obstack, pointer, length); |
|
|
584 } |
|
|
585 |
|
|
586 POINTER (obstack_copy0) (obstack, pointer, length) |
|
|
587 struct obstack *obstack; |
|
|
588 POINTER pointer; |
|
|
589 int length; |
|
|
590 { |
|
|
591 return obstack_copy0 (obstack, pointer, length); |
|
|
592 } |
|
|
593 |
|
2475
|
594 # endif /* __STDC__ */ |
|
334
|
595 |
|
2475
|
596 # endif /* 0 */ |
|
334
|
597 |
|
779
|
598 #endif /* !ELIDE_CODE */ |
