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

 * Simplified allocation function that allocates the specified number of

    10

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

    11

 * type.

    12

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

    13

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

    14

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

    15

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

    16

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

    17

 */

    18

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

    19

{

    20

	/*

    21

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

    22

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

    23

	 * to behave the same on all OSes.

    24

	 */

    25

	if (num_elements == 0) return NULL;

    26

    27

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

    28

	if (t_ptr == NULL) error("Out of memory. Cannot allocate %i bytes", num_elements * sizeof(T));

    29

	return t_ptr;

    30

}

    31

    32

/**

    33

 * Simplified allocation function that allocates the specified number of

    34

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

    35

 * type.

    36

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

    37

 * @note the memory contains all zero values.

    38

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

    39

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

    40

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

    41

 */

    42

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

    43

{

    44

	/*

    45

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

    46

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

    47

	 * to behave the same on all OSes.

    48

	 */

    49

	if (num_elements == 0) return NULL;

    50

    51

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

    52

	if (t_ptr == NULL) error("Out of memory. Cannot allocate %i bytes", num_elements * sizeof(T));

    53

	return t_ptr;

    54

}

    55

    56

/**

    57

 * Simplified reallocation function that allocates the specified number of

    58

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

    59

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

    60

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

    61

 * @note the memory contains all zero values.

    62

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

    63

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

    64

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

    65

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

    66

 */

    67

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

    68

{

    69

	/*

    70

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

    71

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

    72

	 * to behave the same on all OSes.

    73

	 */

    74

	if (num_elements == 0) {

    75

		free(t_ptr);

    76

		return NULL;

    77

	}

    78

    79

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

    80

	if (t_ptr == NULL) error("Out of memory. Cannot reallocate %i bytes", num_elements * sizeof(T));

    81

	return t_ptr;

    82

}

    83

    84

#endif /* ALLOC_FUNC_HPP */