Subversion Repositories Kolibri OS

Rev

Rev 5191 | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

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