From e74f8f6aa7807d479d78bfc680a18a9a5198b172 Mon Sep 17 00:00:00 2001 From: Linus Torvalds Date: Tue, 19 Apr 2005 21:00:09 -0700 Subject: [PATCH] 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. --- Makefile | 9 +- diff-cache.c | 267 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 274 insertions(+), 2 deletions(-) create mode 100644 diff-cache.c diff --git a/Makefile b/Makefile index 57181be367..0d07b9a4d3 100644 --- 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 index 0000000000..fcbc4900d3 --- /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] "); + } + + if (argc != 2 || get_sha1_hex(argv[1], tree_sha1)) + usage("diff-cache [-r] [-z] "); + + 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, ""); +}