macros.h

Go to the documentation of this file.

 
#ifndef _UTILS_MACROS_H_
#define _UTILS_MACROS_H_
 
#ifdef __cplusplus
#include <vector>
#include <map>
#include <string>
#include <utility>
 
#ifndef ARDUINO
using std::map;
#endif
using std::vector;
using std::string;
using std::pair;
 
#endif
 
#include <stdlib.h>   // for abort
 
#if defined(__EMSCRIPTEN__) 
#if defined(EXPECT_DEATH)
#undef EXPECT_DEATH
#endif
#define EXPECT_DEATH(x...) 
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
extern int g_death_lineno;
extern const char* g_death_file;
#ifdef __cplusplus
}
#endif
 
#if defined(__FreeRTOS__)
 
#ifdef RECORD_DEATH_FILE
#define RECORD_DEATH() do { g_death_file = __FILE__ ; g_death_lineno = __LINE__; } while(0)
#else
#define RECORD_DEATH() do { g_death_lineno = __LINE__; } while(0)
#endif
 
#define HASSERT(x) do { if (!(x)) { RECORD_DEATH(); abort(); } } while(0)
 
#define DIE(MSG) abort()
 
#elif defined(ESP32) || defined(ESP_PLATFORM)
 
#include <stdio.h>
#include <assert.h>
 
// Locate the relevant version of ets_sys.h based on the IDF_TARGET
#if defined(CONFIG_IDF_TARGET_ESP32)
#include <esp32/rom/ets_sys.h>
#elif defined(CONFIG_IDF_TARGET_ESP32S2)
#include <esp32s2/rom/ets_sys.h>
#elif defined(CONFIG_IDF_TARGET_ESP32S3)
#include <esp32s3/rom/ets_sys.h>
#elif defined(CONFIG_IDF_TARGET_ESP32C3)
#include <esp32c3/rom/ets_sys.h>
#else
#error Unknown/Unsupported ESP32 variant.
#endif // CONFIG_IDF_TARGET_ESP32
 
// For the ESP32 we are using ets_printf() instead of printf() to avoid the
// internal locking within the newlib implementation. This locking can cause
// difficult to parse backtraces when an ISR is on the same core as the code
// that crashes due to these two macros.
 
#define HASSERT(x) do { if (!(x)) { ets_printf("Assertion failed in file " __FILE__ " line %d: assert(%s)\n", __LINE__, #x); g_death_file = __FILE__; g_death_lineno = __LINE__; assert(0); abort();} } while(0)
 
#define DIE(MSG) do { ets_printf("Crashed in file " __FILE__ " line %d: " MSG "\n", __LINE__); assert(0); abort(); } while(0)
 
#elif defined(ESP_NONOS) || defined(ARDUINO)
 
#include <stdio.h>
#include <assert.h>
 
#define HASSERT(x) do { if (!(x)) { printf("Assertion failed in file " __FILE__ " line %d: assert(%s)\n", __LINE__, #x); g_death_file = __FILE__; g_death_lineno = __LINE__; assert(0); abort();} } while(0)
 
#define DIE(MSG) do { printf("Crashed in file " __FILE__ " line %d: " MSG "\n", __LINE__); assert(0); abort(); } while(0)
 
#else
 
#include <assert.h>
#include <stdio.h>
 
#ifdef NDEBUG
#define HASSERT(x) do { if (!(x)) { fprintf(stderr, "Assertion failed in file " __FILE__ " line %d: assert(" #x ")\n", __LINE__); g_death_file = __FILE__; g_death_lineno = __LINE__; abort();} } while(0)
#else
#define HASSERT(x) do { assert(x); } while(0)
#endif
 
#define DIE(MSG) do { fprintf(stderr, "Crashed in file " __FILE__ " line %d: " MSG "\n", __LINE__); g_death_file = __FILE__; g_death_lineno = __LINE__; abort(); } while(0)
 
#endif
 
#ifdef NDEBUG
 
#define DASSERT(x) 
 
#else
 
#define DASSERT(x) HASSERT(x)
 
#endif
 
 
#define DISALLOW_COPY_AND_ASSIGN(TypeName)                                     \
                         \
    TypeName(const TypeName &);                                                \
                      \
    void operator=(const TypeName &)
 
#define OVERRIDE override 
 
#ifndef ARRAYSIZE
#define ARRAYSIZE(a) (sizeof(a) / sizeof(a[0]))
#endif
 
#define INHERIT_CONSTRUCTOR(CURRENT_CLASS, BASE_CLASS)                         \
    template <typename... Args>                                                \
    explicit CURRENT_CLASS(Args... args)                                       \
        : BASE_CLASS(args...)                                                  \
    {                                                                          \
    }
 
#define INHERIT_CONSTEXPR_CONSTRUCTOR(CURRENT_CLASS, BASE_CLASS)               \
    template <typename... Args>                                                \
    explicit constexpr CURRENT_CLASS(Args... args)                             \
        : BASE_CLASS(args...)                                                  \
    {                                                                          \
    }
 
#define C_STATIC_ASSERT(expr, name) \
    typedef unsigned char __attribute__((unused)) __static_assert_##name[expr ? 0 : -1]
 
#if defined(ARDUINO_ARCH_ESP32)
#include <esp8266-compat.h>
#elif !defined(ESP_NONOS)
#define ICACHE_FLASH_ATTR
#define ICACHE_RAM_ATTR
#endif
 
#define GET_PARENT_PTR(ParentClass, variable)                                  \
    reinterpret_cast<ParentClass *>(                                           \
        reinterpret_cast<char *>(this) - offsetof(ParentClass, variable));
 
 
#define FAKELLP(x)  static_cast<unsigned>((x) >> 32), static_cast<unsigned>((x) & 0xffffffffu)
 
#define MUST_USE_RESULT __attribute__((__warn_unused_result__))
 
#ifdef ESP32
#include <endian.h>
#ifndef __bswap64
#define __bswap64(x) __bswap_64(x)
#endif
#endif
 
 
#endif // _UTILS_MACROS_H_