git-commit-vandalism/diff-cache.c
Junio C Hamano c5bac17ad2 [PATCH] Usage-string fixes.
Usage string fixes to make maintenance easier (only one instance
of a string to update not multiple copies).  I've spotted and
corrected inconsistent usage text in diff-tree while doing this.

Also diff-cache and read-tree usage text have been corrected to
match their up-to-date features.  Earlier, neither "--cached"
form of diff-cache nor "-m single-merge" form of read-tree were
described. 

Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-04-20 19:49:16 -07:00

255 lines
6.2 KiB
C

#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;
}
static char *diff_cache_usage = "diff-cache [-r] [-z] [--cached] <tree sha1>";
int main(int argc, char **argv)
{
unsigned char tree_sha1[20];
void *tree;
unsigned long size;
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_usage);
}
if (argc != 2 || get_sha1_hex(argv[1], tree_sha1))
usage(diff_cache_usage);
tree = read_tree_with_tree_or_commit_sha1(tree_sha1, &size, 0);
if (!tree)
die("bad tree object %s", argv[1]);
return diff_cache(tree, size, active_cache, active_nr, "");
}