2 * Copyright (C) 2005 Junio C Hamano
10 #include "cache-tree.h"
11 #include "path-list.h"
17 static int read_directory(const char *path
, struct path_list
*list
)
22 if (!(dir
= opendir(path
)))
23 return error("Could not open directory %s", path
);
25 while ((e
= readdir(dir
)))
26 if (strcmp(".", e
->d_name
) && strcmp("..", e
->d_name
))
27 path_list_insert(xstrdup(e
->d_name
), list
);
33 static int queue_diff(struct diff_options
*o
,
34 const char *name1
, const char *name2
)
37 int mode1
= 0, mode2
= 0;
41 return error("Could not access '%s'", name1
);
46 return error("Could not access '%s'", name2
);
50 if (mode1
&& mode2
&& S_ISDIR(mode1
) != S_ISDIR(mode2
))
51 return error("file/directory conflict: %s, %s", name1
, name2
);
53 if (S_ISDIR(mode1
) || S_ISDIR(mode2
)) {
54 char buffer1
[PATH_MAX
], buffer2
[PATH_MAX
];
55 struct path_list p1
= {NULL
, 0, 0, 1}, p2
= {NULL
, 0, 0, 1};
56 int len1
= 0, len2
= 0, i1
, i2
, ret
= 0;
58 if (name1
&& read_directory(name1
, &p1
))
60 if (name2
&& read_directory(name2
, &p2
)) {
61 path_list_clear(&p1
, 0);
67 if (len1
> 0 && name1
[len1
- 1] == '/')
69 memcpy(buffer1
, name1
, len1
);
70 buffer1
[len1
++] = '/';
75 if (len2
> 0 && name2
[len2
- 1] == '/')
77 memcpy(buffer2
, name2
, len2
);
78 buffer2
[len2
++] = '/';
81 for (i1
= i2
= 0; !ret
&& (i1
< p1
.nr
|| i2
< p2
.nr
); ) {
90 comp
= strcmp(p1
.items
[i1
].path
,
97 strncpy(buffer1
+ len1
, p1
.items
[i1
++].path
,
105 strncpy(buffer2
+ len2
, p2
.items
[i2
++].path
,
109 ret
= queue_diff(o
, n1
, n2
);
111 path_list_clear(&p1
, 0);
112 path_list_clear(&p2
, 0);
116 struct diff_filespec
*d1
, *d2
;
118 if (o
->reverse_diff
) {
121 tmp
= mode1
; mode1
= mode2
; mode2
= tmp
;
122 tmp_c
= name1
; name1
= name2
; name2
= tmp_c
;
129 d1
= alloc_filespec(name1
);
130 d2
= alloc_filespec(name2
);
131 fill_filespec(d1
, null_sha1
, mode1
);
132 fill_filespec(d2
, null_sha1
, mode2
);
134 diff_queue(&diff_queued_diff
, d1
, d2
);
139 static int is_in_index(const char *path
)
141 int len
= strlen(path
);
142 int pos
= cache_name_pos(path
, len
);
147 if (strncmp(active_cache
[pos
]->name
, path
, len
))
149 c
= active_cache
[pos
]->name
[len
];
150 return c
== '\0' || c
== '/';
153 static int handle_diff_files_args(struct rev_info
*revs
,
154 int argc
, const char **argv
, int *silent
)
158 /* revs->max_count == -2 means --no-index */
159 while (1 < argc
&& argv
[1][0] == '-') {
160 if (!strcmp(argv
[1], "--base"))
162 else if (!strcmp(argv
[1], "--ours"))
164 else if (!strcmp(argv
[1], "--theirs"))
166 else if (!strcmp(argv
[1], "-n") ||
167 !strcmp(argv
[1], "--no-index"))
168 revs
->max_count
= -2;
169 else if (!strcmp(argv
[1], "-q"))
172 return error("invalid option: %s", argv
[1]);
176 if (revs
->max_count
== -1 && revs
->diffopt
.nr_paths
== 2) {
178 * If two files are specified, and at least one is untracked,
179 * default to no-index.
182 if (!is_in_index(revs
->diffopt
.paths
[0]) ||
183 !is_in_index(revs
->diffopt
.paths
[1]))
184 revs
->max_count
= -2;
188 * Make sure there are NO revision (i.e. pending object) parameter,
189 * rev.max_count is reasonable (0 <= n <= 3),
190 * there is no other revision filtering parameters.
192 if (revs
->pending
.nr
|| revs
->max_count
> 3 ||
193 revs
->min_age
!= -1 || revs
->max_age
!= -1)
194 return error("no revision allowed with diff-files");
196 if (revs
->max_count
== -1 &&
197 (revs
->diffopt
.output_format
& DIFF_FORMAT_PATCH
))
198 revs
->combine_merges
= revs
->dense_combined_merges
= 1;
203 int run_diff_files_cmd(struct rev_info
*revs
, int argc
, const char **argv
)
205 int silent_on_removed
;
207 if (handle_diff_files_args(revs
, argc
, argv
, &silent_on_removed
))
210 if (revs
->max_count
== -2) {
211 if (revs
->diffopt
.nr_paths
!= 2)
212 return error("need two files/directories with --no-index");
213 if (queue_diff(&revs
->diffopt
, revs
->diffopt
.paths
[0],
214 revs
->diffopt
.paths
[1]))
216 diffcore_std(&revs
->diffopt
);
217 diff_flush(&revs
->diffopt
);
219 * The return code for --no-index imitates diff(1):
220 * 0 = no changes, 1 = changes, else error
222 return revs
->diffopt
.found_changes
;
225 if (read_cache() < 0) {
226 perror("read_cache");
229 return run_diff_files(revs
, silent_on_removed
);
232 int run_diff_files(struct rev_info
*revs
, int silent_on_removed
)
235 int diff_unmerged_stage
= revs
->max_count
;
237 if (diff_unmerged_stage
< 0)
238 diff_unmerged_stage
= 2;
240 for (i
= 0; i
< entries
; i
++) {
242 unsigned int oldmode
, newmode
;
243 struct cache_entry
*ce
= active_cache
[i
];
246 if (!ce_path_match(ce
, revs
->prune_data
))
250 struct combine_diff_path
*dpath
;
251 int num_compare_stages
= 0;
254 path_len
= ce_namelen(ce
);
256 dpath
= xmalloc(combine_diff_path_size(5, path_len
));
257 dpath
->path
= (char *) &(dpath
->parent
[5]);
260 dpath
->len
= path_len
;
261 memcpy(dpath
->path
, ce
->name
, path_len
);
262 dpath
->path
[path_len
] = '\0';
263 hashclr(dpath
->sha1
);
264 memset(&(dpath
->parent
[0]), 0,
265 sizeof(struct combine_diff_parent
)*5);
267 if (lstat(ce
->name
, &st
) < 0) {
268 if (errno
!= ENOENT
&& errno
!= ENOTDIR
) {
272 if (silent_on_removed
)
276 dpath
->mode
= canon_mode(st
.st_mode
);
278 while (i
< entries
) {
279 struct cache_entry
*nce
= active_cache
[i
];
282 if (strcmp(ce
->name
, nce
->name
))
285 /* Stage #2 (ours) is the first parent,
286 * stage #3 (theirs) is the second.
288 stage
= ce_stage(nce
);
290 int mode
= ntohl(nce
->ce_mode
);
291 num_compare_stages
++;
292 hashcpy(dpath
->parent
[stage
-2].sha1
, nce
->sha1
);
293 dpath
->parent
[stage
-2].mode
=
295 dpath
->parent
[stage
-2].status
=
296 DIFF_STATUS_MODIFIED
;
299 /* diff against the proper unmerged stage */
300 if (stage
== diff_unmerged_stage
)
305 * Compensate for loop update
309 if (revs
->combine_merges
&& num_compare_stages
== 2) {
310 show_combined_diff(dpath
, 2,
311 revs
->dense_combined_merges
,
320 * Show the diff for the 'ce' if we found the one
321 * from the desired stage.
323 diff_unmerge(&revs
->diffopt
, ce
->name
, 0, null_sha1
);
324 if (ce_stage(ce
) != diff_unmerged_stage
)
328 if (lstat(ce
->name
, &st
) < 0) {
329 if (errno
!= ENOENT
&& errno
!= ENOTDIR
) {
333 if (silent_on_removed
)
335 diff_addremove(&revs
->diffopt
, '-', ntohl(ce
->ce_mode
),
336 ce
->sha1
, ce
->name
, NULL
);
339 changed
= ce_match_stat(ce
, &st
, 0);
340 if (!changed
&& !revs
->diffopt
.find_copies_harder
)
342 oldmode
= ntohl(ce
->ce_mode
);
344 newmode
= canon_mode(st
.st_mode
);
345 if (!trust_executable_bit
&&
346 S_ISREG(newmode
) && S_ISREG(oldmode
) &&
347 ((newmode
^ oldmode
) == 0111))
349 else if (!has_symlinks
&&
350 S_ISREG(newmode
) && S_ISLNK(oldmode
))
352 diff_change(&revs
->diffopt
, oldmode
, newmode
,
353 ce
->sha1
, (changed
? null_sha1
: ce
->sha1
),
357 diffcore_std(&revs
->diffopt
);
358 diff_flush(&revs
->diffopt
);
366 /* A file entry went away or appeared */
367 static void diff_index_show_file(struct rev_info
*revs
,
369 struct cache_entry
*ce
,
370 unsigned char *sha1
, unsigned int mode
)
372 diff_addremove(&revs
->diffopt
, prefix
[0], ntohl(mode
),
373 sha1
, ce
->name
, NULL
);
376 static int get_stat_data(struct cache_entry
*ce
,
377 unsigned char **sha1p
,
379 int cached
, int match_missing
)
381 unsigned char *sha1
= ce
->sha1
;
382 unsigned int mode
= ce
->ce_mode
;
385 static unsigned char no_sha1
[20];
388 if (lstat(ce
->name
, &st
) < 0) {
389 if (errno
== ENOENT
&& match_missing
) {
396 changed
= ce_match_stat(ce
, &st
, 0);
398 mode
= ce_mode_from_stat(ce
, st
.st_mode
);
408 static void show_new_file(struct rev_info
*revs
,
409 struct cache_entry
*new,
410 int cached
, int match_missing
)
415 /* New file in the index: it might actually be different in
418 if (get_stat_data(new, &sha1
, &mode
, cached
, match_missing
) < 0)
421 diff_index_show_file(revs
, "+", new, sha1
, mode
);
424 static int show_modified(struct rev_info
*revs
,
425 struct cache_entry
*old
,
426 struct cache_entry
*new,
428 int cached
, int match_missing
)
430 unsigned int mode
, oldmode
;
433 if (get_stat_data(new, &sha1
, &mode
, cached
, match_missing
) < 0) {
435 diff_index_show_file(revs
, "-", old
,
436 old
->sha1
, old
->ce_mode
);
440 if (revs
->combine_merges
&& !cached
&&
441 (hashcmp(sha1
, old
->sha1
) || hashcmp(old
->sha1
, new->sha1
))) {
442 struct combine_diff_path
*p
;
443 int pathlen
= ce_namelen(new);
445 p
= xmalloc(combine_diff_path_size(2, pathlen
));
446 p
->path
= (char *) &p
->parent
[2];
449 memcpy(p
->path
, new->name
, pathlen
);
450 p
->path
[pathlen
] = 0;
451 p
->mode
= ntohl(mode
);
453 memset(p
->parent
, 0, 2 * sizeof(struct combine_diff_parent
));
454 p
->parent
[0].status
= DIFF_STATUS_MODIFIED
;
455 p
->parent
[0].mode
= ntohl(new->ce_mode
);
456 hashcpy(p
->parent
[0].sha1
, new->sha1
);
457 p
->parent
[1].status
= DIFF_STATUS_MODIFIED
;
458 p
->parent
[1].mode
= ntohl(old
->ce_mode
);
459 hashcpy(p
->parent
[1].sha1
, old
->sha1
);
460 show_combined_diff(p
, 2, revs
->dense_combined_merges
, revs
);
465 oldmode
= old
->ce_mode
;
466 if (mode
== oldmode
&& !hashcmp(sha1
, old
->sha1
) &&
467 !revs
->diffopt
.find_copies_harder
)
471 oldmode
= ntohl(oldmode
);
473 diff_change(&revs
->diffopt
, oldmode
, mode
,
474 old
->sha1
, sha1
, old
->name
, NULL
);
478 static int diff_cache(struct rev_info
*revs
,
479 struct cache_entry
**ac
, int entries
,
480 const char **pathspec
,
481 int cached
, int match_missing
)
484 struct cache_entry
*ce
= *ac
;
485 int same
= (entries
> 1) && ce_same_name(ce
, ac
[1]);
487 if (!ce_path_match(ce
, pathspec
))
490 switch (ce_stage(ce
)) {
492 /* No stage 1 entry? That means it's a new file */
494 show_new_file(revs
, ce
, cached
, match_missing
);
497 /* Show difference between old and new */
498 show_modified(revs
, ac
[1], ce
, 1,
499 cached
, match_missing
);
502 /* No stage 3 (merge) entry?
503 * That means it's been deleted.
506 diff_index_show_file(revs
, "-", ce
,
507 ce
->sha1
, ce
->ce_mode
);
510 /* We come here with ce pointing at stage 1
511 * (original tree) and ac[1] pointing at stage
512 * 3 (unmerged). show-modified with
513 * report-missing set to false does not say the
514 * file is deleted but reports true if work
515 * tree does not have it, in which case we
516 * fall through to report the unmerged state.
517 * Otherwise, we show the differences between
518 * the original tree and the work tree.
521 !show_modified(revs
, ce
, ac
[1], 0,
522 cached
, match_missing
))
524 diff_unmerge(&revs
->diffopt
, ce
->name
,
525 ntohl(ce
->ce_mode
), ce
->sha1
);
528 diff_unmerge(&revs
->diffopt
, ce
->name
,
533 die("impossible cache entry stage");
538 * Ignore all the different stages for this file,
539 * we've handled the relevant cases now.
544 } while (entries
&& ce_same_name(ce
, ac
[0]));
550 * This turns all merge entries into "stage 3". That guarantees that
551 * when we read in the new tree (into "stage 1"), we won't lose sight
552 * of the fact that we had unmerged entries.
554 static void mark_merge_entries(void)
557 for (i
= 0; i
< active_nr
; i
++) {
558 struct cache_entry
*ce
= active_cache
[i
];
561 ce
->ce_flags
|= htons(CE_STAGEMASK
);
565 int run_diff_index(struct rev_info
*revs
, int cached
)
570 const char *tree_name
;
571 int match_missing
= 0;
574 * Backward compatibility wart - "diff-index -m" does
575 * not mean "do not ignore merges", but totally different.
577 if (!revs
->ignore_merges
)
580 mark_merge_entries();
582 ent
= revs
->pending
.objects
[0].item
;
583 tree_name
= revs
->pending
.objects
[0].name
;
584 tree
= parse_tree_indirect(ent
->sha1
);
586 return error("bad tree object %s", tree_name
);
587 if (read_tree(tree
, 1, revs
->prune_data
))
588 return error("unable to read tree object %s", tree_name
);
589 ret
= diff_cache(revs
, active_cache
, active_nr
, revs
->prune_data
,
590 cached
, match_missing
);
591 diffcore_std(&revs
->diffopt
);
592 diff_flush(&revs
->diffopt
);
596 int do_diff_cache(const unsigned char *tree_sha1
, struct diff_options
*opt
)
599 struct rev_info revs
;
601 struct cache_entry
**dst
;
602 struct cache_entry
*last
= NULL
;
605 * This is used by git-blame to run diff-cache internally;
606 * it potentially needs to repeatedly run this, so we will
607 * start by removing the higher order entries the last round
611 for (i
= 0; i
< active_nr
; i
++) {
612 struct cache_entry
*ce
= active_cache
[i
];
614 if (last
&& !strcmp(ce
->name
, last
->name
))
616 cache_tree_invalidate_path(active_cache_tree
,
620 ce
->ce_flags
&= ~htons(CE_STAGEMASK
);
624 active_nr
= dst
- active_cache
;
626 init_revisions(&revs
, NULL
);
627 revs
.prune_data
= opt
->paths
;
628 tree
= parse_tree_indirect(tree_sha1
);
630 die("bad tree object %s", sha1_to_hex(tree_sha1
));
631 if (read_tree(tree
, 1, opt
->paths
))
632 return error("unable to read tree %s", sha1_to_hex(tree_sha1
));
633 return diff_cache(&revs
, active_cache
, active_nr
, revs
.prune_data
,