2 * Copyright (C) 2005 Junio C Hamano
10 #include "cache-tree.h"
11 #include "unpack-trees.h"
13 #include "submodule.h"
20 * Has the work tree entity been removed?
22 * Return 1 if it was removed from the work tree, 0 if an entity to be
23 * compared with the cache entry ce still exists (the latter includes
24 * the case where a directory that is not a submodule repository
25 * exists for ce that is a submodule -- it is a submodule that is not
26 * checked out). Return negative for an error.
28 static int check_removed(const struct cache_entry
*ce
, struct stat
*st
)
30 if (lstat(ce
->name
, st
) < 0) {
31 if (errno
!= ENOENT
&& errno
!= ENOTDIR
)
35 if (has_symlink_leading_path(ce
->name
, ce_namelen(ce
)))
37 if (S_ISDIR(st
->st_mode
)) {
38 unsigned char sub
[20];
41 * If ce is already a gitlink, we can have a plain
42 * directory (i.e. the submodule is not checked out),
43 * or a checked out submodule. Either case this is not
44 * a case where something was removed from the work tree,
45 * so we will return 0.
47 * Otherwise, if the directory is not a submodule
48 * repository, that means ce which was a blob turned into
49 * a directory --- the blob was removed!
51 if (!S_ISGITLINK(ce
->ce_mode
) &&
52 resolve_gitlink_ref(ce
->name
, "HEAD", sub
))
59 * Has a file changed or has a submodule new commits or a dirty work tree?
61 * Return 1 when changes are detected, 0 otherwise. If the DIRTY_SUBMODULES
62 * option is set, the caller does not only want to know if a submodule is
63 * modified at all but wants to know all the conditions that are met (new
64 * commits, untracked content and/or modified content).
66 static int match_stat_with_submodule(struct diff_options
*diffopt
,
67 const struct cache_entry
*ce
,
68 struct stat
*st
, unsigned ce_option
,
69 unsigned *dirty_submodule
)
71 int changed
= ce_match_stat(ce
, st
, ce_option
);
72 if (S_ISGITLINK(ce
->ce_mode
)) {
73 unsigned orig_flags
= diffopt
->flags
;
74 if (!DIFF_OPT_TST(diffopt
, OVERRIDE_SUBMODULE_CONFIG
))
75 set_diffopt_flags_from_submodule_config(diffopt
, ce
->name
);
76 if (DIFF_OPT_TST(diffopt
, IGNORE_SUBMODULES
))
78 else if (!DIFF_OPT_TST(diffopt
, IGNORE_DIRTY_SUBMODULES
)
79 && (!changed
|| DIFF_OPT_TST(diffopt
, DIRTY_SUBMODULES
)))
80 *dirty_submodule
= is_submodule_modified(ce
->name
, DIFF_OPT_TST(diffopt
, IGNORE_UNTRACKED_IN_SUBMODULES
));
81 diffopt
->flags
= orig_flags
;
86 int run_diff_files(struct rev_info
*revs
, unsigned int option
)
89 int diff_unmerged_stage
= revs
->max_count
;
90 unsigned ce_option
= ((option
& DIFF_RACY_IS_MODIFIED
)
91 ? CE_MATCH_RACY_IS_DIRTY
: 0);
93 if (option
& DIFF_SILENT_ON_REMOVED
)
94 handle_deprecated_show_diff_q(&revs
->diffopt
);
96 diff_set_mnemonic_prefix(&revs
->diffopt
, "i/", "w/");
98 if (diff_unmerged_stage
< 0)
99 diff_unmerged_stage
= 2;
101 for (i
= 0; i
< entries
; i
++) {
103 unsigned int oldmode
, newmode
;
104 struct cache_entry
*ce
= active_cache
[i
];
106 unsigned dirty_submodule
= 0;
108 if (diff_can_quit_early(&revs
->diffopt
))
111 if (!ce_path_match(ce
, &revs
->prune_data
))
115 struct combine_diff_path
*dpath
;
116 struct diff_filepair
*pair
;
117 unsigned int wt_mode
= 0;
118 int num_compare_stages
= 0;
121 path_len
= ce_namelen(ce
);
123 dpath
= xmalloc(combine_diff_path_size(5, path_len
));
124 dpath
->path
= (char *) &(dpath
->parent
[5]);
127 memcpy(dpath
->path
, ce
->name
, path_len
);
128 dpath
->path
[path_len
] = '\0';
129 hashclr(dpath
->sha1
);
130 memset(&(dpath
->parent
[0]), 0,
131 sizeof(struct combine_diff_parent
)*5);
133 changed
= check_removed(ce
, &st
);
135 wt_mode
= ce_mode_from_stat(ce
, st
.st_mode
);
143 dpath
->mode
= wt_mode
;
145 while (i
< entries
) {
146 struct cache_entry
*nce
= active_cache
[i
];
149 if (strcmp(ce
->name
, nce
->name
))
152 /* Stage #2 (ours) is the first parent,
153 * stage #3 (theirs) is the second.
155 stage
= ce_stage(nce
);
157 int mode
= nce
->ce_mode
;
158 num_compare_stages
++;
159 hashcpy(dpath
->parent
[stage
-2].sha1
, nce
->sha1
);
160 dpath
->parent
[stage
-2].mode
= ce_mode_from_stat(nce
, mode
);
161 dpath
->parent
[stage
-2].status
=
162 DIFF_STATUS_MODIFIED
;
165 /* diff against the proper unmerged stage */
166 if (stage
== diff_unmerged_stage
)
171 * Compensate for loop update
175 if (revs
->combine_merges
&& num_compare_stages
== 2) {
176 show_combined_diff(dpath
, 2,
177 revs
->dense_combined_merges
,
186 * Show the diff for the 'ce' if we found the one
187 * from the desired stage.
189 pair
= diff_unmerge(&revs
->diffopt
, ce
->name
);
191 pair
->two
->mode
= wt_mode
;
192 if (ce_stage(ce
) != diff_unmerged_stage
)
196 if (ce_uptodate(ce
) || ce_skip_worktree(ce
))
199 /* If CE_VALID is set, don't look at workdir for file removal */
200 changed
= (ce
->ce_flags
& CE_VALID
) ? 0 : check_removed(ce
, &st
);
206 diff_addremove(&revs
->diffopt
, '-', ce
->ce_mode
,
207 ce
->sha1
, !is_null_sha1(ce
->sha1
),
211 changed
= match_stat_with_submodule(&revs
->diffopt
, ce
, &st
,
212 ce_option
, &dirty_submodule
);
213 if (!changed
&& !dirty_submodule
) {
214 ce_mark_uptodate(ce
);
215 if (!DIFF_OPT_TST(&revs
->diffopt
, FIND_COPIES_HARDER
))
218 oldmode
= ce
->ce_mode
;
219 newmode
= ce_mode_from_stat(ce
, st
.st_mode
);
220 diff_change(&revs
->diffopt
, oldmode
, newmode
,
221 ce
->sha1
, (changed
? null_sha1
: ce
->sha1
),
222 !is_null_sha1(ce
->sha1
), (changed
? 0 : !is_null_sha1(ce
->sha1
)),
223 ce
->name
, 0, dirty_submodule
);
226 diffcore_std(&revs
->diffopt
);
227 diff_flush(&revs
->diffopt
);
235 /* A file entry went away or appeared */
236 static void diff_index_show_file(struct rev_info
*revs
,
238 const struct cache_entry
*ce
,
239 const unsigned char *sha1
, int sha1_valid
,
241 unsigned dirty_submodule
)
243 diff_addremove(&revs
->diffopt
, prefix
[0], mode
,
244 sha1
, sha1_valid
, ce
->name
, dirty_submodule
);
247 static int get_stat_data(const struct cache_entry
*ce
,
248 const unsigned char **sha1p
,
250 int cached
, int match_missing
,
251 unsigned *dirty_submodule
, struct diff_options
*diffopt
)
253 const unsigned char *sha1
= ce
->sha1
;
254 unsigned int mode
= ce
->ce_mode
;
256 if (!cached
&& !ce_uptodate(ce
)) {
259 changed
= check_removed(ce
, &st
);
270 changed
= match_stat_with_submodule(diffopt
, ce
, &st
,
273 mode
= ce_mode_from_stat(ce
, st
.st_mode
);
283 static void show_new_file(struct rev_info
*revs
,
284 const struct cache_entry
*new,
285 int cached
, int match_missing
)
287 const unsigned char *sha1
;
289 unsigned dirty_submodule
= 0;
292 * New file in the index: it might actually be different in
295 if (get_stat_data(new, &sha1
, &mode
, cached
, match_missing
,
296 &dirty_submodule
, &revs
->diffopt
) < 0)
299 diff_index_show_file(revs
, "+", new, sha1
, !is_null_sha1(sha1
), mode
, dirty_submodule
);
302 static int show_modified(struct rev_info
*revs
,
303 const struct cache_entry
*old
,
304 const struct cache_entry
*new,
306 int cached
, int match_missing
)
308 unsigned int mode
, oldmode
;
309 const unsigned char *sha1
;
310 unsigned dirty_submodule
= 0;
312 if (get_stat_data(new, &sha1
, &mode
, cached
, match_missing
,
313 &dirty_submodule
, &revs
->diffopt
) < 0) {
315 diff_index_show_file(revs
, "-", old
,
316 old
->sha1
, 1, old
->ce_mode
, 0);
320 if (revs
->combine_merges
&& !cached
&&
321 (hashcmp(sha1
, old
->sha1
) || hashcmp(old
->sha1
, new->sha1
))) {
322 struct combine_diff_path
*p
;
323 int pathlen
= ce_namelen(new);
325 p
= xmalloc(combine_diff_path_size(2, pathlen
));
326 p
->path
= (char *) &p
->parent
[2];
328 memcpy(p
->path
, new->name
, pathlen
);
329 p
->path
[pathlen
] = 0;
332 memset(p
->parent
, 0, 2 * sizeof(struct combine_diff_parent
));
333 p
->parent
[0].status
= DIFF_STATUS_MODIFIED
;
334 p
->parent
[0].mode
= new->ce_mode
;
335 hashcpy(p
->parent
[0].sha1
, new->sha1
);
336 p
->parent
[1].status
= DIFF_STATUS_MODIFIED
;
337 p
->parent
[1].mode
= old
->ce_mode
;
338 hashcpy(p
->parent
[1].sha1
, old
->sha1
);
339 show_combined_diff(p
, 2, revs
->dense_combined_merges
, revs
);
344 oldmode
= old
->ce_mode
;
345 if (mode
== oldmode
&& !hashcmp(sha1
, old
->sha1
) && !dirty_submodule
&&
346 !DIFF_OPT_TST(&revs
->diffopt
, FIND_COPIES_HARDER
))
349 diff_change(&revs
->diffopt
, oldmode
, mode
,
350 old
->sha1
, sha1
, 1, !is_null_sha1(sha1
),
351 old
->name
, 0, dirty_submodule
);
356 * This gets a mix of an existing index and a tree, one pathname entry
357 * at a time. The index entry may be a single stage-0 one, but it could
358 * also be multiple unmerged entries (in which case idx_pos/idx_nr will
359 * give you the position and number of entries in the index).
361 static void do_oneway_diff(struct unpack_trees_options
*o
,
362 const struct cache_entry
*idx
,
363 const struct cache_entry
*tree
)
365 struct rev_info
*revs
= o
->unpack_data
;
366 int match_missing
, cached
;
368 /* if the entry is not checked out, don't examine work tree */
369 cached
= o
->index_only
||
370 (idx
&& ((idx
->ce_flags
& CE_VALID
) || ce_skip_worktree(idx
)));
372 * Backward compatibility wart - "diff-index -m" does
373 * not mean "do not ignore merges", but "match_missing".
375 * But with the revision flag parsing, that's found in
376 * "!revs->ignore_merges".
378 match_missing
= !revs
->ignore_merges
;
380 if (cached
&& idx
&& ce_stage(idx
)) {
381 struct diff_filepair
*pair
;
382 pair
= diff_unmerge(&revs
->diffopt
, idx
->name
);
384 fill_filespec(pair
->one
, tree
->sha1
, 1, tree
->ce_mode
);
389 * Something added to the tree?
392 show_new_file(revs
, idx
, cached
, match_missing
);
397 * Something removed from the tree?
400 diff_index_show_file(revs
, "-", tree
, tree
->sha1
, 1, tree
->ce_mode
, 0);
404 /* Show difference between old and new */
405 show_modified(revs
, tree
, idx
, 1, cached
, match_missing
);
409 * The unpack_trees() interface is designed for merging, so
410 * the different source entries are designed primarily for
411 * the source trees, with the old index being really mainly
412 * used for being replaced by the result.
414 * For diffing, the index is more important, and we only have a
417 * We're supposed to advance o->pos to skip what we have already processed.
419 * This wrapper makes it all more readable, and takes care of all
420 * the fairly complex unpack_trees() semantic requirements, including
421 * the skipping, the path matching, the type conflict cases etc.
423 static int oneway_diff(const struct cache_entry
* const *src
,
424 struct unpack_trees_options
*o
)
426 const struct cache_entry
*idx
= src
[0];
427 const struct cache_entry
*tree
= src
[1];
428 struct rev_info
*revs
= o
->unpack_data
;
431 * Unpack-trees generates a DF/conflict entry if
432 * there was a directory in the index and a tree
433 * in the tree. From a diff standpoint, that's a
434 * delete of the tree and a create of the file.
436 if (tree
== o
->df_conflict_entry
)
439 if (ce_path_match(idx
? idx
: tree
, &revs
->prune_data
)) {
440 do_oneway_diff(o
, idx
, tree
);
441 if (diff_can_quit_early(&revs
->diffopt
)) {
442 o
->exiting_early
= 1;
450 static int diff_cache(struct rev_info
*revs
,
451 const unsigned char *tree_sha1
,
452 const char *tree_name
,
457 struct unpack_trees_options opts
;
459 tree
= parse_tree_indirect(tree_sha1
);
461 return error("bad tree object %s",
462 tree_name
? tree_name
: sha1_to_hex(tree_sha1
));
463 memset(&opts
, 0, sizeof(opts
));
465 opts
.index_only
= cached
;
466 opts
.diff_index_cached
= (cached
&&
467 !DIFF_OPT_TST(&revs
->diffopt
, FIND_COPIES_HARDER
));
469 opts
.fn
= oneway_diff
;
470 opts
.unpack_data
= revs
;
471 opts
.src_index
= &the_index
;
472 opts
.dst_index
= NULL
;
473 opts
.pathspec
= &revs
->diffopt
.pathspec
;
474 opts
.pathspec
->recursive
= 1;
476 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
477 return unpack_trees(1, &t
, &opts
);
480 int run_diff_index(struct rev_info
*revs
, int cached
)
482 struct object_array_entry
*ent
;
484 ent
= revs
->pending
.objects
;
485 if (diff_cache(revs
, ent
->item
->sha1
, ent
->name
, cached
))
488 diff_set_mnemonic_prefix(&revs
->diffopt
, "c/", cached
? "i/" : "w/");
489 diffcore_fix_diff_index(&revs
->diffopt
);
490 diffcore_std(&revs
->diffopt
);
491 diff_flush(&revs
->diffopt
);
495 int do_diff_cache(const unsigned char *tree_sha1
, struct diff_options
*opt
)
497 struct rev_info revs
;
499 init_revisions(&revs
, NULL
);
500 copy_pathspec(&revs
.prune_data
, &opt
->pathspec
);
503 if (diff_cache(&revs
, tree_sha1
, NULL
, 1))
508 int index_differs_from(const char *def
, int diff_flags
)
511 struct setup_revision_opt opt
;
513 init_revisions(&rev
, NULL
);
514 memset(&opt
, 0, sizeof(opt
));
516 setup_revisions(0, NULL
, &rev
, &opt
);
517 DIFF_OPT_SET(&rev
.diffopt
, QUICK
);
518 DIFF_OPT_SET(&rev
.diffopt
, EXIT_WITH_STATUS
);
519 rev
.diffopt
.flags
|= diff_flags
;
520 run_diff_index(&rev
, 1);
521 if (rev
.pending
.alloc
)
522 free(rev
.pending
.objects
);
523 return (DIFF_OPT_TST(&rev
.diffopt
, HAS_CHANGES
) != 0);