[PATCH] Add git-diff-stages command.
[git] / read-tree.c
1 /*
2  * GIT - The information manager from hell
3  *
4  * Copyright (C) Linus Torvalds, 2005
5  */
6 #include "cache.h"
7
8 static int stage = 0;
9 static int update = 0;
10
11 static int unpack_tree(unsigned char *sha1)
12 {
13         void *buffer;
14         unsigned long size;
15         int ret;
16
17         buffer = read_object_with_reference(sha1, "tree", &size, NULL);
18         if (!buffer)
19                 return -1;
20         ret = read_tree(buffer, size, stage);
21         free(buffer);
22         return ret;
23 }
24
25 static int path_matches(struct cache_entry *a, struct cache_entry *b)
26 {
27         int len = ce_namelen(a);
28         return ce_namelen(b) == len &&
29                 !memcmp(a->name, b->name, len);
30 }
31
32 static int same(struct cache_entry *a, struct cache_entry *b)
33 {
34         return a->ce_mode == b->ce_mode && 
35                 !memcmp(a->sha1, b->sha1, 20);
36 }
37
38
39 /*
40  * This removes all trivial merges that don't change the tree
41  * and collapses them to state 0.
42  */
43 static struct cache_entry *merge_entries(struct cache_entry *a,
44                                          struct cache_entry *b,
45                                          struct cache_entry *c)
46 {
47         /*
48          * Ok, all three entries describe the same
49          * filename, but maybe the contents or file
50          * mode have changed?
51          *
52          * The trivial cases end up being the ones where two
53          * out of three files are the same:
54          *  - both destinations the same, trivially take either
55          *  - one of the destination versions hasn't changed,
56          *    take the other.
57          *
58          * The "all entries exactly the same" case falls out as
59          * a special case of any of the "two same" cases.
60          *
61          * Here "a" is "original", and "b" and "c" are the two
62          * trees we are merging.
63          */
64         if (a && b && c) {
65                 if (same(b,c))
66                         return c;
67                 if (same(a,b))
68                         return c;
69                 if (same(a,c))
70                         return b;
71         }
72         return NULL;
73 }
74
75 /*
76  * When a CE gets turned into an unmerged entry, we
77  * want it to be up-to-date
78  */
79 static void verify_uptodate(struct cache_entry *ce)
80 {
81         struct stat st;
82
83         if (!lstat(ce->name, &st)) {
84                 unsigned changed = ce_match_stat(ce, &st);
85                 if (!changed)
86                         return;
87                 errno = 0;
88         }
89         if (errno == ENOENT)
90                 return;
91         die("Entry '%s' not uptodate. Cannot merge.", ce->name);
92 }
93
94 /*
95  * If the old tree contained a CE that isn't even in the
96  * result, that's always a problem, regardless of whether
97  * it's up-to-date or not (ie it can be a file that we
98  * have updated but not committed yet).
99  */
100 static void reject_merge(struct cache_entry *ce)
101 {
102         die("Entry '%s' would be overwritten by merge. Cannot merge.", ce->name);
103 }
104
105 static int merged_entry(struct cache_entry *merge, struct cache_entry *old, struct cache_entry **dst)
106 {
107         merge->ce_flags |= htons(CE_UPDATE);
108         if (old) {
109                 /*
110                  * See if we can re-use the old CE directly?
111                  * That way we get the uptodate stat info.
112                  *
113                  * This also removes the UPDATE flag on
114                  * a match.
115                  */
116                 if (same(old, merge)) {
117                         *merge = *old;
118                 } else {
119                         verify_uptodate(old);
120                 }
121         }
122         merge->ce_flags &= ~htons(CE_STAGEMASK);
123         *dst++ = merge;
124         return 1;
125 }
126
127 static int threeway_merge(struct cache_entry *stages[4], struct cache_entry **dst)
128 {
129         struct cache_entry *old = stages[0];
130         struct cache_entry *a = stages[1], *b = stages[2], *c = stages[3];
131         struct cache_entry *merge;
132         int count;
133
134         /*
135          * If we have an entry in the index cache ("old"), then we want
136          * to make sure that it matches any entries in stage 2 ("first
137          * branch", aka "b").
138          */
139         if (old) {
140                 if (!b || !same(old, b))
141                         return -1;
142         }
143         merge = merge_entries(a, b, c);
144         if (merge)
145                 return merged_entry(merge, old, dst);
146         if (old)
147                 verify_uptodate(old);
148         count = 0;
149         if (a) { *dst++ = a; count++; }
150         if (b) { *dst++ = b; count++; }
151         if (c) { *dst++ = c; count++; }
152         return count;
153 }
154
155 /*
156  * Two-way merge.
157  *
158  * The rule is to "carry forward" what is in the index without losing
159  * information across a "fast forward", favoring a successful merge
160  * over a merge failure when it makes sense.  For details of the
161  * "carry forward" rule, please see <Documentation/git-read-tree.txt>.
162  *
163  */
164 static int twoway_merge(struct cache_entry **src, struct cache_entry **dst)
165 {
166         struct cache_entry *current = src[0];
167         struct cache_entry *oldtree = src[1], *newtree = src[2];
168
169         if (src[3])
170                 return -1;
171
172         if (current) {
173                 if ((!oldtree && !newtree) || /* 4 and 5 */
174                     (!oldtree && newtree &&
175                      same(current, newtree)) || /* 6 and 7 */
176                     (oldtree && newtree &&
177                      same(oldtree, newtree)) || /* 14 and 15 */
178                     (oldtree && newtree &&
179                      !same(oldtree, newtree) && /* 18 and 19*/
180                      same(current, newtree))) {
181                         *dst++ = current;
182                         return 1;
183                 }
184                 else if (oldtree && !newtree && same(current, oldtree)) {
185                         /* 10 or 11 */
186                         verify_uptodate(current);
187                         return 0;
188                 }
189                 else if (oldtree && newtree &&
190                          same(current, oldtree) && !same(current, newtree)) {
191                         /* 20 or 21 */
192                         verify_uptodate(current);
193                         return merged_entry(newtree, NULL, dst);
194                 }
195                 else
196                         /* all other failures */
197                         return -1;
198         }
199         else if (newtree)
200                 return merged_entry(newtree, NULL, dst);
201         else
202                 return 0;
203 }
204
205 /*
206  * One-way merge.
207  *
208  * The rule is:
209  * - take the stat information from stage0, take the data from stage1
210  */
211 static int oneway_merge(struct cache_entry **src, struct cache_entry **dst)
212 {
213         struct cache_entry *old = src[0];
214         struct cache_entry *a = src[1];
215
216         if (src[2] || src[3])
217                 return -1;
218
219         if (!a)
220                 return 0;
221         if (old && same(old, a)) {
222                 *dst++ = old;
223                 return 1;
224         }
225         return merged_entry(a, NULL, dst);
226 }
227
228 static void check_updates(struct cache_entry **src, int nr)
229 {
230         static struct checkout state = {
231                 .base_dir = "",
232                 .force = 1,
233                 .quiet = 1,
234                 .refresh_cache = 1,
235         };
236         unsigned short mask = htons(CE_UPDATE);
237         while (nr--) {
238                 struct cache_entry *ce = *src++;
239                 if (ce->ce_flags & mask) {
240                         ce->ce_flags &= ~mask;
241                         if (update)
242                                 checkout_entry(ce, &state);
243                 }
244         }
245 }
246
247 typedef int (*merge_fn_t)(struct cache_entry **, struct cache_entry **);
248
249 static void merge_cache(struct cache_entry **src, int nr, merge_fn_t fn)
250 {
251         struct cache_entry **dst = src;
252
253         while (nr) {
254                 int entries;
255                 struct cache_entry *name, *ce, *stages[4] = { NULL, };
256
257                 name = ce = *src;
258                 for (;;) {
259                         int stage = ce_stage(ce);
260                         stages[stage] = ce;
261                         ce = *++src;
262                         active_nr--;
263                         if (!--nr)
264                                 break;
265                         if (!path_matches(ce, name))
266                                 break;
267                 }
268
269                 entries = fn(stages, dst);
270                 if (entries < 0)
271                         reject_merge(name);
272                 dst += entries;
273                 active_nr += entries;
274         }
275         check_updates(active_cache, active_nr);
276 }
277
278 static int read_cache_unmerged(void)
279 {
280         int i, deleted;
281         struct cache_entry **dst;
282
283         read_cache();
284         dst = active_cache;
285         deleted = 0;
286         for (i = 0; i < active_nr; i++) {
287                 struct cache_entry *ce = active_cache[i];
288                 if (ce_stage(ce)) {
289                         deleted++;
290                         continue;
291                 }
292                 if (deleted)
293                         *dst = ce;
294                 dst++;
295         }
296         active_nr -= deleted;
297         return deleted;
298 }
299
300 static char *read_tree_usage = "git-read-tree (<sha> | -m [-u] <sha1> [<sha2> [<sha3>]])";
301
302 static struct cache_file cache_file;
303
304 int main(int argc, char **argv)
305 {
306         int i, newfd, merge, reset;
307         unsigned char sha1[20];
308
309         newfd = hold_index_file_for_update(&cache_file, get_index_file());
310         if (newfd < 0)
311                 die("unable to create new cachefile");
312
313         merge = 0;
314         reset = 0;
315         for (i = 1; i < argc; i++) {
316                 const char *arg = argv[i];
317
318                 /* "-u" means "update", meaning that a merge will update the working directory */
319                 if (!strcmp(arg, "-u")) {
320                         update = 1;
321                         continue;
322                 }
323
324                 /* This differs from "-m" in that we'll silently ignore unmerged entries */
325                 if (!strcmp(arg, "--reset")) {
326                         if (stage || merge)
327                                 usage(read_tree_usage);
328                         reset = 1;
329                         merge = 1;
330                         stage = 1;
331                         read_cache_unmerged();
332                 }
333
334                 /* "-m" stands for "merge", meaning we start in stage 1 */
335                 if (!strcmp(arg, "-m")) {
336                         if (stage || merge)
337                                 usage(read_tree_usage);
338                         if (read_cache_unmerged())
339                                 die("you need to resolve your current index first");
340                         stage = 1;
341                         merge = 1;
342                         continue;
343                 }
344                 if (get_sha1(arg, sha1) < 0)
345                         usage(read_tree_usage);
346                 if (stage > 3)
347                         usage(read_tree_usage);
348                 if (unpack_tree(sha1) < 0)
349                         die("failed to unpack tree object %s", arg);
350                 stage++;
351         }
352         if (update && !merge)
353                 usage(read_tree_usage);
354         if (merge) {
355                 static const merge_fn_t merge_function[] = {
356                         [1] = oneway_merge,
357                         [2] = twoway_merge,
358                         [3] = threeway_merge,
359                 };
360                 if (stage < 2 || stage > 4)
361                         die("just how do you expect me to merge %d trees?", stage-1);
362                 merge_cache(active_cache, active_nr, merge_function[stage-1]);
363         }
364         if (write_cache(newfd, active_cache, active_nr) ||
365             commit_index_file(&cache_file))
366                 die("unable to write new index file");
367         return 0;
368 }