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