code_c/Maasha/src/lib/mem.c

   1 #include "common.h"
   2 #include "mem.h"
   3
   4
   5 void *mem_get( size_t size )
   6 {
   7     /* Martin A. Hansen, May 2008 */
   8
   9     /* Unit test done.*/
  10
  11     /* Allocate a given chunk of memory to a pointer that is returned. */
  12
  13     void *pt;
  14
  15     assert( size > 0 );
  16
  17     if ( ( pt = malloc( size ) ) == NULL )
  18     {
  19         fprintf( stderr, "ERROR: Could not allocate %ld byte(s): %s\n", size, strerror( errno ) );
  20         abort();
  21     }
  22
  23     return pt;
  24 }
  25
  26
  27 void *mem_get_zero( size_t size )
  28 {
  29     /* Martin A. Hansen, May 2008 */
  30
  31     /* Unit test done.*/
  32
  33     /* Allocate a given chunk of zero'ed memory to a pointer that is returned. */
  34
  35     void *pt;
  36
  37     assert( size > 0 );
  38
  39     pt = mem_get( size );
  40
  41     memset( pt, '\0', size );
  42
  43     return pt;
  44 }
  45
  46
  47 void *mem_resize( void *pt, size_t size )
  48 {
  49     /* Martin A. Hansen, May 2008 */
  50
  51     /* Resize an allocated chunk of memory for a given pointer and new size. */
  52
  53     void *pt_new;
  54
  55     if ( size == 0 ) {
  56         die( "could not re-allocate 0 bytes of memory." );
  57     } else if ( ( pt_new = realloc( pt, size ) ) == NULL ) {
  58         die( "could not re-allocate memory." );
  59     }
  60
  61     return pt_new;
  62 }
  63
  64
  65 void *mem_resize_zero( void *pt, size_t old_size, size_t new_size )
  66 {
  67     /* Martin A. Hansen, May 2008 */
  68
  69     /* Resize an allocated chunk of memory for a given pointer and zero any extra memory. */
  70
  71     void *pt_new;
  72
  73     pt_new = mem_resize( pt, new_size );
  74
  75     if ( new_size > old_size ) {
  76         memset( ( ( void * ) pt_new ) + old_size, '\0', new_size - old_size );
  77     }
  78
  79     return pt_new;
  80 }
  81
  82
  83 void *mem_clone( void *old_pt, size_t size )
  84 {
  85     /* Martin A. Hansen, June 2008 */
  86
  87     /* Clone a structure in memory and return a pointer to the clone. */
  88
  89     void *new_pt;
  90
  91     new_pt = mem_get( size );
  92
  93     memcpy( new_pt, old_pt, size );
  94
  95     return new_pt;
  96 }
  97
  98
  99 void mem_free( void *pt )
 100 {
 101     /* Martin A. Hansen, May 2008 */
 102
 103     /* Free memory from a given pointer. */
 104
 105     if ( pt != NULL )
 106     {
 107         free( pt );
 108
 109         pt = NULL;
 110     }
 111 }
 112
 113
 114 void mem_free_zero( void *pt )
 115 {
 116     /* Martin A. Hansen, July 2008 */
 117
 118     /* Zero and then free memory from a given pointer. */
 119
 120     if ( pt != NULL )
 121     {
 122         MEM_ZERO( pt );
 123         free( pt );
 124
 125         pt = NULL;
 126     }
 127 }
 128
 129