1

     2

/* $Id$ */

     3

     4

/** @file alloc_type.hpp Helper types related to the allocation of memory */

     5

     6

#ifndef ALLOC_TYPE_HPP

     7

#define ALLOC_TYPE_HPP

     8

     9

#include "alloc_func.hpp"

    10

    11

/**

    12

 * A small 'wrapper' for allocations that can be done on most OSes on the

    13

 * stack, but are just too large to fit in the stack on devices with a small

    14

 * stack such as the NDS.

    15

 * So when it is possible a stack allocation is made, otherwise a heap

    16

 * allocation is made and this is freed once the struct goes out of scope.

    17

 * @param T      the type to make the allocation for

    18

 * @param length the amount of items to allocate

    19

 */

    20

template <typename T, size_t length>

    21

struct SmallStackSafeStackAlloc {

    22

#if !defined(__NDS__)

    23

	/** Storing the data on the stack */

    24

	T data[length];

    25

#else

    26

	/** Storing it on the heap */

    27

	T *data;

    28

	/** The length (in elements) of data in this allocator. */

    29

	size_t len;

    30

    31

	/** Allocating the memory */

    32

	SmallStackSafeStackAlloc() : data(MallocT<T>(length)), len(length) {}

    33

	/** And freeing when it goes out of scope */

    34

	~SmallStackSafeStackAlloc() { free(data); }

    35

#endif

    36

    37

	/**

    38

	 * Gets a pointer to the data stored in this wrapper.

    39

	 * @return the pointer.

    40

	 */

    41

	inline operator T* () { return data; }

    42

    43

	/**

    44

	 * Gets a pointer to the data stored in this wrapper.

    45

	 * @return the pointer.

    46

	 */

    47

	inline T* operator -> () { return data; }

    48

    49

	/**

    50

	 * Gets a pointer to the last data element stored in this wrapper.

    51

	 * @note needed because endof does not work properly for pointers.

    52

	 * @return the 'endof' pointer.

    53

	 */

    54

	inline T* EndOf() {

    55

#if !defined(__NDS__)

    56

		return endof(data);

    57

#else

    58

		return &data[len];

    59

#endif

    60

	}

    61

};

    62

    63

/**

    64

 * Base class that provides memory initialization on dynamically created objects.

    65

 * All allocated memory will be zeroed.

    66

 */

    67

class ZeroedMemoryAllocator

    68

{

    69

public:

    70

	ZeroedMemoryAllocator() {}

    71

	virtual ~ZeroedMemoryAllocator() {}

    72

    73

	/**

    74

	 * Memory allocator for a single class instance.

    75

	 * @param size the amount of bytes to allocate.

    76

	 * @return the given amounts of bytes zeroed.

    77

	 */

    78

	void *operator new(size_t size) { return CallocT<byte>(size); }

    79

    80

	/**

    81

	 * Memory allocator for an array of class instances.

    82

	 * @param size the amount of bytes to allocate.

    83

	 * @return the given amounts of bytes zeroed.

    84

	 */

    85

	void *operator new[](size_t size) { return CallocT<byte>(size); }

    86

    87

	/**

    88

	 * Memory release for a single class instance.

    89

	 * @param ptr  the memory to free.

    90

	 * @param size the amount of allocated memory (unused).

    91

	 */

    92

	void operator delete(void *ptr, size_t size) { free(ptr); }

    93

    94

	/**

    95

	 * Memory release for an array of class instances.

    96

	 * @param ptr  the memory to free.

    97

	 * @param size the amount of allocated memory (unused).

    98

	 */

    99

	void operator delete[](void *ptr, size_t size) { free(ptr); }

   100

};

   101

   102

#endif /* ALLOC_TYPE_HPP */