le_basics.h

Go to the documentation of this file.

#ifndef LEGATO_BASICS_INCLUDE_GUARD
#define LEGATO_BASICS_INCLUDE_GUARD

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#ifdef __ARMCC_VERSION
#pragma anon_unions
#endif

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef enum
{
    LE_OK = 0,                  
    LE_NOT_FOUND = -1,          
    LE_NOT_POSSIBLE = -2,       
    LE_OUT_OF_RANGE = -3,       
    LE_NO_MEMORY = -4,          
    LE_NOT_PERMITTED = -5,      
    LE_FAULT = -6,              
    LE_COMM_ERROR = -7,         
    LE_TIMEOUT = -8,            
    LE_OVERFLOW = -9,           
    LE_UNDERFLOW = -10,         
    LE_WOULD_BLOCK = -11,       
    LE_DEADLOCK = -12,          
    LE_FORMAT_ERROR = -13,      
    LE_DUPLICATE = -14,         
    LE_BAD_PARAMETER = -15,     
    LE_CLOSED = -16,            
    LE_BUSY = -17,              
    LE_UNSUPPORTED = -18,       
    LE_IO_ERROR = -19,          
    LE_NOT_IMPLEMENTED = -20,   
    LE_UNAVAILABLE = -21,       
    LE_TERMINATED = -22,        
    LE_IN_PROGRESS = -23,       
    LE_SUSPENDED = -24,         
}
le_result_t;


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define EXIT_UNAVAILABLE 69


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef enum
{
    LE_OFF = 0,
    LE_ON  = 1,
}
le_onoff_t;


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define BIT0        0x01
#define BIT1        0x02
#define BIT2        0x04
#define BIT3        0x08
#define BIT4        0x10
#define BIT5        0x20
#define BIT6        0x40
#define BIT7        0x80
// @}

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define CONTAINER_OF(memberPtr, type, member)                                                       \
    ((type*)(((uint8_t*)(memberPtr))-((size_t)(&(((type*)0)->member)))))


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define NUM_ARRAY_MEMBERS(array) \
    (sizeof(array) / sizeof((array)[0]))


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define INDEX_OF_ARRAY_MEMBER(array, memberPtr) \
    ((((size_t)memberPtr) - ((size_t)array)) / sizeof(*(memberPtr)))


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define STRINGIZE(x)  STRINGIZE_EXPAND(x)

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define STRINGIZE_EXPAND(x)     #x   // Needed to expand macros.

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define CAT(a, ...) PRIMITIVE_CAT(a, __VA_ARGS__)

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define PRIMITIVE_CAT(a, ...) a ## __VA_ARGS__

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define SECOND(a, b, ...) b

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_DEFAULT(...) SECOND(__VA_ARGS__)

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_SHARED __attribute__((visibility ("default")))

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#ifdef __GNUC_GNU_INLINE__
// Using gcc inline semantics
#  define LE_DECLARE_INLINE extern inline
#  define LE_DEFINE_INLINE inline
#else
// Use C99 inline semantics
#  define LE_DECLARE_INLINE inline
#  define LE_DEFINE_INLINE extern inline
#endif

// Clang feature check macros -- define to return sensible defaults if macro is not available.
#ifndef __is_identifier
#  define __is_identifier(x) 1
#endif

#ifndef __has_warning
#  define  __has_warning(x) 0
#endif

#ifndef __has_attribute
#  define __has_attribute(x) 0
#endif

#if !__is_identifier(_Nonnull)

// Nullability information is not complete.  Normally clang will warn in that case.
#  if __has_warning("-Wnullability-completeness")
#    pragma clang diagnostic ignored "-Wnullability-completeness"
#  endif

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#  define LE_NONNULL _Nonnull

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#  define LE_NULLABLE _Nullable
#else
#  define LE_NONNULL
#  define LE_NULLABLE
#endif

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_UNUSED(v)    ((void) (v))

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#if (__STDC_VERSION__ >= 199901L) || LE_CONFIG_LINUX
#   define __PRIS_PREFIX "z"
#elif defined(__LP64__) || defined(_LP64)
#   define __PRIS_PREFIX "ll"
#else
#   define __PRIS_PREFIX "l"
#endif

#define PRIdS __PRIS_PREFIX "d"
#define PRIxS __PRIS_PREFIX "x"
#define PRIuS __PRIS_PREFIX "u"
#define PRIXS __PRIS_PREFIX "X"
#define PRIoS __PRIS_PREFIX "o"


#if !defined(static_assert) && !defined(__cplusplus)
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#  if __GNUC__ || __STDC_VERSION__ >= 201112L
#    define static_assert(cond, msg) _Static_assert((cond), #cond ": " msg)
#  else
#    define static_assert(cond, msg) ((void)sizeof(char[1 - 2*!(cond)]))
#  endif
#endif

#if __GNUC__
// ({ }) is a GNU extension, so only use it if compiler is GCC-compatible
#  define inline_static_assert(cond, msg) ({ static_assert(cond, msg); })
#else
#  define inline_static_assert(cond, msg) ((void)(0))
#endif

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_CONFIG_IS_ENABLED(option)    (("" STRINGIZE(option))[0] == '1')

#endif // LEGATO_BASICS_INCLUDE_GUARD