mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
153 lines
4.3 KiB
153 lines
4.3 KiB
/* SPDX-License-Identifier: GPL-2.0 */ |
|
#ifndef _LINUX_MINMAX_H |
|
#define _LINUX_MINMAX_H |
|
|
|
/* |
|
* min()/max()/clamp() macros must accomplish three things: |
|
* |
|
* - avoid multiple evaluations of the arguments (so side-effects like |
|
* "x++" happen only once) when non-constant. |
|
* - perform strict type-checking (to generate warnings instead of |
|
* nasty runtime surprises). See the "unnecessary" pointer comparison |
|
* in __typecheck(). |
|
* - retain result as a constant expressions when called with only |
|
* constant expressions (to avoid tripping VLA warnings in stack |
|
* allocation usage). |
|
*/ |
|
#define __typecheck(x, y) \ |
|
(!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) |
|
|
|
/* |
|
* This returns a constant expression while determining if an argument is |
|
* a constant expression, most importantly without evaluating the argument. |
|
* Glory to Martin Uecker <[email protected]> |
|
*/ |
|
#define __is_constexpr(x) \ |
|
(sizeof(int) == sizeof(*(8 ? ((void *)((long)(x) * 0l)) : (int *)8))) |
|
|
|
#define __no_side_effects(x, y) \ |
|
(__is_constexpr(x) && __is_constexpr(y)) |
|
|
|
#define __safe_cmp(x, y) \ |
|
(__typecheck(x, y) && __no_side_effects(x, y)) |
|
|
|
#define __cmp(x, y, op) ((x) op (y) ? (x) : (y)) |
|
|
|
#define __cmp_once(x, y, unique_x, unique_y, op) ({ \ |
|
typeof(x) unique_x = (x); \ |
|
typeof(y) unique_y = (y); \ |
|
__cmp(unique_x, unique_y, op); }) |
|
|
|
#define __careful_cmp(x, y, op) \ |
|
__builtin_choose_expr(__safe_cmp(x, y), \ |
|
__cmp(x, y, op), \ |
|
__cmp_once(x, y, __UNIQUE_ID(__x), __UNIQUE_ID(__y), op)) |
|
|
|
/** |
|
* min - return minimum of two values of the same or compatible types |
|
* @x: first value |
|
* @y: second value |
|
*/ |
|
#define min(x, y) __careful_cmp(x, y, <) |
|
|
|
/** |
|
* max - return maximum of two values of the same or compatible types |
|
* @x: first value |
|
* @y: second value |
|
*/ |
|
#define max(x, y) __careful_cmp(x, y, >) |
|
|
|
/** |
|
* min3 - return minimum of three values |
|
* @x: first value |
|
* @y: second value |
|
* @z: third value |
|
*/ |
|
#define min3(x, y, z) min((typeof(x))min(x, y), z) |
|
|
|
/** |
|
* max3 - return maximum of three values |
|
* @x: first value |
|
* @y: second value |
|
* @z: third value |
|
*/ |
|
#define max3(x, y, z) max((typeof(x))max(x, y), z) |
|
|
|
/** |
|
* min_not_zero - return the minimum that is _not_ zero, unless both are zero |
|
* @x: value1 |
|
* @y: value2 |
|
*/ |
|
#define min_not_zero(x, y) ({ \ |
|
typeof(x) __x = (x); \ |
|
typeof(y) __y = (y); \ |
|
__x == 0 ? __y : ((__y == 0) ? __x : min(__x, __y)); }) |
|
|
|
/** |
|
* clamp - return a value clamped to a given range with strict typechecking |
|
* @val: current value |
|
* @lo: lowest allowable value |
|
* @hi: highest allowable value |
|
* |
|
* This macro does strict typechecking of @lo/@hi to make sure they are of the |
|
* same type as @val. See the unnecessary pointer comparisons. |
|
*/ |
|
#define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) |
|
|
|
/* |
|
* ..and if you can't take the strict |
|
* types, you can specify one yourself. |
|
* |
|
* Or not use min/max/clamp at all, of course. |
|
*/ |
|
|
|
/** |
|
* min_t - return minimum of two values, using the specified type |
|
* @type: data type to use |
|
* @x: first value |
|
* @y: second value |
|
*/ |
|
#define min_t(type, x, y) __careful_cmp((type)(x), (type)(y), <) |
|
|
|
/** |
|
* max_t - return maximum of two values, using the specified type |
|
* @type: data type to use |
|
* @x: first value |
|
* @y: second value |
|
*/ |
|
#define max_t(type, x, y) __careful_cmp((type)(x), (type)(y), >) |
|
|
|
/** |
|
* clamp_t - return a value clamped to a given range using a given type |
|
* @type: the type of variable to use |
|
* @val: current value |
|
* @lo: minimum allowable value |
|
* @hi: maximum allowable value |
|
* |
|
* This macro does no typechecking and uses temporary variables of type |
|
* @type to make all the comparisons. |
|
*/ |
|
#define clamp_t(type, val, lo, hi) min_t(type, max_t(type, val, lo), hi) |
|
|
|
/** |
|
* clamp_val - return a value clamped to a given range using val's type |
|
* @val: current value |
|
* @lo: minimum allowable value |
|
* @hi: maximum allowable value |
|
* |
|
* This macro does no typechecking and uses temporary variables of whatever |
|
* type the input argument @val is. This is useful when @val is an unsigned |
|
* type and @lo and @hi are literals that will otherwise be assigned a signed |
|
* integer type. |
|
*/ |
|
#define clamp_val(val, lo, hi) clamp_t(typeof(val), val, lo, hi) |
|
|
|
/** |
|
* swap - swap values of @a and @b |
|
* @a: first value |
|
* @b: second value |
|
*/ |
|
#define swap(a, b) \ |
|
do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0) |
|
|
|
#endif /* _LINUX_MINMAX_H */
|
|
|