You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
267 lines
6.7 KiB
267 lines
6.7 KiB
#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, ""); |
|
}
|
|
|