blob: b73cc1859a49eb8b7f3cf7321680dfda4d96c705 [file] [log] [blame]
Junio C Hamanobe3cfa82005-04-26 09:25:05 -07001/*
2 * Copyright (C) 2005 Junio C Hamano
3 */
Junio C Hamano86436c22005-04-25 18:22:47 -07004#include "cache.h"
Junio C Hamano6fb737b2005-07-07 23:58:32 -07005#include "quote.h"
Junio C Hamano6973dca2006-04-21 23:57:45 -07006#include "commit.h"
Junio C Hamano86436c22005-04-25 18:22:47 -07007#include "diff.h"
Junio C Hamano427dcb42005-05-21 02:39:09 -07008#include "diffcore.h"
Junio C Hamano6973dca2006-04-21 23:57:45 -07009#include "revision.h"
Junio C Hamano1cfe7732007-01-30 01:11:08 -080010#include "cache-tree.h"
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -080011#include "unpack-trees.h"
Junio C Hamano948dd342008-03-30 17:29:48 -070012#include "refs.h"
Jens Lehmannee6fc512010-01-16 18:42:24 +010013#include "submodule.h"
Nguyễn Thái Ngọc Duy429bb402014-01-24 20:40:28 +070014#include "dir.h"
Ben Peart883e2482017-09-22 12:35:40 -040015#include "fsmonitor.h"
Denton Liu177a8302020-09-20 04:22:23 -070016#include "commit-reach.h"
Junio C Hamano427dcb42005-05-21 02:39:09 -070017
Junio C Hamanob46f0b62005-05-04 01:45:24 -070018/*
Junio C Hamano6973dca2006-04-21 23:57:45 -070019 * diff-files
Junio C Hamanob46f0b62005-05-04 01:45:24 -070020 */
Junio C Hamano6973dca2006-04-21 23:57:45 -070021
Junio C Hamano948dd342008-03-30 17:29:48 -070022/*
Junio C Hamano1392a372008-05-03 17:04:42 -070023 * Has the work tree entity been removed?
24 *
25 * Return 1 if it was removed from the work tree, 0 if an entity to be
26 * compared with the cache entry ce still exists (the latter includes
27 * the case where a directory that is not a submodule repository
28 * exists for ce that is a submodule -- it is a submodule that is not
29 * checked out). Return negative for an error.
Junio C Hamano948dd342008-03-30 17:29:48 -070030 */
Linus Torvaldsc40641b2008-05-09 09:21:07 -070031static int check_removed(const struct cache_entry *ce, struct stat *st)
Junio C Hamano948dd342008-03-30 17:29:48 -070032{
33 if (lstat(ce->name, st) < 0) {
Junio C Hamanoc7054202017-05-30 09:23:33 +090034 if (!is_missing_file_error(errno))
Junio C Hamano948dd342008-03-30 17:29:48 -070035 return -1;
36 return 1;
37 }
Kjetil Barvik57199892009-02-09 21:54:06 +010038 if (has_symlink_leading_path(ce->name, ce_namelen(ce)))
Junio C Hamano948dd342008-03-30 17:29:48 -070039 return 1;
40 if (S_ISDIR(st->st_mode)) {
brian m. carlson1053fe82017-10-15 22:07:06 +000041 struct object_id sub;
Junio C Hamano1392a372008-05-03 17:04:42 -070042
43 /*
44 * If ce is already a gitlink, we can have a plain
45 * directory (i.e. the submodule is not checked out),
46 * or a checked out submodule. Either case this is not
47 * a case where something was removed from the work tree,
48 * so we will return 0.
49 *
50 * Otherwise, if the directory is not a submodule
51 * repository, that means ce which was a blob turned into
52 * a directory --- the blob was removed!
53 */
54 if (!S_ISGITLINK(ce->ce_mode) &&
brian m. carlsona98e6102017-10-15 22:07:07 +000055 resolve_gitlink_ref(ce->name, "HEAD", &sub))
Junio C Hamano948dd342008-03-30 17:29:48 -070056 return 1;
57 }
58 return 0;
59}
Johannes Schindelind516c2d2007-02-22 21:50:10 +010060
Jens Lehmannae6d5c12010-03-11 22:50:25 +010061/*
62 * Has a file changed or has a submodule new commits or a dirty work tree?
63 *
64 * Return 1 when changes are detected, 0 otherwise. If the DIRTY_SUBMODULES
65 * option is set, the caller does not only want to know if a submodule is
66 * modified at all but wants to know all the conditions that are met (new
67 * commits, untracked content and/or modified content).
68 */
69static int match_stat_with_submodule(struct diff_options *diffopt,
René Scharfeeb9ae4b2013-06-02 17:46:55 +020070 const struct cache_entry *ce,
71 struct stat *st, unsigned ce_option,
72 unsigned *dirty_submodule)
Jens Lehmannae6d5c12010-03-11 22:50:25 +010073{
Nguyễn Thái Ngọc Duy5adbb402018-09-21 17:57:26 +020074 int changed = ie_match_stat(diffopt->repo->index, ce, st, ce_option);
Jens Lehmannaee9c7d2010-08-06 00:39:25 +020075 if (S_ISGITLINK(ce->ce_mode)) {
Brandon Williams02f2f562017-10-31 11:19:05 -070076 struct diff_flags orig_flags = diffopt->flags;
Brandon Williams0d1e0e72017-10-31 11:19:11 -070077 if (!diffopt->flags.override_submodule_config)
Jens Lehmannaee9c7d2010-08-06 00:39:25 +020078 set_diffopt_flags_from_submodule_config(diffopt, ce->name);
Brandon Williams0d1e0e72017-10-31 11:19:11 -070079 if (diffopt->flags.ignore_submodules)
Jens Lehmannaee9c7d2010-08-06 00:39:25 +020080 changed = 0;
Brandon Williams0d1e0e72017-10-31 11:19:11 -070081 else if (!diffopt->flags.ignore_dirty_submodules &&
82 (!changed || diffopt->flags.dirty_submodules))
Brandon Williams3b69dae2017-10-31 11:19:08 -070083 *dirty_submodule = is_submodule_modified(ce->name,
Brandon Williams0d1e0e72017-10-31 11:19:11 -070084 diffopt->flags.ignore_untracked_in_submodules);
Jens Lehmannaee9c7d2010-08-06 00:39:25 +020085 diffopt->flags = orig_flags;
Jens Lehmannae6d5c12010-03-11 22:50:25 +010086 }
87 return changed;
88}
89
Junio C Hamano4bd5b7d2007-11-10 00:15:03 -080090int run_diff_files(struct rev_info *revs, unsigned int option)
Junio C Hamanob46f0b62005-05-04 01:45:24 -070091{
Junio C Hamano6973dca2006-04-21 23:57:45 -070092 int entries, i;
93 int diff_unmerged_stage = revs->max_count;
Junio C Hamanofb63d7f2007-11-09 18:22:52 -080094 unsigned ce_option = ((option & DIFF_RACY_IS_MODIFIED)
95 ? CE_MATCH_RACY_IS_DIRTY : 0);
Nguyễn Thái Ngọc Duyca54d9b2018-01-27 19:27:56 +070096 uint64_t start = getnanotime();
Nguyễn Thái Ngọc Duy5adbb402018-09-21 17:57:26 +020097 struct index_state *istate = revs->diffopt.repo->index;
Junio C Hamano5c975582005-05-19 03:32:35 -070098
Junio C Hamanoa5a818e2008-08-18 20:08:09 -070099 diff_set_mnemonic_prefix(&revs->diffopt, "i/", "w/");
100
Alex Vandiverc9052a82020-10-20 13:40:58 +0000101 refresh_fsmonitor(istate);
102
Junio C Hamano6973dca2006-04-21 23:57:45 -0700103 if (diff_unmerged_stage < 0)
104 diff_unmerged_stage = 2;
Nguyễn Thái Ngọc Duy5adbb402018-09-21 17:57:26 +0200105 entries = istate->cache_nr;
Junio C Hamano6973dca2006-04-21 23:57:45 -0700106 for (i = 0; i < entries; i++) {
Junio C Hamano6973dca2006-04-21 23:57:45 -0700107 unsigned int oldmode, newmode;
Nguyễn Thái Ngọc Duy5adbb402018-09-21 17:57:26 +0200108 struct cache_entry *ce = istate->cache[i];
Junio C Hamano6973dca2006-04-21 23:57:45 -0700109 int changed;
Jens Lehmanne3d42c42010-01-18 21:26:18 +0100110 unsigned dirty_submodule = 0;
Brandon Williams55497b82017-05-30 10:30:48 -0700111 const struct object_id *old_oid, *new_oid;
Junio C Hamanof0c6b2a2005-05-27 15:56:38 -0700112
Junio C Hamano28b92642011-05-31 09:14:17 -0700113 if (diff_can_quit_early(&revs->diffopt))
Junio C Hamano822cac02007-03-14 11:12:51 -0700114 break;
115
Nguyễn Thái Ngọc Duy5adbb402018-09-21 17:57:26 +0200116 if (!ce_path_match(istate, ce, &revs->prune_data, NULL))
Linus Torvalds8676eb42006-02-26 15:51:24 -0800117 continue;
Linus Torvalds8676eb42006-02-26 15:51:24 -0800118
Junio C Hamano6973dca2006-04-21 23:57:45 -0700119 if (ce_stage(ce)) {
Florian Forsterb4b15502006-06-18 17:18:05 +0200120 struct combine_diff_path *dpath;
Junio C Hamano095ce952011-04-22 16:19:27 -0700121 struct diff_filepair *pair;
122 unsigned int wt_mode = 0;
Junio C Hamano6973dca2006-04-21 23:57:45 -0700123 int num_compare_stages = 0;
Florian Forsterb4b15502006-06-18 17:18:05 +0200124 size_t path_len;
Jeff King53048102014-05-14 18:13:06 -0400125 struct stat st;
Linus Torvalds8676eb42006-02-26 15:51:24 -0800126
Florian Forsterb4b15502006-06-18 17:18:05 +0200127 path_len = ce_namelen(ce);
128
Junio C Hamano4fc970c2007-02-25 22:24:47 -0800129 dpath = xmalloc(combine_diff_path_size(5, path_len));
Florian Forsterb4b15502006-06-18 17:18:05 +0200130 dpath->path = (char *) &(dpath->parent[5]);
131
132 dpath->next = NULL;
Florian Forsterb4b15502006-06-18 17:18:05 +0200133 memcpy(dpath->path, ce->name, path_len);
134 dpath->path[path_len] = '\0';
brian m. carlson1ff57c12015-03-13 23:39:33 +0000135 oidclr(&dpath->oid);
Florian Forsterb4b15502006-06-18 17:18:05 +0200136 memset(&(dpath->parent[0]), 0,
Junio C Hamano4fc970c2007-02-25 22:24:47 -0800137 sizeof(struct combine_diff_parent)*5);
138
Linus Torvaldsc40641b2008-05-09 09:21:07 -0700139 changed = check_removed(ce, &st);
Junio C Hamanof58dbf22008-03-30 17:30:08 -0700140 if (!changed)
Junio C Hamano095ce952011-04-22 16:19:27 -0700141 wt_mode = ce_mode_from_stat(ce, st.st_mode);
Junio C Hamanof58dbf22008-03-30 17:30:08 -0700142 else {
143 if (changed < 0) {
Junio C Hamano4fc970c2007-02-25 22:24:47 -0800144 perror(ce->name);
145 continue;
146 }
Junio C Hamano095ce952011-04-22 16:19:27 -0700147 wt_mode = 0;
Junio C Hamano4fc970c2007-02-25 22:24:47 -0800148 }
Junio C Hamano095ce952011-04-22 16:19:27 -0700149 dpath->mode = wt_mode;
Junio C Hamanobe3cfa82005-04-26 09:25:05 -0700150
Junio C Hamano6973dca2006-04-21 23:57:45 -0700151 while (i < entries) {
Nguyễn Thái Ngọc Duy5adbb402018-09-21 17:57:26 +0200152 struct cache_entry *nce = istate->cache[i];
Junio C Hamano6973dca2006-04-21 23:57:45 -0700153 int stage;
Junio C Hamanobe3cfa82005-04-26 09:25:05 -0700154
Junio C Hamano6973dca2006-04-21 23:57:45 -0700155 if (strcmp(ce->name, nce->name))
156 break;
Junio C Hamanobe3cfa82005-04-26 09:25:05 -0700157
Junio C Hamano6973dca2006-04-21 23:57:45 -0700158 /* Stage #2 (ours) is the first parent,
159 * stage #3 (theirs) is the second.
160 */
161 stage = ce_stage(nce);
162 if (2 <= stage) {
Linus Torvalds7a51ed62008-01-14 16:03:17 -0800163 int mode = nce->ce_mode;
Junio C Hamano6973dca2006-04-21 23:57:45 -0700164 num_compare_stages++;
brian m. carlson99d1a982016-09-05 20:07:52 +0000165 oidcpy(&dpath->parent[stage - 2].oid,
166 &nce->oid);
Linus Torvalds7a51ed62008-01-14 16:03:17 -0800167 dpath->parent[stage-2].mode = ce_mode_from_stat(nce, mode);
Florian Forsterb4b15502006-06-18 17:18:05 +0200168 dpath->parent[stage-2].status =
Junio C Hamano6973dca2006-04-21 23:57:45 -0700169 DIFF_STATUS_MODIFIED;
170 }
Junio C Hamanocebff982006-03-25 23:12:17 -0800171
Junio C Hamano6973dca2006-04-21 23:57:45 -0700172 /* diff against the proper unmerged stage */
173 if (stage == diff_unmerged_stage)
174 ce = nce;
175 i++;
H. Peter Anvin1b1480f2005-11-21 14:17:12 -0800176 }
Junio C Hamano6973dca2006-04-21 23:57:45 -0700177 /*
178 * Compensate for loop update
179 */
180 i--;
Junio C Hamano0e3994f2005-06-03 01:37:54 -0700181
Junio C Hamano6973dca2006-04-21 23:57:45 -0700182 if (revs->combine_merges && num_compare_stages == 2) {
Sergey Organovd01141d2020-09-29 14:31:22 +0300183 show_combined_diff(dpath, 2, revs);
Florian Forsterb4b15502006-06-18 17:18:05 +0200184 free(dpath);
Junio C Hamano15d061b2005-05-27 15:55:55 -0700185 continue;
186 }
Ævar Arnfjörð Bjarmason6a83d902017-06-15 23:15:46 +0000187 FREE_AND_NULL(dpath);
Junio C Hamano6973dca2006-04-21 23:57:45 -0700188
189 /*
190 * Show the diff for the 'ce' if we found the one
191 * from the desired stage.
Junio C Hamano25d5ea42005-05-24 01:10:48 -0700192 */
Junio C Hamano095ce952011-04-22 16:19:27 -0700193 pair = diff_unmerge(&revs->diffopt, ce->name);
194 if (wt_mode)
195 pair->two->mode = wt_mode;
Junio C Hamano6973dca2006-04-21 23:57:45 -0700196 if (ce_stage(ce) != diff_unmerged_stage)
197 continue;
198 }
199
Junio C Hamano125fd982010-01-24 00:10:20 -0800200 if (ce_uptodate(ce) || ce_skip_worktree(ce))
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800201 continue;
Junio C Hamanof58dbf22008-03-30 17:30:08 -0700202
Alex Vandiverc9052a82020-10-20 13:40:58 +0000203 /*
204 * When CE_VALID is set (via "update-index --assume-unchanged"
205 * or via adding paths while core.ignorestat is set to true),
206 * the user has promised that the working tree file for that
207 * path will not be modified. When CE_FSMONITOR_VALID is true,
208 * the fsmonitor knows that the path hasn't been modified since
209 * we refreshed the cached stat information. In either case,
210 * we do not have to stat to see if the path has been removed
211 * or modified.
212 */
213 if (ce->ce_flags & (CE_VALID | CE_FSMONITOR_VALID)) {
Jeff King53048102014-05-14 18:13:06 -0400214 changed = 0;
215 newmode = ce->ce_mode;
216 } else {
217 struct stat st;
218
219 changed = check_removed(ce, &st);
220 if (changed) {
221 if (changed < 0) {
222 perror(ce->name);
223 continue;
224 }
225 diff_addremove(&revs->diffopt, '-', ce->ce_mode,
Brandon Williamsc26022e2017-05-30 10:30:47 -0700226 &ce->oid,
brian m. carlson99d1a982016-09-05 20:07:52 +0000227 !is_null_oid(&ce->oid),
Jeff King53048102014-05-14 18:13:06 -0400228 ce->name, 0);
Junio C Hamano6973dca2006-04-21 23:57:45 -0700229 continue;
Nguyễn Thái Ngọc Duy425a28e2016-10-24 17:42:19 +0700230 } else if (revs->diffopt.ita_invisible_in_index &&
231 ce_intent_to_add(ce)) {
Raymond E. Pascocb0dd222020-08-08 03:53:23 -0400232 newmode = ce_mode_from_stat(ce, st.st_mode);
233 diff_addremove(&revs->diffopt, '+', newmode,
Johannes Schindelin85953a32020-07-01 21:19:06 +0000234 &null_oid, 0, ce->name, 0);
Nguyễn Thái Ngọc Duy425a28e2016-10-24 17:42:19 +0700235 continue;
Junio C Hamano25d5ea42005-05-24 01:10:48 -0700236 }
Jeff King53048102014-05-14 18:13:06 -0400237
238 changed = match_stat_with_submodule(&revs->diffopt, ce, &st,
239 ce_option, &dirty_submodule);
240 newmode = ce_mode_from_stat(ce, st.st_mode);
Junio C Hamanobceafe72005-05-23 18:14:03 -0700241 }
Jeff King53048102014-05-14 18:13:06 -0400242
Jens Lehmann85adbf22010-03-12 22:23:52 +0100243 if (!changed && !dirty_submodule) {
Junio C Hamano8fa29602008-03-30 12:39:25 -0700244 ce_mark_uptodate(ce);
Johannes Schindelinb5a81692019-05-24 05:23:48 -0700245 mark_fsmonitor_valid(istate, ce);
Brandon Williams0d1e0e72017-10-31 11:19:11 -0700246 if (!revs->diffopt.flags.find_copies_harder)
Junio C Hamano8fa29602008-03-30 12:39:25 -0700247 continue;
248 }
Linus Torvalds7a51ed62008-01-14 16:03:17 -0800249 oldmode = ce->ce_mode;
Brandon Williams55497b82017-05-30 10:30:48 -0700250 old_oid = &ce->oid;
251 new_oid = changed ? &null_oid : &ce->oid;
Junio C Hamano6973dca2006-04-21 23:57:45 -0700252 diff_change(&revs->diffopt, oldmode, newmode,
Brandon Williams94a00972017-05-30 10:30:49 -0700253 old_oid, new_oid,
Brandon Williams55497b82017-05-30 10:30:48 -0700254 !is_null_oid(old_oid),
255 !is_null_oid(new_oid),
Jens Lehmanne3d42c42010-01-18 21:26:18 +0100256 ce->name, 0, dirty_submodule);
Junio C Hamano6973dca2006-04-21 23:57:45 -0700257
Junio C Hamanobceafe72005-05-23 18:14:03 -0700258 }
Junio C Hamano6973dca2006-04-21 23:57:45 -0700259 diffcore_std(&revs->diffopt);
260 diff_flush(&revs->diffopt);
Nguyễn Thái Ngọc Duyca54d9b2018-01-27 19:27:56 +0700261 trace_performance_since(start, "diff-files");
Junio C Hamano6973dca2006-04-21 23:57:45 -0700262 return 0;
Junio C Hamanobceafe72005-05-23 18:14:03 -0700263}
264
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700265/*
266 * diff-index
267 */
268
269/* A file entry went away or appeared */
270static void diff_index_show_file(struct rev_info *revs,
271 const char *prefix,
René Scharfeeb9ae4b2013-06-02 17:46:55 +0200272 const struct cache_entry *ce,
Brandon Williamsfcf2cfb2017-05-30 10:30:46 -0700273 const struct object_id *oid, int oid_valid,
Jeff Kinge5450102012-07-28 11:03:01 -0400274 unsigned int mode,
Jens Lehmanne3d42c42010-01-18 21:26:18 +0100275 unsigned dirty_submodule)
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700276{
Linus Torvalds7a51ed62008-01-14 16:03:17 -0800277 diff_addremove(&revs->diffopt, prefix[0], mode,
Brandon Williamsc26022e2017-05-30 10:30:47 -0700278 oid, oid_valid, ce->name, dirty_submodule);
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700279}
280
René Scharfeeb9ae4b2013-06-02 17:46:55 +0200281static int get_stat_data(const struct cache_entry *ce,
Brandon Williams362d7652017-05-30 10:30:45 -0700282 const struct object_id **oidp,
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700283 unsigned int *modep,
Jens Lehmanne3d42c42010-01-18 21:26:18 +0100284 int cached, int match_missing,
Jens Lehmann4d344772010-01-23 17:37:26 +0100285 unsigned *dirty_submodule, struct diff_options *diffopt)
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700286{
Brandon Williams362d7652017-05-30 10:30:45 -0700287 const struct object_id *oid = &ce->oid;
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700288 unsigned int mode = ce->ce_mode;
289
Linus Torvalds658dd482009-05-09 14:57:30 -0700290 if (!cached && !ce_uptodate(ce)) {
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700291 int changed;
292 struct stat st;
Linus Torvaldsc40641b2008-05-09 09:21:07 -0700293 changed = check_removed(ce, &st);
Junio C Hamano948dd342008-03-30 17:29:48 -0700294 if (changed < 0)
295 return -1;
296 else if (changed) {
297 if (match_missing) {
Brandon Williams362d7652017-05-30 10:30:45 -0700298 *oidp = oid;
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700299 *modep = mode;
300 return 0;
301 }
302 return -1;
303 }
Jens Lehmannae6d5c12010-03-11 22:50:25 +0100304 changed = match_stat_with_submodule(diffopt, ce, &st,
305 0, dirty_submodule);
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700306 if (changed) {
Junio C Hamano185c9752007-02-16 22:43:48 -0800307 mode = ce_mode_from_stat(ce, st.st_mode);
Brandon Williams362d7652017-05-30 10:30:45 -0700308 oid = &null_oid;
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700309 }
310 }
311
Brandon Williams362d7652017-05-30 10:30:45 -0700312 *oidp = oid;
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700313 *modep = mode;
314 return 0;
315}
316
Kjetil Barvikff7e6aa2009-01-11 19:36:42 +0100317static void show_new_file(struct rev_info *revs,
Brandon Williamse36ede22018-02-14 10:59:38 -0800318 const struct cache_entry *new_file,
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700319 int cached, int match_missing)
320{
Brandon Williams362d7652017-05-30 10:30:45 -0700321 const struct object_id *oid;
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700322 unsigned int mode;
Jens Lehmanne3d42c42010-01-18 21:26:18 +0100323 unsigned dirty_submodule = 0;
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700324
Junio C Hamano948dd342008-03-30 17:29:48 -0700325 /*
326 * New file in the index: it might actually be different in
Carlos Martín Nietof7d650c2011-09-20 22:25:57 +0200327 * the working tree.
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700328 */
Brandon Williamse36ede22018-02-14 10:59:38 -0800329 if (get_stat_data(new_file, &oid, &mode, cached, match_missing,
Jens Lehmann4d344772010-01-23 17:37:26 +0100330 &dirty_submodule, &revs->diffopt) < 0)
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700331 return;
332
Brandon Williamse36ede22018-02-14 10:59:38 -0800333 diff_index_show_file(revs, "+", new_file, oid, !is_null_oid(oid), mode, dirty_submodule);
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700334}
335
Kjetil Barvikff7e6aa2009-01-11 19:36:42 +0100336static int show_modified(struct rev_info *revs,
Brandon Williamse36ede22018-02-14 10:59:38 -0800337 const struct cache_entry *old_entry,
338 const struct cache_entry *new_entry,
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700339 int report_missing,
340 int cached, int match_missing)
341{
342 unsigned int mode, oldmode;
Brandon Williams362d7652017-05-30 10:30:45 -0700343 const struct object_id *oid;
Jens Lehmanne3d42c42010-01-18 21:26:18 +0100344 unsigned dirty_submodule = 0;
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700345
Brandon Williamse36ede22018-02-14 10:59:38 -0800346 if (get_stat_data(new_entry, &oid, &mode, cached, match_missing,
Jens Lehmann4d344772010-01-23 17:37:26 +0100347 &dirty_submodule, &revs->diffopt) < 0) {
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700348 if (report_missing)
Brandon Williamse36ede22018-02-14 10:59:38 -0800349 diff_index_show_file(revs, "-", old_entry,
350 &old_entry->oid, 1, old_entry->ce_mode,
brian m. carlson99d1a982016-09-05 20:07:52 +0000351 0);
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700352 return -1;
353 }
354
Paul Mackerrascb2b9f52006-09-04 21:38:40 +1000355 if (revs->combine_merges && !cached &&
Jeff King9001dc22018-08-28 17:22:48 -0400356 (!oideq(oid, &old_entry->oid) || !oideq(&old_entry->oid, &new_entry->oid))) {
Paul Mackerrascb2b9f52006-09-04 21:38:40 +1000357 struct combine_diff_path *p;
Brandon Williamse36ede22018-02-14 10:59:38 -0800358 int pathlen = ce_namelen(new_entry);
Paul Mackerrascb2b9f52006-09-04 21:38:40 +1000359
360 p = xmalloc(combine_diff_path_size(2, pathlen));
361 p->path = (char *) &p->parent[2];
362 p->next = NULL;
Brandon Williamse36ede22018-02-14 10:59:38 -0800363 memcpy(p->path, new_entry->name, pathlen);
Paul Mackerrascb2b9f52006-09-04 21:38:40 +1000364 p->path[pathlen] = 0;
Linus Torvalds7a51ed62008-01-14 16:03:17 -0800365 p->mode = mode;
brian m. carlson1ff57c12015-03-13 23:39:33 +0000366 oidclr(&p->oid);
Paul Mackerrascb2b9f52006-09-04 21:38:40 +1000367 memset(p->parent, 0, 2 * sizeof(struct combine_diff_parent));
368 p->parent[0].status = DIFF_STATUS_MODIFIED;
Brandon Williamse36ede22018-02-14 10:59:38 -0800369 p->parent[0].mode = new_entry->ce_mode;
370 oidcpy(&p->parent[0].oid, &new_entry->oid);
Paul Mackerrascb2b9f52006-09-04 21:38:40 +1000371 p->parent[1].status = DIFF_STATUS_MODIFIED;
Brandon Williamse36ede22018-02-14 10:59:38 -0800372 p->parent[1].mode = old_entry->ce_mode;
373 oidcpy(&p->parent[1].oid, &old_entry->oid);
Sergey Organovd01141d2020-09-29 14:31:22 +0300374 show_combined_diff(p, 2, revs);
Paul Mackerrascb2b9f52006-09-04 21:38:40 +1000375 free(p);
376 return 0;
377 }
378
Brandon Williamse36ede22018-02-14 10:59:38 -0800379 oldmode = old_entry->ce_mode;
Jeff King4a7e27e2018-08-28 17:22:40 -0400380 if (mode == oldmode && oideq(oid, &old_entry->oid) && !dirty_submodule &&
Brandon Williams0d1e0e72017-10-31 11:19:11 -0700381 !revs->diffopt.flags.find_copies_harder)
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700382 return 0;
383
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700384 diff_change(&revs->diffopt, oldmode, mode,
Brandon Williamse36ede22018-02-14 10:59:38 -0800385 &old_entry->oid, oid, 1, !is_null_oid(oid),
386 old_entry->name, 0, dirty_submodule);
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700387 return 0;
388}
389
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700390/*
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800391 * This gets a mix of an existing index and a tree, one pathname entry
392 * at a time. The index entry may be a single stage-0 one, but it could
393 * also be multiple unmerged entries (in which case idx_pos/idx_nr will
394 * give you the position and number of entries in the index).
395 */
396static void do_oneway_diff(struct unpack_trees_options *o,
René Scharfeeb9ae4b2013-06-02 17:46:55 +0200397 const struct cache_entry *idx,
398 const struct cache_entry *tree)
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700399{
Kjetil Barvikff7e6aa2009-01-11 19:36:42 +0100400 struct rev_info *revs = o->unpack_data;
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800401 int match_missing, cached;
Junio C Hamano5c21ac02006-04-22 03:58:04 -0700402
Nguyễn Thái Ngọc Duyba4e3562018-05-26 14:08:43 +0200403 /*
404 * i-t-a entries do not actually exist in the index (if we're
405 * looking at its content)
406 */
407 if (o->index_only &&
408 revs->diffopt.ita_invisible_in_index &&
Nguyễn Thái Ngọc Duy425a28e2016-10-24 17:42:19 +0700409 idx && ce_intent_to_add(idx)) {
410 idx = NULL;
411 if (!tree)
412 return; /* nothing to diff.. */
413 }
414
Nguyễn Thái Ngọc Duy540e6942009-08-11 22:43:59 +0700415 /* if the entry is not checked out, don't examine work tree */
Nguyễn Thái Ngọc Duyb4d16902009-08-20 20:46:58 +0700416 cached = o->index_only ||
417 (idx && ((idx->ce_flags & CE_VALID) || ce_skip_worktree(idx)));
Sergey Organov572fc9a2020-08-31 23:14:22 +0300418
419 match_missing = revs->match_missing;
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800420
421 if (cached && idx && ce_stage(idx)) {
Junio C Hamanofa7b2902011-04-22 16:05:58 -0700422 struct diff_filepair *pair;
423 pair = diff_unmerge(&revs->diffopt, idx->name);
Junio C Hamanoff00b682011-07-13 21:36:29 -0700424 if (tree)
Brandon Williamsf9704c22017-05-30 10:30:50 -0700425 fill_filespec(pair->one, &tree->oid, 1,
brian m. carlson99d1a982016-09-05 20:07:52 +0000426 tree->ce_mode);
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800427 return;
428 }
429
430 /*
431 * Something added to the tree?
432 */
433 if (!tree) {
Kjetil Barvikff7e6aa2009-01-11 19:36:42 +0100434 show_new_file(revs, idx, cached, match_missing);
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800435 return;
436 }
437
438 /*
439 * Something removed from the tree?
440 */
441 if (!idx) {
Brandon Williamsfcf2cfb2017-05-30 10:30:46 -0700442 diff_index_show_file(revs, "-", tree, &tree->oid, 1,
brian m. carlson99d1a982016-09-05 20:07:52 +0000443 tree->ce_mode, 0);
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800444 return;
445 }
446
447 /* Show difference between old and new */
Kjetil Barvikff7e6aa2009-01-11 19:36:42 +0100448 show_modified(revs, tree, idx, 1, cached, match_missing);
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800449}
450
451/*
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800452 * The unpack_trees() interface is designed for merging, so
453 * the different source entries are designed primarily for
454 * the source trees, with the old index being really mainly
455 * used for being replaced by the result.
456 *
457 * For diffing, the index is more important, and we only have a
458 * single tree.
459 *
Junio C Hamanoda8ba5e2009-09-17 22:12:17 -0700460 * We're supposed to advance o->pos to skip what we have already processed.
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800461 *
462 * This wrapper makes it all more readable, and takes care of all
463 * the fairly complex unpack_trees() semantic requirements, including
464 * the skipping, the path matching, the type conflict cases etc.
465 */
René Scharfe5828e832013-06-02 17:46:56 +0200466static int oneway_diff(const struct cache_entry * const *src,
467 struct unpack_trees_options *o)
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800468{
René Scharfeeb9ae4b2013-06-02 17:46:55 +0200469 const struct cache_entry *idx = src[0];
470 const struct cache_entry *tree = src[1];
Kjetil Barvikff7e6aa2009-01-11 19:36:42 +0100471 struct rev_info *revs = o->unpack_data;
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800472
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800473 /*
474 * Unpack-trees generates a DF/conflict entry if
475 * there was a directory in the index and a tree
476 * in the tree. From a diff standpoint, that's a
477 * delete of the tree and a create of the file.
478 */
479 if (tree == o->df_conflict_entry)
480 tree = NULL;
481
Nguyễn Thái Ngọc Duy5adbb402018-09-21 17:57:26 +0200482 if (ce_path_match(revs->diffopt.repo->index,
483 idx ? idx : tree,
484 &revs->prune_data, NULL)) {
Linus Torvalds34110cd2008-03-06 18:12:28 -0800485 do_oneway_diff(o, idx, tree);
Junio C Hamanob4194822011-05-31 10:06:44 -0700486 if (diff_can_quit_early(&revs->diffopt)) {
487 o->exiting_early = 1;
488 return -1;
489 }
490 }
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800491
Linus Torvalds34110cd2008-03-06 18:12:28 -0800492 return 0;
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800493}
494
Junio C Hamanobf979c02011-07-13 18:57:42 -0700495static int diff_cache(struct rev_info *revs,
brian m. carlson944cffb2017-05-06 22:10:35 +0000496 const struct object_id *tree_oid,
Junio C Hamanobf979c02011-07-13 18:57:42 -0700497 const char *tree_name,
498 int cached)
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800499{
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800500 struct tree *tree;
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800501 struct tree_desc t;
Junio C Hamanobf979c02011-07-13 18:57:42 -0700502 struct unpack_trees_options opts;
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700503
brian m. carlsona9dbc172017-05-06 22:10:37 +0000504 tree = parse_tree_indirect(tree_oid);
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700505 if (!tree)
Junio C Hamanobf979c02011-07-13 18:57:42 -0700506 return error("bad tree object %s",
brian m. carlson944cffb2017-05-06 22:10:35 +0000507 tree_name ? tree_name : oid_to_hex(tree_oid));
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800508 memset(&opts, 0, sizeof(opts));
509 opts.head_idx = 1;
510 opts.index_only = cached;
Junio C Hamanoa0919ce2009-05-22 23:14:25 -0700511 opts.diff_index_cached = (cached &&
Brandon Williams0d1e0e72017-10-31 11:19:11 -0700512 !revs->diffopt.flags.find_copies_harder);
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800513 opts.merge = 1;
514 opts.fn = oneway_diff;
Kjetil Barvikff7e6aa2009-01-11 19:36:42 +0100515 opts.unpack_data = revs;
Nguyễn Thái Ngọc Duy5adbb402018-09-21 17:57:26 +0200516 opts.src_index = revs->diffopt.repo->index;
Linus Torvalds34110cd2008-03-06 18:12:28 -0800517 opts.dst_index = NULL;
Junio C Hamano2f88c192011-08-29 13:34:08 -0700518 opts.pathspec = &revs->diffopt.pathspec;
Nguyen Thai Ngoc Duy48382372012-01-15 17:03:27 +0700519 opts.pathspec->recursive = 1;
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800520
521 init_tree_desc(&t, tree->buffer, tree->size);
Junio C Hamanobf979c02011-07-13 18:57:42 -0700522 return unpack_trees(1, &t, &opts);
523}
524
Denton Liu177a8302020-09-20 04:22:23 -0700525void diff_get_merge_base(const struct rev_info *revs, struct object_id *mb)
526{
527 int i;
528 struct commit *mb_child[2] = {0};
529 struct commit_list *merge_bases;
530
531 for (i = 0; i < revs->pending.nr; i++) {
532 struct object *obj = revs->pending.objects[i].item;
533 if (obj->flags)
534 die(_("--merge-base does not work with ranges"));
535 if (obj->type != OBJ_COMMIT)
536 die(_("--merge-base only works with commits"));
537 }
538
539 /*
540 * This check must go after the for loop above because A...B
541 * ranges produce three pending commits, resulting in a
542 * misleading error message.
543 */
544 if (revs->pending.nr < 1 || revs->pending.nr > 2)
545 BUG("unexpected revs->pending.nr: %d", revs->pending.nr);
546
547 for (i = 0; i < revs->pending.nr; i++)
548 mb_child[i] = lookup_commit_reference(the_repository, &revs->pending.objects[i].item->oid);
549 if (revs->pending.nr == 1) {
550 struct object_id oid;
551
552 if (get_oid("HEAD", &oid))
553 die(_("unable to get HEAD"));
554
555 mb_child[1] = lookup_commit_reference(the_repository, &oid);
556 }
557
558 merge_bases = repo_get_merge_bases(the_repository, mb_child[0], mb_child[1]);
559 if (!merge_bases)
560 die(_("no merge base found"));
561 if (merge_bases->next)
562 die(_("multiple merge bases found"));
563
564 oidcpy(mb, &merge_bases->item->object.oid);
565
566 free_commit_list(merge_bases);
567}
568
Denton Liu4c3fe822020-09-20 04:22:22 -0700569int run_diff_index(struct rev_info *revs, unsigned int option)
Junio C Hamanobf979c02011-07-13 18:57:42 -0700570{
571 struct object_array_entry *ent;
Denton Liu4c3fe822020-09-20 04:22:22 -0700572 int cached = !!(option & DIFF_INDEX_CACHED);
Denton Liu0f5a1d42020-09-20 04:22:25 -0700573 int merge_base = !!(option & DIFF_INDEX_MERGE_BASE);
574 struct object_id oid;
575 const char *name;
576 char merge_base_hex[GIT_MAX_HEXSZ + 1];
Junio C Hamanobf979c02011-07-13 18:57:42 -0700577
Jeff King3506dc92018-07-11 10:14:06 -0400578 if (revs->pending.nr != 1)
579 BUG("run_diff_index must be passed exactly one tree");
580
Nguyễn Thái Ngọc Duyc46c4062018-08-18 16:41:22 +0200581 trace_performance_enter();
Junio C Hamanobf979c02011-07-13 18:57:42 -0700582 ent = revs->pending.objects;
Denton Liu0f5a1d42020-09-20 04:22:25 -0700583
584 if (merge_base) {
585 diff_get_merge_base(revs, &oid);
586 name = oid_to_hex_r(merge_base_hex, &oid);
587 } else {
588 oidcpy(&oid, &ent->item->oid);
589 name = ent->name;
590 }
591
592 if (diff_cache(revs, &oid, name, cached))
Daniel Barkalow203a2fe2008-02-07 11:39:48 -0500593 exit(128);
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800594
Junio C Hamanoa5a818e2008-08-18 20:08:09 -0700595 diff_set_mnemonic_prefix(&revs->diffopt, "c/", cached ? "i/" : "w/");
Jeff King784c0da2019-02-14 00:48:03 -0500596 diffcore_fix_diff_index();
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700597 diffcore_std(&revs->diffopt);
598 diff_flush(&revs->diffopt);
Nguyễn Thái Ngọc Duyc46c4062018-08-18 16:41:22 +0200599 trace_performance_leave("diff-index");
Linus Torvaldsd1f2d7e2008-01-19 17:27:12 -0800600 return 0;
Junio C Hamanoe09ad6e2006-04-22 02:43:00 -0700601}
Junio C Hamano1cfe7732007-01-30 01:11:08 -0800602
brian m. carlson944cffb2017-05-06 22:10:35 +0000603int do_diff_cache(const struct object_id *tree_oid, struct diff_options *opt)
Junio C Hamano1cfe7732007-01-30 01:11:08 -0800604{
Junio C Hamano1cfe7732007-01-30 01:11:08 -0800605 struct rev_info revs;
Junio C Hamano1cfe7732007-01-30 01:11:08 -0800606
Nguyễn Thái Ngọc Duyffc00a42018-11-10 06:49:04 +0100607 repo_init_revisions(opt->repo, &revs, NULL);
Nguyễn Thái Ngọc Duy9a087272013-07-14 15:35:59 +0700608 copy_pathspec(&revs.prune_data, &opt->pathspec);
René Scharfed44e5262020-11-14 19:37:03 +0100609 diff_setup_done(&revs.diffopt);
Junio C Hamanobf979c02011-07-13 18:57:42 -0700610 revs.diffopt = *opt;
Johannes Schindelin204ce972008-01-20 15:19:56 +0000611
brian m. carlson944cffb2017-05-06 22:10:35 +0000612 if (diff_cache(&revs, tree_oid, NULL, 1))
Daniel Barkalow203a2fe2008-02-07 11:39:48 -0500613 exit(128);
René Scharfed44e5262020-11-14 19:37:03 +0100614 clear_pathspec(&revs.prune_data);
Johannes Schindelin204ce972008-01-20 15:19:56 +0000615 return 0;
Junio C Hamano1cfe7732007-01-30 01:11:08 -0800616}
Stephan Beyer75f3ff22009-02-10 15:30:35 +0100617
Nguyễn Thái Ngọc Duyffc00a42018-11-10 06:49:04 +0100618int index_differs_from(struct repository *r,
619 const char *def, const struct diff_flags *flags,
Nguyễn Thái Ngọc Duy018ec3c2016-10-24 17:42:21 +0700620 int ita_invisible_in_index)
Stephan Beyer75f3ff22009-02-10 15:30:35 +0100621{
622 struct rev_info rev;
Junio C Hamano32962c92010-03-08 22:58:09 -0800623 struct setup_revision_opt opt;
Stephan Beyer75f3ff22009-02-10 15:30:35 +0100624
Nguyễn Thái Ngọc Duyffc00a42018-11-10 06:49:04 +0100625 repo_init_revisions(r, &rev, NULL);
Junio C Hamano32962c92010-03-08 22:58:09 -0800626 memset(&opt, 0, sizeof(opt));
627 opt.def = def;
628 setup_revisions(0, NULL, &rev, &opt);
Brandon Williams0d1e0e72017-10-31 11:19:11 -0700629 rev.diffopt.flags.quick = 1;
630 rev.diffopt.flags.exit_with_status = 1;
Brandon Williams02f2f562017-10-31 11:19:05 -0700631 if (flags)
632 diff_flags_or(&rev.diffopt.flags, flags);
Nguyễn Thái Ngọc Duy018ec3c2016-10-24 17:42:21 +0700633 rev.diffopt.ita_invisible_in_index = ita_invisible_in_index;
Stephan Beyer75f3ff22009-02-10 15:30:35 +0100634 run_diff_index(&rev, 1);
Martin Ågrendcb572a2017-09-23 01:34:52 +0200635 object_array_clear(&rev.pending);
Brandon Williams0d1e0e72017-10-31 11:19:11 -0700636 return (rev.diffopt.flags.has_changes != 0);
Stephan Beyer75f3ff22009-02-10 15:30:35 +0100637}
Eric Sunshinecdffbdc2020-09-08 03:16:08 -0400638
639static struct strbuf *idiff_prefix_cb(struct diff_options *opt, void *data)
640{
641 return data;
642}
643
Eric Sunshine72a72392020-09-08 03:16:09 -0400644void show_interdiff(const struct object_id *oid1, const struct object_id *oid2,
645 int indent, struct diff_options *diffopt)
Eric Sunshinecdffbdc2020-09-08 03:16:08 -0400646{
647 struct diff_options opts;
648 struct strbuf prefix = STRBUF_INIT;
649
Eric Sunshine72a72392020-09-08 03:16:09 -0400650 memcpy(&opts, diffopt, sizeof(opts));
Eric Sunshinecdffbdc2020-09-08 03:16:08 -0400651 opts.output_format = DIFF_FORMAT_PATCH;
652 opts.output_prefix = idiff_prefix_cb;
653 strbuf_addchars(&prefix, ' ', indent);
654 opts.output_prefix_data = &prefix;
655 diff_setup_done(&opts);
656
Eric Sunshine72a72392020-09-08 03:16:09 -0400657 diff_tree_oid(oid1, oid2, "", &opts);
Eric Sunshinecdffbdc2020-09-08 03:16:08 -0400658 diffcore_std(&opts);
659 diff_flush(&opts);
660
661 strbuf_release(&prefix);
662}