inosmacro.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
#if !defined( INC_INOSMACRO_H )
#define INC_INOSMACRO_H
 
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
 
#include <inostype.h>
 
//------------------------------------------------------------------------------
// macros
//------------------------------------------------------------------------------
 
#define LOAD_SETBE16(address, value) inos_setbe16((uint16*)address, value)
 
#define LOAD_GETBE16(address) inos_getbe16((uint16*)address)
 
#define LOAD_SETBE32(address, value) inos_setbe32((uint32*)address, value)
 
#define LOAD_GETBE32(address) inos_getbe32((uint32*)address)
 
//------------------------------------------------------------------------------
// CPP exception macros
//------------------------------------------------------------------------------
 
#ifdef INOS_CPP_EXCEPTION_SUPPORT
 
#define INOS_TRY                                                                \
    try {                                                                       \
        SINOSExceptionGuard __inosTryGuard;                                     \
 
#define INOS_CATCH(Exception)                                                   \
    } catch (Exception)                                                         \
 
#ifdef _MSC_VER
#define INOS_THROW(ExceptionClass, ... ) \
    { ExceptionClass __inosEx(__VA_ARGS__); __inosEx.OnThrow(__FILE__, __LINE__); throw __inosEx; }
#else
#define INOS_THROW(ExceptionClass, args... ) \
    { ExceptionClass __inosEx(args); __inosEx.OnThrow(__FILE__, __LINE__); throw __inosEx; }
#endif
#else
 
#define INOS_TRY                                                                \
    static_assert(0, "One needs to enable C++ Exception feature to use this macro");
 
#define INOS_CATCH(Exception)                                                   \
    static_assert(0, "One needs to enable C++ Exception feature to use this macro");
 
#define INOS_THROW(ExceptionClass, args... ) \
    static_assert(0, "One needs to enable C++ Exception feature to use this macro");
 
#endif
 
//------------------------------------------------------------------------------
// enum X macros
//------------------------------------------------------------------------------
#define INOS_DEFINE_ENUM_CODE_X(id, code, ...) id = code,
#define INOS_DEFINE_ENUM_CODE(defines, ...)     \
    enum __VA_ARGS__ {                          \
        defines(INOS_DEFINE_ENUM_CODE_X) \
    };
 
/*  \brief X Macro to create a combo data string from an emum or definition list */
#define INOS_DEFINE_COMBO_DATA_X(id, code, ...) #code";"#id";"
#define INOS_DEFINE_COMBO_DATA(defines, ...) defines(INOS_DEFINE_COMBO_DATA_X)
 
 
//------------------------------------------------------------------------------
// MISC macros
//------------------------------------------------------------------------------
 
#if INOS_BYTE_ORDER == INOS_LITTLE_ENDIAN
#define INOS_HW_WRITE8(address, value)                                          \
    *((volatile uint8*)((uintptr)(address)^1)) = (value);
#define INOS_HW_READ8(address)                                                  \
    *((volatile uint8*)((uintptr)(address)^1))
#define INOS_HW_ADDR8(address)                                                  \
    ((uint8*)((uintptr)(address)^1))
#define INOS_HW_WRITE16(address, value)                                         \
    *((volatile uint16*)((uintptr)(address)^2)) = (value);
#define INOS_HW_READ16(address)                                                 \
    *((volatile uint16*)((uintptr)(address)^2))
#define INOS_HW_ADDR16(address)                                                 \
    ((uint16*)((uintptr)(address)^2))
#else
#define INOS_HW_WRITE8(address, value)                                          \
    *((volatile uint8*)(address)) = (value);
#define INOS_HW_READ8(address)                                                  \
    *((volatile uint8*)(address))
#define INOS_HW_ADDR8(address)                                                  \
    ((uint8*)(address))
#define INOS_HW_WRITE16(address, value)                                         \
    *((volatile uint16*)(address)) = (value);
#define INOS_HW_READ16(address)                                                 \
    *((volatile uint16*)(address))
#define INOS_HW_ADDR16(address)                                                 \
    ((uint16*)(address))
#endif
#define INOS_HW_WRITE32(address, value)                                         \
    *((volatile uint32*)((uintptr)(address))) = (value);
#define INOS_HW_READ32(address)                                                 \
    *((volatile uint32*)((uintptr)(address)))
#define INOS_HW_ADDR32(address)                                                 \
    ((volatile uint32*)((uintptr)(address)))
 
#if !defined(INOS_MULTICORE) || defined(_MSC_VER)
 
    // Implementation note: At least on certain platforms, it could theoretically
    // make sense to always use the 'multi core' implementation below. But to
    // follow the "never change a running system" rule, I decided to leave this
    // implementation intact for non-multi-core systems - and therefore only
    // change the implementation of 'symmetric multi core systems', which are
    // of limited spread at this time.
 
    #define INOS_OR(variable, mask)                                                 \
        {                                                                           \
        uint32 __msr__ = INOSDisableInterrupts();                                   \
        variable |= (mask);                                                         \
        INOSEnableInterrupts(__msr__);                                              \
        }
 
    #define INOS_AND(variable, mask)                                                \
        {                                                                           \
        uint32 __msr__ = INOSDisableInterrupts();                                   \
        variable &= (mask);                                                         \
        INOSEnableInterrupts(__msr__);                                              \
        }
 
    #define INOS_ADD(variable, value)                                               \
        {                                                                           \
        uint32 __msr__ = INOSDisableInterrupts();                                   \
        variable += (value);                                                        \
        INOSEnableInterrupts(__msr__);                                              \
        }
 
    #define INOS_SET(variable, value)                                               \
        {                                                                           \
        uint32 __msr__ = INOSDisableInterrupts();                                   \
        variable = (value);                                                         \
        INOSEnableInterrupts(__msr__);                                              \
        }
 
    #define INOS_SET_8 INOS_SET
 
    #define INOS_SET_MB(variable, value)                                            \
        INOSMemoryBarrier();                                                        \
        variable = (value);                                                         \
        INOSMemoryBarrier();
 
#else
 
    // Implementation note: The macros are enclosed in brackets '{ ... }' to
    // prevent code, using these macros, from storing the returned value. This
    // seems to make sense to ensure that these macros behave the same ways as
    // the non-multi-core ones, to ensure 'cross compilation' of the user code.
    //
    // Note: From respect to the C++11 memory model, these operation just
    //       guarantee to be 'atomic', but they don't guarantee ordering
    //       across CPUs, means: They do NOT guarantee that all previously
    //       performed store operations are 'sync out' (msync & co), which
    //       clearly improves performance. Manually sync (e.g. using a
    //       std::atomic_thread_fence(...) if required. But what they DO
    //       guarantee is that they won't be reordered by the compiler,
    //       thus the usage of an "optimization barrier". The latter is
    //       guaranteed because I assume that the non-SMP versions (see
    //       above) also caused this as a side effect of the 'volatile asm'
    //       statements used by INOSDisableInterrupts. Thus, I expected the
    //       least "behavioral change" for existing code. But this assumption
    //       has not been proven and may be wrong.
 
    #define INOS_OR(variable, mask) {                                               \
        INOSOptimizationBarrier();                                                  \
        __atomic_or_fetch(&variable, mask, __ATOMIC_RELAXED);                       \
        INOSOptimizationBarrier();                                                  \
    }
 
    #define INOS_AND(variable, mask) {                                              \
        INOSOptimizationBarrier();                                                  \
        __atomic_and_fetch(&variable, mask, __ATOMIC_RELAXED);                      \
        INOSOptimizationBarrier();                                                  \
    }
 
    #define INOS_ADD(variable, value) {                                             \
        INOSOptimizationBarrier();                                                  \
        __atomic_add_fetch(&variable, value, __ATOMIC_RELAXED);                     \
        INOSOptimizationBarrier();                                                  \
    }
 
    #define INOS_SET(variable, value) {                                             \
        INOSOptimizationBarrier();                                                  \
        __atomic_store_n(&variable, value, __ATOMIC_RELAXED);                       \
        INOSOptimizationBarrier();                                                  \
    }
 
    #define INOS_SET_8(variable, value) {                                           \
        INOSOptimizationBarrier();                                                  \
        __atomic_store(&variable, &value, __ATOMIC_RELAXED);                        \
        INOSOptimizationBarrier();                                                  \
    }
 
    #define INOS_SET_MB(variable, value)                                            \
        INOSMemoryBarrier();                                                        \
        INOS_SET(variable, value);                                                  \
        INOSMemoryBarrier();
 
#endif
 
#define INOS_ADD_ INOS_ADD
 
#define DF_INOS_SYNCHRONOUS         ((CINOSSync *) 0)
#define DF_INOS_ASYNCHRONOUS        ((CINOSSync *) 1)
#define DF_INOS_DELEGATE            ((CINOSSync *) 2)
#define DF_INOS_SYNCH_LAST          ((CINOSSync *) 2)
//
#define DF_INOS_LOG_TRIGGER_TYPE_TESTPOINT  uint8(0)
#define DF_INOS_LOG_TRIGGER_TYPE_OVERRUN    uint8(1)
#define DF_INOS_LOG_TRIGGER_TYPE_POSTOVERRUN uint8(2)
#define DF_INOS_LOG_TRIGGER_TYPE_TASK       uint8(3)
#define DF_INOS_LOG_TRIGGER_TYPE_VARLOG     uint8(4)
#define DF_INOS_LOG_TRIGGER_TYPE_USER       uint8(5)
#define DF_INOS_LOG_TRIGGER_TYPE_UNKNOWN    uint8(255)
#define DF_INOS_LOG_SINGLE                  uint8(0)
#define DF_INOS_LOG_ENDLESS                 uint8(1)
 
// --- locking cache -----------------------------------------------------------
 
#ifdef INOS_CACHE_LOCK_SUPPORT
#define ICACHE __attribute__ ((section (".icache")))
#define DCACHE __attribute__ ((section (".dcache")))
#else
#define ICACHE
#define DCACHE
#endif
 
// --- critical irq support ----------------------------------------------------
 
#ifdef INOS_CRITICAL_SUPPORT
#define ICRITICAL __attribute__ ((section (".icritical")))
#define DCRITICAL __attribute__ ((section (".dcritical")))
#else
#define ICRITICAL
#define DCRITICAL
#endif
 
// --- database table structure registration -----------------------------------
 
#if defined(INOS_DESKTOP) || defined(INOS_64)
 
struct SStructDef
{
    // constructor
    SStructDef(const char* apName, const char* apBaseName, uint32 auSize)
        : m_pName(apName), m_pBaseName(apBaseName), m_uSize(auSize)
    {
        m_pNext = m_pFirst; 
        m_pFirst = this;
    };
    // get pointer to first
    static SStructDef* GetFirst()
    {
        return m_pFirst;
    };
    // get pointer to next in list
    SStructDef* GetNext() const
    {
        return m_pNext;
    };
    const char* m_pName;
    const char* m_pBaseName;
    uint32 m_uSize;
    SStructDef* m_pNext;
    static SStructDef* m_pFirst;
};
 
struct SStructColumnDef
{
    // constructor
    SStructColumnDef(SStructDef* apStruct, const char* apName, uint32 auType, uint32 auOffset,
        uint32 auArrayLength, int64 aValue)
        : m_pName(apName), m_uType(auType), m_uOffset(auOffset),
        m_uArrayLength(auArrayLength), m_pStruct(apStruct)
    {
        m_Default.i = aValue;
        m_pNext = m_pFirst;
        m_pFirst = this;
    };
    SStructColumnDef(SStructDef* apStruct, const char* apName, uint32 auType, uint32 auOffset,
        uint32 auArrayLength, uint64 aValue)
        : m_pName(apName), m_uType(auType), m_uOffset(auOffset),
        m_uArrayLength(auArrayLength), m_pStruct(apStruct)
    {
        m_Default.u = aValue;
        m_pNext = m_pFirst;
        m_pFirst = this;
    };
    SStructColumnDef(SStructDef* apStruct, const char* apName, uint32 auType, uint32 auOffset,
        uint32 auArrayLength, double aValue)
        : m_pName(apName), m_uType(auType), m_uOffset(auOffset),
        m_uArrayLength(auArrayLength), m_pStruct(apStruct)
    {
        m_Default.d = aValue;
        m_pNext = m_pFirst;
        m_pFirst = this;
    };
    // get pointer to first
    static SStructColumnDef* GetFirst()
    {
        return m_pFirst;
    };
    // get pointer to next in list
    SStructColumnDef* GetNext() const
    {
        return m_pNext;
    };
    const char* m_pName;
    uint32 m_uType;
    uint32 m_uOffset;
    uint32 m_uArrayLength;
    union {
        int64 i;
        uint64 u;
        double d;
    } m_Default;
    SStructDef* m_pStruct;
    SStructColumnDef* m_pNext;
    static SStructColumnDef* m_pFirst;
};
 
#define DECLARE_STRUCT_BEGIN(aStructName, aTableName, aBaseTable)   \
    char aStructName##tablename[] = aTableName;             \
    char aStructName##basetable[] = aBaseTable;             \
    SStructDef aStructName##_desc (                         \
        (char *)&aStructName##tablename,                    \
        (char *)&aStructName##basetable,                    \
        sizeof(aStructName)                                 \
        );
#define DECLARE_STRUCT_END(aStructName)
 
// offsetof is undefined on non-POD types (specifically occurring here: ones
// with a virtual destructor), however in cases where it actually does not work
// (e.g. virtual inheritance), this has never worked, so suppressing the
// warning seems okay.
// GCC < 13 has a bug where diagnostic pragmas inside macros are ignored
// (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=55578), so in that case disable
// the warning globally from here on.
#if defined(__GNUC__) && __GNUC__ < 13
#pragma GCC diagnostic ignored "-Winvalid-offsetof"
#endif
#define DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, aType, aSize, aValue)  \
    _Pragma("GCC diagnostic push")                                                  \
    _Pragma("GCC diagnostic ignored \"-Winvalid-offsetof\"")                        \
    char aStructName##aMemberName##name[] = aPublicName;                            \
    SStructColumnDef aStructName##aMemberName##_desc (                              \
        &aStructName##_desc,                                                        \
        (char *) &aStructName##aMemberName##name,                                   \
        aType,                                                                      \
        (uintptr) offsetof(aStructName, aMemberName),                               \
        aSize,                                                                      \
        aValue);                                                                    \
    _Pragma("GCC diagnostic pop")
#define DECLARE_STRUCT_INT8(aStructName, aPublicName, aMemberName, aValue, aArrayLength)    \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_int8, aArrayLength, (int64) aValue)    
#define DECLARE_STRUCT_UINT8(aStructName, aPublicName, aMemberName, aValue, aArrayLength)   \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_uint8, aArrayLength, (uint64) aValue)  
#define DECLARE_STRUCT_INT16(aStructName, aPublicName, aMemberName, aValue, aArrayLength)   \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_int16, aArrayLength, (int64) aValue)   
#define DECLARE_STRUCT_UINT16(aStructName, aPublicName, aMemberName, aValue, aArrayLength)  \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_uint16, aArrayLength, (uint64) aValue) 
#define DECLARE_STRUCT_UINT16_NOCHECK(aStructName, aPublicName, aMemberName, aValue, aArrayLength) \
        DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_uint16, aArrayLength, (uint64) aValue)
#define DECLARE_STRUCT_INT32(aStructName, aPublicName, aMemberName, aValue, aArrayLength)   \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_int32, aArrayLength, (int64) aValue)   
#define DECLARE_STRUCT_UINT32(aStructName, aPublicName, aMemberName, aValue, aArrayLength)  \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_uint32, aArrayLength, (uint64) aValue) 
#define DECLARE_STRUCT_INT64(aStructName, aPublicName, aMemberName, aValue, aArrayLength)   \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_int64, aArrayLength, (int64) aValue)   
#define DECLARE_STRUCT_UINT64(aStructName, aPublicName, aMemberName, aValue, aArrayLength)  \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_uint64, aArrayLength, (uint64) aValue) 
#define DECLARE_STRUCT_FLOAT(aStructName, aPublicName, aMemberName, aValue, aArrayLength)   \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_float, aArrayLength, (double) aValue)  
#define DECLARE_STRUCT_DOUBLE(aStructName, aPublicName, aMemberName, aValue, aArrayLength)  \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_double, aArrayLength, (double) aValue) 
#define DECLARE_STRUCT_REAL32(aStructName, aPublicName, aMemberName, aValue, aArrayLength)  \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_real32, aArrayLength, (double) aValue) 
#define DECLARE_STRUCT_REAL64(aStructName, aPublicName, aMemberName, aValue, aArrayLength)  \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_real64, aArrayLength, (double) aValue) 
#define DECLARE_STRUCT_FIXED32(aStructName, aPublicName, aMemberName, aValue, aArrayLength) \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_fixed32, aArrayLength, (double) aValue)    
#define DECLARE_STRUCT_FIXED64(aStructName, aPublicName, aMemberName, aValue, aArrayLength) \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_fixed64, aArrayLength, (double) aValue)    
#define DECLARE_STRUCT_STRING(aStructName, aPublicName, aMemberName, aValue)    \
    char aStructName##aMemberName##value[] = aValue;                            \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_string, sizeof(aStructName::aMemberName), (uint64) &aStructName##aMemberName##value)
#define DECLARE_STRUCT_CHAR(aStructName, aPublicName, aMemberName, aValue, aArrayLength)                \
    char aStructName##aMemberName##value[aArrayLength] = aValue;\
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_string, aArrayLength, (uint64) &aStructName##aMemberName##value)   
#define DECLARE_STRUCT_FILE(aStructName, aPublicName, aMemberName, aValue)      \
    char aStructName##aMemberName##value[] = aValue;                            \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_file, sizeof(aStructName::aMemberName), (uint64) &aStructName##aMemberName##value)
#define DECLARE_STRUCT_BINARY(aStructName, aPublicName, aMemberName, aValue, aArrayLength)              \
    char aStructName##aMemberName##value[aArrayLength] = aValue;\
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_binary, aArrayLength, (uint64) &aStructName##aMemberName##value)   
#else // end if defined(INOS_DESKTOP)
#define STRUCT_DEF __attribute__ ((section (".struct_def"))) __attribute__ ((unused))
#define STRUCT_NAM __attribute__ ((section (".struct_nam")))
 
#define DECLARE_STRUCT_BEGIN(aStructName, aTableName, aBaseTable)                       \
    STRUCT_NAM char aStructName##tablename[] = aTableName;                      \
    STRUCT_NAM char aStructName##basetable[] = aBaseTable;                      \
    STRUCT_DEF char* aStructName##ptablename = (char *) &aStructName##tablename;    \
    STRUCT_DEF char* aStructName##pbasetable = (char *) &aStructName##basetable;    \
    STRUCT_DEF uint32 aStructName##size = sizeof(aStructName);                   \
    STRUCT_DEF uint32 aStructName##align1 = 0;
 
#define DECLARE_STRUCT_END(aStructName)                 \
    STRUCT_DEF uint32 aStructName##end = 0;     \
    STRUCT_DEF uint32 aStructName##align2 = 0;
 
#define DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, aType, aSize)      \
    STRUCT_NAM char aStructName##aMemberName##name[] = aPublicName;                 \
    STRUCT_DEF char* aStructName##aMemberName##pname = (char *) &aStructName##aMemberName##name;\
    STRUCT_DEF uint32 aStructName##aMemberName##type = aType;                   \
    STRUCT_DEF uint32 aStructName##aMemberName##offset = (uintptr) &((aStructName *)0x100)->aMemberName - 0x100; \
    STRUCT_DEF uint32 aStructName##aMemberName##size = aSize;
 
#define DECLARE_STRUCT_INT8(aStructName, aPublicName, aMemberName, aValue, aArrayLength)        \
    static_assert((sizeof(aStructName::aMemberName) == sizeof(int8)) || (sizeof(aStructName::aMemberName) == (aArrayLength * sizeof(int8))), "Detected type mismatch registering struct member for dt2"); \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_int8, aArrayLength)    \
    STRUCT_DEF int64 aStructName##aMemberName##value = aValue;
#define DECLARE_STRUCT_UINT8(aStructName, aPublicName, aMemberName, aValue, aArrayLength)       \
    static_assert((sizeof(aStructName::aMemberName) == sizeof(uint8)) || (sizeof(aStructName::aMemberName) == (aArrayLength * sizeof(uint8))), "Detected type mismatch registering struct member for dt2"); \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_uint8, aArrayLength)   \
    STRUCT_DEF uint64 aStructName##aMemberName##value = aValue;
#define DECLARE_STRUCT_INT16(aStructName, aPublicName, aMemberName, aValue, aArrayLength)       \
    static_assert((sizeof(aStructName::aMemberName) == sizeof(int16)) || (sizeof(aStructName::aMemberName) == (aArrayLength * sizeof(int16))), "Detected type mismatch registering struct member for dt2"); \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_int16, aArrayLength)   \
    STRUCT_DEF int64 aStructName##aMemberName##value = aValue;
#define DECLARE_STRUCT_UINT16(aStructName, aPublicName, aMemberName, aValue, aArrayLength)      \
    static_assert((sizeof(aStructName::aMemberName) == sizeof(uint16)) || (sizeof(aStructName::aMemberName) == (aArrayLength * sizeof(uint16))), "Detected type mismatch registering struct member for dt2"); \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_uint16, aArrayLength)  \
    STRUCT_DEF uint64 aStructName##aMemberName##value = aValue;
#define DECLARE_STRUCT_UINT16_NOCHECK(aStructName, aPublicName, aMemberName, aValue, aArrayLength)    \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_uint16, aArrayLength)  \
    STRUCT_DEF uint64 aStructName##aMemberName##value = aValue;
#define DECLARE_STRUCT_INT32(aStructName, aPublicName, aMemberName, aValue, aArrayLength)       \
    static_assert((sizeof(aStructName::aMemberName) == sizeof(int32)) || (sizeof(aStructName::aMemberName) == (aArrayLength * sizeof(int32))), "Detected type mismatch registering struct member for dt2"); \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_int32, aArrayLength)   \
    STRUCT_DEF int64 aStructName##aMemberName##value = aValue;
#define DECLARE_STRUCT_UINT32(aStructName, aPublicName, aMemberName, aValue, aArrayLength)      \
    static_assert((sizeof(aStructName::aMemberName) == sizeof(uint32)) || (sizeof(aStructName::aMemberName) == (aArrayLength * sizeof(uint32))), "Detected type mismatch registering struct member for dt2"); \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_uint32, aArrayLength)  \
    STRUCT_DEF uint64 aStructName##aMemberName##value = aValue;
#define DECLARE_STRUCT_INT64(aStructName, aPublicName, aMemberName, aValue, aArrayLength)       \
    static_assert((sizeof(aStructName::aMemberName) == sizeof(int64)) || (sizeof(aStructName::aMemberName) == (aArrayLength * sizeof(int64))), "Detected type mismatch registering struct member for dt2"); \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_int64, aArrayLength)   \
    STRUCT_DEF int64 aStructName##aMemberName##value = aValue;
#define DECLARE_STRUCT_UINT64(aStructName, aPublicName, aMemberName, aValue, aArrayLength)      \
    static_assert((sizeof(aStructName::aMemberName) == sizeof(uint64)) || (sizeof(aStructName::aMemberName) == (aArrayLength * sizeof(uint64))), "Detected type mismatch registering struct member for dt2"); \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_uint64, aArrayLength)  \
    STRUCT_DEF uint64 aStructName##aMemberName##value = aValue;
#define DECLARE_STRUCT_FLOAT(aStructName, aPublicName, aMemberName, aValue, aArrayLength)       \
    static_assert((sizeof(aStructName::aMemberName) == sizeof(float)) || (sizeof(aStructName::aMemberName) == (aArrayLength * sizeof(float))), "Detected type mismatch registering struct member for dt2"); \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_float, aArrayLength)   \
    STRUCT_DEF double aStructName##aMemberName##value = aValue;
#define DECLARE_STRUCT_DOUBLE(aStructName, aPublicName, aMemberName, aValue, aArrayLength)      \
    static_assert((sizeof(aStructName::aMemberName) == sizeof(double)) || (sizeof(aStructName::aMemberName) == (aArrayLength * sizeof(double))), "Detected type mismatch registering struct member for dt2"); \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_double, aArrayLength)  \
    STRUCT_DEF double aStructName##aMemberName##value = aValue;
#define DECLARE_STRUCT_REAL32(aStructName, aPublicName, aMemberName, aValue, aArrayLength)      \
    static_assert((sizeof(aStructName::aMemberName) == sizeof(real32)) || (sizeof(aStructName::aMemberName) == (aArrayLength * sizeof(real32))), "Detected type mismatch registering struct member for dt2"); \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_real32, aArrayLength)  \
    STRUCT_DEF double aStructName##aMemberName##value = aValue;
#define DECLARE_STRUCT_REAL64(aStructName, aPublicName, aMemberName, aValue, aArrayLength)      \
    static_assert((sizeof(aStructName::aMemberName) == sizeof(real64)) || (sizeof(aStructName::aMemberName) == (aArrayLength * sizeof(real64))), "Detected type mismatch registering struct member for dt2"); \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_real64, aArrayLength)  \
    STRUCT_DEF double aStructName##aMemberName##value = aValue;
#define DECLARE_STRUCT_FIXED32(aStructName, aPublicName, aMemberName, aValue, aArrayLength)     \
    static_assert((sizeof(aStructName::aMemberName) == sizeof(fixed32)) || (sizeof(aStructName::aMemberName) == (aArrayLength * sizeof(fixed32))), "Detected type mismatch registering struct member for dt2"); \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_fixed32, aArrayLength) \
    STRUCT_DEF double aStructName##aMemberName##value = aValue;
#define DECLARE_STRUCT_FIXED64(aStructName, aPublicName, aMemberName, aValue, aArrayLength)     \
    static_assert((sizeof(aStructName::aMemberName) == sizeof(fixed64)) || (sizeof(aStructName::aMemberName) == (aArrayLength * sizeof(fixed64))), "Detected type mismatch registering struct member for dt2"); \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_fixed64, aArrayLength) \
    STRUCT_DEF double aStructName##aMemberName##value = aValue;
#define DECLARE_STRUCT_STRING(aStructName, aPublicName, aMemberName, aValue)                    \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_string, sizeof(((aStructName *)0)->aMemberName))\
    STRUCT_NAM char aStructName##aMemberName##value[] = aValue;\
    STRUCT_DEF char* aStructName##aMemberName##pvalue = (char *) &aStructName##aMemberName##value;\
    STRUCT_DEF uint32 aStructName##aMemberName##dummy = 0;
#define DECLARE_STRUCT_CHAR(aStructName, aPublicName, aMemberName, aValue, aArrayLength)        \
    static_assert(sizeof(aStructName::aMemberName) == (aArrayLength * sizeof(char)), "Detected type mismatch registering struct member for dt2"); \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_string, aArrayLength)\
    STRUCT_NAM char aStructName##aMemberName##value[aArrayLength] = aValue;\
    STRUCT_DEF char* aStructName##aMemberName##pvalue = (char *) &aStructName##aMemberName##value;\
    STRUCT_DEF uint32 aStructName##aMemberName##dummy = 0;
#define DECLARE_STRUCT_FILE(aStructName, aPublicName, aMemberName, aValue)                  \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_file, sizeof(((aStructName *)0)->aMemberName))\
    STRUCT_NAM char aStructName##aMemberName##value[] = aValue;\
    STRUCT_DEF char* aStructName##aMemberName##pvalue = (char *) &aStructName##aMemberName##value;\
    STRUCT_DEF uint32 aStructName##aMemberName##dummy = 0;
#define DECLARE_STRUCT_BINARY(aStructName, aPublicName, aMemberName, aValue, aArrayLength)      \
    DECLARE_STRUCT_MEMBER(aStructName, aPublicName, aMemberName, defType_binary, aArrayLength)\
    STRUCT_NAM char aStructName##aMemberName##value[aArrayLength] = aValue;\
    STRUCT_DEF char* aStructName##aMemberName##pvalue = (char *) &aStructName##aMemberName##value;\
    STRUCT_DEF uint32 aStructName##aMemberName##dummy = 0;
#endif // not INOS_DESKTOP
 
#ifdef _MSC_VER
    #define INOS_LIKELY(x)      (x)
    #define INOS_UNLIKELY(x)    (x)
    #define INOS_NO_INLINE
    #define INOS_FORMAT(a,b)
    #define INOS_COMPILE_OPTIMIZED
#else
    #define INOS_LIKELY(x)      __builtin_expect(!!(x), 1)
    #define INOS_UNLIKELY(x)    __builtin_expect(!!(x), 0)
    #define INOS_NO_INLINE      __attribute__ ((noinline))
    #if defined(INOS_WINDOWS)
    #define INOS_FORMAT(a,b)
    #else
    #define INOS_FORMAT(a,b)    __attribute__ ((format (printf, a, b)))
    #endif
    #if defined(__clang__)
    #define INOS_COMPILE_OPTIMIZED
    #define INOS_COMPILE_NONOPTIMIZED __attribute__ ((optnone))
    #else
    #define INOS_COMPILE_OPTIMIZED  __attribute__((optimize("-O2")))
    #define INOS_COMPILE_NONOPTIMIZED   __attribute__((optimize("-O0")))
    #endif
    #if defined(INOS_OCRAM_SUPPORT)
    #define INOS_OCRAM __attribute__((section(".ocram")))
    #define INOS_OCRAM_DATA __attribute__((section(".ocramdata")))
    extern char __OCRAM_START[];
    extern uintnbr __ocrambgn;
    #define INOS_OCRAM_ADDR(var) (void*) ((uintptr) &var - reinterpret_cast<uintptr>(__OCRAM_START) + __ocrambgn)
    #else
    #define INOS_OCRAM
    #define INOS_OCRAM_DATA
    #endif
#endif
 
void INOS_NO_INLINE DoAssert(const char* apCondition, const char* apFile, const int aiLine);
void INOS_NO_INLINE DoAssertMsg(const char* apCondition, const char* apFile, const int aiLine, const char* apMsg, ...) INOS_FORMAT(4,5);
 
extern bool g_bThrowExceptionOnAssert;
 
#define ASSERT_ALWAYS(f)                      \
    if (INOS_UNLIKELY(!(f))){                      \
        DoAssert(#f, __FILE__, __LINE__);     \
    }
 
#ifdef _MSC_VER
    #define ASSERT_ALWAYS_MSG(f, i_Msg, ...)                         \
        if( INOS_UNLIKELY(!(f)) ) {                          \
            DoAssertMsg(#f, __FILE__, __LINE__, i_Msg, __VA_ARGS__); \
        }
#else
    #define ASSERT_ALWAYS_MSG(f, i_Msg, i_Args...)                   \
        if( INOS_UNLIKELY(!(f)) ) {                          \
            DoAssertMsg(#f, __FILE__, __LINE__, i_Msg, ##i_Args);    \
        }
#endif
 
#ifdef  _DEBUG
    #define ASSERT(f)                           \
        if (INOS_UNLIKELY(!(f))){               \
            DoAssert(#f, __FILE__, __LINE__);   \
        }
#else   // _DEBUG
    #define ASSERT(f)   ((void)0)
#endif  // !_DEBUG
 
#ifdef INOS_CONCURRENCY_CHECK
//------------------------------------------------------------------------------
//--- class CINOSConcurrencyCheck ----------------------------------------------
//------------------------------------------------------------------------------
//
//
//
// include concurrency check
#include "cinosconcurrencycheck.h"
 
#define INOS_CONCURRENCY_CHECK_DECLARE CINOSConcurrencyCheck m_ConcurrencyCheck;
 
#define INOS_CONCURRENCY_CHECK_CLAIM(ref) (ref)->m_ConcurrencyCheck.Claim();
 
#define INOS_CONCURRENCY_CHECK_FREE(ref) (ref)->m_ConcurrencyCheck.Free();
 
#else
 
#define INOS_CONCURRENCY_CHECK_DECLARE
#define INOS_CONCURRENCY_CHECK_CLAIM(Check)
#define INOS_CONCURRENCY_CHECK_FREE(Check)
 
#endif
 
 
#if defined(INOS_TESTING) and !defined(INOS_DESKTOP)
    #define INOS_TESTING_INTERRUPTION_POINT  Relinquish();
#else
    #define INOS_TESTING_INTERRUPTION_POINT
#endif
 
/* define by INOS for historical reasons: prior C++11, there was no
 static_assert and therefore INOS defined this macro. Now that C++11 provides
 it, INOS still provides this macro for backward compatibility. New code should
 prefer C++11 static_assert over this macro.
 */
#define STATIC_ASSERT(e, msg) \
    static_assert(e, #msg);
 
// make a sizeof for a struct member, sizeof(aClass::aMember) is not allowed anymore
#define sizeofm(aClass, aMember) sizeof(((aClass*)0x100)->aMember)
// make a offsetof that accepts classes, offsetof(aClass::aMember) only works for POD
#define inos_offsetof(aClass, aMember) (uintnbr)((char*)&(((aClass*)0x100)->aMember)-(char*)0x100)
 
#if !defined(INOS_DESKTOP)
 
/*
 * single-evaluated MIN/MAX macros
 * based on https://stackoverflow.com/questions/3437404/min-and-max-in-c
 */
#define INOS_MIN(a, b) ({ \
    __typeof__ (a) _a = (a); \
    __typeof__ (b) _b = (b); \
    _a < _b ? _a : _b; \
})
 
#define INOS_MAX(a, b) ({ \
    __typeof__ (a) _a = (a); \
    __typeof__ (b) _b = (b); \
    _a > _b ? _a : _b; \
})
 
#else
 
/*
 * poor man's MIN/MAX macros (due to lack of typeof operator in VC++)
 */
#define INOS_MIN(X, Y) (((X) < (Y)) ? (X) : (Y))
#define INOS_MAX(X, Y) (((X) > (Y)) ? (X) : (Y))
 
#endif
 
 
#define INOS_STRINGIFY(x) #x
 
/*
 * macro to convert numeric literals to string.
 *
 * useful for compile-time concatenation.
 * see https://stackoverflow.com/a/5459929
 */
#define INOS_STR(x) INOS_STRINGIFY(x)
 
#define INOS_IGNORE_WARNING(warning) \
    _Pragma(INOS_STRINGIFY(GCC diagnostic push)) \
    _Pragma(INOS_STRINGIFY(GCC diagnostic ignored warning))
#define INOS_RESTORE_WARNING \
    _Pragma(INOS_STRINGIFY(GCC diagnostic pop))
 
#define INOS_IGNORE_WARNING_DEPRECATED               INOS_IGNORE_WARNING("-Wdeprecated-declarations")
 
#ifndef INOS_DEPRECATED
    #if __cplusplus >= 201402L
        #define INOS_DEPRECATED(msg) [[deprecated(msg)]]
    #else
        #define INOS_DEPRECATED(msg)
    #endif
#endif
 
//------------------------------------------------------------------------------
// templates to staticly (at compile time) generate a bitmap form a list of values.
//------------------------------------------------------------------------------
//
template<typename T, uint8... Values>
struct TINOSStaticBitmap;
 
template<typename T, uint8 First, uint8... Values>
struct TINOSStaticBitmap<T, First, Values...> {
public:
    static const T s_uBitmap = 1<<First | TINOSStaticBitmap<T,Values...>::s_uBitmap;
};
template<typename T>
struct TINOSStaticBitmap<T> {
public:
    static const T s_uBitmap = 0;
};
 
//------------------------------------------------------------------------------
// makros to staticly (at compile time) generate a bitmap form a list of values.
//------------------------------------------------------------------------------
// Use this makros by simply listing bit values, e.g.: 
// STATIC_UINT8_BITMAP(0, 1, 4, 7) -> 0b10010011 -> 0x93
 
#define STATIC_UINT64_BITMAP(...) (TINOSStaticBitmap<uint64,__VA_ARGS__>::s_uBitmap)
#define STATIC_UINT32_BITMAP(...) (TINOSStaticBitmap<uint32,__VA_ARGS__>::s_uBitmap)
#define STATIC_UINT16_BITMAP(...) (TINOSStaticBitmap<uint16,__VA_ARGS__>::s_uBitmap)
#define STATIC_UINT8_BITMAP(...)  (TINOSStaticBitmap<uint8,__VA_ARGS__>::s_uBitmap)
 
//------------------------------------------------------------------------------
// templates for safe type-casting
//------------------------------------------------------------------------------
//
/*
 * this cast performs conversion between two types and checks that
 * the value stays the same, i.e. there's no loss of precision.
 *
 * This is useful to convert from uint64 to uint32 under the assumption that
 * only the lower 32-bit of the uint64 values are used, and raise an asset otherwise
 *
 * based on https://stackoverflow.com/questions/23830292/c-static-cast-with-assert
 *
 * if you get here while debugging, this probably means that you need to use
 * "bigger" types (e.g. uint64) for the variables involved in the statement
 * that triggered the assert.
 */
template<typename TO, typename FROM>
inline TO checked_static_cast(const FROM& from_value)
{
    TO to_value = static_cast<TO>(from_value);
    FROM back_value = static_cast<FROM>(to_value);
    ASSERT_ALWAYS_MSG(from_value == back_value,
        "casting a value resulted in loss of information/precision");
    return to_value;
}
 
//------------------------------------------------------------------------------
// end of file
//------------------------------------------------------------------------------
 
#endif  // INC_INOSMACRO_H