1 /*
2 * Builtin "git diff"
3 *
4 * Copyright (c) 2006 Junio C Hamano
5 */
6 #define USE_THE_INDEX_COMPATIBILITY_MACROS
7 #include "cache.h"
8 #include "config.h"
9 #include "ewah/ewok.h"
10 #include "lockfile.h"
11 #include "color.h"
12 #include "commit.h"
13 #include "blob.h"
14 #include "tag.h"
15 #include "diff.h"
16 #include "diff-merges.h"
17 #include "diffcore.h"
18 #include "revision.h"
19 #include "log-tree.h"
20 #include "builtin.h"
21 #include "submodule.h"
22 #include "oid-array.h"
23
24 #define DIFF_NO_INDEX_EXPLICIT 1
25 #define DIFF_NO_INDEX_IMPLICIT 2
26
27 static const char builtin_diff_usage[] =
28 "git diff [<options>] [<commit>] [--] [<path>...]\n"
29 " or: git diff [<options>] --cached [--merge-base] [<commit>] [--] [<path>...]\n"
30 " or: git diff [<options>] [--merge-base] <commit> [<commit>...] <commit> [--] [<path>...]\n"
31 " or: git diff [<options>] <commit>...<commit>] [--] [<path>...]\n"
32 " or: git diff [<options>] <blob> <blob>]\n"
33 " or: git diff [<options>] --no-index [--] <path> <path>]\n"
34 COMMON_DIFF_OPTIONS_HELP;
35
blob_path(struct object_array_entry * entry)36 static const char *blob_path(struct object_array_entry *entry)
37 {
38 return entry->path ? entry->path : entry->name;
39 }
40
stuff_change(struct diff_options * opt,unsigned old_mode,unsigned new_mode,const struct object_id * old_oid,const struct object_id * new_oid,int old_oid_valid,int new_oid_valid,const char * old_path,const char * new_path)41 static void stuff_change(struct diff_options *opt,
42 unsigned old_mode, unsigned new_mode,
43 const struct object_id *old_oid,
44 const struct object_id *new_oid,
45 int old_oid_valid,
46 int new_oid_valid,
47 const char *old_path,
48 const char *new_path)
49 {
50 struct diff_filespec *one, *two;
51
52 if (!is_null_oid(old_oid) && !is_null_oid(new_oid) &&
53 oideq(old_oid, new_oid) && (old_mode == new_mode))
54 return;
55
56 if (opt->flags.reverse_diff) {
57 SWAP(old_mode, new_mode);
58 SWAP(old_oid, new_oid);
59 SWAP(old_path, new_path);
60 }
61
62 if (opt->prefix &&
63 (strncmp(old_path, opt->prefix, opt->prefix_length) ||
64 strncmp(new_path, opt->prefix, opt->prefix_length)))
65 return;
66
67 one = alloc_filespec(old_path);
68 two = alloc_filespec(new_path);
69 fill_filespec(one, old_oid, old_oid_valid, old_mode);
70 fill_filespec(two, new_oid, new_oid_valid, new_mode);
71
72 diff_queue(&diff_queued_diff, one, two);
73 }
74
builtin_diff_b_f(struct rev_info * revs,int argc,const char ** argv,struct object_array_entry ** blob)75 static int builtin_diff_b_f(struct rev_info *revs,
76 int argc, const char **argv,
77 struct object_array_entry **blob)
78 {
79 /* Blob vs file in the working tree*/
80 struct stat st;
81 const char *path;
82
83 if (argc > 1)
84 usage(builtin_diff_usage);
85
86 GUARD_PATHSPEC(&revs->prune_data, PATHSPEC_FROMTOP | PATHSPEC_LITERAL);
87 path = revs->prune_data.items[0].match;
88
89 if (lstat(path, &st))
90 die_errno(_("failed to stat '%s'"), path);
91 if (!(S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)))
92 die(_("'%s': not a regular file or symlink"), path);
93
94 diff_set_mnemonic_prefix(&revs->diffopt, "o/", "w/");
95
96 if (blob[0]->mode == S_IFINVALID)
97 blob[0]->mode = canon_mode(st.st_mode);
98
99 stuff_change(&revs->diffopt,
100 blob[0]->mode, canon_mode(st.st_mode),
101 &blob[0]->item->oid, null_oid(),
102 1, 0,
103 blob[0]->path ? blob[0]->path : path,
104 path);
105 diffcore_std(&revs->diffopt);
106 diff_flush(&revs->diffopt);
107 return 0;
108 }
109
builtin_diff_blobs(struct rev_info * revs,int argc,const char ** argv,struct object_array_entry ** blob)110 static int builtin_diff_blobs(struct rev_info *revs,
111 int argc, const char **argv,
112 struct object_array_entry **blob)
113 {
114 const unsigned mode = canon_mode(S_IFREG | 0644);
115
116 if (argc > 1)
117 usage(builtin_diff_usage);
118
119 if (blob[0]->mode == S_IFINVALID)
120 blob[0]->mode = mode;
121
122 if (blob[1]->mode == S_IFINVALID)
123 blob[1]->mode = mode;
124
125 stuff_change(&revs->diffopt,
126 blob[0]->mode, blob[1]->mode,
127 &blob[0]->item->oid, &blob[1]->item->oid,
128 1, 1,
129 blob_path(blob[0]), blob_path(blob[1]));
130 diffcore_std(&revs->diffopt);
131 diff_flush(&revs->diffopt);
132 return 0;
133 }
134
builtin_diff_index(struct rev_info * revs,int argc,const char ** argv)135 static int builtin_diff_index(struct rev_info *revs,
136 int argc, const char **argv)
137 {
138 unsigned int option = 0;
139 while (1 < argc) {
140 const char *arg = argv[1];
141 if (!strcmp(arg, "--cached") || !strcmp(arg, "--staged"))
142 option |= DIFF_INDEX_CACHED;
143 else if (!strcmp(arg, "--merge-base"))
144 option |= DIFF_INDEX_MERGE_BASE;
145 else
146 usage(builtin_diff_usage);
147 argv++; argc--;
148 }
149 /*
150 * Make sure there is one revision (i.e. pending object),
151 * and there is no revision filtering parameters.
152 */
153 if (revs->pending.nr != 1 ||
154 revs->max_count != -1 || revs->min_age != -1 ||
155 revs->max_age != -1)
156 usage(builtin_diff_usage);
157 if (!(option & DIFF_INDEX_CACHED)) {
158 setup_work_tree();
159 if (read_cache_preload(&revs->diffopt.pathspec) < 0) {
160 perror("read_cache_preload");
161 return -1;
162 }
163 } else if (read_cache() < 0) {
164 perror("read_cache");
165 return -1;
166 }
167 return run_diff_index(revs, option);
168 }
169
builtin_diff_tree(struct rev_info * revs,int argc,const char ** argv,struct object_array_entry * ent0,struct object_array_entry * ent1)170 static int builtin_diff_tree(struct rev_info *revs,
171 int argc, const char **argv,
172 struct object_array_entry *ent0,
173 struct object_array_entry *ent1)
174 {
175 const struct object_id *(oid[2]);
176 struct object_id mb_oid;
177 int merge_base = 0;
178
179 while (1 < argc) {
180 const char *arg = argv[1];
181 if (!strcmp(arg, "--merge-base"))
182 merge_base = 1;
183 else
184 usage(builtin_diff_usage);
185 argv++; argc--;
186 }
187
188 if (merge_base) {
189 diff_get_merge_base(revs, &mb_oid);
190 oid[0] = &mb_oid;
191 oid[1] = &revs->pending.objects[1].item->oid;
192 } else {
193 int swap = 0;
194
195 /*
196 * We saw two trees, ent0 and ent1. If ent1 is uninteresting,
197 * swap them.
198 */
199 if (ent1->item->flags & UNINTERESTING)
200 swap = 1;
201 oid[swap] = &ent0->item->oid;
202 oid[1 - swap] = &ent1->item->oid;
203 }
204 diff_tree_oid(oid[0], oid[1], "", &revs->diffopt);
205 log_tree_diff_flush(revs);
206 return 0;
207 }
208
builtin_diff_combined(struct rev_info * revs,int argc,const char ** argv,struct object_array_entry * ent,int ents)209 static int builtin_diff_combined(struct rev_info *revs,
210 int argc, const char **argv,
211 struct object_array_entry *ent,
212 int ents)
213 {
214 struct oid_array parents = OID_ARRAY_INIT;
215 int i;
216
217 if (argc > 1)
218 usage(builtin_diff_usage);
219
220 diff_merges_set_dense_combined_if_unset(revs);
221
222 for (i = 1; i < ents; i++)
223 oid_array_append(&parents, &ent[i].item->oid);
224 diff_tree_combined(&ent[0].item->oid, &parents, revs);
225 oid_array_clear(&parents);
226 return 0;
227 }
228
refresh_index_quietly(void)229 static void refresh_index_quietly(void)
230 {
231 struct lock_file lock_file = LOCK_INIT;
232 int fd;
233
234 fd = hold_locked_index(&lock_file, 0);
235 if (fd < 0)
236 return;
237 discard_cache();
238 read_cache();
239 refresh_cache(REFRESH_QUIET|REFRESH_UNMERGED);
240 repo_update_index_if_able(the_repository, &lock_file);
241 }
242
builtin_diff_files(struct rev_info * revs,int argc,const char ** argv)243 static int builtin_diff_files(struct rev_info *revs, int argc, const char **argv)
244 {
245 unsigned int options = 0;
246
247 while (1 < argc && argv[1][0] == '-') {
248 if (!strcmp(argv[1], "--base"))
249 revs->max_count = 1;
250 else if (!strcmp(argv[1], "--ours"))
251 revs->max_count = 2;
252 else if (!strcmp(argv[1], "--theirs"))
253 revs->max_count = 3;
254 else if (!strcmp(argv[1], "-q"))
255 options |= DIFF_SILENT_ON_REMOVED;
256 else if (!strcmp(argv[1], "-h"))
257 usage(builtin_diff_usage);
258 else
259 return error(_("invalid option: %s"), argv[1]);
260 argv++; argc--;
261 }
262
263 /*
264 * "diff --base" should not combine merges because it was not
265 * asked to. "diff -c" should not densify (if the user wants
266 * dense one, --cc can be explicitly asked for, or just rely
267 * on the default).
268 */
269 if (revs->max_count == -1 &&
270 (revs->diffopt.output_format & DIFF_FORMAT_PATCH))
271 diff_merges_set_dense_combined_if_unset(revs);
272
273 setup_work_tree();
274 if (read_cache_preload(&revs->diffopt.pathspec) < 0) {
275 perror("read_cache_preload");
276 return -1;
277 }
278 return run_diff_files(revs, options);
279 }
280
281 struct symdiff {
282 struct bitmap *skip;
283 int warn;
284 const char *base, *left, *right;
285 };
286
287 /*
288 * Check for symmetric-difference arguments, and if present, arrange
289 * everything we need to know to handle them correctly. As a bonus,
290 * weed out all bogus range-based revision specifications, e.g.,
291 * "git diff A..B C..D" or "git diff A..B C" get rejected.
292 *
293 * For an actual symmetric diff, *symdiff is set this way:
294 *
295 * - its skip is non-NULL and marks *all* rev->pending.objects[i]
296 * indices that the caller should ignore (extra merge bases, of
297 * which there might be many, and A in A...B). Note that the
298 * chosen merge base and right side are NOT marked.
299 * - warn is set if there are multiple merge bases.
300 * - base, left, and right point to the names to use in a
301 * warning about multiple merge bases.
302 *
303 * If there is no symmetric diff argument, sym->skip is NULL and
304 * sym->warn is cleared. The remaining fields are not set.
305 */
symdiff_prepare(struct rev_info * rev,struct symdiff * sym)306 static void symdiff_prepare(struct rev_info *rev, struct symdiff *sym)
307 {
308 int i, is_symdiff = 0, basecount = 0, othercount = 0;
309 int lpos = -1, rpos = -1, basepos = -1;
310 struct bitmap *map = NULL;
311
312 /*
313 * Use the whence fields to find merge bases and left and
314 * right parts of symmetric difference, so that we do not
315 * depend on the order that revisions are parsed. If there
316 * are any revs that aren't from these sources, we have a
317 * "git diff C A...B" or "git diff A...B C" case. Or we
318 * could even get "git diff A...B C...E", for instance.
319 *
320 * If we don't have just one merge base, we pick one
321 * at random.
322 *
323 * NB: REV_CMD_LEFT, REV_CMD_RIGHT are also used for A..B,
324 * so we must check for SYMMETRIC_LEFT too. The two arrays
325 * rev->pending.objects and rev->cmdline.rev are parallel.
326 */
327 for (i = 0; i < rev->cmdline.nr; i++) {
328 struct object *obj = rev->pending.objects[i].item;
329 switch (rev->cmdline.rev[i].whence) {
330 case REV_CMD_MERGE_BASE:
331 if (basepos < 0)
332 basepos = i;
333 basecount++;
334 break; /* do mark all bases */
335 case REV_CMD_LEFT:
336 if (lpos >= 0)
337 usage(builtin_diff_usage);
338 lpos = i;
339 if (obj->flags & SYMMETRIC_LEFT) {
340 is_symdiff = 1;
341 break; /* do mark A */
342 }
343 continue;
344 case REV_CMD_RIGHT:
345 if (rpos >= 0)
346 usage(builtin_diff_usage);
347 rpos = i;
348 continue; /* don't mark B */
349 case REV_CMD_PARENTS_ONLY:
350 case REV_CMD_REF:
351 case REV_CMD_REV:
352 othercount++;
353 continue;
354 }
355 if (map == NULL)
356 map = bitmap_new();
357 bitmap_set(map, i);
358 }
359
360 /*
361 * Forbid any additional revs for both A...B and A..B.
362 */
363 if (lpos >= 0 && othercount > 0)
364 usage(builtin_diff_usage);
365
366 if (!is_symdiff) {
367 bitmap_free(map);
368 sym->warn = 0;
369 sym->skip = NULL;
370 return;
371 }
372
373 sym->left = rev->pending.objects[lpos].name;
374 sym->right = rev->pending.objects[rpos].name;
375 if (basecount == 0)
376 die(_("%s...%s: no merge base"), sym->left, sym->right);
377 sym->base = rev->pending.objects[basepos].name;
378 bitmap_unset(map, basepos); /* unmark the base we want */
379 sym->warn = basecount > 1;
380 sym->skip = map;
381 }
382
cmd_diff(int argc,const char ** argv,const char * prefix)383 int cmd_diff(int argc, const char **argv, const char *prefix)
384 {
385 int i;
386 struct rev_info rev;
387 struct object_array ent = OBJECT_ARRAY_INIT;
388 int blobs = 0, paths = 0;
389 struct object_array_entry *blob[2];
390 int nongit = 0, no_index = 0;
391 int result = 0;
392 struct symdiff sdiff;
393
394 /*
395 * We could get N tree-ish in the rev.pending_objects list.
396 * Also there could be M blobs there, and P pathspecs. --cached may
397 * also be present.
398 *
399 * N=0, M=0:
400 * cache vs files (diff-files)
401 *
402 * N=0, M=0, --cached:
403 * HEAD vs cache (diff-index --cached)
404 *
405 * N=0, M=2:
406 * compare two random blobs. P must be zero.
407 *
408 * N=0, M=1, P=1:
409 * compare a blob with a working tree file.
410 *
411 * N=1, M=0:
412 * tree vs files (diff-index)
413 *
414 * N=1, M=0, --cached:
415 * tree vs cache (diff-index --cached)
416 *
417 * N=2, M=0:
418 * tree vs tree (diff-tree)
419 *
420 * N=0, M=0, P=2:
421 * compare two filesystem entities (aka --no-index).
422 *
423 * Other cases are errors.
424 */
425
426 /* Were we asked to do --no-index explicitly? */
427 for (i = 1; i < argc; i++) {
428 if (!strcmp(argv[i], "--")) {
429 i++;
430 break;
431 }
432 if (!strcmp(argv[i], "--no-index"))
433 no_index = DIFF_NO_INDEX_EXPLICIT;
434 if (argv[i][0] != '-')
435 break;
436 }
437
438 prefix = setup_git_directory_gently(&nongit);
439
440 if (!no_index) {
441 /*
442 * Treat git diff with at least one path outside of the
443 * repo the same as if the command would have been executed
444 * outside of a git repository. In this case it behaves
445 * the same way as "git diff --no-index <a> <b>", which acts
446 * as a colourful "diff" replacement.
447 */
448 if (nongit || ((argc == i + 2) &&
449 (!path_inside_repo(prefix, argv[i]) ||
450 !path_inside_repo(prefix, argv[i + 1]))))
451 no_index = DIFF_NO_INDEX_IMPLICIT;
452 }
453
454 init_diff_ui_defaults();
455 git_config(git_diff_ui_config, NULL);
456 prefix = precompose_argv_prefix(argc, argv, prefix);
457
458 repo_init_revisions(the_repository, &rev, prefix);
459
460 /* Set up defaults that will apply to both no-index and regular diffs. */
461 rev.diffopt.stat_width = -1;
462 rev.diffopt.stat_graph_width = -1;
463 rev.diffopt.flags.allow_external = 1;
464 rev.diffopt.flags.allow_textconv = 1;
465
466 /* If this is a no-index diff, just run it and exit there. */
467 if (no_index)
468 exit(diff_no_index(&rev, no_index == DIFF_NO_INDEX_IMPLICIT,
469 argc, argv));
470
471
472 /*
473 * Otherwise, we are doing the usual "git" diff; set up any
474 * further defaults that apply to regular diffs.
475 */
476 rev.diffopt.skip_stat_unmatch = !!diff_auto_refresh_index;
477
478 /*
479 * Default to intent-to-add entries invisible in the
480 * index. This makes them show up as new files in diff-files
481 * and not at all in diff-cached.
482 */
483 rev.diffopt.ita_invisible_in_index = 1;
484
485 if (nongit)
486 die(_("Not a git repository"));
487 argc = setup_revisions(argc, argv, &rev, NULL);
488 if (!rev.diffopt.output_format) {
489 rev.diffopt.output_format = DIFF_FORMAT_PATCH;
490 diff_setup_done(&rev.diffopt);
491 }
492
493 rev.diffopt.flags.recursive = 1;
494 rev.diffopt.rotate_to_strict = 1;
495
496 setup_diff_pager(&rev.diffopt);
497
498 /*
499 * Do we have --cached and not have a pending object, then
500 * default to HEAD by hand. Eek.
501 */
502 if (!rev.pending.nr) {
503 int i;
504 for (i = 1; i < argc; i++) {
505 const char *arg = argv[i];
506 if (!strcmp(arg, "--"))
507 break;
508 else if (!strcmp(arg, "--cached") ||
509 !strcmp(arg, "--staged")) {
510 add_head_to_pending(&rev);
511 if (!rev.pending.nr) {
512 struct tree *tree;
513 tree = lookup_tree(the_repository,
514 the_repository->hash_algo->empty_tree);
515 add_pending_object(&rev, &tree->object, "HEAD");
516 }
517 break;
518 }
519 }
520 }
521
522 symdiff_prepare(&rev, &sdiff);
523 for (i = 0; i < rev.pending.nr; i++) {
524 struct object_array_entry *entry = &rev.pending.objects[i];
525 struct object *obj = entry->item;
526 const char *name = entry->name;
527 int flags = (obj->flags & UNINTERESTING);
528 if (!obj->parsed)
529 obj = parse_object(the_repository, &obj->oid);
530 obj = deref_tag(the_repository, obj, NULL, 0);
531 if (!obj)
532 die(_("invalid object '%s' given."), name);
533 if (obj->type == OBJ_COMMIT)
534 obj = &get_commit_tree(((struct commit *)obj))->object;
535
536 if (obj->type == OBJ_TREE) {
537 if (sdiff.skip && bitmap_get(sdiff.skip, i))
538 continue;
539 obj->flags |= flags;
540 add_object_array(obj, name, &ent);
541 } else if (obj->type == OBJ_BLOB) {
542 if (2 <= blobs)
543 die(_("more than two blobs given: '%s'"), name);
544 blob[blobs] = entry;
545 blobs++;
546
547 } else {
548 die(_("unhandled object '%s' given."), name);
549 }
550 }
551 if (rev.prune_data.nr)
552 paths += rev.prune_data.nr;
553
554 /*
555 * Now, do the arguments look reasonable?
556 */
557 if (!ent.nr) {
558 switch (blobs) {
559 case 0:
560 result = builtin_diff_files(&rev, argc, argv);
561 break;
562 case 1:
563 if (paths != 1)
564 usage(builtin_diff_usage);
565 result = builtin_diff_b_f(&rev, argc, argv, blob);
566 break;
567 case 2:
568 if (paths)
569 usage(builtin_diff_usage);
570 result = builtin_diff_blobs(&rev, argc, argv, blob);
571 break;
572 default:
573 usage(builtin_diff_usage);
574 }
575 }
576 else if (blobs)
577 usage(builtin_diff_usage);
578 else if (ent.nr == 1)
579 result = builtin_diff_index(&rev, argc, argv);
580 else if (ent.nr == 2) {
581 if (sdiff.warn)
582 warning(_("%s...%s: multiple merge bases, using %s"),
583 sdiff.left, sdiff.right, sdiff.base);
584 result = builtin_diff_tree(&rev, argc, argv,
585 &ent.objects[0], &ent.objects[1]);
586 } else
587 result = builtin_diff_combined(&rev, argc, argv,
588 ent.objects, ent.nr);
589 result = diff_result_code(&rev.diffopt, result);
590 if (1 < rev.diffopt.skip_stat_unmatch)
591 refresh_index_quietly();
592 UNLEAK(rev);
593 UNLEAK(ent);
594 UNLEAK(blob);
595 return result;
596 }
597