// This may look like C code, but it is really -*- C++ -*- // ------------------------------------------------------------------ // The Goldware Library // Copyright (C) 1990-1999 Odinn Sorensen // Copyright (C) 2000 Alexander S. Aganichev // ------------------------------------------------------------------ // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Library General Public // License as published by the Free Software Foundation; either // version 2 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Library General Public License for more details. // // You should have received a copy of the GNU Library General Public // License along with this program; if not, write to the Free // Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, // MA 02111-1307, USA // ------------------------------------------------------------------ // $Id$ // ------------------------------------------------------------------ // Memory management routines with debugging features. // Based on free code from SNIPPETS 9404 by Walter Bright. // ------------------------------------------------------------------ #ifndef __gdbgtmem_h #define __gdbgtmem_h // ------------------------------------------------------------------ #include // ------------------------------------------------------------------ // Global variables extern int throw_alloc_extra; #if defined(GTHROW_LOG) class glog; extern glog* throw_log; #endif // ------------------------------------------------------------------ // Prototypes void throw_init(); void throw_check(); void throw_checkptr(void* ptr); char* throw_strdup(const char* str); void* throw_malloc(size_t size); void* throw_calloc(size_t items, size_t size); void* throw_realloc(void* ptr, size_t size); void throw_free(void* ptr); char* throw_xstrdup(const char* str); void* throw_xmalloc(size_t size); void* throw_xcalloc(size_t items, size_t size); void* throw_xrealloc(void* ptr, size_t size); void throw_xfree(void* ptr); void* throw_outofmem(); void* throw_outofmem_report(const char* file, int line); // ------------------------------------------------------------------ // Debugging prototypes void throw_new_debug(const void* ptr, const char* file, int line); char* throw_strdup_debug(const char* str, const char* file, int line); void* throw_malloc_debug(size_t size, const char* file, int line); void* throw_calloc_debug(size_t items, size_t size, const char* file, int line); void* throw_realloc_debug(void* ptr, size_t size, const char* file, int line); void throw_free_debug(void* ptr, const char* file, int line); void throw_check_debug(const char* file, int line); void throw_checkptr_debug(const void* ptr, const char* file, int line); void throw_xnew_debug(void* ptr, const char* file, int line); char* throw_xstrdup_debug(const char* str, const char* file, int line); void* throw_xmalloc_debug(size_t size, const char* file, int line); void* throw_xcalloc_debug(size_t items, size_t size, const char* file, int line); void* throw_xrealloc_debug(void* ptr, size_t size, const char* file, int line); void throw_xfree_debug(void* ptr, const char* file, int line); // ------------------------------------------------------------------ // Macro functions #if defined(GTHROW_DEBUG) # define throw_new(p) throw_new_debug((p),__FILE__,__LINE__) # define throw_alloc(p) throw_new_debug((p),__FILE__,__LINE__) # define throw_strdup(p) throw_strdup_debug((p),__FILE__,__LINE__) # define throw_malloc(s) throw_malloc_debug((s),__FILE__,__LINE__) # define throw_calloc(i,s) throw_calloc_debug((i),(s),__FILE__,__LINE__) # define throw_realloc(p,s) throw_realloc_debug((p),(s),__FILE__,__LINE__) # define throw_free(p) throw_free_debug((p),__FILE__,__LINE__) # define throw_check() throw_check_debug(__FILE__,__LINE__) # define throw_checkptr(p) throw_checkptr_debug((p),__FILE__,__LINE__) #else # define throw_new(p) throw_xnew_debug((p),__FILE__,__LINE__) # define throw_alloc(p) throw_xnew_debug((p),__FILE__,__LINE__) # define throw_strdup(p) throw_xstrdup_debug((p),__FILE__,__LINE__) # define throw_malloc(s) throw_xmalloc_debug((s),__FILE__,__LINE__) # define throw_calloc(i,s) throw_xcalloc_debug((i),(s),__FILE__,__LINE__) # define throw_realloc(p,s) throw_xrealloc_debug((p),(s),__FILE__,__LINE__) # define throw_free(p) throw_xfree_debug((p),__FILE__,__LINE__) # define throw_check() # define throw_checkptr(p) # define throw_init() #endif #define throw_xnew(p) throw_xnew_debug((p),__FILE__,__LINE__) #define throw_xstrdup(p) throw_xstrdup_debug((p),__FILE__,__LINE__) #define throw_xmalloc(s) throw_xmalloc_debug((s),__FILE__,__LINE__) #define throw_xcalloc(i,s) throw_xcalloc_debug((i),(s),__FILE__,__LINE__) #define throw_xrealloc(p,s) throw_xrealloc_debug((p),(s),__FILE__,__LINE__) #define throw_xfree(p) throw_xfree_debug((p),__FILE__,__LINE__) // ------------------------------------------------------------------ // Special purpose macros #define throw_release(m) { throw_free(m); (m) = NULL; } #define throw_xrelease(m) { throw_xfree(m); (m) = NULL; } #define throw_delete(p) { delete (p); (p) = NULL; } #define throw_xdelete(p) { if(p) delete (p); (p) = NULL; } #define throw_deletearray(p) { delete[] (p); (p) = NULL; } #define throw_xdeletearray(p) { if(p) delete[] (p); (p) = NULL; } #define throw_mallox(__items, __size, __cache) throw_malloc((__items+__cache+1)*__size) #define throw_callox(__items, __size, __cache) throw_calloc(__items+__cache+1, __size) #define throw_reallox(__ptr, __items, __size, __cache) (((__items % __cache) and __ptr) ? (void*)__ptr : throw_realloc(__ptr, (__items+__cache+1)*__size)); #define throw_xmallox(__items, __size, __cache) throw_xmalloc((__items+__cache+1)*__size) #define throw_xcallox(__items, __size, __cache) throw_xcalloc(__items+__cache+1, __size) #define throw_xreallox(__ptr, __items, __size, __cache) (((__items % __cache) and __ptr) ? (void*)__ptr : throw_xrealloc(__ptr, (__items+__cache+1)*__size)); // ------------------------------------------------------------------ #if defined(GTHROWCHKPTR_ENABLE) # define THROW_CHECKPTR(p) throw_checkptr(p) # define THROW_CHECK() throw_check() #else # define THROW_CHECKPTR(p) # define THROW_CHECK() #endif // ------------------------------------------------------------------ #endif // ------------------------------------------------------------------