mirror/git
1
0
Fork 0
mirror of https://github.com/git/git.git synced 2024-09-28 11:11:18 +02:00
Code

diffcore-rename: avoid usage of global in too_many_rename_candidates()

Browse Source 
too_many_rename_candidates() got the number of rename destinations via
an argument to the function, but the number of rename sources via a
global variable.  That felt rather inconsistent.  Pass in the number of
rename sources as an argument as well.

While we are at it... We had a local variable, num_src, that served two
purposes.  Initially it was set to the global value, but later was used
for counting a subset of the number of sources.  Since we now have a
function argument for the former usage, introduce a clearer variable
name for the latter usage.

This patch has no behavioral changes; it's just renaming and passing an
argument instead of grabbing it from the global namespace.  (You may
find it easier to view the patch using git diff's --color-words option.)

Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Elijah Newren 2020-12-11 09:08:41 +00:00 committed by Junio C Hamano
parent 26a66a6b1c
commit 00b8cccdd8
1 changed files with 12 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
diffcore-rename.c
View File

@ -434,12 +434,11 @@ static void record_if_better(struct diff_score m[], struct diff_score *o)
* 1 if we need to disable inexact rename detection;
* 2 if we would be under the limit if we were given -C instead of -C -C.
*/
static int too_many_rename_candidates(int num_destinations,
static int too_many_rename_candidates(int num_destinations, int num_sources,
struct diff_options *options)
{
int rename_limit = options->rename_limit;
int num_src = rename_src_nr;
int i;
int i, limited_sources;
options->needed_rename_limit = 0;
@ -447,30 +446,30 @@ static int too_many_rename_candidates(int num_destinations,
* This basically does a test for the rename matrix not
* growing larger than a "rename_limit" square matrix, ie:
*
* num_destinations * num_src > rename_limit * rename_limit
* num_destinations * num_sources > rename_limit * rename_limit
*/
if (rename_limit <= 0)
rename_limit = 32767;
if ((num_destinations <= rename_limit || num_src <= rename_limit) &&
((uint64_t)num_destinations * (uint64_t)num_src
if ((num_destinations <= rename_limit || num_sources <= rename_limit) &&
((uint64_t)num_destinations * (uint64_t)num_sources
<= (uint64_t)rename_limit * (uint64_t)rename_limit))
return 0;
options->needed_rename_limit =
num_src > num_destinations ? num_src : num_destinations;
num_sources > num_destinations ? num_sources : num_destinations;
/* Are we running under -C -C? */
if (!options->flags.find_copies_harder)
return 1;
/* Would we bust the limit if we were running under -C? */
for (num_src = i = 0; i < rename_src_nr; i++) {
for (limited_sources = i = 0; i < num_sources; i++) {
if (diff_unmodified_pair(rename_src[i].p))
continue;
num_src++;
limited_sources++;
}
if ((num_destinations <= rename_limit || num_src <= rename_limit) &&
((uint64_t)num_destinations * (uint64_t)num_src
if ((num_destinations <= rename_limit || limited_sources <= rename_limit) &&
((uint64_t)num_destinations * (uint64_t)limited_sources
<= (uint64_t)rename_limit * (uint64_t)rename_limit))
return 2;
return 1;
@ -576,7 +575,8 @@ void diffcore_rename(struct diff_options *options)
if (!num_destinations)
goto cleanup;
switch (too_many_rename_candidates(num_destinations, options)) {
switch (too_many_rename_candidates(num_destinations, rename_src_nr,
options)) {
case 1:
goto cleanup;
case 2: