/*
   ** MEMWATCH.H
   ** Nonintrusive ANSI C memory leak / overwrite detection
   ** Copyright (C) 1992-99 Johan Lindh
   ** All rights reserved.
   ** Version 2.59
   **
   ************************************************************************
   **
   ** PURPOSE:
   **
   **  MEMWATCH has been written to allow guys and gals that like to
   **  program in C a public-domain memory error control product.
   **  I hope you'll find it's as advanced as most commercial packages.
   **  The idea is that you use it during the development phase and
   **  then remove the MEMWATCH define to produce your final product.
   **  MEMWATCH is distributed in source code form in order to allow
   **  you to compile it for your platform with your own compiler.
   **  It's aim is to be 100% ANSI C, but some compilers are more stingy
   **  than others. If it doesn't compile without warnings, please mail
   **  me the configuration of operating system and compiler you are using
   **  along with a description of how to modify the source, and the version
   **  number of MEMWATCH that you are using.
   **
   ************************************************************************
   **
   ** And now for some legalese...
   **
   ** LICENSE:
   **
   **  You are granted a non-exclusive right to use MEMWATCH in your
   **  programs, provided that you agree to the following terms:
   **
   **  1.  Johan Lindh retains the full copyright of MEMWATCH, and owns
   **      all rights to it. This means you can't sell it yourself, or
   **      ship it as part of another product, or as part of a package.
   **  2.  If you modify any of the files, you must not give them to
   **      anyone else. But please send me a copy of the changes,
   **      along with a text as to why they should be implemented.
   **  3.  You read and agree to the DISCLAIMER, below.
   **
   ** DISCLAIMER:
   **
   **  THIS SOFTWARE IS PROVIDED FREE OF CHARGE 'AS IS' AND JOHAN LINDH MAKES NO
   **  EXPRESS OR IMPLIED WARRANTIES WITH RESPECT TO IT. JOHAN LINDH WILL
   **  NOT BE LIABLE FOR ANY DAMAGES, DIRECT OR INDIRECT, ARISING FROM THE
   **  USAGE OR HANDLING OF THIS SOFTWARE.
   **
   ************************************************************************
   **
   ** REVISION HISTORY:
   **
   ** 920810 JLI   [1.00]
   ** 920830 JLI   [1.10 double-free detection]
   ** 920912 JLI   [1.15 mwPuts, mwGrab/Drop, mwLimit]
   ** 921022 JLI   [1.20 ASSERT and VERIFY]
   ** 921105 JLI   [1.30 C++ support and TRACE]
   ** 921116 JLI   [1.40 mwSetOutFunc]
   ** 930215 JLI   [1.50 modified ASSERT/VERIFY]
   ** 930327 JLI   [1.51 better auto-init & PC-lint support]
   ** 930506 JLI   [1.55 MemWatch class, improved C++ support]
   ** 930507 JLI   [1.60 mwTest & CHECK()]
   ** 930809 JLI   [1.65 Abort/Retry/Ignore]
   ** 930820 JLI   [1.70 data dump when unfreed]
   ** 931016 JLI   [1.72 modified C++ new/delete handling]
   ** 931108 JLI   [1.77 mwSetAssertAction() & some small changes]
   ** 940110 JLI   [1.80 no-mans-land alloc/checking]
   ** 940328 JLI   [2.00 version 2.0 rewrite]
   **              Improved NML (no-mans-land) support.
   **              Improved performance (especially for free()ing!).
   **              Support for 'read-only' buffers (checksums)
   **              ^^ NOTE: I never did this... maybe I should?
   **              FBI (free'd block info) tagged before freed blocks
   **              Exporting of the mwCounter variable
   **              mwBreakOut() localizes debugger support
   **              Allocation statistics (global, per-module, per-line)
   **              Self-repair ability with relinking
   ** 950913 JLI   [2.10 improved garbage handling]
   ** 951201 JLI   [2.11 improved auto-free in emergencies]
   ** 960125 JLI   [X.01 implemented auto-checking using mwAutoCheck()]
   ** 960514 JLI   [2.12 undefining of existing macros]
   ** 960515 JLI   [2.13 possibility to use default new() & delete()]
   ** 960516 JLI   [2.20 suppression of file flushing on unfreed msgs]
   ** 960516 JLI   [2.21 better support for using MEMWATCH with DLL's]
   ** 960710 JLI   [X.02 multiple logs and mwFlushNow()]
   ** 960801 JLI   [2.22 merged X.01 version with current]
   ** 960805 JLI   [2.30 mwIsXXXXAddr() to avoid unneeded GP's]
   ** 960805 JLI   [2.31 merged X.02 version with current]
   ** 961002 JLI   [2.32 support for realloc() + fixed STDERR bug]
   ** 961222 JLI   [2.40 added mwMark() & mwUnmark()]
   ** 970101 JLI   [2.41 added over/underflow checking after failed ASSERT/VERIFY]
   ** 970113 JLI   [2.42 added support for PC-Lint 7.00g]
   ** 970207 JLI   [2.43 added support for strdup()]
   ** 970209 JLI   [2.44 changed default filename to lowercase]
   ** 970405 JLI   [2.45 fixed bug related with atexit() and some C++ compilers]
   ** 970723 JLI   [2.46 added MW_ARI_NULLREAD flag]
   ** 970813 JLI   [2.47 stabilized marker handling]
   ** 980317 JLI   [2.48 ripped out C++ support; wasn't working good anyway]
   ** 980318 JLI   [2.50 improved self-repair facilities & SIGSEGV support]
   ** 980417 JLI        [2.51 more checks for invalid addresses]
   ** 980512 JLI        [2.52 moved MW_ARI_NULLREAD to occur before aborting]
   ** 990112 JLI        [2.53 added check for empty heap to mwIsOwned]
   ** 990217 JLI        [2.55 improved the emergency repairs diagnostics and NML]
   ** 990224 JLI        [2.56 changed ordering of members in structures]
   ** 990303 JLI        [2.57 first maybe-fixit-for-hpux test]
   ** 990516 JLI        [2.58 added 'static' to the definition of mwAutoInit]
   ** 990517 JLI        [2.59 fixed some high-sensitivity warnings]
   **
   ** To use, simply include 'MEMWATCH.H' as a header file,
   ** and add MEMWATCH.C to your list of files, and define the macro
   ** 'MEMWATCH'. If this is not defined, MEMWATCH will disable itself.
   **
   ** To call the standard C malloc / realloc / calloc / free; use mwMalloc_(),
   ** mwCalloc_() and mwFree_(). Note that mwFree_() will correctly
   ** free both malloc()'d memory as well as mwMalloc()'d.
   **
   ** 980317: C++ support has been disabled.
   **         The code remains, but is not compiled.
   **
   **         For use with C++, which allows use of inlining in header files
   **         and class specific new/delete, you must also define 'new' as
   **         'mwNew' and 'delete' as 'mwDelete'. Do this *after* you include
   **         C++ header files from libraries, otherwise you can mess up their
   **         class definitions. If you don't define these, the C++ allocations
   **         will not have source file and line number information. Also note,
   **         most C++ class libraries implement their own C++ memory management,
   **         and don't allow anyone to override them. MFC belongs to this crew.
   **         In these cases, the only thing to do is to use MEMWATCH_NOCPP.
   **
   ** You can capture output from MEMWATCH using mwSetOutFunc().
   ** Just give it the adress of a "void myOutFunc(int c)" function,
   ** and all characters to be output will be redirected there.
   **
   ** A failing ASSERT() or VERIFY() will normally always abort your
   ** program. This can be changed using mwSetAriFunc(). Give it a
   ** pointer to a "int myAriFunc(const char *)" function. Your function
   ** must ask the user whether to Abort, Retry or Ignore the trap.
   ** Return 2 to Abort, 1 to Retry or 0 to Ignore. Beware retry; it
   ** causes the expression to be evaluated again! MEMWATCH has a
   ** default ARI handler. It's disabled by default, but you can enable
   ** it by calling 'mwDefaultAri()'. Note that this will STILL abort
   ** your program unless you define MEMWATCH_STDIO to allow MEMWATCH
   ** to use the standard C I/O streams. Also, setting the ARI function
   ** will cause MEMWATCH *NOT* to write the ARI error to stderr. The
   ** error string is passed to the ARI function instead, as the
   ** 'const char *' parameter.
   **
   ** You can disable MEMWATCH's ASSERT/VERIFY and/or TRACE implementations.
   ** This can be useful if you're using a debug terminal or smart debugger.
   ** Disable them by defining MW_NOASSERT, MW_NOVERIFY or MW_NOTRACE.
   **
   ** MEMWATCH fills all allocated memory with the byte 0xFE, so if
   ** you're looking at erroneous data which are all 0xFE:s, the
   ** data probably was not initialized by you. The exception is
   ** calloc(), which will fill with zero's. All freed buffers are
   ** zapped with 0xFD. If this is what you look at, you're using
   ** data that has been freed. If this is the case, be aware that
   ** MEMWATCH places a 'free'd block info' structure immediately
   ** before the freed data. This block contains info about where
   ** the block was freed. The information is in readable text,
   ** in the format "FBI<counter>filename(line)", for example:
   ** "FBI<267>test.c(12)". Using FBI's slows down free(), so it's
   ** disabled by default. Use mwFreeBufferInfo(1) to enable it.
   **
   ** To aid in tracking down wild pointer writes, MEMWATCH can perform
   ** no-mans-land allocations. No-mans-land will contain the byte 0xFC.
   ** MEMWATCH will, when this is enabled, convert recently free'd memory
   ** into NML allocations.
   **
   ** MEMWATCH protects it's own data buffers with checksums. If you
   ** get an internal error, it means you're overwriting wildly,
   ** or using an uninitialized pointer.
   **
   ************************************************************************
   **
   ** Note when compiling with Microsoft C:
   **  -   MSC ignores fflush() by default. This is overridden, so that
   **      the disk log will always be current.
   **
   ** This utility has been tested with:
   **  PC-lint 7.0k, passed as 100% ANSI C compatible
   **  Microsoft Visual C++ on Win16 and Win32
   **  Microsoft C on DOS
   **  SAS C on an Amiga 500
   **  Gnu C on a PC running Red Hat Linux
   **  ...and using an (to me) unknown compiler on an Atari machine.
   **
   ************************************************************************
   **
   ** Format of error messages in MEMWATCH.LOG:
   **  message: <sequence-number> filename(linenumber), information
   **
   ** Errors caught by MemWatch, when they are detected, and any
   ** actions taken besides writing to the log file MEMWATCH.LOG:
   **
   **  Double-freeing:
   **      A pointer that was recently freed and has not since been
   **      reused was freed again. The place where the previous free()
   **      was executed is displayed.
   **      Detect: delete or free() using the offending pointer.
   **      Action: The delete or free() is cancelled, execution continues.
   **  Underflow:
   **      You have written just ahead of the allocated memory.
   **      The size and place of the allocation is displayed.
   **      Detect: delete or free() of the damaged buffer.
   **      Action: The buffer is freed, but there may be secondary damage.
   **  Overflow:
   **      Like underflow, but you've written after the end of the buffer.
   **      Detect: see Underflow.
   **      Action: see Underflow.
   **  WILD free:
   **      An unrecognized pointer was passed to delete or free().
   **      The pointer may have been returned from a library function;
   **      in that case, use mwFree_() to force free() of it.
   **      Also, this may be a double-free, but the previous free was
   **      too long ago, causing MEMWATCH to 'forget' it.
   **      Detect: delete or free() of the offending pointer.
   **      Action: The delete or free() is cancelled, execution continues.
   **  NULL free:
   **      It's unclear to me whether or not freeing of NULL pointers
   **      is legal in ANSI C, therefore a warning is written to the log file,
   **      but the error counter remains the same. This is legal using C++,
   **      so the warning does not appear with delete.
   **      Detect: When you free(NULL).
   **      Action: The free() is cancelled.
   **  Failed:
   **      A request to allocate memory failed. If the allocation is
   **      small, this may be due to memory depletion, but is more likely
   **      to be memory fragmentation problems. The amount of memory
   **      allocated so far is displayed also.
   **      Detect: When you new, malloc(), realloc() or calloc() memory.
   **      Action: NULL is returned.
   **  Realloc:
   **      A request to re-allocate a memory buffer failed for reasons
   **      other than out-of-memory. The specific reason is shown.
   **      Detect: When you realloc()
   **      Action: realloc() is cancelled, NULL is returned
   **  Limit fail:
   **      A request to allocate memory failed since it would violate
   **      the limit set using mwLimit(). mwLimit() is used to stress-test
   **      your code under simulated low memory conditions.
   **      Detect: At new, malloc(), realloc() or calloc().
   **      Action: NULL is returned.
   **  Assert trap:
   **      An ASSERT() failed. The ASSERT() macro works like C's assert()
   **      macro/function, except that it's interactive. See your C manual.
   **      Detect: On the ASSERT().
   **      Action: Program ends with an advisory message to stderr, OR
   **              Program writes the ASSERT to the log and continues, OR
   **              Program asks Abort/Retry/Ignore? and takes that action.
   **  Verify trap:
   **      A VERIFY() failed. The VERIFY() macro works like ASSERT(),
   **      but if MEMWATCH is not defined, it still evaluates the
   **      expression, but it does not act upon the result.
   **      Detect: On the VERIFY().
   **      Action: Program ends with an advisory message to stderr, OR
   **              Program writes the VERIFY to the log and continues, OR
   **              Program asks Abort/Retry/Ignore? and takes that action.
   **  Wild pointer:
   **      A no-mans-land buffer has been written into. MEMWATCH can
   **      allocate and distribute chunks of memory solely for the
   **      purpose of trying to catch random writes into memory.
   **      Detect: Always on CHECK(), but can be detected in several places.
   **      Action: The error is logged, and if an ARI handler is installed,
   **              it is executed, otherwise, execution continues.
   **  Unfreed:
   **      A memory buffer you allocated has not been freed.
   **      You are informed where it was allocated, and whether any
   **      over or underflow has occured. MemWatch also displays up to
   **      16 bytes of the data, as much as it can, in hex and text.
   **      Detect: When MemWatch terminates.
   **      Action: The buffer is freed.
   **  Check:
   **      An error was detected during a CHECK() operation.
   **      The associated pointer is displayed along with
   **      the file and line where the CHECK() was executed.
   **      Followed immediately by a normal error message.
   **      Detect: When you CHECK()
   **      Action: Depends on the error
   **  Relink:
   **      After a MEMWATCH internal control block has been trashed,
   **      MEMWATCH tries to repair the damage. If successful, program
   **      execution will continue instead of aborting. Some information
   **      about the block may be gone permanently, though.
   **      Detect: N/A
   **      Action: Relink successful: program continues.
   **              Relink fails: program aborts.
   **  Internal:
   **      An internal error is flagged by MEMWATCH when it's control
   **      structures have been damaged. You are likely using an uninitialized
   **      pointer somewhere in your program, or are zapping memory all over.
   **      The message may give you additional diagnostic information.
   **      If possible, MEMWATCH will recover and continue execution.
   **      Detect: Various actions.
   **      Action: Whatever is needed
   **  Mark:
   **      The program terminated without umarking all marked pointers. Marking
   **      can be used to track resources other than memory. mwMark(pointer,text,...)
   **      when the resource is allocated, and mwUnmark(pointer) when it's freed.
   **      The 'text' is displayed for still marked pointers when the program
   **      ends.
   **      Detect: When MemWatch terminates.
   **      Action: The error is logged.
   **
   **
   ************************************************************************
   **
   **  The author may be reached by e-mail at the address below. If you
   **  mail me about source code changes in MEMWATCH, remember to include
   **  MW's version number.
   **
   **      Johan Lindh
   **      jli@mbox200.swipnet.se
   **
   ** The latest version of MEMWATCH may be downloaded from
   ** http://home1.swipnet.se/~w-10756/
 */

#ifndef __MEMWATCH_H
#define __MEMWATCH_H

/* Make sure that malloc(), realloc(), calloc() and free() are declared. */
/*lint -save -e537 */
#include <stdlib.h>
/*lint -restore */

#ifdef __cplusplus
extern "C" {
#endif


/*
   ** Constants used
   **  All MEMWATCH constants start with the prefix MW_, followed by
   **  a short mnemonic which indicates where the constant is used,
   **  followed by a descriptive text about it.
 */

#define MW_ARI_NULLREAD 0x10	/* Null read (to start debugger) */
#define MW_ARI_ABORT    0x04	/* ARI handler says: abort program! */
#define MW_ARI_RETRY    0x02	/* ARI handler says: retry action! */
#define MW_ARI_IGNORE   0x01	/* ARI handler says: ignore error! */

#define MW_VAL_NEW      0xFE	/* value in newly allocated memory */
#define MW_VAL_DEL      0xFD	/* value in newly deleted memory */
#define MW_VAL_NML      0xFC	/* value in no-mans-land */
#define MW_VAL_GRB      0xFB	/* value in grabbed memory */

#define MW_TEST_ALL     0xFFFF	/* perform all tests */
#define MW_TEST_CHAIN   0x0001	/* walk the heap chain */
#define MW_TEST_ALLOC   0x0002	/* test allocations & NML guards */
#define MW_TEST_NML     0x0004	/* test all-NML areas for modifications */

#define MW_NML_NONE     0	/* no NML */
#define MW_NML_FREE     1	/* turn FREE'd memory into NML */
#define MW_NML_ALL      2	/* all unused memory is NML */
#define MW_NML_DEFAULT  0	/* the default NML setting */

#define MW_STAT_GLOBAL  0	/* only global statistics collected */
#define MW_STAT_MODULE  1	/* collect statistics on a module basis */
#define MW_STAT_LINE    2	/* collect statistics on a line basis */
#define MW_STAT_DEFAULT 0	/* the default statistics setting */

/*
   ** MemWatch internal constants
   **  You may change these and recompile MemWatch to change the limits
   **  of some parameters. Respect the recommended minimums!
 */
#define MW_TRACE_BUFFER 256	/* (min 160) size of TRACE()'s output buffer */
#define MW_FREE_LIST    64	/* (min 4) number of free()'s to track */

/*
   ** Exported variables
   **  In case you have to remove the 'const' keyword because your compiler
   **  doesn't support it, be aware that changing the values may cause
   **  unpredictable behaviour.
   **  - mwCounter contains the current action count. You can use this to
   **      place breakpoints using a debugger, if you want.
 */
#ifndef __MEMWATCH_CPP
	extern const unsigned long mwCounter;
#endif

/*
   ** System functions
   **  Normally, it is not nessecary to call any of these. MEMWATCH will
   **  automatically initialize itself on the first MEMWATCH function call,
   **  and set up a call to mwAbort() using atexit(). Some C++ implementations
   **  run the atexit() chain before the program has terminated, so you
   **  may have to use mwInit() or the MemWatch C++ class to get good
   **  behaviour.
   **  - mwInit() can be called to disable the atexit() usage. If mwInit()
   **      is called directly, you must call mwTerm() to end MemWatch, or
   **      mwAbort().
   **  - mwTerm() is usually not nessecary to call; but if called, it will
   **      call mwAbort() if it finds that it is cancelling the 'topmost'
   **      mwInit() call.
   **  - mwAbort() cleans up after MEMWATCH, reports unfreed buffers, etc.
 */
	void mwInit(void);
	void mwTerm(void);
	void mwAbort(void);

/*
   ** Setup functions
   **  These functions control the operation of MEMWATCH's protective features.
   **  - mwFlushNow() causes MEMWATCH to flush it's buffers.
   **  - mwDoFlush() controls whether MEMWATCH flushes the disk buffers after
   **      writes. The default is smart flushing: MEMWATCH will not flush buffers
   **      explicitly until memory errors are detected. Then, all writes are
   **      flushed until program end or mwDoFlush(0) is called.
   **  - mwLimit() sets the allocation limit, an arbitrary limit on how much
   **      memory your program may allocate in bytes. Used to stress-test app.
   **      Also, in virtual-memory or multitasking environs, puts a limit on
   **      how much MW_NML_ALL can eat up.
   **  - mwGrab() grabs up X kilobytes of memory. Allocates actual memory,
   **      can be used to stress test app & OS both.
   **  - mwDrop() drops X kilobytes of grabbed memory.
   **  - mwNoMansLand() sets the behaviour of the NML logic. See the
   **      MW_NML_xxx for more information. The default is MW_NML_DEFAULT.
   **  - mwStatistics() sets the behaviour of the statistics collector. See
   **      the MW_STAT_xxx defines for more information. Default MW_STAT_DEFAULT.
   **  - mwFreeBufferInfo() enables or disables the tagging of free'd buffers
   **      with freeing information. This information is written in text form,
   **      using sprintf(), so it's pretty slow. Disabled by default.
   **  - mwAutoCheck() performs a CHECK() operation whenever a MemWatch function
   **      is used. Slows down performance, of course.
   **  - mwCalcCheck() calculates checksums for all data buffers. Slow!
   **  - mwDumpCheck() logs buffers where stored & calc'd checksums differ. Slow!!
   **  - mwMark() sets a generic marker. Returns the pointer given.
   **  - mwUnmark() removes a generic marker. If, at the end of execution, some
   **      markers are still in existence, these will be reported as leakage.
   **      returns the pointer given.
 */
	void mwFlushNow(void);
	void mwDoFlush(int onoff);
	void mwLimit(long bytes);
	unsigned mwGrab(unsigned kilobytes);
	unsigned mwDrop(unsigned kilobytes);
	void mwNoMansLand(int mw_nml_level);
	void mwStatistics(int level);
	void mwFreeBufferInfo(int onoff);
	void mwAutoCheck(int onoff);
	void mwCalcCheck(void);
	void mwDumpCheck(void);
	void *mwMark(void *p, const char *description, const char *file, unsigned line);
	void *mwUnmark(void *p, const char *file, unsigned line);

/*
   ** Testing/verification/tracing
   **  All of these macros except VERIFY() evaluates to a null statement
   **  if MEMWATCH is not defined during compilation.
   **  - mwIsReadAddr() checks a memory area for read privilige.
   **  - mwIsSafeAddr() checks a memory area for both read & write privilige.
   **      This function and mwIsReadAddr() is highly system-specific and
   **      may not be implemented. If this is the case, they will default
   **      to returning nonzero for any non-NULL pointer.
   **  - CHECK() does a complete memory integrity test. Slow!
   **  - CHECK_THIS() checks only selected components.
   **  - ASSERT() If the expression evaluates to nonzero, execution continues.
   **      Otherwise, the ARI handler is called, if present. If not present,
   **      the default ARI action is taken (set with mwSetAriAction()).
   **      Can be disabled by defining MW_NOASSERT.
   **  - VERIFY() works just like ASSERT(), but when compiling without
   **      MEMWATCH the macro evaluates to the expression.
   **      Can be disabled by defining MW_NOVERIFY.
   **  - TRACE() writes some text and data to the log. Use like printf().
   **      Note: there is a limit to the maximum resulting string length that
   **      can be written. This defaults to MW_TRACE_BUFFER characters.
   **      Can be disabled by defining MW_NOTRACE.
 */
	int mwIsReadAddr(const void *p, unsigned len);
	int mwIsSafeAddr(void *p, unsigned len);
	int mwTest(const char *file, int line, int mw_test_flags);
	int mwAssert(int, const char *, const char *, int);
	int mwVerify(int, const char *, const char *, int);

/*
   ** User I/O functions
   **  - mwTrace() works like printf(), but dumps output either to the
   **      function specified with mwSetOutFunc(), or the log file.
   **  - mwPuts() works like puts(), dumps output like mwTrace().
   **  - mwSetOutFunc() allows you to give the adress of a function
   **      where all user output will go. (exeption: see mwSetAriFunc)
   **      Specifying NULL will direct output to the log file.
   **  - mwSetAriFunc() gives MEMWATCH the adress of a function to call
   **      when an 'Abort, Retry, Ignore' question is called for. The
   **      actual error message is NOT printed when you've set this adress,
   **      but instead it is passed as an argument. If you call with NULL
   **      for an argument, the ARI handler is disabled again. When the
   **      handler is disabled, MEMWATCH will automatically take the
   **      action specified by mwSetAriAction().
   **  - mwSetAriAction() sets the default ARI return value MEMWATCH should
   **      use if no ARI handler is specified. Defaults to MW_ARI_ABORT.
   **  - mwAriHandler() is an ANSI ARI handler you can use if you like. It
   **      dumps output to stderr, and expects input from stdin.
   **  - mwBreakOut() is called in certain cases when MEMWATCH feels it would
   **      be nice to break into a debugger. If you feel like MEMWATCH, place
   **      an execution breakpoint on this function.
 */
	void mwTrace(const char *format_string,...);
	void mwPuts(const char *text);
	void mwSetOutFunc(void (*func) (int));
	void mwSetAriFunc(int (*func) (const char *));
	void mwSetAriAction(int mw_ari_value);
	int mwAriHandler(const char *cause);
	void mwBreakOut(const char *cause);

/*
   ** Allocation/deallocation functions
   **  These functions are the ones actually to perform allocations
   **  when running MEMWATCH, for both C and C++ calls.
   **  - mwMalloc() debugging allocator
   **  - mwMalloc_() always resolves to a clean call of malloc()
   **  - mwRealloc() debugging re-allocator
   **  - mwRealloc_() always resolves to a clean call of realloc()
   **  - mwCalloc() debugging allocator, fills with zeros
   **  - mwCalloc_() always resolves to a clean call of calloc()
   **  - mwFree() debugging free. Can only free memory which has
   **      been allocated by MEMWATCH.
   **  - mwFree_() resolves to a) normal free() or b) debugging free.
   **      Can free memory allocated by MEMWATCH and malloc() both.
   **      Does not generate any runtime errors.
 */
	void *mwMalloc(size_t, const char *, int);
	void *mwMalloc_(size_t);
	void *mwRealloc(void *, size_t, const char *, int);
	void *mwRealloc_(void *, size_t);
	void *mwCalloc(size_t, size_t, const char *, int);
	void *mwCalloc_(size_t, size_t);
	void mwFree(void *, const char *, int);
	void mwFree_(void *);
	char *mwStrdup(char *, const char *, int);

/*
   ** Enable/disable precompiler block
   **  This block of defines and if(n)defs make sure that references
   **  to MEMWATCH is completely removed from the code if the MEMWATCH
   **  manifest constant is not defined.
 */
#ifndef __MEMWATCH_CPP
#ifdef MEMWATCH

#ifndef MW_NOASSERT
#ifdef ASSERT
#undef ASSERT
#endif				/* ASSERT */
#define ASSERT(exp)     while(mwAssert((int)(exp),#exp,__FILE__,__LINE__))
#endif				/* !MW_NOASSERT */

#ifndef MW_NOVERIFY
#ifdef VERIFY
#undef VERIFY
#endif				/* VERIFY */
#define VERIFY(exp)     while(mwVerify((int)(exp),#exp,__FILE__,__LINE__))
#endif				/* !MW_NOVERIFY */

#ifndef MW_NOTRACE
#ifdef TRACE
#undef TRACE
#endif				/* TRACE */
#define TRACE           mwTrace
#endif				/* !MW_NOTRACE */

#define malloc(n)       mwMalloc(n,__FILE__,__LINE__)
#define strdup(p)       mwStrdup(p,__FILE__,__LINE__)
#define realloc(p,n)    mwRealloc(p,n,__FILE__,__LINE__)
#define calloc(n,m)     mwCalloc(n,m,__FILE__,__LINE__)
#define free(p)         mwFree(p,__FILE__,__LINE__)
#define CHECK()         mwTest(__FILE__,__LINE__,MW_TEST_ALL)
#define CHECK_THIS(n)   mwTest(__FILE__,__LINE__,n)
#define MARK(p)         mwMark(p,#p,__FILE__,__LINE__)
#define UNMARK(p)       mwUnmark(p,__FILE__,__LINE__)

#else				/* MEMWATCH */

#ifndef MW_NOASSERT
#ifdef ASSERT
#undef ASSERT
#endif				/* ASSERT */
#define ASSERT(exp)
#endif				/* !MW_NOASSERT */

#ifndef MW_NOVERIFY
#ifdef VERIFY
#undef VERIFY
#endif				/* VERIFY */
#define VERIFY(exp)     exp
#endif				/* !MW_NOVERIFY */

#ifndef MW_NOTRACE
#ifdef TRACE
#undef TRACE
#endif				/* TRACE */
/*lint -esym(773,TRACE) */
#define TRACE           /*lint -save -e506 */ 1?(void)0:mwDummyTraceFunction	/*lint -restore */
#endif				/* !MW_NOTRACE */

	extern void mwDummyTraceFunction(const char *,...);
/*lint -save -e652 */
#define mwDoFlush(n)
#define mwPuts(s)
#define mwInit()
#define mwGrab(n)
#define mwDrop(n)
#define mwLimit(n)
#define mwTest(f,l)
#define mwSetOutFunc(f)
#define mwSetAriFunc(f)
#define mwDefaultAri()
#define mwNomansland()
#define mwStatistics(f)
#define mwMark(p,t,f,n)     (p)
#define mwUnmark(p,f,n)     (p)
#define mwMalloc(n,f,l)     malloc(n)
#define mwStrdup(p,f,l)     strdup(p)
#define mwRealloc(p,n,f,l)  realloc(p,n)
#define mwCalloc(n,m,f,l)   calloc(n,m)
#define mwFree(p)           free(p)
#define mwMalloc_(n)        malloc(n)
#define mwRealloc_(p,n)     realloc(p,n)
#define mwCalloc_(n,m)      calloc(n,m)
#define mwFree_(p)          free(p)
#define mwAssert(e,es,f,l)
#define mwVerify(e,es,f,l)  (e)
#define mwTrace             mwDummyTrace
#define CHECK()
#define CHECK_THIS(n)
#define MARK(p)             (p)
#define UNMARK(p)           (p)
/*lint -restore */

#endif				/* MEMWATCH */
#endif				/* !__MEMWATCH_CPP */

#ifdef __cplusplus
}

#endif
#if 0				/* 980317: disabled C++ *//*
				   ** C++ support section
				   **  Implements the C++ support. Please note that in order to avoid
				   **  messing up library classes, C++ support is disabled by default.
				   **  You must NOT enable it until AFTER the inclusion of all header
				   **  files belonging to code that are not compiled with MEMWATCH, and
				   **  possibly for some that are! The reason for this is that a C++
				   **  class may implement it's own new() function, and the preprocessor
				   **  would substitute this crucial declaration for MEMWATCH new().
				   **  You can forcibly deny C++ support by defining MEMWATCH_NOCPP.
				   **  To enble C++ support, you must be compiling C++, MEMWATCH must
				   **  be defined, MEMWATCH_NOCPP must not be defined, and finally,
				   **  you must define 'new' to be 'mwNew', and 'delete' to be 'mwDelete'.
				   **  Unlike C, C++ code can begin executing *way* before main(), for
				   **  example if a global variable is created. For this reason, you can
				   **  declare a global variable of the class 'MemWatch'. If this is
				   **  is the first variable created, it will then check ALL C++ allocations
				   **  and deallocations. Unfortunately, this evaluation order is not
				   **  guaranteed by C++, though the compilers I've tried evaluates them
				   **  in the order encountered.
				 */
#ifdef __cplusplus
#ifndef __MEMWATCH_CPP
#ifdef MEMWATCH
#ifndef MEMWATCH_NOCPP extern int mwNCur;
extern const char *mwNFile;
extern int mwNLine;
class MemWatch {
	public:
	MemWatch();
	~MemWatch();
};
void *operator new(size_t);
void *operator new(size_t, const char *, int);
void operator delete(void *);
#define mwNew new(__FILE__,__LINE__)
#define mwDelete (mwNCur=1,mwNFile=__FILE__,mwNLine=__LINE__),delete
#endif				/* MEMWATCH_NOCPP */
#endif				/* MEMWATCH */
#endif				/* !__MEMWATCH_CPP */
#endif				/* __cplusplus */

#endif				/* 980317: disabled C++ */

#endif				/* __MEMWATCH_H */

/* EOF MEMWATCH.H */