2 * Copyright (C) 2005 Junio C Hamano
10 #include "cache-tree.h"
11 #include "unpack-trees.h"
19 * Has the work tree entity been removed?
21 * Return 1 if it was removed from the work tree, 0 if an entity to be
22 * compared with the cache entry ce still exists (the latter includes
23 * the case where a directory that is not a submodule repository
24 * exists for ce that is a submodule -- it is a submodule that is not
25 * checked out). Return negative for an error.
27 static int check_removed(const struct cache_entry
*ce
, struct stat
*st
)
29 if (lstat(ce
->name
, st
) < 0) {
30 if (errno
!= ENOENT
&& errno
!= ENOTDIR
)
34 if (has_symlink_leading_path(ce_namelen(ce
), ce
->name
))
36 if (S_ISDIR(st
->st_mode
)) {
37 unsigned char sub
[20];
40 * If ce is already a gitlink, we can have a plain
41 * directory (i.e. the submodule is not checked out),
42 * or a checked out submodule. Either case this is not
43 * a case where something was removed from the work tree,
44 * so we will return 0.
46 * Otherwise, if the directory is not a submodule
47 * repository, that means ce which was a blob turned into
48 * a directory --- the blob was removed!
50 if (!S_ISGITLINK(ce
->ce_mode
) &&
51 resolve_gitlink_ref(ce
->name
, "HEAD", sub
))
57 int run_diff_files(struct rev_info
*revs
, unsigned int option
)
60 int diff_unmerged_stage
= revs
->max_count
;
61 int silent_on_removed
= option
& DIFF_SILENT_ON_REMOVED
;
62 unsigned ce_option
= ((option
& DIFF_RACY_IS_MODIFIED
)
63 ? CE_MATCH_RACY_IS_DIRTY
: 0);
64 char symcache
[PATH_MAX
];
66 diff_set_mnemonic_prefix(&revs
->diffopt
, "i/", "w/");
68 if (diff_unmerged_stage
< 0)
69 diff_unmerged_stage
= 2;
72 for (i
= 0; i
< entries
; i
++) {
74 unsigned int oldmode
, newmode
;
75 struct cache_entry
*ce
= active_cache
[i
];
78 if (DIFF_OPT_TST(&revs
->diffopt
, QUIET
) &&
79 DIFF_OPT_TST(&revs
->diffopt
, HAS_CHANGES
))
82 if (!ce_path_match(ce
, revs
->prune_data
))
86 struct combine_diff_path
*dpath
;
87 int num_compare_stages
= 0;
90 path_len
= ce_namelen(ce
);
92 dpath
= xmalloc(combine_diff_path_size(5, path_len
));
93 dpath
->path
= (char *) &(dpath
->parent
[5]);
96 dpath
->len
= path_len
;
97 memcpy(dpath
->path
, ce
->name
, path_len
);
98 dpath
->path
[path_len
] = '\0';
100 memset(&(dpath
->parent
[0]), 0,
101 sizeof(struct combine_diff_parent
)*5);
103 changed
= check_removed(ce
, &st
);
105 dpath
->mode
= ce_mode_from_stat(ce
, st
.st_mode
);
111 if (silent_on_removed
)
115 while (i
< entries
) {
116 struct cache_entry
*nce
= active_cache
[i
];
119 if (strcmp(ce
->name
, nce
->name
))
122 /* Stage #2 (ours) is the first parent,
123 * stage #3 (theirs) is the second.
125 stage
= ce_stage(nce
);
127 int mode
= nce
->ce_mode
;
128 num_compare_stages
++;
129 hashcpy(dpath
->parent
[stage
-2].sha1
, nce
->sha1
);
130 dpath
->parent
[stage
-2].mode
= ce_mode_from_stat(nce
, mode
);
131 dpath
->parent
[stage
-2].status
=
132 DIFF_STATUS_MODIFIED
;
135 /* diff against the proper unmerged stage */
136 if (stage
== diff_unmerged_stage
)
141 * Compensate for loop update
145 if (revs
->combine_merges
&& num_compare_stages
== 2) {
146 show_combined_diff(dpath
, 2,
147 revs
->dense_combined_merges
,
156 * Show the diff for the 'ce' if we found the one
157 * from the desired stage.
159 diff_unmerge(&revs
->diffopt
, ce
->name
, 0, null_sha1
);
160 if (ce_stage(ce
) != diff_unmerged_stage
)
164 if (ce_uptodate(ce
) || ce_no_checkout(ce
))
167 changed
= check_removed(ce
, &st
);
173 if (silent_on_removed
)
175 diff_addremove(&revs
->diffopt
, '-', ce
->ce_mode
,
179 changed
= ce_match_stat(ce
, &st
, ce_option
);
181 ce_mark_uptodate(ce
);
182 if (!DIFF_OPT_TST(&revs
->diffopt
, FIND_COPIES_HARDER
))
185 oldmode
= ce
->ce_mode
;
186 newmode
= ce_mode_from_stat(ce
, st
.st_mode
);
187 diff_change(&revs
->diffopt
, oldmode
, newmode
,
188 ce
->sha1
, (changed
? null_sha1
: ce
->sha1
),
192 diffcore_std(&revs
->diffopt
);
193 diff_flush(&revs
->diffopt
);
201 struct oneway_unpack_data
{
202 struct rev_info
*revs
;
203 char symcache
[PATH_MAX
];
206 /* A file entry went away or appeared */
207 static void diff_index_show_file(struct rev_info
*revs
,
209 struct cache_entry
*ce
,
210 const unsigned char *sha1
, unsigned int mode
)
212 diff_addremove(&revs
->diffopt
, prefix
[0], mode
,
216 static int get_stat_data(struct cache_entry
*ce
,
217 const unsigned char **sha1p
,
219 int cached
, int match_missing
,
220 struct oneway_unpack_data
*cbdata
)
222 const unsigned char *sha1
= ce
->sha1
;
223 unsigned int mode
= ce
->ce_mode
;
228 changed
= check_removed(ce
, &st
);
239 changed
= ce_match_stat(ce
, &st
, 0);
241 mode
= ce_mode_from_stat(ce
, st
.st_mode
);
251 static void show_new_file(struct oneway_unpack_data
*cbdata
,
252 struct cache_entry
*new,
253 int cached
, int match_missing
)
255 const unsigned char *sha1
;
257 struct rev_info
*revs
= cbdata
->revs
;
260 * New file in the index: it might actually be different in
263 if (get_stat_data(new, &sha1
, &mode
, cached
, match_missing
, cbdata
) < 0)
266 diff_index_show_file(revs
, "+", new, sha1
, mode
);
269 static int show_modified(struct oneway_unpack_data
*cbdata
,
270 struct cache_entry
*old
,
271 struct cache_entry
*new,
273 int cached
, int match_missing
)
275 unsigned int mode
, oldmode
;
276 const unsigned char *sha1
;
277 struct rev_info
*revs
= cbdata
->revs
;
279 if (get_stat_data(new, &sha1
, &mode
, cached
, match_missing
, cbdata
) < 0) {
281 diff_index_show_file(revs
, "-", old
,
282 old
->sha1
, old
->ce_mode
);
286 if (revs
->combine_merges
&& !cached
&&
287 (hashcmp(sha1
, old
->sha1
) || hashcmp(old
->sha1
, new->sha1
))) {
288 struct combine_diff_path
*p
;
289 int pathlen
= ce_namelen(new);
291 p
= xmalloc(combine_diff_path_size(2, pathlen
));
292 p
->path
= (char *) &p
->parent
[2];
295 memcpy(p
->path
, new->name
, pathlen
);
296 p
->path
[pathlen
] = 0;
299 memset(p
->parent
, 0, 2 * sizeof(struct combine_diff_parent
));
300 p
->parent
[0].status
= DIFF_STATUS_MODIFIED
;
301 p
->parent
[0].mode
= new->ce_mode
;
302 hashcpy(p
->parent
[0].sha1
, new->sha1
);
303 p
->parent
[1].status
= DIFF_STATUS_MODIFIED
;
304 p
->parent
[1].mode
= old
->ce_mode
;
305 hashcpy(p
->parent
[1].sha1
, old
->sha1
);
306 show_combined_diff(p
, 2, revs
->dense_combined_merges
, revs
);
311 oldmode
= old
->ce_mode
;
312 if (mode
== oldmode
&& !hashcmp(sha1
, old
->sha1
) &&
313 !DIFF_OPT_TST(&revs
->diffopt
, FIND_COPIES_HARDER
))
316 diff_change(&revs
->diffopt
, oldmode
, mode
,
317 old
->sha1
, sha1
, old
->name
);
322 * This turns all merge entries into "stage 3". That guarantees that
323 * when we read in the new tree (into "stage 1"), we won't lose sight
324 * of the fact that we had unmerged entries.
326 static void mark_merge_entries(void)
329 for (i
= 0; i
< active_nr
; i
++) {
330 struct cache_entry
*ce
= active_cache
[i
];
333 ce
->ce_flags
|= CE_STAGEMASK
;
338 * This gets a mix of an existing index and a tree, one pathname entry
339 * at a time. The index entry may be a single stage-0 one, but it could
340 * also be multiple unmerged entries (in which case idx_pos/idx_nr will
341 * give you the position and number of entries in the index).
343 static void do_oneway_diff(struct unpack_trees_options
*o
,
344 struct cache_entry
*idx
,
345 struct cache_entry
*tree
)
347 struct oneway_unpack_data
*cbdata
= o
->unpack_data
;
348 struct rev_info
*revs
= cbdata
->revs
;
349 int match_missing
, cached
;
351 /* if the entry is not checked out, don't examine work tree */
352 cached
= o
->index_only
|| (idx
&& ce_no_checkout(idx
));
354 * Backward compatibility wart - "diff-index -m" does
355 * not mean "do not ignore merges", but "match_missing".
357 * But with the revision flag parsing, that's found in
358 * "!revs->ignore_merges".
360 match_missing
= !revs
->ignore_merges
;
362 if (cached
&& idx
&& ce_stage(idx
)) {
364 diff_unmerge(&revs
->diffopt
, idx
->name
, idx
->ce_mode
, idx
->sha1
);
369 * Something added to the tree?
372 show_new_file(cbdata
, idx
, cached
, match_missing
);
377 * Something removed from the tree?
380 diff_index_show_file(revs
, "-", tree
, tree
->sha1
, tree
->ce_mode
);
384 /* Show difference between old and new */
385 show_modified(cbdata
, tree
, idx
, 1, cached
, match_missing
);
388 static inline void skip_same_name(struct cache_entry
*ce
, struct unpack_trees_options
*o
)
390 int len
= ce_namelen(ce
);
391 const struct index_state
*index
= o
->src_index
;
393 while (o
->pos
< index
->cache_nr
) {
394 struct cache_entry
*next
= index
->cache
[o
->pos
];
395 if (len
!= ce_namelen(next
))
397 if (memcmp(ce
->name
, next
->name
, len
))
404 * The unpack_trees() interface is designed for merging, so
405 * the different source entries are designed primarily for
406 * the source trees, with the old index being really mainly
407 * used for being replaced by the result.
409 * For diffing, the index is more important, and we only have a
412 * We're supposed to return how many index entries we want to skip.
414 * This wrapper makes it all more readable, and takes care of all
415 * the fairly complex unpack_trees() semantic requirements, including
416 * the skipping, the path matching, the type conflict cases etc.
418 static int oneway_diff(struct cache_entry
**src
, struct unpack_trees_options
*o
)
420 struct cache_entry
*idx
= src
[0];
421 struct cache_entry
*tree
= src
[1];
422 struct oneway_unpack_data
*cbdata
= o
->unpack_data
;
423 struct rev_info
*revs
= cbdata
->revs
;
425 if (idx
&& ce_stage(idx
))
426 skip_same_name(idx
, o
);
429 * Unpack-trees generates a DF/conflict entry if
430 * there was a directory in the index and a tree
431 * in the tree. From a diff standpoint, that's a
432 * delete of the tree and a create of the file.
434 if (tree
== o
->df_conflict_entry
)
437 if (ce_path_match(idx
? idx
: tree
, revs
->prune_data
))
438 do_oneway_diff(o
, idx
, tree
);
443 int run_diff_index(struct rev_info
*revs
, int cached
)
447 const char *tree_name
;
448 struct unpack_trees_options opts
;
450 struct oneway_unpack_data unpack_cb
;
452 mark_merge_entries();
454 ent
= revs
->pending
.objects
[0].item
;
455 tree_name
= revs
->pending
.objects
[0].name
;
456 tree
= parse_tree_indirect(ent
->sha1
);
458 return error("bad tree object %s", tree_name
);
460 unpack_cb
.revs
= revs
;
461 unpack_cb
.symcache
[0] = '\0';
462 memset(&opts
, 0, sizeof(opts
));
464 opts
.index_only
= cached
;
466 opts
.fn
= oneway_diff
;
467 opts
.unpack_data
= &unpack_cb
;
468 opts
.src_index
= &the_index
;
469 opts
.dst_index
= NULL
;
471 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
472 if (unpack_trees(1, &t
, &opts
))
475 diff_set_mnemonic_prefix(&revs
->diffopt
, "c/", cached
? "i/" : "w/");
476 diffcore_std(&revs
->diffopt
);
477 diff_flush(&revs
->diffopt
);
481 int do_diff_cache(const unsigned char *tree_sha1
, struct diff_options
*opt
)
484 struct rev_info revs
;
486 struct cache_entry
**dst
;
487 struct cache_entry
*last
= NULL
;
488 struct unpack_trees_options opts
;
490 struct oneway_unpack_data unpack_cb
;
493 * This is used by git-blame to run diff-cache internally;
494 * it potentially needs to repeatedly run this, so we will
495 * start by removing the higher order entries the last round
499 for (i
= 0; i
< active_nr
; i
++) {
500 struct cache_entry
*ce
= active_cache
[i
];
502 if (last
&& !strcmp(ce
->name
, last
->name
))
504 cache_tree_invalidate_path(active_cache_tree
,
507 ce
->ce_flags
|= CE_REMOVE
;
511 active_nr
= dst
- active_cache
;
513 init_revisions(&revs
, NULL
);
514 revs
.prune_data
= opt
->paths
;
515 tree
= parse_tree_indirect(tree_sha1
);
517 die("bad tree object %s", sha1_to_hex(tree_sha1
));
519 unpack_cb
.revs
= &revs
;
520 unpack_cb
.symcache
[0] = '\0';
521 memset(&opts
, 0, sizeof(opts
));
525 opts
.fn
= oneway_diff
;
526 opts
.unpack_data
= &unpack_cb
;
527 opts
.src_index
= &the_index
;
528 opts
.dst_index
= &the_index
;
530 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
531 if (unpack_trees(1, &t
, &opts
))