[PATCH] Add git-diff-stages command.

The diff-* brothers acquired a sibling, git-diff-stages.  With
an unmerged index file, you specify two stage numbers and it
shows the differences between them.

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

diff --git a/Makefile b/Makefile
index b02c234..ec62424 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -33,7 +33,7 @@ PROG=   git-update-cache git-diff-files git-init-db git-write-tree \
        git-http-pull git-ssh-push git-ssh-pull git-rev-list git-mktag \
        git-diff-helper git-tar-tree git-local-pull git-write-blob \
        git-get-tar-commit-id git-mkdelta git-apply git-stripspace \
-       git-cvs2git
+       git-cvs2git git-diff-stages
 
 all: $(PROG)
 
@@ -117,6 +117,7 @@ git-write-blob: write-blob.c
 git-mkdelta: mkdelta.c
 git-stripspace: stripspace.c
 git-cvs2git: cvs2git.c
+git-diff-stages: diff-stages.c
 
 git-http-pull: LIBS += -lcurl
 git-rev-list: LIBS += -lssl

diff --git a/diff-stages.c b/diff-stages.c
new file mode 100644 (file)
index 0000000..0090ac0
--- /dev/null
+++ b/diff-stages.c
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2005 Junio C Hamano
+ */
+
+#include "cache.h"
+#include "diff.h"
+
+static int diff_output_format = DIFF_FORMAT_HUMAN;
+static int detect_rename = 0;
+static int diff_setup_opt = 0;
+static int diff_score_opt = 0;
+static const char *pickaxe = NULL;
+static int pickaxe_opts = 0;
+static int diff_break_opt = -1;
+static const char *orderfile = NULL;
+
+static char *diff_stages_usage =
+"git-diff-stages [-p] [-r] [-z] [-M] [-C] [-R] [-S<string>] [-O<orderfile>] <stage1> <stage2> [<path>...]";
+
+int main(int ac, const char **av)
+{
+       int stage1, stage2, i;
+
+       read_cache();
+       while (1 < ac && av[1][0] == '-') {
+               const char *arg = av[1];
+               if (!strcmp(arg, "-r"))
+                       ; /* as usual */
+               else if (!strcmp(arg, "-p"))
+                       diff_output_format = DIFF_FORMAT_PATCH;
+               else if (!strncmp(arg, "-B", 2)) {
+                       if ((diff_break_opt = diff_scoreopt_parse(arg)) == -1)
+                               usage(diff_stages_usage);
+               }
+               else if (!strncmp(arg, "-M", 2)) {
+                       detect_rename = DIFF_DETECT_RENAME;
+                       if ((diff_score_opt = diff_scoreopt_parse(arg)) == -1)
+                               usage(diff_stages_usage);
+               }
+               else if (!strncmp(arg, "-C", 2)) {
+                       detect_rename = DIFF_DETECT_COPY;
+                       if ((diff_score_opt = diff_scoreopt_parse(arg)) == -1)
+                               usage(diff_stages_usage);
+               }
+               else if (!strcmp(arg, "-z"))
+                       diff_output_format = DIFF_FORMAT_MACHINE;
+               else if (!strcmp(arg, "-R"))
+                       diff_setup_opt |= DIFF_SETUP_REVERSE;
+               else if (!strncmp(arg, "-S", 2))
+                       pickaxe = arg + 2;
+               else if (!strncmp(arg, "-O", 2))
+                       orderfile = arg + 2;
+               else if (!strcmp(arg, "--pickaxe-all"))
+                       pickaxe_opts = DIFF_PICKAXE_ALL;
+               else
+                       usage(diff_stages_usage);
+               ac--; av++;
+       }
+
+       if (ac < 3 ||
+           sscanf(av[1], "%d", &stage1) != 1 ||
+           ! (0 <= stage1 && stage1 <= 3) ||
+           sscanf(av[2], "%d", &stage2) != 1 ||
+           ! (0 <= stage2 && stage2 <= 3))
+               usage(diff_stages_usage);
+
+       av += 3; /* The rest from av[0] are for paths restriction. */
+       diff_setup(diff_setup_opt);
+
+       i = 0;
+       while (i < active_nr) {
+               struct cache_entry *ce, *stages[4] = { NULL, };
+               struct cache_entry *one, *two;
+               const char *name;
+               int len;
+               ce = active_cache[i];
+               len = ce_namelen(ce);
+               name = ce->name;
+               for (;;) {
+                       int stage = ce_stage(ce);
+                       stages[stage] = ce;
+                       if (active_nr <= ++i)
+                               break;
+                       ce = active_cache[i];
+                       if (ce_namelen(ce) != len ||
+                           memcmp(name, ce->name, len))
+                               break;
+               }
+               one = stages[stage1];
+               two = stages[stage2];
+               if (!one && !two)
+                       continue;
+               if (!one)
+                       diff_addremove('+', ntohl(two->ce_mode),
+                                      two->sha1, name, NULL);
+               else if (!two)
+                       diff_addremove('-', ntohl(one->ce_mode),
+                                      one->sha1, name, NULL);
+               else if (memcmp(one->sha1, two->sha1, 20) ||
+                        (one->ce_mode != two->ce_mode))
+                        diff_change(ntohl(one->ce_mode), ntohl(two->ce_mode),
+                                    one->sha1, two->sha1, name, NULL);
+       }
+
+       diffcore_std(av,
+                    detect_rename, diff_score_opt,
+                    pickaxe, pickaxe_opts,
+                    diff_break_opt,
+                    orderfile);
+       diff_flush(diff_output_format, 1);
+       return 0;
+}