diff options
| -rw-r--r-- | ChangeLog | 19 | ||||
| -rw-r--r-- | malloc/obstack.c | 135 | ||||
| -rw-r--r-- | malloc/obstack.h | 156 |
3 files changed, 162 insertions, 148 deletions
@@ -1,4 +1,23 @@ 2014-07-02 Will Newton <will.newton@linaro.org> + + * malloc/obstack.c: Merge from gnulib master. + [HAVE_CONFIG_H]: Remove conditional code. + [!_LIBC]: Include config.h. + [!ELIDE_CODE]: Don't include inttypes.h, include + stdint.h unconditionally. + (print_and_abort): Mark as _Noreturn. + (_obstack_allocated_p): Mark as __attribute_pure__. + (obstack_free): Rename to __obstack_free. + [!__attribute__]: Remove conditional code. + * malloc/obstack.h: Merge from gnulib master. + [__cplusplus]: Move conditional down. + [!__attribute_pure__]: Define __attribute_pure__ here + if it is not already defined. + (_obstack_memory_used): Mark as __attribute_pure__. + [!__obstack_free]: Define as obstack_free. + [__GNUC__]: Remove check for ancient NeXT gcc. + +2014-07-02 Will Newton <will.newton@linaro.org> Paul Eggert <eggert@cs.ucla.edu> * misc/sys/cdefs.h (_Noreturn): New macro, for pre-C11 compilers. diff --git a/malloc/obstack.c b/malloc/obstack.c index 4064f61950..fa4fefc149 100644 --- a/malloc/obstack.c +++ b/malloc/obstack.c @@ -17,14 +17,11 @@ <http://www.gnu.org/licenses/>. */ -#ifdef HAVE_CONFIG_H -# include <config.h> -#endif - #ifdef _LIBC # include <obstack.h> # include <shlib-compat.h> #else +# include <config.h> # include "obstack.h" #endif @@ -39,7 +36,7 @@ C Library, but also included in many other GNU distributions. Compiling and linking in this code is a waste when using the GNU C library (especially if it is a shared library). Rather than having every GNU - program understand `configure --with-gnu-libc' and omit the object + program understand 'configure --with-gnu-libc' and omit the object files, it is simpler to just do this in the source for each such file. */ #include <stdio.h> /* Random thing to get __GNU_LIBRARY__. */ @@ -55,12 +52,7 @@ #ifndef ELIDE_CODE -# if HAVE_INTTYPES_H -# include <inttypes.h> -# endif -# if HAVE_STDINT_H || defined _LIBC -# include <stdint.h> -# endif +# include <stdint.h> /* Determine default alignment. */ union fooround @@ -85,23 +77,23 @@ enum /* When we copy a long block of data, this is the unit to do it with. On some machines, copying successive ints does not work; - in such a case, redefine COPYING_UNIT to `long' (if that works) - or `char' as a last resort. */ + in such a case, redefine COPYING_UNIT to 'long' (if that works) + or 'char' as a last resort. */ # ifndef COPYING_UNIT # define COPYING_UNIT int # endif -/* The functions allocating more room by calling `obstack_chunk_alloc' - jump to the handler pointed to by `obstack_alloc_failed_handler'. +/* The functions allocating more room by calling 'obstack_chunk_alloc' + jump to the handler pointed to by 'obstack_alloc_failed_handler'. This can be set to a user defined function which should either abort gracefully or use longjump - but shouldn't return. This variable by default points to the internal function - `print_and_abort'. */ -static void print_and_abort (void); + 'print_and_abort'. */ +static _Noreturn void print_and_abort (void); void (*obstack_alloc_failed_handler) (void) = print_and_abort; -/* Exit value used when `print_and_abort' is used. */ +/* Exit value used when 'print_and_abort' is used. */ # include <stdlib.h> # ifdef _LIBC int obstack_exit_failure = EXIT_FAILURE; @@ -134,9 +126,9 @@ compat_symbol (libc, _obstack_compat, _obstack, GLIBC_2_0); # define CALL_FREEFUN(h, old_chunk) \ do { \ if ((h)->use_extra_arg) \ - (*(h)->freefun)((h)->extra_arg, (old_chunk)); \ + (*(h)->freefun)((h)->extra_arg, (old_chunk)); \ else \ - (*(void (*)(void *))(h)->freefun)((old_chunk)); \ + (*(void (*)(void *))(h)->freefun)((old_chunk)); \ } while (0) @@ -150,44 +142,44 @@ compat_symbol (libc, _obstack_compat, _obstack, GLIBC_2_0); int _obstack_begin (struct obstack *h, - int size, int alignment, - void *(*chunkfun)(long), - void (*freefun)(void *)) + int size, int alignment, + void *(*chunkfun) (long), + void (*freefun) (void *)) { struct _obstack_chunk *chunk; /* points to new chunk */ if (alignment == 0) alignment = DEFAULT_ALIGNMENT; if (size == 0) - /* Default size is what GNU malloc can fit in a 4096-byte block. */ + /* Default size is what GNU malloc can fit in a 4096-byte block. */ { /* 12 is sizeof (mhead) and 4 is EXTRA from GNU malloc. - Use the values for range checking, because if range checking is off, - the extra bytes won't be missed terribly, but if range checking is on - and we used a larger request, a whole extra 4096 bytes would be - allocated. + Use the values for range checking, because if range checking is off, + the extra bytes won't be missed terribly, but if range checking is on + and we used a larger request, a whole extra 4096 bytes would be + allocated. - These number are irrelevant to the new GNU malloc. I suspect it is - less sensitive to the size of the request. */ + These number are irrelevant to the new GNU malloc. I suspect it is + less sensitive to the size of the request. */ int extra = ((((12 + DEFAULT_ROUNDING - 1) & ~(DEFAULT_ROUNDING - 1)) - + 4 + DEFAULT_ROUNDING - 1) - & ~(DEFAULT_ROUNDING - 1)); + + 4 + DEFAULT_ROUNDING - 1) + & ~(DEFAULT_ROUNDING - 1)); size = 4096 - extra; } - h->chunkfun = (struct _obstack_chunk * (*)(void *, long))chunkfun; - h->freefun = (void (*)(void *, struct _obstack_chunk *))freefun; + h->chunkfun = (struct _obstack_chunk * (*) (void *, long)) chunkfun; + h->freefun = (void (*) (void *, struct _obstack_chunk *)) freefun; h->chunk_size = size; h->alignment_mask = alignment - 1; h->use_extra_arg = 0; chunk = h->chunk = CALL_CHUNKFUN (h, h->chunk_size); if (!chunk) - (*obstack_alloc_failed_handler)(); + (*obstack_alloc_failed_handler) (); h->next_free = h->object_base = __PTR_ALIGN ((char *) chunk, chunk->contents, - alignment - 1); + alignment - 1); h->chunk_limit = chunk->limit - = (char *) chunk + h->chunk_size; + = (char *) chunk + h->chunk_size; chunk->prev = 0; /* The initial chunk now contains no empty object. */ h->maybe_empty_object = 0; @@ -197,33 +189,33 @@ _obstack_begin (struct obstack *h, int _obstack_begin_1 (struct obstack *h, int size, int alignment, - void *(*chunkfun)(void *, long), - void (*freefun)(void *, void *), - void *arg) + void *(*chunkfun) (void *, long), + void (*freefun) (void *, void *), + void *arg) { struct _obstack_chunk *chunk; /* points to new chunk */ if (alignment == 0) alignment = DEFAULT_ALIGNMENT; if (size == 0) - /* Default size is what GNU malloc can fit in a 4096-byte block. */ + /* Default size is what GNU malloc can fit in a 4096-byte block. */ { /* 12 is sizeof (mhead) and 4 is EXTRA from GNU malloc. - Use the values for range checking, because if range checking is off, - the extra bytes won't be missed terribly, but if range checking is on - and we used a larger request, a whole extra 4096 bytes would be - allocated. + Use the values for range checking, because if range checking is off, + the extra bytes won't be missed terribly, but if range checking is on + and we used a larger request, a whole extra 4096 bytes would be + allocated. - These number are irrelevant to the new GNU malloc. I suspect it is - less sensitive to the size of the request. */ + These number are irrelevant to the new GNU malloc. I suspect it is + less sensitive to the size of the request. */ int extra = ((((12 + DEFAULT_ROUNDING - 1) & ~(DEFAULT_ROUNDING - 1)) - + 4 + DEFAULT_ROUNDING - 1) - & ~(DEFAULT_ROUNDING - 1)); + + 4 + DEFAULT_ROUNDING - 1) + & ~(DEFAULT_ROUNDING - 1)); size = 4096 - extra; } - h->chunkfun = (struct _obstack_chunk * (*)(void *, long))chunkfun; - h->freefun = (void (*)(void *, struct _obstack_chunk *))freefun; + h->chunkfun = (struct _obstack_chunk * (*)(void *,long)) chunkfun; + h->freefun = (void (*) (void *, struct _obstack_chunk *)) freefun; h->chunk_size = size; h->alignment_mask = alignment - 1; h->extra_arg = arg; @@ -231,11 +223,11 @@ _obstack_begin_1 (struct obstack *h, int size, int alignment, chunk = h->chunk = CALL_CHUNKFUN (h, h->chunk_size); if (!chunk) - (*obstack_alloc_failed_handler)(); + (*obstack_alloc_failed_handler) (); h->next_free = h->object_base = __PTR_ALIGN ((char *) chunk, chunk->contents, - alignment - 1); + alignment - 1); h->chunk_limit = chunk->limit - = (char *) chunk + h->chunk_size; + = (char *) chunk + h->chunk_size; chunk->prev = 0; /* The initial chunk now contains no empty object. */ h->maybe_empty_object = 0; @@ -283,12 +275,12 @@ _obstack_newchunk (struct obstack *h, int length) if (h->alignment_mask + 1 >= DEFAULT_ALIGNMENT) { for (i = obj_size / sizeof (COPYING_UNIT) - 1; - i >= 0; i--) - ((COPYING_UNIT *) object_base)[i] - = ((COPYING_UNIT *) h->object_base)[i]; + i >= 0; i--) + ((COPYING_UNIT *) object_base)[i] + = ((COPYING_UNIT *) h->object_base)[i]; /* We used to copy the odd few remaining bytes as one extra COPYING_UNIT, - but that can cross a page boundary on a machine - which does not do strict alignment for COPYING_UNITS. */ + but that can cross a page boundary on a machine + which does not do strict alignment for COPYING_UNITS. */ already = obj_size / sizeof (COPYING_UNIT) * sizeof (COPYING_UNIT); } else @@ -302,8 +294,8 @@ _obstack_newchunk (struct obstack *h, int length) But not if that chunk might contain an empty object. */ if (!h->maybe_empty_object && (h->object_base - == __PTR_ALIGN ((char *) old_chunk, old_chunk->contents, - h->alignment_mask))) + == __PTR_ALIGN ((char *) old_chunk, old_chunk->contents, + h->alignment_mask))) { new_chunk->prev = old_chunk->prev; CALL_FREEFUN (h, old_chunk); @@ -324,7 +316,7 @@ libc_hidden_def (_obstack_newchunk) /* Suppress -Wmissing-prototypes warning. We don't want to declare this in obstack.h because it is just for debugging. */ -int _obstack_allocated_p (struct obstack *h, void *obj); +int _obstack_allocated_p (struct obstack *h, void *obj) __attribute_pure__; int _obstack_allocated_p (struct obstack *h, void *obj) @@ -350,7 +342,7 @@ _obstack_allocated_p (struct obstack *h, void *obj) # undef obstack_free void -obstack_free (struct obstack *h, void *obj) +__obstack_free (struct obstack *h, void *obj) { struct _obstack_chunk *lp; /* below addr of any objects in this chunk */ struct _obstack_chunk *plp; /* point to previous chunk if any */ @@ -365,7 +357,7 @@ obstack_free (struct obstack *h, void *obj) CALL_FREEFUN (h, lp); lp = plp; /* If we switch chunks, we can't tell whether the new current - chunk contains an empty object, so assume that it may. */ + chunk contains an empty object, so assume that it may. */ h->maybe_empty_object = 1; } if (lp) @@ -412,15 +404,7 @@ _obstack_memory_used (struct obstack *h) # include <libio/iolibio.h> # endif -# ifndef __attribute__ -/* This feature is available in gcc versions 2.5 and later. */ -# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) -# define __attribute__(Spec) /* empty */ -# endif -# endif - -static void -__attribute__ ((noreturn)) +static _Noreturn void print_and_abort (void) { /* Don't change any of these strings. Yes, it would be possible to add @@ -429,10 +413,11 @@ print_and_abort (void) like this and the translation should be reused instead of creating a very similar string which requires a separate translation. */ # ifdef _LIBC - (void) __fxprintf (NULL, "%s\n", _ ("memory exhausted")); + (void) __fxprintf (NULL, "%s\n", _("memory exhausted")); # else - fprintf (stderr, "%s\n", _ ("memory exhausted")); + fprintf (stderr, "%s\n", _("memory exhausted")); # endif exit (obstack_exit_failure); } + #endif /* !ELIDE_CODE */ diff --git a/malloc/obstack.h b/malloc/obstack.h index 85472f99a2..59ae6e568f 100644 --- a/malloc/obstack.h +++ b/malloc/obstack.h @@ -32,11 +32,11 @@ stack is of mature, fixed size and fixed address objects. These routines grab large chunks of memory, using a function you - supply, called `obstack_chunk_alloc'. On occasion, they free chunks, - by calling `obstack_chunk_free'. You must define them and declare + supply, called 'obstack_chunk_alloc'. On occasion, they free chunks, + by calling 'obstack_chunk_free'. You must define them and declare them before using any obstack macros. - Each independent stack is represented by a `struct obstack'. + Each independent stack is represented by a 'struct obstack'. Each of the obstack macros expects a pointer to such a structure as the first argument. @@ -85,17 +85,17 @@ break the ordinary 'growth' macro. Summary: - We allocate large chunks. - We carve out one object at a time from the current chunk. - Once carved, an object never moves. - We are free to append data of any size to the currently - growing object. - Exactly one object is growing in an obstack at any one time. - You can run one obstack per control block. - You may have as many control blocks as you dare. - Because of the way we do it, you can `unwind' an obstack - back to a previous state. (You may remove objects much - as you would with a stack.) + We allocate large chunks. + We carve out one object at a time from the current chunk. + Once carved, an object never moves. + We are free to append data of any size to the currently + growing object. + Exactly one object is growing in an obstack at any one time. + You can run one obstack per control block. + You may have as many control blocks as you dare. + Because of the way we do it, you can "unwind" an obstack + back to a previous state. (You may remove objects much + as you would with a stack.) */ @@ -104,10 +104,6 @@ #ifndef _OBSTACK_H #define _OBSTACK_H 1 -#ifdef __cplusplus -extern "C" { -#endif - /* We need the type of a pointer subtraction. If __PTRDIFF_TYPE__ is defined, as with GNU C, use that; that way we don't pollute the namespace with <stddef.h>'s symbols. Otherwise, include <stddef.h> @@ -124,9 +120,9 @@ extern "C" { aligning P to the next multiple of A + 1. B and P must be of type char *. A + 1 must be a power of 2. */ -#define __BPTR_ALIGN(B, P, A) ((B) + (((P) -(B) + (A)) & ~(A))) +#define __BPTR_ALIGN(B, P, A) ((B) + (((P) - (B) + (A)) & ~(A))) -/* Similiar to _BPTR_ALIGN (B, P, A), except optimize the common case +/* Similar to _BPTR_ALIGN (B, P, A), except optimize the common case where pointers can be converted to integers, aligned as integers, and converted back again. If PTR_INT_TYPE is narrower than a pointer (e.g., the AS/400), play it safe and compute the alignment @@ -135,10 +131,18 @@ extern "C" { #define __PTR_ALIGN(B, P, A) \ __BPTR_ALIGN (sizeof (PTR_INT_TYPE) < sizeof (void *) ? (B) : (char *) 0, \ - P, A) + P, A) #include <string.h> +#ifndef __attribute_pure__ +# define __attribute_pure__ _GL_ATTRIBUTE_PURE +#endif + +#ifdef __cplusplus +extern "C" { +#endif + struct _obstack_chunk /* Lives at front of each chunk. */ { char *limit; /* 1 past end of this chunk */ @@ -159,7 +163,7 @@ struct obstack /* control current object in current chunk */ void *tempptr; } temp; /* Temporary for some macros. */ int alignment_mask; /* Mask of alignment for each object. */ - /* These prototypes vary based on `use_extra_arg', and we use + /* These prototypes vary based on 'use_extra_arg', and we use casts to the prototypeless function type in all assignments, but having prototypes here quiets -Wstrict-prototypes. */ struct _obstack_chunk *(*chunkfun) (void *, long); @@ -167,34 +171,39 @@ struct obstack /* control current object in current chunk */ void *extra_arg; /* first arg for chunk alloc/dealloc funcs */ unsigned use_extra_arg : 1; /* chunk alloc/dealloc funcs take extra arg */ unsigned maybe_empty_object : 1; /* There is a possibility that the current - chunk contains a zero-length object. This - prevents freeing the chunk if we allocate - a bigger chunk to replace it. */ + chunk contains a zero-length object. This + prevents freeing the chunk if we allocate + a bigger chunk to replace it. */ unsigned alloc_failed : 1; /* No longer used, as we now call the failed - handler on error, but retained for binary - compatibility. */ + handler on error, but retained for binary + compatibility. */ }; /* Declare the external functions we use; they are in obstack.c. */ extern void _obstack_newchunk (struct obstack *, int); extern int _obstack_begin (struct obstack *, int, int, - void *(*)(long), void (*)(void *)); + void *(*)(long), void (*)(void *)); extern int _obstack_begin_1 (struct obstack *, int, int, - void *(*)(void *, long), - void (*)(void *, void *), void *); -extern int _obstack_memory_used (struct obstack *); - -void obstack_free (struct obstack *__obstack, void *__glibc_block); + void *(*)(void *, long), + void (*)(void *, void *), void *); +extern int _obstack_memory_used (struct obstack *) __attribute_pure__; + +/* The default name of the function for freeing a chunk is 'obstack_free', + but gnulib users can override this by defining '__obstack_free'. */ +#ifndef __obstack_free +# define __obstack_free obstack_free +#endif +extern void __obstack_free (struct obstack *, void *); -/* Error handler called when `obstack_chunk_alloc' failed to allocate +/* Error handler called when 'obstack_chunk_alloc' failed to allocate more memory. This can be set to a user defined function which should either abort gracefully or use longjump - but shouldn't return. The default action is to print a message and abort. */ extern void (*obstack_alloc_failed_handler) (void); -/* Exit value used when `print_and_abort' is used. */ +/* Exit value used when 'print_and_abort' is used. */ extern int obstack_exit_failure; /* Pointer to beginning of object being allocated or to be allocated next. @@ -218,23 +227,23 @@ extern int obstack_exit_failure; /* To prevent prototype warnings provide complete argument list. */ #define obstack_init(h) \ _obstack_begin ((h), 0, 0, \ - (void *(*)(long))obstack_chunk_alloc, \ - (void (*)(void *))obstack_chunk_free) + (void *(*)(long))obstack_chunk_alloc, \ + (void (*)(void *))obstack_chunk_free) #define obstack_begin(h, size) \ _obstack_begin ((h), (size), 0, \ - (void *(*)(long))obstack_chunk_alloc, \ - (void (*)(void *))obstack_chunk_free) + (void *(*)(long))obstack_chunk_alloc, \ + (void (*)(void *))obstack_chunk_free) #define obstack_specify_allocation(h, size, alignment, chunkfun, freefun) \ _obstack_begin ((h), (size), (alignment), \ - (void *(*)(long))(chunkfun), \ - (void (*)(void *))(freefun)) + (void *(*)(long))(chunkfun), \ + (void (*)(void *))(freefun)) #define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \ _obstack_begin_1 ((h), (size), (alignment), \ - (void *(*)(void *, long))(chunkfun), \ - (void (*)(void *, void *))(freefun), (arg)) + (void *(*)(void *, long))(chunkfun), \ + (void (*)(void *, void *))(freefun), (arg)) #define obstack_chunkfun(h, newchunkfun) \ ((h)->chunkfun = (struct _obstack_chunk *(*)(void *, long))(newchunkfun)) @@ -249,17 +258,14 @@ extern int obstack_exit_failure; #define obstack_memory_used(h) _obstack_memory_used (h) #if defined __GNUC__ -/* NextStep 2.0 cc is really gcc 1.93 but it defines __GNUC__ = 2 and - does not implement __extension__. But that compiler doesn't define - __GNUC_MINOR__. */ -# if __GNUC__ < 2 || (__NeXT__ && !__GNUC_MINOR__) +# if ! (2 < __GNUC__ + (8 <= __GNUC_MINOR__)) # define __extension__ # endif /* For GNU C, if not -traditional, we can define these macros to compute all args only once without using a global variable. - Also, we can avoid using the `temp' slot, to make faster code. */ + Also, we can avoid using the 'temp' slot, to make faster code. */ # define obstack_object_size(OBSTACK) \ __extension__ \ @@ -276,23 +282,23 @@ extern int obstack_exit_failure; ({ struct obstack *__o = (OBSTACK); \ int __len = (length); \ if (__o->chunk_limit - __o->next_free < __len) \ - _obstack_newchunk (__o, __len); \ + _obstack_newchunk (__o, __len); \ (void) 0; }) # define obstack_empty_p(OBSTACK) \ __extension__ \ ({ struct obstack const *__o = (OBSTACK); \ (__o->chunk->prev == 0 \ - && __o->next_free == __PTR_ALIGN ((char *) __o->chunk, \ - __o->chunk->contents, \ - __o->alignment_mask)); }) + && __o->next_free == __PTR_ALIGN ((char *) __o->chunk, \ + __o->chunk->contents, \ + __o->alignment_mask)); }) # define obstack_grow(OBSTACK, where, length) \ __extension__ \ ({ struct obstack *__o = (OBSTACK); \ int __len = (length); \ if (__o->next_free + __len > __o->chunk_limit) \ - _obstack_newchunk (__o, __len); \ + _obstack_newchunk (__o, __len); \ memcpy (__o->next_free, where, __len); \ __o->next_free += __len; \ (void) 0; }) @@ -302,7 +308,7 @@ extern int obstack_exit_failure; ({ struct obstack *__o = (OBSTACK); \ int __len = (length); \ if (__o->next_free + __len + 1 > __o->chunk_limit) \ - _obstack_newchunk (__o, __len + 1); \ + _obstack_newchunk (__o, __len + 1); \ memcpy (__o->next_free, where, __len); \ __o->next_free += __len; \ *(__o->next_free)++ = 0; \ @@ -312,7 +318,7 @@ extern int obstack_exit_failure; __extension__ \ ({ struct obstack *__o = (OBSTACK); \ if (__o->next_free + 1 > __o->chunk_limit) \ - _obstack_newchunk (__o, 1); \ + _obstack_newchunk (__o, 1); \ obstack_1grow_fast (__o, datum); \ (void) 0; }) @@ -324,27 +330,29 @@ extern int obstack_exit_failure; __extension__ \ ({ struct obstack *__o = (OBSTACK); \ if (__o->next_free + sizeof (void *) > __o->chunk_limit) \ - _obstack_newchunk (__o, sizeof (void *)); \ + _obstack_newchunk (__o, sizeof (void *)); \ obstack_ptr_grow_fast (__o, datum); }) \ # define obstack_int_grow(OBSTACK, datum) \ __extension__ \ ({ struct obstack *__o = (OBSTACK); \ if (__o->next_free + sizeof (int) > __o->chunk_limit) \ - _obstack_newchunk (__o, sizeof (int)); \ + _obstack_newchunk (__o, sizeof (int)); \ obstack_int_grow_fast (__o, datum); }) # define obstack_ptr_grow_fast(OBSTACK, aptr) \ __extension__ \ ({ struct obstack *__o1 = (OBSTACK); \ - *(const void **) __o1->next_free = (aptr); \ + void *__p1 = __o1->next_free; \ + *(const void **) __p1 = (aptr); \ __o1->next_free += sizeof (const void *); \ (void) 0; }) # define obstack_int_grow_fast(OBSTACK, aint) \ __extension__ \ ({ struct obstack *__o1 = (OBSTACK); \ - *(int *) __o1->next_free = (aint); \ + void *__p1 = __o1->next_free; \ + *(int *) __p1 = (aint); \ __o1->next_free += sizeof (int); \ (void) 0; }) @@ -353,7 +361,7 @@ extern int obstack_exit_failure; ({ struct obstack *__o = (OBSTACK); \ int __len = (length); \ if (__o->chunk_limit - __o->next_free < __len) \ - _obstack_newchunk (__o, __len); \ + _obstack_newchunk (__o, __len); \ obstack_blank_fast (__o, __len); \ (void) 0; }) @@ -382,13 +390,13 @@ extern int obstack_exit_failure; ({ struct obstack *__o1 = (OBSTACK); \ void *__value = (void *) __o1->object_base; \ if (__o1->next_free == __value) \ - __o1->maybe_empty_object = 1; \ + __o1->maybe_empty_object = 1; \ __o1->next_free \ - = __PTR_ALIGN (__o1->object_base, __o1->next_free, \ - __o1->alignment_mask); \ + = __PTR_ALIGN (__o1->object_base, __o1->next_free, \ + __o1->alignment_mask); \ if (__o1->next_free - (char *) __o1->chunk \ - > __o1->chunk_limit - (char *) __o1->chunk) \ - __o1->next_free = __o1->chunk_limit; \ + > __o1->chunk_limit - (char *) __o1->chunk) \ + __o1->next_free = __o1->chunk_limit; \ __o1->object_base = __o1->next_free; \ __value; }) @@ -397,8 +405,8 @@ extern int obstack_exit_failure; ({ struct obstack *__o = (OBSTACK); \ void *__obj = (OBJ); \ if (__obj > (void *) __o->chunk && __obj < (void *) __o->chunk_limit) \ - __o->next_free = __o->object_base = (char *) __obj; \ - else (obstack_free) (__o, __obj); }) + __o->next_free = __o->object_base = (char *) __obj; \ + else (__obstack_free) (__o, __obj); }) #else /* not __GNUC__ */ @@ -411,8 +419,8 @@ extern int obstack_exit_failure; # define obstack_empty_p(h) \ ((h)->chunk->prev == 0 \ && (h)->next_free == __PTR_ALIGN ((char *) (h)->chunk, \ - (h)->chunk->contents, \ - (h)->alignment_mask)) + (h)->chunk->contents, \ + (h)->alignment_mask)) /* Note that the call to _obstack_newchunk is enclosed in (..., 0) so that we can avoid having void expressions @@ -483,7 +491,7 @@ extern int obstack_exit_failure; (h)->temp.tempptr = (h)->object_base, \ (h)->next_free \ = __PTR_ALIGN ((h)->object_base, (h)->next_free, \ - (h)->alignment_mask), \ + (h)->alignment_mask), \ (((h)->next_free - (char *) (h)->chunk \ > (h)->chunk_limit - (char *) (h)->chunk) \ ? ((h)->next_free = (h)->chunk_limit) : 0), \ @@ -494,12 +502,14 @@ extern int obstack_exit_failure; ((h)->temp.tempint = (char *) (obj) - (char *) (h)->chunk, \ ((((h)->temp.tempint > 0 \ && (h)->temp.tempint < (h)->chunk_limit - (char *) (h)->chunk)) \ - ? (((h)->next_free = (h)->object_base \ - = (h)->temp.tempint + (char *) (h)->chunk), 0) \ - : ((obstack_free) ((h), (h)->temp.tempint + (char *) (h)->chunk), 0))) + ? (void) ((h)->next_free = (h)->object_base \ + = (h)->temp.tempint + (char *) (h)->chunk) \ + : (__obstack_free) (h, (h)->temp.tempint + (char *) (h)->chunk))) + #endif /* not __GNUC__ */ #ifdef __cplusplus } /* C++ */ #endif + #endif /* obstack.h */ |