DISTRHO
/
DPF-Plugins
mirror of https://github.com/DISTRHO/DPF-Plugins
1
0
Fork 0
Code Releases 8 Activity
Collection of DPF-based plugins for packaging
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
139 Commits
1 Branch
86MB
Tree: 64e02a25d3
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '64e02a25d3'
${ noResults }
DPF-Plugins/dpf/distrho/src/DistrhoDefines.h

216 lines
11KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Plugin Framework (DPF)

  3.  * Copyright (C) 2012-2021 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * Permission to use, copy, modify, and/or distribute this software for any purpose with

  6.  * or without fee is hereby granted, provided that the above copyright notice and this

  7.  * permission notice appear in all copies.

  8.  *

  9.  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD

  10.  * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN

  11.  * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL

  12.  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER

  13.  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

  14.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

  15.  */

  16. 

  17. #ifndef DISTRHO_DEFINES_H_INCLUDED

  18. #define DISTRHO_DEFINES_H_INCLUDED

  19. 

  20. /* Compatibility with non-clang compilers */

  21. #ifndef __has_feature

  22. # define __has_feature(x) 0

  23. #endif

  24. #ifndef __has_extension

  25. # define __has_extension __has_feature

  26. #endif

  27. 

  28. /* Check OS */

  29. #if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)

  30. # define DISTRHO_PLUGIN_EXPORT extern "C" __declspec (dllexport)

  31. # define DISTRHO_OS_WINDOWS 1

  32. # define DISTRHO_DLL_EXTENSION "dll"

  33. #else

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

  35. # if defined(__APPLE__)

  36. #  define DISTRHO_OS_MAC 1

  37. #  define DISTRHO_DLL_EXTENSION "dylib"

  38. # elif defined(__HAIKU__)

  39. #  define DISTRHO_OS_HAIKU 1

  40. # elif defined(__linux__) || defined(__linux)

  41. #  define DISTRHO_OS_LINUX 1

  42. # elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)

  43. #  define DISTRHO_OS_BSD 1

  44. # elif defined(__GNU__)

  45. #  define DISTRHO_OS_GNU_HURD 1

  46. # endif

  47. #endif

  48. 

  49. #ifndef DISTRHO_DLL_EXTENSION

  50. # define DISTRHO_DLL_EXTENSION "so"

  51. #endif

  52. 

  53. /* Check for C++11 support */

  54. #if defined(HAVE_CPP11_SUPPORT)

  55. # if HAVE_CPP11_SUPPORT

  56. #  define DISTRHO_PROPER_CPP11_SUPPORT

  57. # endif

  58. #elif __cplusplus >= 201103L || (defined(__GNUC__) && defined(__GXX_EXPERIMENTAL_CXX0X__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 405) || __has_extension(cxx_noexcept) || (defined(_MSC_VER) && _MSVC_LANG >= 201103L)

  59. # define DISTRHO_PROPER_CPP11_SUPPORT

  60. # if (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) < 407 && ! defined(__clang__)) || (defined(__clang__) && ! __has_extension(cxx_override_control))

  61. #  define override /* gcc4.7+ only */

  62. #  define final    /* gcc4.7+ only */

  63. # endif

  64. #endif

  65. 

  66. #ifndef DISTRHO_PROPER_CPP11_SUPPORT

  67. # define constexpr

  68. # define noexcept throw()

  69. # define override

  70. # define final

  71. # define nullptr NULL

  72. #endif

  73. 

  74. /* Define DISTRHO_DEPRECATED */

  75. #if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 480

  76. # define DISTRHO_DEPRECATED __attribute__((deprecated))

  77. #elif defined(_MSC_VER)

  78. # define DISTRHO_DEPRECATED [[deprecated]] /* Note: __declspec(deprecated) it not applicable to enum members */

  79. #else

  80. # define DISTRHO_DEPRECATED

  81. #endif

  82. 

  83. /* Define DISTRHO_DEPRECATED_BY */

  84. #if defined(__clang__) && defined(DISTRHO_PROPER_CPP11_SUPPORT)

  85. # define DISTRHO_DEPRECATED_BY(other) __attribute__((deprecated("", other)))

  86. #elif defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 480

  87. # define DISTRHO_DEPRECATED_BY(other) __attribute__((deprecated("Use " other)))

  88. #else

  89. # define DISTRHO_DEPRECATED_BY(other) DISTRHO_DEPRECATED

  90. #endif

  91. 

  92. /* Define DISTRHO_SAFE_ASSERT* */

  93. #define DISTRHO_SAFE_ASSERT(cond)               if (! (cond)) d_safe_assert      (#cond, __FILE__, __LINE__);

  94. #define DISTRHO_SAFE_ASSERT_INT(cond, value)    if (! (cond)) d_safe_assert_int  (#cond, __FILE__, __LINE__, static_cast<int>(value));

  95. #define DISTRHO_SAFE_ASSERT_INT2(cond, v1, v2)  if (! (cond)) d_safe_assert_int2 (#cond, __FILE__, __LINE__, static_cast<int>(v1), static_cast<int>(v2));

  96. #define DISTRHO_SAFE_ASSERT_UINT(cond, value)   if (! (cond)) d_safe_assert_uint (#cond, __FILE__, __LINE__, static_cast<uint>(value));

  97. #define DISTRHO_SAFE_ASSERT_UINT2(cond, v1, v2) if (! (cond)) d_safe_assert_uint2(#cond, __FILE__, __LINE__, static_cast<uint>(v1), static_cast<uint>(v2));

  98. 

  99. #define DISTRHO_SAFE_ASSERT_BREAK(cond)         if (! (cond)) { d_safe_assert(#cond, __FILE__, __LINE__); break; }

  100. #define DISTRHO_SAFE_ASSERT_CONTINUE(cond)      if (! (cond)) { d_safe_assert(#cond, __FILE__, __LINE__); continue; }

  101. #define DISTRHO_SAFE_ASSERT_RETURN(cond, ret)   if (! (cond)) { d_safe_assert(#cond, __FILE__, __LINE__); return ret; }

  102. 

  103. #define DISTRHO_CUSTOM_SAFE_ASSERT(msg, cond)             if (! (cond))   d_custom_safe_assert(msg, #cond, __FILE__, __LINE__);

  104. #define DISTRHO_CUSTOM_SAFE_ASSERT_BREAK(msg, cond)       if (! (cond)) { d_custom_safe_assert(msg, #cond, __FILE__, __LINE__); break; }

  105. #define DISTRHO_CUSTOM_SAFE_ASSERT_CONTINUE(msg, cond)    if (! (cond)) { d_custom_safe_assert(msg, #cond, __FILE__, __LINE__); continue; }

  106. #define DISTRHO_CUSTOM_SAFE_ASSERT_RETURN(msg, cond, ret) if (! (cond)) { d_custom_safe_assert(msg, #cond, __FILE__, __LINE__); return ret; }

  107. 

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

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

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

  111. 

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

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

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

  115. 

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

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

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

  119. 

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

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

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

  123. 

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

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

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

  127. 

  128. /* Define DISTRHO_SAFE_EXCEPTION */

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

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

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

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

  133. 

  134. /* Define DISTRHO_DECLARE_NON_COPYABLE */

  135. #ifdef DISTRHO_PROPER_CPP11_SUPPORT

  136. # define DISTRHO_DECLARE_NON_COPYABLE(ClassName) \

  137. private:                                         \

  138.     ClassName(ClassName&) = delete;              \

  139.     ClassName(const ClassName&) = delete;        \

  140.     ClassName& operator=(ClassName&) = delete;   \

  141.     ClassName& operator=(const ClassName&) = delete;

  142. #else

  143. # define DISTRHO_DECLARE_NON_COPYABLE(ClassName) \

  144. private:                                         \

  145.     ClassName(ClassName&);                       \

  146.     ClassName(const ClassName&);                 \

  147.     ClassName& operator=(ClassName&);            \

  148.     ClassName& operator=(const ClassName&);

  149. #endif

  150. 

  151. /* Define DISTRHO_PREVENT_HEAP_ALLOCATION */

  152. #ifdef DISTRHO_PROPER_CPP11_SUPPORT

  153. # define DISTRHO_PREVENT_HEAP_ALLOCATION        \

  154. private:                                        \

  155.     static void* operator new(size_t) = delete; \

  156.     static void operator delete(void*) = delete;

  157. #else

  158. # define DISTRHO_PREVENT_HEAP_ALLOCATION \

  159. private:                                 \

  160.     static void* operator new(size_t);   \

  161.     static void operator delete(void*);

  162. #endif

  163. 

  164. /* Define DISTRHO_PREVENT_VIRTUAL_HEAP_ALLOCATION */

  165. #ifdef DISTRHO_PROPER_CPP11_SUPPORT

  166. # define DISTRHO_PREVENT_VIRTUAL_HEAP_ALLOCATION \

  167. private:                                         \

  168.     static void* operator new(std::size_t) = delete;

  169. #else

  170. # define DISTRHO_PREVENT_VIRTUAL_HEAP_ALLOCATION \

  171. private:                                         \

  172.     static void* operator new(std::size_t);

  173. #endif

  174. 

  175. /* Define namespace */

  176. #ifndef DISTRHO_NAMESPACE

  177. # define DISTRHO_NAMESPACE DISTRHO

  178. #endif

  179. #define START_NAMESPACE_DISTRHO namespace DISTRHO_NAMESPACE {

  180. #define END_NAMESPACE_DISTRHO }

  181. #define USE_NAMESPACE_DISTRHO using namespace DISTRHO_NAMESPACE;

  182. 

  183. /* Define DISTRHO_OS_SEP and DISTRHO_OS_SPLIT */

  184. #ifdef DISTRHO_OS_WINDOWS

  185. # define DISTRHO_OS_SEP       '\\'

  186. # define DISTRHO_OS_SEP_STR   "\\"

  187. # define DISTRHO_OS_SPLIT     ';'

  188. # define DISTRHO_OS_SPLIT_STR ";"

  189. #else

  190. # define DISTRHO_OS_SEP       '/'

  191. # define DISTRHO_OS_SEP_STR   "/"

  192. # define DISTRHO_OS_SPLIT     ':'

  193. # define DISTRHO_OS_SPLIT_STR ":"

  194. #endif

  195. 

  196. /* MSVC warnings */

  197. #ifdef _MSC_VER

  198. # define strdup _strdup

  199. # pragma warning(disable:4244) /* possible loss of data */

  200. #endif

  201. 

  202. /* Useful macros */

  203. #define ARRAY_SIZE(ARRAY) sizeof(ARRAY)/sizeof(ARRAY[0])

  204. 

  205. /* Useful typedefs */

  206. typedef unsigned char uchar;

  207. typedef unsigned short int ushort;

  208. typedef unsigned int uint;

  209. typedef unsigned long int ulong;

  210. 

  211. /* Deprecated macros */

  212. #define DISTRHO_DECLARE_NON_COPY_CLASS(ClassName) DISTRHO_DECLARE_NON_COPYABLE(ClassName)

  213. #define DISTRHO_DECLARE_NON_COPY_STRUCT(StructName) DISTRHO_DECLARE_NON_COPYABLE(StructName)

  214. 

  215. #endif // DISTRHO_DEFINES_H_INCLUDED