46b3748c7cef0e5ba984f1e9e4c735f606273a09
[blender.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 #include "BLI_utildefines_variadic.h"
43
44 /* We could remove in future. */
45 #include "BLI_assert.h"
46
47 /* useful for finding bad use of min/max */
48 #if 0
49 /* gcc only */
50 #  define _TYPECHECK(a, b)  ((void)(((typeof(a) *)0) == ((typeof(b) *)0)))
51 #  define MIN2(x, y)          (_TYPECHECK(x, y), (((x) < (y) ? (x) : (y))))
52 #  define MAX2(x, y)          (_TYPECHECK(x, y), (((x) > (y) ? (x) : (y))))
53 #endif
54
55 /* include after _VA_NARGS macro */
56 #include "BLI_compiler_typecheck.h"
57
58 /* min/max */
59 #if defined(__GNUC__) || defined(__clang__)
60
61 #define MIN2(a, b) __extension__ ({  \
62         typeof(a) a_ = (a); typeof(b) b_ = (b); \
63         ((a_) < (b_) ? (a_) : (b_)); })
64
65 #define MAX2(a, b) __extension__ ({  \
66         typeof(a) a_ = (a); typeof(b) b_ = (b); \
67         ((a_) > (b_) ? (a_) : (b_)); })
68
69 #define MIN3(a, b, c) __extension__ ({  \
70         typeof(a) a_ = (a); typeof(b) b_ = (b); typeof(c) c_ = (c); \
71         ((a_ < b_) ? ((a_ < c_) ? a_ : c_) : ((b_ < c_) ? b_ : c_)); })
72
73 #define MAX3(a, b, c) __extension__ ({  \
74         typeof(a) a_ = (a); typeof(b) b_ = (b);  typeof(c) c_ = (c); \
75         ((a_ > b_) ? ((a_ > c_) ? a_ : c_) : ((b_ > c_) ? b_ : c_)); })
76
77 #define MIN4(a, b, c, d) __extension__ ({  \
78         typeof(a) a_ = (a); typeof(b) b_ = (b); typeof(c) c_ = (c); typeof(d) d_ = (d); \
79         ((a_ < b_) ? ((a_ < c_) ? ((a_ < d_) ? a_ : d_) : ((c_ < d_) ? c_ : d_)) : \
80                      ((b_ < c_) ? ((b_ < d_) ? b_ : d_) : ((c_ < d_) ? c_ : d_))); })
81
82 #define MAX4(a, b, c, d) __extension__ ({  \
83         typeof(a) a_ = (a); typeof(b) b_ = (b); typeof(c) c_ = (c); typeof(d) d_ = (d); \
84         ((a_ > b_) ? ((a_ > c_) ? ((a_ > d_) ? a_ : d_) : ((c_ > d_) ? c_ : d_)) : \
85                      ((b_ > c_) ? ((b_ > d_) ? b_ : d_) : ((c_ > d_) ? c_ : d_))); })
86
87 #else
88 #define MIN2(a, b)  ((a) < (b) ? (a) : (b))
89 #define MAX2(a, b)  ((a) > (b) ? (a) : (b))
90
91 #define MIN3(a, b, c)       (MIN2(MIN2((a), (b)), (c)))
92 #define MIN4(a, b, c, d)    (MIN2(MIN2((a), (b)), MIN2((c), (d))))
93
94 #define MAX3(a, b, c)       (MAX2(MAX2((a), (b)), (c)))
95 #define MAX4(a, b, c, d)    (MAX2(MAX2((a), (b)), MAX2((c), (d))))
96 #endif
97
98 /* min/max that return a value of our choice */
99 #define MAX3_PAIR(cmp_a, cmp_b, cmp_c, ret_a, ret_b, ret_c) \
100         ((cmp_a > cmp_b) ? ((cmp_a > cmp_c) ? ret_a : ret_c) : \
101                            ((cmp_b > cmp_c) ? ret_b : ret_c))
102
103 #define MIN3_PAIR(cmp_a, cmp_b, cmp_c, ret_a, ret_b, ret_c) \
104         ((cmp_a < cmp_b) ? ((cmp_a < cmp_c) ? ret_a : ret_c) : \
105                            ((cmp_b < cmp_c) ? ret_b : ret_c))
106
107 #define INIT_MINMAX(min, max) {                                               \
108                 (min)[0] = (min)[1] = (min)[2] =  1.0e30f;                            \
109                 (max)[0] = (max)[1] = (max)[2] = -1.0e30f;                            \
110         } (void)0
111 #define INIT_MINMAX2(min, max) {                                              \
112                 (min)[0] = (min)[1] = 1.0e30f;                                        \
113                 (max)[0] = (max)[1] = -1.0e30f;                                       \
114         } (void)0
115 #define DO_MIN(vec, min) {                                                    \
116                 if ((min)[0] > (vec)[0]) (min)[0] = (vec)[0];                         \
117                 if ((min)[1] > (vec)[1]) (min)[1] = (vec)[1];                         \
118                 if ((min)[2] > (vec)[2]) (min)[2] = (vec)[2];                         \
119         } (void)0
120 #define DO_MAX(vec, max) {                                                    \
121                 if ((max)[0] < (vec)[0]) (max)[0] = (vec)[0];                         \
122                 if ((max)[1] < (vec)[1]) (max)[1] = (vec)[1];                         \
123                 if ((max)[2] < (vec)[2]) (max)[2] = (vec)[2];                         \
124         } (void)0
125 #define DO_MINMAX(vec, min, max) {                                            \
126                 if ((min)[0] > (vec)[0] ) (min)[0] = (vec)[0];                        \
127                 if ((min)[1] > (vec)[1] ) (min)[1] = (vec)[1];                        \
128                 if ((min)[2] > (vec)[2] ) (min)[2] = (vec)[2];                        \
129                 if ((max)[0] < (vec)[0] ) (max)[0] = (vec)[0];                        \
130                 if ((max)[1] < (vec)[1] ) (max)[1] = (vec)[1];                        \
131                 if ((max)[2] < (vec)[2] ) (max)[2] = (vec)[2];                        \
132         } (void)0
133 #define DO_MINMAX2(vec, min, max) {                                           \
134                 if ((min)[0] > (vec)[0] ) (min)[0] = (vec)[0];                        \
135                 if ((min)[1] > (vec)[1] ) (min)[1] = (vec)[1];                        \
136                 if ((max)[0] < (vec)[0] ) (max)[0] = (vec)[0];                        \
137                 if ((max)[1] < (vec)[1] ) (max)[1] = (vec)[1];                        \
138         } (void)0
139
140 /* some math and copy defines */
141
142
143 #define SWAP(type, a, b)  {    \
144         type sw_ap;                \
145         CHECK_TYPE(a, type);       \
146         CHECK_TYPE(b, type);       \
147         sw_ap = (a);               \
148         (a) = (b);                 \
149         (b) = sw_ap;               \
150 } (void)0
151
152 /* swap with a temp value */
153 #define SWAP_TVAL(tval, a, b)  {  \
154         CHECK_TYPE_PAIR(tval, a);     \
155         CHECK_TYPE_PAIR(tval, b);     \
156         (tval) = (a);                 \
157         (a) = (b);                    \
158         (b) = (tval);                 \
159 } (void)0
160
161 /* ELEM#(v, ...): is the first arg equal any others? */
162 /* internal helpers*/
163 #define _VA_ELEM2(v, a) \
164        ((v) == (a))
165 #define _VA_ELEM3(v, a, b) \
166        (_VA_ELEM2(v, a) || ((v) == (b)))
167 #define _VA_ELEM4(v, a, b, c) \
168        (_VA_ELEM3(v, a, b) || ((v) == (c)))
169 #define _VA_ELEM5(v, a, b, c, d) \
170        (_VA_ELEM4(v, a, b, c) || ((v) == (d)))
171 #define _VA_ELEM6(v, a, b, c, d, e) \
172        (_VA_ELEM5(v, a, b, c, d) || ((v) == (e)))
173 #define _VA_ELEM7(v, a, b, c, d, e, f) \
174        (_VA_ELEM6(v, a, b, c, d, e) || ((v) == (f)))
175 #define _VA_ELEM8(v, a, b, c, d, e, f, g) \
176        (_VA_ELEM7(v, a, b, c, d, e, f) || ((v) == (g)))
177 #define _VA_ELEM9(v, a, b, c, d, e, f, g, h) \
178        (_VA_ELEM8(v, a, b, c, d, e, f, g) || ((v) == (h)))
179 #define _VA_ELEM10(v, a, b, c, d, e, f, g, h, i) \
180        (_VA_ELEM9(v, a, b, c, d, e, f, g, h) || ((v) == (i)))
181 #define _VA_ELEM11(v, a, b, c, d, e, f, g, h, i, j) \
182        (_VA_ELEM10(v, a, b, c, d, e, f, g, h, i) || ((v) == (j)))
183 #define _VA_ELEM12(v, a, b, c, d, e, f, g, h, i, j, k) \
184        (_VA_ELEM11(v, a, b, c, d, e, f, g, h, i, j) || ((v) == (k)))
185 #define _VA_ELEM13(v, a, b, c, d, e, f, g, h, i, j, k, l) \
186        (_VA_ELEM12(v, a, b, c, d, e, f, g, h, i, j, k) || ((v) == (l)))
187 #define _VA_ELEM14(v, a, b, c, d, e, f, g, h, i, j, k, l, m) \
188        (_VA_ELEM13(v, a, b, c, d, e, f, g, h, i, j, k, l) || ((v) == (m)))
189 #define _VA_ELEM15(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n) \
190        (_VA_ELEM14(v, a, b, c, d, e, f, g, h, i, j, k, l, m) || ((v) == (n)))
191 #define _VA_ELEM16(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) \
192        (_VA_ELEM15(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n) || ((v) == (o)))
193 #define _VA_ELEM17(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) \
194        (_VA_ELEM16(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) || ((v) == (p)))
195
196 /* reusable ELEM macro */
197 #define ELEM(...) VA_NARGS_CALL_OVERLOAD(_VA_ELEM, __VA_ARGS__)
198
199 /* no-op for expressions we don't want to instansiate, but must remian valid */
200 #define EXPR_NOP(expr) (void)(0 ? ((void)(expr), 1) : 0)
201
202 /* shift around elements */
203 #define SHIFT3(type, a, b, c)  {                                              \
204         type tmp;                                                                 \
205         CHECK_TYPE(a, type);                                                      \
206         CHECK_TYPE(b, type);                                                      \
207         CHECK_TYPE(c, type);                                                      \
208         tmp = a;                                                                  \
209         a = c;                                                                    \
210         c = b;                                                                    \
211         b = tmp;                                                                  \
212 } (void)0
213
214 #define SHIFT4(type, a, b, c, d)  {                                           \
215         type tmp;                                                                 \
216         CHECK_TYPE(a, type);                                                      \
217         CHECK_TYPE(b, type);                                                      \
218         CHECK_TYPE(c, type);                                                      \
219         CHECK_TYPE(d, type);                                                      \
220         tmp = a;                                                                  \
221         a = d;                                                                    \
222         d = c;                                                                    \
223         c = b;                                                                    \
224         b = tmp;                                                                  \
225 } (void)0
226
227
228 #define FTOCHAR(val) ((CHECK_TYPE_INLINE(val, float)), \
229                 (char)(((val) <= 0.0f) ? 0 : (((val) > (1.0f - 0.5f / 255.0f)) ? 255 : ((255.0f * (val)) + 0.5f))))
230 #define FTOUSHORT(val) ((CHECK_TYPE_INLINE(val, float)), \
231                 (unsigned short)((val >= 1.0f - 0.5f / 65535) ? 65535 : (val <= 0.0f) ? 0 : (val * 65535.0f + 0.5f)))
232 #define USHORTTOUCHAR(val) ((unsigned char)(((val) >= 65535 - 128) ? 255 : ((val) + 128) >> 8))
233 #define F3TOCHAR3(v2, v1) {                                                   \
234                 (v1)[0] = FTOCHAR((v2[0]));                                           \
235                 (v1)[1] = FTOCHAR((v2[1]));                                           \
236                 (v1)[2] = FTOCHAR((v2[2]));                                           \
237 } (void)0
238 #define F3TOCHAR4(v2, v1) {                                                   \
239                 (v1)[0] = FTOCHAR((v2[0]));                                           \
240                 (v1)[1] = FTOCHAR((v2[1]));                                           \
241                 (v1)[2] = FTOCHAR((v2[2]));                                           \
242                 (v1)[3] = 255;                                                        \
243 } (void)0
244 #define F4TOCHAR4(v2, v1) {                                                   \
245                 (v1)[0] = FTOCHAR((v2[0]));                                           \
246                 (v1)[1] = FTOCHAR((v2[1]));                                           \
247                 (v1)[2] = FTOCHAR((v2[2]));                                           \
248                 (v1)[3] = FTOCHAR((v2[3]));                                           \
249 } (void)0
250 #define VECCOPY(v1, v2) {                                                     \
251                 *(v1) =   *(v2);                                                      \
252                 *(v1 + 1) = *(v2 + 1);                                                \
253                 *(v1 + 2) = *(v2 + 2);                                                \
254 } (void)0
255 #define VECCOPY2D(v1, v2) {                                                   \
256                 *(v1) =   *(v2);                                                      \
257                 *(v1 + 1) = *(v2 + 1);                                                \
258 } (void)0
259 #define VECADD(v1, v2, v3) {                                                  \
260                 *(v1) =   *(v2)   + *(v3);                                            \
261                 *(v1 + 1) = *(v2 + 1) + *(v3 + 1);                                    \
262                 *(v1 + 2) = *(v2 + 2) + *(v3 + 2);                                    \
263 } (void)0
264 #define VECSUB(v1, v2, v3) {                                                  \
265                 *(v1) =   *(v2)   - *(v3);                                            \
266                 *(v1 + 1) = *(v2 + 1) - *(v3 + 1);                                    \
267                 *(v1 + 2) = *(v2 + 2) - *(v3 + 2);                                    \
268 } (void)0
269 #define VECSUB2D(v1, v2, v3)     {                                            \
270                 *(v1) =   *(v2)   - *(v3);                                            \
271                 *(v1 + 1) = *(v2 + 1) - *(v3 + 1);                                    \
272 } (void)0
273 #define VECADDFAC(v1, v2, v3, fac) {                                          \
274                 *(v1) =   *(v2)   + *(v3) * (fac);                                    \
275                 *(v1 + 1) = *(v2 + 1) + *(v3 + 1) * (fac);                            \
276                 *(v1 + 2) = *(v2 + 2) + *(v3 + 2) * (fac);                            \
277 } (void)0
278 #define VECMADD(v1, v2, v3, v4) {                                             \
279                 *(v1) =   *(v2)   + *(v3) * (*(v4));                                  \
280                 *(v1 + 1) = *(v2 + 1) + *(v3 + 1) * (*(v4 + 1));                      \
281                 *(v1 + 2) = *(v2 + 2) + *(v3 + 2) * (*(v4 + 2));                      \
282 } (void)0
283 #define VECSUBFAC(v1, v2, v3, fac) {                                          \
284                 *(v1) =   *(v2)   - *(v3) * (fac);                                    \
285                 *(v1 + 1) = *(v2 + 1) - *(v3 + 1) * (fac);                            \
286                 *(v1 + 2) = *(v2 + 2) - *(v3 + 2) * (fac);                            \
287 } (void)0
288
289 /* some misc stuff.... */
290
291 /* avoid multiple access for supported compilers */
292 #if defined(__GNUC__) || defined(__clang__)
293
294 #define ABS(a)  ({ \
295         typeof(a) a_ = (a); \
296         ((a_) < 0 ? (-(a_)) : (a_)); })
297 #define SQUARE(a)  ({ \
298         typeof(a) a_ = (a); \
299         ((a_) * (a_)); })
300
301 #else
302
303 #define ABS(a)  ((a) < 0 ? (-(a)) : (a))
304 #define SQUARE(a)  ((a) * (a))
305
306 #endif
307
308 #define CLAMPIS(a, b, c)  ((a) < (b) ? (b) : (a) > (c) ? (c) : (a))
309
310 #define CLAMP(a, b, c)  {           \
311         if      ((a) < (b)) (a) = (b);  \
312         else if ((a) > (c)) (a) = (c);  \
313 } (void)0
314
315 #define CLAMP_MAX(a, c)  {          \
316         if ((a) > (c)) (a) = (c);       \
317 } (void)0
318
319 #define CLAMP_MIN(a, b)  {          \
320         if      ((a) < (b)) (a) = (b);  \
321 } (void)0
322
323 #define CLAMP2(vec, b, c) { \
324         CLAMP((vec)[0], b, c); \
325         CLAMP((vec)[1], b, c); \
326 } (void)0
327
328 #define CLAMP2_MIN(vec, b) { \
329         CLAMP_MIN((vec)[0], b); \
330         CLAMP_MIN((vec)[1], b); \
331 } (void)0
332
333 #define CLAMP2_MAX(vec, b) { \
334         CLAMP_MAX((vec)[0], b); \
335         CLAMP_MAX((vec)[1], b); \
336 } (void)0
337
338 #define CLAMP3(vec, b, c) { \
339         CLAMP((vec)[0], b, c); \
340         CLAMP((vec)[1], b, c); \
341         CLAMP((vec)[2], b, c); \
342 } (void)0
343
344 #define CLAMP3_MIN(vec, b) { \
345         CLAMP_MIN((vec)[0], b); \
346         CLAMP_MIN((vec)[1], b); \
347         CLAMP_MIN((vec)[2], b); \
348 } (void)0
349
350 #define CLAMP3_MAX(vec, b) { \
351         CLAMP_MAX((vec)[0], b); \
352         CLAMP_MAX((vec)[1], b); \
353         CLAMP_MAX((vec)[2], b); \
354 } (void)0
355
356 #define CLAMP4(vec, b, c) { \
357         CLAMP((vec)[0], b, c); \
358         CLAMP((vec)[1], b, c); \
359         CLAMP((vec)[2], b, c); \
360         CLAMP((vec)[3], b, c); \
361 } (void)0
362
363 #define CLAMP4_MIN(vec, b) { \
364         CLAMP_MIN((vec)[0], b); \
365         CLAMP_MIN((vec)[1], b); \
366         CLAMP_MIN((vec)[2], b); \
367         CLAMP_MIN((vec)[3], b); \
368 } (void)0
369
370 #define CLAMP4_MAX(vec, b) { \
371         CLAMP_MAX((vec)[0], b); \
372         CLAMP_MAX((vec)[1], b); \
373         CLAMP_MAX((vec)[2], b); \
374         CLAMP_MAX((vec)[3], b); \
375 } (void)0
376
377 #define IS_EQ(a, b)  ( \
378         CHECK_TYPE_INLINE(a, double), CHECK_TYPE_INLINE(b, double), \
379         ((fabs((double)((a) - (b))) >= (double) FLT_EPSILON) ? false : true))
380
381 #define IS_EQF(a, b)  ( \
382         CHECK_TYPE_INLINE(a, float), CHECK_TYPE_INLINE(b, float), \
383         ((fabsf((float)((a) - (b))) >= (float) FLT_EPSILON) ? false : true))
384
385 #define IS_EQT(a, b, c)        (((a) > (b)) ? ((((a) - (b)) <= (c))) : (((((b) - (a)) <= (c)))))
386 #define IN_RANGE(a, b, c)      (((b) < (c)) ? (((b) <  (a) && (a) <  (c))) : (((c) <  (a) && (a) <  (b))))
387 #define IN_RANGE_INCL(a, b, c) (((b) < (c)) ? (((b) <= (a) && (a) <= (c))) : (((c) <= (a) && (a) <= (b))))
388
389 /* unpack vector for args */
390 #define UNPACK2(a)  ((a)[0]),   ((a)[1])
391 #define UNPACK3(a)  UNPACK2(a), ((a)[2])
392 #define UNPACK4(a)  UNPACK3(a), ((a)[3])
393 /* pre may be '&', '*' or func, post may be '->member' */
394 #define UNPACK2_EX(pre, a, post)  (pre((a)[0])post),        (pre((a)[1])post)
395 #define UNPACK3_EX(pre, a, post)  UNPACK2_EX(pre, a, post), (pre((a)[2])post)
396 #define UNPACK4_EX(pre, a, post)  UNPACK3_EX(pre, a, post), (pre((a)[3])post)
397
398 /* array helpers */
399 #define ARRAY_LAST_ITEM(arr_start, arr_dtype, tot) \
400         (arr_dtype *)((char *)(arr_start) + (sizeof(*((arr_dtype *)NULL)) * (size_t)(tot - 1)))
401
402 #define ARRAY_HAS_ITEM(arr_item, arr_start, tot)  ( \
403         CHECK_TYPE_PAIR_INLINE(arr_start, arr_item), \
404         ((unsigned int)((arr_item) - (arr_start)) < (unsigned int)(tot)))
405
406 #define ARRAY_DELETE(arr, index, tot_delete, tot)  { \
407                 BLI_assert(index + tot_delete <= tot);  \
408                 memmove(&(arr)[(index)], \
409                         &(arr)[(index) + (tot_delete)], \
410                          (((tot) - (index)) - (tot_delete)) * sizeof(*(arr))); \
411         } (void)0
412
413 /* assuming a static array */
414 #if defined(__GNUC__) && !defined(__cplusplus) && !defined(__clang__) && !defined(__INTEL_COMPILER)
415 #  define ARRAY_SIZE(arr) \
416         ((sizeof(struct {int isnt_array : ((const void *)&(arr) == &(arr)[0]);}) * 0) + \
417          (sizeof(arr) / sizeof(*(arr))))
418 #else
419 #  define ARRAY_SIZE(arr)  (sizeof(arr) / sizeof(*(arr)))
420 #endif
421
422 /* ARRAY_SET_ITEMS#(v, ...): set indices of array 'v'  */
423 /* internal helpers */
424 #define _VA_ARRAY_SET_ITEMS2(v, a) \
425         ((v)[0] = (a))
426 #define _VA_ARRAY_SET_ITEMS3(v, a, b) \
427         _VA_ARRAY_SET_ITEMS2(v, a); ((v)[1] = (b))
428 #define _VA_ARRAY_SET_ITEMS4(v, a, b, c) \
429         _VA_ARRAY_SET_ITEMS3(v, a, b); ((v)[2] = (c))
430 #define _VA_ARRAY_SET_ITEMS5(v, a, b, c, d) \
431         _VA_ARRAY_SET_ITEMS4(v, a, b, c); ((v)[3] = (d))
432 #define _VA_ARRAY_SET_ITEMS6(v, a, b, c, d, e) \
433         _VA_ARRAY_SET_ITEMS5(v, a, b, c, d); ((v)[4] = (e))
434 #define _VA_ARRAY_SET_ITEMS7(v, a, b, c, d, e, f) \
435         _VA_ARRAY_SET_ITEMS6(v, a, b, c, d, e); ((v)[5] = (f))
436 #define _VA_ARRAY_SET_ITEMS8(v, a, b, c, d, e, f, g) \
437         _VA_ARRAY_SET_ITEMS7(v, a, b, c, d, e, f); ((v)[6] = (g))
438 #define _VA_ARRAY_SET_ITEMS9(v, a, b, c, d, e, f, g, h) \
439         _VA_ARRAY_SET_ITEMS8(v, a, b, c, d, e, f, g); ((v)[7] = (h))
440 #define _VA_ARRAY_SET_ITEMS10(v, a, b, c, d, e, f, g, h, i) \
441         _VA_ARRAY_SET_ITEMS9(v, a, b, c, d, e, f, g, h); ((v)[8] = (i))
442 #define _VA_ARRAY_SET_ITEMS11(v, a, b, c, d, e, f, g, h, i, j) \
443         _VA_ARRAY_SET_ITEMS10(v, a, b, c, d, e, f, g, h, i); ((v)[9] = (j))
444 #define _VA_ARRAY_SET_ITEMS12(v, a, b, c, d, e, f, g, h, i, j, k) \
445         _VA_ARRAY_SET_ITEMS11(v, a, b, c, d, e, f, g, h, i, j); ((v)[10] = (k))
446 #define _VA_ARRAY_SET_ITEMS13(v, a, b, c, d, e, f, g, h, i, j, k, l) \
447         _VA_ARRAY_SET_ITEMS12(v, a, b, c, d, e, f, g, h, i, j, k); ((v)[11] = (l))
448 #define _VA_ARRAY_SET_ITEMS14(v, a, b, c, d, e, f, g, h, i, j, k, l, m) \
449         _VA_ARRAY_SET_ITEMS13(v, a, b, c, d, e, f, g, h, i, j, k, l); ((v)[12] = (m))
450 #define _VA_ARRAY_SET_ITEMS15(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n) \
451         _VA_ARRAY_SET_ITEMS14(v, a, b, c, d, e, f, g, h, i, j, k, l, m); ((v)[13] = (n))
452 #define _VA_ARRAY_SET_ITEMS16(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) \
453         _VA_ARRAY_SET_ITEMS15(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n); ((v)[14] = (o))
454 #define _VA_ARRAY_SET_ITEMS17(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) \
455         _VA_ARRAY_SET_ITEMS16(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o); ((v)[15] = (p))
456
457 /* reusable ARRAY_SET_ITEMS macro */
458 #define ARRAY_SET_ITEMS(...) { VA_NARGS_CALL_OVERLOAD(_VA_ARRAY_SET_ITEMS, __VA_ARGS__); } (void)0
459
460 #if defined(__GNUC__) || defined(__clang__)
461 #define POINTER_OFFSET(v, ofs) \
462         ((typeof(v))((char *)(v) + (ofs)))
463 #else
464 #define POINTER_OFFSET(v, ofs) \
465         ((void *)((char *)(v) + (ofs)))
466 #endif
467
468 /* Like offsetof(typeof(), member), for non-gcc compilers */
469 #define OFFSETOF_STRUCT(_struct, _member) \
470         ((((char *)&((_struct)->_member)) - ((char *)(_struct))) + sizeof((_struct)->_member))
471
472 /**
473  * memcpy helper, skipping the first part of a struct,
474  * ensures 'struct_dst' isn't const and the offset can be computed at compile time.
475  * This isn't inclusive, the value of \a member isn't copied.
476  */
477 #define MEMCPY_STRUCT_OFS(struct_dst, struct_src, member)  { \
478         CHECK_TYPE_NONCONST(struct_dst); \
479         ((void)(struct_dst == struct_src), \
480          memcpy((char *)(struct_dst)  + OFFSETOF_STRUCT(struct_dst, member), \
481                 (char *)(struct_src)  + OFFSETOF_STRUCT(struct_dst, member), \
482                 sizeof(*(struct_dst)) - OFFSETOF_STRUCT(struct_dst, member))); \
483 } (void)0
484
485 #define MEMSET_STRUCT_OFS(struct_var, value, member)  { \
486         CHECK_TYPE_NONCONST(struct_var); \
487         memset((char *)(struct_var)  + OFFSETOF_STRUCT(struct_var, member), \
488                value, \
489                sizeof(*(struct_var)) - OFFSETOF_STRUCT(struct_var, member)); \
490 } (void)0
491
492 /* defined
493  * in memory_utils.c for now. I do not know where we should put it actually... */
494 #ifndef __BLI_MEMORY_UTILS_H__
495 extern bool BLI_memory_is_zero(const void *arr, const size_t arr_size);
496 #endif
497
498 #define MEMCMP_STRUCT_OFS_IS_ZERO(struct_var, member) \
499         (BLI_memory_is_zero( \
500                (char *)(struct_var)  + OFFSETOF_STRUCT(struct_var, member), \
501                sizeof(*(struct_var)) - OFFSETOF_STRUCT(struct_var, member)))
502
503 /* Warning-free macros for storing ints in pointers. Use these _only_
504  * for storing an int in a pointer, not a pointer in an int (64bit)! */
505 #define SET_INT_IN_POINTER(i)    ((void *)(intptr_t)(i))
506 #define GET_INT_FROM_POINTER(i)  ((void)0, ((int)(intptr_t)(i)))
507
508 #define SET_UINT_IN_POINTER(i)    ((void *)(uintptr_t)(i))
509 #define GET_UINT_FROM_POINTER(i)  ((void)0, ((unsigned int)(uintptr_t)(i)))
510
511 /* Set flag from a single test */
512 #define SET_FLAG_FROM_TEST(value, test, flag) \
513 { \
514         if (test) { \
515                 (value) |=  (flag); \
516         } \
517         else { \
518                 (value) &= ~(flag); \
519         } \
520 } ((void)0)
521
522 /* Macro to convert a value to string in the preprocessor
523  * STRINGIFY_ARG: gives the argument as a string
524  * STRINGIFY_APPEND: appends any argument 'b' onto the string argument 'a',
525  *   used by STRINGIFY because some preprocessors warn about zero arguments
526  * STRINGIFY: gives the argument's value as a string */
527 #define STRINGIFY_ARG(x) "" #x
528 #define STRINGIFY_APPEND(a, b) "" a #b
529 #define STRINGIFY(x) STRINGIFY_APPEND("", x)
530
531
532 /* generic strcmp macros */
533 #if defined(_MSC_VER)
534 #  define strcasecmp _stricmp
535 #  define strncasecmp _strnicmp
536 #endif
537
538 #define STREQ(a, b) (strcmp(a, b) == 0)
539 #define STRCASEEQ(a, b) (strcasecmp(a, b) == 0)
540 #define STREQLEN(a, b, n) (strncmp(a, b, n) == 0)
541 #define STRCASEEQLEN(a, b, n) (strncasecmp(a, b, n) == 0)
542
543 #define STRPREFIX(a, b) (strncmp((a), (b), strlen(b)) == 0)
544 /* useful for debugging */
545 #define AT __FILE__ ":" STRINGIFY(__LINE__)
546
547
548 /* UNUSED macro, for function argument */
549 #ifdef __GNUC__
550 #  define UNUSED(x) UNUSED_ ## x __attribute__((__unused__))
551 #else
552 #  define UNUSED(x) UNUSED_ ## x
553 #endif
554
555 #ifdef __GNUC__
556 #  define UNUSED_FUNCTION(x) __attribute__((__unused__)) UNUSED_ ## x
557 #else
558 #  define UNUSED_FUNCTION(x) UNUSED_ ## x
559 #endif
560
561 /**
562  * UNUSED_VARS#(a, ...): quiet unused warnings
563  *
564  * \code{.py}
565  * for i in range(16):
566  *     args = [(chr(ord('a') + (c % 26)) + (chr(ord('0') + (c // 26)))) for c in range(i + 1)]
567  *     print("#define _VA_UNUSED_VARS_%d(%s) \\" % (i + 1, ", ".join(args)))
568  *     print("\t((void)(%s)%s)" %
569  *             (args[0], ((", _VA_UNUSED_VARS_" + str(i) + "(%s)") if i else "%s") % ", ".join((args[1:]))))
570  * \endcode
571  */
572
573 #define _VA_UNUSED_VARS_1(a0) \
574         ((void)(a0))
575 #define _VA_UNUSED_VARS_2(a0, b0) \
576         ((void)(a0), _VA_UNUSED_VARS_1(b0))
577 #define _VA_UNUSED_VARS_3(a0, b0, c0) \
578         ((void)(a0), _VA_UNUSED_VARS_2(b0, c0))
579 #define _VA_UNUSED_VARS_4(a0, b0, c0, d0) \
580         ((void)(a0), _VA_UNUSED_VARS_3(b0, c0, d0))
581 #define _VA_UNUSED_VARS_5(a0, b0, c0, d0, e0) \
582         ((void)(a0), _VA_UNUSED_VARS_4(b0, c0, d0, e0))
583 #define _VA_UNUSED_VARS_6(a0, b0, c0, d0, e0, f0) \
584         ((void)(a0), _VA_UNUSED_VARS_5(b0, c0, d0, e0, f0))
585 #define _VA_UNUSED_VARS_7(a0, b0, c0, d0, e0, f0, g0) \
586         ((void)(a0), _VA_UNUSED_VARS_6(b0, c0, d0, e0, f0, g0))
587 #define _VA_UNUSED_VARS_8(a0, b0, c0, d0, e0, f0, g0, h0) \
588         ((void)(a0), _VA_UNUSED_VARS_7(b0, c0, d0, e0, f0, g0, h0))
589 #define _VA_UNUSED_VARS_9(a0, b0, c0, d0, e0, f0, g0, h0, i0) \
590         ((void)(a0), _VA_UNUSED_VARS_8(b0, c0, d0, e0, f0, g0, h0, i0))
591 #define _VA_UNUSED_VARS_10(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0) \
592         ((void)(a0), _VA_UNUSED_VARS_9(b0, c0, d0, e0, f0, g0, h0, i0, j0))
593 #define _VA_UNUSED_VARS_11(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0) \
594         ((void)(a0), _VA_UNUSED_VARS_10(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0))
595 #define _VA_UNUSED_VARS_12(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0) \
596         ((void)(a0), _VA_UNUSED_VARS_11(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0))
597 #define _VA_UNUSED_VARS_13(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0) \
598         ((void)(a0), _VA_UNUSED_VARS_12(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0))
599 #define _VA_UNUSED_VARS_14(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0) \
600         ((void)(a0), _VA_UNUSED_VARS_13(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0))
601 #define _VA_UNUSED_VARS_15(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0, o0) \
602         ((void)(a0), _VA_UNUSED_VARS_14(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0, o0))
603 #define _VA_UNUSED_VARS_16(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0, o0, p0) \
604         ((void)(a0), _VA_UNUSED_VARS_15(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0, o0, p0))
605
606
607 /* reusable ELEM macro */
608 #define UNUSED_VARS(...) VA_NARGS_CALL_OVERLOAD(_VA_UNUSED_VARS_, __VA_ARGS__)
609
610 /* for debug-only variables */
611 #ifndef NDEBUG
612 #  define UNUSED_VARS_NDEBUG(...)
613 #else
614 #  define UNUSED_VARS_NDEBUG UNUSED_VARS
615 #endif
616
617 /* hints for branch prediction, only use in code that runs a _lot_ where */
618 #ifdef __GNUC__
619 #  define LIKELY(x)       __builtin_expect(!!(x), 1)
620 #  define UNLIKELY(x)     __builtin_expect(!!(x), 0)
621 #else
622 #  define LIKELY(x)       (x)
623 #  define UNLIKELY(x)     (x)
624 #endif
625
626 #ifdef __cplusplus
627 }
628 #endif
629
630 #endif  /* __BLI_UTILDEFINES_H__ */