Add "diff-cache" helper program to compare a tree (or commit) with

the current cache state and/or working directory.

Very useful to see what has changed since the last commit, either in
the index file or in the whole working directory.

Also very possibly very buggy. Matching the two up is not entirely
trivial.

diff --git a/Makefile b/Makefile
index 57181be..0d07b9a 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -15,7 +15,8 @@ AR=ar
 
 PROG=   update-cache show-diff init-db write-tree read-tree commit-tree \
        cat-file fsck-cache checkout-cache diff-tree rev-tree show-files \
-       check-files ls-tree merge-base merge-cache unpack-file git-export
+       check-files ls-tree merge-base merge-cache unpack-file git-export \
+       diff-cache
 
 all: $(PROG)
 
@@ -84,15 +85,19 @@ unpack-file: unpack-file.o $(LIB_FILE)
 git-export: git-export.o $(LIB_FILE)
        $(CC) $(CFLAGS) -o git-export git-export.o $(LIBS)
 
+diff-cache: diff-cache.o $(LIB_FILE)
+       $(CC) $(CFLAGS) -o diff-cache diff-cache.o $(LIBS)
+
 blob.o: $(LIB_H)
 cat-file.o: $(LIB_H)
 check-files.o: $(LIB_H)
 checkout-cache.o: $(LIB_H)
 commit.o: $(LIB_H)
 commit-tree.o: $(LIB_H)
+diff-cache.o: $(LIB_H)
 diff-tree.o: $(LIB_H)
 fsck-cache.o: $(LIB_H)
-git_export.o: $(LIB_H)
+git-export.o: $(LIB_H)
 init-db.o: $(LIB_H)
 ls-tree.o: $(LIB_H)
 merge-base.o: $(LIB_H)

diff --git a/diff-cache.c b/diff-cache.c
new file mode 100644 (file)
index 0000000..fcbc490
--- /dev/null
+++ b/diff-cache.c
@@ -0,0 +1,267 @@
+#include "cache.h"
+
+static int cached_only = 0;
+static int recursive = 0;
+static int line_termination = '\n';
+
+static int diff_cache(void *tree, unsigned long size, struct cache_entry **ac, int entries, const char *base);
+
+static void update_tree_entry(void **bufp, unsigned long *sizep)
+{
+       void *buf = *bufp;
+       unsigned long size = *sizep;
+       int len = strlen(buf) + 1 + 20;
+
+       if (size < len)
+               die("corrupt tree file 1 (%s)", size);
+       *bufp = buf + len;
+       *sizep = size - len;
+}
+
+static const unsigned char *extract(void *tree, unsigned long size, const char **pathp, unsigned int *modep)
+{
+       int len = strlen(tree)+1;
+       const unsigned char *sha1 = tree + len;
+       const char *path = strchr(tree, ' ');
+
+       if (!path || size < len + 20 || sscanf(tree, "%o", modep) != 1)
+               die("corrupt tree file 2 (%d)", size);
+       *pathp = path+1;
+       return sha1;
+}
+
+static char *malloc_base(const char *base, const char *path, int pathlen)
+{
+       int baselen = strlen(base);
+       char *newbase = malloc(baselen + pathlen + 2);
+       memcpy(newbase, base, baselen);
+       memcpy(newbase + baselen, path, pathlen);
+       memcpy(newbase + baselen + pathlen, "/", 2);
+       return newbase;
+}
+
+static void show_file(const char *prefix, const char *path, unsigned int mode, const unsigned char *sha1, const char *base);
+
+/* A whole sub-tree went away or appeared */
+static void show_tree(const char *prefix, void *tree, unsigned long size, const char *base)
+{
+       while (size) {
+               const char *path;
+               unsigned int mode;
+               const unsigned char *sha1 = extract(tree, size, &path, &mode);
+               
+               show_file(prefix, path, mode, sha1, base);
+               update_tree_entry(&tree, &size);
+       }
+}
+
+/* A file entry went away or appeared */
+static void show_file(const char *prefix, const char *path, unsigned int mode, const unsigned char *sha1, const char *base)
+{
+       if (recursive && S_ISDIR(mode)) {
+               char type[20];
+               unsigned long size;
+               char *newbase = malloc_base(base, path, strlen(path));
+               void *tree;
+
+               tree = read_sha1_file(sha1, type, &size);
+               if (!tree || strcmp(type, "tree"))
+                       die("corrupt tree sha %s", sha1_to_hex(sha1));
+
+               show_tree(prefix, tree, size, newbase);
+               
+               free(tree);
+               free(newbase);
+               return;
+       }
+
+       printf("%s%o\t%s\t%s\t%s%s%c", prefix, mode,
+              S_ISDIR(mode) ? "tree" : "blob",
+              sha1_to_hex(sha1), base, path,
+              line_termination);
+}
+
+static int compare_tree_entry(const char *path1, unsigned int mode1, const unsigned char *sha1,
+                             struct cache_entry **ac, int *entries, const char *base)
+{
+       int baselen = strlen(base);
+       struct cache_entry *ce = *ac;
+       const char *path2 = ce->name + baselen;
+       unsigned int mode2 = ntohl(ce->ce_mode);
+       const unsigned char *sha2 = ce->sha1;
+       int cmp, pathlen1, pathlen2;
+       char old_sha1_hex[50];
+
+       pathlen1 = strlen(path1);
+       pathlen2 = strlen(path2);
+       cmp = cache_name_compare(path1, pathlen1, path2, pathlen2);
+       if (cmp < 0) {
+               if (S_ISDIR(mode1)) {
+                       char type[20];
+                       unsigned long size;
+                       void *tree = read_sha1_file(sha1, type, &size);
+                       char *newbase = malloc(baselen + 2 + pathlen1);
+
+                       memcpy(newbase, base, baselen);
+                       memcpy(newbase + baselen, path1, pathlen1);
+                       memcpy(newbase + baselen + pathlen1, "/", 2);
+                       if (!tree || strcmp(type, "tree"))
+                               die("unable to read tree object %s", sha1_to_hex(sha1));
+                       *entries = diff_cache(tree, size, ac, *entries, newbase);
+                       free(newbase);
+                       free(tree);
+                       return -1;
+               }
+               show_file("-", path1, mode1, sha1, base);
+               return -1;
+       }
+
+       if (!cached_only) {
+               static unsigned char no_sha1[20];
+               int fd, changed;
+               struct stat st;
+               fd = open(ce->name, O_RDONLY);
+               if (fd < 0 || fstat(fd, &st) < 0) {
+                       show_file("-", path1, mode1, sha1, base);
+                       return -1;
+               }
+               changed = cache_match_stat(ce, &st);
+               close(fd);
+               if (changed) {
+                       mode2 = st.st_mode;
+                       sha2 = no_sha1;
+               }
+       }
+
+       if (cmp > 0) {
+               show_file("+", path2, mode2, sha2, base);
+               return 1;
+       }
+       if (!memcmp(sha1, sha2, 20) && mode1 == mode2)
+               return 0;
+
+       /*
+        * If the filemode has changed to/from a directory from/to a regular
+        * file, we need to consider it a remove and an add.
+        */
+       if (S_ISDIR(mode1) || S_ISDIR(mode2)) {
+               show_file("-", path1, mode1, sha1, base);
+               show_file("+", path2, mode2, sha2, base);
+               return 0;
+       }
+
+       strcpy(old_sha1_hex, sha1_to_hex(sha1));
+       printf("*%o->%o\t%s\t%s->%s\t%s%s%c", mode1, mode2,
+              S_ISDIR(mode1) ? "tree" : "blob",
+              old_sha1_hex, sha1_to_hex(sha2), base, path1,
+              line_termination);
+       return 0;
+}
+
+static int diff_cache(void *tree, unsigned long size, struct cache_entry **ac, int entries, const char *base)
+{
+       int baselen = strlen(base);
+
+       for (;;) {
+               struct cache_entry *ce;
+               unsigned int mode;
+               const char *path;
+               const unsigned char *sha1;
+               int left;
+
+               /*
+                * No entries in the cache (with this base)?
+                * Output the tree contents.
+                */
+               if (!entries || ce_namelen(ce = *ac) < baselen || memcmp(ce->name, base, baselen)) {
+                       if (!size)
+                               return entries;
+                       sha1 = extract(tree, size, &path, &mode);
+                       show_file("-", path, mode, sha1, base);
+                       update_tree_entry(&tree, &size);
+                       continue;
+               }
+
+               /*
+                * No entries in the tree? Output the cache contents
+                */
+               if (!size) {
+                       show_file("+", ce->name, ntohl(ce->ce_mode), ce->sha1, "");
+                       ac++;
+                       entries--;
+                       continue;
+               }
+
+               sha1 = extract(tree, size, &path, &mode);
+               left = entries;
+               switch (compare_tree_entry(path, mode, sha1, ac, &left, base)) {
+               case -1:
+                       update_tree_entry(&tree, &size);
+                       if (left < entries) {
+                               ac += (entries - left);
+                               entries = left;
+                       }
+                       continue;
+               case 0:
+                       update_tree_entry(&tree, &size);
+                       /* Fallthrough */
+               case 1:
+                       ac++;
+                       entries--;
+                       continue;
+               }
+               die("diff-cache: internal error");
+       }
+       return 0;
+}
+
+int main(int argc, char **argv)
+{
+       unsigned char tree_sha1[20];
+       void *tree;
+       unsigned long size;
+       char type[20];
+
+       read_cache();
+       while (argc > 2) {
+               char *arg = argv[1];
+               argv++;
+               argc--;
+               if (!strcmp(arg, "-r")) {
+                       recursive = 1;
+                       continue;
+               }
+               if (!strcmp(arg, "-z")) {
+                       line_termination = '\0';
+                       continue;
+               }
+               if (!strcmp(arg, "--cached")) {
+                       cached_only = 1;
+                       continue;
+               }
+               usage("diff-cache [-r] [-z] <tree sha1>");
+       }
+
+       if (argc != 2 || get_sha1_hex(argv[1], tree_sha1))
+               usage("diff-cache [-r] [-z] <tree sha1>");
+
+       tree = read_sha1_file(tree_sha1, type, &size);
+       if (!tree)
+               die("bad tree object %s", argv[1]);
+
+       /* We allow people to feed us a commit object, just because we're nice */
+       if (!strcmp(type, "commit")) {
+               /* tree sha1 is always at offset 5 ("tree ") */
+               if (get_sha1_hex(tree + 5, tree_sha1))
+                       die("bad commit object %s", argv[1]);
+               free(tree);
+               tree = read_sha1_file(tree_sha1, type, &size);       
+               if (!tree)
+                       die("unable to read tree object %s", sha1_to_hex(tree_sha1));
+       }
+
+       if (strcmp(type, "tree"))
+               die("bad tree object %s (%s)", sha1_to_hex(tree_sha1), type);
+
+       return diff_cache(tree, size, active_cache, active_nr, "");
+}