Mercurial > hg > octave-kai > gnulib-hg
annotate lib/obstack.h @ 4253:bd7590d0c6b6
(__INT_TO_PTR) [__STDC__]: Cast result to
(void *) to avoid diagnostic with native c89 on SGI IRIX 6.5
when compiling Bison 1.875's `bitset bset = obstack_alloc
(bobstack, bytes);'. Problem reported by Nelson H. F. Beebe.
| author | Paul Eggert <eggert@cs.ucla.edu> |
|---|---|
| date | Thu, 13 Mar 2003 21:13:59 +0000 |
| parents | 649f79992b70 |
| children | 8985ae624e3d |
| rev | line source |
|---|---|
| 334 | 1 /* obstack.h - object stack macros |
|
4253
bd7590d0c6b6
(__INT_TO_PTR) [__STDC__]: Cast result to
Paul Eggert <eggert@cs.ucla.edu>
parents:
2991
diff
changeset
|
2 Copyright (C) 1988,89,90,91,92,93,94,96,97,98,99,2003 Free Software Foundation, Inc. |
| 334 | 3 |
| 2991 | 4 This file is part of the GNU C Library. Its master source is NOT part of |
| 881 | 5 the C library, however. The master source lives in /gd/gnu/lib. |
| 334 | 6 |
| 1112 | 7 NOTE: The canonical source of this file is maintained with the GNU C Library. |
| 2991 | 8 Bugs can be reported to bug-glibc@gnu.org. |
| 334 | 9 |
| 1112 | 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 | |
| 13 later version. | |
| 14 | |
| 15 This program is distributed in the hope that it will be useful, | |
| 881 | 16 but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 2979 | 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 18 Library General Public License for more details. | |
| 881 | 19 |
| 2979 | 20 You should have received a copy of the GNU Library General Public |
| 21 License along with this program; if not, write to the Free Software | |
| 1112 | 22 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, |
| 23 USA. */ | |
| 334 | 24 |
| 25 /* Summary: | |
| 26 | |
| 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!! | |
| 32 | |
| 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. | |
| 39 | |
| 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. | |
| 44 | |
| 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. | |
| 48 | |
| 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 | |
| 53 symbols. | |
| 54 | |
| 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. | |
| 62 | |
| 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. | |
| 67 | |
| 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. | |
| 76 | |
| 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. | |
| 83 | |
| 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. | |
| 88 | |
| 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. | |
| 92 | |
| 93 Summary: | |
| 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 | |
| 98 growing object. | |
| 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.) | |
| 105 */ | |
| 106 | |
| 107 | |
| 108 /* Don't do the contents of this file more than once. */ | |
| 109 | |
| 1112 | 110 #ifndef _OBSTACK_H |
| 111 #define _OBSTACK_H 1 | |
| 112 | |
| 995 | 113 #ifdef __cplusplus |
| 114 extern "C" { | |
| 115 #endif | |
| 116 | |
| 881 | 117 /* We use subtraction of (char *) 0 instead of casting to int |
| 334 | 118 because on word-addressable machines a simple cast to int |
| 119 may ignore the byte-within-word field of the pointer. */ | |
| 120 | |
| 121 #ifndef __PTR_TO_INT | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
122 # define __PTR_TO_INT(P) ((P) - (char *) 0) |
| 334 | 123 #endif |
| 124 | |
| 125 #ifndef __INT_TO_PTR | |
|
4253
bd7590d0c6b6
(__INT_TO_PTR) [__STDC__]: Cast result to
Paul Eggert <eggert@cs.ucla.edu>
parents:
2991
diff
changeset
|
126 #if defined __STDC__ && __STDC__ |
|
bd7590d0c6b6
(__INT_TO_PTR) [__STDC__]: Cast result to
Paul Eggert <eggert@cs.ucla.edu>
parents:
2991
diff
changeset
|
127 # define __INT_TO_PTR(P) ((void *) ((P) + (char *) 0)) |
|
bd7590d0c6b6
(__INT_TO_PTR) [__STDC__]: Cast result to
Paul Eggert <eggert@cs.ucla.edu>
parents:
2991
diff
changeset
|
128 #else |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
129 # define __INT_TO_PTR(P) ((P) + (char *) 0) |
| 334 | 130 #endif |
|
4253
bd7590d0c6b6
(__INT_TO_PTR) [__STDC__]: Cast result to
Paul Eggert <eggert@cs.ucla.edu>
parents:
2991
diff
changeset
|
131 #endif |
| 334 | 132 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
133 /* We need the type of the resulting object. If __PTRDIFF_TYPE__ is |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
134 defined, as with GNU C, use that; that way we don't pollute the |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
135 namespace with <stddef.h>'s symbols. Otherwise, if <stddef.h> is |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
136 available, include it and use ptrdiff_t. In traditional C, long is |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
137 the best that we can do. */ |
| 334 | 138 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
139 #ifdef __PTRDIFF_TYPE__ |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
140 # define PTR_INT_TYPE __PTRDIFF_TYPE__ |
| 334 | 141 #else |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
142 # ifdef HAVE_STDDEF_H |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
143 # include <stddef.h> |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
144 # define PTR_INT_TYPE ptrdiff_t |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
145 # else |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
146 # define PTR_INT_TYPE long |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
147 # endif |
| 334 | 148 #endif |
| 149 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
150 #if defined _LIBC || defined HAVE_STRING_H |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
151 # include <string.h> |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
152 # define _obstack_memcpy(To, From, N) memcpy ((To), (From), (N)) |
| 881 | 153 #else |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
154 # ifdef memcpy |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
155 # define _obstack_memcpy(To, From, N) memcpy ((To), (From), (N)) |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
156 # else |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
157 # define _obstack_memcpy(To, From, N) bcopy ((From), (To), (N)) |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
158 # endif |
| 881 | 159 #endif |
| 160 | |
| 334 | 161 struct _obstack_chunk /* Lives at front of each chunk. */ |
| 162 { | |
| 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 */ | |
| 166 }; | |
| 167 | |
| 168 struct obstack /* control current object in current chunk */ | |
| 169 { | |
| 170 long chunk_size; /* preferred size to allocate chunks in */ | |
| 881 | 171 struct _obstack_chunk *chunk; /* address of current struct obstack_chunk */ |
| 334 | 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. */ | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
177 #if defined __STDC__ && __STDC__ |
| 779 | 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 *); | |
| 881 | 183 void *extra_arg; /* first arg for chunk alloc/dealloc funcs */ |
| 779 | 184 #else |
| 334 | 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 */ | |
| 779 | 188 #endif |
| 334 | 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. */ | |
| 881 | 194 unsigned alloc_failed:1; /* No longer used, as we now call the failed |
| 195 handler on error, but retained for binary | |
| 196 compatibility. */ | |
| 334 | 197 }; |
| 198 | |
| 199 /* Declare the external functions we use; they are in obstack.c. */ | |
| 200 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
201 #if defined __STDC__ && __STDC__ |
| 334 | 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, | |
| 779 | 205 void *(*) (long), void (*) (void *)); |
| 334 | 206 extern int _obstack_begin_1 (struct obstack *, int, int, |
| 779 | 207 void *(*) (void *, long), |
| 208 void (*) (void *, void *), void *); | |
| 881 | 209 extern int _obstack_memory_used (struct obstack *); |
| 334 | 210 #else |
| 211 extern void _obstack_newchunk (); | |
| 212 extern void _obstack_free (); | |
| 213 extern int _obstack_begin (); | |
| 214 extern int _obstack_begin_1 (); | |
| 881 | 215 extern int _obstack_memory_used (); |
| 334 | 216 #endif |
| 217 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
218 #if defined __STDC__ && __STDC__ |
| 334 | 219 |
| 220 /* Do the function-declarations after the structs | |
| 221 but before defining the macros. */ | |
| 222 | |
| 223 void obstack_init (struct obstack *obstack); | |
| 224 | |
| 225 void * obstack_alloc (struct obstack *obstack, int size); | |
| 226 | |
| 2979 | 227 void * obstack_copy (struct obstack *obstack, const void *address, int size); |
| 228 void * obstack_copy0 (struct obstack *obstack, const void *address, int size); | |
| 334 | 229 |
| 230 void obstack_free (struct obstack *obstack, void *block); | |
| 231 | |
| 232 void obstack_blank (struct obstack *obstack, int size); | |
| 233 | |
| 2979 | 234 void obstack_grow (struct obstack *obstack, const void *data, int size); |
| 235 void obstack_grow0 (struct obstack *obstack, const void *data, int size); | |
| 334 | 236 |
| 237 void obstack_1grow (struct obstack *obstack, int data_char); | |
| 2979 | 238 void obstack_ptr_grow (struct obstack *obstack, const void *data); |
| 334 | 239 void obstack_int_grow (struct obstack *obstack, int data); |
| 240 | |
| 241 void * obstack_finish (struct obstack *obstack); | |
| 242 | |
| 243 int obstack_object_size (struct obstack *obstack); | |
| 244 | |
| 245 int obstack_room (struct obstack *obstack); | |
| 881 | 246 void obstack_make_room (struct obstack *obstack, int size); |
| 334 | 247 void obstack_1grow_fast (struct obstack *obstack, int data_char); |
| 2979 | 248 void obstack_ptr_grow_fast (struct obstack *obstack, const void *data); |
| 334 | 249 void obstack_int_grow_fast (struct obstack *obstack, int data); |
| 250 void obstack_blank_fast (struct obstack *obstack, int size); | |
| 251 | |
| 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); | |
| 881 | 256 int obstack_memory_used (struct obstack *obstack); |
| 334 | 257 |
| 258 #endif /* __STDC__ */ | |
| 259 | |
| 260 /* Non-ANSI C cannot really support alternative functions for these macros, | |
| 261 so we do not declare them. */ | |
| 881 | 262 |
| 263 /* Error handler called when `obstack_chunk_alloc' failed to allocate | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
264 more memory. This can be set to a user defined function which |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
265 should either abort gracefully or use longjump - but shouldn't |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
266 return. The default action is to print a message and abort. */ |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
267 #if defined __STDC__ && __STDC__ |
| 881 | 268 extern void (*obstack_alloc_failed_handler) (void); |
| 269 #else | |
| 270 extern void (*obstack_alloc_failed_handler) (); | |
| 271 #endif | |
| 272 | |
| 273 /* Exit value used when `print_and_abort' is used. */ | |
| 274 extern int obstack_exit_failure; | |
| 334 | 275 |
| 276 /* Pointer to beginning of object being allocated or to be allocated next. | |
| 277 Note that this might not be the final address of the object | |
| 278 because a new chunk might be needed to hold the final size. */ | |
| 279 | |
| 881 | 280 #define obstack_base(h) ((h)->object_base) |
| 334 | 281 |
| 282 /* Size for allocating ordinary chunks. */ | |
| 283 | |
| 284 #define obstack_chunk_size(h) ((h)->chunk_size) | |
| 285 | |
| 286 /* Pointer to next byte not yet allocated in current chunk. */ | |
| 287 | |
| 881 | 288 #define obstack_next_free(h) ((h)->next_free) |
| 334 | 289 |
| 290 /* Mask specifying low bits that should be clear in address of an object. */ | |
| 291 | |
| 292 #define obstack_alignment_mask(h) ((h)->alignment_mask) | |
| 293 | |
| 779 | 294 /* To prevent prototype warnings provide complete argument list in |
| 295 standard C version. */ | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
296 #if defined __STDC__ && __STDC__ |
| 779 | 297 |
| 2990 | 298 # define obstack_init(h) \ |
| 299 _obstack_begin ((h), 0, 0, \ | |
| 300 (void *(*) (long)) obstack_chunk_alloc, \ | |
| 301 (void (*) (void *)) obstack_chunk_free) | |
| 779 | 302 |
| 2990 | 303 # define obstack_begin(h, size) \ |
| 304 _obstack_begin ((h), (size), 0, \ | |
| 305 (void *(*) (long)) obstack_chunk_alloc, \ | |
| 306 (void (*) (void *)) obstack_chunk_free) | |
| 779 | 307 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
308 # define obstack_specify_allocation(h, size, alignment, chunkfun, freefun) \ |
| 2990 | 309 _obstack_begin ((h), (size), (alignment), \ |
| 310 (void *(*) (long)) (chunkfun), \ | |
| 311 (void (*) (void *)) (freefun)) | |
| 779 | 312 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
313 # define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \ |
| 2990 | 314 _obstack_begin_1 ((h), (size), (alignment), \ |
| 315 (void *(*) (void *, long)) (chunkfun), \ | |
| 995 | 316 (void (*) (void *, void *)) (freefun), (arg)) |
| 779 | 317 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
318 # define obstack_chunkfun(h, newchunkfun) \ |
| 995 | 319 ((h) -> chunkfun = (struct _obstack_chunk *(*)(void *, long)) (newchunkfun)) |
| 779 | 320 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
321 # define obstack_freefun(h, newfreefun) \ |
| 995 | 322 ((h) -> freefun = (void (*)(void *, struct _obstack_chunk *)) (newfreefun)) |
| 779 | 323 |
| 324 #else | |
| 325 | |
| 2990 | 326 # define obstack_init(h) \ |
| 327 _obstack_begin ((h), 0, 0, \ | |
| 328 (void *(*) ()) obstack_chunk_alloc, \ | |
| 329 (void (*) ()) obstack_chunk_free) | |
| 334 | 330 |
| 2990 | 331 # define obstack_begin(h, size) \ |
| 332 _obstack_begin ((h), (size), 0, \ | |
| 333 (void *(*) ()) obstack_chunk_alloc, \ | |
| 334 (void (*) ()) obstack_chunk_free) | |
| 334 | 335 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
336 # define obstack_specify_allocation(h, size, alignment, chunkfun, freefun) \ |
| 2990 | 337 _obstack_begin ((h), (size), (alignment), \ |
| 338 (void *(*) ()) (chunkfun), \ | |
| 339 (void (*) ()) (freefun)) | |
| 334 | 340 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
341 # define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \ |
| 2990 | 342 _obstack_begin_1 ((h), (size), (alignment), \ |
| 343 (void *(*) ()) (chunkfun), \ | |
| 344 (void (*) ()) (freefun), (arg)) | |
| 334 | 345 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
346 # define obstack_chunkfun(h, newchunkfun) \ |
| 334 | 347 ((h) -> chunkfun = (struct _obstack_chunk *(*)()) (newchunkfun)) |
| 348 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
349 # define obstack_freefun(h, newfreefun) \ |
| 334 | 350 ((h) -> freefun = (void (*)()) (newfreefun)) |
| 351 | |
| 779 | 352 #endif |
| 353 | |
| 334 | 354 #define obstack_1grow_fast(h,achar) (*((h)->next_free)++ = achar) |
| 355 | |
| 356 #define obstack_blank_fast(h,n) ((h)->next_free += (n)) | |
| 881 | 357 |
| 358 #define obstack_memory_used(h) _obstack_memory_used (h) | |
| 334 | 359 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
360 #if defined __GNUC__ && defined __STDC__ && __STDC__ |
| 350 | 361 /* NextStep 2.0 cc is really gcc 1.93 but it defines __GNUC__ = 2 and |
| 362 does not implement __extension__. But that compiler doesn't define | |
| 363 __GNUC_MINOR__. */ | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
364 # if __GNUC__ < 2 || (__NeXT__ && !__GNUC_MINOR__) |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
365 # define __extension__ |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
366 # endif |
| 334 | 367 |
| 368 /* For GNU C, if not -traditional, | |
| 369 we can define these macros to compute all args only once | |
| 370 without using a global variable. | |
| 371 Also, we can avoid using the `temp' slot, to make faster code. */ | |
| 372 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
373 # define obstack_object_size(OBSTACK) \ |
| 334 | 374 __extension__ \ |
| 375 ({ struct obstack *__o = (OBSTACK); \ | |
| 376 (unsigned) (__o->next_free - __o->object_base); }) | |
| 377 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
378 # define obstack_room(OBSTACK) \ |
| 334 | 379 __extension__ \ |
| 380 ({ struct obstack *__o = (OBSTACK); \ | |
| 381 (unsigned) (__o->chunk_limit - __o->next_free); }) | |
| 382 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
383 # define obstack_make_room(OBSTACK,length) \ |
| 881 | 384 __extension__ \ |
| 385 ({ struct obstack *__o = (OBSTACK); \ | |
| 386 int __len = (length); \ | |
| 387 if (__o->chunk_limit - __o->next_free < __len) \ | |
| 388 _obstack_newchunk (__o, __len); \ | |
| 389 (void) 0; }) | |
| 390 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
391 # define obstack_empty_p(OBSTACK) \ |
| 1112 | 392 __extension__ \ |
| 393 ({ struct obstack *__o = (OBSTACK); \ | |
| 394 (__o->chunk->prev == 0 && __o->next_free - __o->chunk->contents == 0); }) | |
| 395 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
396 # define obstack_grow(OBSTACK,where,length) \ |
| 334 | 397 __extension__ \ |
| 398 ({ struct obstack *__o = (OBSTACK); \ | |
| 399 int __len = (length); \ | |
| 400 if (__o->next_free + __len > __o->chunk_limit) \ | |
| 401 _obstack_newchunk (__o, __len); \ | |
| 2990 | 402 _obstack_memcpy (__o->next_free, (where), __len); \ |
| 881 | 403 __o->next_free += __len; \ |
| 334 | 404 (void) 0; }) |
| 405 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
406 # define obstack_grow0(OBSTACK,where,length) \ |
| 334 | 407 __extension__ \ |
| 408 ({ struct obstack *__o = (OBSTACK); \ | |
| 409 int __len = (length); \ | |
| 410 if (__o->next_free + __len + 1 > __o->chunk_limit) \ | |
| 411 _obstack_newchunk (__o, __len + 1); \ | |
| 2990 | 412 _obstack_memcpy (__o->next_free, (where), __len); \ |
| 881 | 413 __o->next_free += __len; \ |
| 414 *(__o->next_free)++ = 0; \ | |
| 334 | 415 (void) 0; }) |
| 416 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
417 # define obstack_1grow(OBSTACK,datum) \ |
| 334 | 418 __extension__ \ |
| 419 ({ struct obstack *__o = (OBSTACK); \ | |
| 420 if (__o->next_free + 1 > __o->chunk_limit) \ | |
| 421 _obstack_newchunk (__o, 1); \ | |
| 881 | 422 *(__o->next_free)++ = (datum); \ |
| 334 | 423 (void) 0; }) |
| 424 | |
| 2990 | 425 /* These assume that the obstack alignment is good enough for pointers |
| 426 or ints, and that the data added so far to the current object | |
| 334 | 427 shares that much alignment. */ |
| 479 | 428 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
429 # define obstack_ptr_grow(OBSTACK,datum) \ |
| 334 | 430 __extension__ \ |
| 431 ({ struct obstack *__o = (OBSTACK); \ | |
| 432 if (__o->next_free + sizeof (void *) > __o->chunk_limit) \ | |
| 433 _obstack_newchunk (__o, sizeof (void *)); \ | |
| 2990 | 434 *((void **)__o->next_free)++ = (datum); \ |
| 334 | 435 (void) 0; }) |
| 436 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
437 # define obstack_int_grow(OBSTACK,datum) \ |
| 334 | 438 __extension__ \ |
| 439 ({ struct obstack *__o = (OBSTACK); \ | |
| 440 if (__o->next_free + sizeof (int) > __o->chunk_limit) \ | |
| 441 _obstack_newchunk (__o, sizeof (int)); \ | |
| 2990 | 442 *((int *)__o->next_free)++ = (datum); \ |
| 334 | 443 (void) 0; }) |
| 444 | |
| 2990 | 445 # define obstack_ptr_grow_fast(h,aptr) \ |
| 446 (*((void **) (h)->next_free)++ = (aptr)) | |
| 447 | |
| 448 # define obstack_int_grow_fast(h,aint) \ | |
| 449 (*((int *) (h)->next_free)++ = (aint)) | |
| 334 | 450 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
451 # define obstack_blank(OBSTACK,length) \ |
| 334 | 452 __extension__ \ |
| 453 ({ struct obstack *__o = (OBSTACK); \ | |
| 454 int __len = (length); \ | |
| 455 if (__o->chunk_limit - __o->next_free < __len) \ | |
| 456 _obstack_newchunk (__o, __len); \ | |
| 881 | 457 __o->next_free += __len; \ |
| 334 | 458 (void) 0; }) |
| 459 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
460 # define obstack_alloc(OBSTACK,length) \ |
| 334 | 461 __extension__ \ |
| 462 ({ struct obstack *__h = (OBSTACK); \ | |
| 463 obstack_blank (__h, (length)); \ | |
| 464 obstack_finish (__h); }) | |
| 465 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
466 # define obstack_copy(OBSTACK,where,length) \ |
| 334 | 467 __extension__ \ |
| 468 ({ struct obstack *__h = (OBSTACK); \ | |
| 469 obstack_grow (__h, (where), (length)); \ | |
| 470 obstack_finish (__h); }) | |
| 471 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
472 # define obstack_copy0(OBSTACK,where,length) \ |
| 334 | 473 __extension__ \ |
| 474 ({ struct obstack *__h = (OBSTACK); \ | |
| 475 obstack_grow0 (__h, (where), (length)); \ | |
| 476 obstack_finish (__h); }) | |
| 477 | |
| 478 /* The local variable is named __o1 to avoid a name conflict | |
| 479 when obstack_blank is called. */ | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
480 # define obstack_finish(OBSTACK) \ |
| 334 | 481 __extension__ \ |
| 482 ({ struct obstack *__o1 = (OBSTACK); \ | |
| 483 void *value; \ | |
| 881 | 484 value = (void *) __o1->object_base; \ |
| 485 if (__o1->next_free == value) \ | |
| 486 __o1->maybe_empty_object = 1; \ | |
| 487 __o1->next_free \ | |
| 488 = __INT_TO_PTR ((__PTR_TO_INT (__o1->next_free)+__o1->alignment_mask)\ | |
| 489 & ~ (__o1->alignment_mask)); \ | |
| 490 if (__o1->next_free - (char *)__o1->chunk \ | |
| 491 > __o1->chunk_limit - (char *)__o1->chunk) \ | |
| 492 __o1->next_free = __o1->chunk_limit; \ | |
| 493 __o1->object_base = __o1->next_free; \ | |
| 334 | 494 value; }) |
| 495 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
496 # define obstack_free(OBSTACK, OBJ) \ |
| 334 | 497 __extension__ \ |
| 498 ({ struct obstack *__o = (OBSTACK); \ | |
| 499 void *__obj = (OBJ); \ | |
| 500 if (__obj > (void *)__o->chunk && __obj < (void *)__o->chunk_limit) \ | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
501 __o->next_free = __o->object_base = (char *)__obj; \ |
| 334 | 502 else (obstack_free) (__o, __obj); }) |
| 503 | |
| 504 #else /* not __GNUC__ or not __STDC__ */ | |
| 505 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
506 # define obstack_object_size(h) \ |
| 881 | 507 (unsigned) ((h)->next_free - (h)->object_base) |
| 334 | 508 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
509 # define obstack_room(h) \ |
| 334 | 510 (unsigned) ((h)->chunk_limit - (h)->next_free) |
| 511 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
512 # define obstack_empty_p(h) \ |
| 1112 | 513 ((h)->chunk->prev == 0 && (h)->next_free - (h)->chunk->contents == 0) |
| 514 | |
| 334 | 515 /* Note that the call to _obstack_newchunk is enclosed in (..., 0) |
| 516 so that we can avoid having void expressions | |
| 517 in the arms of the conditional expression. | |
| 518 Casting the third operand to void was tried before, | |
| 519 but some compilers won't accept it. */ | |
| 520 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
521 # define obstack_make_room(h,length) \ |
| 881 | 522 ( (h)->temp = (length), \ |
| 523 (((h)->next_free + (h)->temp > (h)->chunk_limit) \ | |
| 524 ? (_obstack_newchunk ((h), (h)->temp), 0) : 0)) | |
| 525 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
526 # define obstack_grow(h,where,length) \ |
| 334 | 527 ( (h)->temp = (length), \ |
| 528 (((h)->next_free + (h)->temp > (h)->chunk_limit) \ | |
| 529 ? (_obstack_newchunk ((h), (h)->temp), 0) : 0), \ | |
| 2990 | 530 _obstack_memcpy ((h)->next_free, (where), (h)->temp), \ |
| 881 | 531 (h)->next_free += (h)->temp) |
| 334 | 532 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
533 # define obstack_grow0(h,where,length) \ |
| 334 | 534 ( (h)->temp = (length), \ |
| 535 (((h)->next_free + (h)->temp + 1 > (h)->chunk_limit) \ | |
| 536 ? (_obstack_newchunk ((h), (h)->temp + 1), 0) : 0), \ | |
| 2990 | 537 _obstack_memcpy ((h)->next_free, (where), (h)->temp), \ |
| 334 | 538 (h)->next_free += (h)->temp, \ |
| 881 | 539 *((h)->next_free)++ = 0) |
| 334 | 540 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
541 # define obstack_1grow(h,datum) \ |
| 334 | 542 ( (((h)->next_free + 1 > (h)->chunk_limit) \ |
| 543 ? (_obstack_newchunk ((h), 1), 0) : 0), \ | |
| 881 | 544 (*((h)->next_free)++ = (datum))) |
| 334 | 545 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
546 # define obstack_ptr_grow(h,datum) \ |
| 334 | 547 ( (((h)->next_free + sizeof (char *) > (h)->chunk_limit) \ |
| 548 ? (_obstack_newchunk ((h), sizeof (char *)), 0) : 0), \ | |
| 2990 | 549 (*((const char **) (((h)->next_free+=sizeof(char *))-sizeof(char *))) = (datum))) |
| 334 | 550 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
551 # define obstack_int_grow(h,datum) \ |
| 334 | 552 ( (((h)->next_free + sizeof (int) > (h)->chunk_limit) \ |
| 553 ? (_obstack_newchunk ((h), sizeof (int)), 0) : 0), \ | |
| 2990 | 554 (*((int *) (((h)->next_free+=sizeof(int))-sizeof(int))) = (datum))) |
| 334 | 555 |
| 2990 | 556 # define obstack_ptr_grow_fast(h,aptr) \ |
| 557 (*((const char **) (h)->next_free)++ = (aptr)) | |
| 558 | |
| 559 # define obstack_int_grow_fast(h,aint) \ | |
| 560 (*((int *) (h)->next_free)++ = (aint)) | |
| 334 | 561 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
562 # define obstack_blank(h,length) \ |
| 334 | 563 ( (h)->temp = (length), \ |
| 564 (((h)->chunk_limit - (h)->next_free < (h)->temp) \ | |
| 565 ? (_obstack_newchunk ((h), (h)->temp), 0) : 0), \ | |
| 881 | 566 ((h)->next_free += (h)->temp)) |
| 334 | 567 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
568 # define obstack_alloc(h,length) \ |
| 334 | 569 (obstack_blank ((h), (length)), obstack_finish ((h))) |
| 570 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
571 # define obstack_copy(h,where,length) \ |
| 334 | 572 (obstack_grow ((h), (where), (length)), obstack_finish ((h))) |
| 573 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
574 # define obstack_copy0(h,where,length) \ |
| 334 | 575 (obstack_grow0 ((h), (where), (length)), obstack_finish ((h))) |
| 576 | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
577 # define obstack_finish(h) \ |
| 881 | 578 ( ((h)->next_free == (h)->object_base \ |
| 334 | 579 ? (((h)->maybe_empty_object = 1), 0) \ |
| 580 : 0), \ | |
| 581 (h)->temp = __PTR_TO_INT ((h)->object_base), \ | |
| 582 (h)->next_free \ | |
| 583 = __INT_TO_PTR ((__PTR_TO_INT ((h)->next_free)+(h)->alignment_mask) \ | |
| 584 & ~ ((h)->alignment_mask)), \ | |
| 881 | 585 (((h)->next_free - (char *) (h)->chunk \ |
| 586 > (h)->chunk_limit - (char *) (h)->chunk) \ | |
| 334 | 587 ? ((h)->next_free = (h)->chunk_limit) : 0), \ |
| 588 (h)->object_base = (h)->next_free, \ | |
| 881 | 589 __INT_TO_PTR ((h)->temp)) |
| 334 | 590 |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
591 # if defined __STDC__ && __STDC__ |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
592 # define obstack_free(h,obj) \ |
| 881 | 593 ( (h)->temp = (char *) (obj) - (char *) (h)->chunk, \ |
| 334 | 594 (((h)->temp > 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\ |
| 595 ? (int) ((h)->next_free = (h)->object_base \ | |
| 596 = (h)->temp + (char *) (h)->chunk) \ | |
| 597 : (((obstack_free) ((h), (h)->temp + (char *) (h)->chunk), 0), 0))) | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
598 # else |
|
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
599 # define obstack_free(h,obj) \ |
| 881 | 600 ( (h)->temp = (char *) (obj) - (char *) (h)->chunk, \ |
| 334 | 601 (((h)->temp > 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\ |
| 602 ? (int) ((h)->next_free = (h)->object_base \ | |
| 603 = (h)->temp + (char *) (h)->chunk) \ | |
| 604 : (_obstack_free ((h), (h)->temp + (char *) (h)->chunk), 0))) | |
|
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
605 # endif |
| 334 | 606 |
| 607 #endif /* not __GNUC__ or not __STDC__ */ | |
| 608 | |
| 995 | 609 #ifdef __cplusplus |
| 610 } /* C++ */ | |
| 611 #endif | |
| 612 | |
| 1112 | 613 #endif /* obstack.h */ |