From 65416758cd83772f2f3c69f1bd1f501608e64745 Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Tue, 28 Feb 2006 16:01:36 -0800 Subject: [PATCH] diffcore-rename: split out the delta counting code. This is to rework diffcore break/rename/copy detection code so that it does not affected when deltifier code gets improved. Signed-off-by: Junio C Hamano --- Makefile | 3 ++- diffcore-break.c | 21 +++++---------------- diffcore-delta.c | 43 +++++++++++++++++++++++++++++++++++++++++++ diffcore-rename.c | 28 +++++----------------------- diffcore.h | 6 ++++++ 5 files changed, 61 insertions(+), 40 deletions(-) create mode 100644 diffcore-delta.c diff --git a/Makefile b/Makefile index 19578fc93a..a5eb0c4beb 100644 --- a/Makefile +++ b/Makefile @@ -196,7 +196,8 @@ LIB_H = \ DIFF_OBJS = \ diff.o diffcore-break.o diffcore-order.o diffcore-pathspec.o \ - diffcore-pickaxe.o diffcore-rename.o tree-diff.o combine-diff.o + diffcore-pickaxe.o diffcore-rename.o tree-diff.o combine-diff.o \ + diffcore-delta.o LIB_OBJS = \ blob.o commit.o connect.o count-delta.o csum-file.o \ diff --git a/diffcore-break.c b/diffcore-break.c index 95b5eb492e..0fc2b860be 100644 --- a/diffcore-break.c +++ b/diffcore-break.c @@ -4,8 +4,6 @@ #include "cache.h" #include "diff.h" #include "diffcore.h" -#include "delta.h" -#include "count-delta.h" static int should_break(struct diff_filespec *src, struct diff_filespec *dst, @@ -47,7 +45,6 @@ static int should_break(struct diff_filespec *src, * The value we return is 1 if we want the pair to be broken, * or 0 if we do not. */ - void *delta; unsigned long delta_size, base_size, src_copied, literal_added; int to_break = 0; @@ -69,19 +66,11 @@ static int should_break(struct diff_filespec *src, if (base_size < MINIMUM_BREAK_SIZE) return 0; /* we do not break too small filepair */ - delta = diff_delta(src->data, src->size, - dst->data, dst->size, - &delta_size, 0); - if (!delta) - return 0; /* error but caught downstream */ - - /* Estimate the edit size by interpreting delta. */ - if (count_delta(delta, delta_size, - &src_copied, &literal_added)) { - free(delta); - return 0; /* we cannot tell */ - } - free(delta); + if (diffcore_count_changes(src->data, src->size, + dst->data, dst->size, + 0, + &src_copied, &literal_added)) + return 0; /* Compute merge-score, which is "how much is removed * from the source material". The clean-up stage will diff --git a/diffcore-delta.c b/diffcore-delta.c new file mode 100644 index 0000000000..1e6a6911ec --- /dev/null +++ b/diffcore-delta.c @@ -0,0 +1,43 @@ +#include "cache.h" +#include "diff.h" +#include "diffcore.h" +#include "delta.h" +#include "count-delta.h" + +static int diffcore_count_changes_1(void *src, unsigned long src_size, + void *dst, unsigned long dst_size, + unsigned long delta_limit, + unsigned long *src_copied, + unsigned long *literal_added) +{ + void *delta; + unsigned long delta_size; + + delta = diff_delta(src, src_size, + dst, dst_size, + &delta_size, delta_limit); + if (!delta) + /* If delta_limit is exceeded, we have too much differences */ + return -1; + + /* Estimate the edit size by interpreting delta. */ + if (count_delta(delta, delta_size, src_copied, literal_added)) { + free(delta); + return -1; + } + free(delta); + return 0; +} + +int diffcore_count_changes(void *src, unsigned long src_size, + void *dst, unsigned long dst_size, + unsigned long delta_limit, + unsigned long *src_copied, + unsigned long *literal_added) +{ + return diffcore_count_changes_1(src, src_size, + dst, dst_size, + delta_limit, + src_copied, + literal_added); +} diff --git a/diffcore-rename.c b/diffcore-rename.c index ffd126af0d..55cf1c37f3 100644 --- a/diffcore-rename.c +++ b/diffcore-rename.c @@ -4,8 +4,6 @@ #include "cache.h" #include "diff.h" #include "diffcore.h" -#include "delta.h" -#include "count-delta.h" /* Table of rename/copy destinations */ @@ -135,7 +133,6 @@ static int estimate_similarity(struct diff_filespec *src, * match than anything else; the destination does not even * call into this function in that case. */ - void *delta; unsigned long delta_size, base_size, src_copied, literal_added; unsigned long delta_limit; int score; @@ -165,29 +162,14 @@ static int estimate_similarity(struct diff_filespec *src, if (diff_populate_filespec(src, 0) || diff_populate_filespec(dst, 0)) return 0; /* error but caught downstream */ + delta_limit = base_size * (MAX_SCORE-minimum_score) / MAX_SCORE; - delta = diff_delta(src->data, src->size, - dst->data, dst->size, - &delta_size, delta_limit); - if (!delta) - /* If delta_limit is exceeded, we have too much differences */ + if (diffcore_count_changes(src->data, src->size, + dst->data, dst->size, + delta_limit, + &src_copied, &literal_added)) return 0; - /* A delta that has a lot of literal additions would have - * big delta_size no matter what else it does. - */ - if (base_size * (MAX_SCORE-minimum_score) < delta_size * MAX_SCORE) { - free(delta); - return 0; - } - - /* Estimate the edit size by interpreting delta. */ - if (count_delta(delta, delta_size, &src_copied, &literal_added)) { - free(delta); - return 0; - } - free(delta); - /* Extent of damage */ if (src->size + literal_added < src_copied) delta_size = 0; diff --git a/diffcore.h b/diffcore.h index 12cd816591..dba4f17658 100644 --- a/diffcore.h +++ b/diffcore.h @@ -101,4 +101,10 @@ void diff_debug_queue(const char *, struct diff_queue_struct *); #define diff_debug_queue(a,b) do {} while(0) #endif +extern int diffcore_count_changes(void *src, unsigned long src_size, + void *dst, unsigned long dst_size, + unsigned long delta_limit, + unsigned long *src_copied, + unsigned long *literal_added); + #endif