[PATCH 024/238] [misc.] bcache.c: -Wshadow fix

Andrey Smirnov
2011-11-28T15:07:16Z

Cause:
`bcache' function from "bcache.h"

To ChangeLog:
* bcache.c (bcache_full): Rename `bcache' to `cache'(-Wshadow).
---
gdb/ChangeLog | 5 +++++
gdb/bcache.c | 36 ++++++++++++++++++------------------
2 files changed, 23 insertions(+), 18 deletions(-)

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 431e4f6..f23767c 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,10 @@
2011-11-22 Andrey Smirnov <andrew.smirnov@gmail.com>

+ * bcache.c (bcache_full): Fix -Wshadow
+ warnings.
+
+2011-11-22 Andrey Smirnov <andrew.smirnov@gmail.com>
+
* bcache.c (bcache): Fix -Wshadow
warnings.

diff --git a/gdb/bcache.c b/gdb/bcache.c
index 035ed22..6e51cf2 100644
--- a/gdb/bcache.c
+++ b/gdb/bcache.c
@@ -221,7 +221,7 @@ bcache (const void *addr, int length, struct bcache *cache)
returning an old entry. */

const void *
-bcache_full (const void *addr, int length, struct bcache *bcache, int *added)
+bcache_full (const void *addr, int length, struct bcache *cache, int *added)
{
unsigned long full_hash;
unsigned short half_hash;
@@ -233,55 +233,55 @@ bcache_full (const void *addr, int length, struct bcache *bcache, int *added)

/* Lazily initialize the obstack. This can save quite a bit of
memory in some cases. */
- if (bcache->total_count == 0)
+ if (cache->total_count == 0)
{
/* We could use obstack_specify_allocation here instead, but
gdb_obstack.h specifies the allocation/deallocation
functions. */
- obstack_init (&bcache->cache);
+ obstack_init (&cache->cache);
}

/* If our average chain length is too high, expand the hash table. */
- if (bcache->unique_count >= bcache->num_buckets * CHAIN_LENGTH_THRESHOLD)
- expand_hash_table (bcache);
+ if (cache->unique_count >= cache->num_buckets * CHAIN_LENGTH_THRESHOLD)
+ expand_hash_table (cache);

- bcache->total_count++;
- bcache->total_size += length;
+ cache->total_count++;
+ cache->total_size += length;

- full_hash = bcache->hash_function (addr, length);
+ full_hash = cache->hash_function (addr, length);

half_hash = (full_hash >> 16);
- hash_index = full_hash % bcache->num_buckets;
+ hash_index = full_hash % cache->num_buckets;

/* Search the hash bucket for a string identical to the caller's.
As a short-circuit first compare the upper part of each hash
values. */
- for (s = bcache->bucket[hash_index]; s; s = s->next)
+ for (s = cache->bucket[hash_index]; s; s = s->next)
{
if (s->half_hash == half_hash)
{
if (s->length == length
- && bcache->compare_function (&s->d.data, addr, length))
+ && cache->compare_function (&s->d.data, addr, length))
return &s->d.data;
else
- bcache->half_hash_miss_count++;
+ cache->half_hash_miss_count++;
}
}

/* The user's string isn't in the list. Insert it after *ps. */
{
struct bstring *new
- = obstack_alloc (&bcache->cache, BSTRING_SIZE (length));
+ = obstack_alloc (&cache->cache, BSTRING_SIZE (length));

memcpy (&new->d.data, addr, length);
new->length = length;
- new->next = bcache->bucket[hash_index];
+ new->next = cache->bucket[hash_index];
new->half_hash = half_hash;
- bcache->bucket[hash_index] = new;
+ cache->bucket[hash_index] = new;

- bcache->unique_count++;
- bcache->unique_size += length;
- bcache->structure_size += BSTRING_SIZE (length);
+ cache->unique_count++;
+ cache->unique_size += length;
+ cache->structure_size += BSTRING_SIZE (length);

if (added)
*added = 1;
--
1.7.5.4