]>
Commit | Line | Data |
---|---|---|
e74f8f6a | 1 | #include "cache.h" |
521698b1 | 2 | #include "tree.h" |
f92a4465 | 3 | #include "diff.h" |
e74f8f6a LT |
4 | |
5 | static int cached_only = 0; | |
160c8433 | 6 | static int match_nonexisting = 0; |
6b5ee137 | 7 | static struct diff_options diff_options; |
e74f8f6a | 8 | |
e74f8f6a | 9 | /* A file entry went away or appeared */ |
6b5ee137 JH |
10 | static void show_file(const char *prefix, |
11 | struct cache_entry *ce, | |
12 | unsigned char *sha1, unsigned int mode) | |
e74f8f6a | 13 | { |
6b5ee137 JH |
14 | diff_addremove(&diff_options, prefix[0], ntohl(mode), |
15 | sha1, ce->name, NULL); | |
e74f8f6a LT |
16 | } |
17 | ||
6b5ee137 | 18 | static int get_stat_data(struct cache_entry *ce, |
3e09cdfd | 19 | unsigned char ** sha1p, unsigned int *modep) |
e74f8f6a | 20 | { |
c9cddabe LT |
21 | unsigned char *sha1 = ce->sha1; |
22 | unsigned int mode = ce->ce_mode; | |
e74f8f6a LT |
23 | |
24 | if (!cached_only) { | |
25 | static unsigned char no_sha1[20]; | |
b5af9107 | 26 | int changed; |
e74f8f6a | 27 | struct stat st; |
160c8433 LT |
28 | if (lstat(ce->name, &st) < 0) { |
29 | if (errno == ENOENT && match_nonexisting) { | |
30 | *sha1p = sha1; | |
31 | *modep = mode; | |
32 | return 0; | |
33 | } | |
e74f8f6a | 34 | return -1; |
160c8433 | 35 | } |
5f73076c | 36 | changed = ce_match_stat(ce, &st, 0); |
e74f8f6a | 37 | if (changed) { |
c9cddabe | 38 | mode = create_ce_mode(st.st_mode); |
3e09cdfd JH |
39 | if (!trust_executable_bit && |
40 | S_ISREG(mode) && S_ISREG(ce->ce_mode) && | |
41 | ((mode ^ ce->ce_mode) == 0111)) | |
42 | mode = ce->ce_mode; | |
b5af9107 | 43 | sha1 = no_sha1; |
e74f8f6a LT |
44 | } |
45 | } | |
46 | ||
c9cddabe LT |
47 | *sha1p = sha1; |
48 | *modep = mode; | |
49 | return 0; | |
50 | } | |
51 | ||
b836825b | 52 | static void show_new_file(struct cache_entry *new) |
c9cddabe LT |
53 | { |
54 | unsigned char *sha1; | |
55 | unsigned int mode; | |
56 | ||
3e09cdfd JH |
57 | /* New file in the index: it might actually be different in |
58 | * the working copy. | |
59 | */ | |
c9cddabe | 60 | if (get_stat_data(new, &sha1, &mode) < 0) |
b836825b | 61 | return; |
c9cddabe LT |
62 | |
63 | show_file("+", new, sha1, mode); | |
64 | } | |
65 | ||
66026590 JH |
66 | static int show_modified(struct cache_entry *old, |
67 | struct cache_entry *new, | |
68 | int report_missing) | |
c9cddabe LT |
69 | { |
70 | unsigned int mode, oldmode; | |
71 | unsigned char *sha1; | |
c9cddabe LT |
72 | |
73 | if (get_stat_data(new, &sha1, &mode) < 0) { | |
66026590 JH |
74 | if (report_missing) |
75 | show_file("-", old, old->sha1, old->ce_mode); | |
c9cddabe LT |
76 | return -1; |
77 | } | |
78 | ||
79 | oldmode = old->ce_mode; | |
c3e7fbcb | 80 | if (mode == oldmode && !memcmp(sha1, old->sha1, 20) && |
6b5ee137 | 81 | !diff_options.find_copies_harder) |
e74f8f6a LT |
82 | return 0; |
83 | ||
c9cddabe LT |
84 | mode = ntohl(mode); |
85 | oldmode = ntohl(oldmode); | |
86 | ||
6b5ee137 | 87 | diff_change(&diff_options, oldmode, mode, |
57fe64a4 | 88 | old->sha1, sha1, old->name, NULL); |
e74f8f6a LT |
89 | return 0; |
90 | } | |
91 | ||
fdee7d07 | 92 | static int diff_cache(struct cache_entry **ac, int entries, const char **pathspec) |
e74f8f6a | 93 | { |
b5af9107 LT |
94 | while (entries) { |
95 | struct cache_entry *ce = *ac; | |
dbbce55b | 96 | int same = (entries > 1) && ce_same_name(ce, ac[1]); |
e74f8f6a | 97 | |
fdee7d07 LT |
98 | if (!ce_path_match(ce, pathspec)) |
99 | goto skip_entry; | |
100 | ||
b0fe89ca LT |
101 | switch (ce_stage(ce)) { |
102 | case 0: | |
103 | /* No stage 1 entry? That means it's a new file */ | |
104 | if (!same) { | |
c9cddabe | 105 | show_new_file(ce); |
b0fe89ca LT |
106 | break; |
107 | } | |
108 | /* Show difference between old and new */ | |
66026590 | 109 | show_modified(ac[1], ce, 1); |
b0fe89ca LT |
110 | break; |
111 | case 1: | |
112 | /* No stage 3 (merge) entry? That means it's been deleted */ | |
113 | if (!same) { | |
c9cddabe | 114 | show_file("-", ce, ce->sha1, ce->ce_mode); |
b0fe89ca LT |
115 | break; |
116 | } | |
66026590 JH |
117 | /* We come here with ce pointing at stage 1 |
118 | * (original tree) and ac[1] pointing at stage | |
119 | * 3 (unmerged). show-modified with | |
82f9d58a | 120 | * report-missing set to false does not say the |
66026590 JH |
121 | * file is deleted but reports true if work |
122 | * tree does not have it, in which case we | |
123 | * fall through to report the unmerged state. | |
124 | * Otherwise, we show the differences between | |
125 | * the original tree and the work tree. | |
126 | */ | |
127 | if (!cached_only && !show_modified(ce, ac[1], 0)) | |
128 | break; | |
129 | /* fallthru */ | |
b0fe89ca | 130 | case 3: |
6b5ee137 | 131 | diff_unmerge(&diff_options, ce->name); |
b0fe89ca LT |
132 | break; |
133 | ||
134 | default: | |
135 | die("impossible cache entry stage"); | |
e74f8f6a | 136 | } |
b0fe89ca | 137 | |
fdee7d07 | 138 | skip_entry: |
b0fe89ca LT |
139 | /* |
140 | * Ignore all the different stages for this file, | |
141 | * we've handled the relevant cases now. | |
142 | */ | |
143 | do { | |
e74f8f6a LT |
144 | ac++; |
145 | entries--; | |
dbbce55b | 146 | } while (entries && ce_same_name(ce, ac[0])); |
e74f8f6a LT |
147 | } |
148 | return 0; | |
149 | } | |
150 | ||
b0fe89ca LT |
151 | /* |
152 | * This turns all merge entries into "stage 3". That guarantees that | |
153 | * when we read in the new tree (into "stage 1"), we won't lose sight | |
154 | * of the fact that we had unmerged entries. | |
155 | */ | |
156 | static void mark_merge_entries(void) | |
b5af9107 LT |
157 | { |
158 | int i; | |
159 | for (i = 0; i < active_nr; i++) { | |
160 | struct cache_entry *ce = active_cache[i]; | |
161 | if (!ce_stage(ce)) | |
5697ecc7 | 162 | continue; |
b0fe89ca | 163 | ce->ce_flags |= htons(CE_STAGEMASK); |
b5af9107 LT |
164 | } |
165 | } | |
166 | ||
4d1f1190 | 167 | static const char diff_cache_usage[] = |
215a7ad1 | 168 | "git-diff-index [-m] [--cached] " |
dda2d79a JH |
169 | "[<common diff options>] <tree-ish> [<path>...]" |
170 | COMMON_DIFF_OPTIONS_HELP; | |
c5bac17a | 171 | |
6b5ee137 | 172 | int main(int argc, const char **argv) |
e74f8f6a | 173 | { |
6c56c534 LT |
174 | const char *tree_name = NULL; |
175 | unsigned char sha1[20]; | |
d288a700 | 176 | const char *prefix = setup_git_directory(); |
6c56c534 | 177 | const char **pathspec = NULL; |
521698b1 | 178 | struct tree *tree; |
5c97558c | 179 | int ret; |
e0f0e891 | 180 | int allow_options = 1; |
6c56c534 | 181 | int i; |
e74f8f6a | 182 | |
9ce392f4 | 183 | git_config(git_diff_config); |
6b5ee137 | 184 | diff_setup(&diff_options); |
6c56c534 LT |
185 | for (i = 1; i < argc; i++) { |
186 | const char *arg = argv[i]; | |
6b5ee137 | 187 | int diff_opt_cnt; |
6c56c534 | 188 | |
e0f0e891 | 189 | if (!allow_options || *arg != '-') { |
d288a700 | 190 | if (tree_name) |
6c56c534 | 191 | break; |
6c56c534 LT |
192 | tree_name = arg; |
193 | continue; | |
194 | } | |
195 | ||
e0f0e891 JF |
196 | if (!strcmp(arg, "--")) { |
197 | allow_options = 0; | |
198 | continue; | |
199 | } | |
e74f8f6a | 200 | if (!strcmp(arg, "-r")) { |
667bb59b | 201 | /* We accept the -r flag just to look like git-diff-tree */ |
e74f8f6a LT |
202 | continue; |
203 | } | |
4abd8964 JH |
204 | if (!strcmp(arg, "--cc")) |
205 | /* | |
206 | * I _think_ "diff-index --cached HEAD" with an | |
207 | * unmerged index could show something else | |
208 | * later, but pretend --cc is the same as -p for | |
209 | * now. "git diff" uses --cc by default. | |
210 | */ | |
211 | argv[i] = arg = "-p"; | |
6b5ee137 JH |
212 | diff_opt_cnt = diff_opt_parse(&diff_options, argv + i, |
213 | argc - i); | |
214 | if (diff_opt_cnt < 0) | |
215 | usage(diff_cache_usage); | |
216 | else if (diff_opt_cnt) { | |
217 | i += diff_opt_cnt - 1; | |
367cec1c JH |
218 | continue; |
219 | } | |
6b5ee137 | 220 | |
160c8433 LT |
221 | if (!strcmp(arg, "-m")) { |
222 | match_nonexisting = 1; | |
223 | continue; | |
224 | } | |
e74f8f6a LT |
225 | if (!strcmp(arg, "--cached")) { |
226 | cached_only = 1; | |
227 | continue; | |
228 | } | |
c5bac17a | 229 | usage(diff_cache_usage); |
e74f8f6a LT |
230 | } |
231 | ||
d288a700 LT |
232 | pathspec = get_pathspec(prefix, argv + i); |
233 | ||
6b5ee137 | 234 | if (diff_setup_done(&diff_options) < 0) |
4727f640 JH |
235 | usage(diff_cache_usage); |
236 | ||
6c56c534 | 237 | if (!tree_name || get_sha1(tree_name, sha1)) |
c5bac17a | 238 | usage(diff_cache_usage); |
e74f8f6a | 239 | |
d288a700 LT |
240 | read_cache(); |
241 | ||
b0fe89ca | 242 | mark_merge_entries(); |
b5af9107 | 243 | |
521698b1 | 244 | tree = parse_tree_indirect(sha1); |
e74f8f6a | 245 | if (!tree) |
6c56c534 | 246 | die("bad tree object %s", tree_name); |
521698b1 | 247 | if (read_tree(tree, 1, pathspec)) |
6c56c534 | 248 | die("unable to read tree object %s", tree_name); |
e74f8f6a | 249 | |
fdee7d07 | 250 | ret = diff_cache(active_cache, active_nr, pathspec); |
f345b0a0 | 251 | |
6b5ee137 JH |
252 | diffcore_std(&diff_options); |
253 | diff_flush(&diff_options); | |
5c97558c | 254 | return ret; |
e74f8f6a | 255 | } |