Changeset 3613 for trunk/src/sed/lib/obstack.h
- Timestamp:
- Sep 19, 2024, 2:34:43 AM (10 months ago)
- Location:
- trunk/src/sed
- Files:
-
- 2 edited
-
. (modified) (1 prop)
-
lib/obstack.h (modified) (9 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/sed
-
Property svn:mergeinfo
set to
/vendor/sed/current merged eligible
-
Property svn:mergeinfo
set to
-
trunk/src/sed/lib/obstack.h
r599 r3613 1 1 /* obstack.h - object stack macros 2 Copyright (C) 1988,89,90,91,92,93,94,96,97,98,99 Free Software Foundation, Inc. 3 This file is part of the GNU C Library. Its master source is NOT part of 4 the C library, however. The master source lives in /gd/gnu/lib. 5 6 The GNU C Library is free software; you can redistribute it and/or 7 modify it under the terms of the GNU Lesser General Public 8 License as published by the Free Software Foundation; either 9 version 2.1 of the License, or (at your option) any later version. 10 11 The GNU C Library is distributed in the hope that it will be useful, 2 Copyright (C) 1988-2022 Free Software Foundation, Inc. 3 This file is part of the GNU C Library. 4 5 This file is free software: you can redistribute it and/or modify 6 it under the terms of the GNU Lesser General Public License as 7 published by the Free Software Foundation, either version 3 of the 8 License, or (at your option) any later version. 9 10 This file is distributed in the hope that it will be useful, 12 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 Lesser General Public License for more details. 15 16 You should have received a copy of the GNU Lesser General Public 17 License along with the GNU C Library; if not, write to the Free 18 Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19 02110-1301 USA. */ 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU Lesser General Public License for more details. 14 15 You should have received a copy of the GNU Lesser General Public License 16 along with this program. If not, see <https://www.gnu.org/licenses/>. */ 20 17 21 18 /* Summary: 22 19 23 All the apparent functions defined here are macros. The idea24 is that you would use these pre-tested macros to solve a25 very specific set of problems, and they would run fast.26 Caution: no side-effects in arguments please!! They may be27 evaluated MANY times!!28 29 These macros operate a stack of objects. Each object starts life30 small, and may grow to maturity. (Consider building a word syllable31 by syllable.) An object can move while it is growing. Once it has32 been "finished" it never changes address again. So the "top of the33 stack" is typically an immature growing object, while the rest of the34 stack is of mature, fixed size and fixed address objects.35 36 These routines grab large chunks of memory, using a function you37 supply, called `obstack_chunk_alloc'. On occasion, they free chunks,38 by calling `obstack_chunk_free'. You must define them and declare39 them before using any obstack macros.40 41 Each independent stack is represented by a `struct obstack'.42 Each of the obstack macros expects a pointer to such a structure43 as the first argument.44 45 One motivation for this package is the problem of growing char strings46 in symbol tables. Unless you are "fascist pig with a read-only mind"47 --Gosper's immortal quote from HAKMEM item 154, out of context--you48 would not like to put any arbitrary upper limit on the length of your49 symbols.50 51 In practice this often means you will build many short symbols and a52 few long symbols. At the time you are reading a symbol you don't know53 how long it is. One traditional method is to read a symbol into a54 buffer, realloc()ating the buffer every time you try to read a symbol55 that is longer than the buffer. This is beaut, but you still will56 want to copy the symbol from the buffer to a more permanent57 symbol-table entry say about half the time.58 59 With obstacks, you can work differently. Use one obstack for all symbol60 names. As you read a symbol, grow the name in the obstack gradually.61 When the name is complete, finalize it. Then, if the symbol exists already,62 free the newly read name.63 64 The way we do this is to take a large chunk, allocating memory from65 low addresses. When you want to build a symbol in the chunk you just66 add chars above the current "high water mark" in the chunk. When you67 have finished adding chars, because you got to the end of the symbol,68 you know how long the chars are, and you can create a new object.69 Mostly the chars will not burst over the highest address of the chunk,70 because you would typically expect a chunk to be (say) 100 times as71 long as an average object.72 73 In case that isn't clear, when we have enough chars to make up74 the object, THEY ARE ALREADY CONTIGUOUS IN THE CHUNK (guaranteed)75 so we just point to it where it lies. No moving of chars is76 needed and this is the second win: potentially long strings need77 never be explicitly shuffled. Once an object is formed, it does not78 change its address during its lifetime.79 80 When the chars burst over a chunk boundary, we allocate a larger81 chunk, and then copy the partly formed object from the end of the old82 chunk to the beginning of the new larger chunk. We then carry on83 accreting characters to the end of the object as we normally would.84 85 A special macro is provided to add a single char at a time to a86 growing object. This allows the use of register variables, which87 break the ordinary 'growth' macro.88 89 Summary:90 91 92 93 94 95 96 97 98 Because of the way we do it, you can `unwind'an obstack99 100 101 */20 All the apparent functions defined here are macros. The idea 21 is that you would use these pre-tested macros to solve a 22 very specific set of problems, and they would run fast. 23 Caution: no side-effects in arguments please!! They may be 24 evaluated MANY times!! 25 26 These macros operate a stack of objects. Each object starts life 27 small, and may grow to maturity. (Consider building a word syllable 28 by syllable.) An object can move while it is growing. Once it has 29 been "finished" it never changes address again. So the "top of the 30 stack" is typically an immature growing object, while the rest of the 31 stack is of mature, fixed size and fixed address objects. 32 33 These routines grab large chunks of memory, using a function you 34 supply, called 'obstack_chunk_alloc'. On occasion, they free chunks, 35 by calling 'obstack_chunk_free'. You must define them and declare 36 them before using any obstack macros. 37 38 Each independent stack is represented by a 'struct obstack'. 39 Each of the obstack macros expects a pointer to such a structure 40 as the first argument. 41 42 One motivation for this package is the problem of growing char strings 43 in symbol tables. Unless you are "fascist pig with a read-only mind" 44 --Gosper's immortal quote from HAKMEM item 154, out of context--you 45 would not like to put any arbitrary upper limit on the length of your 46 symbols. 47 48 In practice this often means you will build many short symbols and a 49 few long symbols. At the time you are reading a symbol you don't know 50 how long it is. One traditional method is to read a symbol into a 51 buffer, realloc()ating the buffer every time you try to read a symbol 52 that is longer than the buffer. This is beaut, but you still will 53 want to copy the symbol from the buffer to a more permanent 54 symbol-table entry say about half the time. 55 56 With obstacks, you can work differently. Use one obstack for all symbol 57 names. As you read a symbol, grow the name in the obstack gradually. 58 When the name is complete, finalize it. Then, if the symbol exists already, 59 free the newly read name. 60 61 The way we do this is to take a large chunk, allocating memory from 62 low addresses. When you want to build a symbol in the chunk you just 63 add chars above the current "high water mark" in the chunk. When you 64 have finished adding chars, because you got to the end of the symbol, 65 you know how long the chars are, and you can create a new object. 66 Mostly the chars will not burst over the highest address of the chunk, 67 because you would typically expect a chunk to be (say) 100 times as 68 long as an average object. 69 70 In case that isn't clear, when we have enough chars to make up 71 the object, THEY ARE ALREADY CONTIGUOUS IN THE CHUNK (guaranteed) 72 so we just point to it where it lies. No moving of chars is 73 needed and this is the second win: potentially long strings need 74 never be explicitly shuffled. Once an object is formed, it does not 75 change its address during its lifetime. 76 77 When the chars burst over a chunk boundary, we allocate a larger 78 chunk, and then copy the partly formed object from the end of the old 79 chunk to the beginning of the new larger chunk. We then carry on 80 accreting characters to the end of the object as we normally would. 81 82 A special macro is provided to add a single char at a time to a 83 growing object. This allows the use of register variables, which 84 break the ordinary 'growth' macro. 85 86 Summary: 87 We allocate large chunks. 88 We carve out one object at a time from the current chunk. 89 Once carved, an object never moves. 90 We are free to append data of any size to the currently 91 growing object. 92 Exactly one object is growing in an obstack at any one time. 93 You can run one obstack per control block. 94 You may have as many control blocks as you dare. 95 Because of the way we do it, you can "unwind" an obstack 96 back to a previous state. (You may remove objects much 97 as you would with a stack.) 98 */ 102 99 103 100 … … 107 104 #define _OBSTACK_H 1 108 105 109 #ifdef HAVE_CONFIG_H 110 #include "config.h" 106 #ifndef _OBSTACK_INTERFACE_VERSION 107 # define _OBSTACK_INTERFACE_VERSION 2 108 #endif 109 110 #include <stddef.h> /* For size_t and ptrdiff_t. */ 111 #include <string.h> /* For __GNU_LIBRARY__, and memcpy. */ 112 113 #if __STDC_VERSION__ < 199901L || defined __HP_cc 114 # define __FLEXIBLE_ARRAY_MEMBER 1 115 #else 116 # define __FLEXIBLE_ARRAY_MEMBER 117 #endif 118 119 #if _OBSTACK_INTERFACE_VERSION == 1 120 /* For binary compatibility with obstack version 1, which used "int" 121 and "long" for these two types. */ 122 # define _OBSTACK_SIZE_T unsigned int 123 # define _CHUNK_SIZE_T unsigned long 124 # define _OBSTACK_CAST(type, expr) ((type) (expr)) 125 #else 126 /* Version 2 with sane types, especially for 64-bit hosts. */ 127 # define _OBSTACK_SIZE_T size_t 128 # define _CHUNK_SIZE_T size_t 129 # define _OBSTACK_CAST(type, expr) (expr) 130 #endif 131 132 /* If B is the base of an object addressed by P, return the result of 133 aligning P to the next multiple of A + 1. B and P must be of type 134 char *. A + 1 must be a power of 2. */ 135 136 #define __BPTR_ALIGN(B, P, A) ((B) + (((P) - (B) + (A)) & ~(A))) 137 138 /* Similar to __BPTR_ALIGN (B, P, A), except optimize the common case 139 where pointers can be converted to integers, aligned as integers, 140 and converted back again. If ptrdiff_t is narrower than a 141 pointer (e.g., the AS/400), play it safe and compute the alignment 142 relative to B. Otherwise, use the faster strategy of computing the 143 alignment relative to 0. */ 144 145 #define __PTR_ALIGN(B, P, A) \ 146 __BPTR_ALIGN (sizeof (ptrdiff_t) < sizeof (void *) ? (B) : (char *) 0, \ 147 P, A) 148 149 #ifndef __attribute_pure__ 150 # define __attribute_pure__ _GL_ATTRIBUTE_PURE 151 #endif 152 153 /* Not the same as _Noreturn, since it also works with function pointers. */ 154 #ifndef __attribute_noreturn__ 155 # if 2 < __GNUC__ + (8 <= __GNUC_MINOR__) || defined __clang__ || 0x5110 <= __SUNPRO_C 156 # define __attribute_noreturn__ __attribute__ ((__noreturn__)) 157 # else 158 # define __attribute_noreturn__ 159 # endif 111 160 #endif 112 161 … … 115 164 #endif 116 165 117 118 /* We use subtraction of (char *) 0 instead of casting to int 119 because on word-addressable machines a simple cast to int 120 may ignore the byte-within-word field of the pointer. */ 121 122 #ifndef __PTR_TO_INT 123 # define __PTR_TO_INT(P) ((P) - (char *) 0) 124 #endif 125 126 #ifndef __INT_TO_PTR 127 # define __INT_TO_PTR(P) ((P) + (char *) 0) 128 #endif 129 130 /* We need the type of the resulting object. If __PTRDIFF_TYPE__ is 131 defined, as with GNU C, use that; that way we don't pollute the 132 namespace with <stddef.h>'s symbols. Otherwise, if <stddef.h> is 133 available, include it and use ptrdiff_t. In traditional C, long is 134 the best that we can do. */ 135 136 #ifdef __PTRDIFF_TYPE__ 137 # define PTR_INT_TYPE __PTRDIFF_TYPE__ 138 #else 139 # ifdef HAVE_STDDEF_H 140 # include <stddef.h> 141 # define PTR_INT_TYPE ptrdiff_t 142 # else 143 # define PTR_INT_TYPE long 144 # endif 145 #endif 146 147 #if defined _LIBC || defined HAVE_STRING_H 148 # include <string.h> 149 # define _obstack_memcpy(To, From, N) memcpy ((To), (From), (N)) 150 #else 151 # ifdef memcpy 152 # define _obstack_memcpy(To, From, N) memcpy ((To), (From), (N)) 153 # else 154 # define _obstack_memcpy(To, From, N) bcopy ((From), (To), (N)) 155 # endif 156 #endif 157 158 struct _obstack_chunk /* Lives at front of each chunk. */ 166 struct _obstack_chunk /* Lives at front of each chunk. */ 159 167 { 160 char *limit;/* 1 past end of this chunk */161 struct _obstack_chunk *prev; 162 char contents[4];/* objects begin here */168 char *limit; /* 1 past end of this chunk */ 169 struct _obstack_chunk *prev; /* address of prior chunk or NULL */ 170 char contents[__FLEXIBLE_ARRAY_MEMBER]; /* objects begin here */ 163 171 }; 164 172 165 struct obstack 173 struct obstack /* control current object in current chunk */ 166 174 { 167 long chunk_size; /* preferred size to allocate chunks in */ 168 struct _obstack_chunk *chunk; /* address of current struct obstack_chunk */ 169 char *object_base; /* address of object we are building */ 170 char *next_free; /* where to add next char to current object */ 171 char *chunk_limit; /* address of char after current chunk */ 172 PTR_INT_TYPE temp; /* Temporary for some macros. */ 173 int alignment_mask; /* Mask of alignment for each object. */ 174 #if defined __STDC__ && __STDC__ 175 /* These prototypes vary based on `use_extra_arg', and we use 176 casts to the prototypeless function type in all assignments, 177 but having prototypes here quiets -Wstrict-prototypes. */ 178 struct _obstack_chunk *(*chunkfun) (void *, long); 179 void (*freefun) (void *, struct _obstack_chunk *); 180 void *extra_arg; /* first arg for chunk alloc/dealloc funcs */ 181 #else 182 struct _obstack_chunk *(*chunkfun) (); /* User's fcn to allocate a chunk. */ 183 void (*freefun) (); /* User's function to free a chunk. */ 184 char *extra_arg; /* first arg for chunk alloc/dealloc funcs */ 185 #endif 186 unsigned use_extra_arg:1; /* chunk alloc/dealloc funcs take extra arg */ 187 unsigned maybe_empty_object:1;/* There is a possibility that the current 188 chunk contains a zero-length object. This 189 prevents freeing the chunk if we allocate 190 a bigger chunk to replace it. */ 191 unsigned alloc_failed:1; /* No longer used, as we now call the failed 192 handler on error, but retained for binary 193 compatibility. */ 175 _CHUNK_SIZE_T chunk_size; /* preferred size to allocate chunks in */ 176 struct _obstack_chunk *chunk; /* address of current struct obstack_chunk */ 177 char *object_base; /* address of object we are building */ 178 char *next_free; /* where to add next char to current object */ 179 char *chunk_limit; /* address of char after current chunk */ 180 union 181 { 182 _OBSTACK_SIZE_T i; 183 void *p; 184 } temp; /* Temporary for some macros. */ 185 _OBSTACK_SIZE_T alignment_mask; /* Mask of alignment for each object. */ 186 187 /* These prototypes vary based on 'use_extra_arg'. */ 188 union 189 { 190 void *(*plain) (size_t); 191 void *(*extra) (void *, size_t); 192 } chunkfun; 193 union 194 { 195 void (*plain) (void *); 196 void (*extra) (void *, void *); 197 } freefun; 198 199 void *extra_arg; /* first arg for chunk alloc/dealloc funcs */ 200 unsigned use_extra_arg : 1; /* chunk alloc/dealloc funcs take extra arg */ 201 unsigned maybe_empty_object : 1; /* There is a possibility that the current 202 chunk contains a zero-length object. This 203 prevents freeing the chunk if we allocate 204 a bigger chunk to replace it. */ 205 unsigned alloc_failed : 1; /* No longer used, as we now call the failed 206 handler on error, but retained for binary 207 compatibility. */ 194 208 }; 195 209 196 210 /* Declare the external functions we use; they are in obstack.c. */ 197 211 198 #if defined __STDC__ && __STDC__ 199 extern void _obstack_newchunk (struct obstack *, int); 212 extern void _obstack_newchunk (struct obstack *, _OBSTACK_SIZE_T); 200 213 extern void _obstack_free (struct obstack *, void *); 201 extern int _obstack_begin (struct obstack *, int, int, 202 void *(*) (long), void (*) (void *)); 203 extern int _obstack_begin_1 (struct obstack *, int, int, 204 void *(*) (void *, long), 205 void (*) (void *, void *), void *); 206 extern int _obstack_memory_used (struct obstack *); 207 #else 208 extern void _obstack_newchunk (); 209 extern void _obstack_free (); 210 extern int _obstack_begin (); 211 extern int _obstack_begin_1 (); 212 extern int _obstack_memory_used (); 213 #endif 214 215 216 #if defined __STDC__ && __STDC__ 217 218 /* Do the function-declarations after the structs 219 but before defining the macros. */ 220 221 void obstack_init (struct obstack *obstack); 222 223 void * obstack_alloc (struct obstack *obstack, int size); 224 225 void * obstack_copy (struct obstack *obstack, const void *address, int size); 226 void * obstack_copy0 (struct obstack *obstack, const void *address, int size); 227 228 void obstack_free (struct obstack *obstack, void *block); 229 230 void obstack_blank (struct obstack *obstack, int size); 231 232 void obstack_grow (struct obstack *obstack, const void *data, int size); 233 void obstack_grow0 (struct obstack *obstack, const void *data, int size); 234 235 void obstack_1grow (struct obstack *obstack, int data_char); 236 void obstack_ptr_grow (struct obstack *obstack, const void *data); 237 void obstack_int_grow (struct obstack *obstack, int data); 238 239 void * obstack_finish (struct obstack *obstack); 240 241 int obstack_object_size (struct obstack *obstack); 242 243 int obstack_room (struct obstack *obstack); 244 void obstack_make_room (struct obstack *obstack, int size); 245 void obstack_1grow_fast (struct obstack *obstack, int data_char); 246 void obstack_ptr_grow_fast (struct obstack *obstack, const void *data); 247 void obstack_int_grow_fast (struct obstack *obstack, int data); 248 void obstack_blank_fast (struct obstack *obstack, int size); 249 250 void * obstack_base (struct obstack *obstack); 251 void * obstack_next_free (struct obstack *obstack); 252 int obstack_alignment_mask (struct obstack *obstack); 253 int obstack_chunk_size (struct obstack *obstack); 254 int obstack_memory_used (struct obstack *obstack); 255 256 #endif /* __STDC__ */ 257 258 /* Non-ANSI C cannot really support alternative functions for these macros, 259 so we do not declare them. */ 260 261 /* Error handler called when `obstack_chunk_alloc' failed to allocate 214 extern int _obstack_begin (struct obstack *, 215 _OBSTACK_SIZE_T, _OBSTACK_SIZE_T, 216 void *(*) (size_t), void (*) (void *)); 217 extern int _obstack_begin_1 (struct obstack *, 218 _OBSTACK_SIZE_T, _OBSTACK_SIZE_T, 219 void *(*) (void *, size_t), 220 void (*) (void *, void *), void *); 221 extern _OBSTACK_SIZE_T _obstack_memory_used (struct obstack *) 222 __attribute_pure__; 223 224 225 /* Error handler called when 'obstack_chunk_alloc' failed to allocate 262 226 more memory. This can be set to a user defined function which 263 227 should either abort gracefully or use longjump - but shouldn't 264 228 return. The default action is to print a message and abort. */ 265 #if defined __STDC__ && __STDC__ 266 extern void (*obstack_alloc_failed_handler) (void); 267 #else 268 extern void (*obstack_alloc_failed_handler) (); 269 #endif 270 271 /* Exit value used when `print_and_abort' is used. */ 229 extern __attribute_noreturn__ void (*obstack_alloc_failed_handler) (void); 230 231 /* Exit value used when 'print_and_abort' is used. */ 272 232 extern int obstack_exit_failure; 273 274 233 275 234 /* Pointer to beginning of object being allocated or to be allocated next. … … 277 236 because a new chunk might be needed to hold the final size. */ 278 237 279 #define obstack_base(h) (( h)->object_base)238 #define obstack_base(h) ((void *) (h)->object_base) 280 239 281 240 /* Size for allocating ordinary chunks. */ … … 285 244 /* Pointer to next byte not yet allocated in current chunk. */ 286 245 287 #define obstack_next_free(h) ((h)->next_free)246 #define obstack_next_free(h) ((void *) (h)->next_free) 288 247 289 248 /* Mask specifying low bits that should be clear in address of an object. */ … … 291 250 #define obstack_alignment_mask(h) ((h)->alignment_mask) 292 251 293 /* To prevent prototype warnings provide complete argument list in 294 standard C version. */ 295 #if defined __STDC__ && __STDC__ 296 297 # define obstack_init(h) \ 298 _obstack_begin ((h), 0, 0, \ 299 (void *(*) (long)) obstack_chunk_alloc, \ 300 (void (*) (void *)) obstack_chunk_free) 301 302 # define obstack_begin(h, size) \ 303 _obstack_begin ((h), (size), 0, \ 304 (void *(*) (long)) obstack_chunk_alloc, \ 305 (void (*) (void *)) obstack_chunk_free) 306 307 # define obstack_specify_allocation(h, size, alignment, chunkfun, freefun) \ 308 _obstack_begin ((h), (size), (alignment), \ 309 (void *(*) (long)) (chunkfun), \ 310 (void (*) (void *)) (freefun)) 311 312 # define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \ 313 _obstack_begin_1 ((h), (size), (alignment), \ 314 (void *(*) (void *, long)) (chunkfun), \ 315 (void (*) (void *, void *)) (freefun), (arg)) 316 317 # define obstack_chunkfun(h, newchunkfun) \ 318 ((h) -> chunkfun = (struct _obstack_chunk *(*)(void *, long)) (newchunkfun)) 319 320 # define obstack_freefun(h, newfreefun) \ 321 ((h) -> freefun = (void (*)(void *, struct _obstack_chunk *)) (newfreefun)) 322 323 #else 324 325 # define obstack_init(h) \ 326 _obstack_begin ((h), 0, 0, \ 327 (void *(*) ()) obstack_chunk_alloc, \ 328 (void (*) ()) obstack_chunk_free) 329 330 # define obstack_begin(h, size) \ 331 _obstack_begin ((h), (size), 0, \ 332 (void *(*) ()) obstack_chunk_alloc, \ 333 (void (*) ()) obstack_chunk_free) 334 335 # define obstack_specify_allocation(h, size, alignment, chunkfun, freefun) \ 336 _obstack_begin ((h), (size), (alignment), \ 337 (void *(*) ()) (chunkfun), \ 338 (void (*) ()) (freefun)) 339 340 # define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \ 341 _obstack_begin_1 ((h), (size), (alignment), \ 342 (void *(*) ()) (chunkfun), \ 343 (void (*) ()) (freefun), (arg)) 344 345 # define obstack_chunkfun(h, newchunkfun) \ 346 ((h) -> chunkfun = (struct _obstack_chunk *(*)()) (newchunkfun)) 347 348 # define obstack_freefun(h, newfreefun) \ 349 ((h) -> freefun = (void (*)()) (newfreefun)) 350 351 #endif 352 353 #define obstack_1grow_fast(h,achar) (*((h)->next_free)++ = achar) 354 355 #define obstack_blank_fast(h,n) ((h)->next_free += (n)) 252 /* To prevent prototype warnings provide complete argument list. */ 253 #define obstack_init(h) \ 254 _obstack_begin ((h), 0, 0, \ 255 _OBSTACK_CAST (void *(*) (size_t), obstack_chunk_alloc), \ 256 _OBSTACK_CAST (void (*) (void *), obstack_chunk_free)) 257 258 #define obstack_begin(h, size) \ 259 _obstack_begin ((h), (size), 0, \ 260 _OBSTACK_CAST (void *(*) (size_t), obstack_chunk_alloc), \ 261 _OBSTACK_CAST (void (*) (void *), obstack_chunk_free)) 262 263 #define obstack_specify_allocation(h, size, alignment, chunkfun, freefun) \ 264 _obstack_begin ((h), (size), (alignment), \ 265 _OBSTACK_CAST (void *(*) (size_t), chunkfun), \ 266 _OBSTACK_CAST (void (*) (void *), freefun)) 267 268 #define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \ 269 _obstack_begin_1 ((h), (size), (alignment), \ 270 _OBSTACK_CAST (void *(*) (void *, size_t), chunkfun), \ 271 _OBSTACK_CAST (void (*) (void *, void *), freefun), arg) 272 273 #define obstack_chunkfun(h, newchunkfun) \ 274 ((void) ((h)->chunkfun.extra = (void *(*) (void *, size_t)) (newchunkfun))) 275 276 #define obstack_freefun(h, newfreefun) \ 277 ((void) ((h)->freefun.extra = (void *(*) (void *, void *)) (newfreefun))) 278 279 #define obstack_1grow_fast(h, achar) ((void) (*((h)->next_free)++ = (achar))) 280 281 #define obstack_blank_fast(h, n) ((void) ((h)->next_free += (n))) 356 282 357 283 #define obstack_memory_used(h) _obstack_memory_used (h) 358 284 359 360 #if defined __GNUC__ && defined __STDC__ && __STDC__ 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__. */ 364 # if __GNUC__ < 2 || (__NeXT__ && !__GNUC_MINOR__) 285 #if defined __GNUC__ || defined __clang__ 286 # if !(defined __GNUC_MINOR__ && __GNUC__ * 1000 + __GNUC_MINOR__ >= 2008 \ 287 || defined __clang__) 365 288 # define __extension__ 366 289 # endif … … 369 292 we can define these macros to compute all args only once 370 293 without using a global variable. 371 Also, we can avoid using the `temp' slot, to make faster code. */ 372 373 # define obstack_object_size(OBSTACK) \ 374 __extension__ \ 375 ({ struct obstack *__o = (OBSTACK); \ 376 (unsigned) (__o->next_free - __o->object_base); }) 377 378 # define obstack_room(OBSTACK) \ 379 __extension__ \ 380 ({ struct obstack *__o = (OBSTACK); \ 381 (unsigned) (__o->chunk_limit - __o->next_free); }) 382 383 # define obstack_make_room(OBSTACK,length) \ 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 391 # define obstack_empty_p(OBSTACK) \ 392 __extension__ \ 393 ({ struct obstack *__o = (OBSTACK); \ 394 (__o->chunk->prev == 0 && __o->next_free - __o->chunk->contents == 0); }) 395 396 # define obstack_grow(OBSTACK,where,length) \ 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); \ 402 _obstack_memcpy (__o->next_free, (where), __len); \ 403 __o->next_free += __len; \ 404 (void) 0; }) 405 406 # define obstack_grow0(OBSTACK,where,length) \ 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); \ 412 _obstack_memcpy (__o->next_free, (where), __len); \ 413 __o->next_free += __len; \ 414 *(__o->next_free)++ = 0; \ 415 (void) 0; }) 416 417 # define obstack_1grow(OBSTACK,datum) \ 418 __extension__ \ 419 ({ struct obstack *__o = (OBSTACK); \ 420 if (__o->next_free + 1 > __o->chunk_limit) \ 421 _obstack_newchunk (__o, 1); \ 422 *(__o->next_free)++ = (datum); \ 423 (void) 0; }) 294 Also, we can avoid using the 'temp' slot, to make faster code. */ 295 296 # define obstack_object_size(OBSTACK) \ 297 __extension__ \ 298 ({ struct obstack const *__o = (OBSTACK); \ 299 (_OBSTACK_SIZE_T) (__o->next_free - __o->object_base); }) 300 301 /* The local variable is named __o1 to avoid a shadowed variable 302 warning when invoked from other obstack macros. */ 303 # define obstack_room(OBSTACK) \ 304 __extension__ \ 305 ({ struct obstack const *__o1 = (OBSTACK); \ 306 (_OBSTACK_SIZE_T) (__o1->chunk_limit - __o1->next_free); }) 307 308 # define obstack_make_room(OBSTACK, length) \ 309 __extension__ \ 310 ({ struct obstack *__o = (OBSTACK); \ 311 _OBSTACK_SIZE_T __len = (length); \ 312 if (obstack_room (__o) < __len) \ 313 _obstack_newchunk (__o, __len); \ 314 (void) 0; }) 315 316 # define obstack_empty_p(OBSTACK) \ 317 __extension__ \ 318 ({ struct obstack const *__o = (OBSTACK); \ 319 (__o->chunk->prev == 0 \ 320 && __o->next_free == __PTR_ALIGN ((char *) __o->chunk, \ 321 __o->chunk->contents, \ 322 __o->alignment_mask)); }) 323 324 # define obstack_grow(OBSTACK, where, length) \ 325 __extension__ \ 326 ({ struct obstack *__o = (OBSTACK); \ 327 _OBSTACK_SIZE_T __len = (length); \ 328 if (obstack_room (__o) < __len) \ 329 _obstack_newchunk (__o, __len); \ 330 memcpy (__o->next_free, where, __len); \ 331 __o->next_free += __len; \ 332 (void) 0; }) 333 334 # define obstack_grow0(OBSTACK, where, length) \ 335 __extension__ \ 336 ({ struct obstack *__o = (OBSTACK); \ 337 _OBSTACK_SIZE_T __len = (length); \ 338 if (obstack_room (__o) < __len + 1) \ 339 _obstack_newchunk (__o, __len + 1); \ 340 memcpy (__o->next_free, where, __len); \ 341 __o->next_free += __len; \ 342 *(__o->next_free)++ = 0; \ 343 (void) 0; }) 344 345 # define obstack_1grow(OBSTACK, datum) \ 346 __extension__ \ 347 ({ struct obstack *__o = (OBSTACK); \ 348 if (obstack_room (__o) < 1) \ 349 _obstack_newchunk (__o, 1); \ 350 obstack_1grow_fast (__o, datum); }) 424 351 425 352 /* These assume that the obstack alignment is good enough for pointers … … 427 354 shares that much alignment. */ 428 355 429 # define obstack_ptr_grow(OBSTACK,datum) \ 430 __extension__ \ 431 ({ struct obstack *__o = (OBSTACK); \ 432 if (__o->next_free + sizeof (void *) > __o->chunk_limit) \ 433 _obstack_newchunk (__o, sizeof (void *)); \ 434 ((*((void **)__o->next_free) = (datum)), (__o->next_free += sizeof (void *))); \ 435 (void) 0; }) 436 437 # define obstack_int_grow(OBSTACK,datum) \ 438 __extension__ \ 439 ({ struct obstack *__o = (OBSTACK); \ 440 if (__o->next_free + sizeof (int) > __o->chunk_limit) \ 441 _obstack_newchunk (__o, sizeof (int)); \ 442 ((*((int *)__o->next_free) = (datum)), (__o->next_free += sizeof (int ))); \ 443 (void) 0; }) 444 445 # define obstack_ptr_grow_fast(h,aptr) \ 446 (((*((void **) (h)->next_free) = (aptr)), ( (h)->next_free += sizeof (void *)))) 447 448 # define obstack_int_grow_fast(h,aint) \ 449 (((*((int *) (h)->next_free) = (aint)), ( (h)->next_free += sizeof (int )))) 450 451 # define obstack_blank(OBSTACK,length) \ 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); \ 457 __o->next_free += __len; \ 458 (void) 0; }) 459 460 # define obstack_alloc(OBSTACK,length) \ 461 __extension__ \ 462 ({ struct obstack *__h = (OBSTACK); \ 463 obstack_blank (__h, (length)); \ 464 obstack_finish (__h); }) 465 466 # define obstack_copy(OBSTACK,where,length) \ 467 __extension__ \ 468 ({ struct obstack *__h = (OBSTACK); \ 469 obstack_grow (__h, (where), (length)); \ 470 obstack_finish (__h); }) 471 472 # define obstack_copy0(OBSTACK,where,length) \ 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. */ 480 # define obstack_finish(OBSTACK) \ 481 __extension__ \ 482 ({ struct obstack *__o1 = (OBSTACK); \ 483 void *value; \ 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; \ 494 value; }) 495 496 # define obstack_free(OBSTACK, OBJ) \ 497 __extension__ \ 498 ({ struct obstack *__o = (OBSTACK); \ 499 void *__obj = (OBJ); \ 500 if (__obj > (void *)__o->chunk && __obj < (void *)__o->chunk_limit) \ 501 __o->next_free = __o->object_base = (char *)__obj; \ 502 else (obstack_free) (__o, __obj); }) 503 504 505 #else /* not __GNUC__ or not __STDC__ */ 506 507 # define obstack_object_size(h) \ 508 (unsigned) ((h)->next_free - (h)->object_base) 509 510 # define obstack_room(h) \ 511 (unsigned) ((h)->chunk_limit - (h)->next_free) 512 513 # define obstack_empty_p(h) \ 514 ((h)->chunk->prev == 0 && (h)->next_free - (h)->chunk->contents == 0) 356 # define obstack_ptr_grow(OBSTACK, datum) \ 357 __extension__ \ 358 ({ struct obstack *__o = (OBSTACK); \ 359 if (obstack_room (__o) < sizeof (void *)) \ 360 _obstack_newchunk (__o, sizeof (void *)); \ 361 obstack_ptr_grow_fast (__o, datum); }) 362 363 # define obstack_int_grow(OBSTACK, datum) \ 364 __extension__ \ 365 ({ struct obstack *__o = (OBSTACK); \ 366 if (obstack_room (__o) < sizeof (int)) \ 367 _obstack_newchunk (__o, sizeof (int)); \ 368 obstack_int_grow_fast (__o, datum); }) 369 370 # define obstack_ptr_grow_fast(OBSTACK, aptr) \ 371 __extension__ \ 372 ({ struct obstack *__o1 = (OBSTACK); \ 373 void *__p1 = __o1->next_free; \ 374 *(const void **) __p1 = (aptr); \ 375 __o1->next_free += sizeof (const void *); \ 376 (void) 0; }) 377 378 # define obstack_int_grow_fast(OBSTACK, aint) \ 379 __extension__ \ 380 ({ struct obstack *__o1 = (OBSTACK); \ 381 void *__p1 = __o1->next_free; \ 382 *(int *) __p1 = (aint); \ 383 __o1->next_free += sizeof (int); \ 384 (void) 0; }) 385 386 # define obstack_blank(OBSTACK, length) \ 387 __extension__ \ 388 ({ struct obstack *__o = (OBSTACK); \ 389 _OBSTACK_SIZE_T __len = (length); \ 390 if (obstack_room (__o) < __len) \ 391 _obstack_newchunk (__o, __len); \ 392 obstack_blank_fast (__o, __len); }) 393 394 # define obstack_alloc(OBSTACK, length) \ 395 __extension__ \ 396 ({ struct obstack *__h = (OBSTACK); \ 397 obstack_blank (__h, (length)); \ 398 obstack_finish (__h); }) 399 400 # define obstack_copy(OBSTACK, where, length) \ 401 __extension__ \ 402 ({ struct obstack *__h = (OBSTACK); \ 403 obstack_grow (__h, (where), (length)); \ 404 obstack_finish (__h); }) 405 406 # define obstack_copy0(OBSTACK, where, length) \ 407 __extension__ \ 408 ({ struct obstack *__h = (OBSTACK); \ 409 obstack_grow0 (__h, (where), (length)); \ 410 obstack_finish (__h); }) 411 412 /* The local variable is named __o1 to avoid a shadowed variable 413 warning when invoked from other obstack macros, typically obstack_free. */ 414 # define obstack_finish(OBSTACK) \ 415 __extension__ \ 416 ({ struct obstack *__o1 = (OBSTACK); \ 417 void *__value = (void *) __o1->object_base; \ 418 if (__o1->next_free == __value) \ 419 __o1->maybe_empty_object = 1; \ 420 __o1->next_free \ 421 = __PTR_ALIGN (__o1->object_base, __o1->next_free, \ 422 __o1->alignment_mask); \ 423 if ((size_t) (__o1->next_free - (char *) __o1->chunk) \ 424 > (size_t) (__o1->chunk_limit - (char *) __o1->chunk)) \ 425 __o1->next_free = __o1->chunk_limit; \ 426 __o1->object_base = __o1->next_free; \ 427 __value; }) 428 429 # define obstack_free(OBSTACK, OBJ) \ 430 __extension__ \ 431 ({ struct obstack *__o = (OBSTACK); \ 432 void *__obj = (void *) (OBJ); \ 433 if (__obj > (void *) __o->chunk && __obj < (void *) __o->chunk_limit) \ 434 __o->next_free = __o->object_base = (char *) __obj; \ 435 else \ 436 _obstack_free (__o, __obj); }) 437 438 #else /* not __GNUC__ */ 439 440 # define obstack_object_size(h) \ 441 ((_OBSTACK_SIZE_T) ((h)->next_free - (h)->object_base)) 442 443 # define obstack_room(h) \ 444 ((_OBSTACK_SIZE_T) ((h)->chunk_limit - (h)->next_free)) 445 446 # define obstack_empty_p(h) \ 447 ((h)->chunk->prev == 0 \ 448 && (h)->next_free == __PTR_ALIGN ((char *) (h)->chunk, \ 449 (h)->chunk->contents, \ 450 (h)->alignment_mask)) 515 451 516 452 /* Note that the call to _obstack_newchunk is enclosed in (..., 0) … … 520 456 but some compilers won't accept it. */ 521 457 522 # define obstack_make_room(h,length) \ 523 ( (h)->temp = (length), \ 524 (((h)->next_free + (h)->temp > (h)->chunk_limit) \ 525 ? (_obstack_newchunk ((h), (h)->temp), 0) : 0)) 526 527 # define obstack_grow(h,where,length) \ 528 ( (h)->temp = (length), \ 529 (((h)->next_free + (h)->temp > (h)->chunk_limit) \ 530 ? (_obstack_newchunk ((h), (h)->temp), 0) : 0), \ 531 _obstack_memcpy ((h)->next_free, (where), (h)->temp), \ 532 (h)->next_free += (h)->temp) 533 534 # define obstack_grow0(h,where,length) \ 535 ( (h)->temp = (length), \ 536 (((h)->next_free + (h)->temp + 1 > (h)->chunk_limit) \ 537 ? (_obstack_newchunk ((h), (h)->temp + 1), 0) : 0), \ 538 _obstack_memcpy ((h)->next_free, (where), (h)->temp), \ 539 (h)->next_free += (h)->temp, \ 540 *((h)->next_free)++ = 0) 541 542 # define obstack_1grow(h,datum) \ 543 ( (((h)->next_free + 1 > (h)->chunk_limit) \ 544 ? (_obstack_newchunk ((h), 1), 0) : 0), \ 545 (*((h)->next_free)++ = (datum))) 546 547 # define obstack_ptr_grow(h,datum) \ 548 ( (((h)->next_free + sizeof (char *) > (h)->chunk_limit) \ 549 ? (_obstack_newchunk ((h), sizeof (char *)), 0) : 0), \ 550 (*((const char **) (((h)->next_free+=sizeof(char *))-sizeof(char *))) = (datum))) 551 552 # define obstack_int_grow(h,datum) \ 553 ( (((h)->next_free + sizeof (int) > (h)->chunk_limit) \ 554 ? (_obstack_newchunk ((h), sizeof (int)), 0) : 0), \ 555 (*((int *) (((h)->next_free+=sizeof(int))-sizeof(int))) = (datum))) 556 557 # define obstack_ptr_grow_fast(h,aptr) \ 558 (((*((const char **) (h)->next_free) = (aptr)), ( (h)->next_free += sizeof (const char *)))) 559 560 # define obstack_int_grow_fast(h,aint) \ 561 (((*((int *) (h)->next_free) = (aint)), ( (h)->next_free += sizeof (int )))) 562 563 # define obstack_blank(h,length) \ 564 ( (h)->temp = (length), \ 565 (((h)->chunk_limit - (h)->next_free < (h)->temp) \ 566 ? (_obstack_newchunk ((h), (h)->temp), 0) : 0), \ 567 ((h)->next_free += (h)->temp)) 568 569 # define obstack_alloc(h,length) \ 570 (obstack_blank ((h), (length)), obstack_finish ((h))) 571 572 # define obstack_copy(h,where,length) \ 573 (obstack_grow ((h), (where), (length)), obstack_finish ((h))) 574 575 # define obstack_copy0(h,where,length) \ 576 (obstack_grow0 ((h), (where), (length)), obstack_finish ((h))) 577 578 # define obstack_finish(h) \ 579 ( ((h)->next_free == (h)->object_base \ 580 ? (((h)->maybe_empty_object = 1), 0) \ 581 : 0), \ 582 (h)->temp = __PTR_TO_INT ((h)->object_base), \ 583 (h)->next_free \ 584 = __INT_TO_PTR ((__PTR_TO_INT ((h)->next_free)+(h)->alignment_mask) \ 585 & ~ ((h)->alignment_mask)), \ 586 (((h)->next_free - (char *) (h)->chunk \ 587 > (h)->chunk_limit - (char *) (h)->chunk) \ 588 ? ((h)->next_free = (h)->chunk_limit) : 0), \ 589 (h)->object_base = (h)->next_free, \ 590 __INT_TO_PTR ((h)->temp)) 591 592 # if defined __STDC__ && __STDC__ 593 # define obstack_free(h,obj) \ 594 ( (h)->temp = (char *) (obj) - (char *) (h)->chunk, \ 595 (((h)->temp > 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\ 596 ? (int) ((h)->next_free = (h)->object_base \ 597 = (h)->temp + (char *) (h)->chunk) \ 598 : (((obstack_free) ((h), (h)->temp + (char *) (h)->chunk), 0), 0))) 599 # else 600 # define obstack_free(h,obj) \ 601 ( (h)->temp = (char *) (obj) - (char *) (h)->chunk, \ 602 (((h)->temp > 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\ 603 ? (int) ((h)->next_free = (h)->object_base \ 604 = (h)->temp + (char *) (h)->chunk) \ 605 : (_obstack_free ((h), (h)->temp + (char *) (h)->chunk), 0))) 606 # endif 607 608 #endif /* not __GNUC__ or not __STDC__ */ 458 # define obstack_make_room(h, length) \ 459 ((h)->temp.i = (length), \ 460 ((obstack_room (h) < (h)->temp.i) \ 461 ? (_obstack_newchunk (h, (h)->temp.i), 0) : 0), \ 462 (void) 0) 463 464 # define obstack_grow(h, where, length) \ 465 ((h)->temp.i = (length), \ 466 ((obstack_room (h) < (h)->temp.i) \ 467 ? (_obstack_newchunk ((h), (h)->temp.i), 0) : 0), \ 468 memcpy ((h)->next_free, where, (h)->temp.i), \ 469 (h)->next_free += (h)->temp.i, \ 470 (void) 0) 471 472 # define obstack_grow0(h, where, length) \ 473 ((h)->temp.i = (length), \ 474 ((obstack_room (h) < (h)->temp.i + 1) \ 475 ? (_obstack_newchunk ((h), (h)->temp.i + 1), 0) : 0), \ 476 memcpy ((h)->next_free, where, (h)->temp.i), \ 477 (h)->next_free += (h)->temp.i, \ 478 *((h)->next_free)++ = 0, \ 479 (void) 0) 480 481 # define obstack_1grow(h, datum) \ 482 (((obstack_room (h) < 1) \ 483 ? (_obstack_newchunk ((h), 1), 0) : 0), \ 484 obstack_1grow_fast (h, datum)) 485 486 # define obstack_ptr_grow(h, datum) \ 487 (((obstack_room (h) < sizeof (char *)) \ 488 ? (_obstack_newchunk ((h), sizeof (char *)), 0) : 0), \ 489 obstack_ptr_grow_fast (h, datum)) 490 491 # define obstack_int_grow(h, datum) \ 492 (((obstack_room (h) < sizeof (int)) \ 493 ? (_obstack_newchunk ((h), sizeof (int)), 0) : 0), \ 494 obstack_int_grow_fast (h, datum)) 495 496 # define obstack_ptr_grow_fast(h, aptr) \ 497 (((const void **) ((h)->next_free += sizeof (void *)))[-1] = (aptr), \ 498 (void) 0) 499 500 # define obstack_int_grow_fast(h, aint) \ 501 (((int *) ((h)->next_free += sizeof (int)))[-1] = (aint), \ 502 (void) 0) 503 504 # define obstack_blank(h, length) \ 505 ((h)->temp.i = (length), \ 506 ((obstack_room (h) < (h)->temp.i) \ 507 ? (_obstack_newchunk ((h), (h)->temp.i), 0) : 0), \ 508 obstack_blank_fast (h, (h)->temp.i)) 509 510 # define obstack_alloc(h, length) \ 511 (obstack_blank ((h), (length)), obstack_finish ((h))) 512 513 # define obstack_copy(h, where, length) \ 514 (obstack_grow ((h), (where), (length)), obstack_finish ((h))) 515 516 # define obstack_copy0(h, where, length) \ 517 (obstack_grow0 ((h), (where), (length)), obstack_finish ((h))) 518 519 # define obstack_finish(h) \ 520 (((h)->next_free == (h)->object_base \ 521 ? (((h)->maybe_empty_object = 1), 0) \ 522 : 0), \ 523 (h)->temp.p = (h)->object_base, \ 524 (h)->next_free \ 525 = __PTR_ALIGN ((h)->object_base, (h)->next_free, \ 526 (h)->alignment_mask), \ 527 (((size_t) ((h)->next_free - (char *) (h)->chunk) \ 528 > (size_t) ((h)->chunk_limit - (char *) (h)->chunk)) \ 529 ? ((h)->next_free = (h)->chunk_limit) : 0), \ 530 (h)->object_base = (h)->next_free, \ 531 (h)->temp.p) 532 533 # define obstack_free(h, obj) \ 534 ((h)->temp.p = (void *) (obj), \ 535 (((h)->temp.p > (void *) (h)->chunk \ 536 && (h)->temp.p < (void *) (h)->chunk_limit) \ 537 ? (void) ((h)->next_free = (h)->object_base = (char *) (h)->temp.p) \ 538 : _obstack_free ((h), (h)->temp.p))) 539 540 #endif /* not __GNUC__ */ 609 541 610 542 #ifdef __cplusplus 611 } 612 #endif 613 614 #endif /* obstack.h*/543 } /* C++ */ 544 #endif 545 546 #endif /* _OBSTACK_H */
Note:
See TracChangeset
for help on using the changeset viewer.
