util_macro.h

Go to the documentation of this file.

/*
 * Copyright (c) 2011-2014, Wind River Systems, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_SYS_UTIL_MACROS_H_
#define ZEPHYR_INCLUDE_SYS_UTIL_MACROS_H_
 
#ifdef __cplusplus
extern "C" {
#endif

 
/*
 * Most of the eldritch implementation details for all the macrobatics
 * below (APIs like IS_ENABLED(), COND_CODE_1(), etc.) are hidden away
 * in this file.
 */
#include <zephyr/sys/util_internal.h>
 
#ifndef BIT
#if defined(_ASMLANGUAGE)
#define BIT(n)  (1 << (n))
#else
#define BIT(n)  (1UL << (n))
#endif
#endif

#define BIT64(_n) (1ULL << (_n))

#define WRITE_BIT(var, bit, set)                                                                   \
        do {                                                                                       \
                __typeof__(var) __mask = ((__typeof__(var))1U << (bit));                           \
                if (set) {                                                                         \
                        (var) |= __mask;                                                           \
                } else {                                                                           \
                        (var) &= ~__mask;                                                          \
                }                                                                                  \
        } while (0)

#define BIT_MASK(n) (BIT(n) - 1UL)

#define BIT64_MASK(n) (BIT64(n) - 1ULL)

#define IS_POWER_OF_TWO(x) (((x) != 0U) && (((x) & ((x) - 1U)) == 0U))

#define IS_SHIFTED_BIT_MASK(m, s) (!(((m) >> (s)) & (((m) >> (s)) + 1U)))

#define IS_BIT_MASK(m) IS_SHIFTED_BIT_MASK(m, 0)

#define IS_BIT_SET(value, bit) ((((value) >> (bit)) & (0x1)) != 0)

#define LSB_GET(value) ((value) & -(value))

#define FIELD_GET(mask, value)  (((value) & (mask)) / LSB_GET(mask))

#define FIELD_PREP(mask, value) (((value) * LSB_GET(mask)) & (mask))

#define IS_ENABLED(config_macro) Z_IS_ENABLED1(config_macro)
/* INTERNAL: the first pass above is just to expand any existing
 * macros, we need the macro value to be e.g. a literal "1" at
 * expansion time in the next macro, not "(1)", etc... Standard
 * recursive expansion does not work.
 */

#define COND_CODE_1(_flag, _if_1_code, _else_code) \
        Z_COND_CODE_1(_flag, _if_1_code, _else_code)

#define COND_CODE_0(_flag, _if_0_code, _else_code) \
        Z_COND_CODE_0(_flag, _if_0_code, _else_code)

#define COND_CASE_1(...) \
        Z_COND_CASE_1(__VA_ARGS__)

#define IF_ENABLED(_flag, _code) \
        COND_CODE_1(_flag, _code, ())

#define IF_DISABLED(_flag, _code) \
        COND_CODE_1(_flag, (), _code)

#define IS_EMPTY(...) Z_IS_EMPTY_(__VA_ARGS__)

#define IS_EQ(a, b) Z_IS_EQ(a, b)

#define LIST_DROP_EMPTY(...) \
        Z_LIST_DROP_FIRST(FOR_EACH(Z_LIST_NO_EMPTIES, (), __VA_ARGS__))

#define EMPTY

#define IDENTITY(V) V

#define GET_ARG_N(N, ...) UTIL_CAT(Z_GET_ARG_, N)(__VA_ARGS__)

#define GET_ARGS_LESS_N(N, ...) UTIL_CAT(Z_GET_ARGS_LESS_, N)(__VA_ARGS__)

#define GET_ARGS_FIRST_N(N, ...) UTIL_CAT(Z_GET_ARGS_FIRST_, N)(__VA_ARGS__)

#define UTIL_OR(a, b) COND_CODE_1(UTIL_BOOL(a), (a), (b))

#define UTIL_AND(a, b) COND_CODE_1(UTIL_BOOL(a), (b), (0))

#define UTIL_INC(x) UTIL_PRIMITIVE_CAT(Z_UTIL_INC_, x)

#define UTIL_DEC(x) UTIL_PRIMITIVE_CAT(Z_UTIL_DEC_, x)

#define UTIL_X2(y) UTIL_PRIMITIVE_CAT(Z_UTIL_X2_, y)
 

#define LISTIFY(LEN, F, sep, ...) UTIL_CAT(Z_UTIL_LISTIFY_, LEN)(F, sep, __VA_ARGS__)

#define FOR_EACH(F, sep, ...) \
        Z_FOR_EACH(F, sep, REVERSE_ARGS(__VA_ARGS__))

#define FOR_EACH_NONEMPTY_TERM(F, term, ...)                            \
        COND_CODE_0(                                                    \
                /* are there zero non-empty arguments ? */              \
                NUM_VA_ARGS_LESS_1(LIST_DROP_EMPTY(__VA_ARGS__, _)),    \
                /* if so, expand to nothing */                          \
                (),                                                     \
                /* otherwise, expand to: */                             \
                (/* FOR_EACH() on nonempty elements, */         \
                        FOR_EACH(F, term, LIST_DROP_EMPTY(__VA_ARGS__)) \
                        /* plus a final terminator */                   \
                        __DEBRACKET term                                \
                ))

#define FOR_EACH_IDX(F, sep, ...) \
        Z_FOR_EACH_IDX(F, sep, REVERSE_ARGS(__VA_ARGS__))

#define FOR_EACH_FIXED_ARG(F, sep, fixed_arg, ...) \
        Z_FOR_EACH_FIXED_ARG(F, sep, fixed_arg, REVERSE_ARGS(__VA_ARGS__))

#define FOR_EACH_IDX_FIXED_ARG(F, sep, fixed_arg, ...) \
        Z_FOR_EACH_IDX_FIXED_ARG(F, sep, fixed_arg, REVERSE_ARGS(__VA_ARGS__))

#define REVERSE_ARGS(...) \
        Z_FOR_EACH_ENGINE(Z_FOR_EACH_EXEC, (,), Z_BYPASS, _, __VA_ARGS__)

#define NUM_VA_ARGS_LESS_1(...) \
        NUM_VA_ARGS_LESS_1_IMPL(__VA_ARGS__, 63, 62, 61, \
        60, 59, 58, 57, 56, 55, 54, 53, 52, 51,          \
        50, 49, 48, 47, 46, 45, 44, 43, 42, 41,          \
        40, 39, 38, 37, 36, 35, 34, 33, 32, 31,          \
        30, 29, 28, 27, 26, 25, 24, 23, 22, 21,          \
        20, 19, 18, 17, 16, 15, 14, 13, 12, 11,          \
        10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, ~)

#define NUM_VA_ARGS(...)                                                                           \
        COND_CODE_1(IS_EMPTY(__VA_ARGS__), (0), (UTIL_INC(NUM_VA_ARGS_LESS_1(__VA_ARGS__))))

#define MACRO_MAP_CAT(...) MACRO_MAP_CAT_(__VA_ARGS__)

#define MACRO_MAP_CAT_N(N, ...) MACRO_MAP_CAT_N_(N, __VA_ARGS__)

 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_SYS_UTIL_MACROS_H_ */