Add macros similar to min/max/min_t/max_t.
PATCH 1/10 Add macros similar to min/max/min_t/max_t.
Also, change the variable names used in the min/max macros to avoid shadowed variable warnings when min/max min_t/max_t are nested.
Small formatting changes to make all the macros have a similar form.
---
Andrew, I'll send you an incremental patch for the patch in -mm, this is just so people can see the final form/users.
drivers/media/video/bt8xx/bttvp.h | 2 - drivers/media/video/usbvideo/vicam.c | 6 --- include/linux/kernel.h | 63 ++++++++++++++++++++++++---------- 3 files changed, 45 insertions(+), 26 deletions(-)
drivers/media/video/bt8xx/bttvp.h +0 -2
@@ -82,8 +82,6 @@/* Limits scaled width, which must be a multiple of 4. */ #define MAX_HACTIVE (0x3FF & -4) -#define clamp (x, low, high) min (max (low, x), high) -#define BTTV_NORMS (\ V4L2_STD_PAL | V4L2_STD_PAL_N | \ V4L2_STD_PAL_Nc | V4L2_STD_SECAM | \
drivers/media/video/usbvideo/vicam.c +0 -6
@@ -70,12 +70,6 @@#define VICAM_HEADER_SIZE 64 -#define clamp ( x, l, h ) max_t( __typeof__( x ), \ - ( l ), \ - min_t( __typeof__( x ), \ - ( h ), \ - ( x ) ) ) -/* Not sure what all the bytes in these char * arrays do, but they're necessary to make * the camera work.
include/linux/kernel.h +45 -18
78 lines not on this page · raw message
Signature · 1 line
1.5.4.4.653.g7cf1e
Quoted 37 lines · On Thu, 13 Mar 2008 22:18:45 -0700 Harvey Harrison wrote:
Also, change the variable names used in the min/max macros to avoid shadowed variable warnings when min/max min_t/max_t are nested.
Small formatting changes to make all the macros have a similar form.
drivers/media/video/bt8xx/bttvp.h | 2 - drivers/media/video/usbvideo/vicam.c | 6 --- include/linux/kernel.h | 63 ++++++++++++++++++++++++---------- 3 files changed, 45 insertions(+), 26 deletions(-)include/linux/kernel.h +3
-12@@ -335,33 +335,60 @@ static inline int __attribute__ ((format (printf, 1, 2))) pr_debug(const char *#endif /* __LITTLE_ENDIAN */ /* -* min()/max() macros that also do +* min()/max()/clamp() macros that also do * strict type-checking.. See the * "unnecessary" pointer comparison. */ -#define min (x,y) ({ \ - typeof(x) _x = (x); \ - typeof(y) _y = (y); \ - (void) (&_x == &_y); \ - _x < _y ? _x : _y; }) - -#define max (x,y) ({ \ - typeof(x) _x = (x); \ - typeof(y) _y = (y); \ - (void) (&_x == &_y); \ - _x > _y ? _x : _y; }) +#define min (x, y) ({ \ + typeof(x) _min1 = (x); \
include/linux/kernel.h static inline int __attribute__ ((format (printf, 1, 2))) pr_debug(const char * · line 353
Quoted 10 lines
include/linux/kernel.h +10
-0+typeof (y) _min2 = (y); \ + (void ) (&_min1 == &_min2); \ + _min1 < _min2 ? _min1 : _min2; }) + +#define max (x, y) ({ \ + typeof(x) _max1 = (x); \ + typeof(y) _max2 = (y); \ + (void) (&_max1 == &_max2); \ + _max1 > _max2 ? _max1 : _max2; }) +
Where is some blurb/comment about what "clamp" means/does? min/max are well understood, but clamp? Is that a shop tool? I think I have a few out in my garage.
So can we have some blurb here to explain clamp(), clamp_t(), and clamp_val()?
(kernel-doc preferred, but not required) e.g:
/**
* clamp - returns a value that is restricted between min & max inclusive
* @val: current value
* @min: minimum value of the clamping region
* @max: maximum value of the clamping region
*/
and explain the differences in clamp/clamp_t/clamp_val...
/*
Quoted 37 lines
include/linux/kernel.h +25
-6+#define clamp (val, min, max) ({ \ + typeof(val) __val = (val); \ + typeof(min) __min = (min); \ + typeof(max) __max = (max); \ + (void) (&__val == &__min); \ + (void) (&__val == &__max); \ + __val = __val < __min ? __min: __val; \ + __val > __max ? __max: __val; })/* * ..and if you can't take the strict * types, you can specify one yourself. * -* Or not use min/max at all, of course. +* Or not use min/max/clamp at all, of course. */ -#define min_t (type,x,y) \ - ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; }) -#define max_t (type,x,y) \ - ({ type __x = (x); type __y = (y); __x > __y ? __x: __y; }) - +#define min_t (type, x, y) ({ \ + type __min1 = (x); \ + type __min2 = (y); \ + __min1 < __min2 ? __min1: __min2; }) + +#define max_t (type, x, y) ({ \ + type __max1 = (x); \ + type __max2 = (y); \ + __max1 > __max2 ? __max1: __max2; }) + +#define clamp_t (type, val, min, max) ({ \ + type __val = (val); \ + type __min = (min); \ + type __max = (max); \ + __val = __val < __min ? __min: __val; \ + __val > __max ? __max: __val; })
include/linux/kernel.h static inline int __attribute__ ((format (printf, 1, 2))) pr_debug(const char * · line 394
Quoted 10 lines
include/linux/kernel.h +7
-0+ +#define clamp_val (val, min, max) ({ \ + typeof(val) __val = (val); \ + typeof(val) __min = (min); \ + typeof(val) __max = (max); \ + __val = __val < __min ? __min: __val; \ + __val > __max ? __max: __val; })/** * container_of - cast a member of a structure out to the containing structure
---
~Randy
Quoted 12 lines · Randy Dunlap
On Thu, 13 Mar 2008 22:18:45 -0700 Harvey Harrison wrote:
Where is some blurb/comment about what "clamp" means/does? min/max are well understood, but clamp? Is that a shop tool? I think I have a few out in my garage.
So can we have some blurb here to explain
clamp(),clamp_t(), andclamp_val()?(kernel-doc preferred, but not required) e.g:
Quoted 10 lines
/**
* clamp - returns a value that is restricted between min & max inclusive
* @val: current value
* @min: minimum value of the clamping region
* @max: maximum value of the clamping region
*/and explain the differences in clamp/clamp_t/clamp_val...
Sure, I'll do that..does kernel-doc actually work for macros?
Harvey
Quoted 19 lines · Harvey Harrison
Quoted 18 lines · Randy Dunlap
On Thu, 13 Mar 2008 22:18:45 -0700 Harvey Harrison wrote:
Where is some blurb/comment about what "clamp" means/does? min/max are well understood, but clamp? Is that a shop tool? I think I have a few out in my garage.
So can we have some blurb here to explain
clamp(),clamp_t(), andclamp_val()?(kernel-doc preferred, but not required) e.g:
/**
* clamp - returns a value that is restricted between min & max inclusive
* @val: current value
* @min: minimum value of the clamping region
* @max: maximum value of the clamping region
*/
Quoted 5 lines
Quoted 3 lines
and explain the differences in clamp/clamp_t/clamp_val...
Sure, I'll do that..does kernel-doc actually work for macros?
Yes, it does.
Signature · 1 line
~Randy
Quoted 11 lines · Randy Dunlap
Quoted 7 lines · Harvey Harrison
Quoted 5 lines · Randy Dunlap
On Thu, 13 Mar 2008 22:18:45 -0700 Harvey Harrison wrote:
Where is some blurb/comment about what "clamp" means/does? min/max are well understood, but clamp? Is that a shop tool? I think I have a few out in my garage.
Sure, I'll do that..does kernel-doc actually work for macros?
Yes, it does.
OK, here's what I've come up with:
/**
* clamp - return a value clamped to a given range with strict typechecking
* @val: current value
* @min: minimum allowable value
* @max: maximum allowable value
*
* This macro does strict typechecking of min/max to make sure they of the
* same type as val. See the unnecessary pointer comparisons. */
#define clamp(val, min, max) ({ \
typeof(val) __val = (val); \
typeof(min) __min = (min); \
typeof(max) __max = (max); \
(void) (&__val == &__min); \
(void) (&__val == &__max); \
__val = __val < __min ? __min: __val; \
__val > __max ? __max: __val; })/**
* clamp_t - return a value clamped to a given range using a given type
* @type: the type of variable to use
* @val: current value
* @min: minimum allowable value
* @max: 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, min, max) ({ \
type __val = (val); \
type __min = (min); \
type __max = (max); \
__val = __val < __min ? __min: __val; \
__val > __max ? __max: __val; })/**
* clamp_val - return a value clamped to a given range using val's type
* @val: current value
* @min: minimum allowable value
* @max: 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 unisgned
* type and min and max are literals that will otherwise be assigned a signed
* integer type.
*/
#define clamp_val(val, min, max) ({ \
typeof(val) __val = (val); \
typeof(val) __min = (min); \
typeof(val) __max = (max); \
__val = __val < __min ? __min: __val; \
__val > __max ? __max: __val; })Comments? Please let me know if I got the kerneldoc format right.
Harvey
Quoted 13 lines · Harvey Harrison
Quoted 9 lines · Randy Dunlap
Quoted 6 lines · Harvey Harrison
Quoted 4 lines · Randy Dunlap
On Thu, 13 Mar 2008 22:18:45 -0700 Harvey Harrison wrote:
Where is some blurb/comment about what "clamp" means/does? min/max are well understood, but clamp? Is that a shop tool? I think I have a few out in my garage.Sure, I'll do that..does kernel-doc actually work for macros?
Yes, it does.
OK, here's what I've come up with:
Quoted 7 lines
/**
* clamp - return a value clamped to a given range with strict typechecking
* @val: current value
* @min: minimum allowable value
* @max: maximum allowable value
*
* This macro does strict typechecking of min/max to make sure they of the
they are of
Quoted 28 lines
* same type as val. See the unnecessary pointer comparisons. */
#define clamp(val, min, max) ({ \ typeof(val) __val = (val); \ typeof(min) __min = (min); \ typeof(max) __max = (max); \ (void) (&__val == &__min); \ (void) (&__val == &__max); \ __val = __val < __min ? __min: __val; \ __val > __max ? __max: __val; })/**
*clamp_t- return a value clamped to a given range using a given type
* @type: the type of variable to use
* @val: current value
* @min: minimum allowable value
* @max: 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, min, max) ({ \ type __val = (val); \ type __min = (min); \ type __max = (max); \ __val = __val < __min ? __min: __val; \ __val > __max ? __max: __val; })
Quoted 8 lines
/**
*clamp_val- return a value clamped to a given range using val's type
* @val: current value
* @min: minimum allowable value
* @max: 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 unisgned
unsigned
Quoted 11 lines
* type and min and max are literals that will otherwise be assigned a signed
* integer type.
*/#define clamp_val(val, min, max) ({ \ typeof(val) __val = (val); \ typeof(val) __min = (min); \ typeof(val) __max = (max); \ __val = __val < __min ? __min: __val; \ __val > __max ? __max: __val; })Comments? Please let me know if I got the kerneldoc format right.
Yes, it looks fine. Thanks.
Signature · 1 line
~Randy