1

/* $Id$ */

     2

     3

/** @file alloc_func.hpp Functions related to the allocation of memory */

     4

     5

#ifndef ALLOC_FUNC_HPP

     6

#define ALLOC_FUNC_HPP

     7

     8

/**

     9

 * Functions to exit badly with an error message.

    10

 * It has to be linked so the error messages are not

    11

 * duplicated in each object file making the final

    12

 * binary needlessly large.

    13

 */

    14

void MallocError(size_t size);

    15

void ReallocError(size_t size);

    16

    17

/**

    18

 * Simplified allocation function that allocates the specified number of

    19

 * elements of the given type. It also explicitly casts it to the requested

    20

 * type.

    21

 * @note throws an error when there is no memory anymore.

    22

 * @note the memory contains garbage data (i.e. possibly non-zero values).

    23

 * @param T the type of the variable(s) to allocation.

    24

 * @param num_elements the number of elements to allocate of the given type.

    25

 * @return NULL when num_elements == 0, non-NULL otherwise.

    26

 */

    27

template <typename T> FORCEINLINE T* MallocT(size_t num_elements)

    28

{

    29

	/*

    30

	 * MorphOS cannot handle 0 elements allocations, or rather that always

    31

	 * returns NULL. So we do that for *all* allocations, thus causing it

    32

	 * to behave the same on all OSes.

    33

	 */

    34

	if (num_elements == 0) return NULL;

    35

    36

	T *t_ptr = (T*)malloc(num_elements * sizeof(T));

    37

	if (t_ptr == NULL) MallocError(num_elements * sizeof(T));

    38

	return t_ptr;

    39

}

    40

    41

/**

    42

 * Simplified allocation function that allocates the specified number of

    43

 * elements of the given type. It also explicitly casts it to the requested

    44

 * type.

    45

 * @note throws an error when there is no memory anymore.

    46

 * @note the memory contains all zero values.

    47

 * @param T the type of the variable(s) to allocation.

    48

 * @param num_elements the number of elements to allocate of the given type.

    49

 * @return NULL when num_elements == 0, non-NULL otherwise.

    50

 */

    51

template <typename T> FORCEINLINE T* CallocT(size_t num_elements)

    52

{

    53

	/*

    54

	 * MorphOS cannot handle 0 elements allocations, or rather that always

    55

	 * returns NULL. So we do that for *all* allocations, thus causing it

    56

	 * to behave the same on all OSes.

    57

	 */

    58

	if (num_elements == 0) return NULL;

    59

    60

	T *t_ptr = (T*)calloc(num_elements, sizeof(T));

    61

	if (t_ptr == NULL) MallocError(num_elements * sizeof(T));

    62

	return t_ptr;

    63

}

    64

    65

/**

    66

 * Simplified reallocation function that allocates the specified number of

    67

 * elements of the given type. It also explicitly casts it to the requested

    68

 * type. It extends/shrinks the memory allocation given in t_ptr.

    69

 * @note throws an error when there is no memory anymore.

    70

 * @note the memory contains all zero values.

    71

 * @param T the type of the variable(s) to allocation.

    72

 * @param t_ptr the previous allocation to extend/shrink.

    73

 * @param num_elements the number of elements to allocate of the given type.

    74

 * @return NULL when num_elements == 0, non-NULL otherwise.

    75

 */

    76

template <typename T> FORCEINLINE T* ReallocT(T *t_ptr, size_t num_elements)

    77

{

    78

	/*

    79

	 * MorphOS cannot handle 0 elements allocations, or rather that always

    80

	 * returns NULL. So we do that for *all* allocations, thus causing it

    81

	 * to behave the same on all OSes.

    82

	 */

    83

	if (num_elements == 0) {

    84

		free(t_ptr);

    85

		return NULL;

    86

	}

    87

    88

	t_ptr = (T*)realloc(t_ptr, num_elements * sizeof(T));

    89

	if (t_ptr == NULL) ReallocError(num_elements * sizeof(T));

    90

	return t_ptr;

    91

}

    92

    93

/**

    94

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

    95

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

    96

 * stack such as the NDS.

    97

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

    98

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

    99

 * @param T      the type to make the allocation for

   100

 * @param length the amount of items to allocate

   101

 */

   102

template <typename T, size_t length>

   103

struct SmallStackSafeStackAlloc {

   104

#if !defined(__NDS__)

   105

	/** Storing the data on the stack */

   106

	T data[length];

   107

#else

   108

	/** Storing it on the heap */

   109

	T *data;

   110

   111

	/** Allocating the memory */

   112

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

   113

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

   114

	~SmallStackSafeStackAlloc() { free(data); }

   115

#endif

   116

   117

	/**

   118

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

   119

	 * @return the pointer.

   120

	 */

   121

	operator T* () { return data; }

   122

};

   123

   124

#endif /* ALLOC_FUNC_HPP */