mem.h

Go to the documentation of this file.

#ifndef CSNIP_MEM_H
#define CSNIP_MEM_H
 
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
 
#include <csnip/err.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
void* csnip_mem_aligned_alloc(size_t nAlign, size_t nSize, int* err);
 
void csnip_mem_aligned_free(void* mem);
 
#ifdef __cplusplus
}
#endif
 
#ifndef __cplusplus
 
/* Memory macros, C version.
 */
 
#include <stdlib.h>
 
#define csnip_mem_Alloc(nMember, ptr, err) \
    do { \
        if ((nMember) < 0 || \
            SIZE_MAX / sizeof(*(ptr)) < (nMember)) \
        { \
            (ptr) = NULL; \
            csnip_err_Raise(csnip_err_RANGE, err); \
            break; \
        } \
        if (((ptr) = malloc(sizeof(*(ptr)) * (nMember))) == NULL) \
            csnip_err_Raise(csnip_err_NOMEM, err); \
    } while(0)
 
#define csnip_mem_Alloc0(nMember, ptr, err) \
    do { \
        if ((nMember) < 0) { \
            (ptr) = NULL; \
            csnip_err_Raise(csnip_err_RANGE, err); \
            break; \
        } \
        if (((ptr) = calloc((nMember), sizeof(*(ptr)))) == NULL) \
            csnip_err_Raise(csnip_err_NOMEM, err); \
    } while(0)
 
#define csnip_mem_AlignedAlloc(nMember, nAlign, ptr, err) \
    csnip_mem__AlignedAlloc((nMember), (nAlign), (ptr), (err))
 
#define csnip_mem__AlignedAlloc(nMember, nAlign, ptr, err) \
    do { \
        if (nAlign < 0 || nAlign > SIZE_MAX ||nMember < 0 || \
            SIZE_MAX / sizeof(*ptr) < nMember) \
        { \
            ptr = NULL; \
            csnip_err_Raise(csnip_err_RANGE, err); \
            break; \
        } \
        int csnip__err; \
        ptr = csnip_mem_aligned_alloc(nAlign, nMember * sizeof(*ptr), \
            &csnip__err); \
        if (ptr == NULL) \
            csnip_err_Raise(csnip__err, err); \
    } while(0);
#define csnip_mem_Realloc(nMember, ptr, err) \
    csnip_mem__Realloc((nMember), (ptr), (err), csnip__p)
 
#define csnip_mem__Realloc(nMember, ptr, err,       p) \
    do { \
        if (nMember < 0 || \
            SIZE_MAX / sizeof(*ptr) < nMember) { \
            csnip_err_Raise(csnip_err_RANGE, err); \
            break; \
        } \
        void* p = realloc(ptr, sizeof(*ptr) * nMember); \
        if (p == NULL) { \
            csnip_err_Raise(csnip_err_NOMEM, err); \
            break; \
        } \
        ptr = p; \
    } while(0)
#define csnip_mem_Free(ptr) \
    do { \
        free(ptr); \
        (ptr) = NULL; \
    } while(0)
 
#define csnip_mem_AlignedFree(ptr) \
    do { \
        csnip_mem_aligned_free(ptr); \
        (ptr) = NULL; \
    } while (0)
 
#else
#include <cstdlib>
 
template<typename T>
  inline T* csnip_mem_alloc_cxx(size_t nMemb, T* typeselect, int* err)
{
    (void)typeselect;
    if (SIZE_MAX / sizeof(T) < nMemb) {
        *err = csnip_err_RANGE;
        return NULL;
    }
    return (T*)std::malloc(sizeof(T) * nMemb);
}
 
template<typename T>
  inline T* csnip_mem_calloc_cxx(size_t nMemb, T* typeselect, int* err)
{
    (void)typeselect;
    if (SIZE_MAX / sizeof(T) < nMemb) {
        *err = csnip_err_RANGE;
        return NULL;
    }
    return (T*)std::calloc(nMemb, sizeof(T));
}
 
template<typename T>
  inline T* csnip_mem_aligned_alloc_cxx(size_t nMemb, size_t nAlign, T* typeselect, int* err)
{
    (void)typeselect;
    if (SIZE_MAX / sizeof(T) < nMemb) {
        *err = csnip_err_RANGE;
        return NULL;
    }
    return (T*)csnip_mem_aligned_alloc(nAlign, nMemb * sizeof(T), err);
}
 
template<typename T>
  inline void csnip_mem_realloc_cxx(size_t nMemb, T** orig, int* err)
{
    if (SIZE_MAX / sizeof(T) < nMemb) {
        *err = csnip_err_RANGE;
        return;
    }
    T* new_ptr = (T*)std::realloc(*orig, sizeof(T) * nMemb);
    if (new_ptr) {
        *orig = new_ptr;
    } else {
        *err = csnip_err_NOMEM;
    }
}
 
#define csnip_mem_Alloc(nMember, ptr, err) \
    do { \
        int csnip__err = 0; \
        (ptr) = NULL; \
        (ptr) = csnip_mem_alloc_cxx((nMember), (ptr), &csnip__err); \
        if ((ptr) == NULL) { \
            csnip_err_Raise(csnip__err, err); \
        } \
    } while(0)
 
#define csnip_mem_Alloc0(nMember, ptr, err) \
    do { \
        int csnip__err = 0; \
        (ptr) = NULL; \
        (ptr) = csnip_mem_calloc_cxx((nMember), (ptr), &csnip__err); \
        if ((ptr) == NULL) { \
            csnip_err_Raise(csnip__err, err); \
        } \
    } while(0)
 
#define csnip_mem_AlignedAlloc(nMember, nAlign, ptr, err) \
    do { \
        int csnip__err = 0; \
        (ptr) = NULL; \
        (ptr) = csnip_mem_aligned_alloc_cxx((nMember), (nAlign), \
          (ptr), &csnip__err); \
        if ((ptr) == NULL) { \
            csnip_err_Raise(csnip__err, err); \
        } \
    } while(0)
 
#define csnip_mem_Realloc(nMember, ptr, err) \
    do { \
        int csnip__err = 0; \
        csnip_mem_realloc_cxx((nMember), &(ptr), &csnip__err);\
        if (csnip__err) { \
            csnip_err_Raise(csnip__err, err); \
        } \
    } while(0)
 
 
#define csnip_mem_Free(ptr) \
    do { \
        std::free(ptr); \
        (ptr) = NULL; \
    } while(0)
 
#define csnip_mem_AlignedFree(ptr) \
    do { \
        csnip_mem_aligned_free(ptr); \
        (ptr) = NULL; \
    } while (0)
 
#endif
 
#endif /* CSNIP_MEM_H */
 
#if defined(CSNIP_SHORT_NAMES) && !defined(CSNIP_MEM_HAVE_SHORT_NAMES)
#define mem_aligned_alloc   csnip_mem_aligned_alloc
#define mem_Alloc       csnip_mem_Alloc
#define mem_Alloc0      csnip_mem_Alloc0
#define mem_AlignedAlloc    csnip_mem_AlignedAlloc
#define mem_Realloc     csnip_mem_Realloc
#define mem_Free        csnip_mem_Free
#define mem_AlignedFree     csnip_mem_AlignedFree
#define CSNIP_MEM_HAVE_SHORT_NAMES
#endif