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