count-delta: match get_delta_hdr_size() changes.

diff --git a/diff.c b/diff.c
index 17d68fa699f7c88aef8e6c1a0812575bfaec70e1..fa1613c2f1fab36deb0f3365bead86160c725d00 100644 (file)
--- a/diff.c
+++ b/diff.c
@@ -555,6 +555,8 @@ static void remove_tempfile(void)
 static void remove_tempfile_on_signal(int signo)
 {
        remove_tempfile();
+       signal(SIGINT, SIG_DFL);
+       raise(signo);
 }
 
 /* An external diff command takes:
@@ -723,7 +725,7 @@ static void run_diff(struct diff_filepair *p, struct diff_options *o)
 
        if (memcmp(one->sha1, two->sha1, 20)) {
                char one_sha1[41];
-               int abbrev = o->full_index ? 40 : DIFF_DEFAULT_INDEX_ABBREV;
+               int abbrev = o->full_index ? 40 : DEFAULT_ABBREV;
                memcpy(one_sha1, sha1_to_hex(one->sha1), 41);
 
                len += snprintf(msg + len, sizeof(msg) - len,
@@ -846,9 +848,14 @@ int diff_opt_parse(struct diff_options *options, const char **av, int ac)
        else if (!strcmp(arg, "--find-copies-harder"))
                options->find_copies_harder = 1;
        else if (!strcmp(arg, "--abbrev"))
-               options->abbrev = DIFF_DEFAULT_ABBREV;
-       else if (!strncmp(arg, "--abbrev=", 9))
+               options->abbrev = DEFAULT_ABBREV;
+       else if (!strncmp(arg, "--abbrev=", 9)) {
                options->abbrev = strtoul(arg + 9, NULL, 10);
+               if (options->abbrev < MINIMUM_ABBREV)
+                       options->abbrev = MINIMUM_ABBREV;
+               else if (40 < options->abbrev)
+                       options->abbrev = 40;
+       }
        else
                return 0;
        return 1;
@@ -956,7 +963,7 @@ void diff_free_filepair(struct diff_filepair *p)
 }
 
 /* This is different from find_unique_abbrev() in that
- * it needs to deal with 0{40} SHA1.
+ * it stuffs the result with dots for alignment.
  */
 const char *diff_unique_abbrev(const unsigned char *sha1, int len)
 {
@@ -966,16 +973,8 @@ const char *diff_unique_abbrev(const unsigned char *sha1, int len)
                return sha1_to_hex(sha1);
 
        abbrev = find_unique_abbrev(sha1, len);
-       if (!abbrev) {
-               if (!memcmp(sha1, null_sha1, 20)) {
-                       char *buf = sha1_to_hex(null_sha1);
-                       if (len < 37)
-                               strcpy(buf + len, "...");
-                       return buf;
-               }
-               else 
-                       return sha1_to_hex(sha1);
-       }
+       if (!abbrev)
+               return sha1_to_hex(sha1);
        abblen = strlen(abbrev);
        if (abblen < 37) {
                static char hex[41];
@@ -1226,28 +1225,34 @@ void diff_flush(struct diff_options *options)
 
        for (i = 0; i < q->nr; i++) {
                struct diff_filepair *p = q->queue[i];
-               if ((diff_output_format == DIFF_FORMAT_NO_OUTPUT) ||
-                   (p->status == DIFF_STATUS_UNKNOWN))
-                       continue;
-               if (p->status == 0)
-                       die("internal error in diff-resolve-rename-copy");
-               switch (diff_output_format) {
-               case DIFF_FORMAT_PATCH:
-                       diff_flush_patch(p, options);
-                       break;
-               case DIFF_FORMAT_RAW:
-               case DIFF_FORMAT_NAME_STATUS:
-                       diff_flush_raw(p, line_termination,
-                                      inter_name_termination,
-                                      options);
+
+               switch (p->status) {
+               case DIFF_STATUS_UNKNOWN:
                        break;
-               case DIFF_FORMAT_NAME:
-                       diff_flush_name(p,
-                                       inter_name_termination,
-                                       line_termination);
+               case 0:
+                       die("internal error in diff-resolve-rename-copy");
                        break;
+               default:
+                       switch (diff_output_format) {
+                       case DIFF_FORMAT_PATCH:
+                               diff_flush_patch(p, options);
+                               break;
+                       case DIFF_FORMAT_RAW:
+                       case DIFF_FORMAT_NAME_STATUS:
+                               diff_flush_raw(p, line_termination,
+                                              inter_name_termination,
+                                              options);
+                               break;
+                       case DIFF_FORMAT_NAME:
+                               diff_flush_name(p,
+                                               inter_name_termination,
+                                               line_termination);
+                               break;
+                       case DIFF_FORMAT_NO_OUTPUT:
+                               break;
+                       }
                }
-               diff_free_filepair(q->queue[i]);
+               diff_free_filepair(p);
        }
        free(q->queue);
        q->queue = NULL;