kc3-lang/freetype/builds/ansi/memdebug.c

• Show log

  Commit

• Hash : 74043010
  Author :
  Date : 2000-07-08T00:22:20
  

  renaming "freetype2/config" to "freetype2/builds"

Download

• builds/ansi/memdebug.c

• /***************************************************************************/
  /*                                                                         */
  /*  memdebug.c                                                             */
  /*                                                                         */
  /*    Memory debugging functions (body only).                              */
  /*                                                                         */
  /*  Copyright 1996-1999 by                                                 */
  /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
  /*                                                                         */
  /*  This file is part of the FreeType project, and may only be used        */
  /*  modified and distributed under the terms of the FreeType project       */
  /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  /*  this file you indicate that you have read the license and              */
  /*  understand and accept it fully.                                        */
  /*                                                                         */
  /***************************************************************************/
  
  
  #include <stdio.h>
  #include <stdlib.h>
  
  
    typedef struct  TBlockRec_
    {
      char*  base;
      long   size;
  
    } TBlockRec;
  
  
    static TBlockRec*  mem_blocks;
    static int         num_mem_blocks;
    static int         max_mem_blocks;
  
  
    void  DM_Init_Mem()
    {
      num_mem_blocks = 0;
      max_mem_blocks = 4096;
      mem_blocks     = (TBlockRec*)malloc( max_mem_blocks *
                                           sizeof ( *mem_blocks ) );
    }
  
  
    void  DM_Done_Mem()
    {
      /* Now print the remaining blocks */
      if ( num_mem_blocks == 0 )
      {
        fprintf( stderr, "No memory leaked!\n" );
      }
      else
      {
        int  i;
  
  
        fprintf( stderr, "There were %d leaked memory blocks\n\n",
                 num_mem_blocks );
  
        fprintf( stderr, "base     size\n" );
        fprintf( stderr, "------------------\n" );
  
        for ( i = 0; i < num_mem_blocks; i++ )
        {
          fprintf( stderr, "%08lx  %04lx\n", 
                   (long)mem_blocks[i].base, mem_blocks[i].size );
        }
      }
      free( mem_blocks );
    }
  
  
    void  DM_Record( char*  base,
                     long   size )
    {
      TBlockRec*  block;
  
  
  #if 0
      /* First, check that the block is not located within one of the */
      /* recorded blocks                                              */
      for ( i = 0; i < num_mem_blocks; i++ )
      {
        char  *start, *end, *_limit, *_base;
  
  
        _base  = mem_blocks[i].base;
        _limit = _base + mem_blocks[i].size;
  
        start = base;
        end   = base + size - 1;
  
        if ( ( start >= base && start < limit ) ||
             ( end >= base && end < limit )     )
        {
          fprintf( stderr, "Warning: Recording an invalid block!\n" );
        }
      }
  #endif
  
      /* Add block to list */
      if ( num_mem_blocks >= max_mem_blocks )
      {
        max_mem_blocks *= 2;
        mem_blocks = realloc( mem_blocks,
                              max_mem_blocks * sizeof ( *mem_blocks ) );
      }
      block = mem_blocks + num_mem_blocks;
      block->base = base;
      block->size = size;
      num_mem_blocks++;
    }
  
  
    void  DM_Forget( char*  base )
    {
      TBlockRec*  block = mem_blocks;
      int         i;
  
  
      for ( i = 0; i < num_mem_blocks; i++, block++ )
      {
        if ( block->base == base )
        {
          /* simply move last block to the current position */
          if ( num_mem_blocks > 1 )
            *block = mem_blocks[num_mem_blocks - 1];
  
          num_mem_blocks--;
          return;
        }
  
  #if 1
        if ( base >= block->base && base < block->base + block->size )
        {
          fprintf( stderr, "Invalid block forgotten!\n" );
        }
  #endif
      }
    }
  
  
  /* END */
  

Download