1 #ifndef foopulsemacrohfoo
2 #define foopulsemacrohfoo
3
4 /***
5 This file is part of PulseAudio.
6
7 Copyright 2004-2006 Lennart Poettering
8
9 PulseAudio is free software; you can redistribute it and/or modify
10 it under the terms of the GNU Lesser General Public License as published
11 by the Free Software Foundation; either version 2.1 of the License,
12 or (at your option) any later version.
13
14 PulseAudio is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
18
19 You should have received a copy of the GNU Lesser General Public License
20 along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
21 ***/
22 #ifndef MACRO_H
23 #define MACRO_H
24 #include <sys/types.h>
25 #include <unistd.h>
26 #include <assert.h>
27 #include <limits.h>
28 #include <unistd.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <stdbool.h>
33
34 #ifndef PACKAGE
35 #error "Please include config.h before including this file!"
36 #endif
37
38 /* Rounds down */
PA_ALIGN_PTR(const void * p)39 static inline void* PA_ALIGN_PTR(const void *p) {
40 return (void*) (((size_t) p) & ~(sizeof(void*) - 1));
41 }
42
43 /* Rounds up */
PA_ALIGN(size_t l)44 static inline size_t PA_ALIGN(size_t l) {
45 return ((l + sizeof(void*) - 1) & ~(sizeof(void*) - 1));
46 }
47
48 #if defined(__GNUC__)
49 #define PA_UNUSED __attribute__ ((unused))
50 #else
51 #define PA_UNUSED
52 #endif
53
54 #define PA_ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0]))
55
56 #if defined(__GNUC__)
57 #define PA_DECLARE_ALIGNED(n,t,v) t v __attribute__ ((aligned (n)))
58 #else
59 #define PA_DECLARE_ALIGNED(n,t,v) t v
60 #endif
61
62 #ifdef __GNUC__
63 #define typeof __typeof__
64 #endif
65
66 /* The users of PA_MIN and PA_MAX, PA_CLAMP, PA_ROUND_UP should be
67 * aware that these macros on non-GCC executed code with side effects
68 * twice. It is thus considered misuse to use code with side effects
69 * as arguments to MIN and MAX. */
70
71 #ifdef __GNUC__
72 #define PA_MAX(a,b) \
73 __extension__ ({ \
74 typeof(a) _a = (a); \
75 typeof(b) _b = (b); \
76 _a > _b ? _a : _b; \
77 })
78 #else
79 #define PA_MAX(a, b) ((a) > (b) ? (a) : (b))
80 #endif
81
82 #ifdef __GNUC__
83 #define PA_MIN(a,b) \
84 __extension__ ({ \
85 typeof(a) _a = (a); \
86 typeof(b) _b = (b); \
87 _a < _b ? _a : _b; \
88 })
89 #else
90 #define PA_MIN(a, b) ((a) < (b) ? (a) : (b))
91 #endif
92
93 #ifdef __GNUC__
94 #define PA_ROUND_UP(a, b) \
95 __extension__ ({ \
96 typeof(a) _a = (a); \
97 typeof(b) _b = (b); \
98 ((_a + _b - 1) / _b) * _b; \
99 })
100 #else
101 #define PA_ROUND_UP(a, b) ((((a) + (b) - 1) / (b)) * (b))
102 #endif
103
104 #ifdef __GNUC__
105 #define PA_ROUND_DOWN(a, b) \
106 __extension__ ({ \
107 typeof(a) _a = (a); \
108 typeof(b) _b = (b); \
109 (_a / _b) * _b; \
110 })
111 #else
112 #define PA_ROUND_DOWN(a, b) (((a) / (b)) * (b))
113 #endif
114
115 #ifdef __GNUC__
116 #define PA_CLIP_SUB(a, b) \
117 __extension__ ({ \
118 typeof(a) _a = (a); \
119 typeof(b) _b = (b); \
120 _a > _b ? _a - _b : 0; \
121 })
122 #else
123 #define PA_CLIP_SUB(a, b) ((a) > (b) ? (a) - (b) : 0)
124 #endif
125
126 #ifdef __GNUC__
127 #define PA_PRETTY_FUNCTION __PRETTY_FUNCTION__
128 #else
129 #define PA_PRETTY_FUNCTION ""
130 #endif
131
132 #define pa_return_if_fail(expr) \
133 do { \
134 if (PA_UNLIKELY(!(expr))) { \
135 pa_log_debug("Assertion '%s' failed at %s:%u, function %s.", #expr , __FILE__, __LINE__, PA_PRETTY_FUNCTION); \
136 return; \
137 } \
138 } while(false)
139
140 #define pa_return_val_if_fail(expr, val) \
141 do { \
142 if (PA_UNLIKELY(!(expr))) { \
143 pa_log_debug("Assertion '%s' failed at %s:%u, function %s.", #expr , __FILE__, __LINE__, PA_PRETTY_FUNCTION); \
144 return (val); \
145 } \
146 } while(false)
147
148 #define pa_return_null_if_fail(expr) pa_return_val_if_fail(expr, NULL)
149
150 /* pa_assert_se() is an assert which guarantees side effects of x,
151 * i.e. is never optimized away, regardless of NDEBUG or FASTPATH. */
152 #ifndef __COVERITY__
153 #define pa_assert_se(expr) \
154 do { \
155 if (PA_UNLIKELY(!(expr))) { \
156 pa_log_error("Assertion '%s' failed. Aborting.", #expr); \
157 } \
158 } while (false)
159 #else
160 #define pa_assert_se(expr) \
161 do { \
162 int _unique_var = (expr); \
163 if (!_unique_var) \
164 pa_log_error("Assertion '%s' failed. Aborting.", #expr); \
165 } while (false)
166 #endif
167
168 /* Does exactly nothing */
169 #define pa_nop() do {} while (false)
170
171 /* pa_assert() is an assert that may be optimized away by defining
172 * NDEBUG. pa_assert_fp() is an assert that may be optimized away by
173 * defining FASTPATH. It is supposed to be used in inner loops. It's
174 * there for extra paranoia checking and should probably be removed in
175 * production builds. */
176 #ifdef NDEBUG
177 #define pa_assert(expr) pa_assert_se(expr)
178 #define pa_assert_fp(expr) pa_assert_se(expr)
179 #elif defined (FASTPATH)
180 #define pa_assert(expr) pa_assert_se(expr)
181 #define pa_assert_fp(expr) pa_assert_se(expr)
182 #else
183 #define pa_assert(expr) pa_assert_se(expr)
184 #define pa_assert_fp(expr) pa_assert_se(expr)
185 #endif
186
187 #ifdef NDEBUG
188 #define pa_assert_not_reached() abort()
189 #else
190 #define pa_assert_not_reached() \
191 do { \
192 pa_log_error("Code should not be reached at %s:%u, function %s(). Aborting.", __FILE__, __LINE__, PA_PRETTY_FUNCTION); \
193 abort(); \
194 } while (false)
195 #endif
196
197 /* A compile time assertion */
198 #define pa_assert_cc(expr) \
199 do { \
200 switch (0) { \
201 case 0: \
202 case !!(expr): \
203 ; \
204 } \
205 } while (false)
206
207 #define PA_PTR_TO_UINT(p) ((unsigned int) ((uintptr_t) (p)))
208 #define PA_UINT_TO_PTR(u) ((void*) ((uintptr_t) (u)))
209
210 #define PA_PTR_TO_UINT32(p) ((uint32_t) ((uintptr_t) (p)))
211 #define PA_UINT32_TO_PTR(u) ((void*) ((uintptr_t) (u)))
212
213 #define PA_PTR_TO_INT(p) ((int) ((intptr_t) (p)))
214 #define PA_INT_TO_PTR(u) ((void*) ((intptr_t) (u)))
215
216 #define PA_PTR_TO_INT32(p) ((int32_t) ((intptr_t) (p)))
217 #define PA_INT32_TO_PTR(u) ((void*) ((intptr_t) (u)))
218
219 #ifdef OS_IS_WIN32
220 #define PA_PATH_SEP "\\"
221 #define PA_PATH_SEP_CHAR '\\'
222 #else
223 #define PA_PATH_SEP "/"
224 #define PA_PATH_SEP_CHAR '/'
225 #endif
226
227 #if defined(__GNUC__) && defined(__ELF__)
228
229 #define PA_WARN_REFERENCE(sym, msg) \
230 __asm__(".section .gnu.warning." #sym); \
231 __asm__(".asciz \"" msg "\""); \
232 __asm__(".previous")
233
234 #else
235
236 #define PA_WARN_REFERENCE(sym, msg)
237
238 #endif
239
240 #if defined(__i386__) || defined(__x86_64__)
241 #define PA_DEBUG_TRAP __asm__("int $3")
242 #else
243 #define PA_DEBUG_TRAP raise(SIGTRAP)
244 #endif
245
246 #define pa_memzero(x,l) (memset((x), 0, (l)))
247 #define pa_zero(x) (pa_memzero(&(x), sizeof(x)))
248
249 #define PA_INT_TYPE_SIGNED(type) (!!((type) 0 > (type) -1))
250
251 #define PA_INT_TYPE_HALF(type) ((type) 1 << (sizeof(type)*8 - 2))
252
253 #define PA_INT_TYPE_MAX(type) \
254 ((type) (PA_INT_TYPE_SIGNED(type) \
255 ? (PA_INT_TYPE_HALF(type) - 1 + PA_INT_TYPE_HALF(type)) \
256 : (type) -1))
257
258 #define PA_INT_TYPE_MIN(type) \
259 ((type) (PA_INT_TYPE_SIGNED(type) \
260 ? (-1 - PA_INT_TYPE_MAX(type)) \
261 : (type) 0))
262
263 /* The '#' preprocessor operator doesn't expand any macros that are in the
264 * parameter, which is why we need a separate macro for those cases where the
265 * parameter contains a macro that needs expanding. */
266 #define PA_STRINGIZE(x) #x
267 #define PA_EXPAND_AND_STRINGIZE(x) PA_STRINGIZE(x)
268
269 /* We include this at the very last place */
270 #include <pulsecore/log.h>
271
272 #endif
273 #endif