#ifndef __LYLEAKS_H /* * Avoid include redundancy * Include only if finding memory leaks. */ #define __LYLEAKS_H /* ** Copyright (c) 1994, University of Kansas, All Rights Reserved ** ** Include File: LYLeaks.h ** Purpose: Header to convert requests for allocation to Lynx ** custom functions to track memory leaks. ** Remarks/Portability/Dependencies/Restrictions: ** For the stdlib.h allocation functions to be overriden by the ** Lynx memory tracking functions all modules allocating, ** freeing, or resizing memory must have LY_FIND_LEAKS ** defined before including this file. ** This header file should be included in every source file which ** does any memory manipulation through use of the ** stdlib.h memory functions. ** For proper reporting of memory leaks, the function LYLeaks ** should be registered for execution by atexit as the ** very first executable statement in main. ** This code is slow and should not be used except in debugging ** circumstances (don't define LY_FIND_LEAKS). ** If you are using LY_FIND_LEAKS and don't want the LYLeak* ** memory functions to be used in a certain file, ** define NO_MEMORY_TRACKING before including this file. ** The only safe way to call the LYLeak* functions is to use ** the below macros because they depend on the static ** string created by __FILE__ to not be dynamic in ** nature (don't free it and assume will exist at all ** times during execution). ** If you are using LY_FIND_LEAKS and LY_FIND_LEAKS_EXTENDED and ** want only normal memory tracking (not extended for ** HTSprintf/HTSprintf0) to be used in a certain file, ** define NO_EXTENDED_MEMORY_TRACKING and don't define ** NO_MEMORY_TRACKING before including this file. ** Revision History: ** 05-26-94 created for Lynx 2-3-1, Garrett Arch Blythe ** 10-30-97 modified to handle StrAllocCopy() and ** StrAllocCat(). - KW & FM ** 1999-10-17 modified to handle HTSprintf0 and HTSprintf(), ** and to provide mark_malloced, if ** LY_FIND_LEAKS_EXTENDED is defined. - kw */ /* Undefine this to get no improved HTSprintf0/HTSprintf tracking: */ #define LY_FIND_LEAKS_EXTENDED /* ** Required includes */ #ifndef HTUTILS_H #include #endif /* ** Constant defines */ #define MAX_CONTENT_LENGTH 50 #ifdef VMS #define LEAKAGE_SINK "sys$login:Lynx.leaks" #else #define LEAKAGE_SINK "Lynx.leaks" #endif /* VMS */ /* ** Data structures */ typedef struct SourceLocation_tag { /* * The file name and line number of where an event took place. */ CONST char *cp_FileName; short ssi_LineNumber; } SourceLocation; typedef struct AllocationList_tag { /* * A singly linked list. */ struct AllocationList_tag *ALp_Next; /* * The memory pointer allocated. * If set to NULL, then an invalid request was made. * The invalid pointer also. */ void *vp_Alloced; void *vp_BadRequest; /* * The size in bytes of the allocated memory. */ size_t st_Bytes; /* * The source location of specific event (calloc, malloc, free). * realloc kept separate since will track last realloc on pointer. */ SourceLocation SL_memory; SourceLocation SL_realloc; } AllocationList; /* ** Global variable declarations */ /* ** Macros */ #if defined(LY_FIND_LEAKS) && !defined(NO_MEMORY_TRACKING) /* ** Only use these macros if we are to track memory allocations. ** The reason for using a macro instead of a define is that we want ** to track where the initial allocation took place or where ** the last reallocation took place. ** Track where the allocation took place by the __FILE__ and __LINE__ ** defines which are automatic to the compiler. */ #ifdef malloc #undef malloc #endif /* malloc */ #define malloc(st_bytes) LYLeakMalloc(st_bytes, __FILE__, __LINE__) #ifdef calloc #undef calloc #endif /* calloc */ #define calloc(st_number, st_bytes) LYLeakCalloc(st_number, st_bytes, \ __FILE__, __LINE__) #ifdef realloc #undef realloc #endif /* realloc */ #define realloc(vp_alloced, st_newbytes) LYLeakRealloc(vp_alloced, \ st_newbytes, __FILE__, __LINE__) #ifdef free #undef free #endif /* free */ #define free(vp_alloced) LYLeakFree(vp_alloced, __FILE__, __LINE__) /* ** Added the following two defines to track Lynx's frequent use ** of those macros. - KW 1997-10-12 */ #ifdef StrAllocCopy #undef StrAllocCopy #endif /* StrAllocCopy */ #define StrAllocCopy(dest, src) LYLeakSACopy(&(dest), src, __FILE__, __LINE__) #ifdef StrAllocCat #undef StrAllocCat #endif /* StrAllocCat */ #define StrAllocCat(dest, src) LYLeakSACat(&(dest), src, __FILE__, __LINE__) #define mark_malloced(a,size) LYLeak_mark_malloced(a,size, __FILE__, __LINE__) #if defined(LY_FIND_LEAKS_EXTENDED) && !defined(NO_EXTENDED_MEMORY_TRACKING) #ifdef HTSprintf0 #undef HTSprintf0 #endif /* HTSprintf0 */ #define HTSprintf0 (Get_htsprintf0_fn(__FILE__,__LINE__)) #ifdef HTSprintf #undef HTSprintf #endif /* HTSprintf */ #define HTSprintf (Get_htsprintf_fn(__FILE__,__LINE__)) #endif /* LY_FIND_LEAKS_EXTENDED and not NO_EXTENDED_MEMORY_TRACKING */ #else /* LY_FIND_LEAKS && !NO_MEMORY_TRACKING */ #define mark_malloced(a,size) /* no-op */ #endif /* LY_FIND_LEAKS && !NO_MEMORY_TRACKING */ #if defined(LY_FIND_LEAKS) #define PUBLIC_IF_FIND_LEAKS PUBLIC #else #define PUBLIC_IF_FIND_LEAKS PRIVATE #endif /* ** Function declarations ** See the appropriate source file for usage. */ extern void LYLeaks NOPARAMS; #ifdef LY_FIND_LEAKS_EXTENDED extern AllocationList *LYLeak_mark_malloced PARAMS(( void * vp_alloced, size_t st_bytes, CONST char * cp_File, CONST short ssi_Line)); #endif /* LY_FIND_LEAKS_EXTENDED */ extern void *LYLeakMalloc PARAMS(( size_t st_bytes, CONST char * cp_File, CONST short ssi_Line)); extern void *LYLeakCalloc PARAMS(( size_t st_number, size_t st_bytes, CONST char * cp_File, CONST short ssi_Line)); extern void *LYLeakRealloc PARAMS(( void * vp_alloced, size_t st_newbytes, CONST char * cp_File, CONST short ssi_Line)); extern void LYLeakFree PARAMS(( void * vp_alloced, CONST char * cp_File, CONST short ssi_Line)); extern char * LYLeakSACopy PARAMS(( char ** dest, CONST char * src, CONST char * cp_File, CONST short ssi_Line)); extern char * LYLeakSACat PARAMS(( char ** dest, CONST char * src, CONST char * cp_File, CONST short ssi_Line)); #ifdef LY_FIND_LEAKS_EXTENDED /* Trick to get tracking of var arg functions without relying on var arg preprocessor macros: */ typedef char * HTSprintflike PARAMS((char **, CONST char *, ...)); extern HTSprintflike *Get_htsprintf_fn PARAMS(( CONST char * cp_File, CONST short ssi_Line)); extern HTSprintflike *Get_htsprintf0_fn PARAMS(( CONST char * cp_File, CONST short ssi_Line)); #endif /* LY_FIND_LEAKS_EXTENDED */ #endif /* __LYLEAKS_H */