[PATCH] diffcore-break.c: various fixes.

This fixes three bugs in the -B heuristics.

- Although it was advertised that the initial break criteria
used was the same as what diffcore-rename uses, it was using
something different.  Instead of using smaller of src and dst
size to compare with "edit" size, (insertion and deletion),
it was using larger of src and dst, unlike the rename/copy
detection logic.  This caused the parameter to -B to mean
something different from the one to -M and -C.  To compensate
for this change, the default break score is also changed to
match that of the default for rename/copy.

- The code would have crashed with division by zero when trying
to break an originally empty file.

- Contrary to what the comment said, the algorithm was breaking
small files, only to later merge them together.

Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/diffcore-break.c b/diffcore-break.c
index 8cbb99fb41bd7a22028757e0e57842365c52622e..082e4e5962da65492fbcc6762661a0b655c0986b 100644 (file)
--- a/diffcore-break.c
+++ b/diffcore-break.c
@@ -61,14 +61,7 @@ static int should_break(struct diff_filespec *src,
        if (diff_populate_filespec(src, 0) || diff_populate_filespec(dst, 0))
                return 0; /* error but caught downstream */
 
        if (diff_populate_filespec(src, 0) || diff_populate_filespec(dst, 0))
                return 0; /* error but caught downstream */
 

-       delta_size = ((src->size < dst->size) ?
-                     (dst->size - src->size) : (src->size - dst->size));
-
-       /* Notice that we use max of src and dst as the base size,
-        * unlike rename similarity detection.  This is so that we do
-        * not mistake a large addition as a complete rewrite.
-        */
-       base_size = ((src->size < dst->size) ? dst->size : src->size);
+       base_size = ((src->size < dst->size) ? src->size : dst->size);

 
        delta = diff_delta(src->data, src->size,
                           dst->data, dst->size,
 
        delta = diff_delta(src->data, src->size,
                           dst->data, dst->size,


@@ -88,10 +81,11 @@ static int should_break(struct diff_filespec *src,
         * less than the minimum, after rename/copy runs.
         */
        if (src->size <= src_copied)
         * less than the minimum, after rename/copy runs.
         */
        if (src->size <= src_copied)

-               delta_size = 0; /* avoid wrapping around */
-       else
+               ; /* all copied, nothing removed */
+       else {

                delta_size = src->size - src_copied;
                delta_size = src->size - src_copied;

-       *merge_score_p = delta_size * MAX_SCORE / src->size;
+               *merge_score_p = delta_size * MAX_SCORE / src->size;
+       }

        
        /* Extent of damage, which counts both inserts and
         * deletes.
        
        /* Extent of damage, which counts both inserts and
         * deletes.


@@ -174,7 +168,8 @@ void diffcore_break(int break_score)
                    !S_ISDIR(p->one->mode) && !S_ISDIR(p->two->mode) &&
                    !strcmp(p->one->path, p->two->path)) {
                        if (should_break(p->one, p->two,
                    !S_ISDIR(p->one->mode) && !S_ISDIR(p->two->mode) &&
                    !strcmp(p->one->path, p->two->path)) {
                        if (should_break(p->one, p->two,

-                                        break_score, &score)) {
+                                        break_score, &score) &&
+                           MINIMUM_BREAK_SIZE <= p->one->size) {

                                /* Split this into delete and create */
                                struct diff_filespec *null_one, *null_two;
                                struct diff_filepair *dp;
                                /* Split this into delete and create */
                                struct diff_filespec *null_one, *null_two;
                                struct diff_filepair *dp;


@@ -185,8 +180,7 @@ void diffcore_break(int break_score)
                                 * Also we do not want to break very
                                 * small files.
                                 */
                                 * Also we do not want to break very
                                 * small files.
                                 */

-                               if ((score < merge_score) ||
-                                   (p->one->size < MINIMUM_BREAK_SIZE))
+                               if (score < merge_score)

                                        score = 0;
 
                                /* deletion of one */
                                        score = 0;
 
                                /* deletion of one */

diff --git a/diffcore.h b/diffcore.h
index 194d40cb4823f294cce67c430fa57520d4bc7ce9..f1b5ca748cae8d40f599552c3605080808da7803 100644 (file)
--- a/diffcore.h
+++ b/diffcore.h
@@ -17,7 +17,7 @@
  */
 #define MAX_SCORE 60000
 #define DEFAULT_RENAME_SCORE 30000 /* rename/copy similarity minimum (50%) */
  */
 #define MAX_SCORE 60000
 #define DEFAULT_RENAME_SCORE 30000 /* rename/copy similarity minimum (50%) */

-#define DEFAULT_BREAK_SCORE  59400 /* minimum for break to happen (99%)*/
+#define DEFAULT_BREAK_SCORE  30000 /* minimum for break to happen (50%)*/

 #define DEFAULT_MERGE_SCORE  48000 /* maximum for break-merge to happen (80%)*/
 
 #define MINIMUM_BREAK_SIZE     400 /* do not break a file smaller than this */
 #define DEFAULT_MERGE_SCORE  48000 /* maximum for break-merge to happen (80%)*/
 
 #define MINIMUM_BREAK_SIZE     400 /* do not break a file smaller than this */