sbgDefines.h

Go to the documentation of this file.

 
#ifndef SBG_DEFINES_H
#define SBG_DEFINES_H
 
// Standard headers
#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <time.h>
 
//
// XXX If NDEBUG is defined, most libraries define assert() as ((void)0), which may
// cause "defined but not used" warnings. Redefine assert() in a way that safely
// prevents this warning, i.e. without triggering the expression side effects.
//
#ifdef NDEBUG
#undef assert
#define assert(expression) ((void)sizeof(expression))
#endif // NDEBUG
 
#ifdef _MSC_VER
        #if defined(SBG_COMMON_LIB_API_EXPORT)
                #define SBG_COMMON_LIB_API __declspec(dllexport)
        #elif defined(SBG_COMMON_LIB_API_IMPORT)
                #define SBG_COMMON_LIB_API __declspec(dllimport)
        #else
                #define SBG_COMMON_LIB_API
        #endif
#else
        #define SBG_COMMON_LIB_API
#endif
 
//----------------------------------------------------------------------//
//- Global definitions                                                 -//
//----------------------------------------------------------------------//
#ifndef SBG_DISABLE
        #define SBG_DISABLE     (0)
#endif
 
#ifndef SBG_ENABLE
        #define SBG_ENABLE      (1)
#endif
 
#ifndef FALSE
    #define FALSE        (0)
#endif
 
#ifndef TRUE
    #define TRUE        (1)
#endif
 
#ifndef NULL
        #define NULL            (0)
#endif
 
#ifndef SBG_INVALID_HANDLE
        #define SBG_INVALID_HANDLE      (0x00000000u)
#endif
 
#ifndef SBG_NOT_FOUND
        #define SBG_NOT_FOUND           (0xFFFFFFFFu)
#endif
 
#ifndef SBG_UNDEFINED
        #define SBG_UNDEFINED           (0xFFFFFFFFu)
#endif
 
#ifndef SBG_ARRAY_SIZE
        #define SBG_ARRAY_SIZE(a)       (sizeof(a) / sizeof((a)[0]))
#endif
 
#ifndef SBG_STRLEN
        #define SBG_STRLEN(s)           (sizeof(s) - 1)
#endif
 
#ifndef SBG_CONTAINER_OF
        #define SBG_CONTAINER_OF(ptr, type, member)             ((type *)((char *)(ptr) - offsetof(type, member)))
#endif
 
#ifndef SBG_LIKELY
        #if defined(__GNUC__)
                #define SBG_LIKELY(expr)                __builtin_expect((bool)(expr), true)
        #else
                #define SBG_LIKELY(expr)                (expr)
        #endif
#endif
 
#ifndef SBG_UNLIKELY
        #if defined(__GNUC__)
                #define SBG_UNLIKELY(expr)              __builtin_expect((bool)(expr), false)
        #else
                #define SBG_UNLIKELY(expr)              (expr)
        #endif
#endif
 
#ifndef __SBG_TYPEOF
        #ifdef __cplusplus
                #define __SBG_TYPEOF(x)                 decltype(x)
        #elif defined(__GNUC__)
                #define __SBG_TYPEOF(x)                 typeof(x)
        #elif defined(__TI_COMPILER_VERSION__)
                #define __SBG_TYPEOF(x)                 typeof(x)
        #endif
#endif
 
#ifndef SBG_CONST_CAST_AA
        #ifdef __SBG_TYPEOF
                #define SBG_CONST_CAST_AA(x)    ((const __SBG_TYPEOF((x)[0][0])(*)[SBG_ARRAY_SIZE((x)[0])])(x))
        #else
                #define SBG_CONST_CAST_AA(x)    x
        #endif
#endif
 
#ifndef SBG_CONST_CAST_PP
        #ifdef __SBG_TYPEOF
                #define SBG_CONST_CAST_PP(x)    ((const __SBG_TYPEOF(**(x))**)(x))
        #else
                #define SBG_CONST_CAST_PP(x)    x
        #endif
#endif
 
#ifndef __GNUC__
#ifndef __BASE_FILE__
        #define __BASE_FILE__ __FILE__
#endif
#endif
 
#ifdef __cplusplus
        #define SBG_DELETE(p)           if (p){delete (p); (p) = NULL;}
        #define SBG_DELETE_ARRAY(p)     if (p){delete[] (p); (p) = NULL;}
        #define SBG_FREE(p)                     if (p){free(p); (p) = NULL;}
        #define SBG_FREE_ARRAY(p)       if (p){free(p); (p) = NULL;}
#else
        #define SBG_DELETE                      if (p){free(p); (p) = NULL;}
        #define SBG_DELETE_ARRAY        if (p){free(p); (p) = NULL;}
        #define SBG_FREE(p)                     if (p){free(p); (p) = NULL;}
        #define SBG_FREE_ARRAY(p)       if (p){free(p); (p) = NULL;}
#endif
 
//----------------------------------------------------------------------//
//- Compiler definitions                                               -//
//----------------------------------------------------------------------//
 
#ifndef SBG_INLINE
        #if defined(_MSC_VER)
                #define SBG_INLINE                      __inline
        #else
                #define SBG_INLINE          static inline
        #endif
#endif
 
#ifndef SBG_UNUSED_PARAMETER
        #define SBG_UNUSED_PARAMETER(x)         (void)(x)
#endif
 
#ifndef SBG_FALLTHROUGH
        #if __cplusplus >= 201703L
                #define SBG_FALLTHROUGH                 [[fallthrough]]                                 /* introduced in C++ 17 */
        #elif defined(__GNUC__)
                #define SBG_FALLTHROUGH                 __attribute__ ((fallthrough))
        #else
                #define SBG_FALLTHROUGH
        #endif
#endif
 
//----------------------------------------------------------------------//
//- Macro used to defined packed structures                            -//
//----------------------------------------------------------------------//
 
#ifdef __GNUC__
        #define SBG_BEGIN_PACKED()
#elif defined(__TI_COMPILER_VERSION__)
        #define SBG_BEGIN_PACKED()
#elif defined(_MSC_VER)
        #define SBG_BEGIN_PACKED()      __pragma(pack(push, 1))
#else
        #error you must byte-align these structures with the appropriate compiler directives
#endif
 
#ifdef __GNUC__
        #define SBG_PACKED                      __attribute__((packed))
#elif defined(__TI_COMPILER_VERSION__)
        #define SBG_PACKED                      __attribute__((packed))
#elif defined(_MSC_VER)
        #define SBG_PACKED
#else
        #error you must byte-align these structures with the appropriate compiler directives
#endif
 
#ifdef __GNUC__
        #define SBG_END_PACKED()
#elif defined(__TI_COMPILER_VERSION__)
        #define SBG_END_PACKED()
#elif defined(_MSC_VER)
        #define SBG_END_PACKED()                __pragma(pack(pop))
#else
        #error you must byte-align these structures with the appropriate compiler directives
#endif
 
//----------------------------------------------------------------------//
//- Deprecation definitions                                                            -//
//----------------------------------------------------------------------//
 
#ifdef __GNUC__
        #define SBG_DEPRECATED(func) func __attribute__ ((deprecated))
#elif defined(__TI_COMPILER_VERSION__)
        #define SBG_DEPRECATED(func) func __attribute__ ((deprecated))
#elif defined(_MSC_VER)
        #define SBG_DEPRECATED(func) __declspec(deprecated) func
#else
        //#warning "WARNING: You need to implement SBG_DEPRECATED for this compiler"
        #define SBG_DEPRECATED(func) func
#endif
 
#ifdef __GNUC__
        #define SBG_DEPRECATED_MACRO(func) __pragma(deprecated(func))
#elif defined(_MSC_VER)
#define SBG_DEPRECATED_MACRO(func) __pragma(deprecated(func))
#else
        //#warning "WARNING: You need to implement SBG_DEPRECATED_MACRO for this compiler"
        #define SBG_DEPRECATED_MACRO(func) func
#endif
 
//----------------------------------------------------------------------//
//- Basic maths definitions                                            -//
//----------------------------------------------------------------------//
#ifndef SBG_PI
        #define SBG_PI 3.14159265358979323846
#endif
 
#ifndef SBG_PI_F
        #define SBG_PI_F 3.14159265358979323846f
#endif
 
#ifndef sbgAbs
        #define sbgAbs(x)                               (((x) < 0) ? -(x) : (x))
#endif
 
#ifndef sbgMax
        #define sbgMax(a,b)            (((a) > (b)) ? (a) : (b))
#endif
 
#ifndef sbgMin
        #define sbgMin(a,b)            (((a) < (b)) ? (a) : (b))
#endif
 
#ifndef sbgClamp
        #define sbgClamp(value, minValue, maxValue)            (((value) < (minValue))?(minValue): ((value) > (maxValue)?maxValue:value))
#endif
 
#ifndef sbgDivCeil
        #define sbgDivCeil(n, d)                (((n) + (d) - 1) / (d))
#endif
 
SBG_INLINE double sbgRadToDegD(double angle)
{
        return angle * 180.0 / SBG_PI;
}
 
SBG_INLINE double sbgDegToRadD(double angle)
{
        return angle * SBG_PI / 180.0;
}
 
SBG_INLINE float sbgRadToDegF(float angle)
{
        return angle * 180.0f / SBG_PI_F;
}
 
SBG_INLINE float sbgDegToRadF(float angle)
{
        return angle * SBG_PI_F / 180.0f;
}
 
#endif  /* __SBG_DEFINES_H__ */