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 */ 39static inline void* PA_ALIGN_PTR(const void *p) { 40 return (void*) (((size_t) p) & ~(sizeof(void*) - 1)); 41} 42 43/* Rounds up */ 44static 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