Subversion Repositories Kolibri OS

/* obstack.h - object stack macros

/* obstack.h - object stack macros

   along with this program; if not, write to the Free Software

   You should have received a copy of the GNU Lesser General Public

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,

   License along with the GNU C Library; if not, see

   USA.  */

   .  */

been "finished" it never changes address again.  So the "top of the

   been "finished" it never changes address again.  So the "top of the

stack" is typically an immature growing object, while the rest of the

   stack" is typically an immature growing object, while the rest of the

stack is of mature, fixed size and fixed address objects.

   stack is of mature, fixed size and fixed address objects.

by calling `obstack_chunk_free'.  You must define them and declare

   by calling 'obstack_chunk_free'.  You must define them and declare

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

   Each of the obstack macros expects a pointer to such a structure

as the first argument.

   as the first argument.

	We are free to append data of any size to the currently

        We are free to append data of any size to the currently

	  growing object.

          growing object.

	Exactly one object is growing in an obstack at any one time.

        Exactly one object is growing in an obstack at any one time.

	You can run one obstack per control block.

        You can run one obstack per control block.

	You may have as many control blocks as you dare.

        You may have as many control blocks as you dare.

	  back to a previous state. (You may remove objects much

          back to a previous state. (You may remove objects much

	  as you would with a stack.)

          as you would with a stack.)

*/

 */

/* Don't do the contents of this file more than once.  */

/* Don't do the contents of this file more than once.  */

#define _OBSTACK_H 1

#define _OBSTACK_H 1

# define __PTR_TO_INT(P) ((P) - (char *) 0)

#else

#ifdef __PTRDIFF_TYPE__

  __BPTR_ALIGN (sizeof (ptrdiff_t) < sizeof (void *) ? (B) : (char *) 0,      \

#else

# ifdef HAVE_STDDEF_H

#ifndef __attribute_pure__

# define _obstack_memcpy(To, From, N) memcpy ((To), (From), (N))

# else

#else

#  define __attribute_pure__

# ifdef memcpy

# endif

#  define _obstack_memcpy(To, From, N) memcpy ((To), (char *)(From), (N))

#endif

  char	contents[4];		/* objects begin here */

  char contents[4];             /* objects begin here */

};

};

struct obstack		/* control current object in current chunk */

struct obstack          /* control current object in current chunk */

  long	chunk_size;		/* preferred size to allocate chunks in */

  _CHUNK_SIZE_T chunk_size;     /* preferred size to allocate chunks in */

  struct _obstack_chunk *chunk;	/* address of current struct obstack_chunk */

  struct _obstack_chunk *chunk; /* address of current struct obstack_chunk */

  char	*object_base;		/* address of object we are building */

  char *object_base;            /* address of object we are building */

  char	*next_free;		/* where to add next char to current object */

  char *next_free;              /* where to add next char to current object */

  void (*freefun) (void *, struct _obstack_chunk *);

  void *extra_arg;		/* first arg for chunk alloc/dealloc funcs */

  void *extra_arg;              /* first arg for chunk alloc/dealloc funcs */

  unsigned use_extra_arg:1;	/* chunk alloc/dealloc funcs take extra arg */

  unsigned use_extra_arg : 1;     /* chunk alloc/dealloc funcs take extra arg */

  unsigned maybe_empty_object:1;/* There is a possibility that the current

  unsigned maybe_empty_object : 1; /* There is a possibility that the current

				   chunk contains a zero-length object.  This

                                      chunk contains a zero-length object.  This

				   compatibility.  */

                                     compatibility.  */

};

};

extern int _obstack_begin_1 (struct obstack *, int, int,

                             _OBSTACK_SIZE_T, _OBSTACK_SIZE_T,

/* Error handler called when 'obstack_chunk_alloc' failed to allocate

   more memory.  This can be set to a user defined function.  The

   should either abort gracefully or use longjump - but shouldn't

   default action is to print a message and abort.  */

   return.  The default action is to print a message and abort.  */

extern void (*obstack_alloc_failed_handler) (void);

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.  */

/* Pointer to beginning of object being allocated or to be allocated next.

/* Pointer to beginning of object being allocated or to be allocated next.

   Note that this might not be the final address of the object

   Note that this might not be the final address of the object

#define obstack_base(h) ((h)->object_base)

#define obstack_base(h) ((void *) (h)->object_base)

/* Size for allocating ordinary chunks.  */

#define obstack_chunk_size(h) ((h)->chunk_size)

/* Pointer to next byte not yet allocated in current chunk.  */

/* Pointer to next byte not yet allocated in current chunk.  */

/* Mask specifying low bits that should be clear in address of an object.  */

/* Mask specifying low bits that should be clear in address of an object.  */

#define obstack_alignment_mask(h) ((h)->alignment_mask)

/* To prevent prototype warnings provide complete argument list.  */

#define obstack_init(h)							      \

# define obstack_init(h) \

                  _OBSTACK_CAST (void (*) (void *), obstack_chunk_free))

		  (void *(*) (long)) obstack_chunk_alloc, (void (*) (void *)) obstack_chunk_free)

#define obstack_begin(h, size)						      \

		  (void *(*) (long)) obstack_chunk_alloc, (void (*) (void *)) obstack_chunk_free)

#define obstack_specify_allocation(h, size, alignment, chunkfun, freefun)     \

  _obstack_begin_1 ((h), (size), (alignment), \

                  _OBSTACK_CAST (void (*) (void *), freefun))

		    (void *(*) (void *, long)) (chunkfun), \

		    (void (*) (void *, void *)) (freefun), (arg))

#define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \

  _obstack_begin_1 ((h), (size), (alignment),				      \

# define obstack_chunkfun(h, newchunkfun) \

                    _OBSTACK_CAST (void *(*) (void *, size_t), chunkfun),     \

# define obstack_freefun(h, newfreefun) \

#define obstack_chunkfun(h, newchunkfun)				      \

#define obstack_1grow_fast(h,achar) (*((h)->next_free)++ = (achar))

#define obstack_1grow_fast(h, achar) ((void) (*((h)->next_free)++ = (achar)))

#define obstack_memory_used(h) _obstack_memory_used (h)

#define obstack_memory_used(h) _obstack_memory_used (h)

#if defined __GNUC__ && defined __STDC__ && __STDC__

   __GNUC_MINOR__.  */

#  define __extension__

# if __GNUC__ < 2 || (__NeXT__ && !__GNUC_MINOR__)

# endif

#  define __extension__

# endif

/* For GNU C, if not -traditional,

   we can define these macros to compute all args only once

  __extension__								      \

   without using a global variable.

    ({ struct obstack const *__o = (OBSTACK);				      \

   Also, we can avoid using the `temp' slot, to make faster code.  */

       (_OBSTACK_SIZE_T) (__o->next_free - __o->object_base); })

  __extension__								\

   warning when invoked from other obstack macros.  */

     (unsigned) (__o->next_free - __o->object_base); })

  __extension__								      \

    ({ struct obstack const *__o1 = (OBSTACK);				      \

# define obstack_room(OBSTACK)						\

       (_OBSTACK_SIZE_T) (__o1->chunk_limit - __o1->next_free); })

  __extension__								\

  ({ struct obstack *__o = (OBSTACK);					\

# define obstack_make_room(OBSTACK, length)				      \

# define obstack_make_room(OBSTACK,length)				\

       _OBSTACK_SIZE_T __len = (length);				      \

({ struct obstack *__o = (OBSTACK);					\

         _obstack_newchunk (__o, __len);				      \

   int __len = (length);						\

       (void) 0; })

   if (__o->chunk_limit - __o->next_free < __len)			\

     _obstack_newchunk (__o, __len);					\

# define obstack_empty_p(OBSTACK)					      \

   (void) 0; })

  __extension__								      \

    ({ struct obstack const *__o = (OBSTACK);				      \

  __extension__								\

        && __o->next_free == __PTR_ALIGN ((char *) __o->chunk,		      \

__extension__								\

# define obstack_grow(OBSTACK, where, length)				      \

({ struct obstack *__o = (OBSTACK);					\

  __extension__								      \

   int __len = (length);						\

    ({ struct obstack *__o = (OBSTACK);					      \

   if (__o->next_free + __len > __o->chunk_limit)			\

       _OBSTACK_SIZE_T __len = (length);				      \

   _obstack_memcpy (__o->next_free, (where), __len);			\

         _obstack_newchunk (__o, __len);				      \

   __o->next_free += __len;						\

       memcpy (__o->next_free, where, __len);				      \

   (void) 0; })

       __o->next_free += __len;						      \

       (void) 0; })

# define obstack_grow0(OBSTACK,where,length)				\

({ struct obstack *__o = (OBSTACK);					\

  __extension__								      \

   int __len = (length);						\

    ({ struct obstack *__o = (OBSTACK);					      \

   if (__o->next_free + __len + 1 > __o->chunk_limit)			\

       _OBSTACK_SIZE_T __len = (length);				      \

     _obstack_newchunk (__o, __len + 1);				\

       if (obstack_room (__o) < __len + 1)				      \

   _obstack_memcpy (__o->next_free, (where), __len);			\

         _obstack_newchunk (__o, __len + 1);				      \

   *(__o->next_free)++ = 0;						\

       *(__o->next_free)++ = 0;						      \

   (void) 0; })

       (void) 0; })

# define obstack_1grow(OBSTACK,datum)					\

# define obstack_1grow(OBSTACK, datum)					      \

__extension__								\

  __extension__								      \

   if (__o->next_free + 1 > __o->chunk_limit)				\

         _obstack_newchunk (__o, 1);					      \

     _obstack_newchunk (__o, 1);					\

       obstack_1grow_fast (__o, datum); })

   obstack_1grow_fast (__o, datum);					\

   (void) 0; })

/* These assume that the obstack alignment is good enough for pointers

   or ints, and that the data added so far to the current object

   shares that much alignment.  */

# define obstack_ptr_grow(OBSTACK, datum)				      \

__extension__								\

    ({ struct obstack *__o = (OBSTACK);					      \

({ struct obstack *__o = (OBSTACK);					\

       if (obstack_room (__o) < sizeof (void *))			      \

   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); })

__extension__								\

  __extension__								      \

({ struct obstack *__h = (OBSTACK);					\

    ({ struct obstack *__h = (OBSTACK);					      \

   obstack_grow0 (__h, (where), (length));				\

       obstack_grow0 (__h, (where), (length));				      \

   obstack_finish (__h); })

       obstack_finish (__h); })

   when obstack_blank is called.  */

   warning when invoked from other obstack macros, typically obstack_free.  */

# define obstack_finish(OBSTACK)  					\

# define obstack_finish(OBSTACK)					      \

__extension__								\

  __extension__								      \

   if (__o1->next_free == value)					\

       if (__o1->next_free == __value)					      \

     __o1->maybe_empty_object = 1;					\

         __o1->maybe_empty_object = 1;					      \

       > __o1->chunk_limit - (char *)__o1->chunk)			\

           > (size_t) (__o1->chunk_limit - (char *) __o1->chunk))	      \

     __o1->next_free = __o1->chunk_limit;				\

         __o1->next_free = __o1->chunk_limit;				      \

   value; })

       __value; })

# define obstack_free(OBSTACK, OBJ)					\

# define obstack_free(OBSTACK, OBJ)					      \

__extension__								\

  __extension__								      \

({ struct obstack *__o = (OBSTACK);					\

    ({ struct obstack *__o = (OBSTACK);					      \

   void *__obj = (void *) (OBJ);					\

       void *__obj = (void *) (OBJ);					      \

     __o->next_free = __o->object_base = (char *) __obj;		\

       else								      \

 (unsigned) ((h)->next_free - (h)->object_base)

  ((_OBSTACK_SIZE_T) ((h)->next_free - (h)->object_base))

# define obstack_room(h)		\

# define obstack_empty_p(h)						      \

 (unsigned) ((h)->chunk_limit - (h)->next_free)

  ((h)->chunk->prev == 0						      \

   && (h)->next_free == __PTR_ALIGN ((char *) (h)->chunk,		      \

# define obstack_empty_p(h) \

                                     (h)->chunk->contents,		      \

 ((h)->chunk->prev == 0 && (h)->next_free - (h)->chunk->contents == 0)

                                     (h)->alignment_mask))

   Casting the third operand to void was tried before,

   but some compilers won't accept it.  */

   ? (_obstack_newchunk ((h), (h)->temp), 0) : 0))

  (h)->next_free += (h)->temp)

# define obstack_grow0(h,where,length)					\

  ((h)->temp.i = (length),						      \

( (h)->temp = (length),							\

   ((obstack_room (h) < (h)->temp.i + 1)				      \

  (((h)->next_free + (h)->temp + 1 > (h)->chunk_limit)			\

   ? (_obstack_newchunk ((h), (h)->temp.i + 1), 0) : 0),		      \

  _obstack_memcpy ((h)->next_free, (where), (h)->temp),			\

   (h)->next_free += (h)->temp.i,					      \

  (h)->next_free += (h)->temp,						\

   *((h)->next_free)++ = 0,						      \

  *((h)->next_free)++ = 0)

   (void) 0)

# define obstack_1grow(h,datum)						\

# define obstack_1grow(h, datum)					      \

( (((h)->next_free + 1 > (h)->chunk_limit)				\

  (((obstack_room (h) < 1)						      \

   ? (_obstack_newchunk ((h), 1), 0) : 0),				\

    ? (_obstack_newchunk ((h), 1), 0) : 0),				      \

# define obstack_ptr_grow(h, datum)					      \

( (((h)->next_free + sizeof (char *) > (h)->chunk_limit)		\

   obstack_ptr_grow_fast (h, datum))

( (((h)->next_free + sizeof (int) > (h)->chunk_limit)			\

   obstack_int_grow_fast (h, datum))

   ? (_obstack_newchunk ((h), sizeof (int)), 0) : 0),			\

  obstack_int_grow_fast (h, datum))

# define obstack_ptr_grow_fast(h, aptr)					      \

# define obstack_finish(h)  						\

# define obstack_finish(h)						      \

( ((h)->next_free == (h)->object_base					\

  (((h)->next_free == (h)->object_base					      \

   ? (((h)->maybe_empty_object = 1), 0)					\

    ? (((h)->maybe_empty_object = 1), 0)				      \

  (h)->temp = __PTR_TO_INT ((h)->object_base),				\

   (h)->temp.p = (h)->object_base,					      \

    > (h)->chunk_limit - (char *) (h)->chunk)				\

     > (size_t) ((h)->chunk_limit - (char *) (h)->chunk))		      \

   ? ((h)->next_free = (h)->chunk_limit) : 0),				\

   ? ((h)->next_free = (h)->chunk_limit) : 0),				      \

  (void *) __INT_TO_PTR ((h)->temp))

   (h)->temp.p)

   : ((obstack_free) ((h), (h)->temp + (char *) (h)->chunk), 0)))

    : _obstack_free ((h), (h)->temp.p)))

#endif /* not __GNUC__ or not __STDC__ */

#endif /* not __GNUC__ */