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.
[[email protected]: coding-style fixes]
[[email protected]: fix v4l build]
Signed-off-by: Harvey Harrison <[email protected]>
Cc: Mauro Carvalho Chehab <[email protected]>
Signed-off-by: Andrew Morton <[email protected]>
---
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(-)
diff --git a/drivers/media/video/bt8xx/bttvp.h b/drivers/media/video/bt8xx/bttvp.h
index 1305d31..b38e3a0 100644
--- a/drivers/media/video/bt8xx/bttvp.h
+++ b/drivers/media/video/bt8xx/bttvp.h
@@ -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 | \
diff --git a/drivers/media/video/usbvideo/vicam.c b/drivers/media/video/usbvideo/vicam.c
index da1ba02..938a60d 100644
--- a/drivers/media/video/usbvideo/vicam.c
+++ b/drivers/media/video/usbvideo/vicam.c
@@ -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.
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 2df44e7..c74460c 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -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); \
+ 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; })
+
+#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; })
+
+#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
--
1.5.4.4.653.g7cf1e
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(-)
> diff --git a/include/linux/kernel.h b/include/linux/kernel.h
> index 2df44e7..c74460c 100644
> --- a/include/linux/kernel.h
> +++ b/include/linux/kernel.h
> @@ -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); \
> + 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...
/*
> +#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; })
> +
> +#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
On Fri, 2008-03-14 at 09:34 -0700, Randy Dunlap wrote:
> 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(),
> 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...
>
>
Sure, I'll do that..does kernel-doc actually work for macros?
Harvey
Harvey Harrison wrote:
> On Fri, 2008-03-14 at 09:34 -0700, Randy Dunlap wrote:
>> 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(),
>> 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...
>>
>>
>
> Sure, I'll do that..does kernel-doc actually work for macros?
Yes, it does.
--
~Randy
On Fri, 2008-03-14 at 09:49 -0700, Randy Dunlap wrote:
> Harvey Harrison wrote:
> > On Fri, 2008-03-14 at 09:34 -0700, Randy Dunlap wrote:
> >> 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
Harvey Harrison wrote:
> On Fri, 2008-03-14 at 09:49 -0700, Randy Dunlap wrote:
>> Harvey Harrison wrote:
>>> On Fri, 2008-03-14 at 09:34 -0700, Randy Dunlap wrote:
>>>> 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
they are of
> * 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
unsigned
> * 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.
--
~Randy