diffcore-rename: refactor "too many candidates" logic

Move the logic to a separate function, to be enhanced by later patches in
the series.

While at it, swap the condition used in the if statement from "if it is
too big then do this" to "if it would fit then do this".

Signed-off-by: Junio C Hamano <gitster@pobox.com>
---

Rebased to 'master' as the logic to use the result of this logic was
updated recently, together with the addition of eye-candy.

diff --git a/diffcore-rename.c b/diffcore-rename.c
index d40e40a3ac9c919475d6157464fa906e37b0dd80..00f7f8428f18153c74c0c4d7abc4977bdc3ddeda 100644 (file)
--- a/diffcore-rename.c
+++ b/diffcore-rename.c
@@ -419,6 +419,34 @@ static void record_if_better(struct diff_score m[], struct diff_score *o)
                m[worst] = *o;
 }
 
                m[worst] = *o;
 }
 

+static int too_many_rename_candidates(int num_create,
+                                     struct diff_options *options)
+{
+       int rename_limit = options->rename_limit;
+       int num_src = rename_src_nr;
+
+       options->needed_rename_limit = 0;
+
+       /*
+        * This basically does a test for the rename matrix not
+        * growing larger than a "rename_limit" square matrix, ie:
+        *
+        *    num_create * num_src > rename_limit * rename_limit
+        *
+        * but handles the potential overflow case specially (and we
+        * assume at least 32-bit integers)
+        */
+       if (rename_limit <= 0 || rename_limit > 32767)
+               rename_limit = 32767;
+       if ((num_create <= rename_limit || num_src <= rename_limit) &&
+           (num_create * num_src <= rename_limit * rename_limit))
+               return 0;
+
+       options->needed_rename_limit =
+               num_src > num_create ? num_src : num_create;
+       return 1;
+}
+

 static int find_renames(struct diff_score *mx, int dst_cnt, int minimum_score, int copies)
 {
        int count = 0, i;
 static int find_renames(struct diff_score *mx, int dst_cnt, int minimum_score, int copies)
 {
        int count = 0, i;


@@ -444,7 +472,6 @@ void diffcore_rename(struct diff_options *options)
 {
        int detect_rename = options->detect_rename;
        int minimum_score = options->rename_score;
 {
        int detect_rename = options->detect_rename;
        int minimum_score = options->rename_score;

-       int rename_limit = options->rename_limit;

        struct diff_queue_struct *q = &diff_queued_diff;
        struct diff_queue_struct outq;
        struct diff_score *mx;
        struct diff_queue_struct *q = &diff_queued_diff;
        struct diff_queue_struct outq;
        struct diff_score *mx;


@@ -511,24 +538,8 @@ void diffcore_rename(struct diff_options *options)
        if (!num_create)
                goto cleanup;
 
        if (!num_create)
                goto cleanup;
 

-       /*
-        * This basically does a test for the rename matrix not
-        * growing larger than a "rename_limit" square matrix, ie:
-        *
-        *    num_create * num_src > rename_limit * rename_limit
-        *
-        * but handles the potential overflow case specially (and we
-        * assume at least 32-bit integers)
-        */
-       options->needed_rename_limit = 0;
-       if (rename_limit <= 0 || rename_limit > 32767)
-               rename_limit = 32767;
-       if ((num_create > rename_limit && num_src > rename_limit) ||
-           (num_create * num_src > rename_limit * rename_limit)) {
-               options->needed_rename_limit =
-                       num_src > num_create ? num_src : num_create;
+       if (too_many_rename_candidates(num_create, options))

                goto cleanup;
                goto cleanup;

-       }

 
        if (options->show_rename_progress) {
                progress = start_progress_delay(
 
        if (options->show_rename_progress) {
                progress = start_progress_delay(