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