include/common/memory.h

/**
 * Copyright © 2007 Pippijn van Steenhoven / The Ermyth Team
 * Rights to this code are documented in doc/pod/license.pod.
 *
 * Memory templates.
 */

#ifndef ERMYTH_MEMORY_H
#define ERMYTH_MEMORY_H

#include <vector>

#include <ermyth/type_traits.h>

namespace impl
{
  inline void *
  smalloc (size_t n) throw (std::bad_alloc)
  {
    void *ptr = malloc (n);
  
    if (!ptr)
      throw std::bad_alloc ();
  
    return ptr;
  }
  
  inline void *
  smalloc (size_t n, void const * const src) throw (std::bad_alloc)
  {
    void *ptr = smalloc (n);
  
    if (src)
      memcpy (ptr, src, n);
    else
      memset (ptr, 0, n);
  
    return ptr;
  }
  
  // safe and slow version of above: never tries to copy more than len from src
  inline void *
  smalloc (size_t n, void *src, size_t len) throw (std::bad_alloc)
  {
    size_t max = n >= len ? n : len;
    void *ptr = smalloc (max);
  
    if (src)
      {
        memcpy (ptr, src, len);
        memset (((char *)(ptr)) + len, 0, max - len); // XXX: hack to allow pointer arithmetic
      }
    else
      memset (ptr, 0, max);
  
    return ptr;
  }
}

template<typename T>
inline T *
salloc (size_t n = 1) throw (std::bad_alloc)
{
  return (T *) impl::smalloc (n * sizeof (T));
}

template<typename T>
inline T *
salloc (size_t n, T const * const src) throw (std::bad_alloc)
{
  return (T *) impl::smalloc (n * sizeof (T), src);
}

// template counterpart of the safe copying allocator
template<typename T>
inline T *
salloc (size_t n, T *src, size_t len) throw (std::bad_alloc)
{
  return (T *) impl::smalloc (n * sizeof (T), src, len);
}

template<typename T>
inline T *
salloc (size_t n, char c) throw (std::bad_alloc)
{
  T *ptr = (T *) impl::smalloc (n * sizeof (T));
  return memset (ptr, c, n * sizeof (T));
}

template<typename T>
inline void
sfree (T *ptr) throw ()
{
  free (ptr);
}

template<typename T>
inline void
sfree (T *ptr, size_t n) throw ()
{
  free (ptr);
}

// makes dynamically allocated objects zero-initialised
struct zero_initialised
{
  void *operator new (size_t s)
  {
    void *p = impl::smalloc (s);
    memset (p, 0, s);
    return p;
  }

  void *operator new[] (size_t s)
  {
    void *p = impl::smalloc (s);
    memset (p, 0, s);
    return p;
  }

  void operator delete (void *p, size_t s)
  {
    free (p);
  }

  void operator delete[] (void *p, size_t s)
  {
    free (p);
  }
};

E char *sstrdup (char const * const s);
E char *sstrndup (char const * const s, size_t len);

template<size_t N>
inline char *
sstrndup (char const (&s)[N])
{
  return sstrndup (s, N);
}

struct garbage_collector
{
  void insert (void *p)
  {
    mortals.push_back (p);
  }

  void collect ()
  {
    while (!mortals.empty ())
      {
        sfree (mortals.back ());
        mortals.pop_back ();
      }
  }

private:
  std::vector<void *> mortals;
};

E garbage_collector gc;

#endif
Revision:	1.4
Committed:	Wed Sep 5 11:23:13 2007 UTC (19 years, 1 month ago) by pippijn
Content type:	text/plain
Branch:	MAIN
Changes since 1.3:	+1 -1 lines
Log Message:	removed GPLed code and put license back to BSD
#	User	Rev	Content
1	pippijn	1.1	/**
2			* Copyright © 2007 Pippijn van Steenhoven / The Ermyth Team
3	pippijn	1.4	* Rights to this code are documented in doc/pod/license.pod.
4	pippijn	1.1	*
5			* Memory templates.
6			*/
7
8			#ifndef ERMYTH_MEMORY_H
9			#define ERMYTH_MEMORY_H
10
11	pippijn	1.2	#include <vector>
12
13			#include <ermyth/type_traits.h>
14
15	pippijn	1.1	namespace impl
16			{
17			inline void *
18	pippijn	1.3	smalloc (size_t n) throw (std::bad_alloc)
19	pippijn	1.1	{
20			void *ptr = malloc (n);
21
22			if (!ptr)
23			throw std::bad_alloc ();
24
25			return ptr;
26			}
27
28			inline void *
29	pippijn	1.3	smalloc (size_t n, void const * const src) throw (std::bad_alloc)
30	pippijn	1.1	{
31			void *ptr = smalloc (n);
32
33			if (src)
34			memcpy (ptr, src, n);
35			else
36			memset (ptr, 0, n);
37
38			return ptr;
39			}
40
41			// safe and slow version of above: never tries to copy more than len from src
42			inline void *
43	pippijn	1.3	smalloc (size_t n, void *src, size_t len) throw (std::bad_alloc)
44	pippijn	1.1	{
45			size_t max = n >= len ? n : len;
46			void *ptr = smalloc (max);
47
48			if (src)
49			{
50			memcpy (ptr, src, len);
51			memset (((char *)(ptr)) + len, 0, max - len); // XXX: hack to allow pointer arithmetic
52			}
53			else
54			memset (ptr, 0, max);
55
56			return ptr;
57			}
58			}
59
60			template<typename T>
61			inline T *
62	pippijn	1.3	salloc (size_t n = 1) throw (std::bad_alloc)
63	pippijn	1.1	{
64			return (T ) impl::smalloc (n sizeof (T));
65			}
66
67			template<typename T>
68			inline T *
69	pippijn	1.3	salloc (size_t n, T const * const src) throw (std::bad_alloc)
70	pippijn	1.1	{
71			return (T ) impl::smalloc (n sizeof (T), src);
72			}
73
74			// template counterpart of the safe copying allocator
75			template<typename T>
76			inline T *
77	pippijn	1.3	salloc (size_t n, T *src, size_t len) throw (std::bad_alloc)
78	pippijn	1.1	{
79			return (T ) impl::smalloc (n sizeof (T), src, len);
80			}
81
82			template<typename T>
83			inline T *
84	pippijn	1.3	salloc (size_t n, char c) throw (std::bad_alloc)
85	pippijn	1.1	{
86			T ptr = (T ) impl::smalloc (n * sizeof (T));
87			return memset (ptr, c, n * sizeof (T));
88			}
89
90			template<typename T>
91			inline void
92			sfree (T *ptr) throw ()
93			{
94			free (ptr);
95			}
96
97	pippijn	1.3	template<typename T>
98			inline void
99			sfree (T *ptr, size_t n) throw ()
100			{
101			free (ptr);
102			}
103
104	pippijn	1.1	// makes dynamically allocated objects zero-initialised
105			struct zero_initialised
106			{
107			void *operator new (size_t s)
108			{
109			void *p = impl::smalloc (s);
110			memset (p, 0, s);
111			return p;
112			}
113
114			void *operator new[] (size_t s)
115			{
116			void *p = impl::smalloc (s);
117			memset (p, 0, s);
118			return p;
119			}
120
121			void operator delete (void *p, size_t s)
122			{
123			free (p);
124			}
125
126			void operator delete[] (void *p, size_t s)
127			{
128			free (p);
129			}
130			};
131
132			E char sstrdup (char const const s);
133	pippijn	1.3	E char sstrndup (char const const s, size_t len);
134	pippijn	1.1
135			template<size_t N>
136			inline char *
137			sstrndup (char const (&s)[N])
138			{
139			return sstrndup (s, N);
140			}
141
142	pippijn	1.2	struct garbage_collector
143			{
144			void insert (void *p)
145			{
146			mortals.push_back (p);
147			}
148
149			void collect ()
150			{
151			while (!mortals.empty ())
152			{
153			sfree (mortals.back ());
154			mortals.pop_back ();
155			}
156			}
157
158			private:
159			std::vector<void *> mortals;
160			};
161
162			E garbage_collector gc;
163
164	pippijn	1.1	#endif