/* * ***** BEGIN GPL LICENSE BLOCK ***** * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software Foundation, * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. * All rights reserved. * * The Original Code is: all of this file. * * Contributor(s): none yet. * * ***** END GPL LICENSE BLOCK ***** */ #ifndef __BLI_UTILDEFINES_H__ #define __BLI_UTILDEFINES_H__ /** \file BLI_utildefines.h * \ingroup bli */ #ifdef __cplusplus extern "C" { #endif /* avoid many includes for now */ #include "BLI_sys_types.h" #include "BLI_compiler_compat.h" #ifndef NDEBUG /* for BLI_assert */ #include #endif /* varargs macros (keep first so others can use) */ /* --- internal helpers --- */ #define _VA_NARGS_GLUE(x, y) x y #define _VA_NARGS_RETURN_COUNT(\ _1_, _2_, _3_, _4_, _5_, _6_, _7_, _8_, _9_, _10_, _11_, _12_, _13_, _14_, _15_, _16_, \ _17_, _18_, _19_, _20_, _21_, _22_, _23_, _24_, _25_, _26_, _27_, _28_, _29_, _30_, _31_, _32_, \ _33_, _34_, _35_, _36_, _37_, _38_, _39_, _40_, _41_, _42_, _43_, _44_, _45_, _46_, _47_, _48_, \ _49_, _50_, _51_, _52_, _53_, _54_, _55_, _56_, _57_, _58_, _59_, _60_, _61_, _62_, _63_, _64_, \ count, ...) count #define _VA_NARGS_EXPAND(args) _VA_NARGS_RETURN_COUNT args /* 64 args max */ #define _VA_NARGS_COUNT(...) _VA_NARGS_EXPAND((__VA_ARGS__, \ 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, \ 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, \ 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, \ 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)) #define _VA_NARGS_OVERLOAD_MACRO2(name, count) name##count #define _VA_NARGS_OVERLOAD_MACRO1(name, count) _VA_NARGS_OVERLOAD_MACRO2(name, count) #define _VA_NARGS_OVERLOAD_MACRO(name, count) _VA_NARGS_OVERLOAD_MACRO1(name, count) /* --- expose for re-use --- */ #define VA_NARGS_CALL_OVERLOAD(name, ...) \ _VA_NARGS_GLUE(_VA_NARGS_OVERLOAD_MACRO(name, _VA_NARGS_COUNT(__VA_ARGS__)), (__VA_ARGS__)) /* useful for finding bad use of min/max */ #if 0 /* gcc only */ # define _TYPECHECK(a, b) ((void)(((typeof(a) *)0) == ((typeof(b) *)0))) # define MIN2(x, y) (_TYPECHECK(x, y), (((x) < (y) ? (x) : (y)))) # define MAX2(x, y) (_TYPECHECK(x, y), (((x) > (y) ? (x) : (y)))) #endif /* include after _VA_NARGS macro */ #include "BLI_compiler_typecheck.h" /* min/max */ #if defined(__GNUC__) || defined(__clang__) #define MIN2(a, b) __extension__ ({ \ typeof(a) a_ = (a); typeof(b) b_ = (b); \ ((a_) < (b_) ? (a_) : (b_)); }) #define MAX2(a, b) __extension__ ({ \ typeof(a) a_ = (a); typeof(b) b_ = (b); \ ((a_) > (b_) ? (a_) : (b_)); }) #define MIN3(a, b, c) __extension__ ({ \ typeof(a) a_ = (a); typeof(b) b_ = (b); typeof(c) c_ = (c); \ ((a_ < b_) ? ((a_ < c_) ? a_ : c_) : ((b_ < c_) ? b_ : c_)); }) #define MAX3(a, b, c) __extension__ ({ \ typeof(a) a_ = (a); typeof(b) b_ = (b); typeof(c) c_ = (c); \ ((a_ > b_) ? ((a_ > c_) ? a_ : c_) : ((b_ > c_) ? b_ : c_)); }) #define MIN4(a, b, c, d) __extension__ ({ \ typeof(a) a_ = (a); typeof(b) b_ = (b); typeof(c) c_ = (c); typeof(d) d_ = (d); \ ((a_ < b_) ? ((a_ < c_) ? ((a_ < d_) ? a_ : d_) : ((c_ < d_) ? c_ : d_)) : \ ((b_ < c_) ? ((b_ < d_) ? b_ : d_) : ((c_ < d_) ? c_ : d_))); }) #define MAX4(a, b, c, d) __extension__ ({ \ typeof(a) a_ = (a); typeof(b) b_ = (b); typeof(c) c_ = (c); typeof(d) d_ = (d); \ ((a_ > b_) ? ((a_ > c_) ? ((a_ > d_) ? a_ : d_) : ((c_ > d_) ? c_ : d_)) : \ ((b_ > c_) ? ((b_ > d_) ? b_ : d_) : ((c_ > d_) ? c_ : d_))); }) #else #define MIN2(a, b) ((a) < (b) ? (a) : (b)) #define MAX2(a, b) ((a) > (b) ? (a) : (b)) #define MIN3(a, b, c) (MIN2(MIN2((a), (b)), (c))) #define MIN4(a, b, c, d) (MIN2(MIN2((a), (b)), MIN2((c), (d)))) #define MAX3(a, b, c) (MAX2(MAX2((a), (b)), (c))) #define MAX4(a, b, c, d) (MAX2(MAX2((a), (b)), MAX2((c), (d)))) #endif /* min/max that return a value of our choice */ #define MAX3_PAIR(cmp_a, cmp_b, cmp_c, ret_a, ret_b, ret_c) \ ((cmp_a > cmp_b) ? ((cmp_a > cmp_c) ? ret_a : ret_c) : \ ((cmp_b > cmp_c) ? ret_b : ret_c)) #define MIN3_PAIR(cmp_a, cmp_b, cmp_c, ret_a, ret_b, ret_c) \ ((cmp_a < cmp_b) ? ((cmp_a < cmp_c) ? ret_a : ret_c) : \ ((cmp_b < cmp_c) ? ret_b : ret_c)) #define INIT_MINMAX(min, max) { \ (min)[0] = (min)[1] = (min)[2] = 1.0e30f; \ (max)[0] = (max)[1] = (max)[2] = -1.0e30f; \ } (void)0 #define INIT_MINMAX2(min, max) { \ (min)[0] = (min)[1] = 1.0e30f; \ (max)[0] = (max)[1] = -1.0e30f; \ } (void)0 #define DO_MIN(vec, min) { \ if ((min)[0] > (vec)[0]) (min)[0] = (vec)[0]; \ if ((min)[1] > (vec)[1]) (min)[1] = (vec)[1]; \ if ((min)[2] > (vec)[2]) (min)[2] = (vec)[2]; \ } (void)0 #define DO_MAX(vec, max) { \ if ((max)[0] < (vec)[0]) (max)[0] = (vec)[0]; \ if ((max)[1] < (vec)[1]) (max)[1] = (vec)[1]; \ if ((max)[2] < (vec)[2]) (max)[2] = (vec)[2]; \ } (void)0 #define DO_MINMAX(vec, min, max) { \ if ((min)[0] > (vec)[0] ) (min)[0] = (vec)[0]; \ if ((min)[1] > (vec)[1] ) (min)[1] = (vec)[1]; \ if ((min)[2] > (vec)[2] ) (min)[2] = (vec)[2]; \ if ((max)[0] < (vec)[0] ) (max)[0] = (vec)[0]; \ if ((max)[1] < (vec)[1] ) (max)[1] = (vec)[1]; \ if ((max)[2] < (vec)[2] ) (max)[2] = (vec)[2]; \ } (void)0 #define DO_MINMAX2(vec, min, max) { \ if ((min)[0] > (vec)[0] ) (min)[0] = (vec)[0]; \ if ((min)[1] > (vec)[1] ) (min)[1] = (vec)[1]; \ if ((max)[0] < (vec)[0] ) (max)[0] = (vec)[0]; \ if ((max)[1] < (vec)[1] ) (max)[1] = (vec)[1]; \ } (void)0 /* some math and copy defines */ #define SWAP(type, a, b) { \ type sw_ap; \ CHECK_TYPE(a, type); \ CHECK_TYPE(b, type); \ sw_ap = (a); \ (a) = (b); \ (b) = sw_ap; \ } (void)0 /* swap with a temp value */ #define SWAP_TVAL(tval, a, b) { \ CHECK_TYPE_PAIR(tval, a); \ CHECK_TYPE_PAIR(tval, b); \ (tval) = (a); \ (a) = (b); \ (b) = (tval); \ } (void)0 /* ELEM#(v, ...): is the first arg equal any others? */ /* internal helpers*/ #define _VA_ELEM2(v, a) \ ((v) == (a)) #define _VA_ELEM3(v, a, b) \ (_VA_ELEM2(v, a) || ((v) == (b))) #define _VA_ELEM4(v, a, b, c) \ (_VA_ELEM3(v, a, b) || ((v) == (c))) #define _VA_ELEM5(v, a, b, c, d) \ (_VA_ELEM4(v, a, b, c) || ((v) == (d))) #define _VA_ELEM6(v, a, b, c, d, e) \ (_VA_ELEM5(v, a, b, c, d) || ((v) == (e))) #define _VA_ELEM7(v, a, b, c, d, e, f) \ (_VA_ELEM6(v, a, b, c, d, e) || ((v) == (f))) #define _VA_ELEM8(v, a, b, c, d, e, f, g) \ (_VA_ELEM7(v, a, b, c, d, e, f) || ((v) == (g))) #define _VA_ELEM9(v, a, b, c, d, e, f, g, h) \ (_VA_ELEM8(v, a, b, c, d, e, f, g) || ((v) == (h))) #define _VA_ELEM10(v, a, b, c, d, e, f, g, h, i) \ (_VA_ELEM9(v, a, b, c, d, e, f, g, h) || ((v) == (i))) #define _VA_ELEM11(v, a, b, c, d, e, f, g, h, i, j) \ (_VA_ELEM10(v, a, b, c, d, e, f, g, h, i) || ((v) == (j))) #define _VA_ELEM12(v, a, b, c, d, e, f, g, h, i, j, k) \ (_VA_ELEM11(v, a, b, c, d, e, f, g, h, i, j) || ((v) == (k))) #define _VA_ELEM13(v, a, b, c, d, e, f, g, h, i, j, k, l) \ (_VA_ELEM12(v, a, b, c, d, e, f, g, h, i, j, k) || ((v) == (l))) #define _VA_ELEM14(v, a, b, c, d, e, f, g, h, i, j, k, l, m) \ (_VA_ELEM13(v, a, b, c, d, e, f, g, h, i, j, k, l) || ((v) == (m))) #define _VA_ELEM15(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n) \ (_VA_ELEM14(v, a, b, c, d, e, f, g, h, i, j, k, l, m) || ((v) == (n))) #define _VA_ELEM16(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) \ (_VA_ELEM15(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n) || ((v) == (o))) #define _VA_ELEM17(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) \ (_VA_ELEM16(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) || ((v) == (p))) /* reusable ELEM macro */ #define ELEM(...) VA_NARGS_CALL_OVERLOAD(_VA_ELEM, __VA_ARGS__) /* no-op for expressions we don't want to instansiate, but must remian valid */ #define EXPR_NOP(expr) (void)(0 ? ((void)(expr), 1) : 0) /* shift around elements */ #define SHIFT3(type, a, b, c) { \ type tmp; \ CHECK_TYPE(a, type); \ CHECK_TYPE(b, type); \ CHECK_TYPE(c, type); \ tmp = a; \ a = c; \ c = b; \ b = tmp; \ } (void)0 #define SHIFT4(type, a, b, c, d) { \ type tmp; \ CHECK_TYPE(a, type); \ CHECK_TYPE(b, type); \ CHECK_TYPE(c, type); \ CHECK_TYPE(d, type); \ tmp = a; \ a = d; \ d = c; \ c = b; \ b = tmp; \ } (void)0 #define FTOCHAR(val) ((CHECK_TYPE_INLINE(val, float)), \ (char)(((val) <= 0.0f) ? 0 : (((val) > (1.0f - 0.5f / 255.0f)) ? 255 : ((255.0f * (val)) + 0.5f)))) #define FTOUSHORT(val) ((CHECK_TYPE_INLINE(val, float)), \ (unsigned short)((val >= 1.0f - 0.5f / 65535) ? 65535 : (val <= 0.0f) ? 0 : (val * 65535.0f + 0.5f))) #define USHORTTOUCHAR(val) ((unsigned char)(((val) >= 65535 - 128) ? 255 : ((val) + 128) >> 8)) #define F3TOCHAR3(v2, v1) { \ (v1)[0] = FTOCHAR((v2[0])); \ (v1)[1] = FTOCHAR((v2[1])); \ (v1)[2] = FTOCHAR((v2[2])); \ } (void)0 #define F3TOCHAR4(v2, v1) { \ (v1)[0] = FTOCHAR((v2[0])); \ (v1)[1] = FTOCHAR((v2[1])); \ (v1)[2] = FTOCHAR((v2[2])); \ (v1)[3] = 255; \ } (void)0 #define F4TOCHAR4(v2, v1) { \ (v1)[0] = FTOCHAR((v2[0])); \ (v1)[1] = FTOCHAR((v2[1])); \ (v1)[2] = FTOCHAR((v2[2])); \ (v1)[3] = FTOCHAR((v2[3])); \ } (void)0 #define VECCOPY(v1, v2) { \ *(v1) = *(v2); \ *(v1 + 1) = *(v2 + 1); \ *(v1 + 2) = *(v2 + 2); \ } (void)0 #define VECCOPY2D(v1, v2) { \ *(v1) = *(v2); \ *(v1 + 1) = *(v2 + 1); \ } (void)0 #define VECADD(v1, v2, v3) { \ *(v1) = *(v2) + *(v3); \ *(v1 + 1) = *(v2 + 1) + *(v3 + 1); \ *(v1 + 2) = *(v2 + 2) + *(v3 + 2); \ } (void)0 #define VECSUB(v1, v2, v3) { \ *(v1) = *(v2) - *(v3); \ *(v1 + 1) = *(v2 + 1) - *(v3 + 1); \ *(v1 + 2) = *(v2 + 2) - *(v3 + 2); \ } (void)0 #define VECSUB2D(v1, v2, v3) { \ *(v1) = *(v2) - *(v3); \ *(v1 + 1) = *(v2 + 1) - *(v3 + 1); \ } (void)0 #define VECADDFAC(v1, v2, v3, fac) { \ *(v1) = *(v2) + *(v3) * (fac); \ *(v1 + 1) = *(v2 + 1) + *(v3 + 1) * (fac); \ *(v1 + 2) = *(v2 + 2) + *(v3 + 2) * (fac); \ } (void)0 #define VECMADD(v1, v2, v3, v4) { \ *(v1) = *(v2) + *(v3) * (*(v4)); \ *(v1 + 1) = *(v2 + 1) + *(v3 + 1) * (*(v4 + 1)); \ *(v1 + 2) = *(v2 + 2) + *(v3 + 2) * (*(v4 + 2)); \ } (void)0 #define VECSUBFAC(v1, v2, v3, fac) { \ *(v1) = *(v2) - *(v3) * (fac); \ *(v1 + 1) = *(v2 + 1) - *(v3 + 1) * (fac); \ *(v1 + 2) = *(v2 + 2) - *(v3 + 2) * (fac); \ } (void)0 /* some misc stuff.... */ /* avoid multiple access for supported compilers */ #if defined(__GNUC__) || defined(__clang__) #define ABS(a) ({ \ typeof(a) a_ = (a); \ ((a_) < 0 ? (-(a_)) : (a_)); }) #define SQUARE(a) ({ \ typeof(a) a_ = (a); \ ((a_) * (a_)); }) #else #define ABS(a) ((a) < 0 ? (-(a)) : (a)) #define SQUARE(a) ((a) * (a)) #endif #define CLAMPIS(a, b, c) ((a) < (b) ? (b) : (a) > (c) ? (c) : (a)) #define CLAMP(a, b, c) { \ if ((a) < (b)) (a) = (b); \ else if ((a) > (c)) (a) = (c); \ } (void)0 #define CLAMP_MAX(a, c) { \ if ((a) > (c)) (a) = (c); \ } (void)0 #define CLAMP_MIN(a, b) { \ if ((a) < (b)) (a) = (b); \ } (void)0 #define CLAMP2(vec, b, c) { \ CLAMP((vec)[0], b, c); \ CLAMP((vec)[1], b, c); \ } (void)0 #define CLAMP2_MIN(vec, b) { \ CLAMP_MIN((vec)[0], b); \ CLAMP_MIN((vec)[1], b); \ } (void)0 #define CLAMP2_MAX(vec, b) { \ CLAMP_MAX((vec)[0], b); \ CLAMP_MAX((vec)[1], b); \ } (void)0 #define CLAMP3(vec, b, c) { \ CLAMP((vec)[0], b, c); \ CLAMP((vec)[1], b, c); \ CLAMP((vec)[2], b, c); \ } (void)0 #define CLAMP3_MIN(vec, b) { \ CLAMP_MIN((vec)[0], b); \ CLAMP_MIN((vec)[1], b); \ CLAMP_MIN((vec)[2], b); \ } (void)0 #define CLAMP3_MAX(vec, b) { \ CLAMP_MAX((vec)[0], b); \ CLAMP_MAX((vec)[1], b); \ CLAMP_MAX((vec)[2], b); \ } (void)0 #define CLAMP4(vec, b, c) { \ CLAMP((vec)[0], b, c); \ CLAMP((vec)[1], b, c); \ CLAMP((vec)[2], b, c); \ CLAMP((vec)[3], b, c); \ } (void)0 #define CLAMP4_MIN(vec, b) { \ CLAMP_MIN((vec)[0], b); \ CLAMP_MIN((vec)[1], b); \ CLAMP_MIN((vec)[2], b); \ CLAMP_MIN((vec)[3], b); \ } (void)0 #define CLAMP4_MAX(vec, b) { \ CLAMP_MAX((vec)[0], b); \ CLAMP_MAX((vec)[1], b); \ CLAMP_MAX((vec)[2], b); \ CLAMP_MAX((vec)[3], b); \ } (void)0 #define IS_EQ(a, b) ( \ CHECK_TYPE_INLINE(a, double), CHECK_TYPE_INLINE(b, double), \ ((fabs((double)((a) - (b))) >= (double) FLT_EPSILON) ? false : true)) #define IS_EQF(a, b) ( \ CHECK_TYPE_INLINE(a, float), CHECK_TYPE_INLINE(b, float), \ ((fabsf((float)((a) - (b))) >= (float) FLT_EPSILON) ? false : true)) #define IS_EQT(a, b, c) (((a) > (b)) ? ((((a) - (b)) <= (c))) : (((((b) - (a)) <= (c))))) #define IN_RANGE(a, b, c) (((b) < (c)) ? (((b) < (a) && (a) < (c))) : (((c) < (a) && (a) < (b)))) #define IN_RANGE_INCL(a, b, c) (((b) < (c)) ? (((b) <= (a) && (a) <= (c))) : (((c) <= (a) && (a) <= (b)))) /* unpack vector for args */ #define UNPACK2(a) ((a)[0]), ((a)[1]) #define UNPACK3(a) UNPACK2(a), ((a)[2]) #define UNPACK4(a) UNPACK3(a), ((a)[3]) /* pre may be '&', '*' or func, post may be '->member' */ #define UNPACK2_EX(pre, a, post) (pre((a)[0])post), (pre((a)[1])post) #define UNPACK3_EX(pre, a, post) UNPACK2_EX(pre, a, post), (pre((a)[2])post) #define UNPACK4_EX(pre, a, post) UNPACK3_EX(pre, a, post), (pre((a)[3])post) /* array helpers */ #define ARRAY_LAST_ITEM(arr_start, arr_dtype, tot) \ (arr_dtype *)((char *)(arr_start) + (sizeof(*((arr_dtype *)NULL)) * (size_t)(tot - 1))) #define ARRAY_HAS_ITEM(arr_item, arr_start, tot) ( \ CHECK_TYPE_PAIR_INLINE(arr_start, arr_item), \ ((unsigned int)((arr_item) - (arr_start)) < (unsigned int)(tot))) #define ARRAY_DELETE(arr, index, tot_delete, tot) { \ BLI_assert(index + tot_delete <= tot); \ memmove(&(arr)[(index)], \ &(arr)[(index) + (tot_delete)], \ (((tot) - (index)) - (tot_delete)) * sizeof(*(arr))); \ } (void)0 /* assuming a static array */ #if defined(__GNUC__) && !defined(__cplusplus) && !defined(__clang__) # define ARRAY_SIZE(arr) \ ((sizeof(struct {int isnt_array : ((const void *)&(arr) == &(arr)[0]);}) * 0) + \ (sizeof(arr) / sizeof(*(arr)))) #else # define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(*(arr))) #endif /* ARRAY_SET_ITEMS#(v, ...): set indices of array 'v' */ /* internal helpers */ #define _VA_ARRAY_SET_ITEMS2(v, a) \ ((v)[0] = (a)) #define _VA_ARRAY_SET_ITEMS3(v, a, b) \ _VA_ARRAY_SET_ITEMS2(v, a); ((v)[1] = (b)) #define _VA_ARRAY_SET_ITEMS4(v, a, b, c) \ _VA_ARRAY_SET_ITEMS3(v, a, b); ((v)[2] = (c)) #define _VA_ARRAY_SET_ITEMS5(v, a, b, c, d) \ _VA_ARRAY_SET_ITEMS4(v, a, b, c); ((v)[3] = (d)) #define _VA_ARRAY_SET_ITEMS6(v, a, b, c, d, e) \ _VA_ARRAY_SET_ITEMS5(v, a, b, c, d); ((v)[4] = (e)) #define _VA_ARRAY_SET_ITEMS7(v, a, b, c, d, e, f) \ _VA_ARRAY_SET_ITEMS6(v, a, b, c, d, e); ((v)[5] = (f)) #define _VA_ARRAY_SET_ITEMS8(v, a, b, c, d, e, f, g) \ _VA_ARRAY_SET_ITEMS7(v, a, b, c, d, e, f); ((v)[6] = (g)) #define _VA_ARRAY_SET_ITEMS9(v, a, b, c, d, e, f, g, h) \ _VA_ARRAY_SET_ITEMS8(v, a, b, c, d, e, f, g); ((v)[7] = (h)) #define _VA_ARRAY_SET_ITEMS10(v, a, b, c, d, e, f, g, h, i) \ _VA_ARRAY_SET_ITEMS9(v, a, b, c, d, e, f, g, h); ((v)[8] = (i)) #define _VA_ARRAY_SET_ITEMS11(v, a, b, c, d, e, f, g, h, i, j) \ _VA_ARRAY_SET_ITEMS10(v, a, b, c, d, e, f, g, h, i); ((v)[9] = (j)) #define _VA_ARRAY_SET_ITEMS12(v, a, b, c, d, e, f, g, h, i, j, k) \ _VA_ARRAY_SET_ITEMS11(v, a, b, c, d, e, f, g, h, i, j); ((v)[10] = (k)) #define _VA_ARRAY_SET_ITEMS13(v, a, b, c, d, e, f, g, h, i, j, k, l) \ _VA_ARRAY_SET_ITEMS12(v, a, b, c, d, e, f, g, h, i, j, k); ((v)[11] = (l)) #define _VA_ARRAY_SET_ITEMS14(v, a, b, c, d, e, f, g, h, i, j, k, l, m) \ _VA_ARRAY_SET_ITEMS13(v, a, b, c, d, e, f, g, h, i, j, k, l); ((v)[12] = (m)) #define _VA_ARRAY_SET_ITEMS15(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n) \ _VA_ARRAY_SET_ITEMS14(v, a, b, c, d, e, f, g, h, i, j, k, l, m); ((v)[13] = (n)) #define _VA_ARRAY_SET_ITEMS16(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) \ _VA_ARRAY_SET_ITEMS15(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n); ((v)[14] = (o)) #define _VA_ARRAY_SET_ITEMS17(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) \ _VA_ARRAY_SET_ITEMS16(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o); ((v)[15] = (p)) /* reusable ARRAY_SET_ITEMS macro */ #define ARRAY_SET_ITEMS(...) { VA_NARGS_CALL_OVERLOAD(_VA_ARRAY_SET_ITEMS, __VA_ARGS__); } (void)0 #if defined(__GNUC__) || defined(__clang__) #define POINTER_OFFSET(v, ofs) \ ((typeof(v))((char *)(v) + (ofs))) #else #define POINTER_OFFSET(v, ofs) \ ((void *)((char *)(v) + (ofs))) #endif /* Like offsetof(typeof(), member), for non-gcc compilers */ #define OFFSETOF_STRUCT(_struct, _member) \ ((((char *)&((_struct)->_member)) - ((char *)(_struct))) + sizeof((_struct)->_member)) /** * memcpy helper, skipping the first part of a struct, * ensures 'struct_dst' isn't const and the offset can be computed at compile time. * This isn't inclusive, the value of \a member isn't copied. */ #define MEMCPY_STRUCT_OFS(struct_dst, struct_src, member) { \ CHECK_TYPE_NONCONST(struct_dst); \ ((void)(struct_dst == struct_src), \ memcpy((char *)(struct_dst) + OFFSETOF_STRUCT(struct_dst, member), \ (char *)(struct_src) + OFFSETOF_STRUCT(struct_dst, member), \ sizeof(*(struct_dst)) - OFFSETOF_STRUCT(struct_dst, member))); \ } (void)0 #define MEMSET_STRUCT_OFS(struct_var, value, member) { \ CHECK_TYPE_NONCONST(struct_var); \ memset((char *)(struct_var) + OFFSETOF_STRUCT(struct_var, member), \ value, \ sizeof(*(struct_var)) - OFFSETOF_STRUCT(struct_var, member)); \ } (void)0 /* defined * in memory_utils.c for now. I do not know where we should put it actually... */ #ifndef __BLI_MEMORY_UTILS_H__ extern bool BLI_memory_is_zero(const void *arr, const size_t arr_size); #endif #define MEMCMP_STRUCT_OFS_IS_ZERO(struct_var, member) \ (BLI_memory_is_zero( \ (char *)(struct_var) + OFFSETOF_STRUCT(struct_var, member), \ sizeof(*(struct_var)) - OFFSETOF_STRUCT(struct_var, member))) /* Warning-free macros for storing ints in pointers. Use these _only_ * for storing an int in a pointer, not a pointer in an int (64bit)! */ #define SET_INT_IN_POINTER(i) ((void *)(intptr_t)(i)) #define GET_INT_FROM_POINTER(i) ((void)0, ((int)(intptr_t)(i))) #define SET_UINT_IN_POINTER(i) ((void *)(uintptr_t)(i)) #define GET_UINT_FROM_POINTER(i) ((void)0, ((unsigned int)(uintptr_t)(i))) /* Macro to convert a value to string in the preprocessor * STRINGIFY_ARG: gives the argument as a string * STRINGIFY_APPEND: appends any argument 'b' onto the string argument 'a', * used by STRINGIFY because some preprocessors warn about zero arguments * STRINGIFY: gives the argument's value as a string */ #define STRINGIFY_ARG(x) "" #x #define STRINGIFY_APPEND(a, b) "" a #b #define STRINGIFY(x) STRINGIFY_APPEND("", x) /* generic strcmp macros */ #if defined(_MSC_VER) # define strcasecmp _stricmp # define strncasecmp _strnicmp #endif #define STREQ(a, b) (strcmp(a, b) == 0) #define STRCASEEQ(a, b) (strcasecmp(a, b) == 0) #define STREQLEN(a, b, n) (strncmp(a, b, n) == 0) #define STRCASEEQLEN(a, b, n) (strncasecmp(a, b, n) == 0) #define STRPREFIX(a, b) (strncmp((a), (b), strlen(b)) == 0) /* useful for debugging */ #define AT __FILE__ ":" STRINGIFY(__LINE__) /* UNUSED macro, for function argument */ #ifdef __GNUC__ # define UNUSED(x) UNUSED_ ## x __attribute__((__unused__)) #else # define UNUSED(x) UNUSED_ ## x #endif #ifdef __GNUC__ # define UNUSED_FUNCTION(x) __attribute__((__unused__)) UNUSED_ ## x #else # define UNUSED_FUNCTION(x) UNUSED_ ## x #endif /** * UNUSED_VARS#(a, ...): quiet unused warnings * * \code{.py} * for i in range(16): * args = [(chr(ord('a') + (c % 26)) + (chr(ord('0') + (c // 26)))) for c in range(i + 1)] * print("#define _VA_UNUSED_VARS_%d(%s) \\" % (i + 1, ", ".join(args))) * print("\t((void)(%s)%s)" % * (args[0], ((", _VA_UNUSED_VARS_" + str(i) + "(%s)") if i else "%s") % ", ".join((args[1:])))) * \endcode */ #define _VA_UNUSED_VARS_1(a0) \ ((void)(a0)) #define _VA_UNUSED_VARS_2(a0, b0) \ ((void)(a0), _VA_UNUSED_VARS_1(b0)) #define _VA_UNUSED_VARS_3(a0, b0, c0) \ ((void)(a0), _VA_UNUSED_VARS_2(b0, c0)) #define _VA_UNUSED_VARS_4(a0, b0, c0, d0) \ ((void)(a0), _VA_UNUSED_VARS_3(b0, c0, d0)) #define _VA_UNUSED_VARS_5(a0, b0, c0, d0, e0) \ ((void)(a0), _VA_UNUSED_VARS_4(b0, c0, d0, e0)) #define _VA_UNUSED_VARS_6(a0, b0, c0, d0, e0, f0) \ ((void)(a0), _VA_UNUSED_VARS_5(b0, c0, d0, e0, f0)) #define _VA_UNUSED_VARS_7(a0, b0, c0, d0, e0, f0, g0) \ ((void)(a0), _VA_UNUSED_VARS_6(b0, c0, d0, e0, f0, g0)) #define _VA_UNUSED_VARS_8(a0, b0, c0, d0, e0, f0, g0, h0) \ ((void)(a0), _VA_UNUSED_VARS_7(b0, c0, d0, e0, f0, g0, h0)) #define _VA_UNUSED_VARS_9(a0, b0, c0, d0, e0, f0, g0, h0, i0) \ ((void)(a0), _VA_UNUSED_VARS_8(b0, c0, d0, e0, f0, g0, h0, i0)) #define _VA_UNUSED_VARS_10(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0) \ ((void)(a0), _VA_UNUSED_VARS_9(b0, c0, d0, e0, f0, g0, h0, i0, j0)) #define _VA_UNUSED_VARS_11(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0) \ ((void)(a0), _VA_UNUSED_VARS_10(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0)) #define _VA_UNUSED_VARS_12(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0) \ ((void)(a0), _VA_UNUSED_VARS_11(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0)) #define _VA_UNUSED_VARS_13(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0) \ ((void)(a0), _VA_UNUSED_VARS_12(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0)) #define _VA_UNUSED_VARS_14(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0) \ ((void)(a0), _VA_UNUSED_VARS_13(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0)) #define _VA_UNUSED_VARS_15(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0, o0) \ ((void)(a0), _VA_UNUSED_VARS_14(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0, o0)) #define _VA_UNUSED_VARS_16(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0, o0, p0) \ ((void)(a0), _VA_UNUSED_VARS_15(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0, o0, p0)) /* reusable ELEM macro */ #define UNUSED_VARS(...) VA_NARGS_CALL_OVERLOAD(_VA_UNUSED_VARS_, __VA_ARGS__) /* for debug-only variables */ #ifndef NDEBUG # define UNUSED_VARS_NDEBUG(...) #else # define UNUSED_VARS_NDEBUG UNUSED_VARS #endif /* BLI_assert(), default only to print * for aborting need to define WITH_ASSERT_ABORT */ #ifndef NDEBUG # include "BLI_system.h" # ifdef WITH_ASSERT_ABORT # define _BLI_DUMMY_ABORT abort # else # define _BLI_DUMMY_ABORT() (void)0 # endif # if defined(__GNUC__) || defined(_MSC_VER) /* check __func__ is available */ # define BLI_assert(a) \ (void)((!(a)) ? ( \ ( \ BLI_system_backtrace(stderr), \ fprintf(stderr, \ "BLI_assert failed: %s:%d, %s(), at \'%s\'\n", \ __FILE__, __LINE__, __func__, STRINGIFY(a)), \ _BLI_DUMMY_ABORT(), \ NULL)) : NULL) # else # define BLI_assert(a) \ (void)((!(a)) ? ( \ ( \ fprintf(stderr, \ "BLI_assert failed: %s:%d, at \'%s\'\n", \ __FILE__, __LINE__, STRINGIFY(a)), \ _BLI_DUMMY_ABORT(), \ NULL)) : NULL) # endif #else # define BLI_assert(a) (void)0 #endif /* C++ can't use _Static_assert, expects static_assert() but c++0x only, * Coverity also errors out. */ #if (!defined(__cplusplus)) && \ (!defined(__COVERITY__)) && \ (defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 406)) /* gcc4.6+ only */ # define BLI_STATIC_ASSERT(a, msg) __extension__ _Static_assert(a, msg); #else /* TODO msvc, clang */ # define BLI_STATIC_ASSERT(a, msg) #endif /* hints for branch prediction, only use in code that runs a _lot_ where */ #ifdef __GNUC__ # define LIKELY(x) __builtin_expect(!!(x), 1) # define UNLIKELY(x) __builtin_expect(!!(x), 0) #else # define LIKELY(x) (x) # define UNLIKELY(x) (x) #endif #ifdef __cplusplus } #endif #endif /* __BLI_UTILDEFINES_H__ */