mirror of
https://github.com/git/git
synced 2024-08-28 20:20:07 +00:00
![Jeff King](/assets/img/avatar_default.png)
The setup_revision_opt struct has a "tweak" function pointer, which can be used to adjust parameters after setup_revisions() parses arguments, but before it finalizes setup. In addition to the rev_info struct, the callback receives a pointer to the setup_revision_opt, as well. But none of the existing callbacks looks at the extra "opt" parameter, leading to -Wunused-parameter warnings. We could mark it as UNUSED, but instead let's remove it entirely. It's conceivable that it could be useful for a callback to have access to the "opt" struct. But in the 13 years that this mechanism has existed, nobody has used it. So let's just drop it in the name of simplifying. Signed-off-by: Jeff King <peff@peff.net> Signed-off-by: Junio C Hamano <gitster@pobox.com>
237 lines
6.3 KiB
C
237 lines
6.3 KiB
C
#define USE_THE_INDEX_VARIABLE
|
|
#include "builtin.h"
|
|
#include "config.h"
|
|
#include "diff.h"
|
|
#include "commit.h"
|
|
#include "gettext.h"
|
|
#include "hex.h"
|
|
#include "log-tree.h"
|
|
#include "submodule.h"
|
|
#include "read-cache-ll.h"
|
|
#include "repository.h"
|
|
#include "revision.h"
|
|
#include "tree.h"
|
|
|
|
static struct rev_info log_tree_opt;
|
|
|
|
static int diff_tree_commit_oid(const struct object_id *oid)
|
|
{
|
|
struct commit *commit = lookup_commit_reference(the_repository, oid);
|
|
if (!commit)
|
|
return -1;
|
|
return log_tree_commit(&log_tree_opt, commit);
|
|
}
|
|
|
|
/* Diff one or more commits. */
|
|
static int stdin_diff_commit(struct commit *commit, const char *p)
|
|
{
|
|
struct object_id oid;
|
|
struct commit_list **pptr = NULL;
|
|
|
|
/* Graft the fake parents locally to the commit */
|
|
while (isspace(*p++) && !parse_oid_hex(p, &oid, &p)) {
|
|
struct commit *parent = lookup_commit(the_repository, &oid);
|
|
if (!pptr) {
|
|
/* Free the real parent list */
|
|
free_commit_list(commit->parents);
|
|
commit->parents = NULL;
|
|
pptr = &(commit->parents);
|
|
}
|
|
if (parent) {
|
|
pptr = &commit_list_insert(parent, pptr)->next;
|
|
}
|
|
}
|
|
return log_tree_commit(&log_tree_opt, commit);
|
|
}
|
|
|
|
/* Diff two trees. */
|
|
static int stdin_diff_trees(struct tree *tree1, const char *p)
|
|
{
|
|
struct object_id oid;
|
|
struct tree *tree2;
|
|
if (!isspace(*p++) || parse_oid_hex(p, &oid, &p) || *p)
|
|
return error("Need exactly two trees, separated by a space");
|
|
tree2 = lookup_tree(the_repository, &oid);
|
|
if (!tree2 || parse_tree(tree2))
|
|
return -1;
|
|
printf("%s %s\n", oid_to_hex(&tree1->object.oid),
|
|
oid_to_hex(&tree2->object.oid));
|
|
diff_tree_oid(&tree1->object.oid, &tree2->object.oid,
|
|
"", &log_tree_opt.diffopt);
|
|
log_tree_diff_flush(&log_tree_opt);
|
|
return 0;
|
|
}
|
|
|
|
static int diff_tree_stdin(char *line)
|
|
{
|
|
int len = strlen(line);
|
|
struct object_id oid;
|
|
struct object *obj;
|
|
const char *p;
|
|
|
|
if (!len || line[len-1] != '\n')
|
|
return -1;
|
|
line[len-1] = 0;
|
|
if (parse_oid_hex(line, &oid, &p))
|
|
return -1;
|
|
obj = parse_object(the_repository, &oid);
|
|
if (!obj)
|
|
return -1;
|
|
if (obj->type == OBJ_COMMIT)
|
|
return stdin_diff_commit((struct commit *)obj, p);
|
|
if (obj->type == OBJ_TREE)
|
|
return stdin_diff_trees((struct tree *)obj, p);
|
|
error("Object %s is a %s, not a commit or tree",
|
|
oid_to_hex(&oid), type_name(obj->type));
|
|
return -1;
|
|
}
|
|
|
|
static const char diff_tree_usage[] =
|
|
"git diff-tree [--stdin] [-m] [-s] [-v] [--no-commit-id] [--pretty]\n"
|
|
" [-t] [-r] [-c | --cc] [--combined-all-paths] [--root] [--merge-base]\n"
|
|
" [<common-diff-options>] <tree-ish> [<tree-ish>] [<path>...]\n"
|
|
"\n"
|
|
" -r diff recursively\n"
|
|
" -c show combined diff for merge commits\n"
|
|
" --cc show combined diff for merge commits removing uninteresting hunks\n"
|
|
" --combined-all-paths\n"
|
|
" show name of file in all parents for combined diffs\n"
|
|
" --root include the initial commit as diff against /dev/null\n"
|
|
COMMON_DIFF_OPTIONS_HELP;
|
|
|
|
static void diff_tree_tweak_rev(struct rev_info *rev)
|
|
{
|
|
if (!rev->diffopt.output_format) {
|
|
if (rev->dense_combined_merges)
|
|
rev->diffopt.output_format = DIFF_FORMAT_PATCH;
|
|
else
|
|
rev->diffopt.output_format = DIFF_FORMAT_RAW;
|
|
}
|
|
}
|
|
|
|
int cmd_diff_tree(int argc, const char **argv, const char *prefix)
|
|
{
|
|
char line[1000];
|
|
struct object *tree1, *tree2;
|
|
static struct rev_info *opt = &log_tree_opt;
|
|
struct setup_revision_opt s_r_opt;
|
|
struct userformat_want w;
|
|
int read_stdin = 0;
|
|
int merge_base = 0;
|
|
|
|
if (argc == 2 && !strcmp(argv[1], "-h"))
|
|
usage(diff_tree_usage);
|
|
|
|
git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
|
|
|
|
prepare_repo_settings(the_repository);
|
|
the_repository->settings.command_requires_full_index = 0;
|
|
|
|
repo_init_revisions(the_repository, opt, prefix);
|
|
if (repo_read_index(the_repository) < 0)
|
|
die(_("index file corrupt"));
|
|
opt->abbrev = 0;
|
|
opt->diff = 1;
|
|
opt->disable_stdin = 1;
|
|
memset(&s_r_opt, 0, sizeof(s_r_opt));
|
|
s_r_opt.tweak = diff_tree_tweak_rev;
|
|
|
|
prefix = precompose_argv_prefix(argc, argv, prefix);
|
|
argc = setup_revisions(argc, argv, opt, &s_r_opt);
|
|
|
|
memset(&w, 0, sizeof(w));
|
|
userformat_find_requirements(NULL, &w);
|
|
|
|
if (!opt->show_notes_given && w.notes)
|
|
opt->show_notes = 1;
|
|
if (opt->show_notes)
|
|
load_display_notes(&opt->notes_opt);
|
|
|
|
while (--argc > 0) {
|
|
const char *arg = *++argv;
|
|
|
|
if (!strcmp(arg, "--stdin")) {
|
|
read_stdin = 1;
|
|
continue;
|
|
}
|
|
if (!strcmp(arg, "--merge-base")) {
|
|
merge_base = 1;
|
|
continue;
|
|
}
|
|
usage(diff_tree_usage);
|
|
}
|
|
|
|
if (read_stdin && merge_base)
|
|
die(_("options '%s' and '%s' cannot be used together"), "--stdin", "--merge-base");
|
|
if (merge_base && opt->pending.nr != 2)
|
|
die(_("--merge-base only works with two commits"));
|
|
|
|
opt->diffopt.rotate_to_strict = 1;
|
|
|
|
/*
|
|
* NOTE! We expect "a..b" to expand to "^a b" but it is
|
|
* perfectly valid for revision range parser to yield "b ^a",
|
|
* which means the same thing. If we get the latter, i.e. the
|
|
* second one is marked UNINTERESTING, we recover the original
|
|
* order the user gave, i.e. "a..b", by swapping the trees.
|
|
*/
|
|
switch (opt->pending.nr) {
|
|
case 0:
|
|
if (!read_stdin)
|
|
usage(diff_tree_usage);
|
|
break;
|
|
case 1:
|
|
tree1 = opt->pending.objects[0].item;
|
|
diff_tree_commit_oid(&tree1->oid);
|
|
break;
|
|
case 2:
|
|
tree1 = opt->pending.objects[0].item;
|
|
tree2 = opt->pending.objects[1].item;
|
|
if (merge_base) {
|
|
struct object_id oid;
|
|
|
|
diff_get_merge_base(opt, &oid);
|
|
tree1 = lookup_object(the_repository, &oid);
|
|
} else if (tree2->flags & UNINTERESTING) {
|
|
SWAP(tree2, tree1);
|
|
}
|
|
diff_tree_oid(&tree1->oid, &tree2->oid, "", &opt->diffopt);
|
|
log_tree_diff_flush(opt);
|
|
break;
|
|
}
|
|
|
|
if (read_stdin) {
|
|
int saved_nrl = 0;
|
|
int saved_dcctc = 0;
|
|
|
|
opt->diffopt.rotate_to_strict = 0;
|
|
opt->diffopt.no_free = 1;
|
|
if (opt->diffopt.detect_rename) {
|
|
if (!the_index.cache)
|
|
repo_read_index(the_repository);
|
|
opt->diffopt.setup |= DIFF_SETUP_USE_SIZE_CACHE;
|
|
}
|
|
while (fgets(line, sizeof(line), stdin)) {
|
|
struct object_id oid;
|
|
|
|
if (get_oid_hex(line, &oid)) {
|
|
fputs(line, stdout);
|
|
fflush(stdout);
|
|
}
|
|
else {
|
|
diff_tree_stdin(line);
|
|
if (saved_nrl < opt->diffopt.needed_rename_limit)
|
|
saved_nrl = opt->diffopt.needed_rename_limit;
|
|
if (opt->diffopt.degraded_cc_to_c)
|
|
saved_dcctc = 1;
|
|
}
|
|
}
|
|
opt->diffopt.degraded_cc_to_c = saved_dcctc;
|
|
opt->diffopt.needed_rename_limit = saved_nrl;
|
|
opt->diffopt.no_free = 0;
|
|
diff_free(&opt->diffopt);
|
|
}
|
|
|
|
return diff_result_code(&opt->diffopt, 0);
|
|
}
|