← Back to branch summary

~ubuntu-branches/ubuntu/lucid/dpkg/lucid

« back to all changes in this revision

Viewing changes to libcompat/obstack.h

  • Committer: Bazaar Package Importer
  • Author(s): Guillem Jover, Guillem Jover, Raphael Hertzog, Modestas Vainius, Updated dpkg translations, Updated dselect translations, Updated man page translations, Updated scripts translations
  • Date: 2009-09-06 09:37:45 UTC
  • mto: (1.4.1 squeeze)
  • mto: This revision was merged to the branch mainline in revision 68.
  • Revision ID: james.westby@ubuntu.com-20090906093745-orb3im04ozfxypis
Tags: 1.15.4
http://bugs.debian.org/472208
http://bugs.debian.org/33394
http://bugs.debian.org/429262
http://bugs.debian.org/218018
http://bugs.debian.org/373602
http://bugs.debian.org/536821
http://bugs.debian.org/455501
http://bugs.debian.org/540019
http://bugs.debian.org/9771
http://bugs.debian.org/523980
http://bugs.debian.org/535138
http://bugs.debian.org/537558
http://bugs.debian.org/535353
http://bugs.debian.org/537800
http://bugs.debian.org/537559
http://bugs.debian.org/540382
http://bugs.debian.org/541412
http://bugs.debian.org/496114
http://bugs.debian.org/531307
http://bugs.debian.org/494714
http://bugs.debian.org/544037
http://bugs.debian.org/541829
http://bugs.debian.org/535327
http://bugs.debian.org/536538
http://bugs.debian.org/542254
http://bugs.debian.org/537742
http://bugs.debian.org/542254
http://bugs.debian.org/537741
http://bugs.debian.org/542254
[ Guillem Jover ]
* Call _g instead of g_ in dpkg-name.
* Fix inverted logic when deciding to assume the architecture in dpkg-name
  when the package didn't have such field.
* Do not take into account Revision and Package_Revision fields in dpkg-name
  and dpkg-scanpackages as they have been handled already by “dpkg-deb -I”.
* Switch dpkg-scansources to use Dpkg::Cdata instead of duplicating the
  .dsc parsing code. As a side effect it now handles properly bogus files.
* Do not remap obsolete fields in dpkg-scanpackages as they have been
  handled already by “dpkg-deb -I”.
* Properly mark packages being purged for disappearance from the database.
  This will make the status database not be left behind with traces of old
  not-installed packages. Closes: #472208
* On parse mark not-installed leftover packages for automatic removal from
  the database on next dump. This obsoletes the --forget-old-unavail option,
  thus making it now a no-op. Closes: #33394, #429262
* Document “hold” under package selection states instead of flags in dpkg(1).
* Remove trailing ‘/’ and ‘/.’ from the directory name to be used as the
  package name on “dpkg-deb -b”. Closes: #218018, #373602
* Remove obsolete ‘hold’ and ‘hold-reinstreq’ internal status flags.
* Add fakeroot to dpkg-dev Recommends. Closes: #536821
* Fix an always false test when trying to decide which package to deselect
  to resolve a dependency problem in dselect.
* Add uClibc Linux support to ostable and triplettable. Closes: #455501
* Add uClinux support to ostable and triplettable.
  Thanks to Simon Richter <sjr@debian.org>.
* When aborting due to file conflicts print the version of the conflicted
  package. Closes: #540019
* Remove double slash in database path visible to the user in some error
  conditions.
* Stop macthing sparc64-*-* GNU triplets with sparc Debian architecture.
* Add support for config.d style directories in dpkg and dselect,
  (/etc/dpkg/dpkg.cfg.d and /etc/dpkg/dselect.cfg.d respectively).
* Define DPKG_MAINTSCRIPT_ARCH on the maintainer script environment to the
  architecture the package got built for.
* Document DPKG_MAINTSCRIPT_PACKAGE maintainer script environment variable
  in dpkg man page.
* Document DPKG_RUNNING_VERSION maintainer script environment variable
  in dpkg man page.
* Change po4a usage to not create unwated changes depending if doing out or
  in-tree builds.
* Use po4a “--previous” support when updating the man pages.
  Suggested by Christian Perrier <bubulle@debian.org>.
* On configuration error print file name and line number.
* Allow quoting values in configuration file options.
* Add new --pre-invoke and --post-invoke hooks in dpkg.
* Add new --control-path command to dpkg-query.
* Use ohshit on bad version syntax in --compare-versions.
* Add Multi-Arch to the list of known binary package fields for dpkg-dev.
  Thanks to Steve Langasek <vorlon@debian.org>.

[ Raphael Hertzog ]
* Replace install-info by a wrapper around GNU's install-info. The wrapper
  will be dropped in squeeze+1. dpkg now Breaks: old versions of
  info-browsers that do not depend on the new install-info package
  that provides the real functionality. Closes: #9771, #523980
  See http://wiki.debian.org/Transitions/DpkgToGnuInstallInfo for details.
* Fix dpkg's preinst in case /var/lib/dpkg/alternatives contains unexpected
  sub-directories. Closes: #535138
  And also when one of the file doesn't contain correct alternatives
  information (improper number of lines). Closes: #537558
* Upgrade Standards-Version to 3.8.2 (no changes).
* Update deb-substvars(5) to list fields that do not support substvars.
  Closes: #535353
* Fix dpkg-parsechangelog to include all entries with -v0 parameter.
  Closes: #537800
* Fix update-alternatives to mention the correct slave link that can't
  be installed due to a conflicting file instead of quoting the master link.
* Add support for extra override file in dpkg-scanpackages. Thanks to Robert
  Millan for the patch. Closes: #537559
* Add support for extra override file in dpkg-scansources.
* Document format of extra override file in a new manual page
  deb-extra-override(5).
* Update sample in dpkg-gensymbols(1) to give an accurate listing of
  64 bit arches. Thanks to Julien Cristau for the patch. Closes: #540382
* Create /etc/cron.daily/dpkg to handle the backup of
  /var/lib/dpkg/status in /var/backups. This is taken out of the cron
  package and need no conflicts/breaks as the code does nothing if
  the current status file is already backupped. Thanks to Leo 'costela'
  Antunes <costela@debian.org> for the patch. Closes: #541412
* Change behaviour of dpkg --merge-avail to not update a package's
  information if the version provided is older than the one already listed
  in the available file. Thanks to Ian Jackson
  <ian@davenant.greenend.org.uk> for the patch. Closes: #496114
* dpkg-architecture can now export DEB_{HOST,BUILD}_ARCH_{BITS,ENDIAN}
  (pointer size and endianness):
  - cputable (in dpkg) modified to contain those information
  - dpkg-dev depends on dpkg (>= 1.15.4) to ensure that we have an updated
    cputable (and so that a versioned build-dependency on dpkg-dev is enough
    to use this new feature)
  Closes: #531307
* Split overly long Binary: field values over multiple lines. This is
  allowed since policy 3.8.3. Closes: #494714
* Improve performance of dpkg-shlibdeps by caching minimal version
  associated to each library in Dpkg::Shlib::SymbolFile. Thanks to
  Jiří Paleček <jpalecek@web.de> for the patch.
* Slightly improve dpkg-source(1) by giving the section name that we're
  referring to. Closes: #544037
* Fix translation error in german manpage of dpkg-buildpackage. Thanks
  to Joachim Breitner <nomeata@debian.org>. Closes: #541829

[ Modestas Vainius ]
* Provide a meaningful label for dpkg-gensymbols diff.

[ Updated dpkg translations ]
* Asturian (Marcos Alvarez Costales). Closes: #535327
* French (Christian Perrier).
* German (Sven Joachim).
* Italian (Milo Casagrande). Closes: #536538
* Russian (Yuri Kozlov). Closes: #542254
* Slovak (Ivan Masár). Closes: #537742
* Swedish (Peter Krefting).

[ Updated dselect translations ]
* Russian (Yuri Kozlov). Closes: #542254
* Slovak (Ivan Masár). Closes: #537741

[ Updated man page translations ]
* French (Christian Perrier).
* German (Helge Kreutzmann), proofread by Jens Seidel.
* Swedish (Peter Krefting).

[ Updated scripts translations ]
* French completed (Christian Perrier).
* German (Helge Kreutzmann).
* Russian (Yuri Kozlov). Closes: #542254
* Swedish (Peter Krefting).

Show diffs side-by-side

added added

removed removed

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