LMMS
Loading...
Searching...
No Matches
Macros
DistrhoDefines.h File Reference

Go to the source code of this file.

Macros

#define __has_feature(x)
#define __has_extension   __has_feature
#define DISTRHO_API
#define DISTRHO_PLUGIN_EXPORT   extern "C" __attribute__ ((visibility("default")))
#define DISTRHO_DLL_EXTENSION   "so"
#define constexpr
#define noexcept   throw()
#define override
#define final
#define nullptr   NULL
#define unlikely(x)
#define DISTRHO_DEPRECATED
#define DISTRHO_DEPRECATED_BY(other)
#define DISTRHO_SAFE_ASSERT(cond)
#define DISTRHO_SAFE_ASSERT_INT(cond, value)
#define DISTRHO_SAFE_ASSERT_INT2(cond, v1, v2)
#define DISTRHO_SAFE_ASSERT_UINT(cond, value)
#define DISTRHO_SAFE_ASSERT_UINT2(cond, v1, v2)
#define DISTRHO_SAFE_ASSERT_BREAK(cond)
#define DISTRHO_SAFE_ASSERT_CONTINUE(cond)
#define DISTRHO_SAFE_ASSERT_RETURN(cond, ret)
#define DISTRHO_CUSTOM_SAFE_ASSERT(msg, cond)
#define DISTRHO_CUSTOM_SAFE_ASSERT_BREAK(msg, cond)
#define DISTRHO_CUSTOM_SAFE_ASSERT_CONTINUE(msg, cond)
#define DISTRHO_CUSTOM_SAFE_ASSERT_RETURN(msg, cond, ret)
#define DISTRHO_CUSTOM_SAFE_ASSERT_ONCE_BREAK(msg, cond)
#define DISTRHO_CUSTOM_SAFE_ASSERT_ONCE_CONTINUE(msg, cond)
#define DISTRHO_CUSTOM_SAFE_ASSERT_ONCE_RETURN(msg, cond, ret)
#define DISTRHO_SAFE_ASSERT_INT_BREAK(cond, value)
#define DISTRHO_SAFE_ASSERT_INT_CONTINUE(cond, value)
#define DISTRHO_SAFE_ASSERT_INT_RETURN(cond, value, ret)
#define DISTRHO_SAFE_ASSERT_INT2_BREAK(cond, v1, v2)
#define DISTRHO_SAFE_ASSERT_INT2_CONTINUE(cond, v1, v2)
#define DISTRHO_SAFE_ASSERT_INT2_RETURN(cond, v1, v2, ret)
#define DISTRHO_SAFE_ASSERT_UINT_BREAK(cond, value)
#define DISTRHO_SAFE_ASSERT_UINT_CONTINUE(cond, value)
#define DISTRHO_SAFE_ASSERT_UINT_RETURN(cond, value, ret)
#define DISTRHO_SAFE_ASSERT_UINT2_BREAK(cond, v1, v2)
#define DISTRHO_SAFE_ASSERT_UINT2_CONTINUE(cond, v1, v2)
#define DISTRHO_SAFE_ASSERT_UINT2_RETURN(cond, v1, v2, ret)
#define DISTRHO_SAFE_EXCEPTION(msg)
#define DISTRHO_SAFE_EXCEPTION_BREAK(msg)
#define DISTRHO_SAFE_EXCEPTION_CONTINUE(msg)
#define DISTRHO_SAFE_EXCEPTION_RETURN(msg, ret)
#define DISTRHO_DECLARE_NON_COPYABLE(ClassName)
#define DISTRHO_PREVENT_HEAP_ALLOCATION
#define DISTRHO_PREVENT_VIRTUAL_HEAP_ALLOCATION
#define DISTRHO_NAMESPACE   DISTRHO
#define START_NAMESPACE_DISTRHO   namespace DISTRHO_NAMESPACE {
#define END_NAMESPACE_DISTRHO   }
#define USE_NAMESPACE_DISTRHO   using namespace DISTRHO_NAMESPACE;
#define DISTRHO_OS_SEP   '/'
#define DISTRHO_OS_SEP_STR   "/"
#define DISTRHO_OS_SPLIT   ':'
#define DISTRHO_OS_SPLIT_STR   ":"
#define ARRAY_SIZE(ARRAY)
#define DISTRHO_DECLARE_NON_COPY_CLASS(ClassName)
#define DISTRHO_DECLARE_NON_COPY_STRUCT(StructName)

Macro Definition Documentation

◆ __has_extension

#define __has_extension   __has_feature

◆ __has_feature

#define __has_feature ( x)
Value:
0

◆ ARRAY_SIZE

#define ARRAY_SIZE ( ARRAY)
Value:
sizeof(ARRAY)/sizeof(ARRAY[0])

◆ constexpr

#define constexpr

◆ DISTRHO_API

#define DISTRHO_API

◆ DISTRHO_CUSTOM_SAFE_ASSERT

#define DISTRHO_CUSTOM_SAFE_ASSERT ( msg,
cond )
Value:
if (unlikely(!(cond))) d_custom_safe_assert(msg, #cond, __FILE__, __LINE__);
unlikely
#define unlikely(x)
Definition CarlaDefines.h:163
msg
const char * msg
Definition missing_descriptor.c:20

◆ DISTRHO_CUSTOM_SAFE_ASSERT_BREAK

#define DISTRHO_CUSTOM_SAFE_ASSERT_BREAK ( msg,
cond )
Value:
if (unlikely(!(cond))) { d_custom_safe_assert(msg, #cond, __FILE__, __LINE__); break; }

◆ DISTRHO_CUSTOM_SAFE_ASSERT_CONTINUE

#define DISTRHO_CUSTOM_SAFE_ASSERT_CONTINUE ( msg,
cond )
Value:
if (unlikely(!(cond))) { d_custom_safe_assert(msg, #cond, __FILE__, __LINE__); continue; }

◆ DISTRHO_CUSTOM_SAFE_ASSERT_ONCE_BREAK

#define DISTRHO_CUSTOM_SAFE_ASSERT_ONCE_BREAK ( msg,
cond )
Value:
if (unlikely(!(cond))) { static bool _p; if (!_p) { _p = true; d_custom_safe_assert(msg, #cond, __FILE__, __LINE__); } break; }

◆ DISTRHO_CUSTOM_SAFE_ASSERT_ONCE_CONTINUE

#define DISTRHO_CUSTOM_SAFE_ASSERT_ONCE_CONTINUE ( msg,
cond )
Value:
if (unlikely(!(cond))) { static bool _p; if (!_p) { _p = true; d_custom_safe_assert(msg, #cond, __FILE__, __LINE__); } continue; }

◆ DISTRHO_CUSTOM_SAFE_ASSERT_ONCE_RETURN

#define DISTRHO_CUSTOM_SAFE_ASSERT_ONCE_RETURN ( msg,
cond,
ret )
Value:
if (unlikely(!(cond))) { static bool _p; if (!_p) { _p = true; d_custom_safe_assert(msg, #cond, __FILE__, __LINE__); } return ret; }

◆ DISTRHO_CUSTOM_SAFE_ASSERT_RETURN

#define DISTRHO_CUSTOM_SAFE_ASSERT_RETURN ( msg,
cond,
ret )
Value:
if (unlikely(!(cond))) { d_custom_safe_assert(msg, #cond, __FILE__, __LINE__); return ret; }

◆ DISTRHO_DECLARE_NON_COPY_CLASS

#define DISTRHO_DECLARE_NON_COPY_CLASS ( ClassName)
Value:
DISTRHO_DECLARE_NON_COPYABLE(ClassName)
DISTRHO_DECLARE_NON_COPYABLE
#define DISTRHO_DECLARE_NON_COPYABLE(ClassName)
Definition DistrhoDefines.h:154

◆ DISTRHO_DECLARE_NON_COPY_STRUCT

#define DISTRHO_DECLARE_NON_COPY_STRUCT ( StructName)
Value:
DISTRHO_DECLARE_NON_COPYABLE(StructName)

◆ DISTRHO_DECLARE_NON_COPYABLE

#define DISTRHO_DECLARE_NON_COPYABLE ( ClassName)
Value:
private: \
ClassName(ClassName&); \
ClassName(const ClassName&); \
ClassName& operator=(ClassName&); \
ClassName& operator=(const ClassName&);

◆ DISTRHO_DEPRECATED

#define DISTRHO_DEPRECATED

◆ DISTRHO_DEPRECATED_BY

#define DISTRHO_DEPRECATED_BY ( other)
Value:
DISTRHO_DEPRECATED
DISTRHO_DEPRECATED
#define DISTRHO_DEPRECATED
Definition DistrhoDefines.h:91

◆ DISTRHO_DLL_EXTENSION

#define DISTRHO_DLL_EXTENSION   "so"

◆ DISTRHO_NAMESPACE

#define DISTRHO_NAMESPACE   DISTRHO

◆ DISTRHO_OS_SEP

#define DISTRHO_OS_SEP   '/'

◆ DISTRHO_OS_SEP_STR

#define DISTRHO_OS_SEP_STR   "/"

◆ DISTRHO_OS_SPLIT

#define DISTRHO_OS_SPLIT   ':'

◆ DISTRHO_OS_SPLIT_STR

#define DISTRHO_OS_SPLIT_STR   ":"

◆ DISTRHO_PLUGIN_EXPORT

#define DISTRHO_PLUGIN_EXPORT   extern "C" __attribute__ ((visibility("default")))

◆ DISTRHO_PREVENT_HEAP_ALLOCATION

#define DISTRHO_PREVENT_HEAP_ALLOCATION
Value:
private: \
static void* operator new(size_t); \
static void operator delete(void*);

◆ DISTRHO_PREVENT_VIRTUAL_HEAP_ALLOCATION

#define DISTRHO_PREVENT_VIRTUAL_HEAP_ALLOCATION
Value:
private: \
static void* operator new(std::size_t);

◆ DISTRHO_SAFE_ASSERT

#define DISTRHO_SAFE_ASSERT ( cond)
Value:
if (unlikely(!(cond))) d_safe_assert (#cond, __FILE__, __LINE__);

◆ DISTRHO_SAFE_ASSERT_BREAK

#define DISTRHO_SAFE_ASSERT_BREAK ( cond)
Value:
if (unlikely(!(cond))) { d_safe_assert(#cond, __FILE__, __LINE__); break; }

◆ DISTRHO_SAFE_ASSERT_CONTINUE

#define DISTRHO_SAFE_ASSERT_CONTINUE ( cond)
Value:
if (unlikely(!(cond))) { d_safe_assert(#cond, __FILE__, __LINE__); continue; }

◆ DISTRHO_SAFE_ASSERT_INT

#define DISTRHO_SAFE_ASSERT_INT ( cond,
value )
Value:
if (unlikely(!(cond))) d_safe_assert_int (#cond, __FILE__, __LINE__, static_cast<int>(value));
value
static PuglViewHint int value
Definition pugl.h:1708

◆ DISTRHO_SAFE_ASSERT_INT2

#define DISTRHO_SAFE_ASSERT_INT2 ( cond,
v1,
v2 )
Value:
if (unlikely(!(cond))) d_safe_assert_int2 (#cond, __FILE__, __LINE__, static_cast<int>(v1), static_cast<int>(v2));
v2
static void v2(register WDL_FFT_REAL *a)
Definition fft.c:1099

◆ DISTRHO_SAFE_ASSERT_INT2_BREAK

#define DISTRHO_SAFE_ASSERT_INT2_BREAK ( cond,
v1,
v2 )
Value:
if (unlikely(!(cond))) { d_safe_assert_int2(#cond, __FILE__, __LINE__, static_cast<int>(v1), static_cast<int>(v2)); break; }

◆ DISTRHO_SAFE_ASSERT_INT2_CONTINUE

#define DISTRHO_SAFE_ASSERT_INT2_CONTINUE ( cond,
v1,
v2 )
Value:
if (unlikely(!(cond))) { d_safe_assert_int2(#cond, __FILE__, __LINE__, static_cast<int>(v1), static_cast<int>(v2)); continue; }

◆ DISTRHO_SAFE_ASSERT_INT2_RETURN

#define DISTRHO_SAFE_ASSERT_INT2_RETURN ( cond,
v1,
v2,
ret )
Value:
if (unlikely(!(cond))) { d_safe_assert_int2(#cond, __FILE__, __LINE__, static_cast<int>(v1), static_cast<int>(v2)); return ret; }

◆ DISTRHO_SAFE_ASSERT_INT_BREAK

#define DISTRHO_SAFE_ASSERT_INT_BREAK ( cond,
value )
Value:
if (unlikely(!(cond))) { d_safe_assert_int(#cond, __FILE__, __LINE__, static_cast<int>(value)); break; }

◆ DISTRHO_SAFE_ASSERT_INT_CONTINUE

#define DISTRHO_SAFE_ASSERT_INT_CONTINUE ( cond,
value )
Value:
if (unlikely(!(cond))) { d_safe_assert_int(#cond, __FILE__, __LINE__, static_cast<int>(value)); continue; }

◆ DISTRHO_SAFE_ASSERT_INT_RETURN

#define DISTRHO_SAFE_ASSERT_INT_RETURN ( cond,
value,
ret )
Value:
if (unlikely(!(cond))) { d_safe_assert_int(#cond, __FILE__, __LINE__, static_cast<int>(value)); return ret; }

◆ DISTRHO_SAFE_ASSERT_RETURN

#define DISTRHO_SAFE_ASSERT_RETURN ( cond,
ret )
Value:
if (unlikely(!(cond))) { d_safe_assert(#cond, __FILE__, __LINE__); return ret; }

◆ DISTRHO_SAFE_ASSERT_UINT

#define DISTRHO_SAFE_ASSERT_UINT ( cond,
value )
Value:
if (unlikely(!(cond))) d_safe_assert_uint (#cond, __FILE__, __LINE__, static_cast<uint>(value));
uint
unsigned int uint
Definition CarlaDefines.h:327

◆ DISTRHO_SAFE_ASSERT_UINT2

#define DISTRHO_SAFE_ASSERT_UINT2 ( cond,
v1,
v2 )
Value:
if (unlikely(!(cond))) d_safe_assert_uint2(#cond, __FILE__, __LINE__, static_cast<uint>(v1), static_cast<uint>(v2));

◆ DISTRHO_SAFE_ASSERT_UINT2_BREAK

#define DISTRHO_SAFE_ASSERT_UINT2_BREAK ( cond,
v1,
v2 )
Value:
if (unlikely(!(cond))) { d_safe_assert_uint2(#cond, __FILE__, __LINE__, static_cast<uint>(v1), static_cast<uint>(v2)); break; }

◆ DISTRHO_SAFE_ASSERT_UINT2_CONTINUE

#define DISTRHO_SAFE_ASSERT_UINT2_CONTINUE ( cond,
v1,
v2 )
Value:
if (unlikely(!(cond))) { d_safe_assert_uint2(#cond, __FILE__, __LINE__, static_cast<uint>(v1), static_cast<uint>(v2)); continue; }

◆ DISTRHO_SAFE_ASSERT_UINT2_RETURN

#define DISTRHO_SAFE_ASSERT_UINT2_RETURN ( cond,
v1,
v2,
ret )
Value:
if (unlikely(!(cond))) { d_safe_assert_uint2(#cond, __FILE__, __LINE__, static_cast<uint>(v1), static_cast<uint>(v2)); return ret; }

◆ DISTRHO_SAFE_ASSERT_UINT_BREAK

#define DISTRHO_SAFE_ASSERT_UINT_BREAK ( cond,
value )
Value:
if (unlikely(!(cond))) { d_safe_assert_uint(#cond, __FILE__, __LINE__, static_cast<uint>(value)); break; }

◆ DISTRHO_SAFE_ASSERT_UINT_CONTINUE

#define DISTRHO_SAFE_ASSERT_UINT_CONTINUE ( cond,
value )
Value:
if (unlikely(!(cond))) { d_safe_assert_uint(#cond, __FILE__, __LINE__, static_cast<uint>(value)); continue; }

◆ DISTRHO_SAFE_ASSERT_UINT_RETURN

#define DISTRHO_SAFE_ASSERT_UINT_RETURN ( cond,
value,
ret )
Value:
if (unlikely(!(cond))) { d_safe_assert_uint(#cond, __FILE__, __LINE__, static_cast<uint>(value)); return ret; }

◆ DISTRHO_SAFE_EXCEPTION

#define DISTRHO_SAFE_EXCEPTION ( msg)
Value:
catch(...) { d_safe_exception(msg, __FILE__, __LINE__); }

◆ DISTRHO_SAFE_EXCEPTION_BREAK

#define DISTRHO_SAFE_EXCEPTION_BREAK ( msg)
Value:
catch(...) { d_safe_exception(msg, __FILE__, __LINE__); break; }

◆ DISTRHO_SAFE_EXCEPTION_CONTINUE

#define DISTRHO_SAFE_EXCEPTION_CONTINUE ( msg)
Value:
catch(...) { d_safe_exception(msg, __FILE__, __LINE__); continue; }

◆ DISTRHO_SAFE_EXCEPTION_RETURN

#define DISTRHO_SAFE_EXCEPTION_RETURN ( msg,
ret )
Value:
catch(...) { d_safe_exception(msg, __FILE__, __LINE__); return ret; }

◆ END_NAMESPACE_DISTRHO

#define END_NAMESPACE_DISTRHO   }

◆ final

#define final

◆ noexcept

#define noexcept   throw()

◆ nullptr

#define nullptr   NULL

◆ override

#define override

◆ START_NAMESPACE_DISTRHO

#define START_NAMESPACE_DISTRHO   namespace DISTRHO_NAMESPACE {

◆ unlikely

#define unlikely ( x)
Value:
x
x
unsigned x[BMAX+1]
Definition inflate.c:1586

◆ USE_NAMESPACE_DISTRHO

#define USE_NAMESPACE_DISTRHO   using namespace DISTRHO_NAMESPACE;
Generated on for LMMS by doxygen 1.16.1