diffcore-rename.c: move code around to prepare for the next patch

No actual code changes, just move hash_filespec up and outdent part of
find_identical_files.

Signed-off-by: Karsten Blees <blees@dcon.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/diffcore-rename.c b/diffcore-rename.c
index 6c7a72fbe74e8dd6fca07d2555cdea62c16b8b1e..008a60c09dde780580c8eee7d2b08400a8c42b4d 100644 (file)
--- a/diffcore-rename.c
+++ b/diffcore-rename.c
@@ -248,6 +248,18 @@ struct file_similarity {
        struct file_similarity *next;
 };
 
        struct file_similarity *next;
 };
 

+static unsigned int hash_filespec(struct diff_filespec *filespec)
+{
+       unsigned int hash;
+       if (!filespec->sha1_valid) {
+               if (diff_populate_filespec(filespec, 0))
+                       return 0;
+               hash_sha1_file(filespec->data, filespec->size, "blob", filespec->sha1);
+       }
+       memcpy(&hash, filespec->sha1, sizeof(hash));
+       return hash;
+}
+

 static int find_identical_files(struct file_similarity *src,
                                struct file_similarity *dst,
                                struct diff_options *options)
 static int find_identical_files(struct file_similarity *src,
                                struct file_similarity *dst,
                                struct diff_options *options)


@@ -258,46 +270,46 @@ static int find_identical_files(struct file_similarity *src,
         * Walk over all the destinations ...
         */
        do {
         * Walk over all the destinations ...
         */
        do {

-               struct diff_filespec *target = dst->filespec;
-               struct file_similarity *p, *best;
-               int i = 100, best_score = -1;
-
-               /*
-                * .. to find the best source match
-                */
-               best = NULL;
-               for (p = src; p; p = p->next) {
-                       int score;
-                       struct diff_filespec *source = p->filespec;
-
-                       /* False hash collision? */
-                       if (hashcmp(source->sha1, target->sha1))
-                               continue;
-                       /* Non-regular files? If so, the modes must match! */
-                       if (!S_ISREG(source->mode) || !S_ISREG(target->mode)) {
-                               if (source->mode != target->mode)
-                                       continue;
-                       }
-                       /* Give higher scores to sources that haven't been used already */
-                       score = !source->rename_used;
-                       if (source->rename_used && options->detect_rename != DIFF_DETECT_COPY)
-                               continue;
-                       score += basename_same(source, target);
-                       if (score > best_score) {
-                               best = p;
-                               best_score = score;
-                               if (score == 2)
-                                       break;
-                       }
+       struct diff_filespec *target = dst->filespec;
+       struct file_similarity *p, *best;
+       int i = 100, best_score = -1;

 
 

-                       /* Too many identical alternatives? Pick one */
-                       if (!--i)
-                               break;
+       /*
+        * .. to find the best source match
+        */
+       best = NULL;
+       for (p = src; p; p = p->next) {
+               int score;
+               struct diff_filespec *source = p->filespec;
+
+               /* False hash collision? */
+               if (hashcmp(source->sha1, target->sha1))
+                       continue;
+               /* Non-regular files? If so, the modes must match! */
+               if (!S_ISREG(source->mode) || !S_ISREG(target->mode)) {
+                       if (source->mode != target->mode)
+                               continue;

                }
                }

-               if (best) {
-                       record_rename_pair(dst->index, best->index, MAX_SCORE);
-                       renames++;
+               /* Give higher scores to sources that haven't been used already */
+               score = !source->rename_used;
+               if (source->rename_used && options->detect_rename != DIFF_DETECT_COPY)
+                       continue;
+               score += basename_same(source, target);
+               if (score > best_score) {
+                       best = p;
+                       best_score = score;
+                       if (score == 2)
+                               break;

                }
                }

+
+               /* Too many identical alternatives? Pick one */
+               if (!--i)
+                       break;
+       }
+       if (best) {
+               record_rename_pair(dst->index, best->index, MAX_SCORE);
+               renames++;
+       }

        } while ((dst = dst->next) != NULL);
        return renames;
 }
        } while ((dst = dst->next) != NULL);
        return renames;
 }


@@ -343,18 +355,6 @@ static int find_same_files(void *ptr, void *data)
        return ret;
 }
 
        return ret;
 }
 

-static unsigned int hash_filespec(struct diff_filespec *filespec)
-{
-       unsigned int hash;
-       if (!filespec->sha1_valid) {
-               if (diff_populate_filespec(filespec, 0))
-                       return 0;
-               hash_sha1_file(filespec->data, filespec->size, "blob", filespec->sha1);
-       }
-       memcpy(&hash, filespec->sha1, sizeof(hash));
-       return hash;
-}
-

 static void insert_file_table(struct hash_table *table, int src_dst, int index, struct diff_filespec *filespec)
 {
        void **pos;
 static void insert_file_table(struct hash_table *table, int src_dst, int index, struct diff_filespec *filespec)
 {
        void **pos;