[PATCH 01/10] Add macros similar to min/max/min_t/max_t.

[PATCH 01/10] Add macros similar to min/max/min_t/max_t.

[Harvey Harrison]

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.

[akpm@linux-foundation.org: coding-style fixes]
[akpm@linux-foundation.org: fix v4l build]
Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
Cc: Mauro Carvalho Chehab <mchehab@infradead.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
---
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

Re: [PATCH 01/10] Add macros similar to min/max/min_t/max_t.

[Randy Dunlap]

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

Re: [PATCH 01/10] Add macros similar to min/max/min_t/max_t.

[Harvey Harrison]

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

Re: [PATCH 01/10] Add macros similar to min/max/min_t/max_t.

[Randy Dunlap]

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

Re: [PATCH 01/10] Add macros similar to min/max/min_t/max_t.

[Harvey Harrison]

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

Re: [PATCH 01/10] Add macros similar to min/max/min_t/max_t.

[Randy Dunlap]

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