5 #include "cache-tree.h"
6 #include "unpack-trees.h"
10 struct tree_entry_list
{
11 struct tree_entry_list
*next
;
12 unsigned directory
: 1;
13 unsigned executable
: 1;
17 const unsigned char *sha1
;
20 static struct tree_entry_list
*create_tree_entry_list(struct tree
*tree
)
22 struct tree_desc desc
;
23 struct name_entry one
;
24 struct tree_entry_list
*ret
= NULL
;
25 struct tree_entry_list
**list_p
= &ret
;
27 if (!tree
->object
.parsed
)
30 init_tree_desc(&desc
, tree
->buffer
, tree
->size
);
32 while (tree_entry(&desc
, &one
)) {
33 struct tree_entry_list
*entry
;
35 entry
= xmalloc(sizeof(struct tree_entry_list
));
36 entry
->name
= one
.path
;
37 entry
->sha1
= one
.sha1
;
38 entry
->mode
= one
.mode
;
39 entry
->directory
= S_ISDIR(one
.mode
) != 0;
40 entry
->executable
= (one
.mode
& S_IXUSR
) != 0;
41 entry
->symlink
= S_ISLNK(one
.mode
) != 0;
45 list_p
= &entry
->next
;
50 static int entcmp(const char *name1
, int dir1
, const char *name2
, int dir2
)
52 int len1
= strlen(name1
);
53 int len2
= strlen(name2
);
54 int len
= len1
< len2
? len1
: len2
;
55 int ret
= memcmp(name1
, name2
, len
);
65 ret
= (c1
< c2
) ? -1 : (c1
> c2
) ? 1 : 0;
71 static int unpack_trees_rec(struct tree_entry_list
**posns
, int len
,
72 const char *base
, struct unpack_trees_options
*o
,
73 struct tree_entry_list
*df_conflict_list
)
75 int baselen
= strlen(base
);
76 int src_size
= len
+ 1;
81 i_stk
= push_exclude_per_directory(o
->dir
, base
, strlen(base
));
89 struct tree_entry_list
**subposns
;
90 struct cache_entry
**src
;
96 /* Find the first name in the input. */
101 /* Check the cache */
102 if (o
->merge
&& o
->pos
< active_nr
) {
103 /* This is a bit tricky: */
104 /* If the index has a subdirectory (with
105 * contents) as the first name, it'll get a
106 * filename like "foo/bar". But that's after
107 * "foo", so the entry in trees will get
108 * handled first, at which point we'll go into
109 * "foo", and deal with "bar" from the index,
110 * because the base will be "foo/". The only
111 * way we can actually have "foo/bar" first of
112 * all the things is if the trees don't
113 * contain "foo" at all, in which case we'll
114 * handle "foo/bar" without going into the
115 * directory, but that's fine (and will return
116 * an error anyway, with the added unknown
120 cache_name
= active_cache
[o
->pos
]->name
;
121 if (strlen(cache_name
) > baselen
&&
122 !memcmp(cache_name
, base
, baselen
)) {
123 cache_name
+= baselen
;
132 printf("index %s\n", first
);
134 for (i
= 0; i
< len
; i
++) {
135 if (!posns
[i
] || posns
[i
] == df_conflict_list
)
138 printf("%d %s\n", i
+ 1, posns
[i
]->name
);
140 if (!first
|| entcmp(first
, firstdir
,
142 posns
[i
]->directory
) > 0) {
143 first
= posns
[i
]->name
;
144 firstdir
= posns
[i
]->directory
;
147 /* No name means we're done */
149 goto leave_directory
;
151 pathlen
= strlen(first
);
152 ce_size
= cache_entry_size(baselen
+ pathlen
);
154 src
= xcalloc(src_size
, sizeof(struct cache_entry
*));
156 subposns
= xcalloc(len
, sizeof(struct tree_list_entry
*));
158 if (cache_name
&& !strcmp(cache_name
, first
)) {
160 src
[0] = active_cache
[o
->pos
];
161 remove_cache_entry_at(o
->pos
);
164 for (i
= 0; i
< len
; i
++) {
165 struct cache_entry
*ce
;
168 (posns
[i
] != df_conflict_list
&&
169 strcmp(first
, posns
[i
]->name
))) {
173 if (posns
[i
] == df_conflict_list
) {
174 src
[i
+ o
->merge
] = o
->df_conflict_entry
;
178 if (posns
[i
]->directory
) {
179 struct tree
*tree
= lookup_tree(posns
[i
]->sha1
);
182 subposns
[i
] = create_tree_entry_list(tree
);
183 posns
[i
] = posns
[i
]->next
;
184 src
[i
+ o
->merge
] = o
->df_conflict_entry
;
190 else if (i
+ 1 < o
->head_idx
)
192 else if (i
+ 1 > o
->head_idx
)
197 ce
= xcalloc(1, ce_size
);
198 ce
->ce_mode
= create_ce_mode(posns
[i
]->mode
);
199 ce
->ce_flags
= create_ce_flags(baselen
+ pathlen
,
201 memcpy(ce
->name
, base
, baselen
);
202 memcpy(ce
->name
+ baselen
, first
, pathlen
+ 1);
206 hashcpy(ce
->sha1
, posns
[i
]->sha1
);
207 src
[i
+ o
->merge
] = ce
;
208 subposns
[i
] = df_conflict_list
;
209 posns
[i
] = posns
[i
]->next
;
216 printf("%s:\n", first
);
217 for (i
= 0; i
< src_size
; i
++) {
220 printf("%s\n", sha1_to_hex(src
[i
]->sha1
));
228 printf("Added %d entries\n", ret
);
232 for (i
= 0; i
< src_size
; i
++) {
234 add_cache_entry(src
[i
], ADD_CACHE_OK_TO_ADD
|ADD_CACHE_SKIP_DFCHECK
);
240 char *newbase
= xmalloc(baselen
+ 2 + pathlen
);
241 memcpy(newbase
, base
, baselen
);
242 memcpy(newbase
+ baselen
, first
, pathlen
);
243 newbase
[baselen
+ pathlen
] = '/';
244 newbase
[baselen
+ pathlen
+ 1] = '\0';
245 if (unpack_trees_rec(subposns
, len
, newbase
, o
,
248 goto leave_directory
;
258 pop_exclude_per_directory(o
->dir
, i_stk
);
262 /* Unlink the last component and attempt to remove leading
263 * directories, in case this unlink is the removal of the
264 * last entry in the directory -- empty directories are removed.
266 static void unlink_entry(char *name
)
275 cp
= strrchr(name
, '/');
282 status
= rmdir(name
);
291 static volatile sig_atomic_t progress_update
;
293 static void progress_interval(int signum
)
298 static void setup_progress_signal(void)
303 memset(&sa
, 0, sizeof(sa
));
304 sa
.sa_handler
= progress_interval
;
305 sigemptyset(&sa
.sa_mask
);
306 sa
.sa_flags
= SA_RESTART
;
307 sigaction(SIGALRM
, &sa
, NULL
);
309 v
.it_interval
.tv_sec
= 1;
310 v
.it_interval
.tv_usec
= 0;
311 v
.it_value
= v
.it_interval
;
312 setitimer(ITIMER_REAL
, &v
, NULL
);
315 static struct checkout state
;
316 static void check_updates(struct cache_entry
**src
, int nr
,
317 struct unpack_trees_options
*o
)
319 unsigned short mask
= htons(CE_UPDATE
);
320 unsigned last_percent
= 200, cnt
= 0, total
= 0;
322 if (o
->update
&& o
->verbose_update
) {
323 for (total
= cnt
= 0; cnt
< nr
; cnt
++) {
324 struct cache_entry
*ce
= src
[cnt
];
325 if (!ce
->ce_mode
|| ce
->ce_flags
& mask
)
329 /* Don't bother doing this for very small updates */
334 fprintf(stderr
, "Checking files out...\n");
335 setup_progress_signal();
342 struct cache_entry
*ce
= *src
++;
345 if (!ce
->ce_mode
|| ce
->ce_flags
& mask
) {
348 percent
= (cnt
* 100) / total
;
349 if (percent
!= last_percent
||
351 fprintf(stderr
, "%4u%% (%u/%u) done\r",
352 percent
, cnt
, total
);
353 last_percent
= percent
;
360 unlink_entry(ce
->name
);
363 if (ce
->ce_flags
& mask
) {
364 ce
->ce_flags
&= ~mask
;
366 checkout_entry(ce
, &state
, NULL
);
370 signal(SIGALRM
, SIG_IGN
);
375 int unpack_trees(struct object_list
*trees
, struct unpack_trees_options
*o
)
377 unsigned len
= object_list_length(trees
);
378 struct tree_entry_list
**posns
;
380 struct object_list
*posn
= trees
;
381 struct tree_entry_list df_conflict_list
;
382 static struct cache_entry
*dfc
;
384 memset(&df_conflict_list
, 0, sizeof(df_conflict_list
));
385 df_conflict_list
.next
= &df_conflict_list
;
386 memset(&state
, 0, sizeof(state
));
390 state
.refresh_cache
= 1;
395 dfc
= xcalloc(1, sizeof(struct cache_entry
) + 1);
396 o
->df_conflict_entry
= dfc
;
399 posns
= xmalloc(len
* sizeof(struct tree_entry_list
*));
400 for (i
= 0; i
< len
; i
++) {
401 posns
[i
] = create_tree_entry_list((struct tree
*) posn
->item
);
404 if (unpack_trees_rec(posns
, len
, o
->prefix
? o
->prefix
: "",
405 o
, &df_conflict_list
))
409 if (o
->trivial_merges_only
&& o
->nontrivial_merge
)
410 die("Merge requires file-level merging");
412 check_updates(active_cache
, active_nr
, o
);
416 /* Here come the merge functions */
418 static void reject_merge(struct cache_entry
*ce
)
420 die("Entry '%s' would be overwritten by merge. Cannot merge.",
424 static int same(struct cache_entry
*a
, struct cache_entry
*b
)
430 return a
->ce_mode
== b
->ce_mode
&&
431 !hashcmp(a
->sha1
, b
->sha1
);
436 * When a CE gets turned into an unmerged entry, we
437 * want it to be up-to-date
439 static void verify_uptodate(struct cache_entry
*ce
,
440 struct unpack_trees_options
*o
)
444 if (o
->index_only
|| o
->reset
)
447 if (!lstat(ce
->name
, &st
)) {
448 unsigned changed
= ce_match_stat(ce
, &st
, 1);
454 ce
->ce_flags
|= htons(CE_UPDATE
);
459 die("Entry '%s' not uptodate. Cannot merge.", ce
->name
);
462 static void invalidate_ce_path(struct cache_entry
*ce
)
465 cache_tree_invalidate_path(active_cache_tree
, ce
->name
);
469 * We do not want to remove or overwrite a working tree file that
470 * is not tracked, unless it is ignored.
472 static void verify_absent(const char *path
, const char *action
,
473 struct unpack_trees_options
*o
)
477 if (o
->index_only
|| o
->reset
|| !o
->update
)
479 if (!lstat(path
, &st
) && !(o
->dir
&& excluded(o
->dir
, path
)))
480 die("Untracked working tree file '%s' "
481 "would be %s by merge.", path
, action
);
484 static int merged_entry(struct cache_entry
*merge
, struct cache_entry
*old
,
485 struct unpack_trees_options
*o
)
487 merge
->ce_flags
|= htons(CE_UPDATE
);
490 * See if we can re-use the old CE directly?
491 * That way we get the uptodate stat info.
493 * This also removes the UPDATE flag on
496 if (same(old
, merge
)) {
499 verify_uptodate(old
, o
);
500 invalidate_ce_path(old
);
504 verify_absent(merge
->name
, "overwritten", o
);
505 invalidate_ce_path(merge
);
508 merge
->ce_flags
&= ~htons(CE_STAGEMASK
);
509 add_cache_entry(merge
, ADD_CACHE_OK_TO_ADD
|ADD_CACHE_OK_TO_REPLACE
);
513 static int deleted_entry(struct cache_entry
*ce
, struct cache_entry
*old
,
514 struct unpack_trees_options
*o
)
517 verify_uptodate(old
, o
);
519 verify_absent(ce
->name
, "removed", o
);
521 add_cache_entry(ce
, ADD_CACHE_OK_TO_ADD
|ADD_CACHE_OK_TO_REPLACE
);
522 invalidate_ce_path(ce
);
526 static int keep_entry(struct cache_entry
*ce
, struct unpack_trees_options
*o
)
528 add_cache_entry(ce
, ADD_CACHE_OK_TO_ADD
);
533 static void show_stage_entry(FILE *o
,
534 const char *label
, const struct cache_entry
*ce
)
537 fprintf(o
, "%s (missing)\n", label
);
539 fprintf(o
, "%s%06o %s %d\t%s\n",
542 sha1_to_hex(ce
->sha1
),
548 int threeway_merge(struct cache_entry
**stages
,
549 struct unpack_trees_options
*o
)
551 struct cache_entry
*index
;
552 struct cache_entry
*head
;
553 struct cache_entry
*remote
= stages
[o
->head_idx
+ 1];
556 int remote_match
= 0;
557 const char *path
= NULL
;
559 int df_conflict_head
= 0;
560 int df_conflict_remote
= 0;
562 int any_anc_missing
= 0;
563 int no_anc_exists
= 1;
566 for (i
= 1; i
< o
->head_idx
; i
++) {
571 path
= stages
[i
]->name
;
577 head
= stages
[o
->head_idx
];
579 if (head
== o
->df_conflict_entry
) {
580 df_conflict_head
= 1;
584 if (remote
== o
->df_conflict_entry
) {
585 df_conflict_remote
= 1;
596 /* First, if there's a #16 situation, note that to prevent #13
599 if (!same(remote
, head
)) {
600 for (i
= 1; i
< o
->head_idx
; i
++) {
601 if (same(stages
[i
], head
)) {
604 if (same(stages
[i
], remote
)) {
610 /* We start with cases where the index is allowed to match
611 * something other than the head: #14(ALT) and #2ALT, where it
612 * is permitted to match the result instead.
614 /* #14, #14ALT, #2ALT */
615 if (remote
&& !df_conflict_head
&& head_match
&& !remote_match
) {
616 if (index
&& !same(index
, remote
) && !same(index
, head
))
618 return merged_entry(remote
, index
, o
);
621 * If we have an entry in the index cache, then we want to
622 * make sure that it matches head.
624 if (index
&& !same(index
, head
)) {
630 if (same(head
, remote
))
631 return merged_entry(head
, index
, o
);
633 if (!df_conflict_remote
&& remote_match
&& !head_match
)
634 return merged_entry(head
, index
, o
);
638 if (!head
&& !remote
&& any_anc_missing
)
641 /* Under the new "aggressive" rule, we resolve mostly trivial
642 * cases that we historically had git-merge-one-file resolve.
645 int head_deleted
= !head
&& !df_conflict_head
;
646 int remote_deleted
= !remote
&& !df_conflict_remote
;
649 * Deleted in one and unchanged in the other.
651 if ((head_deleted
&& remote_deleted
) ||
652 (head_deleted
&& remote
&& remote_match
) ||
653 (remote_deleted
&& head
&& head_match
)) {
655 return deleted_entry(index
, index
, o
);
656 else if (path
&& !head_deleted
)
657 verify_absent(path
, "removed", o
);
661 * Added in both, identically.
663 if (no_anc_exists
&& head
&& remote
&& same(head
, remote
))
664 return merged_entry(head
, index
, o
);
668 /* Below are "no merge" cases, which require that the index be
669 * up-to-date to avoid the files getting overwritten with
670 * conflict resolution files.
673 verify_uptodate(index
, o
);
676 o
->nontrivial_merge
= 1;
678 /* #2, #3, #4, #6, #7, #9, #11. */
680 if (!head_match
|| !remote_match
) {
681 for (i
= 1; i
< o
->head_idx
; i
++) {
683 keep_entry(stages
[i
], o
);
691 fprintf(stderr
, "read-tree: warning #16 detected\n");
692 show_stage_entry(stderr
, "head ", stages
[head_match
]);
693 show_stage_entry(stderr
, "remote ", stages
[remote_match
]);
696 if (head
) { count
+= keep_entry(head
, o
); }
697 if (remote
) { count
+= keep_entry(remote
, o
); }
704 * The rule is to "carry forward" what is in the index without losing
705 * information across a "fast forward", favoring a successful merge
706 * over a merge failure when it makes sense. For details of the
707 * "carry forward" rule, please see <Documentation/git-read-tree.txt>.
710 int twoway_merge(struct cache_entry
**src
,
711 struct unpack_trees_options
*o
)
713 struct cache_entry
*current
= src
[0];
714 struct cache_entry
*oldtree
= src
[1];
715 struct cache_entry
*newtree
= src
[2];
717 if (o
->merge_size
!= 2)
718 return error("Cannot do a twoway merge of %d trees",
721 if (oldtree
== o
->df_conflict_entry
)
723 if (newtree
== o
->df_conflict_entry
)
727 if ((!oldtree
&& !newtree
) || /* 4 and 5 */
728 (!oldtree
&& newtree
&&
729 same(current
, newtree
)) || /* 6 and 7 */
730 (oldtree
&& newtree
&&
731 same(oldtree
, newtree
)) || /* 14 and 15 */
732 (oldtree
&& newtree
&&
733 !same(oldtree
, newtree
) && /* 18 and 19 */
734 same(current
, newtree
))) {
735 return keep_entry(current
, o
);
737 else if (oldtree
&& !newtree
&& same(current
, oldtree
)) {
739 return deleted_entry(oldtree
, current
, o
);
741 else if (oldtree
&& newtree
&&
742 same(current
, oldtree
) && !same(current
, newtree
)) {
744 return merged_entry(newtree
, current
, o
);
747 /* all other failures */
749 reject_merge(oldtree
);
751 reject_merge(current
);
753 reject_merge(newtree
);
758 return merged_entry(newtree
, current
, o
);
760 return deleted_entry(oldtree
, current
, o
);
766 * Keep the index entries at stage0, collapse stage1 but make sure
767 * stage0 does not have anything there.
769 int bind_merge(struct cache_entry
**src
,
770 struct unpack_trees_options
*o
)
772 struct cache_entry
*old
= src
[0];
773 struct cache_entry
*a
= src
[1];
775 if (o
->merge_size
!= 1)
776 return error("Cannot do a bind merge of %d trees\n",
779 die("Entry '%s' overlaps. Cannot bind.", a
->name
);
781 return keep_entry(old
, o
);
783 return merged_entry(a
, NULL
, o
);
790 * - take the stat information from stage0, take the data from stage1
792 int oneway_merge(struct cache_entry
**src
,
793 struct unpack_trees_options
*o
)
795 struct cache_entry
*old
= src
[0];
796 struct cache_entry
*a
= src
[1];
798 if (o
->merge_size
!= 1)
799 return error("Cannot do a oneway merge of %d trees",
803 return deleted_entry(old
, old
, o
);
804 if (old
&& same(old
, a
)) {
807 if (lstat(old
->name
, &st
) ||
808 ce_match_stat(old
, &st
, 1))
809 old
->ce_flags
|= htons(CE_UPDATE
);
811 return keep_entry(old
, o
);
813 return merged_entry(a
, old
, o
);