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