65e8dcdba4aa91ca8ebb8a730faa9f46ff6a7e4b
[blender-staging.git] / source / blender / blenlib / BLI_utildefines.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 #ifndef __BLI_UTILDEFINES_H__
29 #define __BLI_UTILDEFINES_H__
30
31 /** \file BLI_utildefines.h
32  *  \ingroup bli
33  */
34
35 #ifdef __cplusplus
36 extern "C" {
37 #endif
38
39 /* avoid many includes for now */
40 #include "BLI_sys_types.h"
41 #include "BLI_compiler_compat.h"
42
43 #ifndef NDEBUG /* for BLI_assert */
44 #include <stdio.h>
45 #endif
46
47
48 /* varargs macros (keep first so others can use) */
49 /* --- internal helpers --- */
50 #define _VA_NARGS_GLUE(x, y) x y
51 #define _VA_NARGS_RETURN_COUNT(\
52         _1_, _2_, _3_, _4_, _5_, _6_, _7_, _8_, _9_, _10_, _11_, _12_, _13_, _14_, _15_, _16_, \
53         _17_, _18_, _19_, _20_, _21_, _22_, _23_, _24_, _25_, _26_, _27_, _28_, _29_, _30_, _31_, _32_, \
54         _33_, _34_, _35_, _36_, _37_, _38_, _39_, _40_, _41_, _42_, _43_, _44_, _45_, _46_, _47_, _48_, \
55         _49_, _50_, _51_, _52_, _53_, _54_, _55_, _56_, _57_, _58_, _59_, _60_, _61_, _62_, _63_, _64_, \
56         count, ...) count
57 #define _VA_NARGS_EXPAND(args) _VA_NARGS_RETURN_COUNT args
58 /* 64 args max */
59 #define _VA_NARGS_COUNT(...) _VA_NARGS_EXPAND((__VA_ARGS__, \
60         64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, \
61         48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, \
62         32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, \
63         16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2, 1, 0))
64 #define _VA_NARGS_OVERLOAD_MACRO2(name, count) name##count
65 #define _VA_NARGS_OVERLOAD_MACRO1(name, count) _VA_NARGS_OVERLOAD_MACRO2(name, count)
66 #define _VA_NARGS_OVERLOAD_MACRO(name,  count) _VA_NARGS_OVERLOAD_MACRO1(name, count)
67 /* --- expose for re-use --- */
68 #define VA_NARGS_CALL_OVERLOAD(name, ...) \
69         _VA_NARGS_GLUE(_VA_NARGS_OVERLOAD_MACRO(name, _VA_NARGS_COUNT(__VA_ARGS__)), (__VA_ARGS__))
70
71 /* useful for finding bad use of min/max */
72 #if 0
73 /* gcc only */
74 #  define _TYPECHECK(a, b)  ((void)(((typeof(a) *)0) == ((typeof(b) *)0)))
75 #  define MIN2(x, y)          (_TYPECHECK(x, y), (((x) < (y) ? (x) : (y))))
76 #  define MAX2(x, y)          (_TYPECHECK(x, y), (((x) > (y) ? (x) : (y))))
77 #endif
78
79 /* include after _VA_NARGS macro */
80 #include "BLI_compiler_typecheck.h"
81
82 /* min/max */
83 #if defined(__GNUC__) || defined(__clang__)
84
85 #define MIN2(a, b) __extension__ ({  \
86         typeof(a) a_ = (a); typeof(b) b_ = (b); \
87         ((a_) < (b_) ? (a_) : (b_)); })
88
89 #define MAX2(a, b) __extension__ ({  \
90         typeof(a) a_ = (a); typeof(b) b_ = (b); \
91         ((a_) > (b_) ? (a_) : (b_)); })
92
93 #define MIN3(a, b, c) __extension__ ({  \
94         typeof(a) a_ = (a); typeof(b) b_ = (b); typeof(c) c_ = (c); \
95         ((a_ < b_) ? ((a_ < c_) ? a_ : c_) : ((b_ < c_) ? b_ : c_)); })
96
97 #define MAX3(a, b, c) __extension__ ({  \
98         typeof(a) a_ = (a); typeof(b) b_ = (b);  typeof(c) c_ = (c); \
99         ((a_ > b_) ? ((a_ > c_) ? a_ : c_) : ((b_ > c_) ? b_ : c_)); })
100
101 #define MIN4(a, b, c, d) __extension__ ({  \
102         typeof(a) a_ = (a); typeof(b) b_ = (b); typeof(c) c_ = (c); typeof(d) d_ = (d); \
103         ((a_ < b_) ? ((a_ < c_) ? ((a_ < d_) ? a_ : d_) : ((c_ < d_) ? c_ : d_)) : \
104                      ((b_ < c_) ? ((b_ < d_) ? b_ : d_) : ((c_ < d_) ? c_ : d_))); })
105
106 #define MAX4(a, b, c, d) __extension__ ({  \
107         typeof(a) a_ = (a); typeof(b) b_ = (b); typeof(c) c_ = (c); typeof(d) d_ = (d); \
108         ((a_ > b_) ? ((a_ > c_) ? ((a_ > d_) ? a_ : d_) : ((c_ > d_) ? c_ : d_)) : \
109                      ((b_ > c_) ? ((b_ > d_) ? b_ : d_) : ((c_ > d_) ? c_ : d_))); })
110
111 #else
112 #define MIN2(a, b)  ((a) < (b) ? (a) : (b))
113 #define MAX2(a, b)  ((a) > (b) ? (a) : (b))
114
115 #define MIN3(a, b, c)       (MIN2(MIN2((a), (b)), (c)))
116 #define MIN4(a, b, c, d)    (MIN2(MIN2((a), (b)), MIN2((c), (d))))
117
118 #define MAX3(a, b, c)       (MAX2(MAX2((a), (b)), (c)))
119 #define MAX4(a, b, c, d)    (MAX2(MAX2((a), (b)), MAX2((c), (d))))
120 #endif
121
122 /* min/max that return a value of our choice */
123 #define MAX3_PAIR(cmp_a, cmp_b, cmp_c, ret_a, ret_b, ret_c) \
124         ((cmp_a > cmp_b) ? ((cmp_a > cmp_c) ? ret_a : ret_c) : \
125                            ((cmp_b > cmp_c) ? ret_b : ret_c))
126
127 #define MIN3_PAIR(cmp_a, cmp_b, cmp_c, ret_a, ret_b, ret_c) \
128         ((cmp_a < cmp_b) ? ((cmp_a < cmp_c) ? ret_a : ret_c) : \
129                            ((cmp_b < cmp_c) ? ret_b : ret_c))
130
131 #define INIT_MINMAX(min, max) {                                               \
132                 (min)[0] = (min)[1] = (min)[2] =  1.0e30f;                            \
133                 (max)[0] = (max)[1] = (max)[2] = -1.0e30f;                            \
134         } (void)0
135 #define INIT_MINMAX2(min, max) {                                              \
136                 (min)[0] = (min)[1] = 1.0e30f;                                        \
137                 (max)[0] = (max)[1] = -1.0e30f;                                       \
138         } (void)0
139 #define DO_MIN(vec, min) {                                                    \
140                 if ((min)[0] > (vec)[0]) (min)[0] = (vec)[0];                         \
141                 if ((min)[1] > (vec)[1]) (min)[1] = (vec)[1];                         \
142                 if ((min)[2] > (vec)[2]) (min)[2] = (vec)[2];                         \
143         } (void)0
144 #define DO_MAX(vec, max) {                                                    \
145                 if ((max)[0] < (vec)[0]) (max)[0] = (vec)[0];                         \
146                 if ((max)[1] < (vec)[1]) (max)[1] = (vec)[1];                         \
147                 if ((max)[2] < (vec)[2]) (max)[2] = (vec)[2];                         \
148         } (void)0
149 #define DO_MINMAX(vec, min, max) {                                            \
150                 if ((min)[0] > (vec)[0] ) (min)[0] = (vec)[0];                        \
151                 if ((min)[1] > (vec)[1] ) (min)[1] = (vec)[1];                        \
152                 if ((min)[2] > (vec)[2] ) (min)[2] = (vec)[2];                        \
153                 if ((max)[0] < (vec)[0] ) (max)[0] = (vec)[0];                        \
154                 if ((max)[1] < (vec)[1] ) (max)[1] = (vec)[1];                        \
155                 if ((max)[2] < (vec)[2] ) (max)[2] = (vec)[2];                        \
156         } (void)0
157 #define DO_MINMAX2(vec, min, max) {                                           \
158                 if ((min)[0] > (vec)[0] ) (min)[0] = (vec)[0];                        \
159                 if ((min)[1] > (vec)[1] ) (min)[1] = (vec)[1];                        \
160                 if ((max)[0] < (vec)[0] ) (max)[0] = (vec)[0];                        \
161                 if ((max)[1] < (vec)[1] ) (max)[1] = (vec)[1];                        \
162         } (void)0
163
164 /* some math and copy defines */
165
166
167 #define SWAP(type, a, b)  {    \
168         type sw_ap;                \
169         CHECK_TYPE(a, type);       \
170         CHECK_TYPE(b, type);       \
171         sw_ap = (a);               \
172         (a) = (b);                 \
173         (b) = sw_ap;               \
174 } (void)0
175
176 /* swap with a temp value */
177 #define SWAP_TVAL(tval, a, b)  {  \
178         CHECK_TYPE_PAIR(tval, a);     \
179         CHECK_TYPE_PAIR(tval, b);     \
180         (tval) = (a);                 \
181         (a) = (b);                    \
182         (b) = (tval);                 \
183 } (void)0
184
185 /* ELEM#(v, ...): is the first arg equal any others? */
186 /* internal helpers*/
187 #define _VA_ELEM2(v, a) \
188        ((v) == (a))
189 #define _VA_ELEM3(v, a, b) \
190        (_VA_ELEM2(v, a) || ((v) == (b)))
191 #define _VA_ELEM4(v, a, b, c) \
192        (_VA_ELEM3(v, a, b) || ((v) == (c)))
193 #define _VA_ELEM5(v, a, b, c, d) \
194        (_VA_ELEM4(v, a, b, c) || ((v) == (d)))
195 #define _VA_ELEM6(v, a, b, c, d, e) \
196        (_VA_ELEM5(v, a, b, c, d) || ((v) == (e)))
197 #define _VA_ELEM7(v, a, b, c, d, e, f) \
198        (_VA_ELEM6(v, a, b, c, d, e) || ((v) == (f)))
199 #define _VA_ELEM8(v, a, b, c, d, e, f, g) \
200        (_VA_ELEM7(v, a, b, c, d, e, f) || ((v) == (g)))
201 #define _VA_ELEM9(v, a, b, c, d, e, f, g, h) \
202        (_VA_ELEM8(v, a, b, c, d, e, f, g) || ((v) == (h)))
203 #define _VA_ELEM10(v, a, b, c, d, e, f, g, h, i) \
204        (_VA_ELEM9(v, a, b, c, d, e, f, g, h) || ((v) == (i)))
205 #define _VA_ELEM11(v, a, b, c, d, e, f, g, h, i, j) \
206        (_VA_ELEM10(v, a, b, c, d, e, f, g, h, i) || ((v) == (j)))
207 #define _VA_ELEM12(v, a, b, c, d, e, f, g, h, i, j, k) \
208        (_VA_ELEM11(v, a, b, c, d, e, f, g, h, i, j) || ((v) == (k)))
209 #define _VA_ELEM13(v, a, b, c, d, e, f, g, h, i, j, k, l) \
210        (_VA_ELEM12(v, a, b, c, d, e, f, g, h, i, j, k) || ((v) == (l)))
211 #define _VA_ELEM14(v, a, b, c, d, e, f, g, h, i, j, k, l, m) \
212        (_VA_ELEM13(v, a, b, c, d, e, f, g, h, i, j, k, l) || ((v) == (m)))
213 #define _VA_ELEM15(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n) \
214        (_VA_ELEM14(v, a, b, c, d, e, f, g, h, i, j, k, l, m) || ((v) == (n)))
215 #define _VA_ELEM16(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) \
216        (_VA_ELEM15(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n) || ((v) == (o)))
217 #define _VA_ELEM17(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) \
218        (_VA_ELEM16(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) || ((v) == (p)))
219
220 /* reusable ELEM macro */
221 #define ELEM(...) VA_NARGS_CALL_OVERLOAD(_VA_ELEM, __VA_ARGS__)
222
223 /* no-op for expressions we don't want to instansiate, but must remian valid */
224 #define EXPR_NOP(expr) (void)(0 ? ((void)(expr), 1) : 0)
225
226 /* shift around elements */
227 #define SHIFT3(type, a, b, c)  {                                              \
228         type tmp;                                                                 \
229         CHECK_TYPE(a, type);                                                      \
230         CHECK_TYPE(b, type);                                                      \
231         CHECK_TYPE(c, type);                                                      \
232         tmp = a;                                                                  \
233         a = c;                                                                    \
234         c = b;                                                                    \
235         b = tmp;                                                                  \
236 } (void)0
237
238 #define SHIFT4(type, a, b, c, d)  {                                           \
239         type tmp;                                                                 \
240         CHECK_TYPE(a, type);                                                      \
241         CHECK_TYPE(b, type);                                                      \
242         CHECK_TYPE(c, type);                                                      \
243         CHECK_TYPE(d, type);                                                      \
244         tmp = a;                                                                  \
245         a = d;                                                                    \
246         d = c;                                                                    \
247         c = b;                                                                    \
248         b = tmp;                                                                  \
249 } (void)0
250
251
252 #define FTOCHAR(val) ((CHECK_TYPE_INLINE(val, float)), \
253                 (char)(((val) <= 0.0f) ? 0 : (((val) > (1.0f - 0.5f / 255.0f)) ? 255 : ((255.0f * (val)) + 0.5f))))
254 #define FTOUSHORT(val) ((CHECK_TYPE_INLINE(val, float)), \
255                 (unsigned short)((val >= 1.0f - 0.5f / 65535) ? 65535 : (val <= 0.0f) ? 0 : (val * 65535.0f + 0.5f)))
256 #define USHORTTOUCHAR(val) ((unsigned char)(((val) >= 65535 - 128) ? 255 : ((val) + 128) >> 8))
257 #define F3TOCHAR3(v2, v1) {                                                   \
258                 (v1)[0] = FTOCHAR((v2[0]));                                           \
259                 (v1)[1] = FTOCHAR((v2[1]));                                           \
260                 (v1)[2] = FTOCHAR((v2[2]));                                           \
261 } (void)0
262 #define F3TOCHAR4(v2, v1) {                                                   \
263                 (v1)[0] = FTOCHAR((v2[0]));                                           \
264                 (v1)[1] = FTOCHAR((v2[1]));                                           \
265                 (v1)[2] = FTOCHAR((v2[2]));                                           \
266                 (v1)[3] = 255;                                                        \
267 } (void)0
268 #define F4TOCHAR4(v2, v1) {                                                   \
269                 (v1)[0] = FTOCHAR((v2[0]));                                           \
270                 (v1)[1] = FTOCHAR((v2[1]));                                           \
271                 (v1)[2] = FTOCHAR((v2[2]));                                           \
272                 (v1)[3] = FTOCHAR((v2[3]));                                           \
273 } (void)0
274 #define VECCOPY(v1, v2) {                                                     \
275                 *(v1) =   *(v2);                                                      \
276                 *(v1 + 1) = *(v2 + 1);                                                \
277                 *(v1 + 2) = *(v2 + 2);                                                \
278 } (void)0
279 #define VECCOPY2D(v1, v2) {                                                   \
280                 *(v1) =   *(v2);                                                      \
281                 *(v1 + 1) = *(v2 + 1);                                                \
282 } (void)0
283 #define VECADD(v1, v2, v3) {                                                  \
284                 *(v1) =   *(v2)   + *(v3);                                            \
285                 *(v1 + 1) = *(v2 + 1) + *(v3 + 1);                                    \
286                 *(v1 + 2) = *(v2 + 2) + *(v3 + 2);                                    \
287 } (void)0
288 #define VECSUB(v1, v2, v3) {                                                  \
289                 *(v1) =   *(v2)   - *(v3);                                            \
290                 *(v1 + 1) = *(v2 + 1) - *(v3 + 1);                                    \
291                 *(v1 + 2) = *(v2 + 2) - *(v3 + 2);                                    \
292 } (void)0
293 #define VECSUB2D(v1, v2, v3)     {                                            \
294                 *(v1) =   *(v2)   - *(v3);                                            \
295                 *(v1 + 1) = *(v2 + 1) - *(v3 + 1);                                    \
296 } (void)0
297 #define VECADDFAC(v1, v2, v3, fac) {                                          \
298                 *(v1) =   *(v2)   + *(v3) * (fac);                                    \
299                 *(v1 + 1) = *(v2 + 1) + *(v3 + 1) * (fac);                            \
300                 *(v1 + 2) = *(v2 + 2) + *(v3 + 2) * (fac);                            \
301 } (void)0
302 #define VECMADD(v1, v2, v3, v4) {                                             \
303                 *(v1) =   *(v2)   + *(v3) * (*(v4));                                  \
304                 *(v1 + 1) = *(v2 + 1) + *(v3 + 1) * (*(v4 + 1));                      \
305                 *(v1 + 2) = *(v2 + 2) + *(v3 + 2) * (*(v4 + 2));                      \
306 } (void)0
307 #define VECSUBFAC(v1, v2, v3, fac) {                                          \
308                 *(v1) =   *(v2)   - *(v3) * (fac);                                    \
309                 *(v1 + 1) = *(v2 + 1) - *(v3 + 1) * (fac);                            \
310                 *(v1 + 2) = *(v2 + 2) - *(v3 + 2) * (fac);                            \
311 } (void)0
312
313 /* some misc stuff.... */
314
315 /* avoid multiple access for supported compilers */
316 #if defined(__GNUC__) || defined(__clang__)
317
318 #define ABS(a)  ({ \
319         typeof(a) a_ = (a); \
320         ((a_) < 0 ? (-(a_)) : (a_)); })
321 #define SQUARE(a)  ({ \
322         typeof(a) a_ = (a); \
323         ((a_) * (a_)); })
324
325 #else
326
327 #define ABS(a)  ((a) < 0 ? (-(a)) : (a))
328 #define SQUARE(a)  ((a) * (a))
329
330 #endif
331
332 #define CLAMPIS(a, b, c)  ((a) < (b) ? (b) : (a) > (c) ? (c) : (a))
333
334 #define CLAMP(a, b, c)  {           \
335         if      ((a) < (b)) (a) = (b);  \
336         else if ((a) > (c)) (a) = (c);  \
337 } (void)0
338
339 #define CLAMP_MAX(a, c)  {          \
340         if ((a) > (c)) (a) = (c);       \
341 } (void)0
342
343 #define CLAMP_MIN(a, b)  {          \
344         if      ((a) < (b)) (a) = (b);  \
345 } (void)0
346
347 #define CLAMP2(vec, b, c) { \
348         CLAMP((vec)[0], b, c); \
349         CLAMP((vec)[1], b, c); \
350 } (void)0
351
352 #define CLAMP2_MIN(vec, b) { \
353         CLAMP_MIN((vec)[0], b); \
354         CLAMP_MIN((vec)[1], b); \
355 } (void)0
356
357 #define CLAMP2_MAX(vec, b) { \
358         CLAMP_MAX((vec)[0], b); \
359         CLAMP_MAX((vec)[1], b); \
360 } (void)0
361
362 #define CLAMP3(vec, b, c) { \
363         CLAMP((vec)[0], b, c); \
364         CLAMP((vec)[1], b, c); \
365         CLAMP((vec)[2], b, c); \
366 } (void)0
367
368 #define CLAMP3_MIN(vec, b) { \
369         CLAMP_MIN((vec)[0], b); \
370         CLAMP_MIN((vec)[1], b); \
371         CLAMP_MIN((vec)[2], b); \
372 } (void)0
373
374 #define CLAMP3_MAX(vec, b) { \
375         CLAMP_MAX((vec)[0], b); \
376         CLAMP_MAX((vec)[1], b); \
377         CLAMP_MAX((vec)[2], b); \
378 } (void)0
379
380 #define CLAMP4(vec, b, c) { \
381         CLAMP((vec)[0], b, c); \
382         CLAMP((vec)[1], b, c); \
383         CLAMP((vec)[2], b, c); \
384         CLAMP((vec)[3], b, c); \
385 } (void)0
386
387 #define CLAMP4_MIN(vec, b) { \
388         CLAMP_MIN((vec)[0], b); \
389         CLAMP_MIN((vec)[1], b); \
390         CLAMP_MIN((vec)[2], b); \
391         CLAMP_MIN((vec)[3], b); \
392 } (void)0
393
394 #define CLAMP4_MAX(vec, b) { \
395         CLAMP_MAX((vec)[0], b); \
396         CLAMP_MAX((vec)[1], b); \
397         CLAMP_MAX((vec)[2], b); \
398         CLAMP_MAX((vec)[3], b); \
399 } (void)0
400
401 #define IS_EQ(a, b)  ( \
402         CHECK_TYPE_INLINE(a, double), CHECK_TYPE_INLINE(b, double), \
403         ((fabs((double)((a) - (b))) >= (double) FLT_EPSILON) ? false : true))
404
405 #define IS_EQF(a, b)  ( \
406         CHECK_TYPE_INLINE(a, float), CHECK_TYPE_INLINE(b, float), \
407         ((fabsf((float)((a) - (b))) >= (float) FLT_EPSILON) ? false : true))
408
409 #define IS_EQT(a, b, c) ((a > b) ? ((((a) - (b)) <= c) ? 1 : 0) : (((((b) - (a)) <= c) ? 1 : 0)))
410 #define IN_RANGE(a, b, c) ((b < c) ? ((b < a && a < c) ? 1 : 0) : ((c < a && a < b) ? 1 : 0))
411 #define IN_RANGE_INCL(a, b, c) ((b < c) ? ((b <= a && a <= c) ? 1 : 0) : ((c <= a && a <= b) ? 1 : 0))
412
413 /* unpack vector for args */
414 #define UNPACK2(a)  ((a)[0]),   ((a)[1])
415 #define UNPACK3(a)  UNPACK2(a), ((a)[2])
416 #define UNPACK4(a)  UNPACK3(a), ((a)[3])
417 /* pre may be '&', '*' or func, post may be '->member' */
418 #define UNPACK2_EX(pre, a, post)  (pre((a)[0])post),        (pre((a)[1])post)
419 #define UNPACK3_EX(pre, a, post)  UNPACK2_EX(pre, a, post), (pre((a)[2])post)
420 #define UNPACK4_EX(pre, a, post)  UNPACK3_EX(pre, a, post), (pre((a)[3])post)
421
422 /* array helpers */
423 #define ARRAY_LAST_ITEM(arr_start, arr_dtype, tot) \
424         (arr_dtype *)((char *)(arr_start) + (sizeof(*((arr_dtype *)NULL)) * (size_t)(tot - 1)))
425
426 #define ARRAY_HAS_ITEM(arr_item, arr_start, tot)  ( \
427         CHECK_TYPE_PAIR_INLINE(arr_start, arr_item), \
428         ((unsigned int)((arr_item) - (arr_start)) < (unsigned int)(tot)))
429
430 #define ARRAY_DELETE(arr, index, tot_delete, tot)  { \
431                 BLI_assert(index + tot_delete <= tot);  \
432                 memmove(&(arr)[(index)], \
433                         &(arr)[(index) + (tot_delete)], \
434                          (((tot) - (index)) - (tot_delete)) * sizeof(*(arr))); \
435         } (void)0
436
437 /* assuming a static array */
438 #if defined(__GNUC__) && !defined(__cplusplus) && !defined(__clang__)
439 #  define ARRAY_SIZE(arr) \
440         ((sizeof(struct {int isnt_array : ((const void *)&(arr) == &(arr)[0]);}) * 0) + \
441          (sizeof(arr) / sizeof(*(arr))))
442 #else
443 #  define ARRAY_SIZE(arr)  (sizeof(arr) / sizeof(*(arr)))
444 #endif
445
446 /* ARRAY_SET_ITEMS#(v, ...): set indices of array 'v'  */
447 /* internal helpers */
448 #define _VA_ARRAY_SET_ITEMS2(v, a) \
449         ((v)[0] = (a))
450 #define _VA_ARRAY_SET_ITEMS3(v, a, b) \
451         _VA_ARRAY_SET_ITEMS2(v, a); ((v)[1] = (b))
452 #define _VA_ARRAY_SET_ITEMS4(v, a, b, c) \
453         _VA_ARRAY_SET_ITEMS3(v, a, b); ((v)[2] = (c))
454 #define _VA_ARRAY_SET_ITEMS5(v, a, b, c, d) \
455         _VA_ARRAY_SET_ITEMS4(v, a, b, c); ((v)[3] = (d))
456 #define _VA_ARRAY_SET_ITEMS6(v, a, b, c, d, e) \
457         _VA_ARRAY_SET_ITEMS5(v, a, b, c, d); ((v)[4] = (e))
458 #define _VA_ARRAY_SET_ITEMS7(v, a, b, c, d, e, f) \
459         _VA_ARRAY_SET_ITEMS6(v, a, b, c, d, e); ((v)[5] = (f))
460 #define _VA_ARRAY_SET_ITEMS8(v, a, b, c, d, e, f, g) \
461         _VA_ARRAY_SET_ITEMS7(v, a, b, c, d, e, f); ((v)[6] = (g))
462 #define _VA_ARRAY_SET_ITEMS9(v, a, b, c, d, e, f, g, h) \
463         _VA_ARRAY_SET_ITEMS8(v, a, b, c, d, e, f, g); ((v)[7] = (h))
464 #define _VA_ARRAY_SET_ITEMS10(v, a, b, c, d, e, f, g, h, i) \
465         _VA_ARRAY_SET_ITEMS9(v, a, b, c, d, e, f, g, h); ((v)[8] = (i))
466 #define _VA_ARRAY_SET_ITEMS11(v, a, b, c, d, e, f, g, h, i, j) \
467         _VA_ARRAY_SET_ITEMS10(v, a, b, c, d, e, f, g, h, i); ((v)[9] = (j))
468 #define _VA_ARRAY_SET_ITEMS12(v, a, b, c, d, e, f, g, h, i, j, k) \
469         _VA_ARRAY_SET_ITEMS11(v, a, b, c, d, e, f, g, h, i, j); ((v)[10] = (k))
470 #define _VA_ARRAY_SET_ITEMS13(v, a, b, c, d, e, f, g, h, i, j, k, l) \
471         _VA_ARRAY_SET_ITEMS12(v, a, b, c, d, e, f, g, h, i, j, k); ((v)[11] = (l))
472 #define _VA_ARRAY_SET_ITEMS14(v, a, b, c, d, e, f, g, h, i, j, k, l, m) \
473         _VA_ARRAY_SET_ITEMS13(v, a, b, c, d, e, f, g, h, i, j, k, l); ((v)[12] = (m))
474 #define _VA_ARRAY_SET_ITEMS15(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n) \
475         _VA_ARRAY_SET_ITEMS14(v, a, b, c, d, e, f, g, h, i, j, k, l, m); ((v)[13] = (n))
476 #define _VA_ARRAY_SET_ITEMS16(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) \
477         _VA_ARRAY_SET_ITEMS15(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n); ((v)[14] = (o))
478 #define _VA_ARRAY_SET_ITEMS17(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) \
479         _VA_ARRAY_SET_ITEMS16(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o); ((v)[15] = (p))
480
481 /* reusable ARRAY_SET_ITEMS macro */
482 #define ARRAY_SET_ITEMS(...) { VA_NARGS_CALL_OVERLOAD(_VA_ARRAY_SET_ITEMS, __VA_ARGS__); } (void)0
483
484 #if defined(__GNUC__) || defined(__clang__)
485 #define POINTER_OFFSET(v, ofs) \
486         ((typeof(v))((char *)(v) + (ofs)))
487 #else
488 #define POINTER_OFFSET(v, ofs) \
489         ((void *)((char *)(v) + (ofs)))
490 #endif
491
492 /* Like offsetof(typeof(), member), for non-gcc compilers */
493 #define OFFSETOF_STRUCT(_struct, _member) \
494         ((((char *)&((_struct)->_member)) - ((char *)(_struct))) + sizeof((_struct)->_member))
495
496 /**
497  * memcpy helper, skipping the first part of a struct,
498  * ensures 'struct_dst' isn't const and the offset can be computed at compile time.
499  * This isn't inclusive, the value of \a member isn't copied.
500  */
501 #define MEMCPY_STRUCT_OFS(struct_dst, struct_src, member)  { \
502         CHECK_TYPE_NONCONST(struct_dst); \
503         ((void)(struct_dst == struct_src), \
504          memcpy((char *)(struct_dst)  + OFFSETOF_STRUCT(struct_dst, member), \
505                 (char *)(struct_src)  + OFFSETOF_STRUCT(struct_dst, member), \
506                 sizeof(*(struct_dst)) - OFFSETOF_STRUCT(struct_dst, member))); \
507 } (void)0
508
509 #define MEMSET_STRUCT_OFS(struct_var, value, member)  { \
510         CHECK_TYPE_NONCONST(struct_var); \
511         memset((char *)(struct_var)  + OFFSETOF_STRUCT(struct_var, member), \
512                value, \
513                sizeof(*(struct_var)) - OFFSETOF_STRUCT(struct_var, member)); \
514 } (void)0
515
516 /* Warning-free macros for storing ints in pointers. Use these _only_
517  * for storing an int in a pointer, not a pointer in an int (64bit)! */
518 #define SET_INT_IN_POINTER(i)    ((void *)(intptr_t)(i))
519 #define GET_INT_FROM_POINTER(i)  ((void)0, ((int)(intptr_t)(i)))
520
521 #define SET_UINT_IN_POINTER(i)    ((void *)(uintptr_t)(i))
522 #define GET_UINT_FROM_POINTER(i)  ((void)0, ((unsigned int)(uintptr_t)(i)))
523
524
525 /* Macro to convert a value to string in the preprocessor
526  * STRINGIFY_ARG: gives the argument as a string
527  * STRINGIFY_APPEND: appends any argument 'b' onto the string argument 'a',
528  *   used by STRINGIFY because some preprocessors warn about zero arguments
529  * STRINGIFY: gives the argument's value as a string */
530 #define STRINGIFY_ARG(x) "" #x
531 #define STRINGIFY_APPEND(a, b) "" a #b
532 #define STRINGIFY(x) STRINGIFY_APPEND("", x)
533
534
535 /* generic strcmp macros */
536 #if defined(_MSC_VER)
537 #  define strcasecmp _stricmp
538 #  define strncasecmp _strnicmp
539 #endif
540
541 #define STREQ(a, b) (strcmp(a, b) == 0)
542 #define STRCASEEQ(a, b) (strcasecmp(a, b) == 0)
543 #define STREQLEN(a, b, n) (strncmp(a, b, n) == 0)
544 #define STRCASEEQLEN(a, b, n) (strncasecmp(a, b, n) == 0)
545
546 #define STRPREFIX(a, b) (strncmp((a), (b), strlen(b)) == 0)
547 /* useful for debugging */
548 #define AT __FILE__ ":" STRINGIFY(__LINE__)
549
550
551 /* UNUSED macro, for function argument */
552 #ifdef __GNUC__
553 #  define UNUSED(x) UNUSED_ ## x __attribute__((__unused__))
554 #else
555 #  define UNUSED(x) UNUSED_ ## x
556 #endif
557
558 #ifdef __GNUC__
559 #  define UNUSED_FUNCTION(x) __attribute__((__unused__)) UNUSED_ ## x
560 #else
561 #  define UNUSED_FUNCTION(x) UNUSED_ ## x
562 #endif
563
564 /**
565  * UNUSED_VARS#(a, ...): quiet unused warnings
566  *
567  * \code{.py}
568  * for i in range(16):
569  *     args = [(chr(ord('a') + (c % 26)) + (chr(ord('0') + (c // 26)))) for c in range(i + 1)]
570  *     print("#define _VA_UNUSED_VARS_%d(%s) \\" % (i + 1, ", ".join(args)))
571  *     print("\t((void)(%s)%s)" %
572  *             (args[0], ((", _VA_UNUSED_VARS_" + str(i) + "(%s)") if i else "%s") % ", ".join((args[1:]))))
573  * \endcode
574  */
575
576 #define _VA_UNUSED_VARS_1(a0) \
577         ((void)(a0))
578 #define _VA_UNUSED_VARS_2(a0, b0) \
579         ((void)(a0), _VA_UNUSED_VARS_1(b0))
580 #define _VA_UNUSED_VARS_3(a0, b0, c0) \
581         ((void)(a0), _VA_UNUSED_VARS_2(b0, c0))
582 #define _VA_UNUSED_VARS_4(a0, b0, c0, d0) \
583         ((void)(a0), _VA_UNUSED_VARS_3(b0, c0, d0))
584 #define _VA_UNUSED_VARS_5(a0, b0, c0, d0, e0) \
585         ((void)(a0), _VA_UNUSED_VARS_4(b0, c0, d0, e0))
586 #define _VA_UNUSED_VARS_6(a0, b0, c0, d0, e0, f0) \
587         ((void)(a0), _VA_UNUSED_VARS_5(b0, c0, d0, e0, f0))
588 #define _VA_UNUSED_VARS_7(a0, b0, c0, d0, e0, f0, g0) \
589         ((void)(a0), _VA_UNUSED_VARS_6(b0, c0, d0, e0, f0, g0))
590 #define _VA_UNUSED_VARS_8(a0, b0, c0, d0, e0, f0, g0, h0) \
591         ((void)(a0), _VA_UNUSED_VARS_7(b0, c0, d0, e0, f0, g0, h0))
592 #define _VA_UNUSED_VARS_9(a0, b0, c0, d0, e0, f0, g0, h0, i0) \
593         ((void)(a0), _VA_UNUSED_VARS_8(b0, c0, d0, e0, f0, g0, h0, i0))
594 #define _VA_UNUSED_VARS_10(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0) \
595         ((void)(a0), _VA_UNUSED_VARS_9(b0, c0, d0, e0, f0, g0, h0, i0, j0))
596 #define _VA_UNUSED_VARS_11(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0) \
597         ((void)(a0), _VA_UNUSED_VARS_10(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0))
598 #define _VA_UNUSED_VARS_12(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0) \
599         ((void)(a0), _VA_UNUSED_VARS_11(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0))
600 #define _VA_UNUSED_VARS_13(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0) \
601         ((void)(a0), _VA_UNUSED_VARS_12(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0))
602 #define _VA_UNUSED_VARS_14(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0) \
603         ((void)(a0), _VA_UNUSED_VARS_13(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0))
604 #define _VA_UNUSED_VARS_15(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0, o0) \
605         ((void)(a0), _VA_UNUSED_VARS_14(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0, o0))
606 #define _VA_UNUSED_VARS_16(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0, o0, p0) \
607         ((void)(a0), _VA_UNUSED_VARS_15(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0, o0, p0))
608
609
610 /* reusable ELEM macro */
611 #define UNUSED_VARS(...) VA_NARGS_CALL_OVERLOAD(_VA_UNUSED_VARS_, __VA_ARGS__)
612
613 /* for debug-only variables */
614 #ifndef NDEBUG
615 #  define UNUSED_VARS_NDEBUG(...)
616 #else
617 #  define UNUSED_VARS_NDEBUG UNUSED_VARS
618 #endif
619
620 /*little macro so inline keyword works*/
621 #if defined(_MSC_VER)
622 #  define BLI_INLINE static __forceinline
623 #else
624 #  if (defined(__APPLE__) && defined(__ppc__))
625 /* static inline __attribute__ here breaks osx ppc gcc42 build */
626 #    define BLI_INLINE static __attribute__((always_inline))
627 #  else
628 #    define BLI_INLINE static inline __attribute__((always_inline))
629 #  endif
630 #endif
631
632
633 /* BLI_assert(), default only to print
634  * for aborting need to define WITH_ASSERT_ABORT
635  */
636 #ifndef NDEBUG
637 extern void BLI_system_backtrace(FILE *fp);
638 #  ifdef WITH_ASSERT_ABORT
639 #    define _BLI_DUMMY_ABORT abort
640 #  else
641 #    define _BLI_DUMMY_ABORT() (void)0
642 #  endif
643 #  if defined(__GNUC__) || defined(_MSC_VER) /* check __func__ is available */
644 #    define BLI_assert(a)                                                     \
645         (void)((!(a)) ?  (                                                        \
646                 (                                                                     \
647                 BLI_system_backtrace(stderr),                                         \
648                 fprintf(stderr,                                                       \
649                         "BLI_assert failed: %s:%d, %s(), at \'%s\'\n",                    \
650                         __FILE__, __LINE__, __func__, STRINGIFY(a)),                      \
651                 _BLI_DUMMY_ABORT(),                                                   \
652                 NULL)) : NULL)
653 #  else
654 #    define BLI_assert(a)                                                     \
655         (void)((!(a)) ?  (                                                        \
656                 (                                                                     \
657                 fprintf(stderr,                                                       \
658                         "BLI_assert failed: %s:%d, at \'%s\'\n",                          \
659                         __FILE__, __LINE__, STRINGIFY(a)),                                \
660                 _BLI_DUMMY_ABORT(),                                                   \
661                 NULL)) : NULL)
662 #  endif
663 #else
664 #  define BLI_assert(a) (void)0
665 #endif
666
667 /* C++ can't use _Static_assert, expects static_assert() but c++0x only,
668  * Coverity also errors out. */
669 #if (!defined(__cplusplus)) && \
670     (!defined(__COVERITY__)) && \
671     (defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 406))  /* gcc4.6+ only */
672 #  define BLI_STATIC_ASSERT(a, msg) __extension__ _Static_assert(a, msg);
673 #else
674    /* TODO msvc, clang */
675 #  define BLI_STATIC_ASSERT(a, msg)
676 #endif
677
678 /* hints for branch prediction, only use in code that runs a _lot_ where */
679 #ifdef __GNUC__
680 #  define LIKELY(x)       __builtin_expect(!!(x), 1)
681 #  define UNLIKELY(x)     __builtin_expect(!!(x), 0)
682 #else
683 #  define LIKELY(x)       (x)
684 #  define UNLIKELY(x)     (x)
685 #endif
686
687 #ifdef __cplusplus
688 }
689 #endif
690
691 #endif  /* __BLI_UTILDEFINES_H__ */