bitrotate: Use UINT*_MAX constants. Doc string improvement.

diff --git a/ChangeLog b/ChangeLog
index 3c7252160e2a1c3939cf9fba2043f33b838e5eb2..47bc08fbdbac04de95fa4cba71cade308ec2c7b8 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,12 @@
+2008-09-08  Simon Josefsson  <simon@josefsson.org>
+
+       * lib/bitrotate.h: Doc fix, mention that N can be wider than minimally
+       required for 16-bit and 8-bit rotates.
+       * lib/bitrotate.h (rotl64, rotr64, rotl32, rotl32, rotl16, rotr16,
+       rotl8, rotr8): Use UINT64_MAX, UINT32_MAX, UINT16_MAX, and
+       UINT8_MAX instead of hard-coded constants.  Suggested by Paul
+       Eggert.
+

 2008-09-07  Bruno Haible  <bruno@clisp.org>
 
        * tests/test-striconveh.c (main): Check behaviour when converting from
 2008-09-07  Bruno Haible  <bruno@clisp.org>
 
        * tests/test-striconveh.c (main): Check behaviour when converting from

diff --git a/lib/bitrotate.h b/lib/bitrotate.h
index 65bf682f9432ebc4772783a3dbe011502224e82d..d4911d0b2d83c2c0b6ee1c914673d04474a27598 100644 (file)
--- a/lib/bitrotate.h
+++ b/lib/bitrotate.h
@@ -28,7 +28,7 @@
 static inline uint64_t
 rotl64 (uint64_t x, int n)
 {
 static inline uint64_t
 rotl64 (uint64_t x, int n)
 {

-  return ((x << n) | (x >> (64 - n))) & 0xFFFFFFFFFFFFFFFFULL;
+  return ((x << n) | (x >> (64 - n))) & UINT64_MAX;

 }
 
 /* Given an unsigned 64-bit argument X, return the value corresponding
 }
 
 /* Given an unsigned 64-bit argument X, return the value corresponding


@@ -37,7 +37,7 @@ rotl64 (uint64_t x, int n)
 static inline uint64_t
 rotr64 (uint64_t x, int n)
 {
 static inline uint64_t
 rotr64 (uint64_t x, int n)
 {

-  return ((x >> n) | (x << (64 - n))) & 0xFFFFFFFFFFFFFFFFULL;
+  return ((x >> n) | (x << (64 - n))) & UINT64_MAX;

 }
 #endif
 
 }
 #endif
 


@@ -47,7 +47,7 @@ rotr64 (uint64_t x, int n)
 static inline uint32_t
 rotl32 (uint32_t x, int n)
 {
 static inline uint32_t
 rotl32 (uint32_t x, int n)
 {

-  return ((x << n) | (x >> (32 - n))) & 0xFFFFFFFF;
+  return ((x << n) | (x >> (32 - n))) & UINT32_MAX;

 }
 
 /* Given an unsigned 32-bit argument X, return the value corresponding
 }
 
 /* Given an unsigned 32-bit argument X, return the value corresponding


@@ -56,43 +56,51 @@ rotl32 (uint32_t x, int n)
 static inline uint32_t
 rotr32 (uint32_t x, int n)
 {
 static inline uint32_t
 rotr32 (uint32_t x, int n)
 {

-  return ((x >> n) | (x << (32 - n))) & 0xFFFFFFFF;
+  return ((x >> n) | (x << (32 - n))) & UINT32_MAX;

 }
 
 /* Given an unsigned 16-bit argument X, return the value corresponding
    to rotating the bits N steps to the left.  N must be between 1 to
 }
 
 /* Given an unsigned 16-bit argument X, return the value corresponding
    to rotating the bits N steps to the left.  N must be between 1 to

-   15 inclusive. */
+   15 inclusive, but on most relevant targets N can also be 0 and 16
+   because 'int' is at least 32 bits and the arguments must widen
+   before shifting. */

 static inline uint16_t
 rotl16 (uint16_t x, int n)
 {
 static inline uint16_t
 rotl16 (uint16_t x, int n)
 {

-  return ((x << n) | (x >> (16 - n))) & 0xFFFF;
+  return ((x << n) | (x >> (16 - n))) & UINT16_MAX;

 }
 
 /* Given an unsigned 16-bit argument X, return the value corresponding
    to rotating the bits N steps to the right.  N must be in 1 to 15
 }
 
 /* Given an unsigned 16-bit argument X, return the value corresponding
    to rotating the bits N steps to the right.  N must be in 1 to 15

-   inclusive. */
+   inclusive, but on most relevant targets N can also be 0 and 16
+   because 'int' is at least 32 bits and the arguments must widen
+   before shifting. */

 static inline uint16_t
 rotr16 (uint16_t x, int n)
 {
 static inline uint16_t
 rotr16 (uint16_t x, int n)
 {

-  return ((x >> n) | (x << (16 - n))) & 0xFFFF;
+  return ((x >> n) | (x << (16 - n))) & UINT16_MAX;

 }
 
 /* Given an unsigned 8-bit argument X, return the value corresponding
    to rotating the bits N steps to the left.  N must be between 1 to 7
 }
 
 /* Given an unsigned 8-bit argument X, return the value corresponding
    to rotating the bits N steps to the left.  N must be between 1 to 7

-   inclusive. */
+   inclusive, but on most relevant targets N can also be 0 and 8
+   because 'int' is at least 32 bits and the arguments must widen
+   before shifting. */

 static inline uint8_t
 rotl8 (uint8_t x, int n)
 {
 static inline uint8_t
 rotl8 (uint8_t x, int n)
 {

-  return ((x << n) | (x >> (8 - n))) & 0xFF;
+  return ((x << n) | (x >> (8 - n))) & UINT8_MAX;

 }
 
 /* Given an unsigned 8-bit argument X, return the value corresponding
    to rotating the bits N steps to the right.  N must be in 1 to 7
 }
 
 /* Given an unsigned 8-bit argument X, return the value corresponding
    to rotating the bits N steps to the right.  N must be in 1 to 7

-   inclusive. */
+   inclusive, but on most relevant targets N can also be 0 and 8
+   because 'int' is at least 32 bits and the arguments must widen
+   before shifting. */

 static inline uint8_t
 rotr8 (uint8_t x, int n)
 {
 static inline uint8_t
 rotr8 (uint8_t x, int n)
 {

-  return ((x >> n) | (x << (8 - n))) & 0xFF;
+  return ((x >> n) | (x << (8 - n))) & UINT8_MAX;

 }
 
 #endif /* _GL_BITROTATE_H */
 }
 
 #endif /* _GL_BITROTATE_H */