patch [#34103]
[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 #ifndef NDEBUG /* for BLI_assert */
36 #include <stdio.h>
37 #endif
38
39 /* note: use of (int, TRUE / FALSE) is deprecated,
40  * use (bool, true / false) instead */
41 #ifdef HAVE_STDBOOL_H
42 # include <stdbool.h>
43 #else
44 # ifndef HAVE__BOOL
45 #  ifdef __cplusplus
46 typedef bool _BLI_Bool;
47 #  else
48 /* using char here may cause nasty tricky bugs, e.g.
49  *     bool is_bit_flag = RNA_property_flag(prop) & PROP_ENUM_FLAG;
50  * as PROP_ENUM_FLAG is farther than 8th bit, do_translate would be always false!
51  */
52 #   define _BLI_Bool unsigned int
53 #  endif
54 # else
55 #  define _BLI_Bool _Bool
56 # endif
57 # define bool _BLI_Bool
58 # define false 0
59 # define true 1
60 # define __bool_true_false_are_defined 1
61 #endif
62
63 /* remove this when we're ready to remove TRUE/FALSE completely */
64 #ifdef WITH_BOOL_COMPAT
65 /* interim until all occurrences of these can be updated to stdbool */
66 /* XXX Why not use the true/false velues here? */
67 # ifndef FALSE
68 #   define FALSE 0
69 # endif
70
71 # ifndef TRUE
72 #   define TRUE 1
73 # endif
74 #endif
75
76 /* useful for finding bad use of min/max */
77 #if 0
78 /* gcc only */
79 #  define _TYPECHECK(a, b)  ((void)(((typeof(a) *)0) == ((typeof(b) *)0)))
80 #  define MIN2(x, y)          (_TYPECHECK(x, y), (((x) < (y) ? (x) : (y))))
81 #  define MAX2(x, y)          (_TYPECHECK(x, y), (((x) > (y) ? (x) : (y))))
82 #endif
83
84 /* min/max */
85 #define MIN2(x, y)          ((x) < (y) ? (x) : (y))
86 #define MIN3(x, y, z)       (MIN2(MIN2((x), (y)), (z)))
87 #define MIN4(x, y, z, a)    (MIN2(MIN2((x), (y)), MIN2((z), (a))))
88
89 #define MAX2(x, y)          ((x) > (y) ? (x) : (y))
90 #define MAX3(x, y, z)       (MAX2(MAX2((x), (y)), (z)))
91 #define MAX4(x, y, z, a)    (MAX2(MAX2((x), (y)), MAX2((z), (a))))
92
93 #define INIT_MINMAX(min, max) {                                               \
94                 (min)[0] = (min)[1] = (min)[2] =  1.0e30f;                            \
95                 (max)[0] = (max)[1] = (max)[2] = -1.0e30f;                            \
96         } (void)0
97 #define INIT_MINMAX2(min, max) {                                              \
98                 (min)[0] = (min)[1] = 1.0e30f;                                        \
99                 (max)[0] = (max)[1] = -1.0e30f;                                       \
100         } (void)0
101 #define DO_MIN(vec, min) {                                                    \
102                 if ((min)[0] > (vec)[0]) (min)[0] = (vec)[0];                         \
103                 if ((min)[1] > (vec)[1]) (min)[1] = (vec)[1];                         \
104                 if ((min)[2] > (vec)[2]) (min)[2] = (vec)[2];                         \
105         } (void)0
106 #define DO_MAX(vec, max) {                                                    \
107                 if ((max)[0] < (vec)[0]) (max)[0] = (vec)[0];                         \
108                 if ((max)[1] < (vec)[1]) (max)[1] = (vec)[1];                         \
109                 if ((max)[2] < (vec)[2]) (max)[2] = (vec)[2];                         \
110         } (void)0
111 #define DO_MINMAX(vec, min, max) {                                            \
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                 if ((max)[0] < (vec)[0] ) (max)[0] = (vec)[0];                        \
116                 if ((max)[1] < (vec)[1] ) (max)[1] = (vec)[1];                        \
117                 if ((max)[2] < (vec)[2] ) (max)[2] = (vec)[2];                        \
118         } (void)0
119 #define DO_MINMAX2(vec, min, max) {                                           \
120                 if ((min)[0] > (vec)[0] ) (min)[0] = (vec)[0];                        \
121                 if ((min)[1] > (vec)[1] ) (min)[1] = (vec)[1];                        \
122                 if ((max)[0] < (vec)[0] ) (max)[0] = (vec)[0];                        \
123                 if ((max)[1] < (vec)[1] ) (max)[1] = (vec)[1];                        \
124         } (void)0
125
126 /* some math and copy defines */
127
128 /* Causes warning:
129  * incompatible types when assigning to type 'Foo' from type 'Bar'
130  * ... the compiler optimizes away the temp var */
131 #ifdef __GNUC__
132 #define CHECK_TYPE(var, type)  {  \
133         __typeof(var) *__tmp;         \
134         __tmp = (type *)NULL;         \
135         (void)__tmp;                  \
136 } (void)0
137
138 #define CHECK_TYPE_PAIR(var_a, var_b)  {  \
139         __typeof(var_a) *__tmp;               \
140         __tmp = (__typeof(var_b) *)NULL;      \
141         (void)__tmp;                          \
142 } (void)0
143 #else
144 #  define CHECK_TYPE(var, type)
145 #  define CHECK_TYPE_PAIR(var_a, var_b)
146 #endif
147
148 /* can be used in simple macros */
149 #define CHECK_TYPE_INLINE(val, type) \
150         ((void)(((type *)0) != (val)))
151
152 #define SWAP(type, a, b)  {    \
153         type sw_ap;                \
154         CHECK_TYPE(a, type);       \
155         CHECK_TYPE(b, type);       \
156         sw_ap = (a);               \
157         (a) = (b);                 \
158         (b) = sw_ap;               \
159 } (void)0
160
161 /* swap with a temp value */
162 #define SWAP_TVAL(tval, a, b)  {  \
163         CHECK_TYPE_PAIR(tval, a);     \
164         CHECK_TYPE_PAIR(tval, b);     \
165         (tval) = (a);                 \
166         (a) = (b);                    \
167         (b) = (tval);                 \
168 } (void)0
169
170 /* ELEM#(a, ...): is the first arg equal any of the others */
171 #define ELEM(a, b, c)           ((a) == (b) || (a) == (c))
172 #define ELEM3(a, b, c, d)       (ELEM(a, b, c) || (a) == (d) )
173 #define ELEM4(a, b, c, d, e)    (ELEM(a, b, c) || ELEM(a, d, e) )
174 #define ELEM5(a, b, c, d, e, f) (ELEM(a, b, c) || ELEM3(a, d, e, f) )
175 #define ELEM6(a, b, c, d, e, f, g)      (ELEM(a, b, c) || ELEM4(a, d, e, f, g) )
176 #define ELEM7(a, b, c, d, e, f, g, h)   (ELEM3(a, b, c, d) || ELEM4(a, e, f, g, h) )
177 #define ELEM8(a, b, c, d, e, f, g, h, i)        (ELEM4(a, b, c, d, e) || ELEM4(a, f, g, h, i) )
178 #define ELEM9(a, b, c, d, e, f, g, h, i, j)        (ELEM4(a, b, c, d, e) || ELEM5(a, f, g, h, i, j) )
179 #define ELEM10(a, b, c, d, e, f, g, h, i, j, k)        (ELEM4(a, b, c, d, e) || ELEM6(a, f, g, h, i, j, k) )
180 #define ELEM11(a, b, c, d, e, f, g, h, i, j, k, l)        (ELEM4(a, b, c, d, e) || ELEM7(a, f, g, h, i, j, k, l) )
181
182 /* shift around elements */
183 #define SHIFT3(type, a, b, c)  {                                              \
184         type tmp;                                                                 \
185         CHECK_TYPE(a, type);                                                      \
186         CHECK_TYPE(b, type);                                                      \
187         CHECK_TYPE(c, type);                                                      \
188         tmp = a;                                                                  \
189         a = c;                                                                    \
190         c = b;                                                                    \
191         b = tmp;                                                                  \
192 } (void)0
193
194 #define SHIFT4(type, a, b, c, d)  {                                           \
195         type tmp;                                                                 \
196         CHECK_TYPE(a, type);                                                      \
197         CHECK_TYPE(b, type);                                                      \
198         CHECK_TYPE(c, type);                                                      \
199         CHECK_TYPE(d, type);                                                      \
200         tmp = a;                                                                  \
201         a = d;                                                                    \
202         d = c;                                                                    \
203         c = b;                                                                    \
204         b = tmp;                                                                  \
205 } (void)0
206
207
208 #define ABS(a)          ( (a) < 0 ? (-(a)) : (a) )
209
210 #define FTOCHAR(val) ((val) <= 0.0f) ? 0 : (((val) > (1.0f - 0.5f / 255.0f)) ? 255 : (char)((255.0f * (val)) + 0.5f))
211 #define FTOUSHORT(val) ((val >= 1.0f - 0.5f / 65535) ? 65535 : (val <= 0.0f) ? 0 : (unsigned short)(val * 65535.0f + 0.5f))
212 #define USHORTTOUCHAR(val) ((unsigned char)(((val) >= 65535 - 128) ? 255 : ((val) + 128) >> 8))
213 #define F3TOCHAR3(v2, v1) {                                                   \
214                 (v1)[0] = FTOCHAR((v2[0]));                                           \
215                 (v1)[1] = FTOCHAR((v2[1]));                                           \
216                 (v1)[2] = FTOCHAR((v2[2]));                                           \
217 } (void)0
218 #define F3TOCHAR4(v2, v1) {                                                   \
219                 (v1)[0] = FTOCHAR((v2[0]));                                           \
220                 (v1)[1] = FTOCHAR((v2[1]));                                           \
221                 (v1)[2] = FTOCHAR((v2[2]));                                           \
222                 (v1)[3] = 255;                                                        \
223 } (void)0
224 #define F4TOCHAR4(v2, v1) {                                                   \
225                 (v1)[0] = FTOCHAR((v2[0]));                                           \
226                 (v1)[1] = FTOCHAR((v2[1]));                                           \
227                 (v1)[2] = FTOCHAR((v2[2]));                                           \
228                 (v1)[3] = FTOCHAR((v2[3]));                                           \
229 } (void)0
230 #define VECCOPY(v1, v2) {                                                     \
231                 *(v1) =   *(v2);                                                      \
232                 *(v1 + 1) = *(v2 + 1);                                                \
233                 *(v1 + 2) = *(v2 + 2);                                                \
234 } (void)0
235 #define VECCOPY2D(v1, v2) {                                                   \
236                 *(v1) =   *(v2);                                                      \
237                 *(v1 + 1) = *(v2 + 1);                                                \
238 } (void)0
239 #define VECADD(v1, v2, v3) {                                                  \
240                 *(v1) =   *(v2)   + *(v3);                                            \
241                 *(v1 + 1) = *(v2 + 1) + *(v3 + 1);                                    \
242                 *(v1 + 2) = *(v2 + 2) + *(v3 + 2);                                    \
243 } (void)0
244 #define VECSUB(v1, v2, v3) {                                                  \
245                 *(v1) =   *(v2)   - *(v3);                                            \
246                 *(v1 + 1) = *(v2 + 1) - *(v3 + 1);                                    \
247                 *(v1 + 2) = *(v2 + 2) - *(v3 + 2);                                    \
248 } (void)0
249 #define VECSUB2D(v1, v2, v3)     {                                            \
250                 *(v1) =   *(v2)   - *(v3);                                            \
251                 *(v1 + 1) = *(v2 + 1) - *(v3 + 1);                                    \
252 } (void)0
253 #define VECADDFAC(v1, v2, v3, fac) {                                          \
254                 *(v1) =   *(v2)   + *(v3) * (fac);                                    \
255                 *(v1 + 1) = *(v2 + 1) + *(v3 + 1) * (fac);                            \
256                 *(v1 + 2) = *(v2 + 2) + *(v3 + 2) * (fac);                            \
257 } (void)0
258 #define VECMADD(v1, v2, v3, v4) {                                             \
259                 *(v1) =   *(v2)   + *(v3) * (*(v4));                                     \
260                 *(v1 + 1) = *(v2 + 1) + *(v3 + 1) * (*(v4 + 1));                         \
261                 *(v1 + 2) = *(v2 + 2) + *(v3 + 2) * (*(v4 + 2));                         \
262 } (void)0
263 #define VECSUBFAC(v1, v2, v3, fac) {                                          \
264                 *(v1) =   *(v2)   - *(v3) * (fac);                                    \
265                 *(v1 + 1) = *(v2 + 1) - *(v3 + 1) * (fac);                            \
266                 *(v1 + 2) = *(v2 + 2) - *(v3 + 2) * (fac);                            \
267 } (void)0
268
269 #define INPR(v1, v2) ( (v1)[0] * (v2)[0] + (v1)[1] * (v2)[1] + (v1)[2] * (v2)[2])
270
271 /* some misc stuff.... */
272 #define CLAMP(a, b, c)  {           \
273         if ((a) < (b)) (a) = (b);       \
274         else if ((a) > (c)) (a) = (c);  \
275 } (void)0
276
277 #define CLAMPIS(a, b, c) ((a) < (b) ? (b) : (a) > (c) ? (c) : (a))
278 #define CLAMPTEST(a, b, c)                                                    \
279         if ((b) < (c)) {                                                          \
280                 CLAMP(a, b, c);                                                       \
281         }                                                                         \
282         else {                                                                    \
283                 CLAMP(a, c, b);                                                       \
284         } (void)0
285
286 #define IS_EQ(a, b) ((fabs((double)(a) - (b)) >= (double) FLT_EPSILON) ? 0 : 1)
287 #define IS_EQF(a, b) ((fabsf((float)(a) - (b)) >= (float) FLT_EPSILON) ? 0 : 1)
288
289 #define IS_EQT(a, b, c) ((a > b) ? (((a - b) <= c) ? 1 : 0) : ((((b - a) <= c) ? 1 : 0)))
290 #define IN_RANGE(a, b, c) ((b < c) ? ((b < a && a < c) ? 1 : 0) : ((c < a && a < b) ? 1 : 0))
291 #define IN_RANGE_INCL(a, b, c) ((b < c) ? ((b <= a && a <= c) ? 1 : 0) : ((c <= a && a <= b) ? 1 : 0))
292
293 /* unpack vector for args */
294 #define UNPACK2(a)  ((a)[0]), ((a)[1])
295 #define UNPACK3(a)  ((a)[0]), ((a)[1]), ((a)[2])
296 #define UNPACK4(a)  ((a)[0]), ((a)[1]), ((a)[2]), ((a)[3])
297 /* op may be '&' or '*' */
298 #define UNPACK2OP(a, op)  op((a)[0]), op((a)[1])
299 #define UNPACK3OP(a, op)  op((a)[0]), op((a)[1]), op((a)[2])
300 #define UNPACK4OP(a, op)  op((a)[0]), op((a)[1]), op((a)[2]), op((a)[3])
301
302 /* array helpers */
303 #define ARRAY_LAST_ITEM(arr_start, arr_dtype, elem_size, tot)                 \
304         (arr_dtype *)((char *)arr_start + (elem_size * (tot - 1)))
305
306 #define ARRAY_HAS_ITEM(item, arr_start, arr_dtype, elem_size, tot) (          \
307                 (item >= arr_start) &&                                                \
308                 (item <= ARRAY_LAST_ITEM(arr_start, arr_dtype, elem_size, tot))       \
309         )
310
311 /* Warning-free macros for storing ints in pointers. Use these _only_
312  * for storing an int in a pointer, not a pointer in an int (64bit)! */
313 #define SET_INT_IN_POINTER(i)    ((void *)(intptr_t)(i))
314 #define GET_INT_FROM_POINTER(i)  ((int)(intptr_t)(i))
315
316 #define SET_UINT_IN_POINTER(i)    ((void *)(uintptr_t)(i))
317 #define GET_UINT_FROM_POINTER(i)  ((unsigned int)(uintptr_t)(i))
318
319
320 /* Macro to convert a value to string in the preprocessor
321  * STRINGIFY_ARG: gives the argument as a string
322  * STRINGIFY_APPEND: appends any argument 'b' onto the string argument 'a',
323  *   used by STRINGIFY because some preprocessors warn about zero arguments
324  * STRINGIFY: gives the argument's value as a string */
325 #define STRINGIFY_ARG(x) "" #x
326 #define STRINGIFY_APPEND(a, b) "" a #b
327 #define STRINGIFY(x) STRINGIFY_APPEND("", x)
328
329 /* useful for debugging */
330 #define AT __FILE__ ":" STRINGIFY(__LINE__)
331
332 /* so we can use __func__ everywhere */
333 #if defined(_MSC_VER)
334 #  define __func__ __FUNCTION__
335 #endif
336
337
338 /* UNUSED macro, for function argument */
339 #ifdef __GNUC__
340 #  define UNUSED(x) UNUSED_ ## x __attribute__((__unused__))
341 #else
342 #  define UNUSED(x) UNUSED_ ## x
343 #endif
344
345 #ifdef __GNUC__
346 #  define UNUSED_FUNCTION(x) __attribute__((__unused__)) UNUSED_ ## x
347 #else
348 #  define UNUSED_FUNCTION(x) UNUSED_ ## x
349 #endif
350
351 #ifdef __GNUC__
352 #  define WARN_UNUSED  __attribute__((warn_unused_result))
353 #else
354 #  define WARN_UNUSED
355 #endif
356
357 /*little macro so inline keyword works*/
358 #if defined(_MSC_VER)
359 #  define BLI_INLINE static __forceinline
360 #else
361 #  if (defined(__APPLE__) && defined(__ppc__))
362 /* static inline __attribute__ here breaks osx ppc gcc42 build */
363 #    define BLI_INLINE static __attribute__((always_inline))
364 #  else
365 #    define BLI_INLINE static inline __attribute__((always_inline))
366 #  endif
367 #endif
368
369
370 /* BLI_assert(), default only to print
371  * for aborting need to define WITH_ASSERT_ABORT
372  */
373 #ifndef NDEBUG
374 #  ifdef WITH_ASSERT_ABORT
375 #    define _BLI_DUMMY_ABORT abort
376 #  else
377 #    define _BLI_DUMMY_ABORT() (void)0
378 #  endif
379 #  if defined(__GNUC__) || defined(_MSC_VER) /* check __func__ is available */
380 #    define BLI_assert(a)                                                     \
381         (void)((!(a)) ?  (                                                        \
382                 (                                                                     \
383                 fprintf(stderr,                                                       \
384                         "BLI_assert failed: %s:%d, %s(), at \'%s\'\n",                    \
385                         __FILE__, __LINE__, __func__, STRINGIFY(a)),                      \
386                 _BLI_DUMMY_ABORT(),                                                   \
387                 NULL)) : NULL)
388 #  else
389 #    define BLI_assert(a)                                                     \
390         (void)((!(a)) ?  (                                                        \
391                 (                                                                     \
392                 fprintf(stderr,                                                       \
393                         "BLI_assert failed: %s:%d, at \'%s\'\n",                          \
394                         __FILE__, __LINE__, STRINGIFY(a)),                                \
395                 _BLI_DUMMY_ABORT(),                                                   \
396                 NULL)) : NULL)
397 #  endif
398 #else
399 #  define BLI_assert(a) (void)0
400 #endif
401
402 /* C++ can't use _Static_assert, expects static_assert() but c++0x only */
403 #if (!defined(__cplusplus)) && (defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 406))  /* gcc4.6+ only */
404 #  define BLI_STATIC_ASSERT(a, msg) _Static_assert(a, msg);
405 #else
406    /* TODO msvc, clang */
407 #  define BLI_STATIC_ASSERT(a, msg)
408 #endif
409
410 /* hints for branch pradiction, only use in code that runs a _lot_ where */
411 #ifdef __GNUC__
412 #  define LIKELY(x)       __builtin_expect(!!(x), 1)
413 #  define UNLIKELY(x)     __builtin_expect(!!(x), 0)
414 #else
415 #  define LIKELY(x)       (x)
416 #  define UNLIKELY(x)     (x)
417 #endif
418
419 #endif  /* __BLI_UTILDEFINES_H__ */