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/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)
 
 #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);
 {
        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) {
        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)
                return;
        }
 
        if (an > n)

-               BITMAP_WORD(bitmap, n) &= ~bitmap_bswap(headmask);
+               BITMAP_WORD(b, n) &= ~bitmap_bswap(headmask);

 
        if (am > an)
 
        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)
                       (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);
 {
        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) {
        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)
                return;
        }
 
        if (an > n)

-               BITMAP_WORD(bitmap, n) |= bitmap_bswap(headmask);
+               BITMAP_WORD(b, n) |= bitmap_bswap(headmask);

 
        if (am > an)
 
        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)
                       (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)
 }
 
 static int bitmap_clz(bitmap_word w)


@@ -76,7 +76,7 @@ static int bitmap_clz(bitmap_word w)
 #endif
 }
 
 #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);
                         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) {
        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);
 
 
                w &= (headmask & tailmask);
 


@@ -95,7 +95,7 @@ unsigned long bitmap_ffs(const bitmap *bitmap,
        }
 
        if (an > n) {
        }
 
        if (an > n) {

-               bitmap_word w = bitmap_bswap(BITMAP_WORD(bitmap, n));
+               bitmap_word w = bitmap_bswap(BITMAP_WORD(b, n));

 
                w &= headmask;
 
 
                w &= headmask;
 


@@ -104,7 +104,7 @@ unsigned long bitmap_ffs(const bitmap *bitmap,
        }
 
        while (an < am) {
        }
 
        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);
 
                if (w)
                        return an + bitmap_clz(w);


@@ -113,7 +113,7 @@ unsigned long bitmap_ffs(const bitmap *bitmap,
        }
 
        if (m > am) {
        }
 
        if (m > am) {

-               bitmap_word w = bitmap_bswap(BITMAP_WORD(bitmap, m));
+               bitmap_word w = bitmap_bswap(BITMAP_WORD(b, m));

 
                w &= tailmask;
 
 
                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))
 
 #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,
 }
 
 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;
 }
 
        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++) {
 {
        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) &&
                        return false;
        }
        if (BITMAP_HASTAIL(nbits) &&

-           (BITMAP_TAIL(bitmap, nbits) != BITMAP_TAILBITS(nbits)))
+           (BITMAP_TAIL(b, nbits) != BITMAP_TAILBITS(nbits)))

                return false;
 
        return true;
 }
 
                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++) {
 {
        unsigned long i;
 
        for (i = 0; i < BITMAP_HEADWORDS(nbits); i++) {

-               if (bitmap[i].w != 0)
+               if (b[i].w != 0)

                        return false;
        }
                        return false;
        }

-       if (BITMAP_HASTAIL(nbits) && (BITMAP_TAIL(bitmap, nbits) != 0))
+       if (BITMAP_HASTAIL(nbits) && (BITMAP_TAIL(b, nbits) != 0))

                return false;
 
        return true;
 }
 
                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
 
 /*
  * Allocation functions


@@ -221,26 +220,26 @@ static inline bitmap *bitmap_alloc1(unsigned long nbits)
        return bitmap;
 }
 
        return bitmap;
 }
 

-static inline bitmap *bitmap_realloc0(bitmap *bitmap,
+static inline bitmap *bitmap_realloc0(bitmap *b,

                                      unsigned long obits, unsigned long nbits)
 {
                                      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)
 {
                                      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_ */
 }
 
 #endif /* CCAN_BITMAP_H_ */