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(e
->d_name
, list
);
33 static int get_mode(const char *path
, int *mode
)
37 if (!path
|| is_dev_null(path
))
39 else if (!strcmp(path
, "-"))
40 *mode
= ntohl(create_ce_mode(0666));
41 else if (stat(path
, &st
))
42 return error("Could not access '%s'", path
);
48 static int queue_diff(struct diff_options
*o
,
49 const char *name1
, const char *name2
)
51 int mode1
= 0, mode2
= 0;
53 if (get_mode(name1
, &mode1
) || get_mode(name2
, &mode2
))
56 if (mode1
&& mode2
&& S_ISDIR(mode1
) != S_ISDIR(mode2
))
57 return error("file/directory conflict: %s, %s", name1
, name2
);
59 if (S_ISDIR(mode1
) || S_ISDIR(mode2
)) {
60 char buffer1
[PATH_MAX
], buffer2
[PATH_MAX
];
61 struct path_list p1
= {NULL
, 0, 0, 1}, p2
= {NULL
, 0, 0, 1};
62 int len1
= 0, len2
= 0, i1
, i2
, ret
= 0;
64 if (name1
&& read_directory(name1
, &p1
))
66 if (name2
&& read_directory(name2
, &p2
)) {
67 path_list_clear(&p1
, 0);
73 if (len1
> 0 && name1
[len1
- 1] == '/')
75 memcpy(buffer1
, name1
, len1
);
76 buffer1
[len1
++] = '/';
81 if (len2
> 0 && name2
[len2
- 1] == '/')
83 memcpy(buffer2
, name2
, len2
);
84 buffer2
[len2
++] = '/';
87 for (i1
= i2
= 0; !ret
&& (i1
< p1
.nr
|| i2
< p2
.nr
); ) {
96 comp
= strcmp(p1
.items
[i1
].path
,
103 strncpy(buffer1
+ len1
, p1
.items
[i1
++].path
,
111 strncpy(buffer2
+ len2
, p2
.items
[i2
++].path
,
115 ret
= queue_diff(o
, n1
, n2
);
117 path_list_clear(&p1
, 0);
118 path_list_clear(&p2
, 0);
122 struct diff_filespec
*d1
, *d2
;
124 if (DIFF_OPT_TST(o
, REVERSE_DIFF
)) {
127 tmp
= mode1
; mode1
= mode2
; mode2
= tmp
;
128 tmp_c
= name1
; name1
= name2
; name2
= tmp_c
;
135 d1
= alloc_filespec(name1
);
136 d2
= alloc_filespec(name2
);
137 fill_filespec(d1
, null_sha1
, mode1
);
138 fill_filespec(d2
, null_sha1
, mode2
);
140 diff_queue(&diff_queued_diff
, d1
, d2
);
146 * Does the path name a blob in the working tree, or a directory
147 * in the working tree?
149 static int is_in_index(const char *path
)
152 struct cache_entry
*ce
;
155 while (path
[len
-1] == '/')
159 pos
= cache_name_pos(path
, len
);
163 while (pos
< active_nr
) {
164 ce
= active_cache
[pos
++];
165 if (ce_namelen(ce
) <= len
||
166 strncmp(ce
->name
, path
, len
) ||
167 (ce
->name
[len
] > '/'))
168 break; /* path cannot be a prefix */
169 if (ce
->name
[len
] == '/')
175 static int handle_diff_files_args(struct rev_info
*revs
,
176 int argc
, const char **argv
,
177 unsigned int *options
)
181 /* revs->max_count == -2 means --no-index */
182 while (1 < argc
&& argv
[1][0] == '-') {
183 if (!strcmp(argv
[1], "--base"))
185 else if (!strcmp(argv
[1], "--ours"))
187 else if (!strcmp(argv
[1], "--theirs"))
189 else if (!strcmp(argv
[1], "-n") ||
190 !strcmp(argv
[1], "--no-index")) {
191 revs
->max_count
= -2;
192 DIFF_OPT_SET(&revs
->diffopt
, EXIT_WITH_STATUS
);
193 DIFF_OPT_SET(&revs
->diffopt
, NO_INDEX
);
195 else if (!strcmp(argv
[1], "-q"))
196 *options
|= DIFF_SILENT_ON_REMOVED
;
198 return error("invalid option: %s", argv
[1]);
202 if (revs
->max_count
== -1 && revs
->diffopt
.nr_paths
== 2) {
204 * If two files are specified, and at least one is untracked,
205 * default to no-index.
208 if (!is_in_index(revs
->diffopt
.paths
[0]) ||
209 !is_in_index(revs
->diffopt
.paths
[1])) {
210 revs
->max_count
= -2;
211 DIFF_OPT_SET(&revs
->diffopt
, NO_INDEX
);
216 * Make sure there are NO revision (i.e. pending object) parameter,
217 * rev.max_count is reasonable (0 <= n <= 3),
218 * there is no other revision filtering parameters.
220 if (revs
->pending
.nr
|| revs
->max_count
> 3 ||
221 revs
->min_age
!= -1 || revs
->max_age
!= -1)
222 return error("no revision allowed with diff-files");
224 if (revs
->max_count
== -1 &&
225 (revs
->diffopt
.output_format
& DIFF_FORMAT_PATCH
))
226 revs
->combine_merges
= revs
->dense_combined_merges
= 1;
231 static int is_outside_repo(const char *path
, int nongit
, const char *prefix
)
234 if (nongit
|| !strcmp(path
, "-") || is_absolute_path(path
))
237 if (!strcmp(path
, "nul"))
240 if (prefixcmp(path
, "../"))
244 for (i
= strlen(prefix
); !prefixcmp(path
, "../"); ) {
245 while (i
> 0 && prefix
[i
- 1] != '/')
254 int setup_diff_no_index(struct rev_info
*revs
,
255 int argc
, const char ** argv
, int nongit
, const char *prefix
)
258 for (i
= 1; i
< argc
; i
++)
259 if (argv
[i
][0] != '-' || argv
[i
][1] == '\0')
261 else if (!strcmp(argv
[i
], "--")) {
264 } else if (i
< argc
- 3 && !strcmp(argv
[i
], "--no-index")) {
266 DIFF_OPT_SET(&revs
->diffopt
, EXIT_WITH_STATUS
);
269 if (argc
!= i
+ 2 || (!is_outside_repo(argv
[i
+ 1], nongit
, prefix
) &&
270 !is_outside_repo(argv
[i
], nongit
, prefix
)))
273 diff_setup(&revs
->diffopt
);
274 for (i
= 1; i
< argc
- 2; )
275 if (!strcmp(argv
[i
], "--no-index"))
278 int j
= diff_opt_parse(&revs
->diffopt
,
281 die("invalid diff option/value: %s", argv
[i
]);
286 int len
= strlen(prefix
);
288 revs
->diffopt
.paths
= xcalloc(2, sizeof(char*));
289 for (i
= 0; i
< 2; i
++) {
290 const char *p
= argv
[argc
- 2 + i
];
292 * stdin should be spelled as '-'; if you have
293 * path that is '-', spell it as ./-.
296 ? xstrdup(prefix_filename(prefix
, len
, p
))
298 revs
->diffopt
.paths
[i
] = p
;
302 revs
->diffopt
.paths
= argv
+ argc
- 2;
303 revs
->diffopt
.nr_paths
= 2;
304 DIFF_OPT_SET(&revs
->diffopt
, NO_INDEX
);
305 revs
->max_count
= -2;
306 if (diff_setup_done(&revs
->diffopt
) < 0)
307 die("diff_setup_done failed");
311 int run_diff_files_cmd(struct rev_info
*revs
, int argc
, const char **argv
)
313 unsigned int options
;
315 if (handle_diff_files_args(revs
, argc
, argv
, &options
))
318 if (DIFF_OPT_TST(&revs
->diffopt
, NO_INDEX
)) {
319 if (revs
->diffopt
.nr_paths
!= 2)
320 return error("need two files/directories with --no-index");
321 if (queue_diff(&revs
->diffopt
, revs
->diffopt
.paths
[0],
322 revs
->diffopt
.paths
[1]))
324 diffcore_std(&revs
->diffopt
);
325 diff_flush(&revs
->diffopt
);
327 * The return code for --no-index imitates diff(1):
328 * 0 = no changes, 1 = changes, else error
330 return revs
->diffopt
.found_changes
;
333 if (read_cache() < 0) {
334 perror("read_cache");
337 return run_diff_files(revs
, options
);
340 int run_diff_files(struct rev_info
*revs
, unsigned int option
)
343 int diff_unmerged_stage
= revs
->max_count
;
344 int silent_on_removed
= option
& DIFF_SILENT_ON_REMOVED
;
345 unsigned ce_option
= ((option
& DIFF_RACY_IS_MODIFIED
)
346 ? CE_MATCH_RACY_IS_DIRTY
: 0);
348 if (diff_unmerged_stage
< 0)
349 diff_unmerged_stage
= 2;
351 for (i
= 0; i
< entries
; i
++) {
353 unsigned int oldmode
, newmode
;
354 struct cache_entry
*ce
= active_cache
[i
];
357 if (DIFF_OPT_TST(&revs
->diffopt
, QUIET
) &&
358 DIFF_OPT_TST(&revs
->diffopt
, HAS_CHANGES
))
361 if (!ce_path_match(ce
, revs
->prune_data
))
365 struct combine_diff_path
*dpath
;
366 int num_compare_stages
= 0;
369 path_len
= ce_namelen(ce
);
371 dpath
= xmalloc(combine_diff_path_size(5, path_len
));
372 dpath
->path
= (char *) &(dpath
->parent
[5]);
375 dpath
->len
= path_len
;
376 memcpy(dpath
->path
, ce
->name
, path_len
);
377 dpath
->path
[path_len
] = '\0';
378 hashclr(dpath
->sha1
);
379 memset(&(dpath
->parent
[0]), 0,
380 sizeof(struct combine_diff_parent
)*5);
382 if (lstat(ce
->name
, &st
) < 0) {
383 if (errno
!= ENOENT
&& errno
!= ENOTDIR
) {
387 if (silent_on_removed
)
391 dpath
->mode
= ntohl(ce_mode_from_stat(ce
, st
.st_mode
));
393 while (i
< entries
) {
394 struct cache_entry
*nce
= active_cache
[i
];
397 if (strcmp(ce
->name
, nce
->name
))
400 /* Stage #2 (ours) is the first parent,
401 * stage #3 (theirs) is the second.
403 stage
= ce_stage(nce
);
405 int mode
= ntohl(nce
->ce_mode
);
406 num_compare_stages
++;
407 hashcpy(dpath
->parent
[stage
-2].sha1
, nce
->sha1
);
408 dpath
->parent
[stage
-2].mode
= ntohl(ce_mode_from_stat(nce
, mode
));
409 dpath
->parent
[stage
-2].status
=
410 DIFF_STATUS_MODIFIED
;
413 /* diff against the proper unmerged stage */
414 if (stage
== diff_unmerged_stage
)
419 * Compensate for loop update
423 if (revs
->combine_merges
&& num_compare_stages
== 2) {
424 show_combined_diff(dpath
, 2,
425 revs
->dense_combined_merges
,
434 * Show the diff for the 'ce' if we found the one
435 * from the desired stage.
437 diff_unmerge(&revs
->diffopt
, ce
->name
, 0, null_sha1
);
438 if (ce_stage(ce
) != diff_unmerged_stage
)
442 if (lstat(ce
->name
, &st
) < 0) {
443 if (errno
!= ENOENT
&& errno
!= ENOTDIR
) {
447 if (silent_on_removed
)
449 diff_addremove(&revs
->diffopt
, '-', ntohl(ce
->ce_mode
),
450 ce
->sha1
, ce
->name
, NULL
);
453 changed
= ce_match_stat(ce
, &st
, ce_option
);
454 if (!changed
&& !DIFF_OPT_TST(&revs
->diffopt
, FIND_COPIES_HARDER
))
456 oldmode
= ntohl(ce
->ce_mode
);
457 newmode
= ntohl(ce_mode_from_stat(ce
, st
.st_mode
));
458 diff_change(&revs
->diffopt
, oldmode
, newmode
,
459 ce
->sha1
, (changed
? null_sha1
: ce
->sha1
),
463 diffcore_std(&revs
->diffopt
);
464 diff_flush(&revs
->diffopt
);
472 /* A file entry went away or appeared */
473 static void diff_index_show_file(struct rev_info
*revs
,
475 struct cache_entry
*ce
,
476 unsigned char *sha1
, unsigned int mode
)
478 diff_addremove(&revs
->diffopt
, prefix
[0], ntohl(mode
),
479 sha1
, ce
->name
, NULL
);
482 static int get_stat_data(struct cache_entry
*ce
,
483 unsigned char **sha1p
,
485 int cached
, int match_missing
)
487 unsigned char *sha1
= ce
->sha1
;
488 unsigned int mode
= ce
->ce_mode
;
491 static unsigned char no_sha1
[20];
494 if (lstat(ce
->name
, &st
) < 0) {
495 if (errno
== ENOENT
&& match_missing
) {
502 changed
= ce_match_stat(ce
, &st
, 0);
504 mode
= ce_mode_from_stat(ce
, st
.st_mode
);
514 static void show_new_file(struct rev_info
*revs
,
515 struct cache_entry
*new,
516 int cached
, int match_missing
)
521 /* New file in the index: it might actually be different in
524 if (get_stat_data(new, &sha1
, &mode
, cached
, match_missing
) < 0)
527 diff_index_show_file(revs
, "+", new, sha1
, mode
);
530 static int show_modified(struct rev_info
*revs
,
531 struct cache_entry
*old
,
532 struct cache_entry
*new,
534 int cached
, int match_missing
)
536 unsigned int mode
, oldmode
;
539 if (get_stat_data(new, &sha1
, &mode
, cached
, match_missing
) < 0) {
541 diff_index_show_file(revs
, "-", old
,
542 old
->sha1
, old
->ce_mode
);
546 if (revs
->combine_merges
&& !cached
&&
547 (hashcmp(sha1
, old
->sha1
) || hashcmp(old
->sha1
, new->sha1
))) {
548 struct combine_diff_path
*p
;
549 int pathlen
= ce_namelen(new);
551 p
= xmalloc(combine_diff_path_size(2, pathlen
));
552 p
->path
= (char *) &p
->parent
[2];
555 memcpy(p
->path
, new->name
, pathlen
);
556 p
->path
[pathlen
] = 0;
557 p
->mode
= ntohl(mode
);
559 memset(p
->parent
, 0, 2 * sizeof(struct combine_diff_parent
));
560 p
->parent
[0].status
= DIFF_STATUS_MODIFIED
;
561 p
->parent
[0].mode
= ntohl(new->ce_mode
);
562 hashcpy(p
->parent
[0].sha1
, new->sha1
);
563 p
->parent
[1].status
= DIFF_STATUS_MODIFIED
;
564 p
->parent
[1].mode
= ntohl(old
->ce_mode
);
565 hashcpy(p
->parent
[1].sha1
, old
->sha1
);
566 show_combined_diff(p
, 2, revs
->dense_combined_merges
, revs
);
571 oldmode
= old
->ce_mode
;
572 if (mode
== oldmode
&& !hashcmp(sha1
, old
->sha1
) &&
573 !DIFF_OPT_TST(&revs
->diffopt
, FIND_COPIES_HARDER
))
577 oldmode
= ntohl(oldmode
);
579 diff_change(&revs
->diffopt
, oldmode
, mode
,
580 old
->sha1
, sha1
, old
->name
, NULL
);
584 static int diff_cache(struct rev_info
*revs
,
585 struct cache_entry
**ac
, int entries
,
586 const char **pathspec
,
587 int cached
, int match_missing
)
590 struct cache_entry
*ce
= *ac
;
591 int same
= (entries
> 1) && ce_same_name(ce
, ac
[1]);
593 if (DIFF_OPT_TST(&revs
->diffopt
, QUIET
) &&
594 DIFF_OPT_TST(&revs
->diffopt
, HAS_CHANGES
))
597 if (!ce_path_match(ce
, pathspec
))
600 switch (ce_stage(ce
)) {
602 /* No stage 1 entry? That means it's a new file */
604 show_new_file(revs
, ce
, cached
, match_missing
);
607 /* Show difference between old and new */
608 show_modified(revs
, ac
[1], ce
, 1,
609 cached
, match_missing
);
612 /* No stage 3 (merge) entry?
613 * That means it's been deleted.
616 diff_index_show_file(revs
, "-", ce
,
617 ce
->sha1
, ce
->ce_mode
);
620 /* We come here with ce pointing at stage 1
621 * (original tree) and ac[1] pointing at stage
622 * 3 (unmerged). show-modified with
623 * report-missing set to false does not say the
624 * file is deleted but reports true if work
625 * tree does not have it, in which case we
626 * fall through to report the unmerged state.
627 * Otherwise, we show the differences between
628 * the original tree and the work tree.
631 !show_modified(revs
, ce
, ac
[1], 0,
632 cached
, match_missing
))
634 diff_unmerge(&revs
->diffopt
, ce
->name
,
635 ntohl(ce
->ce_mode
), ce
->sha1
);
638 diff_unmerge(&revs
->diffopt
, ce
->name
,
643 die("impossible cache entry stage");
648 * Ignore all the different stages for this file,
649 * we've handled the relevant cases now.
654 } while (entries
&& ce_same_name(ce
, ac
[0]));
660 * This turns all merge entries into "stage 3". That guarantees that
661 * when we read in the new tree (into "stage 1"), we won't lose sight
662 * of the fact that we had unmerged entries.
664 static void mark_merge_entries(void)
667 for (i
= 0; i
< active_nr
; i
++) {
668 struct cache_entry
*ce
= active_cache
[i
];
671 ce
->ce_flags
|= htons(CE_STAGEMASK
);
675 int run_diff_index(struct rev_info
*revs
, int cached
)
680 const char *tree_name
;
681 int match_missing
= 0;
684 * Backward compatibility wart - "diff-index -m" does
685 * not mean "do not ignore merges", but totally different.
687 if (!revs
->ignore_merges
)
690 mark_merge_entries();
692 ent
= revs
->pending
.objects
[0].item
;
693 tree_name
= revs
->pending
.objects
[0].name
;
694 tree
= parse_tree_indirect(ent
->sha1
);
696 return error("bad tree object %s", tree_name
);
697 if (read_tree(tree
, 1, revs
->prune_data
))
698 return error("unable to read tree object %s", tree_name
);
699 ret
= diff_cache(revs
, active_cache
, active_nr
, revs
->prune_data
,
700 cached
, match_missing
);
701 diffcore_std(&revs
->diffopt
);
702 diff_flush(&revs
->diffopt
);
706 int do_diff_cache(const unsigned char *tree_sha1
, struct diff_options
*opt
)
709 struct rev_info revs
;
711 struct cache_entry
**dst
;
712 struct cache_entry
*last
= NULL
;
715 * This is used by git-blame to run diff-cache internally;
716 * it potentially needs to repeatedly run this, so we will
717 * start by removing the higher order entries the last round
721 for (i
= 0; i
< active_nr
; i
++) {
722 struct cache_entry
*ce
= active_cache
[i
];
724 if (last
&& !strcmp(ce
->name
, last
->name
))
726 cache_tree_invalidate_path(active_cache_tree
,
730 ce
->ce_flags
&= ~htons(CE_STAGEMASK
);
734 active_nr
= dst
- active_cache
;
736 init_revisions(&revs
, NULL
);
737 revs
.prune_data
= opt
->paths
;
738 tree
= parse_tree_indirect(tree_sha1
);
740 die("bad tree object %s", sha1_to_hex(tree_sha1
));
741 if (read_tree(tree
, 1, opt
->paths
))
742 return error("unable to read tree %s", sha1_to_hex(tree_sha1
));
743 return diff_cache(&revs
, active_cache
, active_nr
, revs
.prune_data
,