2 * GIT - The information manager from hell
4 * Copyright (C) Linus Torvalds, 2005
12 static int update
= 0;
14 static int head_idx
= -1;
15 static int merge_size
= 0;
17 static struct object_list
*trees
= NULL
;
19 static struct cache_entry df_conflict_entry
= {
22 static struct tree_entry_list df_conflict_list
= {
24 .next
= &df_conflict_list
27 typedef int (*merge_fn_t
)(struct cache_entry
**src
);
29 static int entcmp(char *name1
, int dir1
, char *name2
, int dir2
)
31 int len1
= strlen(name1
);
32 int len2
= strlen(name2
);
33 int len
= len1
< len2
? len1
: len2
;
34 int ret
= memcmp(name1
, name2
, len
);
44 ret
= (c1
< c2
) ? -1 : (c1
> c2
) ? 1 : 0;
50 static int unpack_trees_rec(struct tree_entry_list
**posns
, int len
,
51 const char *base
, merge_fn_t fn
, int *indpos
)
53 int baselen
= strlen(base
);
54 int src_size
= len
+ 1;
61 struct tree_entry_list
**subposns
;
62 struct cache_entry
**src
;
68 /* Find the first name in the input. */
74 if (merge
&& *indpos
< active_nr
) {
75 /* This is a bit tricky: */
76 /* If the index has a subdirectory (with
77 * contents) as the first name, it'll get a
78 * filename like "foo/bar". But that's after
79 * "foo", so the entry in trees will get
80 * handled first, at which point we'll go into
81 * "foo", and deal with "bar" from the index,
82 * because the base will be "foo/". The only
83 * way we can actually have "foo/bar" first of
84 * all the things is if the trees don't
85 * contain "foo" at all, in which case we'll
86 * handle "foo/bar" without going into the
87 * directory, but that's fine (and will return
88 * an error anyway, with the added unknown
92 cache_name
= active_cache
[*indpos
]->name
;
93 if (strlen(cache_name
) > baselen
&&
94 !memcmp(cache_name
, base
, baselen
)) {
95 cache_name
+= baselen
;
103 printf("index %s\n", first
);
105 for (i
= 0; i
< len
; i
++) {
106 if (!posns
[i
] || posns
[i
] == &df_conflict_list
)
108 printf("%d %s\n", i
+ 1, posns
[i
]->name
);
109 if (!first
|| entcmp(first
, firstdir
,
111 posns
[i
]->directory
) > 0) {
112 first
= posns
[i
]->name
;
113 firstdir
= posns
[i
]->directory
;
116 /* No name means we're done */
120 pathlen
= strlen(first
);
121 ce_size
= cache_entry_size(baselen
+ pathlen
);
123 src
= xmalloc(sizeof(struct cache_entry
*) * src_size
);
124 memset(src
, 0, sizeof(struct cache_entry
*) * src_size
);
126 subposns
= xmalloc(sizeof(struct tree_list_entry
*) * len
);
127 memset(subposns
, 0, sizeof(struct tree_list_entry
*) * len
);
129 if (cache_name
&& !strcmp(cache_name
, first
)) {
131 src
[0] = active_cache
[*indpos
];
132 remove_cache_entry_at(*indpos
);
135 for (i
= 0; i
< len
; i
++) {
136 struct cache_entry
*ce
;
139 (posns
[i
] != &df_conflict_list
&&
140 strcmp(first
, posns
[i
]->name
))) {
144 if (posns
[i
] == &df_conflict_list
) {
145 src
[i
+ merge
] = &df_conflict_entry
;
149 if (posns
[i
]->directory
) {
151 parse_tree(posns
[i
]->item
.tree
);
152 subposns
[i
] = posns
[i
]->item
.tree
->entries
;
153 posns
[i
] = posns
[i
]->next
;
154 src
[i
+ merge
] = &df_conflict_entry
;
160 else if (i
+ 1 < head_idx
)
162 else if (i
+ 1 > head_idx
)
167 ce
= xmalloc(ce_size
);
168 memset(ce
, 0, ce_size
);
169 ce
->ce_mode
= create_ce_mode(posns
[i
]->mode
);
170 ce
->ce_flags
= create_ce_flags(baselen
+ pathlen
,
172 memcpy(ce
->name
, base
, baselen
);
173 memcpy(ce
->name
+ baselen
, first
, pathlen
+ 1);
177 memcpy(ce
->sha1
, posns
[i
]->item
.any
->sha1
, 20);
179 subposns
[i
] = &df_conflict_list
;
180 posns
[i
] = posns
[i
]->next
;
186 printf("%s:\n", first
);
187 for (i
= 0; i
< src_size
; i
++) {
190 printf("%s\n", sha1_to_hex(src
[i
]->sha1
));
197 printf("Added %d entries\n", ret
);
201 for (i
= 0; i
< src_size
; i
++) {
203 add_cache_entry(src
[i
], ADD_CACHE_OK_TO_ADD
|ADD_CACHE_SKIP_DFCHECK
);
209 char *newbase
= xmalloc(baselen
+ 2 + pathlen
);
210 memcpy(newbase
, base
, baselen
);
211 memcpy(newbase
+ baselen
, first
, pathlen
);
212 newbase
[baselen
+ pathlen
] = '/';
213 newbase
[baselen
+ pathlen
+ 1] = '\0';
214 if (unpack_trees_rec(subposns
, len
, newbase
, fn
,
223 static void reject_merge(struct cache_entry
*ce
)
225 die("Entry '%s' would be overwritten by merge. Cannot merge.",
229 static void check_updates(struct cache_entry
**src
, int nr
)
231 static struct checkout state
= {
237 unsigned short mask
= htons(CE_UPDATE
);
239 struct cache_entry
*ce
= *src
++;
245 if (ce
->ce_flags
& mask
) {
246 ce
->ce_flags
&= ~mask
;
248 checkout_entry(ce
, &state
);
253 static int unpack_trees(merge_fn_t fn
)
256 unsigned len
= object_list_length(trees
);
257 struct tree_entry_list
**posns
=
258 xmalloc(len
* sizeof(struct tree_entry_list
*));
260 struct object_list
*posn
= trees
;
262 for (i
= 0; i
< len
; i
++) {
263 posns
[i
] = ((struct tree
*) posn
->item
)->entries
;
266 if (unpack_trees_rec(posns
, len
, "", fn
, &indpos
))
269 check_updates(active_cache
, active_nr
);
273 static int list_tree(unsigned char *sha1
)
275 struct tree
*tree
= parse_tree_indirect(sha1
);
278 object_list_append(&tree
->object
, &trees
);
282 static int same(struct cache_entry
*a
, struct cache_entry
*b
)
288 return a
->ce_mode
== b
->ce_mode
&&
289 !memcmp(a
->sha1
, b
->sha1
, 20);
294 * When a CE gets turned into an unmerged entry, we
295 * want it to be up-to-date
297 static void verify_uptodate(struct cache_entry
*ce
)
301 if (!lstat(ce
->name
, &st
)) {
302 unsigned changed
= ce_match_stat(ce
, &st
);
309 die("Entry '%s' not uptodate. Cannot merge.", ce
->name
);
312 static int merged_entry(struct cache_entry
*merge
, struct cache_entry
*old
)
314 merge
->ce_flags
|= htons(CE_UPDATE
);
317 * See if we can re-use the old CE directly?
318 * That way we get the uptodate stat info.
320 * This also removes the UPDATE flag on
323 if (same(old
, merge
)) {
326 verify_uptodate(old
);
329 merge
->ce_flags
&= ~htons(CE_STAGEMASK
);
330 add_cache_entry(merge
, ADD_CACHE_OK_TO_ADD
);
334 static int deleted_entry(struct cache_entry
*ce
, struct cache_entry
*old
)
337 verify_uptodate(old
);
339 add_cache_entry(ce
, ADD_CACHE_OK_TO_ADD
);
343 static int keep_entry(struct cache_entry
*ce
)
345 add_cache_entry(ce
, ADD_CACHE_OK_TO_ADD
);
349 static int threeway_merge(struct cache_entry
**stages
)
351 struct cache_entry
*index
;
352 struct cache_entry
*head
;
353 struct cache_entry
*remote
= stages
[head_idx
+ 1];
356 int remote_match
= 0;
358 int df_conflict_head
= 0;
359 int df_conflict_remote
= 0;
361 int any_anc_missing
= 0;
364 for (i
= 1; i
< head_idx
; i
++) {
370 head
= stages
[head_idx
];
372 if (head
== &df_conflict_entry
) {
373 df_conflict_head
= 1;
377 if (remote
== &df_conflict_entry
) {
378 df_conflict_remote
= 1;
382 /* First, if there's a #16 situation, note that to prevent #13
385 if (!same(remote
, head
)) {
386 for (i
= 1; i
< head_idx
; i
++) {
387 if (same(stages
[i
], head
)) {
390 if (same(stages
[i
], remote
)) {
396 /* We start with cases where the index is allowed to match
397 * something other than the head: #14(ALT) and #2ALT, where it
398 * is permitted to match the result instead.
400 /* #14, #14ALT, #2ALT */
401 if (remote
&& !df_conflict_head
&& head_match
&& !remote_match
) {
402 if (index
&& !same(index
, remote
) && !same(index
, head
))
404 return merged_entry(remote
, index
);
407 * If we have an entry in the index cache, then we want to
408 * make sure that it matches head.
410 if (index
&& !same(index
, head
)) {
416 if (same(head
, remote
))
417 return merged_entry(head
, index
);
419 if (!df_conflict_remote
&& remote_match
&& !head_match
)
420 return merged_entry(head
, index
);
424 if (!head
&& !remote
&& any_anc_missing
)
427 /* Below are "no merge" cases, which require that the index be
428 * up-to-date to avoid the files getting overwritten with
429 * conflict resolution files.
432 verify_uptodate(index
);
435 /* #2, #3, #4, #6, #7, #9, #11. */
437 if (!head_match
|| !remote_match
) {
438 for (i
= 1; i
< head_idx
; i
++) {
440 keep_entry(stages
[i
]);
446 if (head
) { count
+= keep_entry(head
); }
447 if (remote
) { count
+= keep_entry(remote
); }
454 * The rule is to "carry forward" what is in the index without losing
455 * information across a "fast forward", favoring a successful merge
456 * over a merge failure when it makes sense. For details of the
457 * "carry forward" rule, please see <Documentation/git-read-tree.txt>.
460 static int twoway_merge(struct cache_entry
**src
)
462 struct cache_entry
*current
= src
[0];
463 struct cache_entry
*oldtree
= src
[1], *newtree
= src
[2];
466 return error("Cannot do a twoway merge of %d trees\n",
470 if ((!oldtree
&& !newtree
) || /* 4 and 5 */
471 (!oldtree
&& newtree
&&
472 same(current
, newtree
)) || /* 6 and 7 */
473 (oldtree
&& newtree
&&
474 same(oldtree
, newtree
)) || /* 14 and 15 */
475 (oldtree
&& newtree
&&
476 !same(oldtree
, newtree
) && /* 18 and 19*/
477 same(current
, newtree
))) {
478 return keep_entry(current
);
480 else if (oldtree
&& !newtree
&& same(current
, oldtree
)) {
482 return deleted_entry(oldtree
, current
);
484 else if (oldtree
&& newtree
&&
485 same(current
, oldtree
) && !same(current
, newtree
)) {
487 return merged_entry(newtree
, current
);
490 /* all other failures */
492 reject_merge(oldtree
);
494 reject_merge(current
);
496 reject_merge(newtree
);
501 return merged_entry(newtree
, current
);
503 return deleted_entry(oldtree
, current
);
510 * - take the stat information from stage0, take the data from stage1
512 static int oneway_merge(struct cache_entry
**src
)
514 struct cache_entry
*old
= src
[0];
515 struct cache_entry
*a
= src
[1];
518 return error("Cannot do a oneway merge of %d trees\n",
523 if (old
&& same(old
, a
)) {
524 return keep_entry(old
);
526 return merged_entry(a
, NULL
);
529 static int read_cache_unmerged(void)
532 struct cache_entry
**dst
;
537 for (i
= 0; i
< active_nr
; i
++) {
538 struct cache_entry
*ce
= active_cache
[i
];
547 active_nr
-= deleted
;
551 static const char read_tree_usage
[] = "git-read-tree (<sha> | -m [-u] <sha1> [<sha2> [<sha3>]])";
553 static struct cache_file cache_file
;
555 int main(int argc
, char **argv
)
557 int i
, newfd
, reset
, stage
= 0;
558 unsigned char sha1
[20];
559 merge_fn_t fn
= NULL
;
561 newfd
= hold_index_file_for_update(&cache_file
, get_index_file());
563 die("unable to create new cachefile");
567 for (i
= 1; i
< argc
; i
++) {
568 const char *arg
= argv
[i
];
570 /* "-u" means "update", meaning that a merge will update the working directory */
571 if (!strcmp(arg
, "-u")) {
576 /* This differs from "-m" in that we'll silently ignore unmerged entries */
577 if (!strcmp(arg
, "--reset")) {
579 usage(read_tree_usage
);
583 read_cache_unmerged();
587 if (!strcmp(arg
, "--head")) {
588 head_idx
= stage
- 1;
592 /* "-m" stands for "merge", meaning we start in stage 1 */
593 if (!strcmp(arg
, "-m")) {
595 usage(read_tree_usage
);
596 if (read_cache_unmerged())
597 die("you need to resolve your current index first");
603 if (get_sha1(arg
, sha1
) < 0)
604 usage(read_tree_usage
);
605 if (list_tree(sha1
) < 0)
606 die("failed to unpack tree object %s", arg
);
609 if (update
&& !merge
)
610 usage(read_tree_usage
);
613 die("just how do you expect me to merge %d trees?", stage
-1);
632 head_idx
= stage
- 2;
638 if (write_cache(newfd
, active_cache
, active_nr
) ||
639 commit_index_file(&cache_file
))
640 die("unable to write new index file");