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