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