crt_heap.h

/*****************************************************/
/* lean Memory                  (c) Tobias Zirr 2011 */
/*****************************************************/

#ifndef LEAN_MEMORY_CRT_HEAP
#define LEAN_MEMORY_CRT_HEAP

#include "../lean.h"
#include "alignment.h"

#ifndef LEAN_ASSUME_CRT_ALIGNMENT
    // MONITOR: Seems to be guaranteed for MSC & GCC
    #ifdef LEAN_64_BIT


        #define LEAN_ASSUME_CRT_ALIGNMENT 16
    #else


        #define LEAN_ASSUME_CRT_ALIGNMENT 8
    #endif
#endif

namespace lean
{
namespace memory
{

struct crt_heap
{
    typedef size_t size_type;
    static const size_type default_alignment = LEAN_ASSUME_CRT_ALIGNMENT;

    static LEAN_INLINE void* allocate(size_type size) { return ::operator new(size); }
    static LEAN_INLINE void free(void *memory) { ::operator delete(memory); }

    template <size_t Alignment>
    static LEAN_INLINE void* allocate(size_type size)
    {
        if (Alignment <= default_alignment && check_alignment<Alignment>::valid)
            return allocate(size);
        else
        {
            LEAN_STATIC_ASSERT_MSG_ALT(Alignment < static_cast<unsigned char>(-1),
                "Alignment > max unsigned char unsupported.",
                Alignment_bigger_than_max_unsigned_char_unsupported);

            unsigned char *unaligned = reinterpret_cast<unsigned char*>( allocate(size + Alignment) );
            unsigned char *aligned = upper_align<Alignment>(unaligned);
            aligned[-1] = static_cast<unsigned char>(aligned - unaligned);
            return aligned;
        }
    }
    template <size_t Alignment>
    static LEAN_INLINE void free(void *memory)
    {
        if (Alignment <= default_alignment && check_alignment<Alignment>::valid)
            free(memory);
        else
        {
            if (memory)
                free(reinterpret_cast<unsigned char*>(memory) - reinterpret_cast<unsigned char*>(memory)[-1]);
        }
    }
    static LEAN_INLINE void free(void *memory, size_t alignment)
    {
        if (alignment <= default_alignment)
            free(memory);
        else
        {
            if (memory)
                free(reinterpret_cast<unsigned char*>(memory) - reinterpret_cast<unsigned char*>(memory)[-1]);
        }
    }
};

} // namespace

using memory::crt_heap;

} // namespace

#endif