Subversion Repositories or1k

/*
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
cleanup_glue (ptr, glue)
     struct _reent *ptr;
     struct _glue *glue;
{
  /* Have to reclaim these in reverse order: */
  if (glue->_next)
    cleanup_glue (ptr, glue->_next);
 
  _free_r (ptr, glue);
}
 
void
_reclaim_reent (ptr)
     struct _reent *ptr;
{
  if (ptr != _impure_ptr)
    {
      /* used by mprec routines. */
      if (ptr->_freelist)
	{
	  int i;
	  for (i = 0; i < 15 /* _Kmax */; i++) 
	    {
	      struct _Bigint *thisone, *nextone;
 
	      nextone = ptr->_freelist[i];
	      while (nextone)
		{
		  thisone = nextone;
		  nextone = nextone->_next;
		  _free_r (ptr, thisone);
		}
	    }    
 
	  _free_r (ptr, ptr->_freelist);
	}
 
      /* 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);
	    }
	}
 
      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
_wrapup_reent(struct _reent *ptr)
{
  register struct _atexit *p;
  register int n;
 
  if (ptr == 0)
      ptr = _REENT;
 
  for (p = ptr->_atexit; p; p = p->_next)
    for (n = p->_ind; --n >= 0;)
      (*p->_fns[n]) ();
  if (ptr->__cleanup)
    (*ptr->__cleanup) (ptr);
}