]>
Commit | Line | Data |
---|---|---|
e74f8f6a | 1 | #include "cache.h" |
f92a4465 | 2 | #include "diff.h" |
e74f8f6a LT |
3 | |
4 | static int cached_only = 0; | |
e68b6f15 LT |
5 | static int diff_output_format = DIFF_FORMAT_RAW; |
6 | static int diff_line_termination = '\n'; | |
160c8433 | 7 | static int match_nonexisting = 0; |
5c97558c | 8 | static int detect_rename = 0; |
4727f640 | 9 | static int find_copies_harder = 0; |
19feebc8 | 10 | static int diff_setup_opt = 0; |
57fe64a4 | 11 | static int diff_score_opt = 0; |
057c7d30 | 12 | static const char *pickaxe = NULL; |
367cec1c | 13 | static int pickaxe_opts = 0; |
f345b0a0 | 14 | static int diff_break_opt = -1; |
af5323e0 | 15 | static const char *orderfile = NULL; |
f2ce9fde | 16 | static const char *diff_filter = NULL; |
e74f8f6a | 17 | |
e74f8f6a | 18 | /* A file entry went away or appeared */ |
c9cddabe | 19 | static void show_file(const char *prefix, struct cache_entry *ce, unsigned char *sha1, unsigned int mode) |
e74f8f6a | 20 | { |
57fe64a4 | 21 | diff_addremove(prefix[0], ntohl(mode), sha1, ce->name, NULL); |
e74f8f6a LT |
22 | } |
23 | ||
c9cddabe | 24 | static int get_stat_data(struct cache_entry *ce, unsigned char **sha1p, unsigned int *modep) |
e74f8f6a | 25 | { |
c9cddabe LT |
26 | unsigned char *sha1 = ce->sha1; |
27 | unsigned int mode = ce->ce_mode; | |
e74f8f6a LT |
28 | |
29 | if (!cached_only) { | |
30 | static unsigned char no_sha1[20]; | |
b5af9107 | 31 | int changed; |
e74f8f6a | 32 | struct stat st; |
160c8433 LT |
33 | if (lstat(ce->name, &st) < 0) { |
34 | if (errno == ENOENT && match_nonexisting) { | |
35 | *sha1p = sha1; | |
36 | *modep = mode; | |
37 | return 0; | |
38 | } | |
e74f8f6a | 39 | return -1; |
160c8433 | 40 | } |
5d728c84 | 41 | changed = ce_match_stat(ce, &st); |
e74f8f6a | 42 | if (changed) { |
c9cddabe | 43 | mode = create_ce_mode(st.st_mode); |
b5af9107 | 44 | sha1 = no_sha1; |
e74f8f6a LT |
45 | } |
46 | } | |
47 | ||
c9cddabe LT |
48 | *sha1p = sha1; |
49 | *modep = mode; | |
50 | return 0; | |
51 | } | |
52 | ||
b836825b | 53 | static void show_new_file(struct cache_entry *new) |
c9cddabe LT |
54 | { |
55 | unsigned char *sha1; | |
56 | unsigned int mode; | |
57 | ||
58 | /* New file in the index: it might actually be different in the working copy */ | |
59 | if (get_stat_data(new, &sha1, &mode) < 0) | |
b836825b | 60 | return; |
c9cddabe LT |
61 | |
62 | show_file("+", new, sha1, mode); | |
63 | } | |
64 | ||
66026590 JH |
65 | static int show_modified(struct cache_entry *old, |
66 | struct cache_entry *new, | |
67 | int report_missing) | |
c9cddabe LT |
68 | { |
69 | unsigned int mode, oldmode; | |
70 | unsigned char *sha1; | |
c9cddabe LT |
71 | |
72 | if (get_stat_data(new, &sha1, &mode) < 0) { | |
66026590 JH |
73 | if (report_missing) |
74 | show_file("-", old, old->sha1, old->ce_mode); | |
c9cddabe LT |
75 | return -1; |
76 | } | |
77 | ||
78 | oldmode = old->ce_mode; | |
c3e7fbcb | 79 | if (mode == oldmode && !memcmp(sha1, old->sha1, 20) && |
4727f640 | 80 | !find_copies_harder) |
e74f8f6a LT |
81 | return 0; |
82 | ||
c9cddabe LT |
83 | mode = ntohl(mode); |
84 | oldmode = ntohl(oldmode); | |
85 | ||
57fe64a4 JH |
86 | diff_change(oldmode, mode, |
87 | old->sha1, sha1, old->name, NULL); | |
e74f8f6a LT |
88 | return 0; |
89 | } | |
90 | ||
fdee7d07 | 91 | static int diff_cache(struct cache_entry **ac, int entries, const char **pathspec) |
e74f8f6a | 92 | { |
b5af9107 LT |
93 | while (entries) { |
94 | struct cache_entry *ce = *ac; | |
dbbce55b | 95 | int same = (entries > 1) && ce_same_name(ce, ac[1]); |
e74f8f6a | 96 | |
fdee7d07 LT |
97 | if (!ce_path_match(ce, pathspec)) |
98 | goto skip_entry; | |
99 | ||
b0fe89ca LT |
100 | switch (ce_stage(ce)) { |
101 | case 0: | |
102 | /* No stage 1 entry? That means it's a new file */ | |
103 | if (!same) { | |
c9cddabe | 104 | show_new_file(ce); |
b0fe89ca LT |
105 | break; |
106 | } | |
107 | /* Show difference between old and new */ | |
66026590 | 108 | show_modified(ac[1], ce, 1); |
b0fe89ca LT |
109 | break; |
110 | case 1: | |
111 | /* No stage 3 (merge) entry? That means it's been deleted */ | |
112 | if (!same) { | |
c9cddabe | 113 | show_file("-", ce, ce->sha1, ce->ce_mode); |
b0fe89ca LT |
114 | break; |
115 | } | |
66026590 JH |
116 | /* We come here with ce pointing at stage 1 |
117 | * (original tree) and ac[1] pointing at stage | |
118 | * 3 (unmerged). show-modified with | |
119 | * report-mising set to false does not say the | |
120 | * file is deleted but reports true if work | |
121 | * tree does not have it, in which case we | |
122 | * fall through to report the unmerged state. | |
123 | * Otherwise, we show the differences between | |
124 | * the original tree and the work tree. | |
125 | */ | |
126 | if (!cached_only && !show_modified(ce, ac[1], 0)) | |
127 | break; | |
128 | /* fallthru */ | |
b0fe89ca | 129 | case 3: |
57fe64a4 | 130 | diff_unmerge(ce->name); |
b0fe89ca LT |
131 | break; |
132 | ||
133 | default: | |
134 | die("impossible cache entry stage"); | |
e74f8f6a | 135 | } |
b0fe89ca | 136 | |
fdee7d07 | 137 | skip_entry: |
b0fe89ca LT |
138 | /* |
139 | * Ignore all the different stages for this file, | |
140 | * we've handled the relevant cases now. | |
141 | */ | |
142 | do { | |
e74f8f6a LT |
143 | ac++; |
144 | entries--; | |
dbbce55b | 145 | } while (entries && ce_same_name(ce, ac[0])); |
e74f8f6a LT |
146 | } |
147 | return 0; | |
148 | } | |
149 | ||
b0fe89ca LT |
150 | /* |
151 | * This turns all merge entries into "stage 3". That guarantees that | |
152 | * when we read in the new tree (into "stage 1"), we won't lose sight | |
153 | * of the fact that we had unmerged entries. | |
154 | */ | |
155 | static void mark_merge_entries(void) | |
b5af9107 LT |
156 | { |
157 | int i; | |
158 | for (i = 0; i < active_nr; i++) { | |
159 | struct cache_entry *ce = active_cache[i]; | |
160 | if (!ce_stage(ce)) | |
5697ecc7 | 161 | continue; |
b0fe89ca | 162 | ce->ce_flags |= htons(CE_STAGEMASK); |
b5af9107 LT |
163 | } |
164 | } | |
165 | ||
f92a4465 | 166 | static char *diff_cache_usage = |
dda2d79a JH |
167 | "git-diff-cache [-m] [--cached] " |
168 | "[<common diff options>] <tree-ish> [<path>...]" | |
169 | COMMON_DIFF_OPTIONS_HELP; | |
c5bac17a | 170 | |
6b14d7fa | 171 | int main(int argc, const char **argv) |
e74f8f6a | 172 | { |
6c56c534 LT |
173 | const char *tree_name = NULL; |
174 | unsigned char sha1[20]; | |
175 | const char **pathspec = NULL; | |
e74f8f6a LT |
176 | void *tree; |
177 | unsigned long size; | |
5c97558c | 178 | int ret; |
e0f0e891 | 179 | int allow_options = 1; |
6c56c534 | 180 | int i; |
e74f8f6a LT |
181 | |
182 | read_cache(); | |
6c56c534 LT |
183 | for (i = 1; i < argc; i++) { |
184 | const char *arg = argv[i]; | |
185 | ||
e0f0e891 | 186 | if (!allow_options || *arg != '-') { |
6c56c534 LT |
187 | if (tree_name) { |
188 | pathspec = argv + i; | |
189 | break; | |
190 | } | |
191 | tree_name = arg; | |
192 | continue; | |
193 | } | |
194 | ||
e0f0e891 JF |
195 | if (!strcmp(arg, "--")) { |
196 | allow_options = 0; | |
197 | continue; | |
198 | } | |
e74f8f6a | 199 | if (!strcmp(arg, "-r")) { |
667bb59b | 200 | /* We accept the -r flag just to look like git-diff-tree */ |
e74f8f6a LT |
201 | continue; |
202 | } | |
acb46f87 LT |
203 | /* We accept the -u flag as a synonym for "-p" */ |
204 | if (!strcmp(arg, "-p") || !strcmp(arg, "-u")) { | |
81e50eab | 205 | diff_output_format = DIFF_FORMAT_PATCH; |
f92a4465 JH |
206 | continue; |
207 | } | |
f345b0a0 | 208 | if (!strncmp(arg, "-B", 2)) { |
0e3994fa JH |
209 | if ((diff_break_opt = diff_scoreopt_parse(arg)) == -1) |
210 | usage(diff_cache_usage); | |
f345b0a0 JH |
211 | continue; |
212 | } | |
57fe64a4 | 213 | if (!strncmp(arg, "-M", 2)) { |
6b14d7fa | 214 | detect_rename = DIFF_DETECT_RENAME; |
0e3994fa JH |
215 | if ((diff_score_opt = diff_scoreopt_parse(arg)) == -1) |
216 | usage(diff_cache_usage); | |
5c97558c JH |
217 | continue; |
218 | } | |
427dcb4b | 219 | if (!strncmp(arg, "-C", 2)) { |
6b14d7fa | 220 | detect_rename = DIFF_DETECT_COPY; |
0e3994fa JH |
221 | if ((diff_score_opt = diff_scoreopt_parse(arg)) == -1) |
222 | usage(diff_cache_usage); | |
427dcb4b JH |
223 | continue; |
224 | } | |
4727f640 JH |
225 | if (!strcmp(arg, "--find-copies-harder")) { |
226 | find_copies_harder = 1; | |
227 | continue; | |
228 | } | |
e74f8f6a | 229 | if (!strcmp(arg, "-z")) { |
e68b6f15 | 230 | diff_line_termination = 0; |
e74f8f6a LT |
231 | continue; |
232 | } | |
52f28529 JH |
233 | if (!strcmp(arg, "--name-only")) { |
234 | diff_output_format = DIFF_FORMAT_NAME; | |
235 | continue; | |
236 | } | |
57fe64a4 | 237 | if (!strcmp(arg, "-R")) { |
19feebc8 | 238 | diff_setup_opt |= DIFF_SETUP_REVERSE; |
57fe64a4 JH |
239 | continue; |
240 | } | |
e25de756 | 241 | if (!strncmp(arg, "-S", 2)) { |
52e95789 JH |
242 | pickaxe = arg + 2; |
243 | continue; | |
244 | } | |
f2ce9fde JH |
245 | if (!strncmp(arg, "--diff-filter=", 14)) { |
246 | diff_filter = arg + 14; | |
247 | continue; | |
248 | } | |
af5323e0 JH |
249 | if (!strncmp(arg, "-O", 2)) { |
250 | orderfile = arg + 2; | |
251 | continue; | |
252 | } | |
367cec1c JH |
253 | if (!strcmp(arg, "--pickaxe-all")) { |
254 | pickaxe_opts = DIFF_PICKAXE_ALL; | |
255 | continue; | |
256 | } | |
160c8433 LT |
257 | if (!strcmp(arg, "-m")) { |
258 | match_nonexisting = 1; | |
259 | continue; | |
260 | } | |
e74f8f6a LT |
261 | if (!strcmp(arg, "--cached")) { |
262 | cached_only = 1; | |
263 | continue; | |
264 | } | |
c5bac17a | 265 | usage(diff_cache_usage); |
e74f8f6a LT |
266 | } |
267 | ||
4727f640 JH |
268 | if (find_copies_harder && detect_rename != DIFF_DETECT_COPY) |
269 | usage(diff_cache_usage); | |
270 | ||
6c56c534 | 271 | if (!tree_name || get_sha1(tree_name, sha1)) |
c5bac17a | 272 | usage(diff_cache_usage); |
e74f8f6a | 273 | |
6b14d7fa | 274 | /* The rest is for paths restriction. */ |
19feebc8 | 275 | diff_setup(diff_setup_opt); |
5c97558c | 276 | |
b0fe89ca | 277 | mark_merge_entries(); |
b5af9107 | 278 | |
6c56c534 | 279 | tree = read_object_with_reference(sha1, "tree", &size, NULL); |
e74f8f6a | 280 | if (!tree) |
6c56c534 | 281 | die("bad tree object %s", tree_name); |
a74ba54b | 282 | if (read_tree(tree, size, 1, pathspec)) |
6c56c534 | 283 | die("unable to read tree object %s", tree_name); |
e74f8f6a | 284 | |
fdee7d07 | 285 | ret = diff_cache(active_cache, active_nr, pathspec); |
f345b0a0 | 286 | |
a74ba54b | 287 | diffcore_std(pathspec, |
befe8639 | 288 | detect_rename, diff_score_opt, |
f345b0a0 | 289 | pickaxe, pickaxe_opts, |
af5323e0 | 290 | diff_break_opt, |
f2ce9fde | 291 | orderfile, diff_filter); |
e68b6f15 | 292 | diff_flush(diff_output_format, diff_line_termination); |
5c97558c | 293 | return ret; |
e74f8f6a | 294 | } |