Mercurial > hg > octave-kai > gnulib-hg
annotate lib/obstack.h @ 17444:a83ad7365d40
fnmatch: don't goto over declaration
* lib/fnmatch_loop.c (FCT): Hoist local up one level, to avoid
undefined behavior for goto over a declaration.
Problem reported by Charlie Brown in
<http://lists.gnu.org/archive/html/bug-gnulib/2013-07/msg00009.html>.
author | Paul Eggert <eggert@cs.ucla.edu> |
---|---|
date | Sat, 06 Jul 2013 17:12:29 -0700 (2013-07-07) |
parents | 253d6bbd7aa4 |
children |
rev | line source |
---|---|
334 | 1 /* obstack.h - object stack macros |
17249
e542fd46ad6f
maint: update all copyright year number ranges
Eric Blake <eblake@redhat.com>
parents:
16358
diff
changeset
|
2 Copyright (C) 1988-1994, 1996-1999, 2003-2006, 2009-2013 Free Software |
12518
b5e42ef33b49
update nearly all FSF copyright year lists to include 2009
Jim Meyering <meyering@redhat.com>
parents:
12421
diff
changeset
|
3 Foundation, Inc. |
6376
56829cd68e67
* config/srclist.txt: Add glibc bug 321 for obstack.c, obstack.h.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5848
diff
changeset
|
4 This file is part of the GNU C Library. |
334 | 5 |
9309
bbbbbf4cd1c5
Change copyright notice from GPLv2+ to GPLv3+.
Bruno Haible <bruno@clisp.org>
parents:
7550
diff
changeset
|
6 This program is free software: you can redistribute it and/or modify |
4422 | 7 it under the terms of the GNU General Public License as published by |
9309
bbbbbf4cd1c5
Change copyright notice from GPLv2+ to GPLv3+.
Bruno Haible <bruno@clisp.org>
parents:
7550
diff
changeset
|
8 the Free Software Foundation; either version 3 of the License, or |
bbbbbf4cd1c5
Change copyright notice from GPLv2+ to GPLv3+.
Bruno Haible <bruno@clisp.org>
parents:
7550
diff
changeset
|
9 (at your option) any later version. |
1112 | 10 |
11 This program is distributed in the hope that it will be useful, | |
881 | 12 but WITHOUT ANY WARRANTY; without even the implied warranty of |
4422 | 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
14 GNU General Public License for more details. | |
881 | 15 |
9309
bbbbbf4cd1c5
Change copyright notice from GPLv2+ to GPLv3+.
Bruno Haible <bruno@clisp.org>
parents:
7550
diff
changeset
|
16 You should have received a copy of the GNU General Public License |
bbbbbf4cd1c5
Change copyright notice from GPLv2+ to GPLv3+.
Bruno Haible <bruno@clisp.org>
parents:
7550
diff
changeset
|
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
334 | 18 |
19 /* Summary: | |
20 | |
21 All the apparent functions defined here are macros. The idea | |
22 is that you would use these pre-tested macros to solve a | |
23 very specific set of problems, and they would run fast. | |
24 Caution: no side-effects in arguments please!! They may be | |
25 evaluated MANY times!! | |
26 | |
27 These macros operate a stack of objects. Each object starts life | |
28 small, and may grow to maturity. (Consider building a word syllable | |
29 by syllable.) An object can move while it is growing. Once it has | |
30 been "finished" it never changes address again. So the "top of the | |
31 stack" is typically an immature growing object, while the rest of the | |
32 stack is of mature, fixed size and fixed address objects. | |
33 | |
34 These routines grab large chunks of memory, using a function you | |
16235
18a38c9615f0
In commentary, do not use ` to quote.
Paul Eggert <eggert@cs.ucla.edu>
parents:
16201
diff
changeset
|
35 supply, called 'obstack_chunk_alloc'. On occasion, they free chunks, |
18a38c9615f0
In commentary, do not use ` to quote.
Paul Eggert <eggert@cs.ucla.edu>
parents:
16201
diff
changeset
|
36 by calling 'obstack_chunk_free'. You must define them and declare |
334 | 37 them before using any obstack macros. |
38 | |
16235
18a38c9615f0
In commentary, do not use ` to quote.
Paul Eggert <eggert@cs.ucla.edu>
parents:
16201
diff
changeset
|
39 Each independent stack is represented by a 'struct obstack'. |
334 | 40 Each of the obstack macros expects a pointer to such a structure |
41 as the first argument. | |
42 | |
43 One motivation for this package is the problem of growing char strings | |
44 in symbol tables. Unless you are "fascist pig with a read-only mind" | |
45 --Gosper's immortal quote from HAKMEM item 154, out of context--you | |
46 would not like to put any arbitrary upper limit on the length of your | |
47 symbols. | |
48 | |
49 In practice this often means you will build many short symbols and a | |
50 few long symbols. At the time you are reading a symbol you don't know | |
51 how long it is. One traditional method is to read a symbol into a | |
52 buffer, realloc()ating the buffer every time you try to read a symbol | |
53 that is longer than the buffer. This is beaut, but you still will | |
54 want to copy the symbol from the buffer to a more permanent | |
55 symbol-table entry say about half the time. | |
56 | |
57 With obstacks, you can work differently. Use one obstack for all symbol | |
58 names. As you read a symbol, grow the name in the obstack gradually. | |
59 When the name is complete, finalize it. Then, if the symbol exists already, | |
60 free the newly read name. | |
61 | |
62 The way we do this is to take a large chunk, allocating memory from | |
63 low addresses. When you want to build a symbol in the chunk you just | |
64 add chars above the current "high water mark" in the chunk. When you | |
65 have finished adding chars, because you got to the end of the symbol, | |
66 you know how long the chars are, and you can create a new object. | |
67 Mostly the chars will not burst over the highest address of the chunk, | |
68 because you would typically expect a chunk to be (say) 100 times as | |
69 long as an average object. | |
70 | |
71 In case that isn't clear, when we have enough chars to make up | |
72 the object, THEY ARE ALREADY CONTIGUOUS IN THE CHUNK (guaranteed) | |
73 so we just point to it where it lies. No moving of chars is | |
74 needed and this is the second win: potentially long strings need | |
75 never be explicitly shuffled. Once an object is formed, it does not | |
76 change its address during its lifetime. | |
77 | |
78 When the chars burst over a chunk boundary, we allocate a larger | |
79 chunk, and then copy the partly formed object from the end of the old | |
80 chunk to the beginning of the new larger chunk. We then carry on | |
81 accreting characters to the end of the object as we normally would. | |
82 | |
83 A special macro is provided to add a single char at a time to a | |
84 growing object. This allows the use of register variables, which | |
85 break the ordinary 'growth' macro. | |
86 | |
87 Summary: | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
88 We allocate large chunks. |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
89 We carve out one object at a time from the current chunk. |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
90 Once carved, an object never moves. |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
91 We are free to append data of any size to the currently |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
92 growing object. |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
93 Exactly one object is growing in an obstack at any one time. |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
94 You can run one obstack per control block. |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
95 You may have as many control blocks as you dare. |
16235
18a38c9615f0
In commentary, do not use ` to quote.
Paul Eggert <eggert@cs.ucla.edu>
parents:
16201
diff
changeset
|
96 Because of the way we do it, you can "unwind" an obstack |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
97 back to a previous state. (You may remove objects much |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
98 as you would with a stack.) |
334 | 99 */ |
100 | |
101 | |
102 /* Don't do the contents of this file more than once. */ | |
103 | |
1112 | 104 #ifndef _OBSTACK_H |
105 #define _OBSTACK_H 1 | |
995 | 106 |
5065
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
107 /* We need the type of a pointer subtraction. If __PTRDIFF_TYPE__ is |
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
108 defined, as with GNU C, use that; that way we don't pollute the |
4667 | 109 namespace with <stddef.h>'s symbols. Otherwise, include <stddef.h> |
110 and use ptrdiff_t. */ | |
334 | 111 |
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
112 #ifdef __PTRDIFF_TYPE__ |
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
113 # define PTR_INT_TYPE __PTRDIFF_TYPE__ |
334 | 114 #else |
4667 | 115 # include <stddef.h> |
116 # define PTR_INT_TYPE ptrdiff_t | |
334 | 117 #endif |
118 | |
5065
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
119 /* If B is the base of an object addressed by P, return the result of |
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
120 aligning P to the next multiple of A + 1. B and P must be of type |
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
121 char *. A + 1 must be a power of 2. */ |
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
122 |
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
123 #define __BPTR_ALIGN(B, P, A) ((B) + (((P) - (B) + (A)) & ~(A))) |
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
124 |
16358 | 125 /* Similar to _BPTR_ALIGN (B, P, A), except optimize the common case |
5065
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
126 where pointers can be converted to integers, aligned as integers, |
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
127 and converted back again. If PTR_INT_TYPE is narrower than a |
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
128 pointer (e.g., the AS/400), play it safe and compute the alignment |
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
129 relative to B. Otherwise, use the faster strategy of computing the |
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
130 alignment relative to 0. */ |
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
131 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
132 #define __PTR_ALIGN(B, P, A) \ |
5065
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
133 __BPTR_ALIGN (sizeof (PTR_INT_TYPE) < sizeof (void *) ? (B) : (char *) 0, \ |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
134 P, A) |
5065
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
135 |
4667 | 136 #include <string.h> |
881 | 137 |
13021
239c17119e60
Ensure no #include statements inside extern "C" { ... }.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
138 #ifdef __cplusplus |
239c17119e60
Ensure no #include statements inside extern "C" { ... }.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
139 extern "C" { |
239c17119e60
Ensure no #include statements inside extern "C" { ... }.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
140 #endif |
239c17119e60
Ensure no #include statements inside extern "C" { ... }.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
141 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
142 struct _obstack_chunk /* Lives at front of each chunk. */ |
334 | 143 { |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
144 char *limit; /* 1 past end of this chunk */ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
145 struct _obstack_chunk *prev; /* address of prior chunk or NULL */ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
146 char contents[4]; /* objects begin here */ |
334 | 147 }; |
148 | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
149 struct obstack /* control current object in current chunk */ |
334 | 150 { |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
151 long chunk_size; /* preferred size to allocate chunks in */ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
152 struct _obstack_chunk *chunk; /* address of current struct obstack_chunk */ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
153 char *object_base; /* address of object we are building */ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
154 char *next_free; /* where to add next char to current object */ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
155 char *chunk_limit; /* address of char after current chunk */ |
5065
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
156 union |
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
157 { |
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
158 PTR_INT_TYPE tempint; |
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
159 void *tempptr; |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
160 } temp; /* Temporary for some macros. */ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
161 int alignment_mask; /* Mask of alignment for each object. */ |
16235
18a38c9615f0
In commentary, do not use ` to quote.
Paul Eggert <eggert@cs.ucla.edu>
parents:
16201
diff
changeset
|
162 /* These prototypes vary based on 'use_extra_arg', and we use |
779 | 163 casts to the prototypeless function type in all assignments, |
164 but having prototypes here quiets -Wstrict-prototypes. */ | |
165 struct _obstack_chunk *(*chunkfun) (void *, long); | |
166 void (*freefun) (void *, struct _obstack_chunk *); | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
167 void *extra_arg; /* first arg for chunk alloc/dealloc funcs */ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
168 unsigned use_extra_arg:1; /* chunk alloc/dealloc funcs take extra arg */ |
334 | 169 unsigned maybe_empty_object:1;/* There is a possibility that the current |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
170 chunk contains a zero-length object. This |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
171 prevents freeing the chunk if we allocate |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
172 a bigger chunk to replace it. */ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
173 unsigned alloc_failed:1; /* No longer used, as we now call the failed |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
174 handler on error, but retained for binary |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
175 compatibility. */ |
334 | 176 }; |
177 | |
178 /* Declare the external functions we use; they are in obstack.c. */ | |
179 | |
180 extern void _obstack_newchunk (struct obstack *, int); | |
181 extern int _obstack_begin (struct obstack *, int, int, | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
182 void *(*) (long), void (*) (void *)); |
334 | 183 extern int _obstack_begin_1 (struct obstack *, int, int, |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
184 void *(*) (void *, long), |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
185 void (*) (void *, void *), void *); |
881 | 186 extern int _obstack_memory_used (struct obstack *); |
334 | 187 |
7550
0d3d27f21643
Make it possible to rename obstack_free.
Bruno Haible <bruno@clisp.org>
parents:
6376
diff
changeset
|
188 /* The default name of the function for freeing a chunk is 'obstack_free', |
0d3d27f21643
Make it possible to rename obstack_free.
Bruno Haible <bruno@clisp.org>
parents:
6376
diff
changeset
|
189 but gnulib users can override this by defining '__obstack_free'. */ |
0d3d27f21643
Make it possible to rename obstack_free.
Bruno Haible <bruno@clisp.org>
parents:
6376
diff
changeset
|
190 #ifndef __obstack_free |
0d3d27f21643
Make it possible to rename obstack_free.
Bruno Haible <bruno@clisp.org>
parents:
6376
diff
changeset
|
191 # define __obstack_free obstack_free |
0d3d27f21643
Make it possible to rename obstack_free.
Bruno Haible <bruno@clisp.org>
parents:
6376
diff
changeset
|
192 #endif |
0d3d27f21643
Make it possible to rename obstack_free.
Bruno Haible <bruno@clisp.org>
parents:
6376
diff
changeset
|
193 extern void __obstack_free (struct obstack *obstack, void *block); |
334 | 194 |
5070
57d23334289f
Remove unused vars and decls in obstack.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5065
diff
changeset
|
195 |
16235
18a38c9615f0
In commentary, do not use ` to quote.
Paul Eggert <eggert@cs.ucla.edu>
parents:
16201
diff
changeset
|
196 /* 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
|
197 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
|
198 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
|
199 return. The default action is to print a message and abort. */ |
881 | 200 extern void (*obstack_alloc_failed_handler) (void); |
201 | |
16235
18a38c9615f0
In commentary, do not use ` to quote.
Paul Eggert <eggert@cs.ucla.edu>
parents:
16201
diff
changeset
|
202 /* Exit value used when 'print_and_abort' is used. */ |
881 | 203 extern int obstack_exit_failure; |
334 | 204 |
205 /* Pointer to beginning of object being allocated or to be allocated next. | |
206 Note that this might not be the final address of the object | |
207 because a new chunk might be needed to hold the final size. */ | |
208 | |
5095
0afa9dc2bdfc
(obstack_base): Cast to (void *), per documentation.
Jim Meyering <jim@meyering.net>
parents:
5070
diff
changeset
|
209 #define obstack_base(h) ((void *) (h)->object_base) |
334 | 210 |
211 /* Size for allocating ordinary chunks. */ | |
212 | |
213 #define obstack_chunk_size(h) ((h)->chunk_size) | |
214 | |
215 /* Pointer to next byte not yet allocated in current chunk. */ | |
216 | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
217 #define obstack_next_free(h) ((h)->next_free) |
334 | 218 |
219 /* Mask specifying low bits that should be clear in address of an object. */ | |
220 | |
221 #define obstack_alignment_mask(h) ((h)->alignment_mask) | |
222 | |
4667 | 223 /* To prevent prototype warnings provide complete argument list. */ |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
224 #define obstack_init(h) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
225 _obstack_begin ((h), 0, 0, \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
226 (void *(*) (long)) obstack_chunk_alloc, \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
227 (void (*) (void *)) obstack_chunk_free) |
779 | 228 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
229 #define obstack_begin(h, size) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
230 _obstack_begin ((h), (size), 0, \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
231 (void *(*) (long)) obstack_chunk_alloc, \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
232 (void (*) (void *)) obstack_chunk_free) |
779 | 233 |
4805
8f430f14ff21
Merge changes from glibc obstack; minor cleanups to make it easier to
Paul Eggert <eggert@cs.ucla.edu>
parents:
4804
diff
changeset
|
234 #define obstack_specify_allocation(h, size, alignment, chunkfun, freefun) \ |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
235 _obstack_begin ((h), (size), (alignment), \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
236 (void *(*) (long)) (chunkfun), \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
237 (void (*) (void *)) (freefun)) |
779 | 238 |
4805
8f430f14ff21
Merge changes from glibc obstack; minor cleanups to make it easier to
Paul Eggert <eggert@cs.ucla.edu>
parents:
4804
diff
changeset
|
239 #define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \ |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
240 _obstack_begin_1 ((h), (size), (alignment), \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
241 (void *(*) (void *, long)) (chunkfun), \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
242 (void (*) (void *, void *)) (freefun), (arg)) |
779 | 243 |
4805
8f430f14ff21
Merge changes from glibc obstack; minor cleanups to make it easier to
Paul Eggert <eggert@cs.ucla.edu>
parents:
4804
diff
changeset
|
244 #define obstack_chunkfun(h, newchunkfun) \ |
995 | 245 ((h) -> chunkfun = (struct _obstack_chunk *(*)(void *, long)) (newchunkfun)) |
779 | 246 |
4805
8f430f14ff21
Merge changes from glibc obstack; minor cleanups to make it easier to
Paul Eggert <eggert@cs.ucla.edu>
parents:
4804
diff
changeset
|
247 #define obstack_freefun(h, newfreefun) \ |
995 | 248 ((h) -> freefun = (void (*)(void *, struct _obstack_chunk *)) (newfreefun)) |
779 | 249 |
4804
d0a345595720
Don't use lvalue casts, as GCC plans to remove support for them in GCC 3.5.
Paul Eggert <eggert@cs.ucla.edu>
parents:
4667
diff
changeset
|
250 #define obstack_1grow_fast(h,achar) (*((h)->next_free)++ = (achar)) |
334 | 251 |
252 #define obstack_blank_fast(h,n) ((h)->next_free += (n)) | |
881 | 253 |
254 #define obstack_memory_used(h) _obstack_memory_used (h) | |
334 | 255 |
16311
ca5972990d4f
obstack: remove __STDC__ conditionals
Paul Eggert <eggert@cs.ucla.edu>
parents:
16235
diff
changeset
|
256 #if defined __GNUC__ |
350 | 257 /* NextStep 2.0 cc is really gcc 1.93 but it defines __GNUC__ = 2 and |
258 does not implement __extension__. But that compiler doesn't define | |
259 __GNUC_MINOR__. */ | |
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
260 # if __GNUC__ < 2 || (__NeXT__ && !__GNUC_MINOR__) |
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
261 # define __extension__ |
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
262 # endif |
334 | 263 |
264 /* For GNU C, if not -traditional, | |
265 we can define these macros to compute all args only once | |
266 without using a global variable. | |
16235
18a38c9615f0
In commentary, do not use ` to quote.
Paul Eggert <eggert@cs.ucla.edu>
parents:
16201
diff
changeset
|
267 Also, we can avoid using the 'temp' slot, to make faster code. */ |
334 | 268 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
269 # define obstack_object_size(OBSTACK) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
270 __extension__ \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
271 ({ struct obstack const *__o = (OBSTACK); \ |
334 | 272 (unsigned) (__o->next_free - __o->object_base); }) |
273 | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
274 # define obstack_room(OBSTACK) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
275 __extension__ \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
276 ({ struct obstack const *__o = (OBSTACK); \ |
334 | 277 (unsigned) (__o->chunk_limit - __o->next_free); }) |
278 | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
279 # define obstack_make_room(OBSTACK,length) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
280 __extension__ \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
281 ({ struct obstack *__o = (OBSTACK); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
282 int __len = (length); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
283 if (__o->chunk_limit - __o->next_free < __len) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
284 _obstack_newchunk (__o, __len); \ |
881 | 285 (void) 0; }) |
286 | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
287 # define obstack_empty_p(OBSTACK) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
288 __extension__ \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
289 ({ struct obstack const *__o = (OBSTACK); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
290 (__o->chunk->prev == 0 \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
291 && __o->next_free == __PTR_ALIGN ((char *) __o->chunk, \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
292 __o->chunk->contents, \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
293 __o->alignment_mask)); }) |
1112 | 294 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
295 # define obstack_grow(OBSTACK,where,length) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
296 __extension__ \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
297 ({ struct obstack *__o = (OBSTACK); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
298 int __len = (length); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
299 if (__o->next_free + __len > __o->chunk_limit) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
300 _obstack_newchunk (__o, __len); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
301 memcpy (__o->next_free, where, __len); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
302 __o->next_free += __len; \ |
334 | 303 (void) 0; }) |
304 | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
305 # define obstack_grow0(OBSTACK,where,length) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
306 __extension__ \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
307 ({ struct obstack *__o = (OBSTACK); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
308 int __len = (length); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
309 if (__o->next_free + __len + 1 > __o->chunk_limit) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
310 _obstack_newchunk (__o, __len + 1); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
311 memcpy (__o->next_free, where, __len); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
312 __o->next_free += __len; \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
313 *(__o->next_free)++ = 0; \ |
334 | 314 (void) 0; }) |
315 | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
316 # define obstack_1grow(OBSTACK,datum) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
317 __extension__ \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
318 ({ struct obstack *__o = (OBSTACK); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
319 if (__o->next_free + 1 > __o->chunk_limit) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
320 _obstack_newchunk (__o, 1); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
321 obstack_1grow_fast (__o, datum); \ |
334 | 322 (void) 0; }) |
323 | |
2990 | 324 /* These assume that the obstack alignment is good enough for pointers |
325 or ints, and that the data added so far to the current object | |
334 | 326 shares that much alignment. */ |
479 | 327 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
328 # define obstack_ptr_grow(OBSTACK,datum) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
329 __extension__ \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
330 ({ struct obstack *__o = (OBSTACK); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
331 if (__o->next_free + sizeof (void *) > __o->chunk_limit) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
332 _obstack_newchunk (__o, sizeof (void *)); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
333 obstack_ptr_grow_fast (__o, datum); }) \ |
334 | 334 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
335 # define obstack_int_grow(OBSTACK,datum) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
336 __extension__ \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
337 ({ struct obstack *__o = (OBSTACK); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
338 if (__o->next_free + sizeof (int) > __o->chunk_limit) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
339 _obstack_newchunk (__o, sizeof (int)); \ |
4804
d0a345595720
Don't use lvalue casts, as GCC plans to remove support for them in GCC 3.5.
Paul Eggert <eggert@cs.ucla.edu>
parents:
4667
diff
changeset
|
340 obstack_int_grow_fast (__o, datum); }) |
d0a345595720
Don't use lvalue casts, as GCC plans to remove support for them in GCC 3.5.
Paul Eggert <eggert@cs.ucla.edu>
parents:
4667
diff
changeset
|
341 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
342 # define obstack_ptr_grow_fast(OBSTACK,aptr) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
343 __extension__ \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
344 ({ struct obstack *__o1 = (OBSTACK); \ |
17406
253d6bbd7aa4
obstack: port --enable-gcc-warnings to clang
Paul Eggert <eggert@cs.ucla.edu>
parents:
17249
diff
changeset
|
345 void *__p1 = __o1->next_free; \ |
253d6bbd7aa4
obstack: port --enable-gcc-warnings to clang
Paul Eggert <eggert@cs.ucla.edu>
parents:
17249
diff
changeset
|
346 *(const void **) __p1 = (aptr); \ |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
347 __o1->next_free += sizeof (const void *); \ |
334 | 348 (void) 0; }) |
349 | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
350 # define obstack_int_grow_fast(OBSTACK,aint) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
351 __extension__ \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
352 ({ struct obstack *__o1 = (OBSTACK); \ |
17406
253d6bbd7aa4
obstack: port --enable-gcc-warnings to clang
Paul Eggert <eggert@cs.ucla.edu>
parents:
17249
diff
changeset
|
353 void *__p1 = __o1->next_free; \ |
253d6bbd7aa4
obstack: port --enable-gcc-warnings to clang
Paul Eggert <eggert@cs.ucla.edu>
parents:
17249
diff
changeset
|
354 *(int *) __p1 = (aint); \ |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
355 __o1->next_free += sizeof (int); \ |
4804
d0a345595720
Don't use lvalue casts, as GCC plans to remove support for them in GCC 3.5.
Paul Eggert <eggert@cs.ucla.edu>
parents:
4667
diff
changeset
|
356 (void) 0; }) |
334 | 357 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
358 # define obstack_blank(OBSTACK,length) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
359 __extension__ \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
360 ({ struct obstack *__o = (OBSTACK); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
361 int __len = (length); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
362 if (__o->chunk_limit - __o->next_free < __len) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
363 _obstack_newchunk (__o, __len); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
364 obstack_blank_fast (__o, __len); \ |
334 | 365 (void) 0; }) |
366 | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
367 # define obstack_alloc(OBSTACK,length) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
368 __extension__ \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
369 ({ struct obstack *__h = (OBSTACK); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
370 obstack_blank (__h, (length)); \ |
334 | 371 obstack_finish (__h); }) |
372 | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
373 # define obstack_copy(OBSTACK,where,length) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
374 __extension__ \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
375 ({ struct obstack *__h = (OBSTACK); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
376 obstack_grow (__h, (where), (length)); \ |
334 | 377 obstack_finish (__h); }) |
378 | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
379 # define obstack_copy0(OBSTACK,where,length) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
380 __extension__ \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
381 ({ struct obstack *__h = (OBSTACK); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
382 obstack_grow0 (__h, (where), (length)); \ |
334 | 383 obstack_finish (__h); }) |
384 | |
385 /* The local variable is named __o1 to avoid a name conflict | |
386 when obstack_blank is called. */ | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
387 # define obstack_finish(OBSTACK) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
388 __extension__ \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
389 ({ struct obstack *__o1 = (OBSTACK); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
390 void *__value = (void *) __o1->object_base; \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
391 if (__o1->next_free == __value) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
392 __o1->maybe_empty_object = 1; \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
393 __o1->next_free \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
394 = __PTR_ALIGN (__o1->object_base, __o1->next_free, \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
395 __o1->alignment_mask); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
396 if (__o1->next_free - (char *)__o1->chunk \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
397 > __o1->chunk_limit - (char *)__o1->chunk) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
398 __o1->next_free = __o1->chunk_limit; \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
399 __o1->object_base = __o1->next_free; \ |
5057
f4b3a4229349
Import obstack changes from libc.
Paul Eggert <eggert@cs.ucla.edu>
parents:
4805
diff
changeset
|
400 __value; }) |
334 | 401 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
402 # define obstack_free(OBSTACK, OBJ) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
403 __extension__ \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
404 ({ struct obstack *__o = (OBSTACK); \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
405 void *__obj = (OBJ); \ |
334 | 406 if (__obj > (void *)__o->chunk && __obj < (void *)__o->chunk_limit) \ |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
407 __o->next_free = __o->object_base = (char *)__obj; \ |
7550
0d3d27f21643
Make it possible to rename obstack_free.
Bruno Haible <bruno@clisp.org>
parents:
6376
diff
changeset
|
408 else (__obstack_free) (__o, __obj); }) |
334 | 409 |
16311
ca5972990d4f
obstack: remove __STDC__ conditionals
Paul Eggert <eggert@cs.ucla.edu>
parents:
16235
diff
changeset
|
410 #else /* not __GNUC__ */ |
334 | 411 |
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
412 # define obstack_object_size(h) \ |
881 | 413 (unsigned) ((h)->next_free - (h)->object_base) |
334 | 414 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
415 # define obstack_room(h) \ |
334 | 416 (unsigned) ((h)->chunk_limit - (h)->next_free) |
417 | |
2477
27aa55bf95b7
update from glibc -- solely white space changes
Jim Meyering <jim@meyering.net>
parents:
1112
diff
changeset
|
418 # define obstack_empty_p(h) \ |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
419 ((h)->chunk->prev == 0 \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
420 && (h)->next_free == __PTR_ALIGN ((char *) (h)->chunk, \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
421 (h)->chunk->contents, \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
422 (h)->alignment_mask)) |
1112 | 423 |
334 | 424 /* Note that the call to _obstack_newchunk is enclosed in (..., 0) |
425 so that we can avoid having void expressions | |
426 in the arms of the conditional expression. | |
427 Casting the third operand to void was tried before, | |
428 but some compilers won't accept it. */ | |
429 | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
430 # define obstack_make_room(h,length) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
431 ( (h)->temp.tempint = (length), \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
432 (((h)->next_free + (h)->temp.tempint > (h)->chunk_limit) \ |
5065
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
433 ? (_obstack_newchunk ((h), (h)->temp.tempint), 0) : 0)) |
881 | 434 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
435 # define obstack_grow(h,where,length) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
436 ( (h)->temp.tempint = (length), \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
437 (((h)->next_free + (h)->temp.tempint > (h)->chunk_limit) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
438 ? (_obstack_newchunk ((h), (h)->temp.tempint), 0) : 0), \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
439 memcpy ((h)->next_free, where, (h)->temp.tempint), \ |
5065
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
440 (h)->next_free += (h)->temp.tempint) |
334 | 441 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
442 # define obstack_grow0(h,where,length) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
443 ( (h)->temp.tempint = (length), \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
444 (((h)->next_free + (h)->temp.tempint + 1 > (h)->chunk_limit) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
445 ? (_obstack_newchunk ((h), (h)->temp.tempint + 1), 0) : 0), \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
446 memcpy ((h)->next_free, where, (h)->temp.tempint), \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
447 (h)->next_free += (h)->temp.tempint, \ |
881 | 448 *((h)->next_free)++ = 0) |
334 | 449 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
450 # define obstack_1grow(h,datum) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
451 ( (((h)->next_free + 1 > (h)->chunk_limit) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
452 ? (_obstack_newchunk ((h), 1), 0) : 0), \ |
4804
d0a345595720
Don't use lvalue casts, as GCC plans to remove support for them in GCC 3.5.
Paul Eggert <eggert@cs.ucla.edu>
parents:
4667
diff
changeset
|
453 obstack_1grow_fast (h, datum)) |
334 | 454 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
455 # define obstack_ptr_grow(h,datum) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
456 ( (((h)->next_free + sizeof (char *) > (h)->chunk_limit) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
457 ? (_obstack_newchunk ((h), sizeof (char *)), 0) : 0), \ |
4804
d0a345595720
Don't use lvalue casts, as GCC plans to remove support for them in GCC 3.5.
Paul Eggert <eggert@cs.ucla.edu>
parents:
4667
diff
changeset
|
458 obstack_ptr_grow_fast (h, datum)) |
334 | 459 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
460 # define obstack_int_grow(h,datum) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
461 ( (((h)->next_free + sizeof (int) > (h)->chunk_limit) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
462 ? (_obstack_newchunk ((h), sizeof (int)), 0) : 0), \ |
4804
d0a345595720
Don't use lvalue casts, as GCC plans to remove support for them in GCC 3.5.
Paul Eggert <eggert@cs.ucla.edu>
parents:
4667
diff
changeset
|
463 obstack_int_grow_fast (h, datum)) |
334 | 464 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
465 # define obstack_ptr_grow_fast(h,aptr) \ |
4804
d0a345595720
Don't use lvalue casts, as GCC plans to remove support for them in GCC 3.5.
Paul Eggert <eggert@cs.ucla.edu>
parents:
4667
diff
changeset
|
466 (((const void **) ((h)->next_free += sizeof (void *)))[-1] = (aptr)) |
2990 | 467 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
468 # define obstack_int_grow_fast(h,aint) \ |
6376
56829cd68e67
* config/srclist.txt: Add glibc bug 321 for obstack.c, obstack.h.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5848
diff
changeset
|
469 (((int *) ((h)->next_free += sizeof (int)))[-1] = (aint)) |
334 | 470 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
471 # define obstack_blank(h,length) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
472 ( (h)->temp.tempint = (length), \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
473 (((h)->chunk_limit - (h)->next_free < (h)->temp.tempint) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
474 ? (_obstack_newchunk ((h), (h)->temp.tempint), 0) : 0), \ |
5065
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
475 obstack_blank_fast (h, (h)->temp.tempint)) |
334 | 476 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
477 # define obstack_alloc(h,length) \ |
334 | 478 (obstack_blank ((h), (length)), obstack_finish ((h))) |
479 | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
480 # define obstack_copy(h,where,length) \ |
334 | 481 (obstack_grow ((h), (where), (length)), obstack_finish ((h))) |
482 | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
483 # define obstack_copy0(h,where,length) \ |
334 | 484 (obstack_grow0 ((h), (where), (length)), obstack_finish ((h))) |
485 | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
486 # define obstack_finish(h) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
487 ( ((h)->next_free == (h)->object_base \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
488 ? (((h)->maybe_empty_object = 1), 0) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
489 : 0), \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
490 (h)->temp.tempptr = (h)->object_base, \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
491 (h)->next_free \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
492 = __PTR_ALIGN ((h)->object_base, (h)->next_free, \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
493 (h)->alignment_mask), \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
494 (((h)->next_free - (char *) (h)->chunk \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
495 > (h)->chunk_limit - (char *) (h)->chunk) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
496 ? ((h)->next_free = (h)->chunk_limit) : 0), \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
497 (h)->object_base = (h)->next_free, \ |
5065
4ce8ff7e5f06
Port obstack to the AS/400.
Paul Eggert <eggert@cs.ucla.edu>
parents:
5057
diff
changeset
|
498 (h)->temp.tempptr) |
334 | 499 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
500 # define obstack_free(h,obj) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
501 ( (h)->temp.tempint = (char *) (obj) - (char *) (h)->chunk, \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
502 ((((h)->temp.tempint > 0 \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
503 && (h)->temp.tempint < (h)->chunk_limit - (char *) (h)->chunk)) \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
504 ? (int) ((h)->next_free = (h)->object_base \ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
505 = (h)->temp.tempint + (char *) (h)->chunk) \ |
7550
0d3d27f21643
Make it possible to rename obstack_free.
Bruno Haible <bruno@clisp.org>
parents:
6376
diff
changeset
|
506 : (((__obstack_free) ((h), (h)->temp.tempint + (char *) (h)->chunk), 0), 0))) |
334 | 507 |
16311
ca5972990d4f
obstack: remove __STDC__ conditionals
Paul Eggert <eggert@cs.ucla.edu>
parents:
16235
diff
changeset
|
508 #endif /* not __GNUC__ */ |
334 | 509 |
995 | 510 #ifdef __cplusplus |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
511 } /* C++ */ |
995 | 512 #endif |
513 | |
1112 | 514 #endif /* obstack.h */ |