Makefile: rebuild git.o on version change, clean up git$X flags

diff --git a/builtin-diff.c b/builtin-diff.c
index 4efbb8237bd49e8717a42833b2d9b2db064b45ac..7f367b6b9d545ea760224fdacb68056261ce1617 100644 (file)
--- a/builtin-diff.c
+++ b/builtin-diff.c
@@ -13,13 +13,10 @@
 #include "log-tree.h"
 #include "builtin.h"
 
-/* NEEDSWORK: struct object has place for name but we _do_
- * know mode when we extracted the blob out of a tree, which
- * we currently lose.
- */
 struct blobinfo {
        unsigned char sha1[20];
        const char *name;
+       unsigned mode;
 };
 
 static const char builtin_diff_usage[] =
@@ -35,7 +32,7 @@ static void stuff_change(struct diff_options *opt,
        struct diff_filespec *one, *two;
 
        if (!is_null_sha1(old_sha1) && !is_null_sha1(new_sha1) &&
-           !hashcmp(old_sha1, new_sha1))
+           !hashcmp(old_sha1, new_sha1) && (old_mode == new_mode))
                return;
 
        if (opt->reverse_diff) {
@@ -70,8 +67,12 @@ static int builtin_diff_b_f(struct rev_info *revs,
                die("'%s': %s", path, strerror(errno));
        if (!(S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)))
                die("'%s': not a regular file or symlink", path);
+
+       if (blob[0].mode == S_IFINVALID)
+               blob[0].mode = canon_mode(st.st_mode);
+
        stuff_change(&revs->diffopt,
-                    canon_mode(st.st_mode), canon_mode(st.st_mode),
+                    blob[0].mode, canon_mode(st.st_mode),
                     blob[0].sha1, null_sha1,
                     path, path);
        diffcore_std(&revs->diffopt);
@@ -88,8 +89,14 @@ static int builtin_diff_blobs(struct rev_info *revs,
        if (argc > 1)
                usage(builtin_diff_usage);
 
+       if (blob[0].mode == S_IFINVALID)
+               blob[0].mode = mode;
+
+       if (blob[1].mode == S_IFINVALID)
+               blob[1].mode = mode;
+
        stuff_change(&revs->diffopt,
-                    mode, mode,
+                    blob[0].mode, blob[1].mode,
                     blob[0].sha1, blob[1].sha1,
                     blob[0].name, blob[1].name);
        diffcore_std(&revs->diffopt);
@@ -190,6 +197,7 @@ int cmd_diff(int argc, const char **argv, const char *prefix)
        const char *path = NULL;
        struct blobinfo blob[2];
        int nongit = 0;
+       int result = 0;
 
        /*
         * We could get N tree-ish in the rev.pending_objects list.
@@ -224,6 +232,7 @@ int cmd_diff(int argc, const char **argv, const char *prefix)
                if (diff_setup_done(&rev.diffopt) < 0)
                        die("diff_setup_done failed");
        }
+       rev.diffopt.allow_external = 1;
 
        /* Do we have --cached and not have a pending object, then
         * default to HEAD by hand.  Eek.
@@ -270,6 +279,7 @@ int cmd_diff(int argc, const char **argv, const char *prefix)
                                die("more than two blobs given: '%s'", name);
                        hashcpy(blob[blobs].sha1, obj->sha1);
                        blob[blobs].name = name;
+                       blob[blobs].mode = list->mode;
                        blobs++;
                        continue;
 
@@ -292,17 +302,17 @@ int cmd_diff(int argc, const char **argv, const char *prefix)
        if (!ents) {
                switch (blobs) {
                case 0:
-                       return run_diff_files_cmd(&rev, argc, argv);
+                       result = run_diff_files_cmd(&rev, argc, argv);
                        break;
                case 1:
                        if (paths != 1)
                                usage(builtin_diff_usage);
-                       return builtin_diff_b_f(&rev, argc, argv, blob, path);
+                       result = builtin_diff_b_f(&rev, argc, argv, blob, path);
                        break;
                case 2:
                        if (paths)
                                usage(builtin_diff_usage);
-                       return builtin_diff_blobs(&rev, argc, argv, blob);
+                       result = builtin_diff_blobs(&rev, argc, argv, blob);
                        break;
                default:
                        usage(builtin_diff_usage);
@@ -311,19 +321,21 @@ int cmd_diff(int argc, const char **argv, const char *prefix)
        else if (blobs)
                usage(builtin_diff_usage);
        else if (ents == 1)
-               return builtin_diff_index(&rev, argc, argv);
+               result = builtin_diff_index(&rev, argc, argv);
        else if (ents == 2)
-               return builtin_diff_tree(&rev, argc, argv, ent);
+               result = builtin_diff_tree(&rev, argc, argv, ent);
        else if ((ents == 3) && (ent[0].item->flags & UNINTERESTING)) {
                /* diff A...B where there is one sane merge base between
                 * A and B.  We have ent[0] == merge-base, ent[1] == A,
                 * and ent[2] == B.  Show diff between the base and B.
                 */
                ent[1] = ent[2];
-               return builtin_diff_tree(&rev, argc, argv, ent);
+               result = builtin_diff_tree(&rev, argc, argv, ent);
        }
        else
-               return builtin_diff_combined(&rev, argc, argv,
+               result = builtin_diff_combined(&rev, argc, argv,
                                             ent, ents);
-       usage(builtin_diff_usage);
+       if (rev.diffopt.exit_with_status)
+               result = rev.diffopt.has_changes;
+       return result;
 }