/***
*alloc.c - disked malloc/free front-end.
*
*Copyright (c) 1993-1995, Gregg Jennings.  All wrongs reserved.
*   P O Box 200, Falmouth, MA 02541-0200
*
*Purpose:
*   Debugging support.
*
*Notice:
*   This progam may be freely used and distributed.  Any distrubution
*   with modifications must retain the above copyright statement and
*   modifications noted.
*   No pulp-publication, in whole or in part, permitted without
*   permission (magazines or books).
*******************************************************************************/

/*
   Version

   2.6   20-Dec-1994    converted error references to function calls
   2.5   18-Nov-1994    alloc_handler()
   2.4   11-Sep-1994    removed DISKED ifdefs
                        fixed heapstat()
   2.3   25-Feb-1994    hugealloc(),hugefree(), etc
   2.2   21-Feb-1994    fixed heapstat
   2.1   13-Jan-1994    Borland stuff, heaptest was heapcheck
   2.0   28-Nov-1993

   malloc() and free() front end or "wrappers".  This family of
   functions can be called explicitly (as DISKED does) or via
   macros:

      #define malloc(s)    alloc(1,s)
      #define free(p)      freep(p)
         etc.

   which will enable them to be used if needed for debugging.
   The heaptest() function can find bounds errors; just add
   this in your code to find it:

      if (heaptest() < 1)
         printf("%s%d",__FILE__,__LINE__);

   Notes:   This unit can be a separate unit.  The only globals
            referenced are the error message enums in ERROR.H.
            The ERROR.C error message calls can be removed
            without effect.

            Borland does not have a near heap in Large Memory model.
*/

#include <stdlib.h>
#include <malloc.h>

#include "alloc.h"
#include "error.h"

/* globals referenced here 

   error number definitions (enum ERROR_MSG, ERROR.H)

*/

/* globals defined here */

unsigned int blocks = 0;               /* statistics only */
unsigned int nblocks = 0;              /* used by DEBUG.C */
unsigned int hblocks = 0;
unsigned int frees = 0;
unsigned int nfrees = 0;
unsigned int hfrees = 0;


/* internal functions */

static void default_alloc_handler(void);


/***
*alloc_handler -  got the idea from C++, this is called
*                 for alloc failures
*
***/

void (*alloc_handler)(void) = default_alloc_handler;

/***
*default_alloc_handler -  handles memory allocation failure
*
*  So far only sets error message information.
*
****/

static void default_alloc_handler(void)
{
   set_err_num(ALLOC_FAIL);            /* set error number */
                                       /*  the module, function error */
                                       /*  arg are set by the caller */
   set_err_info("memavail: %lu",memavail()); /* set avail. mem. info */
}

/***
*set_alloc_handler   -  set the function to call upon malloc
*                       failure
*
****/

extern void set_alloc_handler(void (*func)(void))
{
   alloc_handler = (func) ? func : default_alloc_handler;
}

/***
*alloc   -  malloc/calloc replacement
*
****/

extern void *alloc(size_t num, size_t size)
{
void *t;

   if (size == 0)
   {
      set_err_num(ALLOC_ZERO);
      return NULL;
   }
   if ((t = calloc(num,size)) == NULL)
      alloc_handler();

   ++blocks;
   return t;
}

#ifndef __BORLANDC__

extern void _near *nalloc(size_t num, size_t size)
{
void _near *t;

   if (size == 0)
   {
      set_err_num(ALLOC_ZERO);
      return NULL;
   }
   if ((t = _ncalloc(num,size)) == NULL)
      alloc_handler();

   ++nblocks;
   return t;
}

#endif   /* !__BORLANDC__ */

extern void _huge *hugealloc(long num, long size)
{
void _huge *t;

   if (size == 0)
   {
      set_err_num(ALLOC_ZERO);
      return NULL;
   }

   if ((t = huge_alloc(num,size)) == NULL)
      alloc_handler();

   ++hblocks;
   return t;
}

/* realloc() */

extern void *newalloc(void *p, size_t size)
{
   if (p != NULL)
      freep(p);
   return alloc(1,size);
}

extern void freep(void *addr)
{
int h;

   if (addr != NULL)
   {
      free(addr);
      if ((h = _fheapset(254)) != _HEAPOK)
      {
         set_error(NULL,"alloc",HEAP_ERROR,"freep");
         set_err_arg(heapstat(h));
      }
      addr = NULL;
      ++frees;
   }
   else
      set_err_num(FREE_NULL);
}

#if !defined(__BORLANDC__)

extern void nfreep(void _near *addr)
{
int h;

   if (addr != NULL)
   {
      _nfree(addr);
      if ((h = _nheapset(254)) != _HEAPOK)
      {
         set_error(NULL,"alloc",HEAP_ERROR,"nfreep");
         set_err_arg(heapstat(h));
      }
      addr = NULL;
      ++nfrees;
   }
   else
      set_err_num(FREE_NULL);
}

#endif

extern void hugefreep(void _huge *addr)
{
   if (addr != NULL)
   {
      huge_free(addr);
      addr = NULL;
      ++hfrees;
   }
   else
      set_err_num(FREE_NULL);
}


/***
*heaptest()
*
*   putting calls to this throughout the program can help find were the
*   heap is getting corrupted:
*
*      if (heaptest() < 1)
*         printf("%s%d",__FILE__,__LINE__);
***/

extern int heaptest(void)
{
int h;

#if !defined(__BORLANDC__)
   if ((h = _fheapchk()) != _HEAPOK || (h = _nheapchk()) != _HEAPOK)
#else
   if ((h = _heapchk()) != _HEAPOK)
#endif
      return h;
   else
      return 1;
}

/* AS IN MALLOC.H:

constants for _heapchk/_heapset/_heapwalk routines

Borland:

#define _HEAPEMPTY      1     // 0
#define _HEAPOK         2     // 1
#define _HEAPEND        5     // 4
#define _HEAPCORRUPT   -1     // 5
#define _BADNODE       -2     // 2
#define _BADVALUE      -3     // 3

#define _FREEENTRY      3
#define _USEDENTRY      4

Microsoft:

#define _HEAPEMPTY      (-1)
#define _HEAPOK         (-2)           // _heapchk/_heapset only
#define _HEAPBADBEGIN   (-3)
#define _HEAPBADNODE    (-4)
#define _HEAPEND        (-5)           // _heapwalk only
#define _HEAPBADPTR     (-6)

#define _FREEENTRY      0
#define _USEDENTRY      1

Watcom:

#define _HEAPOK         0
#define _HEAPEMPTY      1  // heap isn't initialized
#define _HEAPBADBEGIN   2  // heap header is corrupted
#define _HEAPBADNODE    3  // heap entry is corrupted
#define _HEAPEND        4  // end of heap entries (_heapwalk)
#define _HEAPBADPTR     5  // invalid heap entry pointer (_heapwalk)

#define _FREEENTRY      1
#define _USEDENTRY      0


You can see the dificulty with these compiler library functions!
*/

/* heap status message - values are normalized to 0-N */

static char *heap_msg[] = {
#ifdef _MSC_VER
   "empty heap",
   "heap is fine",
   "bad start of heap",
   "bad node in heap",
   "end of heap",
   "bad pointer to heap",
   "bad heap",                /* unknown value */
#elif __WATCOMC__
   "heap is fine",
   "empty heap",
   "bad start of heap",
   "bad node in heap",
   "end of heap",
   "bad pointer to heap",
   "bad heap",                /* unknown value */
#elif __BORLANDC__
   "empty heap",
   "heap is fine",
   "bad node in heap",
   "bad pointer to heap",
   "end of heap",
   "bad heap",                /* unknown value */
#else
#error put Your compiler messages here
#endif
};

/* get heap status message */

extern char *heapstat(int status)
{
#ifdef _MSC_VER
   status = -status-1;     /* make offset into message array */
#elif defined(__BORLANDC__)
   if (status < 0)
   {
      if (status == -1)
         status = 5;
      else
         status = -status;
   }
   else
      --status;
#endif
   if (status < 0 || status > (sizeof(heap_msg)/sizeof(char *))-1)
      status = (sizeof(heap_msg)/sizeof(char *))-1;
   return heap_msg[status];
}