X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=diff-tree.c;h=51e3274f36dd7792fdbd20fdde4f4e7546f3b10b;hb=1c9da46da4fe5cf99c5f6ab251419d0f412ecfba;hp=222591936f8a8ada4bf40fe848ba59bcd067357e;hpb=c1fdf2a6abb6a7c5b8092d72514264ae378d60ee;p=git.git diff --git a/diff-tree.c b/diff-tree.c index 22259193..51e3274f 100644 --- a/diff-tree.c +++ b/diff-tree.c @@ -1,7 +1,21 @@ +#include #include "cache.h" +#include "diff.h" +static int silent = 0; +static int verbose_header = 0; +static int ignore_merges = 1; static int recursive = 0; +static int read_stdin = 0; static int line_termination = '\n'; +static int generate_patch = 0; +static const char *header = NULL; +static const char *header_prefix = ""; + +// What paths are we interested in? +static int nr_paths = 0; +static char **paths = NULL; +static int *pathlens = NULL; static int diff_tree_sha1(const unsigned char *old, const unsigned char *new, const char *base); @@ -32,7 +46,7 @@ static const unsigned char *extract(void *tree, unsigned long size, const char * static char *malloc_base(const char *base, const char *path, int pathlen) { int baselen = strlen(base); - char *newbase = malloc(baselen + pathlen + 2); + char *newbase = xmalloc(baselen + pathlen + 2); memcpy(newbase, base, baselen); memcpy(newbase + baselen, path, pathlen); memcpy(newbase + baselen + pathlen, "/", 2); @@ -57,6 +71,14 @@ static void show_file(const char *prefix, void *tree, unsigned long size, const const char *path; const unsigned char *sha1 = extract(tree, size, &path, &mode); + if (header) { + printf("%s", header); + header = NULL; + } + + if (silent) + return; + if (recursive && S_ISDIR(mode)) { char type[20]; unsigned long size; @@ -74,10 +96,15 @@ static void show_file(const char *prefix, void *tree, unsigned long size, const 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); + if (generate_patch) { + if (!S_ISDIR(mode)) + diff_addremove(prefix[0], mode, sha1, base, path); + } + else + printf("%s%06o\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(void *tree1, unsigned long size1, void *tree2, unsigned long size2, const char *base) @@ -123,17 +150,84 @@ static int compare_tree_entry(void *tree1, unsigned long size1, void *tree2, uns return retval; } - 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); + if (header) { + printf("%s", header); + header = NULL; + } + if (silent) + return 0; + + if (generate_patch) { + if (!S_ISDIR(mode1)) + diff_change(mode1, mode2, sha1, sha2, base, path1); + } + else { + strcpy(old_sha1_hex, sha1_to_hex(sha1)); + printf("*%06o->%06o\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 interesting(void *tree, unsigned long size, const char *base) +{ + const char *path; + unsigned mode; + int i; + int baselen, pathlen; + + if (!nr_paths) + return 1; + + (void)extract(tree, size, &path, &mode); + + pathlen = strlen(path); + baselen = strlen(base); + + for (i=0; i < nr_paths; i++) { + const char *match = paths[i]; + int matchlen = pathlens[i]; + + if (baselen >= matchlen) { + /* If it doesn't match, move along... */ + if (strncmp(base, match, matchlen)) + continue; + + /* The base is a subdirectory of a path which was specified. */ + return 1; + } + + /* Does the base match? */ + if (strncmp(base, match, baselen)) + continue; + + match += baselen; + matchlen -= baselen; + + if (pathlen > matchlen) + continue; + + if (strncmp(path, match, pathlen)) + continue; + + return 1; + } + return 0; /* No matches */ +} + static int diff_tree(void *tree1, unsigned long size1, void *tree2, unsigned long size2, const char *base) { while (size1 | size2) { + if (nr_paths && size1 && !interesting(tree1, size1, base)) { + update_tree_entry(&tree1, &size1); + continue; + } + if (nr_paths && size2 && !interesting(tree2, size2, base)) { + update_tree_entry(&tree2, &size2); + continue; + } if (!size1) { show_file("+", tree2, size2, base); update_tree_entry(&tree2, &size2); @@ -166,10 +260,10 @@ static int diff_tree_sha1(const unsigned char *old, const unsigned char *new, co unsigned long size1, size2; int retval; - tree1 = read_tree_with_tree_or_commit_sha1(old, &size1, 0); + tree1 = read_object_with_reference(old, "tree", &size1, 0); if (!tree1) die("unable to read source tree (%s)", sha1_to_hex(old)); - tree2 = read_tree_with_tree_or_commit_sha1(new, &size2, 0); + tree2 = read_object_with_reference(new, "tree", &size2, 0); if (!tree2) die("unable to read destination tree (%s)", sha1_to_hex(new)); retval = diff_tree(tree1, size1, tree2, size2, base); @@ -178,26 +272,196 @@ static int diff_tree_sha1(const unsigned char *old, const unsigned char *new, co return retval; } +static int get_one_line(const char *msg, unsigned long len) +{ + int ret = 0; + + while (len--) { + ret++; + if (*msg++ == '\n') + break; + } + return ret; +} + +static int add_author_info(char *buf, const char *line, int len) +{ + char *date; + unsigned int namelen; + unsigned long time; + int tz; + + line += strlen("author "); + date = strchr(line, '>'); + if (!date) + return 0; + namelen = ++date - line; + time = strtoul(date, &date, 10); + tz = strtol(date, NULL, 10); + + return sprintf(buf, "Author: %.*s\nDate: %s\n", + namelen, line, + show_date(time, tz)); +} + +static char *generate_header(const char *commit, const char *parent, const char *msg, unsigned long len) +{ + static char this_header[1000]; + int offset; + + offset = sprintf(this_header, "%s%s (from %s)\n", header_prefix, commit, parent); + if (verbose_header) { + int hdr = 1; + + for (;;) { + const char *line = msg; + int linelen = get_one_line(msg, len); + + if (!linelen) + break; + if (offset + linelen + 10 > sizeof(this_header)) + break; + + msg += linelen; + len -= linelen; + if (linelen == 1) + hdr = 0; + if (hdr) { + if (!memcmp(line, "author ", 7)) + offset += add_author_info(this_header + offset, line, linelen); + continue; + } + memset(this_header + offset, ' ', 4); + memcpy(this_header + offset + 4, line, linelen); + offset += linelen + 4; + } + this_header[offset++] = '\n'; + this_header[offset] = 0; + } + + return this_header; +} + +static int diff_tree_stdin(char *line) +{ + int len = strlen(line); + unsigned char commit[20], parent[20]; + unsigned long size, offset; + static char this_header[1000]; + char *buf; + + if (!len || line[len-1] != '\n') + return -1; + line[len-1] = 0; + if (get_sha1_hex(line, commit)) + return -1; + if (isspace(line[40]) && !get_sha1_hex(line+41, parent)) { + line[40] = 0; + line[81] = 0; + sprintf(this_header, "%s (from %s)\n", line, line+41); + header = this_header; + return diff_tree_sha1(parent, commit, ""); + } + buf = read_object_with_reference(commit, "commit", &size, NULL); + if (!buf) + return -1; + + /* More than one parent? */ + if (ignore_merges) { + if (!memcmp(buf + 46 + 48, "parent ", 7)) + return 0; + } + + line[40] = 0; + offset = 46; + while (offset + 48 < size && !memcmp(buf + offset, "parent ", 7)) { + if (get_sha1_hex(buf + offset + 7, parent)) + return -1; + header = generate_header(line, sha1_to_hex(parent), buf, size); + diff_tree_sha1(parent, commit, ""); + if (!header && verbose_header) + header_prefix = "\ndiff-tree "; + offset += 48; + } + return -1; +} + +static char *diff_tree_usage = +"diff-tree [-p] [-r] [-z] [--stdin] [-m] [-s] [-v] "; + int main(int argc, char **argv) { + char line[1000]; unsigned char old[20], new[20]; - while (argc > 3) { - char *arg = argv[1]; + for (;;) { + char *arg; + argv++; argc--; + arg = *argv; + if (!arg || *arg != '-') + break; + + if (!strcmp(arg, "-")) { + argv++; + argc--; + break; + } if (!strcmp(arg, "-r")) { recursive = 1; continue; } + if (!strcmp(arg, "-p")) { + recursive = generate_patch = 1; + continue; + } if (!strcmp(arg, "-z")) { line_termination = '\0'; continue; } - usage("diff-tree [-r] [-z] "); + if (!strcmp(arg, "-m")) { + ignore_merges = 0; + continue; + } + if (!strcmp(arg, "-s")) { + silent = 1; + continue; + } + if (!strcmp(arg, "-v")) { + verbose_header = 1; + header_prefix = "diff-tree "; + continue; + } + if (!strcmp(arg, "--stdin")) { + read_stdin = 1; + continue; + } + usage(diff_tree_usage); } - if (argc != 3 || get_sha1_hex(argv[1], old) || get_sha1_hex(argv[2], new)) - usage("diff-tree "); - return diff_tree_sha1(old, new, ""); + if (!read_stdin) { + if (argc < 2 || get_sha1(argv[0], old) || get_sha1(argv[1], new)) + usage(diff_tree_usage); + argv += 2; + argc -= 2; + } + + if (argc > 0) { + int i; + + paths = argv; + nr_paths = argc; + pathlens = xmalloc(nr_paths * sizeof(int)); + for (i=0; i