home *** CD-ROM | disk | FTP | other *** search
/ POINT Software Programming / PPROG1.ISO / c / snippets / jnew.cpp < prev    next >
C/C++ Source or Header  |  1995-03-13  |  4KB  |  131 lines
  1. /*--------------------------------------------------------------*/
  2. /* Debugging extension by Jeff Dunlop                           */
  3. /* Copyright 1992-1993, DB/Soft Publishing Co.                  */
  4. /* License is hereby granted for use of JMalloc as a debugging  */
  5. /* aid in any program.  JMalloc may not be sold or distributed  */
  6. /* as or part of any for-profit debugging program or library    */
  7. /* nor may it be included in any for-profit library that offers */
  8. /* debugging features.  Any redistribution of JMalloc source    */
  9. /* must include this copyright notice.                          */
  10. /*--------------------------------------------------------------*/
  11.  
  12. /*--------------------------------------------------------------*/
  13. /* Usage:                                                       */
  14. /*  If you want line number information available on your       */
  15. /*  allocated memory blocks, your new and delete calls have to  */
  16. /*  be replaced with NEW() and DELETE() macro calls.  This is   */
  17. /*  not absolutely required but finding where an orphaned block */
  18. /*  was allocated is much easier if the line information can be */
  19. /*  saved.  Otherwise, JNew is a drop-in replacement for        */
  20. /*  operators new and delete.                                   */
  21. /*                                                              */
  22. /*  If you compile jnew.cpp and jmalloc.c into .obj files, your */
  23. /*  linker will find jnew's operator new before that in the     */
  24. /*  standard library.  If you store jnew.obj and jmalloc.obj in */
  25. /*  a library file, that library must appear in your list       */
  26. /*  before the standard library or the linker will link in the  */
  27. /*  standard library's operator new.  Define DBUG to turn on    */
  28. /*  line numbers.  Undefine DBUG and remove the jnew binaries   */
  29. /*  from your linker list to disable.                           */
  30. /*                                                              */
  31. /*  There is a bit of memory overhead involved in having        */
  32. /*  diagnostic information stored for every allocated block.    */
  33. /*  Depending on your compiler, this can run from 30 bytes per  */
  34. /*  block with Borland C++ to 50+ bytes per block for C Set/2.  */
  35. /*  If your compiler supports duplicate string merging and your */
  36. /*  program won't break using it, file information stored in    */
  37. /*  the static data area will be compressed.                    */
  38. /*  If memory is tight and you want to use jnew on a            */
  39. /*  file-by-file basis you will need to redefine the NEW and    */
  40. /*  DELETE macros to use a different operator and rename        */
  41. /*  operators new and delete in jnew.cpp.  Performance doesn't  */
  42. /*  take much of a hit unless you have a LOT of small allocated */
  43. /*  blocks floating around most of the time.  Then, searching   */
  44. /*  the diagnostic list can become significant.                 */
  45. /*--------------------------------------------------------------*/
  46.  
  47. #define DBUG
  48.  
  49. #include <stdlib.h>
  50. #include <string.h>
  51.  
  52. #include <new.h>
  53.  
  54. #include <jmalloc.h>
  55.  
  56. static char *db_file;
  57. static int db_line;
  58.  
  59. void db_set(char *file, int line)
  60. {
  61.     if ( db_file )
  62.         free(db_file)
  63.     db_file = strdup(file);
  64.     db_line = line;
  65. }
  66.  
  67. void *operator new(size_t n)
  68. {
  69.     void *q;
  70.  
  71.     while ( (q = j_malloc(n, db_file, db_line)) == NULL )
  72.     {
  73.         if ( _new_handler )
  74.         {
  75.             _new_handler();
  76.         }
  77.         else
  78.             return NULL;
  79.     }
  80.     return q;
  81. }
  82.  
  83. void operator delete(void *p)
  84. {
  85.     j_free(p, db_file, db_line);
  86. }
  87.  
  88. #ifdef TESTPP
  89.  
  90. int main(void)
  91. {
  92.     char *n,
  93.          *p,
  94.          *q,
  95.          r[30],
  96.          *s[256] = {NULL};
  97.     int i = 1;
  98.  
  99.     n = NEW(char[64 * 56]);
  100.     JStrCpy(n + 10, "Test string");
  101.     DBUG_PRINT("alloc", ("r is invalid"));
  102.     JStrCpy(r, "Test");
  103.     q = NEW(char[16]);
  104.     q[16] = 3;
  105.  
  106.     DBUG_PRINT("alloc", ("p was never allocated"));
  107.     DELETE(p);
  108.  
  109.     i = 0;
  110.  
  111.     DBUG_PRINT("alloc", ("Deplete memory"));
  112.     do
  113.     {
  114.         s[i] = NEW(char[32000]);
  115.         i++;
  116.     } while ( s[i - 1] != NULL );
  117.  
  118.     i = 0;
  119.     while ( s[i] != NULL )
  120.     {
  121.         DELETE(s[i++]);
  122.     }
  123.  
  124.     DBUG_PRINT("alloc", ("New and q are orphaned blocks"));
  125.     DBUG_PRINT("alloc", ("q has an overrun"));
  126.     JMemcheck(1);
  127.     return 0;
  128. }
  129.  
  130. #endif
  131.