bitmap: Avoid shadowing type name with parameter name

'bitmap' is a typedef name in this module, and we also use it as a
parameter name in a bunch of places.  Although that's possible, because
types and variables live in different namespaces, it's probably not that
wise.  It also appears to trip warnings with at least some options and
compiler versions.

Reported-by: Ashok Raj <ashok.raj@intel.com>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>

diff --git a/ccan/base64/base64.c b/ccan/base64/base64.c
index b2326293a992b45d011999a5211b4fc9fa54634e..c28e0da2a496dcbdd09abf7688caf5bbc37e117d 100644 (file)
--- a/ccan/base64/base64.c
+++ b/ccan/base64/base64.c
@@ -31,7 +31,7 @@ static int8_t sixbit_from_b64(const base64_maps_t *maps,
        int8_t ret;
 
        ret = maps->decode_map[(unsigned char)b64letter];
-       if (ret == (char)0xff) {
+       if (ret == '\xff') {
                errno = EDOM;
                return -1;
        }
@@ -41,7 +41,7 @@ static int8_t sixbit_from_b64(const base64_maps_t *maps,
 
 bool base64_char_in_alphabet(const base64_maps_t *maps, const char b64char)
 {
-       return (maps->decode_map[(const unsigned char)b64char] != (char)0xff);
+       return (maps->decode_map[(const unsigned char)b64char] != '\xff');
 }
 
 void base64_init_maps(base64_maps_t *dest, const char src[64])

diff --git a/ccan/bitmap/bitmap.c b/ccan/bitmap/bitmap.c
index d254b20e561ea804f456f777034c892d957e8cfd..ccc0cd21efa7247d3993dfb956b49608520019b7 100644 (file)
--- a/ccan/bitmap/bitmap.c
+++ b/ccan/bitmap/bitmap.c
@@ -9,7 +9,7 @@
 #define BIT_ALIGN_DOWN(n)      ((n) & ~(BITMAP_WORD_BITS - 1))
 #define BIT_ALIGN_UP(n)                BIT_ALIGN_DOWN((n) + BITMAP_WORD_BITS - 1)
 
-void bitmap_zero_range(bitmap *bitmap, unsigned long n, unsigned long m)
+void bitmap_zero_range(bitmap *b, unsigned long n, unsigned long m)
 {
        unsigned long an = BIT_ALIGN_UP(n);
        unsigned long am = BIT_ALIGN_DOWN(m);
@@ -19,22 +19,22 @@ void bitmap_zero_range(bitmap *bitmap, unsigned long n, unsigned long m)
        assert(m >= n);
 
        if (am < an) {
-               BITMAP_WORD(bitmap, n) &= ~bitmap_bswap(headmask & tailmask);
+               BITMAP_WORD(b, n) &= ~bitmap_bswap(headmask & tailmask);
                return;
        }
 
        if (an > n)
-               BITMAP_WORD(bitmap, n) &= ~bitmap_bswap(headmask);
+               BITMAP_WORD(b, n) &= ~bitmap_bswap(headmask);
 
        if (am > an)
-               memset(&BITMAP_WORD(bitmap, an), 0,
+               memset(&BITMAP_WORD(b, an), 0,
                       (am - an) / BITMAP_WORD_BITS * sizeof(bitmap_word));
 
        if (m > am)
-               BITMAP_WORD(bitmap, m) &= ~bitmap_bswap(tailmask);
+               BITMAP_WORD(b, m) &= ~bitmap_bswap(tailmask);
 }
 
-void bitmap_fill_range(bitmap *bitmap, unsigned long n, unsigned long m)
+void bitmap_fill_range(bitmap *b, unsigned long n, unsigned long m)
 {
        unsigned long an = BIT_ALIGN_UP(n);
        unsigned long am = BIT_ALIGN_DOWN(m);
@@ -44,19 +44,19 @@ void bitmap_fill_range(bitmap *bitmap, unsigned long n, unsigned long m)
        assert(m >= n);
 
        if (am < an) {
-               BITMAP_WORD(bitmap, n) |= bitmap_bswap(headmask & tailmask);
+               BITMAP_WORD(b, n) |= bitmap_bswap(headmask & tailmask);
                return;
        }
 
        if (an > n)
-               BITMAP_WORD(bitmap, n) |= bitmap_bswap(headmask);
+               BITMAP_WORD(b, n) |= bitmap_bswap(headmask);
 
        if (am > an)
-               memset(&BITMAP_WORD(bitmap, an), 0xff,
+               memset(&BITMAP_WORD(b, an), 0xff,
                       (am - an) / BITMAP_WORD_BITS * sizeof(bitmap_word));
 
        if (m > am)
-               BITMAP_WORD(bitmap, m) |= bitmap_bswap(tailmask);
+               BITMAP_WORD(b, m) |= bitmap_bswap(tailmask);
 }
 
 static int bitmap_clz(bitmap_word w)
@@ -76,7 +76,7 @@ static int bitmap_clz(bitmap_word w)
 #endif
 }
 
-unsigned long bitmap_ffs(const bitmap *bitmap,
+unsigned long bitmap_ffs(const bitmap *b,
                         unsigned long n, unsigned long m)
 {
        unsigned long an = BIT_ALIGN_UP(n);
@@ -87,7 +87,7 @@ unsigned long bitmap_ffs(const bitmap *bitmap,
        assert(m >= n);
 
        if (am < an) {
-               bitmap_word w = bitmap_bswap(BITMAP_WORD(bitmap, n));
+               bitmap_word w = bitmap_bswap(BITMAP_WORD(b, n));
 
                w &= (headmask & tailmask);
 
@@ -95,7 +95,7 @@ unsigned long bitmap_ffs(const bitmap *bitmap,
        }
 
        if (an > n) {
-               bitmap_word w = bitmap_bswap(BITMAP_WORD(bitmap, n));
+               bitmap_word w = bitmap_bswap(BITMAP_WORD(b, n));
 
                w &= headmask;
 
@@ -104,7 +104,7 @@ unsigned long bitmap_ffs(const bitmap *bitmap,
        }
 
        while (an < am) {
-               bitmap_word w = bitmap_bswap(BITMAP_WORD(bitmap, an));
+               bitmap_word w = bitmap_bswap(BITMAP_WORD(b, an));
 
                if (w)
                        return an + bitmap_clz(w);
@@ -113,7 +113,7 @@ unsigned long bitmap_ffs(const bitmap *bitmap,
        }
 
        if (m > am) {
-               bitmap_word w = bitmap_bswap(BITMAP_WORD(bitmap, m));
+               bitmap_word w = bitmap_bswap(BITMAP_WORD(b, m));
 
                w &= tailmask;
 

diff --git a/ccan/bitmap/bitmap.h b/ccan/bitmap/bitmap.h
index 543828010188aa39490005ebe53dcaba3b52c1a5..e1bf4bb761d236d63df247769f4d0239098c5657 100644 (file)
--- a/ccan/bitmap/bitmap.h
+++ b/ccan/bitmap/bitmap.h
@@ -58,37 +58,37 @@ static inline bitmap_word bitmap_bswap(bitmap_word w)
 #define BITMAP_TAIL(_bm, _nbits) \
        (BITMAP_TAILWORD(_bm, _nbits) & BITMAP_TAILBITS(_nbits))
 
-static inline void bitmap_set_bit(bitmap *bitmap, unsigned long n)
+static inline void bitmap_set_bit(bitmap *b, unsigned long n)
 {
-       BITMAP_WORD(bitmap, n) |= BITMAP_WORDBIT(n);
+       BITMAP_WORD(b, n) |= BITMAP_WORDBIT(n);
 }
 
-static inline void bitmap_clear_bit(bitmap *bitmap, unsigned long n)
+static inline void bitmap_clear_bit(bitmap *b, unsigned long n)
 {
-       BITMAP_WORD(bitmap, n) &= ~BITMAP_WORDBIT(n);
+       BITMAP_WORD(b, n) &= ~BITMAP_WORDBIT(n);
 }
 
-static inline void bitmap_change_bit(bitmap *bitmap, unsigned long n)
+static inline void bitmap_change_bit(bitmap *b, unsigned long n)
 {
-       BITMAP_WORD(bitmap, n) ^= BITMAP_WORDBIT(n);
+       BITMAP_WORD(b, n) ^= BITMAP_WORDBIT(n);
 }
 
-static inline bool bitmap_test_bit(const bitmap *bitmap, unsigned long n)
+static inline bool bitmap_test_bit(const bitmap *b, unsigned long n)
 {
-       return !!(BITMAP_WORD(bitmap, n) & BITMAP_WORDBIT(n));
+       return !!(BITMAP_WORD(b, n) & BITMAP_WORDBIT(n));
 }
 
-void bitmap_zero_range(bitmap *bitmap, unsigned long n, unsigned long m);
-void bitmap_fill_range(bitmap *bitmap, unsigned long n, unsigned long m);
+void bitmap_zero_range(bitmap *b, unsigned long n, unsigned long m);
+void bitmap_fill_range(bitmap *b, unsigned long n, unsigned long m);
 
-static inline void bitmap_zero(bitmap *bitmap, unsigned long nbits)
+static inline void bitmap_zero(bitmap *b, unsigned long nbits)
 {
-       memset(bitmap, 0, bitmap_sizeof(nbits));
+       memset(b, 0, bitmap_sizeof(nbits));
 }
 
-static inline void bitmap_fill(bitmap *bitmap, unsigned long nbits)
+static inline void bitmap_fill(bitmap *b, unsigned long nbits)
 {
-       memset(bitmap, 0xff, bitmap_sizeof(nbits));
+       memset(b, 0xff, bitmap_sizeof(nbits));
 }
 
 static inline void bitmap_copy(bitmap *dst, const bitmap *src,
@@ -161,37 +161,36 @@ static inline bool bitmap_subset(const bitmap *src1, const bitmap *src2,
        return true;
 }
 
-static inline bool bitmap_full(const bitmap *bitmap, unsigned long nbits)
+static inline bool bitmap_full(const bitmap *b, unsigned long nbits)
 {
        unsigned long i;
 
        for (i = 0; i < BITMAP_HEADWORDS(nbits); i++) {
-               if (bitmap[i].w != -1UL)
+               if (b[i].w != -1UL)
                        return false;
        }
        if (BITMAP_HASTAIL(nbits) &&
-           (BITMAP_TAIL(bitmap, nbits) != BITMAP_TAILBITS(nbits)))
+           (BITMAP_TAIL(b, nbits) != BITMAP_TAILBITS(nbits)))
                return false;
 
        return true;
 }
 
-static inline bool bitmap_empty(const bitmap *bitmap, unsigned long nbits)
+static inline bool bitmap_empty(const bitmap *b, unsigned long nbits)
 {
        unsigned long i;
 
        for (i = 0; i < BITMAP_HEADWORDS(nbits); i++) {
-               if (bitmap[i].w != 0)
+               if (b[i].w != 0)
                        return false;
        }
-       if (BITMAP_HASTAIL(nbits) && (BITMAP_TAIL(bitmap, nbits) != 0))
+       if (BITMAP_HASTAIL(nbits) && (BITMAP_TAIL(b, nbits) != 0))
                return false;
 
        return true;
 }
 
-unsigned long bitmap_ffs(const bitmap *bitmap,
-                        unsigned long n, unsigned long m);
+unsigned long bitmap_ffs(const bitmap *b, unsigned long n, unsigned long m);
 
 /*
  * Allocation functions
@@ -221,26 +220,26 @@ static inline bitmap *bitmap_alloc1(unsigned long nbits)
        return bitmap;
 }
 
-static inline bitmap *bitmap_realloc0(bitmap *bitmap,
+static inline bitmap *bitmap_realloc0(bitmap *b,
                                      unsigned long obits, unsigned long nbits)
 {
-       bitmap = realloc(bitmap, bitmap_sizeof(nbits));
+       b = realloc(b, bitmap_sizeof(nbits));
 
-       if ((nbits > obits) && bitmap)
-               bitmap_zero_range(bitmap, obits, nbits);
+       if ((nbits > obits) && b)
+               bitmap_zero_range(b, obits, nbits);
 
-       return bitmap;
+       return b;
 }
 
-static inline bitmap *bitmap_realloc1(bitmap *bitmap,
+static inline bitmap *bitmap_realloc1(bitmap *b,
                                      unsigned long obits, unsigned long nbits)
 {
-       bitmap = realloc(bitmap, bitmap_sizeof(nbits));
+       b = realloc(b, bitmap_sizeof(nbits));
 
-       if ((nbits > obits) && bitmap)
-               bitmap_fill_range(bitmap, obits, nbits);
+       if ((nbits > obits) && b)
+               bitmap_fill_range(b, obits, nbits);
 
-       return bitmap;
+       return b;
 }
 
 #endif /* CCAN_BITMAP_H_ */