@matheusbsbs / matheus-bagliano / commits / 65416758cd
Fork 0

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 <junkio@cox.net>

Junio C Hamano committed Feb 28, 2006 at 16:01 UTC 65416758cd83772f2f3c69f1bd1f501608e64745
5 files changed +61 -40
Makefile
+2 -1
@@ -196,7 +196,8 @@ LIB_H = \
196
197 DIFF_OBJS = \
198 diff.o diffcore-break.o diffcore-order.o diffcore-pathspec.o \
199 - diffcore-pickaxe.o diffcore-rename.o tree-diff.o combine-diff.o
199 + diffcore-pickaxe.o diffcore-rename.o tree-diff.o combine-diff.o \
200 + diffcore-delta.o
201
202 LIB_OBJS = \
203 blob.o commit.o connect.o count-delta.o csum-file.o \
diffcore-break.c
+5 -16
@@ -4,8 +4,6 @@
4 #include "cache.h"
5 #include "diff.h"
6 #include "diffcore.h"
7 -#include "delta.h"
8 -#include "count-delta.h"
7
8 static int should_break(struct diff_filespec *src,
9 struct diff_filespec *dst,
@@ -47,7 +45,6 @@ static int should_break(struct diff_filespec *src,
45 * The value we return is 1 if we want the pair to be broken,
46 * or 0 if we do not.
47 */
50 - void *delta;
48 unsigned long delta_size, base_size, src_copied, literal_added;
49 int to_break = 0;
50
@@ -69,19 +66,11 @@ static int should_break(struct diff_filespec *src,
66 if (base_size < MINIMUM_BREAK_SIZE)
67 return 0; /* we do not break too small filepair */
68
72 - delta = diff_delta(src->data, src->size,
73 - dst->data, dst->size,
74 - &delta_size, 0);
75 - if (!delta)
76 - return 0; /* error but caught downstream */
77 -
78 - /* Estimate the edit size by interpreting delta. */
79 - if (count_delta(delta, delta_size,
80 - &src_copied, &literal_added)) {
81 - free(delta);
82 - return 0; /* we cannot tell */
83 - }
84 - free(delta);
69 + if (diffcore_count_changes(src->data, src->size,
70 + dst->data, dst->size,
71 + 0,
72 + &src_copied, &literal_added))
73 + return 0;
74
75 /* Compute merge-score, which is "how much is removed
76 * from the source material". The clean-up stage will
diffcore-delta.c new
+43
@@ -0,0 +1,43 @@
1 +#include "cache.h"
2 +#include "diff.h"
3 +#include "diffcore.h"
4 +#include "delta.h"
5 +#include "count-delta.h"
6 +
7 +static int diffcore_count_changes_1(void *src, unsigned long src_size,
8 + void *dst, unsigned long dst_size,
9 + unsigned long delta_limit,
10 + unsigned long *src_copied,
11 + unsigned long *literal_added)
12 +{
13 + void *delta;
14 + unsigned long delta_size;
15 +
16 + delta = diff_delta(src, src_size,
17 + dst, dst_size,
18 + &delta_size, delta_limit);
19 + if (!delta)
20 + /* If delta_limit is exceeded, we have too much differences */
21 + return -1;
22 +
23 + /* Estimate the edit size by interpreting delta. */
24 + if (count_delta(delta, delta_size, src_copied, literal_added)) {
25 + free(delta);
26 + return -1;
27 + }
28 + free(delta);
29 + return 0;
30 +}
31 +
32 +int diffcore_count_changes(void *src, unsigned long src_size,
33 + void *dst, unsigned long dst_size,
34 + unsigned long delta_limit,
35 + unsigned long *src_copied,
36 + unsigned long *literal_added)
37 +{
38 + return diffcore_count_changes_1(src, src_size,
39 + dst, dst_size,
40 + delta_limit,
41 + src_copied,
42 + literal_added);
43 +}
diffcore-rename.c
+5 -23
@@ -4,8 +4,6 @@
4 #include "cache.h"
5 #include "diff.h"
6 #include "diffcore.h"
7 -#include "delta.h"
8 -#include "count-delta.h"
7
8 /* Table of rename/copy destinations */
9
@@ -135,7 +133,6 @@ static int estimate_similarity(struct diff_filespec *src,
133 * match than anything else; the destination does not even
134 * call into this function in that case.
135 */
138 - void *delta;
136 unsigned long delta_size, base_size, src_copied, literal_added;
137 unsigned long delta_limit;
138 int score;
@@ -165,28 +162,13 @@ static int estimate_similarity(struct diff_filespec *src,
162 if (diff_populate_filespec(src, 0) || diff_populate_filespec(dst, 0))
163 return 0; /* error but caught downstream */
164
168 - delta_limit = base_size * (MAX_SCORE-minimum_score) / MAX_SCORE;
169 - delta = diff_delta(src->data, src->size,
170 - dst->data, dst->size,
171 - &delta_size, delta_limit);
172 - if (!delta)
173 - /* If delta_limit is exceeded, we have too much differences */
174 - return 0;
175 -
176 - /* A delta that has a lot of literal additions would have
177 - * big delta_size no matter what else it does.
178 - */
179 - if (base_size * (MAX_SCORE-minimum_score) < delta_size * MAX_SCORE) {
180 - free(delta);
181 - return 0;
182 - }
165
184 - /* Estimate the edit size by interpreting delta. */
185 - if (count_delta(delta, delta_size, &src_copied, &literal_added)) {
186 - free(delta);
166 + delta_limit = base_size * (MAX_SCORE-minimum_score) / MAX_SCORE;
167 + if (diffcore_count_changes(src->data, src->size,
168 + dst->data, dst->size,
169 + delta_limit,
170 + &src_copied, &literal_added))
171 return 0;
188 - }
189 - free(delta);
172
173 /* Extent of damage */
174 if (src->size + literal_added < src_copied)
diffcore.h
+6
@@ -101,4 +101,10 @@ void diff_debug_queue(const char *, struct diff_queue_struct *);
101 #define diff_debug_queue(a,b) do {} while(0)
102 #endif
103
104 +extern int diffcore_count_changes(void *src, unsigned long src_size,
105 + void *dst, unsigned long dst_size,
106 + unsigned long delta_limit,
107 + unsigned long *src_copied,
108 + unsigned long *literal_added);
109 +
110 #endif