Skip to content
Navigation Menu
Toggle navigation
Sign in
In this repository
All GitHub Enterprise
↵
Jump to
↵
No suggested jump to results
In this repository
All GitHub Enterprise
↵
Jump to
↵
In this organization
All GitHub Enterprise
↵
Jump to
↵
In this repository
All GitHub Enterprise
↵
Jump to
↵
Sign in
Reseting focus
You signed in with another tab or window.
Reload
to refresh your session.
You signed out in another tab or window.
Reload
to refresh your session.
You switched accounts on another tab or window.
Reload
to refresh your session.
Dismiss alert
{{ message }}
git-mirror
/
git
Public
Notifications
You must be signed in to change notification settings
Fork
0
Star
0
Code
Issues
0
Pull requests
0
Actions
Projects
0
Security
Insights
Additional navigation options
Code
Issues
Pull requests
Actions
Projects
Security
Insights
Files
efdfd6c
Documentation
arm
compat
contrib
git-gui
gitweb
mozilla-sha1
perl
ppc
t
templates
xdiff
.gitignore
.mailmap
COPYING
GIT-VERSION-GEN
INSTALL
Makefile
README
RelNotes
alloc.c
archive-tar.c
archive-zip.c
archive.h
base85.c
blob.c
blob.h
builtin-add.c
builtin-annotate.c
builtin-apply.c
builtin-archive.c
builtin-blame.c
builtin-branch.c
builtin-cat-file.c
builtin-check-ref-format.c
builtin-checkout-index.c
builtin-commit-tree.c
builtin-config.c
builtin-count-objects.c
builtin-describe.c
builtin-diff-files.c
builtin-diff-index.c
builtin-diff-tree.c
builtin-diff.c
builtin-fmt-merge-msg.c
builtin-for-each-ref.c
builtin-fsck.c
builtin-grep.c
builtin-init-db.c
builtin-log.c
builtin-ls-files.c
builtin-ls-tree.c
builtin-mailinfo.c
builtin-mailsplit.c
builtin-merge-base.c
builtin-merge-file.c
builtin-mv.c
builtin-name-rev.c
builtin-pack-objects.c
builtin-pack-refs.c
builtin-prune-packed.c
builtin-prune.c
builtin-push.c
builtin-read-tree.c
builtin-reflog.c
builtin-rerere.c
builtin-rev-list.c
builtin-rev-parse.c
builtin-rm.c
builtin-runstatus.c
builtin-shortlog.c
builtin-show-branch.c
builtin-show-ref.c
builtin-stripspace.c
builtin-symbolic-ref.c
builtin-tar-tree.c
builtin-unpack-objects.c
builtin-update-index.c
builtin-update-ref.c
builtin-upload-archive.c
builtin-verify-pack.c
builtin-write-tree.c
builtin.h
cache-tree.c
cache-tree.h
cache.h
check-builtins.sh
check-racy.c
color.c
color.h
combine-diff.c
commit.c
commit.h
config.c
config.mak.in
configure.ac
connect.c
convert-objects.c
copy.c
csum-file.c
csum-file.h
ctype.c
daemon.c
date.c
delta.h
diff-delta.c
diff-lib.c
diff.c
diff.h
diffcore-break.c
diffcore-delta.c
diffcore-order.c
diffcore-pickaxe.c
diffcore-rename.c
diffcore.h
dir.c
dir.h
dump-cache-tree.c
entry.c
environment.c
exec_cmd.c
exec_cmd.h
fast-import.c
fetch-pack.c
fetch.c
fetch.h
generate-cmdlist.sh
git-add--interactive.perl
git-am.sh
git-applymbox.sh
git-applypatch.sh
git-archimport.perl
git-bisect.sh
git-checkout.sh
git-clean.sh
git-clone.sh
git-commit.sh
git-compat-util.h
git-cvsexportcommit.perl
git-cvsimport.perl
git-cvsserver.perl
git-fetch.sh
git-gc.sh
git-instaweb.sh
git-lost-found.sh
git-ls-remote.sh
git-merge-octopus.sh
git-merge-one-file.sh
git-merge-ours.sh
git-merge-resolve.sh
git-merge-stupid.sh
git-merge.sh
git-p4import.py
git-parse-remote.sh
git-pull.sh
git-quiltimport.sh
git-rebase.sh
git-relink.perl
git-remote.perl
git-repack.sh
git-request-pull.sh
git-reset.sh
git-revert.sh
git-send-email.perl
git-sh-setup.sh
git-svn.perl
git-svnimport.perl
git-tag.sh
git-verify-tag.sh
git.c
git.spec.in
gitk
grep.c
grep.h
hash-object.c
help.c
http-fetch.c
http-push.c
http.c
http.h
ident.c
imap-send.c
index-pack.c
interpolate.c
interpolate.h
list-objects.c
list-objects.h
local-fetch.c
lockfile.c
log-tree.c
log-tree.h
merge-file.c
merge-index.c
merge-recursive.c
merge-tree.c
mktag.c
mktree.c
object-refs.c
object.c
object.h
pack-check.c
pack-redundant.c
pack.h
pager.c
patch-delta.c
patch-id.c
path-list.c
path-list.h
path.c
peek-remote.c
pkt-line.c
pkt-line.h
quote.c
quote.h
reachable.c
reachable.h
read-cache.c
receive-pack.c
reflog-walk.c
reflog-walk.h
refs.c
refs.h
revision.c
revision.h
rsh.c
rsh.h
run-command.c
run-command.h
send-pack.c
server-info.c
setup.c
sha1_file.c
sha1_name.c
shallow.c
shell.c
show-index.c
sideband.c
sideband.h
ssh-fetch.c
ssh-pull.c
ssh-push.c
ssh-upload.c
strbuf.c
strbuf.h
tag.c
tag.h
tar.h
test-date.c
test-delta.c
test-sha1.c
test-sha1.sh
trace.c
tree-diff.c
tree-walk.c
tree-walk.h
tree.c
tree.h
unpack-file.c
unpack-trees.c
unpack-trees.h
update-server-info.c
upload-pack.c
usage.c
utf8.c
utf8.h
var.c
write_or_die.c
wt-status.c
wt-status.h
xdiff-interface.c
xdiff-interface.h
Breadcrumbs
git
/
diff-lib.c
Blame
Blame
Latest commit
History
History
617 lines (540 loc) · 14.5 KB
Breadcrumbs
git
/
diff-lib.c
Top
File metadata and controls
Code
Blame
617 lines (540 loc) · 14.5 KB
Raw
/* * Copyright (C) 2005 Junio C Hamano */ #include "cache.h" #include "quote.h" #include "commit.h" #include "diff.h" #include "diffcore.h" #include "revision.h" #include "cache-tree.h" #include "path-list.h" /* * diff-files */ static int read_directory(const char *path, struct path_list *list) { DIR *dir; struct dirent *e; if (!(dir = opendir(path))) return error("Could not open directory %s", path); while ((e = readdir(dir))) if (strcmp(".", e->d_name) && strcmp("..", e->d_name)) path_list_insert(xstrdup(e->d_name), list); closedir(dir); return 0; } static int queue_diff(struct diff_options *o, const char *name1, const char *name2) { struct stat st; int mode1 = 0, mode2 = 0; if (name1) { if (stat(name1, &st)) return error("Could not access '%s'", name1); mode1 = st.st_mode; } if (name2) { if (stat(name2, &st)) return error("Could not access '%s'", name1); mode2 = st.st_mode; } if (mode1 && mode2 && S_ISDIR(mode1) != S_ISDIR(mode2)) return error("file/directory conflict: %s, %s", name1, name2); if (S_ISDIR(mode1) || S_ISDIR(mode2)) { char buffer1[PATH_MAX], buffer2[PATH_MAX]; struct path_list p1 = {NULL, 0, 0, 1}, p2 = {NULL, 0, 0, 1}; int len1 = 0, len2 = 0, i1, i2, ret = 0; if (name1 && read_directory(name1, &p1)) return -1; if (name2 && read_directory(name2, &p2)) { path_list_clear(&p1, 0); return -1; } if (name1) { len1 = strlen(name1); if (len1 > 0 && name1[len1 - 1] == '/') len1--; memcpy(buffer1, name1, len1); buffer1[len1++] = '/'; } if (name2) { len2 = strlen(name2); if (len2 > 0 && name2[len2 - 1] == '/') len2--; memcpy(buffer2, name2, len2); buffer2[len2++] = '/'; } for (i1 = i2 = 0; !ret && (i1 < p1.nr || i2 < p2.nr); ) { const char *n1, *n2; int comp; if (i1 == p1.nr) comp = 1; else if (i2 == p2.nr) comp = -1; else comp = strcmp(p1.items[i1].path, p2.items[i2].path); if (comp > 0) n1 = NULL; else { n1 = buffer1; strncpy(buffer1 + len1, p1.items[i1++].path, PATH_MAX - len1); } if (comp < 0) n2 = NULL; else { n2 = buffer2; strncpy(buffer2 + len2, p2.items[i2++].path, PATH_MAX - len2); } ret = queue_diff(o, n1, n2); } path_list_clear(&p1, 0); path_list_clear(&p2, 0); return ret; } else { struct diff_filespec *d1, *d2; if (o->reverse_diff) { unsigned tmp; const char *tmp_c; tmp = mode1; mode1 = mode2; mode2 = tmp; tmp_c = name1; name1 = name2; name2 = tmp_c; } if (!name1) name1 = "/dev/null"; if (!name2) name2 = "/dev/null"; d1 = alloc_filespec(name1); d2 = alloc_filespec(name2); fill_filespec(d1, null_sha1, mode1); fill_filespec(d2, null_sha1, mode2); diff_queue(&diff_queued_diff, d1, d2); return 0; } } static int is_in_index(const char *path) { int len = strlen(path); int pos = cache_name_pos(path, len); char c; if (pos < 0) return 0; if (strncmp(active_cache[pos]->name, path, len)) return 0; c = active_cache[pos]->name[len]; return c == '\0' || c == '/'; } static int handle_diff_files_args(struct rev_info *revs, int argc, const char **argv, int *silent) { *silent = 0; /* revs->max_count == -2 means --no-index */ while (1 < argc && argv[1][0] == '-') { if (!strcmp(argv[1], "--base")) revs->max_count = 1; else if (!strcmp(argv[1], "--ours")) revs->max_count = 2; else if (!strcmp(argv[1], "--theirs")) revs->max_count = 3; else if (!strcmp(argv[1], "-n") || !strcmp(argv[1], "--no-index")) revs->max_count = -2; else if (!strcmp(argv[1], "-q")) *silent = 1; else return error("invalid option: %s", argv[1]); argv++; argc--; } if (revs->max_count == -1 && revs->diffopt.nr_paths == 2) { /* * If two files are specified, and at least one is untracked, * default to no-index. */ read_cache(); if (!is_in_index(revs->diffopt.paths[0]) || !is_in_index(revs->diffopt.paths[1])) revs->max_count = -2; } /* * Make sure there are NO revision (i.e. pending object) parameter, * rev.max_count is reasonable (0 <= n <= 3), * there is no other revision filtering parameters. */ if (revs->pending.nr || revs->max_count > 3 || revs->min_age != -1 || revs->max_age != -1) return error("no revision allowed with diff-files"); if (revs->max_count == -1 && (revs->diffopt.output_format & DIFF_FORMAT_PATCH)) revs->combine_merges = revs->dense_combined_merges = 1; return 0; } int run_diff_files_cmd(struct rev_info *revs, int argc, const char **argv) { int silent_on_removed; if (handle_diff_files_args(revs, argc, argv, &silent_on_removed)) return -1; if (revs->max_count == -2) { if (revs->diffopt.nr_paths != 2) return error("need two files/directories with --no-index"); queue_diff(&revs->diffopt, revs->diffopt.paths[0], revs->diffopt.paths[1]); diffcore_std(&revs->diffopt); diff_flush(&revs->diffopt); return 0; } if (read_cache() < 0) { perror("read_cache"); return -1; } return run_diff_files(revs, silent_on_removed); } int run_diff_files(struct rev_info *revs, int silent_on_removed) { int entries, i; int diff_unmerged_stage = revs->max_count; if (diff_unmerged_stage < 0) diff_unmerged_stage = 2; entries = active_nr; for (i = 0; i < entries; i++) { struct stat st; unsigned int oldmode, newmode; struct cache_entry *ce = active_cache[i]; int changed; if (!ce_path_match(ce, revs->prune_data)) continue; if (ce_stage(ce)) { struct combine_diff_path *dpath; int num_compare_stages = 0; size_t path_len; path_len = ce_namelen(ce); dpath = xmalloc (combine_diff_path_size (5, path_len)); dpath->path = (char *) &(dpath->parent[5]); dpath->next = NULL; dpath->len = path_len; memcpy(dpath->path, ce->name, path_len); dpath->path[path_len] = '\0'; dpath->mode = 0; hashclr(dpath->sha1); memset(&(dpath->parent[0]), 0, sizeof(struct combine_diff_parent)*5); 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++; hashcpy(dpath->parent[stage-2].sha1, nce->sha1); dpath->parent[stage-2].mode = canon_mode(mode); dpath->parent[stage-2].status = DIFF_STATUS_MODIFIED; } /* diff against the proper unmerged stage */ if (stage == diff_unmerged_stage) ce = nce; i++; } /* * Compensate for loop update */ i--; if (revs->combine_merges && num_compare_stages == 2) { show_combined_diff(dpath, 2, revs->dense_combined_merges, revs); free(dpath); continue; } free(dpath); dpath = NULL; /* * Show the diff for the 'ce' if we found the one * from the desired stage. */ diff_unmerge(&revs->diffopt, ce->name, 0, null_sha1); if (ce_stage(ce) != diff_unmerged_stage) continue; } if (lstat(ce->name, &st) < 0) { if (errno != ENOENT && errno != ENOTDIR) { perror(ce->name); continue; } if (silent_on_removed) continue; diff_addremove(&revs->diffopt, '-', ntohl(ce->ce_mode), ce->sha1, ce->name, NULL); continue; } changed = ce_match_stat(ce, &st, 0); if (!changed && !revs->diffopt.find_copies_harder) continue; oldmode = ntohl(ce->ce_mode); newmode = canon_mode(st.st_mode); if (!trust_executable_bit && S_ISREG(newmode) && S_ISREG(oldmode) && ((newmode ^ oldmode) == 0111)) newmode = oldmode; diff_change(&revs->diffopt, oldmode, newmode, ce->sha1, (changed ? null_sha1 : ce->sha1), ce->name, NULL); } diffcore_std(&revs->diffopt); diff_flush(&revs->diffopt); return 0; } /* * diff-index */ /* A file entry went away or appeared */ static void diff_index_show_file(struct rev_info *revs, const char *prefix, struct cache_entry *ce, unsigned char *sha1, unsigned int mode) { diff_addremove(&revs->diffopt, prefix[0], ntohl(mode), sha1, ce->name, NULL); } static int get_stat_data(struct cache_entry *ce, unsigned char **sha1p, unsigned int *modep, int cached, int match_missing) { unsigned char *sha1 = ce->sha1; unsigned int mode = ce->ce_mode; if (!cached) { static unsigned char no_sha1[20]; int changed; struct stat st; if (lstat(ce->name, &st) < 0) { if (errno == ENOENT && match_missing) { *sha1p = sha1; *modep = mode; return 0; } return -1; } changed = ce_match_stat(ce, &st, 0); if (changed) { mode = ce_mode_from_stat(ce, st.st_mode); sha1 = no_sha1; } } *sha1p = sha1; *modep = mode; return 0; } static void show_new_file(struct rev_info *revs, struct cache_entry *new, int cached, int match_missing) { unsigned char *sha1; unsigned int mode; /* New file in the index: it might actually be different in * the working copy. */ if (get_stat_data(new, &sha1, &mode, cached, match_missing) < 0) return; diff_index_show_file(revs, "+", new, sha1, mode); } static int show_modified(struct rev_info *revs, struct cache_entry *old, struct cache_entry *new, int report_missing, int cached, int match_missing) { unsigned int mode, oldmode; unsigned char *sha1; if (get_stat_data(new, &sha1, &mode, cached, match_missing) < 0) { if (report_missing) diff_index_show_file(revs, "-", old, old->sha1, old->ce_mode); return -1; } if (revs->combine_merges && !cached && (hashcmp(sha1, old->sha1) || hashcmp(old->sha1, new->sha1))) { struct combine_diff_path *p; int pathlen = ce_namelen(new); p = xmalloc(combine_diff_path_size(2, pathlen)); p->path = (char *) &p->parent[2]; p->next = NULL; p->len = pathlen; memcpy(p->path, new->name, pathlen); p->path[pathlen] = 0; p->mode = ntohl(mode); hashclr(p->sha1); memset(p->parent, 0, 2 * sizeof(struct combine_diff_parent)); p->parent[0].status = DIFF_STATUS_MODIFIED; p->parent[0].mode = ntohl(new->ce_mode); hashcpy(p->parent[0].sha1, new->sha1); p->parent[1].status = DIFF_STATUS_MODIFIED; p->parent[1].mode = ntohl(old->ce_mode); hashcpy(p->parent[1].sha1, old->sha1); show_combined_diff(p, 2, revs->dense_combined_merges, revs); free(p); return 0; } oldmode = old->ce_mode; if (mode == oldmode && !hashcmp(sha1, old->sha1) && !revs->diffopt.find_copies_harder) return 0; mode = ntohl(mode); oldmode = ntohl(oldmode); diff_change(&revs->diffopt, oldmode, mode, old->sha1, sha1, old->name, NULL); return 0; } static int diff_cache(struct rev_info *revs, struct cache_entry **ac, int entries, const char **pathspec, int cached, int match_missing) { while (entries) { struct cache_entry *ce = *ac; int same = (entries > 1) && ce_same_name(ce, ac[1]); if (!ce_path_match(ce, pathspec)) goto skip_entry; switch (ce_stage(ce)) { case 0: /* No stage 1 entry? That means it's a new file */ if (!same) { show_new_file(revs, ce, cached, match_missing); break; } /* Show difference between old and new */ show_modified(revs, ac[1], ce, 1, cached, match_missing); break; case 1: /* No stage 3 (merge) entry? * That means it's been deleted. */ if (!same) { diff_index_show_file(revs, "-", ce, ce->sha1, ce->ce_mode); break; } /* We come here with ce pointing at stage 1 * (original tree) and ac[1] pointing at stage * 3 (unmerged). show-modified with * report-missing set to false does not say the * file is deleted but reports true if work * tree does not have it, in which case we * fall through to report the unmerged state. * Otherwise, we show the differences between * the original tree and the work tree. */ if (!cached && !show_modified(revs, ce, ac[1], 0, cached, match_missing)) break; diff_unmerge(&revs->diffopt, ce->name, ntohl(ce->ce_mode), ce->sha1); break; case 3: diff_unmerge(&revs->diffopt, ce->name, 0, null_sha1); break; default: die("impossible cache entry stage"); } skip_entry: /* * Ignore all the different stages for this file, * we've handled the relevant cases now. */ do { ac++; entries--; } while (entries && ce_same_name(ce, ac[0])); } return 0; } /* * This turns all merge entries into "stage 3". That guarantees that * when we read in the new tree (into "stage 1"), we won't lose sight * of the fact that we had unmerged entries. */ static void mark_merge_entries(void) { int i; for (i = 0; i < active_nr; i++) { struct cache_entry *ce = active_cache[i]; if (!ce_stage(ce)) continue; ce->ce_flags |= htons(CE_STAGEMASK); } } int run_diff_index(struct rev_info *revs, int cached) { int ret; struct object *ent; struct tree *tree; const char *tree_name; int match_missing = 0; /* * Backward compatibility wart - "diff-index -m" does * not mean "do not ignore merges", but totally different. */ if (!revs->ignore_merges) match_missing = 1; mark_merge_entries(); ent = revs->pending.objects[0].item; tree_name = revs->pending.objects[0].name; tree = parse_tree_indirect(ent->sha1); if (!tree) return error("bad tree object %s", tree_name); if (read_tree(tree, 1, revs->prune_data)) return error("unable to read tree object %s", tree_name); ret = diff_cache(revs, active_cache, active_nr, revs->prune_data, cached, match_missing); diffcore_std(&revs->diffopt); diff_flush(&revs->diffopt); return ret; } int do_diff_cache(const unsigned char *tree_sha1, struct diff_options *opt) { struct tree *tree; struct rev_info revs; int i; struct cache_entry **dst; struct cache_entry *last = NULL; /* * This is used by git-blame to run diff-cache internally; * it potentially needs to repeatedly run this, so we will * start by removing the higher order entries the last round * left behind. */ dst = active_cache; for (i = 0; i < active_nr; i++) { struct cache_entry *ce = active_cache[i]; if (ce_stage(ce)) { if (last && !strcmp(ce->name, last->name)) continue; cache_tree_invalidate_path(active_cache_tree, ce->name); last = ce; ce->ce_mode = 0; ce->ce_flags &= ~htons(CE_STAGEMASK); } *dst++ = ce; } active_nr = dst - active_cache; init_revisions(&revs, NULL); revs.prune_data = opt->paths; tree = parse_tree_indirect(tree_sha1); if (!tree) die("bad tree object %s", sha1_to_hex(tree_sha1)); if (read_tree(tree, 1, opt->paths)) return error("unable to read tree %s", sha1_to_hex(tree_sha1)); return diff_cache(&revs, active_cache, active_nr, revs.prune_data, 1, 0); }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
You can’t perform that action at this time.