Merge branch 'blender2.7'
[blender.git] / source / blender / blenlib / BLI_utildefines.h
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 #ifndef __BLI_UTILDEFINES_H__
21 #define __BLI_UTILDEFINES_H__
22
23 /** \file
24  * \ingroup bli
25  */
26
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30
31 /* avoid many includes for now */
32 #include "BLI_sys_types.h"
33 #include "BLI_compiler_compat.h"
34 #include "BLI_utildefines_variadic.h"
35
36 /* We could remove in future. */
37 #include "BLI_assert.h"
38
39 /* include after _VA_NARGS macro */
40 #include "BLI_compiler_typecheck.h"
41
42 /* -------------------------------------------------------------------- */
43 /** \name Min/Max Macros
44  * \{ */
45
46 /* useful for finding bad use of min/max */
47 #if 0
48 /* gcc only */
49 #  define _TYPECHECK(a, b)  ((void)(((typeof(a) *)0) == ((typeof(b) *)0)))
50 #  define MIN2(x, y)          (_TYPECHECK(x, y), (((x) < (y) ? (x) : (y))))
51 #  define MAX2(x, y)          (_TYPECHECK(x, y), (((x) > (y) ? (x) : (y))))
52 #endif
53
54 /* min/max */
55 #if defined(__GNUC__) || defined(__clang__)
56
57 #define MIN2(a, b) __extension__ ({  \
58         typeof(a) a_ = (a); typeof(b) b_ = (b); \
59         ((a_) < (b_) ? (a_) : (b_)); })
60
61 #define MAX2(a, b) __extension__ ({  \
62         typeof(a) a_ = (a); typeof(b) b_ = (b); \
63         ((a_) > (b_) ? (a_) : (b_)); })
64
65 #define MIN3(a, b, c) __extension__ ({  \
66         typeof(a) a_ = (a); typeof(b) b_ = (b); typeof(c) c_ = (c); \
67         ((a_ < b_) ? ((a_ < c_) ? a_ : c_) : ((b_ < c_) ? b_ : c_)); })
68
69 #define MAX3(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 MIN4(a, b, c, d) __extension__ ({  \
74         typeof(a) a_ = (a); typeof(b) b_ = (b); typeof(c) c_ = (c); typeof(d) d_ = (d); \
75         ((a_ < b_) ? ((a_ < c_) ? ((a_ < d_) ? a_ : d_) : ((c_ < d_) ? c_ : d_)) : \
76                      ((b_ < c_) ? ((b_ < d_) ? b_ : d_) : ((c_ < d_) ? c_ : d_))); })
77
78 #define MAX4(a, b, c, d) __extension__ ({  \
79         typeof(a) a_ = (a); typeof(b) b_ = (b); typeof(c) c_ = (c); typeof(d) d_ = (d); \
80         ((a_ > b_) ? ((a_ > c_) ? ((a_ > d_) ? a_ : d_) : ((c_ > d_) ? c_ : d_)) : \
81                      ((b_ > c_) ? ((b_ > d_) ? b_ : d_) : ((c_ > d_) ? c_ : d_))); })
82
83 #else
84 #define MIN2(a, b)  ((a) < (b) ? (a) : (b))
85 #define MAX2(a, b)  ((a) > (b) ? (a) : (b))
86
87 #define MIN3(a, b, c)       (MIN2(MIN2((a), (b)), (c)))
88 #define MIN4(a, b, c, d)    (MIN2(MIN2((a), (b)), MIN2((c), (d))))
89
90 #define MAX3(a, b, c)       (MAX2(MAX2((a), (b)), (c)))
91 #define MAX4(a, b, c, d)    (MAX2(MAX2((a), (b)), MAX2((c), (d))))
92 #endif
93
94 /* min/max that return a value of our choice */
95 #define MAX3_PAIR(cmp_a, cmp_b, cmp_c, ret_a, ret_b, ret_c) \
96         ((cmp_a > cmp_b) ? ((cmp_a > cmp_c) ? ret_a : ret_c) : \
97                            ((cmp_b > cmp_c) ? ret_b : ret_c))
98
99 #define MIN3_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 INIT_MINMAX(min, max) {                                               \
104                 (min)[0] = (min)[1] = (min)[2] =  1.0e30f;                            \
105                 (max)[0] = (max)[1] = (max)[2] = -1.0e30f;                            \
106         } (void)0
107 #define INIT_MINMAX2(min, max) {                                              \
108                 (min)[0] = (min)[1] = 1.0e30f;                                        \
109                 (max)[0] = (max)[1] = -1.0e30f;                                       \
110         } (void)0
111 #define DO_MIN(vec, min) {                                                    \
112                 if ((min)[0] > (vec)[0]) (min)[0] = (vec)[0];                         \
113                 if ((min)[1] > (vec)[1]) (min)[1] = (vec)[1];                         \
114                 if ((min)[2] > (vec)[2]) (min)[2] = (vec)[2];                         \
115         } (void)0
116 #define DO_MAX(vec, max) {                                                    \
117                 if ((max)[0] < (vec)[0]) (max)[0] = (vec)[0];                         \
118                 if ((max)[1] < (vec)[1]) (max)[1] = (vec)[1];                         \
119                 if ((max)[2] < (vec)[2]) (max)[2] = (vec)[2];                         \
120         } (void)0
121 #define DO_MINMAX(vec, min, max) {                                            \
122                 if ((min)[0] > (vec)[0] ) (min)[0] = (vec)[0];                        \
123                 if ((min)[1] > (vec)[1] ) (min)[1] = (vec)[1];                        \
124                 if ((min)[2] > (vec)[2] ) (min)[2] = (vec)[2];                        \
125                 if ((max)[0] < (vec)[0] ) (max)[0] = (vec)[0];                        \
126                 if ((max)[1] < (vec)[1] ) (max)[1] = (vec)[1];                        \
127                 if ((max)[2] < (vec)[2] ) (max)[2] = (vec)[2];                        \
128         } (void)0
129 #define DO_MINMAX2(vec, min, max) {                                           \
130                 if ((min)[0] > (vec)[0] ) (min)[0] = (vec)[0];                        \
131                 if ((min)[1] > (vec)[1] ) (min)[1] = (vec)[1];                        \
132                 if ((max)[0] < (vec)[0] ) (max)[0] = (vec)[0];                        \
133                 if ((max)[1] < (vec)[1] ) (max)[1] = (vec)[1];                        \
134         } (void)0
135
136 /** \} */
137
138 /* -------------------------------------------------------------------- */
139 /** \name Swap/Shift Macros
140  * \{ */
141
142 #define SWAP(type, a, b)  {    \
143         type sw_ap;                \
144         CHECK_TYPE(a, type);       \
145         CHECK_TYPE(b, type);       \
146         sw_ap = (a);               \
147         (a) = (b);                 \
148         (b) = sw_ap;               \
149 } (void)0
150
151 /* swap with a temp value */
152 #define SWAP_TVAL(tval, a, b)  {  \
153         CHECK_TYPE_PAIR(tval, a);     \
154         CHECK_TYPE_PAIR(tval, b);     \
155         (tval) = (a);                 \
156         (a) = (b);                    \
157         (b) = (tval);                 \
158 } (void)0
159
160 /* shift around elements */
161 #define SHIFT3(type, a, b, c)  {                                              \
162         type tmp;                                                                 \
163         CHECK_TYPE(a, type);                                                      \
164         CHECK_TYPE(b, type);                                                      \
165         CHECK_TYPE(c, type);                                                      \
166         tmp = a;                                                                  \
167         a = c;                                                                    \
168         c = b;                                                                    \
169         b = tmp;                                                                  \
170 } (void)0
171
172 #define SHIFT4(type, a, b, c, d)  {                                           \
173         type tmp;                                                                 \
174         CHECK_TYPE(a, type);                                                      \
175         CHECK_TYPE(b, type);                                                      \
176         CHECK_TYPE(c, type);                                                      \
177         CHECK_TYPE(d, type);                                                      \
178         tmp = a;                                                                  \
179         a = d;                                                                    \
180         d = c;                                                                    \
181         c = b;                                                                    \
182         b = tmp;                                                                  \
183 } (void)0
184
185 /** \} */
186
187 /* -------------------------------------------------------------------- */
188 /** \name Equal to Any Element (ELEM) Macro
189  * \{ */
190
191 /* ELEM#(v, ...): is the first arg equal any others? */
192 /* internal helpers*/
193 #define _VA_ELEM2(v, a) \
194        ((v) == (a))
195 #define _VA_ELEM3(v, a, b) \
196        (_VA_ELEM2(v, a) || ((v) == (b)))
197 #define _VA_ELEM4(v, a, b, c) \
198        (_VA_ELEM3(v, a, b) || ((v) == (c)))
199 #define _VA_ELEM5(v, a, b, c, d) \
200        (_VA_ELEM4(v, a, b, c) || ((v) == (d)))
201 #define _VA_ELEM6(v, a, b, c, d, e) \
202        (_VA_ELEM5(v, a, b, c, d) || ((v) == (e)))
203 #define _VA_ELEM7(v, a, b, c, d, e, f) \
204        (_VA_ELEM6(v, a, b, c, d, e) || ((v) == (f)))
205 #define _VA_ELEM8(v, a, b, c, d, e, f, g) \
206        (_VA_ELEM7(v, a, b, c, d, e, f) || ((v) == (g)))
207 #define _VA_ELEM9(v, a, b, c, d, e, f, g, h) \
208        (_VA_ELEM8(v, a, b, c, d, e, f, g) || ((v) == (h)))
209 #define _VA_ELEM10(v, a, b, c, d, e, f, g, h, i) \
210        (_VA_ELEM9(v, a, b, c, d, e, f, g, h) || ((v) == (i)))
211 #define _VA_ELEM11(v, a, b, c, d, e, f, g, h, i, j) \
212        (_VA_ELEM10(v, a, b, c, d, e, f, g, h, i) || ((v) == (j)))
213 #define _VA_ELEM12(v, a, b, c, d, e, f, g, h, i, j, k) \
214        (_VA_ELEM11(v, a, b, c, d, e, f, g, h, i, j) || ((v) == (k)))
215 #define _VA_ELEM13(v, a, b, c, d, e, f, g, h, i, j, k, l) \
216        (_VA_ELEM12(v, a, b, c, d, e, f, g, h, i, j, k) || ((v) == (l)))
217 #define _VA_ELEM14(v, a, b, c, d, e, f, g, h, i, j, k, l, m) \
218        (_VA_ELEM13(v, a, b, c, d, e, f, g, h, i, j, k, l) || ((v) == (m)))
219 #define _VA_ELEM15(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n) \
220        (_VA_ELEM14(v, a, b, c, d, e, f, g, h, i, j, k, l, m) || ((v) == (n)))
221 #define _VA_ELEM16(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) \
222        (_VA_ELEM15(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n) || ((v) == (o)))
223 #define _VA_ELEM17(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) \
224        (_VA_ELEM16(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) || ((v) == (p)))
225
226 /* reusable ELEM macro */
227 #define ELEM(...) VA_NARGS_CALL_OVERLOAD(_VA_ELEM, __VA_ARGS__)
228
229 /** \} */
230
231 /* -------------------------------------------------------------------- */
232 /** \name Simple Math Macros
233  * \{ */
234
235 /* avoid multiple access for supported compilers */
236 #if defined(__GNUC__) || defined(__clang__)
237
238 #define ABS(a)  ({ \
239         typeof(a) a_ = (a); \
240         ((a_) < 0 ? (-(a_)) : (a_)); })
241 #define SQUARE(a)  ({ \
242         typeof(a) a_ = (a); \
243         ((a_) * (a_)); })
244 #define CUBE(a)  ({ \
245         typeof(a) a_ = (a); \
246         ((a_) * (a_) * (a_)); })
247
248 #else
249
250 #define ABS(a)  ((a) < 0 ? (-(a)) : (a))
251 #define SQUARE(a)  ((a) * (a))
252 #define CUBE(a)  ((a) * (a) * (a))
253
254 #endif
255
256 /* Float equality checks. */
257
258 #define IS_EQ(a, b)  ( \
259         CHECK_TYPE_INLINE(a, double), CHECK_TYPE_INLINE(b, double), \
260         ((fabs((double)((a) - (b))) >= (double) FLT_EPSILON) ? false : true))
261
262 #define IS_EQF(a, b)  ( \
263         CHECK_TYPE_INLINE(a, float), CHECK_TYPE_INLINE(b, float), \
264         ((fabsf((float)((a) - (b))) >= (float) FLT_EPSILON) ? false : true))
265
266 #define IS_EQT(a, b, c)        (((a) > (b)) ? ((((a) - (b)) <= (c))) : (((((b) - (a)) <= (c)))))
267 #define IN_RANGE(a, b, c)      (((b) < (c)) ? (((b) <  (a) && (a) <  (c))) : (((c) <  (a) && (a) <  (b))))
268 #define IN_RANGE_INCL(a, b, c) (((b) < (c)) ? (((b) <= (a) && (a) <= (c))) : (((c) <= (a) && (a) <= (b))))
269
270 /**
271  * Expands to an integer constant expression evaluating to a close upper bound
272  * on the number the number of decimal digits in a value expressible in the
273  * integer type given by the argument (if it is a type name) or the integer
274  * type of the argument (if it is an expression). The meaning of the resulting
275  * expression is unspecified for other arguments.
276  * i.e: `DECIMAL_DIGITS_BOUND(uchar)` is equal to 3.
277  */
278 #define DECIMAL_DIGITS_BOUND(t) (241 * sizeof(t) / 100 + 1)
279
280 /** \} */
281
282 /* -------------------------------------------------------------------- */
283 /** \name Clamp Macros
284  * \{ */
285
286 #define CLAMPIS(a, b, c)  ((a) < (b) ? (b) : (a) > (c) ? (c) : (a))
287
288 #define CLAMP(a, b, c)  {           \
289         if      ((a) < (b)) (a) = (b);  \
290         else if ((a) > (c)) (a) = (c);  \
291 } (void)0
292
293 #define CLAMP_MAX(a, c)  {          \
294         if ((a) > (c)) (a) = (c);       \
295 } (void)0
296
297 #define CLAMP_MIN(a, b)  {          \
298         if      ((a) < (b)) (a) = (b);  \
299 } (void)0
300
301 #define CLAMP2(vec, b, c) { \
302         CLAMP((vec)[0], b, c); \
303         CLAMP((vec)[1], b, c); \
304 } (void)0
305
306 #define CLAMP2_MIN(vec, b) { \
307         CLAMP_MIN((vec)[0], b); \
308         CLAMP_MIN((vec)[1], b); \
309 } (void)0
310
311 #define CLAMP2_MAX(vec, b) { \
312         CLAMP_MAX((vec)[0], b); \
313         CLAMP_MAX((vec)[1], b); \
314 } (void)0
315
316 #define CLAMP3(vec, b, c) { \
317         CLAMP((vec)[0], b, c); \
318         CLAMP((vec)[1], b, c); \
319         CLAMP((vec)[2], b, c); \
320 } (void)0
321
322 #define CLAMP3_MIN(vec, b) { \
323         CLAMP_MIN((vec)[0], b); \
324         CLAMP_MIN((vec)[1], b); \
325         CLAMP_MIN((vec)[2], b); \
326 } (void)0
327
328 #define CLAMP3_MAX(vec, b) { \
329         CLAMP_MAX((vec)[0], b); \
330         CLAMP_MAX((vec)[1], b); \
331         CLAMP_MAX((vec)[2], b); \
332 } (void)0
333
334 #define CLAMP4(vec, b, c) { \
335         CLAMP((vec)[0], b, c); \
336         CLAMP((vec)[1], b, c); \
337         CLAMP((vec)[2], b, c); \
338         CLAMP((vec)[3], b, c); \
339 } (void)0
340
341 #define CLAMP4_MIN(vec, b) { \
342         CLAMP_MIN((vec)[0], b); \
343         CLAMP_MIN((vec)[1], b); \
344         CLAMP_MIN((vec)[2], b); \
345         CLAMP_MIN((vec)[3], b); \
346 } (void)0
347
348 #define CLAMP4_MAX(vec, b) { \
349         CLAMP_MAX((vec)[0], b); \
350         CLAMP_MAX((vec)[1], b); \
351         CLAMP_MAX((vec)[2], b); \
352         CLAMP_MAX((vec)[3], b); \
353 } (void)0
354
355 /** \} */
356
357 /* -------------------------------------------------------------------- */
358 /** \name Array Unpacking Macros
359  * \{ */
360
361 /* unpack vector for args */
362 #define UNPACK2(a)  ((a)[0]),   ((a)[1])
363 #define UNPACK3(a)  UNPACK2(a), ((a)[2])
364 #define UNPACK4(a)  UNPACK3(a), ((a)[3])
365 /* pre may be '&', '*' or func, post may be '->member' */
366 #define UNPACK2_EX(pre, a, post)  (pre((a)[0])post),        (pre((a)[1])post)
367 #define UNPACK3_EX(pre, a, post)  UNPACK2_EX(pre, a, post), (pre((a)[2])post)
368 #define UNPACK4_EX(pre, a, post)  UNPACK3_EX(pre, a, post), (pre((a)[3])post)
369
370 /** \} */
371
372 /* -------------------------------------------------------------------- */
373 /** \name Array Macros
374  * \{ */
375
376 /* array helpers */
377 #define ARRAY_LAST_ITEM(arr_start, arr_dtype, arr_len) \
378         (arr_dtype *)((char *)(arr_start) + (sizeof(*((arr_dtype *)NULL)) * (size_t)(arr_len - 1)))
379
380 #define ARRAY_HAS_ITEM(arr_item, arr_start, arr_len)  ( \
381         CHECK_TYPE_PAIR_INLINE(arr_start, arr_item), \
382         ((unsigned int)((arr_item) - (arr_start)) < (unsigned int)(arr_len)))
383
384 /**
385  * \note use faster #ARRAY_DELETE_REORDER_LAST when we can re-order.
386  */
387 #define ARRAY_DELETE(arr, index, delete_len, arr_len) \
388         { \
389                 BLI_assert((&arr[index] >= arr) && ((index) + delete_len <= arr_len));  \
390                 memmove(&(arr)[index], \
391                         &(arr)[(index) + (delete_len)], \
392                          (((arr_len) - (index)) - (delete_len)) * sizeof(*(arr))); \
393         } ((void)0)
394
395 /**
396  * Re-ordering array removal.
397  *
398  * When removing single items this compiles down to:
399  * `if (index + 1 != arr_len) { arr[index] = arr[arr_len - 1]; }` (typical reordering removal),
400  * with removing multiple items, overlap is detected to avoid memcpy errors.
401  */
402 #define ARRAY_DELETE_REORDER_LAST(arr, index, delete_len, arr_len) \
403         { \
404                 BLI_assert((&arr[index] >= arr) && ((index) + delete_len <= arr_len));  \
405                 if ((index) + (delete_len) != (arr_len)) { \
406                         if (((delete_len) == 1) || ((delete_len) <= ((arr_len) - ((index) + (delete_len))))) { \
407                                 memcpy(&(arr)[index], \
408                                        &(arr)[(arr_len) - (delete_len)], \
409                                        (delete_len) * sizeof(*(arr))); \
410                         } \
411                         else { \
412                                 memcpy(&(arr)[index], \
413                                        &(arr)[(arr_len) - ((arr_len) - ((index) + (delete_len)))], \
414                                        ((arr_len) - ((index) + (delete_len))) * sizeof(*(arr))); \
415                         } \
416                 } \
417         } ((void)0)
418
419
420 /* assuming a static array */
421 #if defined(__GNUC__) && !defined(__cplusplus) && !defined(__clang__) && !defined(__INTEL_COMPILER)
422 #  define ARRAY_SIZE(arr) \
423         ((sizeof(struct {int isnt_array : ((const void *)&(arr) == &(arr)[0]);}) * 0) + \
424          (sizeof(arr) / sizeof(*(arr))))
425 #else
426 #  define ARRAY_SIZE(arr)  (sizeof(arr) / sizeof(*(arr)))
427 #endif
428
429 /* ARRAY_SET_ITEMS#(v, ...): set indices of array 'v'  */
430 /* internal helpers */
431 #define _VA_ARRAY_SET_ITEMS2(v, a) \
432         ((v)[0] = (a))
433 #define _VA_ARRAY_SET_ITEMS3(v, a, b) \
434         _VA_ARRAY_SET_ITEMS2(v, a); ((v)[1] = (b))
435 #define _VA_ARRAY_SET_ITEMS4(v, a, b, c) \
436         _VA_ARRAY_SET_ITEMS3(v, a, b); ((v)[2] = (c))
437 #define _VA_ARRAY_SET_ITEMS5(v, a, b, c, d) \
438         _VA_ARRAY_SET_ITEMS4(v, a, b, c); ((v)[3] = (d))
439 #define _VA_ARRAY_SET_ITEMS6(v, a, b, c, d, e) \
440         _VA_ARRAY_SET_ITEMS5(v, a, b, c, d); ((v)[4] = (e))
441 #define _VA_ARRAY_SET_ITEMS7(v, a, b, c, d, e, f) \
442         _VA_ARRAY_SET_ITEMS6(v, a, b, c, d, e); ((v)[5] = (f))
443 #define _VA_ARRAY_SET_ITEMS8(v, a, b, c, d, e, f, g) \
444         _VA_ARRAY_SET_ITEMS7(v, a, b, c, d, e, f); ((v)[6] = (g))
445 #define _VA_ARRAY_SET_ITEMS9(v, a, b, c, d, e, f, g, h) \
446         _VA_ARRAY_SET_ITEMS8(v, a, b, c, d, e, f, g); ((v)[7] = (h))
447 #define _VA_ARRAY_SET_ITEMS10(v, a, b, c, d, e, f, g, h, i) \
448         _VA_ARRAY_SET_ITEMS9(v, a, b, c, d, e, f, g, h); ((v)[8] = (i))
449 #define _VA_ARRAY_SET_ITEMS11(v, a, b, c, d, e, f, g, h, i, j) \
450         _VA_ARRAY_SET_ITEMS10(v, a, b, c, d, e, f, g, h, i); ((v)[9] = (j))
451 #define _VA_ARRAY_SET_ITEMS12(v, a, b, c, d, e, f, g, h, i, j, k) \
452         _VA_ARRAY_SET_ITEMS11(v, a, b, c, d, e, f, g, h, i, j); ((v)[10] = (k))
453 #define _VA_ARRAY_SET_ITEMS13(v, a, b, c, d, e, f, g, h, i, j, k, l) \
454         _VA_ARRAY_SET_ITEMS12(v, a, b, c, d, e, f, g, h, i, j, k); ((v)[11] = (l))
455 #define _VA_ARRAY_SET_ITEMS14(v, a, b, c, d, e, f, g, h, i, j, k, l, m) \
456         _VA_ARRAY_SET_ITEMS13(v, a, b, c, d, e, f, g, h, i, j, k, l); ((v)[12] = (m))
457 #define _VA_ARRAY_SET_ITEMS15(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n) \
458         _VA_ARRAY_SET_ITEMS14(v, a, b, c, d, e, f, g, h, i, j, k, l, m); ((v)[13] = (n))
459 #define _VA_ARRAY_SET_ITEMS16(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) \
460         _VA_ARRAY_SET_ITEMS15(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n); ((v)[14] = (o))
461 #define _VA_ARRAY_SET_ITEMS17(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) \
462         _VA_ARRAY_SET_ITEMS16(v, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o); ((v)[15] = (p))
463
464 /* reusable ARRAY_SET_ITEMS macro */
465 #define ARRAY_SET_ITEMS(...) { VA_NARGS_CALL_OVERLOAD(_VA_ARRAY_SET_ITEMS, __VA_ARGS__); } (void)0
466
467 /** \} */
468
469 /* -------------------------------------------------------------------- */
470 /** \name Pointer Macros
471  * \{ */
472
473 #if defined(__GNUC__) || defined(__clang__)
474 #define POINTER_OFFSET(v, ofs) \
475         ((typeof(v))((char *)(v) + (ofs)))
476 #else
477 #define POINTER_OFFSET(v, ofs) \
478         ((void *)((char *)(v) + (ofs)))
479 #endif
480
481 /* Warning-free macros for storing ints in pointers. Use these _only_
482  * for storing an int in a pointer, not a pointer in an int (64bit)! */
483 #define POINTER_FROM_INT(i)    ((void *)(intptr_t)(i))
484 #define POINTER_AS_INT(i)  ((void)0, ((int)(intptr_t)(i)))
485
486 #define POINTER_FROM_UINT(i)    ((void *)(uintptr_t)(i))
487 #define POINTER_AS_UINT(i)  ((void)0, ((unsigned int)(uintptr_t)(i)))
488
489 /** \} */
490
491 /* -------------------------------------------------------------------- */
492 /** \name Struct After Macros
493  *
494  * Typically used to copy/clear polymorphic structs which have a generic
495  * member at the start which needs to be left as-is.
496  *
497  * \{ */
498
499 /** Performs `offsetof(typeof(data), member) + sizeof((data)->member)` for non-gcc compilers. */
500 #define OFFSETOF_STRUCT_AFTER(_struct, _member) \
501         ((((const char *)&((_struct)->_member)) - ((const char *)(_struct))) + sizeof((_struct)->_member))
502
503 /**
504  * memcpy helper, skipping the first part of a struct,
505  * ensures 'struct_dst' isn't const and the offset can be computed at compile time.
506  * This isn't inclusive, the value of \a member isn't copied.
507  */
508 #define MEMCPY_STRUCT_AFTER(struct_dst, struct_src, member)  { \
509         CHECK_TYPE_NONCONST(struct_dst); \
510         ((void)(struct_dst == struct_src), \
511          memcpy((char *)(struct_dst)       + OFFSETOF_STRUCT_AFTER(struct_dst, member), \
512                 (const char *)(struct_src) + OFFSETOF_STRUCT_AFTER(struct_dst, member), \
513                 sizeof(*(struct_dst))      - OFFSETOF_STRUCT_AFTER(struct_dst, member))); \
514 } ((void)0)
515
516 #define MEMSET_STRUCT_AFTER(struct_var, value, member)  { \
517         CHECK_TYPE_NONCONST(struct_var); \
518         memset((char *)(struct_var)  + OFFSETOF_STRUCT_AFTER(struct_var, member), \
519                value, \
520                sizeof(*(struct_var)) - OFFSETOF_STRUCT_AFTER(struct_var, member)); \
521 } ((void)0)
522
523 /* defined
524  * in memory_utils.c for now. I do not know where we should put it actually... */
525 #ifndef __BLI_MEMORY_UTILS_H__
526 extern bool BLI_memory_is_zero(const void *arr, const size_t arr_size);
527 #endif
528
529 #define MEMCMP_STRUCT_AFTER_IS_ZERO(struct_var, member) \
530         (BLI_memory_is_zero( \
531                (const char *)(struct_var)  + OFFSETOF_STRUCT_AFTER(struct_var, member), \
532                sizeof(*(struct_var))       - OFFSETOF_STRUCT_AFTER(struct_var, member)))
533
534 /** \} */
535
536 /* -------------------------------------------------------------------- */
537 /** \name String Macros
538  * \{ */
539
540 /* Macro to convert a value to string in the preprocessor
541  * STRINGIFY_ARG: gives the argument as a string
542  * STRINGIFY_APPEND: appends any argument 'b' onto the string argument 'a',
543  *   used by STRINGIFY because some preprocessors warn about zero arguments
544  * STRINGIFY: gives the argument's value as a string */
545 #define STRINGIFY_ARG(x) "" #x
546 #define STRINGIFY_APPEND(a, b) "" a #b
547 #define STRINGIFY(x) STRINGIFY_APPEND("", x)
548
549
550 /* generic strcmp macros */
551 #if defined(_MSC_VER)
552 #  define strcasecmp _stricmp
553 #  define strncasecmp _strnicmp
554 #endif
555
556 #define STREQ(a, b) (strcmp(a, b) == 0)
557 #define STRCASEEQ(a, b) (strcasecmp(a, b) == 0)
558 #define STREQLEN(a, b, n) (strncmp(a, b, n) == 0)
559 #define STRCASEEQLEN(a, b, n) (strncasecmp(a, b, n) == 0)
560
561 #define STRPREFIX(a, b) (strncmp((a), (b), strlen(b)) == 0)
562
563 /** \} */
564
565 /* -------------------------------------------------------------------- */
566 /** \name Unused Function/Argument Macros
567  * \{ */
568
569 /* UNUSED macro, for function argument */
570 #if defined(__GNUC__) || defined(__clang__)
571 #  define UNUSED(x) UNUSED_ ## x __attribute__((__unused__))
572 #else
573 #  define UNUSED(x) UNUSED_ ## x
574 #endif
575
576 #if defined(__GNUC__) || defined(__clang__)
577 #  define UNUSED_FUNCTION(x) __attribute__((__unused__)) UNUSED_ ## x
578 #else
579 #  define UNUSED_FUNCTION(x) UNUSED_ ## x
580 #endif
581
582 /**
583  * UNUSED_VARS#(a, ...): quiet unused warnings
584  *
585  * \code{.py}
586  * for i in range(16):
587  *     args = [(chr(ord('a') + (c % 26)) + (chr(ord('0') + (c // 26)))) for c in range(i + 1)]
588  *     print("#define _VA_UNUSED_VARS_%d(%s) \\" % (i + 1, ", ".join(args)))
589  *     print("\t((void)(%s)%s)" %
590  *             (args[0], ((", _VA_UNUSED_VARS_" + str(i) + "(%s)") if i else "%s") % ", ".join((args[1:]))))
591  * \endcode
592  */
593
594 #define _VA_UNUSED_VARS_1(a0) \
595         ((void)(a0))
596 #define _VA_UNUSED_VARS_2(a0, b0) \
597         ((void)(a0), _VA_UNUSED_VARS_1(b0))
598 #define _VA_UNUSED_VARS_3(a0, b0, c0) \
599         ((void)(a0), _VA_UNUSED_VARS_2(b0, c0))
600 #define _VA_UNUSED_VARS_4(a0, b0, c0, d0) \
601         ((void)(a0), _VA_UNUSED_VARS_3(b0, c0, d0))
602 #define _VA_UNUSED_VARS_5(a0, b0, c0, d0, e0) \
603         ((void)(a0), _VA_UNUSED_VARS_4(b0, c0, d0, e0))
604 #define _VA_UNUSED_VARS_6(a0, b0, c0, d0, e0, f0) \
605         ((void)(a0), _VA_UNUSED_VARS_5(b0, c0, d0, e0, f0))
606 #define _VA_UNUSED_VARS_7(a0, b0, c0, d0, e0, f0, g0) \
607         ((void)(a0), _VA_UNUSED_VARS_6(b0, c0, d0, e0, f0, g0))
608 #define _VA_UNUSED_VARS_8(a0, b0, c0, d0, e0, f0, g0, h0) \
609         ((void)(a0), _VA_UNUSED_VARS_7(b0, c0, d0, e0, f0, g0, h0))
610 #define _VA_UNUSED_VARS_9(a0, b0, c0, d0, e0, f0, g0, h0, i0) \
611         ((void)(a0), _VA_UNUSED_VARS_8(b0, c0, d0, e0, f0, g0, h0, i0))
612 #define _VA_UNUSED_VARS_10(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0) \
613         ((void)(a0), _VA_UNUSED_VARS_9(b0, c0, d0, e0, f0, g0, h0, i0, j0))
614 #define _VA_UNUSED_VARS_11(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0) \
615         ((void)(a0), _VA_UNUSED_VARS_10(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0))
616 #define _VA_UNUSED_VARS_12(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0) \
617         ((void)(a0), _VA_UNUSED_VARS_11(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0))
618 #define _VA_UNUSED_VARS_13(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0) \
619         ((void)(a0), _VA_UNUSED_VARS_12(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0))
620 #define _VA_UNUSED_VARS_14(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0) \
621         ((void)(a0), _VA_UNUSED_VARS_13(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0))
622 #define _VA_UNUSED_VARS_15(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0, o0) \
623         ((void)(a0), _VA_UNUSED_VARS_14(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0, o0))
624 #define _VA_UNUSED_VARS_16(a0, b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0, o0, p0) \
625         ((void)(a0), _VA_UNUSED_VARS_15(b0, c0, d0, e0, f0, g0, h0, i0, j0, k0, l0, m0, n0, o0, p0))
626
627
628 /* reusable ELEM macro */
629 #define UNUSED_VARS(...) VA_NARGS_CALL_OVERLOAD(_VA_UNUSED_VARS_, __VA_ARGS__)
630
631 /* for debug-only variables */
632 #ifndef NDEBUG
633 #  define UNUSED_VARS_NDEBUG(...)
634 #else
635 #  define UNUSED_VARS_NDEBUG UNUSED_VARS
636 #endif
637
638 /** \} */
639
640 /* -------------------------------------------------------------------- */
641 /** \name Branch Prediction Macros
642  * \{ */
643
644 /* hints for branch prediction, only use in code that runs a _lot_ where */
645 #ifdef __GNUC__
646 #  define LIKELY(x)       __builtin_expect(!!(x), 1)
647 #  define UNLIKELY(x)     __builtin_expect(!!(x), 0)
648 #else
649 #  define LIKELY(x)       (x)
650 #  define UNLIKELY(x)     (x)
651 #endif
652
653 /** \} */
654
655 /* -------------------------------------------------------------------- */
656 /** \name Flag Macros
657  * \{ */
658
659 /* Set flag from a single test */
660 #define SET_FLAG_FROM_TEST(value, test, flag) \
661 { \
662         if (test) { \
663                 (value) |=  (flag); \
664         } \
665         else { \
666                 (value) &= ~(flag); \
667         } \
668 } ((void)0)
669
670 /** \} */
671
672 /* -------------------------------------------------------------------- */
673 /** \name Misc Macros
674  * \{ */
675
676 /** Useful for debugging. */
677 #define AT __FILE__ ":" STRINGIFY(__LINE__)
678
679 /** No-op for expressions we don't want to instansiate, but must remian valid. */
680 #define EXPR_NOP(expr) (void)(0 ? ((void)(expr), 1) : 0)
681
682 /** \} */
683
684 #ifdef __cplusplus
685 }
686 #endif
687
688 #endif  /* __BLI_UTILDEFINES_H__ */