mirror of
https://github.com/git/git
synced 2024-08-29 04:29:22 +00:00
![Elijah Newren](/assets/img/avatar_default.png)
Each of these were checked with gcc -E -I. ${SOURCE_FILE} | grep ${HEADER_FILE} to ensure that removing the direct inclusion of the header actually resulted in that header no longer being included at all (i.e. that no other header pulled it in transitively). ...except for a few cases where we verified that although the header was brought in transitively, nothing from it was directly used in that source file. These cases were: * builtin/credential-cache.c * builtin/pull.c * builtin/send-pack.c Signed-off-by: Elijah Newren <newren@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
236 lines
6.3 KiB
C
236 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 "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);
|
|
}
|