dmd/mem.c

   1
   2 /* Copyright (c) 2000 Digital Mars      */
   3 /* All Rights Reserved                  */
   4
   5 /* NOTE: This file has been patched from the original DMD distribution to
   6    work with the GDC compiler.
   7
   8    Modified by David Friedman, May 2005
   9 */
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14
  15 #if IN_GCC
  16 #include "mem.h"
  17 #elif linux
  18 #include "../root/mem.h"
  19 #else
  20 #include "mem.h"
  21 #endif
  22
  23 /* This implementation of the storage allocator uses the standard C allocation package.
  24  */
  25
  26 Mem mem;
  27
  28 void Mem::init()
  29 {
  30 }
  31
  32 char *Mem::strdup(const char *s)
  33 {
  34     char *p;
  35
  36     if (s)
  37     {
  38         p = ::strdup(s);
  39         if (p)
  40             return p;
  41         error();
  42     }
  43     return NULL;
  44 }
  45
  46 void *Mem::malloc(size_t size)
  47 {   void *p;
  48
  49     if (!size)
  50         p = NULL;
  51     else
  52     {
  53         p = ::malloc(size);
  54         if (!p)
  55             error();
  56     }
  57     return p;
  58 }
  59
  60 void *Mem::calloc(size_t size, size_t n)
  61 {   void *p;
  62
  63     if (!size || !n)
  64         p = NULL;
  65     else
  66     {
  67         p = ::calloc(size, n);
  68         if (!p)
  69             error();
  70     }
  71     return p;
  72 }
  73
  74 void *Mem::realloc(void *p, size_t size)
  75 {
  76     if (!size)
  77     {   if (p)
  78         {   ::free(p);
  79             p = NULL;
  80         }
  81     }
  82     else if (!p)
  83     {
  84         p = ::malloc(size);
  85         if (!p)
  86             error();
  87     }
  88     else
  89     {
  90         p = ::realloc(p, size);
  91         if (!p)
  92             error();
  93     }
  94     return p;
  95 }
  96
  97 void Mem::free(void *p)
  98 {
  99     if (p)
 100         ::free(p);
 101 }
 102
 103 void *Mem::mallocdup(void *o, size_t size)
 104 {   void *p;
 105
 106     if (!size)
 107         p = NULL;
 108     else
 109     {
 110         p = ::malloc(size);
 111         if (!p)
 112             error();
 113         else
 114             memcpy(p,o,size);
 115     }
 116     return p;
 117 }
 118
 119 void Mem::error()
 120 {
 121     fprintf(stderr, "Error: out of memory\n");
 122     exit(EXIT_FAILURE);
 123 }
 124
 125 void Mem::fullcollect()
 126 {
 127 }
 128
 129 void Mem::mark(void *pointer)
 130 {
 131     (void) pointer;             // necessary for VC /W4
 132 }
 133
 134 /* =================================================== */
 135
 136 void * operator new(size_t m_size)
 137 {
 138     void *p = malloc(m_size);
 139     if (p)
 140         return p;
 141     fprintf(stderr, "Error: out of memory\n");
 142     exit(EXIT_FAILURE);
 143     return p;
 144 }
 145
 146 void operator delete(void *p)
 147 {
 148     free(p);
 149 }
 150
 151