Merge branch 'maint'
[git] / diff-lib.c
1 /*
2  * Copyright (C) 2005 Junio C Hamano
3  */
4 #include "cache.h"
5 #include "quote.h"
6 #include "commit.h"
7 #include "diff.h"
8 #include "diffcore.h"
9 #include "revision.h"
10 #include "cache-tree.h"
11 #include "unpack-trees.h"
12 #include "refs.h"
13 #include "submodule.h"
14
15 /*
16  * diff-files
17  */
18
19 /*
20  * Has the work tree entity been removed?
21  *
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.
27  */
28 static int check_removed(const struct cache_entry *ce, struct stat *st)
29 {
30         if (lstat(ce->name, st) < 0) {
31                 if (errno != ENOENT && errno != ENOTDIR)
32                         return -1;
33                 return 1;
34         }
35         if (has_symlink_leading_path(ce->name, ce_namelen(ce)))
36                 return 1;
37         if (S_ISDIR(st->st_mode)) {
38                 unsigned char sub[20];
39
40                 /*
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.
46                  *
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!
50                  */
51                 if (!S_ISGITLINK(ce->ce_mode) &&
52                     resolve_gitlink_ref(ce->name, "HEAD", sub))
53                         return 1;
54         }
55         return 0;
56 }
57
58 /*
59  * Has a file changed or has a submodule new commits or a dirty work tree?
60  *
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).
65  */
66 static int match_stat_with_submodule(struct diff_options *diffopt,
67                                       struct cache_entry *ce, struct stat *st,
68                                       unsigned ce_option, unsigned *dirty_submodule)
69 {
70         int changed = ce_match_stat(ce, st, ce_option);
71         if (S_ISGITLINK(ce->ce_mode)) {
72                 unsigned orig_flags = diffopt->flags;
73                 if (!DIFF_OPT_TST(diffopt, OVERRIDE_SUBMODULE_CONFIG))
74                         set_diffopt_flags_from_submodule_config(diffopt, ce->name);
75                 if (DIFF_OPT_TST(diffopt, IGNORE_SUBMODULES))
76                         changed = 0;
77                 else if (!DIFF_OPT_TST(diffopt, IGNORE_DIRTY_SUBMODULES)
78                     && (!changed || DIFF_OPT_TST(diffopt, DIRTY_SUBMODULES)))
79                         *dirty_submodule = is_submodule_modified(ce->name, DIFF_OPT_TST(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES));
80                 diffopt->flags = orig_flags;
81         }
82         return changed;
83 }
84
85 int run_diff_files(struct rev_info *revs, unsigned int option)
86 {
87         int entries, i;
88         int diff_unmerged_stage = revs->max_count;
89         int silent_on_removed = option & DIFF_SILENT_ON_REMOVED;
90         unsigned ce_option = ((option & DIFF_RACY_IS_MODIFIED)
91                               ? CE_MATCH_RACY_IS_DIRTY : 0);
92
93         diff_set_mnemonic_prefix(&revs->diffopt, "i/", "w/");
94
95         if (diff_unmerged_stage < 0)
96                 diff_unmerged_stage = 2;
97         entries = active_nr;
98         for (i = 0; i < entries; i++) {
99                 struct stat st;
100                 unsigned int oldmode, newmode;
101                 struct cache_entry *ce = active_cache[i];
102                 int changed;
103                 unsigned dirty_submodule = 0;
104
105                 if (DIFF_OPT_TST(&revs->diffopt, QUICK) &&
106                     !revs->diffopt.filter &&
107                     DIFF_OPT_TST(&revs->diffopt, HAS_CHANGES))
108                         break;
109
110                 if (!ce_path_match(ce, &revs->prune_data))
111                         continue;
112
113                 if (ce_stage(ce)) {
114                         struct combine_diff_path *dpath;
115                         int num_compare_stages = 0;
116                         size_t path_len;
117
118                         path_len = ce_namelen(ce);
119
120                         dpath = xmalloc(combine_diff_path_size(5, path_len));
121                         dpath->path = (char *) &(dpath->parent[5]);
122
123                         dpath->next = NULL;
124                         dpath->len = path_len;
125                         memcpy(dpath->path, ce->name, path_len);
126                         dpath->path[path_len] = '\0';
127                         hashclr(dpath->sha1);
128                         memset(&(dpath->parent[0]), 0,
129                                sizeof(struct combine_diff_parent)*5);
130
131                         changed = check_removed(ce, &st);
132                         if (!changed)
133                                 dpath->mode = ce_mode_from_stat(ce, st.st_mode);
134                         else {
135                                 if (changed < 0) {
136                                         perror(ce->name);
137                                         continue;
138                                 }
139                                 if (silent_on_removed)
140                                         continue;
141                         }
142
143                         while (i < entries) {
144                                 struct cache_entry *nce = active_cache[i];
145                                 int stage;
146
147                                 if (strcmp(ce->name, nce->name))
148                                         break;
149
150                                 /* Stage #2 (ours) is the first parent,
151                                  * stage #3 (theirs) is the second.
152                                  */
153                                 stage = ce_stage(nce);
154                                 if (2 <= stage) {
155                                         int mode = nce->ce_mode;
156                                         num_compare_stages++;
157                                         hashcpy(dpath->parent[stage-2].sha1, nce->sha1);
158                                         dpath->parent[stage-2].mode = ce_mode_from_stat(nce, mode);
159                                         dpath->parent[stage-2].status =
160                                                 DIFF_STATUS_MODIFIED;
161                                 }
162
163                                 /* diff against the proper unmerged stage */
164                                 if (stage == diff_unmerged_stage)
165                                         ce = nce;
166                                 i++;
167                         }
168                         /*
169                          * Compensate for loop update
170                          */
171                         i--;
172
173                         if (revs->combine_merges && num_compare_stages == 2) {
174                                 show_combined_diff(dpath, 2,
175                                                    revs->dense_combined_merges,
176                                                    revs);
177                                 free(dpath);
178                                 continue;
179                         }
180                         free(dpath);
181                         dpath = NULL;
182
183                         /*
184                          * Show the diff for the 'ce' if we found the one
185                          * from the desired stage.
186                          */
187                         diff_unmerge(&revs->diffopt, ce->name, 0, null_sha1);
188                         if (ce_stage(ce) != diff_unmerged_stage)
189                                 continue;
190                 }
191
192                 if (ce_uptodate(ce) || ce_skip_worktree(ce))
193                         continue;
194
195                 /* If CE_VALID is set, don't look at workdir for file removal */
196                 changed = (ce->ce_flags & CE_VALID) ? 0 : check_removed(ce, &st);
197                 if (changed) {
198                         if (changed < 0) {
199                                 perror(ce->name);
200                                 continue;
201                         }
202                         if (silent_on_removed)
203                                 continue;
204                         diff_addremove(&revs->diffopt, '-', ce->ce_mode,
205                                        ce->sha1, ce->name, 0);
206                         continue;
207                 }
208                 changed = match_stat_with_submodule(&revs->diffopt, ce, &st,
209                                                     ce_option, &dirty_submodule);
210                 if (!changed && !dirty_submodule) {
211                         ce_mark_uptodate(ce);
212                         if (!DIFF_OPT_TST(&revs->diffopt, FIND_COPIES_HARDER))
213                                 continue;
214                 }
215                 oldmode = ce->ce_mode;
216                 newmode = ce_mode_from_stat(ce, st.st_mode);
217                 diff_change(&revs->diffopt, oldmode, newmode,
218                             ce->sha1, (changed ? null_sha1 : ce->sha1),
219                             ce->name, 0, dirty_submodule);
220
221         }
222         diffcore_std(&revs->diffopt);
223         diff_flush(&revs->diffopt);
224         return 0;
225 }
226
227 /*
228  * diff-index
229  */
230
231 /* A file entry went away or appeared */
232 static void diff_index_show_file(struct rev_info *revs,
233                                  const char *prefix,
234                                  struct cache_entry *ce,
235                                  const unsigned char *sha1, unsigned int mode,
236                                  unsigned dirty_submodule)
237 {
238         diff_addremove(&revs->diffopt, prefix[0], mode,
239                        sha1, ce->name, dirty_submodule);
240 }
241
242 static int get_stat_data(struct cache_entry *ce,
243                          const unsigned char **sha1p,
244                          unsigned int *modep,
245                          int cached, int match_missing,
246                          unsigned *dirty_submodule, struct diff_options *diffopt)
247 {
248         const unsigned char *sha1 = ce->sha1;
249         unsigned int mode = ce->ce_mode;
250
251         if (!cached && !ce_uptodate(ce)) {
252                 int changed;
253                 struct stat st;
254                 changed = check_removed(ce, &st);
255                 if (changed < 0)
256                         return -1;
257                 else if (changed) {
258                         if (match_missing) {
259                                 *sha1p = sha1;
260                                 *modep = mode;
261                                 return 0;
262                         }
263                         return -1;
264                 }
265                 changed = match_stat_with_submodule(diffopt, ce, &st,
266                                                     0, dirty_submodule);
267                 if (changed) {
268                         mode = ce_mode_from_stat(ce, st.st_mode);
269                         sha1 = null_sha1;
270                 }
271         }
272
273         *sha1p = sha1;
274         *modep = mode;
275         return 0;
276 }
277
278 static void show_new_file(struct rev_info *revs,
279                           struct cache_entry *new,
280                           int cached, int match_missing)
281 {
282         const unsigned char *sha1;
283         unsigned int mode;
284         unsigned dirty_submodule = 0;
285
286         /*
287          * New file in the index: it might actually be different in
288          * the working copy.
289          */
290         if (get_stat_data(new, &sha1, &mode, cached, match_missing,
291             &dirty_submodule, &revs->diffopt) < 0)
292                 return;
293
294         diff_index_show_file(revs, "+", new, sha1, mode, dirty_submodule);
295 }
296
297 static int show_modified(struct rev_info *revs,
298                          struct cache_entry *old,
299                          struct cache_entry *new,
300                          int report_missing,
301                          int cached, int match_missing)
302 {
303         unsigned int mode, oldmode;
304         const unsigned char *sha1;
305         unsigned dirty_submodule = 0;
306
307         if (get_stat_data(new, &sha1, &mode, cached, match_missing,
308                           &dirty_submodule, &revs->diffopt) < 0) {
309                 if (report_missing)
310                         diff_index_show_file(revs, "-", old,
311                                              old->sha1, old->ce_mode, 0);
312                 return -1;
313         }
314
315         if (revs->combine_merges && !cached &&
316             (hashcmp(sha1, old->sha1) || hashcmp(old->sha1, new->sha1))) {
317                 struct combine_diff_path *p;
318                 int pathlen = ce_namelen(new);
319
320                 p = xmalloc(combine_diff_path_size(2, pathlen));
321                 p->path = (char *) &p->parent[2];
322                 p->next = NULL;
323                 p->len = pathlen;
324                 memcpy(p->path, new->name, pathlen);
325                 p->path[pathlen] = 0;
326                 p->mode = mode;
327                 hashclr(p->sha1);
328                 memset(p->parent, 0, 2 * sizeof(struct combine_diff_parent));
329                 p->parent[0].status = DIFF_STATUS_MODIFIED;
330                 p->parent[0].mode = new->ce_mode;
331                 hashcpy(p->parent[0].sha1, new->sha1);
332                 p->parent[1].status = DIFF_STATUS_MODIFIED;
333                 p->parent[1].mode = old->ce_mode;
334                 hashcpy(p->parent[1].sha1, old->sha1);
335                 show_combined_diff(p, 2, revs->dense_combined_merges, revs);
336                 free(p);
337                 return 0;
338         }
339
340         oldmode = old->ce_mode;
341         if (mode == oldmode && !hashcmp(sha1, old->sha1) && !dirty_submodule &&
342             !DIFF_OPT_TST(&revs->diffopt, FIND_COPIES_HARDER))
343                 return 0;
344
345         diff_change(&revs->diffopt, oldmode, mode,
346                     old->sha1, sha1, old->name, 0, dirty_submodule);
347         return 0;
348 }
349
350 /*
351  * This gets a mix of an existing index and a tree, one pathname entry
352  * at a time. The index entry may be a single stage-0 one, but it could
353  * also be multiple unmerged entries (in which case idx_pos/idx_nr will
354  * give you the position and number of entries in the index).
355  */
356 static void do_oneway_diff(struct unpack_trees_options *o,
357         struct cache_entry *idx,
358         struct cache_entry *tree)
359 {
360         struct rev_info *revs = o->unpack_data;
361         int match_missing, cached;
362
363         /* if the entry is not checked out, don't examine work tree */
364         cached = o->index_only ||
365                 (idx && ((idx->ce_flags & CE_VALID) || ce_skip_worktree(idx)));
366         /*
367          * Backward compatibility wart - "diff-index -m" does
368          * not mean "do not ignore merges", but "match_missing".
369          *
370          * But with the revision flag parsing, that's found in
371          * "!revs->ignore_merges".
372          */
373         match_missing = !revs->ignore_merges;
374
375         if (cached && idx && ce_stage(idx)) {
376                 diff_unmerge(&revs->diffopt, idx->name, idx->ce_mode,
377                              idx->sha1);
378                 return;
379         }
380
381         /*
382          * Something added to the tree?
383          */
384         if (!tree) {
385                 show_new_file(revs, idx, cached, match_missing);
386                 return;
387         }
388
389         /*
390          * Something removed from the tree?
391          */
392         if (!idx) {
393                 diff_index_show_file(revs, "-", tree, tree->sha1, tree->ce_mode, 0);
394                 return;
395         }
396
397         /* Show difference between old and new */
398         show_modified(revs, tree, idx, 1, cached, match_missing);
399 }
400
401 /*
402  * The unpack_trees() interface is designed for merging, so
403  * the different source entries are designed primarily for
404  * the source trees, with the old index being really mainly
405  * used for being replaced by the result.
406  *
407  * For diffing, the index is more important, and we only have a
408  * single tree.
409  *
410  * We're supposed to advance o->pos to skip what we have already processed.
411  *
412  * This wrapper makes it all more readable, and takes care of all
413  * the fairly complex unpack_trees() semantic requirements, including
414  * the skipping, the path matching, the type conflict cases etc.
415  */
416 static int oneway_diff(struct cache_entry **src, struct unpack_trees_options *o)
417 {
418         struct cache_entry *idx = src[0];
419         struct cache_entry *tree = src[1];
420         struct rev_info *revs = o->unpack_data;
421
422         /*
423          * Unpack-trees generates a DF/conflict entry if
424          * there was a directory in the index and a tree
425          * in the tree. From a diff standpoint, that's a
426          * delete of the tree and a create of the file.
427          */
428         if (tree == o->df_conflict_entry)
429                 tree = NULL;
430
431         if (ce_path_match(idx ? idx : tree, &revs->prune_data))
432                 do_oneway_diff(o, idx, tree);
433
434         return 0;
435 }
436
437 int run_diff_index(struct rev_info *revs, int cached)
438 {
439         struct object *ent;
440         struct tree *tree;
441         const char *tree_name;
442         struct unpack_trees_options opts;
443         struct tree_desc t;
444
445         ent = revs->pending.objects[0].item;
446         tree_name = revs->pending.objects[0].name;
447         tree = parse_tree_indirect(ent->sha1);
448         if (!tree)
449                 return error("bad tree object %s", tree_name);
450
451         memset(&opts, 0, sizeof(opts));
452         opts.head_idx = 1;
453         opts.index_only = cached;
454         opts.diff_index_cached = (cached &&
455                                   !DIFF_OPT_TST(&revs->diffopt, FIND_COPIES_HARDER));
456         opts.merge = 1;
457         opts.fn = oneway_diff;
458         opts.unpack_data = revs;
459         opts.src_index = &the_index;
460         opts.dst_index = NULL;
461
462         init_tree_desc(&t, tree->buffer, tree->size);
463         if (unpack_trees(1, &t, &opts))
464                 exit(128);
465
466         diff_set_mnemonic_prefix(&revs->diffopt, "c/", cached ? "i/" : "w/");
467         diffcore_fix_diff_index(&revs->diffopt);
468         diffcore_std(&revs->diffopt);
469         diff_flush(&revs->diffopt);
470         return 0;
471 }
472
473 int do_diff_cache(const unsigned char *tree_sha1, struct diff_options *opt)
474 {
475         struct tree *tree;
476         struct rev_info revs;
477         int i;
478         struct cache_entry **dst;
479         struct cache_entry *last = NULL;
480         struct unpack_trees_options opts;
481         struct tree_desc t;
482
483         /*
484          * This is used by git-blame to run diff-cache internally;
485          * it potentially needs to repeatedly run this, so we will
486          * start by removing the higher order entries the last round
487          * left behind.
488          */
489         dst = active_cache;
490         for (i = 0; i < active_nr; i++) {
491                 struct cache_entry *ce = active_cache[i];
492                 if (ce_stage(ce)) {
493                         if (last && !strcmp(ce->name, last->name))
494                                 continue;
495                         cache_tree_invalidate_path(active_cache_tree,
496                                                    ce->name);
497                         last = ce;
498                         ce->ce_flags |= CE_REMOVE;
499                 }
500                 *dst++ = ce;
501         }
502         active_nr = dst - active_cache;
503
504         init_revisions(&revs, NULL);
505         init_pathspec(&revs.prune_data, opt->pathspec.raw);
506         tree = parse_tree_indirect(tree_sha1);
507         if (!tree)
508                 die("bad tree object %s", sha1_to_hex(tree_sha1));
509
510         memset(&opts, 0, sizeof(opts));
511         opts.head_idx = 1;
512         opts.index_only = 1;
513         opts.diff_index_cached = !DIFF_OPT_TST(opt, FIND_COPIES_HARDER);
514         opts.merge = 1;
515         opts.fn = oneway_diff;
516         opts.unpack_data = &revs;
517         opts.src_index = &the_index;
518         opts.dst_index = &the_index;
519
520         init_tree_desc(&t, tree->buffer, tree->size);
521         if (unpack_trees(1, &t, &opts))
522                 exit(128);
523         return 0;
524 }
525
526 int index_differs_from(const char *def, int diff_flags)
527 {
528         struct rev_info rev;
529         struct setup_revision_opt opt;
530
531         init_revisions(&rev, NULL);
532         memset(&opt, 0, sizeof(opt));
533         opt.def = def;
534         setup_revisions(0, NULL, &rev, &opt);
535         DIFF_OPT_SET(&rev.diffopt, QUICK);
536         DIFF_OPT_SET(&rev.diffopt, EXIT_WITH_STATUS);
537         rev.diffopt.flags |= diff_flags;
538         run_diff_index(&rev, 1);
539         if (rev.pending.alloc)
540                 free(rev.pending.objects);
541         return (DIFF_OPT_TST(&rev.diffopt, HAS_CHANGES) != 0);
542 }