Retro68/gcc/newlib/libc/reent/reent.c
2012-03-27 01:51:53 +02:00

152 lines
3.0 KiB
C

/*
FUNCTION
<<reent>>---definition of impure data.
INDEX
reent
DESCRIPTION
This module defines the impure data area used by the
non-reentrant functions, such as strtok.
*/
#include <stdlib.h>
#include <reent.h>
#ifdef _REENT_ONLY
#ifndef REENTRANT_SYSCALLS_PROVIDED
#define REENTRANT_SYSCALLS_PROVIDED
#endif
#endif
#ifndef REENTRANT_SYSCALLS_PROVIDED
/* We use the errno variable used by the system dependent layer. */
#undef errno
int errno;
#endif
/* Interim cleanup code */
void
_DEFUN (cleanup_glue, (ptr, glue),
struct _reent *ptr _AND
struct _glue *glue)
{
/* Have to reclaim these in reverse order: */
if (glue->_next)
cleanup_glue (ptr, glue->_next);
_free_r (ptr, glue);
}
void
_DEFUN (_reclaim_reent, (ptr),
struct _reent *ptr)
{
if (ptr != _impure_ptr)
{
/* used by mprec routines. */
#ifdef _REENT_SMALL
if (ptr->_mp) /* don't bother allocating it! */
{
#endif
if (_REENT_MP_FREELIST(ptr))
{
int i;
for (i = 0; i < _Kmax; i++)
{
struct _Bigint *thisone, *nextone;
nextone = _REENT_MP_FREELIST(ptr)[i];
while (nextone)
{
thisone = nextone;
nextone = nextone->_next;
_free_r (ptr, thisone);
}
}
_free_r (ptr, _REENT_MP_FREELIST(ptr));
}
if (_REENT_MP_RESULT(ptr))
_free_r (ptr, _REENT_MP_RESULT(ptr));
#ifdef _REENT_SMALL
}
#endif
#ifdef _REENT_SMALL
if (ptr->_emergency)
_free_r (ptr, ptr->_emergency);
if (ptr->_mp)
_free_r (ptr, ptr->_mp);
if (ptr->_r48)
_free_r (ptr, ptr->_r48);
if (ptr->_localtime_buf)
_free_r (ptr, ptr->_localtime_buf);
if (ptr->_asctime_buf)
_free_r (ptr, ptr->_asctime_buf);
if (ptr->_atexit && ptr->_atexit->_on_exit_args_ptr)
_free_r (ptr, ptr->_atexit->_on_exit_args_ptr);
#else
/* atexit stuff */
if ((ptr->_atexit) && (ptr->_atexit != &ptr->_atexit0))
{
struct _atexit *p, *q;
for (p = ptr->_atexit; p != &ptr->_atexit0;)
{
q = p;
p = p->_next;
_free_r (ptr, q);
}
}
#endif
if (ptr->_cvtbuf)
_free_r (ptr, ptr->_cvtbuf);
if (ptr->__sdidinit)
{
/* cleanup won't reclaim memory 'coz usually it's run
before the program exits, and who wants to wait for that? */
ptr->__cleanup (ptr);
if (ptr->__sglue._next)
cleanup_glue (ptr, ptr->__sglue._next);
}
/* Malloc memory not reclaimed; no good way to return memory anyway. */
}
}
/*
* Do atexit() processing and cleanup
*
* NOTE: This is to be executed at task exit. It does not tear anything
* down which is used on a global basis.
*/
void
_DEFUN (_wrapup_reent, (ptr), struct _reent *ptr)
{
register struct _atexit *p;
register int n;
if (ptr == NULL)
ptr = _REENT;
#ifdef _REENT_SMALL
for (p = ptr->_atexit, n = p ? p->_ind : 0; --n >= 0;)
(*p->_fns[n]) ();
#else
for (p = ptr->_atexit; p; p = p->_next)
for (n = p->_ind; --n >= 0;)
(*p->_fns[n]) ();
#endif
if (ptr->__cleanup)
(*ptr->__cleanup) (ptr);
}