[thirdparty/gcc.git] / libiberty / xatexit.c

/*
 * Copyright (c) 1990 Regents of the University of California.
 * All rights reserved.
 *
 * %sccs.include.redist.c%
 */


/*

@deftypefun int xatexit (void (*@var{fn}) (void))

Behaves as the standard @code{atexit} function, but with no limit on
the number of registered functions.  Returns 0 on success, or @minus{}1 on
failure.  If you use @code{xatexit} to register functions, you must use
@code{xexit} to terminate your program.

@end deftypefun

*/

/* Adapted from newlib/libc/stdlib/{,at}exit.[ch].
   If you use xatexit, you must call xexit instead of exit.  */

#include "ansidecl.h"
#include "libiberty.h"

#include <stdio.h>

#ifdef __STDC__
#include <stddef.h>
#else
#define size_t unsigned long
#endif

/* For systems with larger pointers than ints, this must be declared.  */
PTR malloc PARAMS ((size_t));

static void xatexit_cleanup PARAMS ((void));

/* Pointer to function run by xexit.  */
extern void (*_xexit_cleanup) PARAMS ((void));

#define	XATEXIT_SIZE 32

struct xatexit {
	struct	xatexit *next;		/* next in list */
	int	ind;			/* next index in this table */
	void	(*fns[XATEXIT_SIZE]) PARAMS ((void));	/* the table itself */
};

/* Allocate one struct statically to guarantee that we can register
   at least a few handlers.  */
static struct xatexit xatexit_first;

/* Points to head of LIFO stack.  */
static struct xatexit *xatexit_head = &xatexit_first;

/* Register function FN to be run by xexit.
   Return 0 if successful, -1 if not.  */

int
xatexit (fn)
     void (*fn) PARAMS ((void));
{
  register struct xatexit *p;

  /* Tell xexit to call xatexit_cleanup.  */
  if (!_xexit_cleanup)
    _xexit_cleanup = xatexit_cleanup;

  p = xatexit_head;
  if (p->ind >= XATEXIT_SIZE)
    {
      if ((p = (struct xatexit *) malloc (sizeof *p)) == NULL)
	return -1;
      p->ind = 0;
      p->next = xatexit_head;
      xatexit_head = p;
    }
  p->fns[p->ind++] = fn;
  return 0;
}

/* Call any cleanup functions.  */

static void
xatexit_cleanup ()
{
  register struct xatexit *p;
  register int n;

  for (p = xatexit_head; p; p = p->next)
    for (n = p->ind; --n >= 0;)
      (*p->fns[n]) ();
}
Commit	Line	Data
6599da04 JM	1	/*
	2	* Copyright (c) 1990 Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* %sccs.include.redist.c%
	6	*/
	7
aaa5f039 DD	8
	9	/*
	10
	11	@deftypefun int xatexit (void (*@var{fn}) (void))
	12
	13	Behaves as the standard @code{atexit} function, but with no limit on
7f8fa05d	14	the number of registered functions. Returns 0 on success, or @minus{}1 on
aaa5f039 DD	15	failure. If you use @code{xatexit} to register functions, you must use
	16	@code{xexit} to terminate your program.
	17
	18	@end deftypefun
	19
	20	*/
	21
6599da04 JM	22	/* Adapted from newlib/libc/stdlib/{,at}exit.[ch].
	23	If you use xatexit, you must call xexit instead of exit. */
	24
	25	#include "ansidecl.h"
	26	#include "libiberty.h"
	27
	28	#include <stdio.h>
	29
	30	#ifdef __STDC__
	31	#include <stddef.h>
	32	#else
	33	#define size_t unsigned long
	34	#endif
	35
	36	/* For systems with larger pointers than ints, this must be declared. */
	37	PTR malloc PARAMS ((size_t));
	38
	39	static void xatexit_cleanup PARAMS ((void));
	40
	41	/* Pointer to function run by xexit. */
	42	extern void (*_xexit_cleanup) PARAMS ((void));
	43
	44	#define XATEXIT_SIZE 32
	45
	46	struct xatexit {
	47	struct xatexit next; / next in list */
	48	int ind; /* next index in this table */
	49	void (fns[XATEXIT_SIZE]) PARAMS ((void)); / the table itself */
	50	};
	51
	52	/* Allocate one struct statically to guarantee that we can register
	53	at least a few handlers. */
	54	static struct xatexit xatexit_first;
	55
	56	/* Points to head of LIFO stack. */
	57	static struct xatexit *xatexit_head = &xatexit_first;
	58
	59	/* Register function FN to be run by xexit.
	60	Return 0 if successful, -1 if not. */
	61
	62	int
	63	xatexit (fn)
	64	void (*fn) PARAMS ((void));
	65	{
	66	register struct xatexit *p;
	67
	68	/* Tell xexit to call xatexit_cleanup. */
	69	if (!_xexit_cleanup)
	70	_xexit_cleanup = xatexit_cleanup;
	71
	72	p = xatexit_head;
	73	if (p->ind >= XATEXIT_SIZE)
	74	{
	75	if ((p = (struct xatexit ) malloc (sizeof p)) == NULL)
	76	return -1;
	77	p->ind = 0;
	78	p->next = xatexit_head;
	79	xatexit_head = p;
	80	}
	81	p->fns[p->ind++] = fn;
	82	return 0;
	83	}
	84
	85	/* Call any cleanup functions. */
86
87	static void
88	xatexit_cleanup ()
89	{
90	register struct xatexit *p;
91	register int n;
92
93	for (p = xatexit_head; p; p = p->next)
94	for (n = p->ind; --n >= 0;)
95	(*p->fns[n]) ();
96	}