Junio C Hamano | be3cfa8 | 2005-04-26 09:25:05 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2005 Junio C Hamano |
| 3 | */ |
Junio C Hamano | 86436c2 | 2005-04-25 18:22:47 -0700 | [diff] [blame] | 4 | #include "cache.h" |
Junio C Hamano | 6fb737b | 2005-07-07 23:58:32 -0700 | [diff] [blame] | 5 | #include "quote.h" |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 6 | #include "commit.h" |
Junio C Hamano | 86436c2 | 2005-04-25 18:22:47 -0700 | [diff] [blame] | 7 | #include "diff.h" |
Junio C Hamano | 427dcb4 | 2005-05-21 02:39:09 -0700 | [diff] [blame] | 8 | #include "diffcore.h" |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 9 | #include "revision.h" |
Junio C Hamano | 1cfe773 | 2007-01-30 01:11:08 -0800 | [diff] [blame] | 10 | #include "cache-tree.h" |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 11 | #include "unpack-trees.h" |
Junio C Hamano | 948dd34 | 2008-03-30 17:29:48 -0700 | [diff] [blame] | 12 | #include "refs.h" |
Jens Lehmann | ee6fc51 | 2010-01-16 18:42:24 +0100 | [diff] [blame] | 13 | #include "submodule.h" |
Junio C Hamano | 427dcb4 | 2005-05-21 02:39:09 -0700 | [diff] [blame] | 14 | |
Junio C Hamano | b46f0b6 | 2005-05-04 01:45:24 -0700 | [diff] [blame] | 15 | /* |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 16 | * diff-files |
Junio C Hamano | b46f0b6 | 2005-05-04 01:45:24 -0700 | [diff] [blame] | 17 | */ |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 18 | |
Junio C Hamano | 948dd34 | 2008-03-30 17:29:48 -0700 | [diff] [blame] | 19 | /* |
Junio C Hamano | 1392a37 | 2008-05-03 17:04:42 -0700 | [diff] [blame] | 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. |
Junio C Hamano | 948dd34 | 2008-03-30 17:29:48 -0700 | [diff] [blame] | 27 | */ |
Linus Torvalds | c40641b | 2008-05-09 09:21:07 -0700 | [diff] [blame] | 28 | static int check_removed(const struct cache_entry *ce, struct stat *st) |
Junio C Hamano | 948dd34 | 2008-03-30 17:29:48 -0700 | [diff] [blame] | 29 | { |
| 30 | if (lstat(ce->name, st) < 0) { |
| 31 | if (errno != ENOENT && errno != ENOTDIR) |
| 32 | return -1; |
| 33 | return 1; |
| 34 | } |
Kjetil Barvik | 5719989 | 2009-02-09 21:54:06 +0100 | [diff] [blame] | 35 | if (has_symlink_leading_path(ce->name, ce_namelen(ce))) |
Junio C Hamano | 948dd34 | 2008-03-30 17:29:48 -0700 | [diff] [blame] | 36 | return 1; |
| 37 | if (S_ISDIR(st->st_mode)) { |
| 38 | unsigned char sub[20]; |
Junio C Hamano | 1392a37 | 2008-05-03 17:04:42 -0700 | [diff] [blame] | 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)) |
Junio C Hamano | 948dd34 | 2008-03-30 17:29:48 -0700 | [diff] [blame] | 53 | return 1; |
| 54 | } |
| 55 | return 0; |
| 56 | } |
Johannes Schindelin | d516c2d | 2007-02-22 21:50:10 +0100 | [diff] [blame] | 57 | |
Jens Lehmann | ae6d5c1 | 2010-03-11 22:50:25 +0100 | [diff] [blame] | 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); |
Jens Lehmann | aee9c7d | 2010-08-06 00:39:25 +0200 | [diff] [blame] | 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; |
Jens Lehmann | ae6d5c1 | 2010-03-11 22:50:25 +0100 | [diff] [blame] | 81 | } |
| 82 | return changed; |
| 83 | } |
| 84 | |
Junio C Hamano | 4bd5b7d | 2007-11-10 00:15:03 -0800 | [diff] [blame] | 85 | int run_diff_files(struct rev_info *revs, unsigned int option) |
Junio C Hamano | b46f0b6 | 2005-05-04 01:45:24 -0700 | [diff] [blame] | 86 | { |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 87 | int entries, i; |
| 88 | int diff_unmerged_stage = revs->max_count; |
Junio C Hamano | 4bd5b7d | 2007-11-10 00:15:03 -0800 | [diff] [blame] | 89 | int silent_on_removed = option & DIFF_SILENT_ON_REMOVED; |
Junio C Hamano | fb63d7f | 2007-11-09 18:22:52 -0800 | [diff] [blame] | 90 | unsigned ce_option = ((option & DIFF_RACY_IS_MODIFIED) |
| 91 | ? CE_MATCH_RACY_IS_DIRTY : 0); |
Junio C Hamano | 5c97558 | 2005-05-19 03:32:35 -0700 | [diff] [blame] | 92 | |
Junio C Hamano | a5a818e | 2008-08-18 20:08:09 -0700 | [diff] [blame] | 93 | diff_set_mnemonic_prefix(&revs->diffopt, "i/", "w/"); |
| 94 | |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 95 | if (diff_unmerged_stage < 0) |
| 96 | diff_unmerged_stage = 2; |
Junio C Hamano | b4e1e4a | 2007-02-09 18:51:40 -0800 | [diff] [blame] | 97 | entries = active_nr; |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 98 | for (i = 0; i < entries; i++) { |
Junio C Hamano | 427dcb4 | 2005-05-21 02:39:09 -0700 | [diff] [blame] | 99 | struct stat st; |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 100 | unsigned int oldmode, newmode; |
| 101 | struct cache_entry *ce = active_cache[i]; |
| 102 | int changed; |
Jens Lehmann | e3d42c4 | 2010-01-18 21:26:18 +0100 | [diff] [blame] | 103 | unsigned dirty_submodule = 0; |
Junio C Hamano | f0c6b2a | 2005-05-27 15:56:38 -0700 | [diff] [blame] | 104 | |
Junio C Hamano | 28b9264 | 2011-05-31 09:14:17 -0700 | [diff] [blame] | 105 | if (diff_can_quit_early(&revs->diffopt)) |
Junio C Hamano | 822cac0 | 2007-03-14 11:12:51 -0700 | [diff] [blame] | 106 | break; |
| 107 | |
Nguyễn Thái Ngọc Duy | eb9cb55 | 2010-12-17 19:43:07 +0700 | [diff] [blame] | 108 | if (!ce_path_match(ce, &revs->prune_data)) |
Linus Torvalds | 8676eb4 | 2006-02-26 15:51:24 -0800 | [diff] [blame] | 109 | continue; |
Linus Torvalds | 8676eb4 | 2006-02-26 15:51:24 -0800 | [diff] [blame] | 110 | |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 111 | if (ce_stage(ce)) { |
Florian Forster | b4b1550 | 2006-06-18 17:18:05 +0200 | [diff] [blame] | 112 | struct combine_diff_path *dpath; |
Junio C Hamano | 095ce95 | 2011-04-22 16:19:27 -0700 | [diff] [blame] | 113 | struct diff_filepair *pair; |
| 114 | unsigned int wt_mode = 0; |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 115 | int num_compare_stages = 0; |
Florian Forster | b4b1550 | 2006-06-18 17:18:05 +0200 | [diff] [blame] | 116 | size_t path_len; |
Linus Torvalds | 8676eb4 | 2006-02-26 15:51:24 -0800 | [diff] [blame] | 117 | |
Florian Forster | b4b1550 | 2006-06-18 17:18:05 +0200 | [diff] [blame] | 118 | path_len = ce_namelen(ce); |
| 119 | |
Junio C Hamano | 4fc970c | 2007-02-25 22:24:47 -0800 | [diff] [blame] | 120 | dpath = xmalloc(combine_diff_path_size(5, path_len)); |
Florian Forster | b4b1550 | 2006-06-18 17:18:05 +0200 | [diff] [blame] | 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'; |
Junio C Hamano | a8e0d16 | 2006-08-23 13:57:23 -0700 | [diff] [blame] | 127 | hashclr(dpath->sha1); |
Florian Forster | b4b1550 | 2006-06-18 17:18:05 +0200 | [diff] [blame] | 128 | memset(&(dpath->parent[0]), 0, |
Junio C Hamano | 4fc970c | 2007-02-25 22:24:47 -0800 | [diff] [blame] | 129 | sizeof(struct combine_diff_parent)*5); |
| 130 | |
Linus Torvalds | c40641b | 2008-05-09 09:21:07 -0700 | [diff] [blame] | 131 | changed = check_removed(ce, &st); |
Junio C Hamano | f58dbf2 | 2008-03-30 17:30:08 -0700 | [diff] [blame] | 132 | if (!changed) |
Junio C Hamano | 095ce95 | 2011-04-22 16:19:27 -0700 | [diff] [blame] | 133 | wt_mode = ce_mode_from_stat(ce, st.st_mode); |
Junio C Hamano | f58dbf2 | 2008-03-30 17:30:08 -0700 | [diff] [blame] | 134 | else { |
| 135 | if (changed < 0) { |
Junio C Hamano | 4fc970c | 2007-02-25 22:24:47 -0800 | [diff] [blame] | 136 | perror(ce->name); |
| 137 | continue; |
| 138 | } |
| 139 | if (silent_on_removed) |
| 140 | continue; |
Junio C Hamano | 095ce95 | 2011-04-22 16:19:27 -0700 | [diff] [blame] | 141 | wt_mode = 0; |
Junio C Hamano | 4fc970c | 2007-02-25 22:24:47 -0800 | [diff] [blame] | 142 | } |
Junio C Hamano | 095ce95 | 2011-04-22 16:19:27 -0700 | [diff] [blame] | 143 | dpath->mode = wt_mode; |
Junio C Hamano | be3cfa8 | 2005-04-26 09:25:05 -0700 | [diff] [blame] | 144 | |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 145 | while (i < entries) { |
| 146 | struct cache_entry *nce = active_cache[i]; |
| 147 | int stage; |
Junio C Hamano | be3cfa8 | 2005-04-26 09:25:05 -0700 | [diff] [blame] | 148 | |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 149 | if (strcmp(ce->name, nce->name)) |
| 150 | break; |
Junio C Hamano | be3cfa8 | 2005-04-26 09:25:05 -0700 | [diff] [blame] | 151 | |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 152 | /* Stage #2 (ours) is the first parent, |
| 153 | * stage #3 (theirs) is the second. |
| 154 | */ |
| 155 | stage = ce_stage(nce); |
| 156 | if (2 <= stage) { |
Linus Torvalds | 7a51ed6 | 2008-01-14 16:03:17 -0800 | [diff] [blame] | 157 | int mode = nce->ce_mode; |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 158 | num_compare_stages++; |
Shawn Pearce | e702496 | 2006-08-23 02:49:00 -0400 | [diff] [blame] | 159 | hashcpy(dpath->parent[stage-2].sha1, nce->sha1); |
Linus Torvalds | 7a51ed6 | 2008-01-14 16:03:17 -0800 | [diff] [blame] | 160 | dpath->parent[stage-2].mode = ce_mode_from_stat(nce, mode); |
Florian Forster | b4b1550 | 2006-06-18 17:18:05 +0200 | [diff] [blame] | 161 | dpath->parent[stage-2].status = |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 162 | DIFF_STATUS_MODIFIED; |
| 163 | } |
Junio C Hamano | cebff98 | 2006-03-25 23:12:17 -0800 | [diff] [blame] | 164 | |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 165 | /* diff against the proper unmerged stage */ |
| 166 | if (stage == diff_unmerged_stage) |
| 167 | ce = nce; |
| 168 | i++; |
H. Peter Anvin | 1b1480f | 2005-11-21 14:17:12 -0800 | [diff] [blame] | 169 | } |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 170 | /* |
| 171 | * Compensate for loop update |
| 172 | */ |
| 173 | i--; |
Junio C Hamano | 0e3994f | 2005-06-03 01:37:54 -0700 | [diff] [blame] | 174 | |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 175 | if (revs->combine_merges && num_compare_stages == 2) { |
Florian Forster | b4b1550 | 2006-06-18 17:18:05 +0200 | [diff] [blame] | 176 | show_combined_diff(dpath, 2, |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 177 | revs->dense_combined_merges, |
| 178 | revs); |
Florian Forster | b4b1550 | 2006-06-18 17:18:05 +0200 | [diff] [blame] | 179 | free(dpath); |
Junio C Hamano | 15d061b | 2005-05-27 15:55:55 -0700 | [diff] [blame] | 180 | continue; |
| 181 | } |
Florian Forster | b4b1550 | 2006-06-18 17:18:05 +0200 | [diff] [blame] | 182 | free(dpath); |
| 183 | dpath = NULL; |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 184 | |
| 185 | /* |
| 186 | * Show the diff for the 'ce' if we found the one |
| 187 | * from the desired stage. |
Junio C Hamano | 25d5ea4 | 2005-05-24 01:10:48 -0700 | [diff] [blame] | 188 | */ |
Junio C Hamano | 095ce95 | 2011-04-22 16:19:27 -0700 | [diff] [blame] | 189 | pair = diff_unmerge(&revs->diffopt, ce->name); |
| 190 | if (wt_mode) |
| 191 | pair->two->mode = wt_mode; |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 192 | if (ce_stage(ce) != diff_unmerged_stage) |
| 193 | continue; |
| 194 | } |
| 195 | |
Junio C Hamano | 125fd98 | 2010-01-24 00:10:20 -0800 | [diff] [blame] | 196 | if (ce_uptodate(ce) || ce_skip_worktree(ce)) |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 197 | continue; |
Junio C Hamano | f58dbf2 | 2008-03-30 17:30:08 -0700 | [diff] [blame] | 198 | |
Nguyễn Thái Ngọc Duy | 540e694 | 2009-08-11 22:43:59 +0700 | [diff] [blame] | 199 | /* If CE_VALID is set, don't look at workdir for file removal */ |
| 200 | changed = (ce->ce_flags & CE_VALID) ? 0 : check_removed(ce, &st); |
Junio C Hamano | f58dbf2 | 2008-03-30 17:30:08 -0700 | [diff] [blame] | 201 | if (changed) { |
| 202 | if (changed < 0) { |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 203 | perror(ce->name); |
| 204 | continue; |
Junio C Hamano | 25d5ea4 | 2005-05-24 01:10:48 -0700 | [diff] [blame] | 205 | } |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 206 | if (silent_on_removed) |
| 207 | continue; |
Linus Torvalds | 7a51ed6 | 2008-01-14 16:03:17 -0800 | [diff] [blame] | 208 | diff_addremove(&revs->diffopt, '-', ce->ce_mode, |
Jens Lehmann | e3d42c4 | 2010-01-18 21:26:18 +0100 | [diff] [blame] | 209 | ce->sha1, ce->name, 0); |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 210 | continue; |
Junio C Hamano | bceafe7 | 2005-05-23 18:14:03 -0700 | [diff] [blame] | 211 | } |
Jens Lehmann | ae6d5c1 | 2010-03-11 22:50:25 +0100 | [diff] [blame] | 212 | changed = match_stat_with_submodule(&revs->diffopt, ce, &st, |
| 213 | ce_option, &dirty_submodule); |
Jens Lehmann | 85adbf2 | 2010-03-12 22:23:52 +0100 | [diff] [blame] | 214 | if (!changed && !dirty_submodule) { |
Junio C Hamano | 8fa2960 | 2008-03-30 12:39:25 -0700 | [diff] [blame] | 215 | ce_mark_uptodate(ce); |
| 216 | if (!DIFF_OPT_TST(&revs->diffopt, FIND_COPIES_HARDER)) |
| 217 | continue; |
| 218 | } |
Linus Torvalds | 7a51ed6 | 2008-01-14 16:03:17 -0800 | [diff] [blame] | 219 | oldmode = ce->ce_mode; |
| 220 | newmode = ce_mode_from_stat(ce, st.st_mode); |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 221 | diff_change(&revs->diffopt, oldmode, newmode, |
| 222 | ce->sha1, (changed ? null_sha1 : ce->sha1), |
Jens Lehmann | e3d42c4 | 2010-01-18 21:26:18 +0100 | [diff] [blame] | 223 | ce->name, 0, dirty_submodule); |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 224 | |
Junio C Hamano | bceafe7 | 2005-05-23 18:14:03 -0700 | [diff] [blame] | 225 | } |
Junio C Hamano | 6973dca | 2006-04-21 23:57:45 -0700 | [diff] [blame] | 226 | diffcore_std(&revs->diffopt); |
| 227 | diff_flush(&revs->diffopt); |
| 228 | return 0; |
Junio C Hamano | bceafe7 | 2005-05-23 18:14:03 -0700 | [diff] [blame] | 229 | } |
| 230 | |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 231 | /* |
| 232 | * diff-index |
| 233 | */ |
| 234 | |
| 235 | /* A file entry went away or appeared */ |
| 236 | static void diff_index_show_file(struct rev_info *revs, |
| 237 | const char *prefix, |
| 238 | struct cache_entry *ce, |
Jens Lehmann | e3d42c4 | 2010-01-18 21:26:18 +0100 | [diff] [blame] | 239 | const unsigned char *sha1, unsigned int mode, |
| 240 | unsigned dirty_submodule) |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 241 | { |
Linus Torvalds | 7a51ed6 | 2008-01-14 16:03:17 -0800 | [diff] [blame] | 242 | diff_addremove(&revs->diffopt, prefix[0], mode, |
Jens Lehmann | e3d42c4 | 2010-01-18 21:26:18 +0100 | [diff] [blame] | 243 | sha1, ce->name, dirty_submodule); |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 244 | } |
| 245 | |
| 246 | static int get_stat_data(struct cache_entry *ce, |
Junio C Hamano | c8c16f2 | 2008-03-02 00:57:26 -0800 | [diff] [blame] | 247 | const unsigned char **sha1p, |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 248 | unsigned int *modep, |
Jens Lehmann | e3d42c4 | 2010-01-18 21:26:18 +0100 | [diff] [blame] | 249 | int cached, int match_missing, |
Jens Lehmann | 4d34477 | 2010-01-23 17:37:26 +0100 | [diff] [blame] | 250 | unsigned *dirty_submodule, struct diff_options *diffopt) |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 251 | { |
Junio C Hamano | c8c16f2 | 2008-03-02 00:57:26 -0800 | [diff] [blame] | 252 | const unsigned char *sha1 = ce->sha1; |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 253 | unsigned int mode = ce->ce_mode; |
| 254 | |
Linus Torvalds | 658dd48 | 2009-05-09 14:57:30 -0700 | [diff] [blame] | 255 | if (!cached && !ce_uptodate(ce)) { |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 256 | int changed; |
| 257 | struct stat st; |
Linus Torvalds | c40641b | 2008-05-09 09:21:07 -0700 | [diff] [blame] | 258 | changed = check_removed(ce, &st); |
Junio C Hamano | 948dd34 | 2008-03-30 17:29:48 -0700 | [diff] [blame] | 259 | if (changed < 0) |
| 260 | return -1; |
| 261 | else if (changed) { |
| 262 | if (match_missing) { |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 263 | *sha1p = sha1; |
| 264 | *modep = mode; |
| 265 | return 0; |
| 266 | } |
| 267 | return -1; |
| 268 | } |
Jens Lehmann | ae6d5c1 | 2010-03-11 22:50:25 +0100 | [diff] [blame] | 269 | changed = match_stat_with_submodule(diffopt, ce, &st, |
| 270 | 0, dirty_submodule); |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 271 | if (changed) { |
Junio C Hamano | 185c975 | 2007-02-16 22:43:48 -0800 | [diff] [blame] | 272 | mode = ce_mode_from_stat(ce, st.st_mode); |
Junio C Hamano | c8c16f2 | 2008-03-02 00:57:26 -0800 | [diff] [blame] | 273 | sha1 = null_sha1; |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 274 | } |
| 275 | } |
| 276 | |
| 277 | *sha1p = sha1; |
| 278 | *modep = mode; |
| 279 | return 0; |
| 280 | } |
| 281 | |
Kjetil Barvik | ff7e6aa | 2009-01-11 19:36:42 +0100 | [diff] [blame] | 282 | static void show_new_file(struct rev_info *revs, |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 283 | struct cache_entry *new, |
| 284 | int cached, int match_missing) |
| 285 | { |
Junio C Hamano | c8c16f2 | 2008-03-02 00:57:26 -0800 | [diff] [blame] | 286 | const unsigned char *sha1; |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 287 | unsigned int mode; |
Jens Lehmann | e3d42c4 | 2010-01-18 21:26:18 +0100 | [diff] [blame] | 288 | unsigned dirty_submodule = 0; |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 289 | |
Junio C Hamano | 948dd34 | 2008-03-30 17:29:48 -0700 | [diff] [blame] | 290 | /* |
| 291 | * New file in the index: it might actually be different in |
Carlos Martín Nieto | f7d650c | 2011-09-20 22:25:57 +0200 | [diff] [blame] | 292 | * the working tree. |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 293 | */ |
Jens Lehmann | e3d42c4 | 2010-01-18 21:26:18 +0100 | [diff] [blame] | 294 | if (get_stat_data(new, &sha1, &mode, cached, match_missing, |
Jens Lehmann | 4d34477 | 2010-01-23 17:37:26 +0100 | [diff] [blame] | 295 | &dirty_submodule, &revs->diffopt) < 0) |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 296 | return; |
| 297 | |
Jens Lehmann | e3d42c4 | 2010-01-18 21:26:18 +0100 | [diff] [blame] | 298 | diff_index_show_file(revs, "+", new, sha1, mode, dirty_submodule); |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 299 | } |
| 300 | |
Kjetil Barvik | ff7e6aa | 2009-01-11 19:36:42 +0100 | [diff] [blame] | 301 | static int show_modified(struct rev_info *revs, |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 302 | struct cache_entry *old, |
| 303 | struct cache_entry *new, |
| 304 | int report_missing, |
| 305 | int cached, int match_missing) |
| 306 | { |
| 307 | unsigned int mode, oldmode; |
Junio C Hamano | c8c16f2 | 2008-03-02 00:57:26 -0800 | [diff] [blame] | 308 | const unsigned char *sha1; |
Jens Lehmann | e3d42c4 | 2010-01-18 21:26:18 +0100 | [diff] [blame] | 309 | unsigned dirty_submodule = 0; |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 310 | |
Jens Lehmann | e3d42c4 | 2010-01-18 21:26:18 +0100 | [diff] [blame] | 311 | if (get_stat_data(new, &sha1, &mode, cached, match_missing, |
Jens Lehmann | 4d34477 | 2010-01-23 17:37:26 +0100 | [diff] [blame] | 312 | &dirty_submodule, &revs->diffopt) < 0) { |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 313 | if (report_missing) |
| 314 | diff_index_show_file(revs, "-", old, |
Jens Lehmann | e3d42c4 | 2010-01-18 21:26:18 +0100 | [diff] [blame] | 315 | old->sha1, old->ce_mode, 0); |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 316 | return -1; |
| 317 | } |
| 318 | |
Paul Mackerras | cb2b9f5 | 2006-09-04 21:38:40 +1000 | [diff] [blame] | 319 | if (revs->combine_merges && !cached && |
| 320 | (hashcmp(sha1, old->sha1) || hashcmp(old->sha1, new->sha1))) { |
| 321 | struct combine_diff_path *p; |
| 322 | int pathlen = ce_namelen(new); |
| 323 | |
| 324 | p = xmalloc(combine_diff_path_size(2, pathlen)); |
| 325 | p->path = (char *) &p->parent[2]; |
| 326 | p->next = NULL; |
| 327 | p->len = pathlen; |
| 328 | memcpy(p->path, new->name, pathlen); |
| 329 | p->path[pathlen] = 0; |
Linus Torvalds | 7a51ed6 | 2008-01-14 16:03:17 -0800 | [diff] [blame] | 330 | p->mode = mode; |
Paul Mackerras | cb2b9f5 | 2006-09-04 21:38:40 +1000 | [diff] [blame] | 331 | hashclr(p->sha1); |
| 332 | memset(p->parent, 0, 2 * sizeof(struct combine_diff_parent)); |
| 333 | p->parent[0].status = DIFF_STATUS_MODIFIED; |
Linus Torvalds | 7a51ed6 | 2008-01-14 16:03:17 -0800 | [diff] [blame] | 334 | p->parent[0].mode = new->ce_mode; |
Paul Mackerras | cb2b9f5 | 2006-09-04 21:38:40 +1000 | [diff] [blame] | 335 | hashcpy(p->parent[0].sha1, new->sha1); |
| 336 | p->parent[1].status = DIFF_STATUS_MODIFIED; |
Linus Torvalds | 7a51ed6 | 2008-01-14 16:03:17 -0800 | [diff] [blame] | 337 | p->parent[1].mode = old->ce_mode; |
Paul Mackerras | cb2b9f5 | 2006-09-04 21:38:40 +1000 | [diff] [blame] | 338 | hashcpy(p->parent[1].sha1, old->sha1); |
| 339 | show_combined_diff(p, 2, revs->dense_combined_merges, revs); |
| 340 | free(p); |
| 341 | return 0; |
| 342 | } |
| 343 | |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 344 | oldmode = old->ce_mode; |
Jens Lehmann | 85adbf2 | 2010-03-12 22:23:52 +0100 | [diff] [blame] | 345 | if (mode == oldmode && !hashcmp(sha1, old->sha1) && !dirty_submodule && |
Pierre Habouzit | 8f67f8a | 2007-11-10 20:05:14 +0100 | [diff] [blame] | 346 | !DIFF_OPT_TST(&revs->diffopt, FIND_COPIES_HARDER)) |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 347 | return 0; |
| 348 | |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 349 | diff_change(&revs->diffopt, oldmode, mode, |
Jens Lehmann | e3d42c4 | 2010-01-18 21:26:18 +0100 | [diff] [blame] | 350 | old->sha1, sha1, old->name, 0, dirty_submodule); |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 351 | return 0; |
| 352 | } |
| 353 | |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 354 | /* |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 355 | * This gets a mix of an existing index and a tree, one pathname entry |
| 356 | * at a time. The index entry may be a single stage-0 one, but it could |
| 357 | * also be multiple unmerged entries (in which case idx_pos/idx_nr will |
| 358 | * give you the position and number of entries in the index). |
| 359 | */ |
| 360 | static void do_oneway_diff(struct unpack_trees_options *o, |
| 361 | struct cache_entry *idx, |
Linus Torvalds | 34110cd | 2008-03-06 18:12:28 -0800 | [diff] [blame] | 362 | struct cache_entry *tree) |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 363 | { |
Kjetil Barvik | ff7e6aa | 2009-01-11 19:36:42 +0100 | [diff] [blame] | 364 | struct rev_info *revs = o->unpack_data; |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 365 | int match_missing, cached; |
Junio C Hamano | 5c21ac0 | 2006-04-22 03:58:04 -0700 | [diff] [blame] | 366 | |
Nguyễn Thái Ngọc Duy | 540e694 | 2009-08-11 22:43:59 +0700 | [diff] [blame] | 367 | /* if the entry is not checked out, don't examine work tree */ |
Nguyễn Thái Ngọc Duy | b4d1690 | 2009-08-20 20:46:58 +0700 | [diff] [blame] | 368 | cached = o->index_only || |
| 369 | (idx && ((idx->ce_flags & CE_VALID) || ce_skip_worktree(idx))); |
Junio C Hamano | a6080a0 | 2007-06-07 00:04:01 -0700 | [diff] [blame] | 370 | /* |
Junio C Hamano | 5c21ac0 | 2006-04-22 03:58:04 -0700 | [diff] [blame] | 371 | * Backward compatibility wart - "diff-index -m" does |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 372 | * not mean "do not ignore merges", but "match_missing". |
| 373 | * |
| 374 | * But with the revision flag parsing, that's found in |
| 375 | * "!revs->ignore_merges". |
Junio C Hamano | 5c21ac0 | 2006-04-22 03:58:04 -0700 | [diff] [blame] | 376 | */ |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 377 | match_missing = !revs->ignore_merges; |
| 378 | |
| 379 | if (cached && idx && ce_stage(idx)) { |
Junio C Hamano | fa7b290 | 2011-04-22 16:05:58 -0700 | [diff] [blame] | 380 | struct diff_filepair *pair; |
| 381 | pair = diff_unmerge(&revs->diffopt, idx->name); |
Junio C Hamano | ff00b68 | 2011-07-13 21:36:29 -0700 | [diff] [blame] | 382 | if (tree) |
| 383 | fill_filespec(pair->one, tree->sha1, tree->ce_mode); |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 384 | return; |
| 385 | } |
| 386 | |
| 387 | /* |
| 388 | * Something added to the tree? |
| 389 | */ |
| 390 | if (!tree) { |
Kjetil Barvik | ff7e6aa | 2009-01-11 19:36:42 +0100 | [diff] [blame] | 391 | show_new_file(revs, idx, cached, match_missing); |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 392 | return; |
| 393 | } |
| 394 | |
| 395 | /* |
| 396 | * Something removed from the tree? |
| 397 | */ |
| 398 | if (!idx) { |
Jens Lehmann | e3d42c4 | 2010-01-18 21:26:18 +0100 | [diff] [blame] | 399 | diff_index_show_file(revs, "-", tree, tree->sha1, tree->ce_mode, 0); |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 400 | return; |
| 401 | } |
| 402 | |
| 403 | /* Show difference between old and new */ |
Kjetil Barvik | ff7e6aa | 2009-01-11 19:36:42 +0100 | [diff] [blame] | 404 | show_modified(revs, tree, idx, 1, cached, match_missing); |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 405 | } |
| 406 | |
| 407 | /* |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 408 | * The unpack_trees() interface is designed for merging, so |
| 409 | * the different source entries are designed primarily for |
| 410 | * the source trees, with the old index being really mainly |
| 411 | * used for being replaced by the result. |
| 412 | * |
| 413 | * For diffing, the index is more important, and we only have a |
| 414 | * single tree. |
| 415 | * |
Junio C Hamano | da8ba5e | 2009-09-17 22:12:17 -0700 | [diff] [blame] | 416 | * We're supposed to advance o->pos to skip what we have already processed. |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 417 | * |
| 418 | * This wrapper makes it all more readable, and takes care of all |
| 419 | * the fairly complex unpack_trees() semantic requirements, including |
| 420 | * the skipping, the path matching, the type conflict cases etc. |
| 421 | */ |
Linus Torvalds | 34110cd | 2008-03-06 18:12:28 -0800 | [diff] [blame] | 422 | static int oneway_diff(struct cache_entry **src, struct unpack_trees_options *o) |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 423 | { |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 424 | struct cache_entry *idx = src[0]; |
| 425 | struct cache_entry *tree = src[1]; |
Kjetil Barvik | ff7e6aa | 2009-01-11 19:36:42 +0100 | [diff] [blame] | 426 | struct rev_info *revs = o->unpack_data; |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 427 | |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 428 | /* |
| 429 | * Unpack-trees generates a DF/conflict entry if |
| 430 | * there was a directory in the index and a tree |
| 431 | * in the tree. From a diff standpoint, that's a |
| 432 | * delete of the tree and a create of the file. |
| 433 | */ |
| 434 | if (tree == o->df_conflict_entry) |
| 435 | tree = NULL; |
| 436 | |
Junio C Hamano | b419482 | 2011-05-31 10:06:44 -0700 | [diff] [blame] | 437 | if (ce_path_match(idx ? idx : tree, &revs->prune_data)) { |
Linus Torvalds | 34110cd | 2008-03-06 18:12:28 -0800 | [diff] [blame] | 438 | do_oneway_diff(o, idx, tree); |
Junio C Hamano | b419482 | 2011-05-31 10:06:44 -0700 | [diff] [blame] | 439 | if (diff_can_quit_early(&revs->diffopt)) { |
| 440 | o->exiting_early = 1; |
| 441 | return -1; |
| 442 | } |
| 443 | } |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 444 | |
Linus Torvalds | 34110cd | 2008-03-06 18:12:28 -0800 | [diff] [blame] | 445 | return 0; |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 446 | } |
| 447 | |
Junio C Hamano | bf979c0 | 2011-07-13 18:57:42 -0700 | [diff] [blame] | 448 | static int diff_cache(struct rev_info *revs, |
| 449 | const unsigned char *tree_sha1, |
| 450 | const char *tree_name, |
| 451 | int cached) |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 452 | { |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 453 | struct tree *tree; |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 454 | struct tree_desc t; |
Junio C Hamano | bf979c0 | 2011-07-13 18:57:42 -0700 | [diff] [blame] | 455 | struct unpack_trees_options opts; |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 456 | |
Junio C Hamano | bf979c0 | 2011-07-13 18:57:42 -0700 | [diff] [blame] | 457 | tree = parse_tree_indirect(tree_sha1); |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 458 | if (!tree) |
Junio C Hamano | bf979c0 | 2011-07-13 18:57:42 -0700 | [diff] [blame] | 459 | return error("bad tree object %s", |
| 460 | tree_name ? tree_name : sha1_to_hex(tree_sha1)); |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 461 | memset(&opts, 0, sizeof(opts)); |
| 462 | opts.head_idx = 1; |
| 463 | opts.index_only = cached; |
Junio C Hamano | a0919ce | 2009-05-22 23:14:25 -0700 | [diff] [blame] | 464 | opts.diff_index_cached = (cached && |
| 465 | !DIFF_OPT_TST(&revs->diffopt, FIND_COPIES_HARDER)); |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 466 | opts.merge = 1; |
| 467 | opts.fn = oneway_diff; |
Kjetil Barvik | ff7e6aa | 2009-01-11 19:36:42 +0100 | [diff] [blame] | 468 | opts.unpack_data = revs; |
Linus Torvalds | 34110cd | 2008-03-06 18:12:28 -0800 | [diff] [blame] | 469 | opts.src_index = &the_index; |
| 470 | opts.dst_index = NULL; |
Junio C Hamano | 2f88c19 | 2011-08-29 13:34:08 -0700 | [diff] [blame] | 471 | opts.pathspec = &revs->diffopt.pathspec; |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 472 | |
| 473 | init_tree_desc(&t, tree->buffer, tree->size); |
Junio C Hamano | bf979c0 | 2011-07-13 18:57:42 -0700 | [diff] [blame] | 474 | return unpack_trees(1, &t, &opts); |
| 475 | } |
| 476 | |
| 477 | int run_diff_index(struct rev_info *revs, int cached) |
| 478 | { |
| 479 | struct object_array_entry *ent; |
| 480 | |
| 481 | ent = revs->pending.objects; |
| 482 | if (diff_cache(revs, ent->item->sha1, ent->name, cached)) |
Daniel Barkalow | 203a2fe | 2008-02-07 11:39:48 -0500 | [diff] [blame] | 483 | exit(128); |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 484 | |
Junio C Hamano | a5a818e | 2008-08-18 20:08:09 -0700 | [diff] [blame] | 485 | diff_set_mnemonic_prefix(&revs->diffopt, "c/", cached ? "i/" : "w/"); |
Junio C Hamano | 730f728 | 2009-09-20 00:03:39 -0700 | [diff] [blame] | 486 | diffcore_fix_diff_index(&revs->diffopt); |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 487 | diffcore_std(&revs->diffopt); |
| 488 | diff_flush(&revs->diffopt); |
Linus Torvalds | d1f2d7e | 2008-01-19 17:27:12 -0800 | [diff] [blame] | 489 | return 0; |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 490 | } |
Junio C Hamano | 1cfe773 | 2007-01-30 01:11:08 -0800 | [diff] [blame] | 491 | |
| 492 | int do_diff_cache(const unsigned char *tree_sha1, struct diff_options *opt) |
| 493 | { |
Junio C Hamano | 1cfe773 | 2007-01-30 01:11:08 -0800 | [diff] [blame] | 494 | struct rev_info revs; |
Junio C Hamano | 1cfe773 | 2007-01-30 01:11:08 -0800 | [diff] [blame] | 495 | |
| 496 | init_revisions(&revs, NULL); |
Nguyễn Thái Ngọc Duy | afe069d | 2010-12-17 19:43:06 +0700 | [diff] [blame] | 497 | init_pathspec(&revs.prune_data, opt->pathspec.raw); |
Junio C Hamano | bf979c0 | 2011-07-13 18:57:42 -0700 | [diff] [blame] | 498 | revs.diffopt = *opt; |
Johannes Schindelin | 204ce97 | 2008-01-20 15:19:56 +0000 | [diff] [blame] | 499 | |
Junio C Hamano | bf979c0 | 2011-07-13 18:57:42 -0700 | [diff] [blame] | 500 | if (diff_cache(&revs, tree_sha1, NULL, 1)) |
Daniel Barkalow | 203a2fe | 2008-02-07 11:39:48 -0500 | [diff] [blame] | 501 | exit(128); |
Johannes Schindelin | 204ce97 | 2008-01-20 15:19:56 +0000 | [diff] [blame] | 502 | return 0; |
Junio C Hamano | 1cfe773 | 2007-01-30 01:11:08 -0800 | [diff] [blame] | 503 | } |
Stephan Beyer | 75f3ff2 | 2009-02-10 15:30:35 +0100 | [diff] [blame] | 504 | |
| 505 | int index_differs_from(const char *def, int diff_flags) |
| 506 | { |
| 507 | struct rev_info rev; |
Junio C Hamano | 32962c9 | 2010-03-08 22:58:09 -0800 | [diff] [blame] | 508 | struct setup_revision_opt opt; |
Stephan Beyer | 75f3ff2 | 2009-02-10 15:30:35 +0100 | [diff] [blame] | 509 | |
| 510 | init_revisions(&rev, NULL); |
Junio C Hamano | 32962c9 | 2010-03-08 22:58:09 -0800 | [diff] [blame] | 511 | memset(&opt, 0, sizeof(opt)); |
| 512 | opt.def = def; |
| 513 | setup_revisions(0, NULL, &rev, &opt); |
Junio C Hamano | 90b1994 | 2009-05-23 01:15:35 -0700 | [diff] [blame] | 514 | DIFF_OPT_SET(&rev.diffopt, QUICK); |
Stephan Beyer | 75f3ff2 | 2009-02-10 15:30:35 +0100 | [diff] [blame] | 515 | DIFF_OPT_SET(&rev.diffopt, EXIT_WITH_STATUS); |
| 516 | rev.diffopt.flags |= diff_flags; |
| 517 | run_diff_index(&rev, 1); |
| 518 | if (rev.pending.alloc) |
| 519 | free(rev.pending.objects); |
| 520 | return (DIFF_OPT_TST(&rev.diffopt, HAS_CHANGES) != 0); |
| 521 | } |