[PATCH] diff.c: locate_size_cache() fix.

This fixes two bugs.

- declaration of auto variable "cmp" was preceeded by a
statement, causing compilation error on real C compilers;
noticed and patch given by Yoichi Yuasa.

- the function's calling convention was overloading its size
parameter to mean "largest possible value means do not add
entry", which was a bad taste.  Brought up during a
discussion with Peter Baudis.

Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/diff.c b/diff.c
index 315eb5c26ac347a54ff0a4013ad40844ecf2812e..ab77b4bfedace3ef75fb3984542638d1fe3e3105 100644 (file)
--- a/diff.c
+++ b/diff.c
@@ -236,6 +236,7 @@ static struct sha1_size_cache {
 static int sha1_size_cache_nr, sha1_size_cache_alloc;
 
 static struct sha1_size_cache *locate_size_cache(unsigned char *sha1,
 static int sha1_size_cache_nr, sha1_size_cache_alloc;
 
 static struct sha1_size_cache *locate_size_cache(unsigned char *sha1,

+                                                int find_only,

                                                 unsigned long size)
 {
        int first, last;
                                                 unsigned long size)
 {
        int first, last;


@@ -244,9 +245,9 @@ static struct sha1_size_cache *locate_size_cache(unsigned char *sha1,
        first = 0;
        last = sha1_size_cache_nr;
        while (last > first) {
        first = 0;
        last = sha1_size_cache_nr;
        while (last > first) {

-               int next = (last + first) >> 1;
+               int cmp, next = (last + first) >> 1;

                e = sha1_size_cache[next];
                e = sha1_size_cache[next];

-               int cmp = memcmp(e->sha1, sha1, 20);
+               cmp = memcmp(e->sha1, sha1, 20);

                if (!cmp)
                        return e;
                if (cmp < 0) {
                if (!cmp)
                        return e;
                if (cmp < 0) {


@@ -256,7 +257,7 @@ static struct sha1_size_cache *locate_size_cache(unsigned char *sha1,
                first = next+1;
        }
        /* not found */
                first = next+1;
        }
        /* not found */

-       if (size == UINT_MAX)
+       if (find_only)

                return NULL;
        /* insert to make it at "first" */
        if (sha1_size_cache_alloc <= sha1_size_cache_nr) {
                return NULL;
        /* insert to make it at "first" */
        if (sha1_size_cache_alloc <= sha1_size_cache_nr) {


@@ -337,13 +338,13 @@ int diff_populate_filespec(struct diff_filespec *s, int size_only)
                struct sha1_size_cache *e;
 
                if (size_only) {
                struct sha1_size_cache *e;
 
                if (size_only) {

-                       e = locate_size_cache(s->sha1, UINT_MAX);
+                       e = locate_size_cache(s->sha1, 1, 0);

                        if (e) {
                                s->size = e->size;
                                return 0;
                        }
                        if (!sha1_file_size(s->sha1, &s->size))
                        if (e) {
                                s->size = e->size;
                                return 0;
                        }
                        if (!sha1_file_size(s->sha1, &s->size))

-                               locate_size_cache(s->sha1, s->size);
+                               locate_size_cache(s->sha1, 0, s->size);

                }
                else {
                        s->data = read_sha1_file(s->sha1, type, &s->size);
                }
                else {
                        s->data = read_sha1_file(s->sha1, type, &s->size);