include/common/memory.h

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

#ifndef ERMYTH_MEMORY_H
#define ERMYTH_MEMORY_H

namespace impl
{
  inline void *
  smalloc (unsigned n) throw (std::bad_alloc)
  {
    void *ptr = malloc (n);
  
    if (!ptr)
      throw std::bad_alloc ();
  
    return ptr;
  }
  
  inline void *
  smalloc (unsigned n, void *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 (unsigned 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 *
alloc (int n = 1) throw (std::bad_alloc)
{
  return (T *) impl::smalloc (n * sizeof (T));
}

template<typename T>
inline T *
alloc (unsigned n, T *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 *
alloc (unsigned n, T *src, size_t len) throw (std::bad_alloc)
{
  return (T *) impl::smalloc (n * sizeof (T), src, len);
}

template<typename T>
inline T *
alloc (unsigned 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);
}

// 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, int len);

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

#endif
Revision:	1.1
Committed:	Tue Aug 28 17:14:43 2007 UTC (19 years, 1 month ago) by pippijn
Content type:	text/plain
Branch:	MAIN
Log Message:	added new files
#	User	Rev	Content
1	pippijn	1.1	/**
2			* Copyright © 2007 Pippijn van Steenhoven / The Ermyth Team
3			* Rights to this code are documented in doc/pod/gplicense.pod.
4			*
5			* Memory templates.
6			*/
7
8			#ifndef ERMYTH_MEMORY_H
9			#define ERMYTH_MEMORY_H
10
11			namespace impl
12			{
13			inline void *
14			smalloc (unsigned n) throw (std::bad_alloc)
15			{
16			void *ptr = malloc (n);
17
18			if (!ptr)
19			throw std::bad_alloc ();
20
21			return ptr;
22			}
23
24			inline void *
25			smalloc (unsigned n, void *src) throw (std::bad_alloc)
26			{
27			void *ptr = smalloc (n);
28
29			if (src)
30			memcpy (ptr, src, n);
31			else
32			memset (ptr, 0, n);
33
34			return ptr;
35			}
36
37			// safe and slow version of above: never tries to copy more than len from src
38			inline void *
39			smalloc (unsigned n, void *src, size_t len) throw (std::bad_alloc)
40			{
41			size_t max = n >= len ? n : len;
42			void *ptr = smalloc (max);
43
44			if (src)
45			{
46			memcpy (ptr, src, len);
47			memset (((char *)(ptr)) + len, 0, max - len); // XXX: hack to allow pointer arithmetic
48			}
49			else
50			memset (ptr, 0, max);
51
52			return ptr;
53			}
54			}
55
56			template<typename T>
57			inline T *
58			alloc (int n = 1) throw (std::bad_alloc)
59			{
60			return (T ) impl::smalloc (n sizeof (T));
61			}
62
63			template<typename T>
64			inline T *
65			alloc (unsigned n, T *src) throw (std::bad_alloc)
66			{
67			return (T ) impl::smalloc (n sizeof (T), src);
68			}
69
70			// template counterpart of the safe copying allocator
71			template<typename T>
72			inline T *
73			alloc (unsigned n, T *src, size_t len) throw (std::bad_alloc)
74			{
75			return (T ) impl::smalloc (n sizeof (T), src, len);
76			}
77
78			template<typename T>
79			inline T *
80			alloc (unsigned n, char c) throw (std::bad_alloc)
81			{
82			T ptr = (T ) impl::smalloc (n * sizeof (T));
83			return memset (ptr, c, n * sizeof (T));
84			}
85
86			template<typename T>
87			inline void
88			sfree (T *ptr) throw ()
89			{
90			free (ptr);
91			}
92
93			// makes dynamically allocated objects zero-initialised
94			struct zero_initialised
95			{
96			void *operator new (size_t s)
97			{
98			void *p = impl::smalloc (s);
99			memset (p, 0, s);
100			return p;
101			}
102
103			void *operator new[] (size_t s)
104			{
105			void *p = impl::smalloc (s);
106			memset (p, 0, s);
107			return p;
108			}
109
110			void operator delete (void *p, size_t s)
111			{
112			free (p);
113			}
114
115			void operator delete[] (void *p, size_t s)
116			{
117			free (p);
118			}
119			};
120
121			E char sstrdup (char const const s);
122			E char sstrndup (char const const s, int len);
123
124			template<size_t N>
125			inline char *
126			sstrndup (char const (&s)[N])
127			{
128			return sstrndup (s, N);
129			}
130
131			#endif