mono/eglib/gmem.c

   1 /*
   2  * gmem.c: memory utility functions
   3  *
   4  * Author:
   5  *      Gonzalo Paniagua Javier (gonzalo@novell.com)
   6  *
   7  * (C) 2006 Novell, Inc.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining
  10  * a copy of this software and associated documentation files (the
  11  * "Software"), to deal in the Software without restriction, including
  12  * without limitation the rights to use, copy, modify, merge, publish,
  13  * distribute, sublicense, and/or sell copies of the Software, and to
  14  * permit persons to whom the Software is furnished to do so, subject to
  15  * the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be
  18  * included in all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27  */
  28 #include <config.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <glib.h>
  32 #include <eglib-remap.h> // Remove the cast macros and restore the rename macros.
  33 #undef malloc
  34 #undef realloc
  35 #undef free
  36 #undef calloc
  37
  38 #if defined (ENABLE_OVERRIDABLE_ALLOCATORS)
  39
  40 static GMemVTable sGMemVTable = { malloc, realloc, free, calloc };
  41
  42 void
  43 g_mem_set_vtable (GMemVTable* vtable)
  44 {
  45         sGMemVTable.calloc = vtable->calloc ? vtable->calloc : calloc;
  46         sGMemVTable.realloc = vtable->realloc ? vtable->realloc : realloc;
  47         sGMemVTable.malloc = vtable->malloc ? vtable->malloc : malloc;
  48         sGMemVTable.free = vtable->free ? vtable->free : free;
  49 }
  50
  51 void
  52 g_mem_get_vtable (GMemVTable* vtable)
  53 {
  54         *vtable = sGMemVTable;
  55 }
  56
  57 #define G_FREE_INTERNAL sGMemVTable.free
  58 #define G_REALLOC_INTERNAL sGMemVTable.realloc
  59 #define G_CALLOC_INTERNAL sGMemVTable.calloc
  60 #define G_MALLOC_INTERNAL sGMemVTable.malloc
  61 #else
  62
  63 void
  64 g_mem_get_vtable (GMemVTable* vtable)
  65 {
  66         memset (vtable, 0, sizeof (*vtable));
  67 }
  68
  69 void
  70 g_mem_set_vtable (GMemVTable* vtable)
  71 {
  72 }
  73
  74 #define G_FREE_INTERNAL free
  75 #define G_REALLOC_INTERNAL realloc
  76 #define G_CALLOC_INTERNAL calloc
  77 #define G_MALLOC_INTERNAL malloc
  78 #endif
  79 void
  80 g_free (void *ptr)
  81 {
  82         if (ptr != NULL)
  83                 G_FREE_INTERNAL (ptr);
  84 }
  85
  86 gpointer
  87 g_memdup (gconstpointer mem, guint byte_size)
  88 {
  89         gpointer ptr;
  90
  91         if (mem == NULL)
  92                 return NULL;
  93
  94         ptr = g_malloc (byte_size);
  95         if (ptr != NULL)
  96                 memcpy (ptr, mem, byte_size);
  97
  98         return ptr;
  99 }
 100
 101 gpointer g_realloc (gpointer obj, gsize size)
 102 {
 103         gpointer ptr;
 104         if (!size) {
 105                 g_free (obj);
 106                 return 0;
 107         }
 108         ptr = G_REALLOC_INTERNAL (obj, size);
 109         if (ptr)
 110                 return ptr;
 111         g_error ("Could not allocate %i bytes", size);
 112 }
 113
 114 gpointer
 115 g_malloc (gsize x)
 116 {
 117         gpointer ptr;
 118         if (!x)
 119                 return 0;
 120         ptr = G_MALLOC_INTERNAL (x);
 121         if (ptr)
 122                 return ptr;
 123         g_error ("Could not allocate %i bytes", x);
 124 }
 125
 126 gpointer g_calloc (gsize n, gsize x)
 127 {
 128         gpointer ptr;
 129         if (!x || !n)
 130                 return 0;
 131         ptr = G_CALLOC_INTERNAL (n, x);
 132         if (ptr)
 133                 return ptr;
 134         g_error ("Could not allocate %i (%i * %i) bytes", x*n, n, x);
 135 }
 136 gpointer g_malloc0 (gsize x)
 137 {
 138         return g_calloc (1,x);
 139 }
 140
 141 gpointer g_try_malloc (gsize x)
 142 {
 143         if (x)
 144                 return G_MALLOC_INTERNAL (x);
 145         return 0;
 146 }
 147
 148
 149 gpointer g_try_realloc (gpointer obj, gsize size)
 150 {
 151         if (!size) {
 152                 G_FREE_INTERNAL (obj);
 153                 return 0;
 154         }
 155         return G_REALLOC_INTERNAL (obj, size);
 156 }