eglib/src/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 <stdio.h>
  29 #include <string.h>
  30 #include <glib.h>
  31
  32 #if defined (G_OVERRIDABLE_ALLOCATORS)
  33
  34 static GMemVTable sGMemVTable = { malloc, realloc, free, calloc };
  35
  36 void
  37 g_mem_set_vtable (GMemVTable* vtable)
  38 {
  39         sGMemVTable.calloc = vtable->calloc ? vtable->calloc : calloc;
  40         sGMemVTable.realloc = vtable->realloc ? vtable->realloc : realloc;
  41         sGMemVTable.malloc = vtable->malloc ? vtable->malloc : malloc;
  42         sGMemVTable.free = vtable->free ? vtable->free : free;
  43 }
  44 #define G_FREE_INTERNAL sGMemVTable.free
  45 #define G_REALLOC_INTERNAL sGMemVTable.realloc
  46 #define G_CALLOC_INTERNAL sGMemVTable.calloc
  47 #define G_MALLOC_INTERNAL sGMemVTable.malloc
  48 #else
  49 #define G_FREE_INTERNAL free
  50 #define G_REALLOC_INTERNAL realloc
  51 #define G_CALLOC_INTERNAL calloc
  52 #define G_MALLOC_INTERNAL malloc
  53 #endif
  54 void
  55 g_free (void *ptr)
  56 {
  57         if (ptr != NULL)
  58                 G_FREE_INTERNAL (ptr);
  59 }
  60
  61 gpointer
  62 g_memdup (gconstpointer mem, guint byte_size)
  63 {
  64         gpointer ptr;
  65
  66         if (mem == NULL)
  67                 return NULL;
  68
  69         ptr = g_malloc (byte_size);
  70         if (ptr != NULL)
  71                 memcpy (ptr, mem, byte_size);
  72
  73         return ptr;
  74 }
  75
  76 gpointer g_realloc (gpointer obj, gsize size)
  77 {
  78         gpointer ptr;
  79         if (!size) {
  80                 g_free (obj);
  81                 return 0;
  82         }
  83         ptr = G_REALLOC_INTERNAL (obj, size);
  84         if (ptr)
  85                 return ptr;
  86         g_error ("Could not allocate %i bytes", size);
  87 }
  88
  89 gpointer
  90 g_malloc (gsize x)
  91 {
  92         gpointer ptr;
  93         if (!x)
  94                 return 0;
  95         ptr = G_MALLOC_INTERNAL (x);
  96         if (ptr)
  97                 return ptr;
  98         g_error ("Could not allocate %i bytes", x);
  99 }
 100
 101 gpointer g_calloc (gsize n, gsize x)
 102 {
 103         gpointer ptr;
 104         if (!x || !n)
 105                 return 0;
 106                 ptr = G_CALLOC_INTERNAL (n, x);
 107         if (ptr)
 108                 return ptr;
 109         g_error ("Could not allocate %i (%i * %i) bytes", x*n, n, x);
 110 }
 111 gpointer g_malloc0 (gsize x)
 112 {
 113         return g_calloc (1,x);
 114 }
 115
 116 gpointer g_try_malloc (gsize x)
 117 {
 118         if (x)
 119                 return G_MALLOC_INTERNAL (x);
 120         return 0;
 121 }
 122
 123
 124 gpointer g_try_realloc (gpointer obj, gsize size)
 125 {
 126         if (!size) {
 127                 G_FREE_INTERNAL (obj);
 128                 return 0;
 129         }
 130         return G_REALLOC_INTERNAL (obj, size);
 131 }