X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=diff-files.c;h=7db5ce6407b9755e42445a7cf43d6dc5615bf3e7;hb=5ee2ad654bc7d19ec4f08e11dc4fed8b97a59222;hp=d7cfad79e7aae77bb121cf5c678ba02c98184c3e;hpb=bceafe752c03f4b13b9b1671a55d9e2acd26432d;p=git.git diff --git a/diff-files.c b/diff-files.c index d7cfad79..7db5ce64 100644 --- a/diff-files.c +++ b/diff-files.c @@ -6,66 +6,97 @@ #include "cache.h" #include "diff.h" -static const char *diff_files_usage = -"git-diff-files [-p] [-q] [-r] [-z] [-M] [-C] [-R] [-S] [paths...]"; - -static int diff_output_format = DIFF_FORMAT_HUMAN; -static int detect_rename = 0; -static int reverse_diff = 0; -static int diff_score_opt = 0; -static const char *pickaxe = NULL; +static const char diff_files_usage[] = +"git-diff-files [-q] [-0/-1/2/3 |-c|--cc] [] [...]" +COMMON_DIFF_OPTIONS_HELP; + +static struct diff_options diff_options; static int silent = 0; +static int diff_unmerged_stage = 2; +static int combine_merges = 0; +static int dense_combined_merges = 0; static void show_unmerge(const char *path) { - diff_unmerge(path); + diff_unmerge(&diff_options, path); } static void show_file(int pfx, struct cache_entry *ce) { - diff_addremove(pfx, ntohl(ce->ce_mode), ce->sha1, ce->name, NULL); + diff_addremove(&diff_options, pfx, ntohl(ce->ce_mode), + ce->sha1, ce->name, NULL); } static void show_modified(int oldmode, int mode, const unsigned char *old_sha1, const unsigned char *sha1, char *path) { - diff_change(oldmode, mode, old_sha1, sha1, path, NULL); + diff_change(&diff_options, oldmode, mode, old_sha1, sha1, path, NULL); } int main(int argc, const char **argv) { - static const unsigned char null_sha1[20] = { 0, }; - int entries = read_cache(); - int i; + const char **pathspec; + const char *prefix = setup_git_directory(); + int entries, i; + git_config(git_diff_config); + diff_setup(&diff_options); while (1 < argc && argv[1][0] == '-') { - if (!strcmp(argv[1], "-p")) - diff_output_format = DIFF_FORMAT_PATCH; + if (!strcmp(argv[1], "--")) { + argv++; + argc--; + break; + } + if (!strcmp(argv[1], "-0")) + diff_unmerged_stage = 0; + else if (!strcmp(argv[1], "-1")) + diff_unmerged_stage = 1; + else if (!strcmp(argv[1], "-2")) + diff_unmerged_stage = 2; + else if (!strcmp(argv[1], "-3")) + diff_unmerged_stage = 3; + else if (!strcmp(argv[1], "--base")) + diff_unmerged_stage = 1; + else if (!strcmp(argv[1], "--ours")) + diff_unmerged_stage = 2; + else if (!strcmp(argv[1], "--theirs")) + diff_unmerged_stage = 3; else if (!strcmp(argv[1], "-q")) silent = 1; else if (!strcmp(argv[1], "-r")) ; /* no-op */ else if (!strcmp(argv[1], "-s")) ; /* no-op */ - else if (!strcmp(argv[1], "-z")) - diff_output_format = DIFF_FORMAT_MACHINE; - else if (!strcmp(argv[1], "-R")) - reverse_diff = 1; - else if (!strcmp(argv[1], "-S")) - pickaxe = argv[1] + 2; - else if (!strncmp(argv[1], "-M", 2)) { - diff_score_opt = diff_scoreopt_parse(argv[1]); - detect_rename = DIFF_DETECT_RENAME; - } - else if (!strncmp(argv[1], "-C", 2)) { - diff_score_opt = diff_scoreopt_parse(argv[1]); - detect_rename = DIFF_DETECT_COPY; + else if (!strcmp(argv[1], "-c")) + combine_merges = 1; + else if (!strcmp(argv[1], "--cc")) + dense_combined_merges = combine_merges = 1; + else { + int diff_opt_cnt; + diff_opt_cnt = diff_opt_parse(&diff_options, + argv+1, argc-1); + if (diff_opt_cnt < 0) + usage(diff_files_usage); + else if (diff_opt_cnt) { + argv += diff_opt_cnt; + argc -= diff_opt_cnt; + continue; + } + else + usage(diff_files_usage); } - else - usage(diff_files_usage); argv++; argc--; } + if (dense_combined_merges) + diff_options.output_format = DIFF_FORMAT_PATCH; + + /* Find the directory, and set up the pathspec */ + pathspec = get_pathspec(prefix, argv + 1); + entries = read_cache(); + + if (diff_setup_done(&diff_options) < 0) + usage(diff_files_usage); /* At this point, if argc == 1, then we are doing everything. * Otherwise argv[1] .. argv[argc-1] have the explicit paths. @@ -75,21 +106,79 @@ int main(int argc, const char **argv) exit(1); } - diff_setup(reverse_diff); - for (i = 0; i < entries; i++) { struct stat st; - unsigned int oldmode, mode; + unsigned int oldmode, newmode; struct cache_entry *ce = active_cache[i]; int changed; + if (!ce_path_match(ce, pathspec)) + continue; + if (ce_stage(ce)) { - show_unmerge(ce->name); - while (i < entries && - !strcmp(ce->name, active_cache[i]->name)) + struct { + struct combine_diff_path p; + struct combine_diff_parent filler[5]; + } combine; + int num_compare_stages = 0; + + combine.p.next = NULL; + combine.p.len = ce_namelen(ce); + combine.p.path = xmalloc(combine.p.len + 1); + memcpy(combine.p.path, ce->name, combine.p.len); + combine.p.path[combine.p.len] = 0; + combine.p.mode = 0; + memset(combine.p.sha1, 0, 20); + memset(&combine.p.parent[0], 0, + sizeof(combine.filler)); + + while (i < entries) { + struct cache_entry *nce = active_cache[i]; + int stage; + + if (strcmp(ce->name, nce->name)) + break; + + /* Stage #2 (ours) is the first parent, + * stage #3 (theirs) is the second. + */ + stage = ce_stage(nce); + if (2 <= stage) { + int mode = ntohl(nce->ce_mode); + num_compare_stages++; + memcpy(combine.p.parent[stage-2].sha1, + nce->sha1, 20); + combine.p.parent[stage-2].mode = + DIFF_FILE_CANON_MODE(mode); + } + + /* diff against the proper unmerged stage */ + if (stage == diff_unmerged_stage) + ce = nce; i++; - i--; /* compensate for loop control increments */ - continue; + } + /* + * Compensate for loop update + */ + i--; + + if (combine_merges && num_compare_stages == 2) { + show_combined_diff(&combine.p, 2, + dense_combined_merges, + NULL, + &diff_options); + free(combine.p.path); + continue; + } + free(combine.p.path); + + /* + * Show the diff for the 'ce' if we found the one + * from the desired stage. + */ + show_unmerge(ce->name); + if (ce_stage(ce) != diff_unmerged_stage) + continue; } if (lstat(ce->name, &st) < 0) { @@ -103,22 +192,20 @@ int main(int argc, const char **argv) continue; } changed = ce_match_stat(ce, &st); - if (!changed && detect_rename < DIFF_DETECT_COPY) + if (!changed && !diff_options.find_copies_harder) continue; - oldmode = ntohl(ce->ce_mode); - mode = (S_ISLNK(st.st_mode) ? S_IFLNK : - S_IFREG | ce_permissions(st.st_mode)); - show_modified(oldmode, mode, ce->sha1, null_sha1, + newmode = DIFF_FILE_CANON_MODE(st.st_mode); + if (!trust_executable_bit && + S_ISREG(newmode) && S_ISREG(oldmode) && + ((newmode ^ oldmode) == 0111)) + newmode = oldmode; + show_modified(oldmode, newmode, + ce->sha1, (changed ? null_sha1 : ce->sha1), ce->name); } - if (detect_rename) - diffcore_rename(detect_rename, diff_score_opt); - if (pickaxe) - diffcore_pickaxe(pickaxe); - if (1 < argc) - diffcore_pathspec(argv + 1); - diff_flush(diff_output_format, 1); + diffcore_std(&diff_options); + diff_flush(&diff_options); return 0; }