5 #include "cache-tree.h"
6 #include "unpack-trees.h"
12 struct tree_entry_list
{
13 struct tree_entry_list
*next
;
16 const unsigned char *sha1
;
19 static struct tree_entry_list
*create_tree_entry_list(struct tree
*tree
)
21 struct tree_desc desc
;
22 struct name_entry one
;
23 struct tree_entry_list
*ret
= NULL
;
24 struct tree_entry_list
**list_p
= &ret
;
26 if (!tree
->object
.parsed
)
29 init_tree_desc(&desc
, tree
->buffer
, tree
->size
);
31 while (tree_entry(&desc
, &one
)) {
32 struct tree_entry_list
*entry
;
34 entry
= xmalloc(sizeof(struct tree_entry_list
));
35 entry
->name
= one
.path
;
36 entry
->sha1
= one
.sha1
;
37 entry
->mode
= one
.mode
;
41 list_p
= &entry
->next
;
46 static int entcmp(const char *name1
, int dir1
, const char *name2
, int dir2
)
48 int len1
= strlen(name1
);
49 int len2
= strlen(name2
);
50 int len
= len1
< len2
? len1
: len2
;
51 int ret
= memcmp(name1
, name2
, len
);
61 ret
= (c1
< c2
) ? -1 : (c1
> c2
) ? 1 : 0;
67 static int unpack_trees_rec(struct tree_entry_list
**posns
, int len
,
68 const char *base
, struct unpack_trees_options
*o
,
69 struct tree_entry_list
*df_conflict_list
)
71 int baselen
= strlen(base
);
72 int src_size
= len
+ 1;
77 i_stk
= push_exclude_per_directory(o
->dir
, base
, strlen(base
));
85 struct tree_entry_list
**subposns
;
86 struct cache_entry
**src
;
92 /* Find the first name in the input. */
98 if (o
->merge
&& o
->pos
< active_nr
) {
99 /* This is a bit tricky: */
100 /* If the index has a subdirectory (with
101 * contents) as the first name, it'll get a
102 * filename like "foo/bar". But that's after
103 * "foo", so the entry in trees will get
104 * handled first, at which point we'll go into
105 * "foo", and deal with "bar" from the index,
106 * because the base will be "foo/". The only
107 * way we can actually have "foo/bar" first of
108 * all the things is if the trees don't
109 * contain "foo" at all, in which case we'll
110 * handle "foo/bar" without going into the
111 * directory, but that's fine (and will return
112 * an error anyway, with the added unknown
116 cache_name
= active_cache
[o
->pos
]->name
;
117 if (strlen(cache_name
) > baselen
&&
118 !memcmp(cache_name
, base
, baselen
)) {
119 cache_name
+= baselen
;
128 printf("index %s\n", first
);
130 for (i
= 0; i
< len
; i
++) {
131 if (!posns
[i
] || posns
[i
] == df_conflict_list
)
134 printf("%d %s\n", i
+ 1, posns
[i
]->name
);
136 if (!first
|| entcmp(first
, firstdir
,
138 S_ISDIR(posns
[i
]->mode
)) > 0) {
139 first
= posns
[i
]->name
;
140 firstdir
= S_ISDIR(posns
[i
]->mode
);
143 /* No name means we're done */
145 goto leave_directory
;
147 pathlen
= strlen(first
);
148 ce_size
= cache_entry_size(baselen
+ pathlen
);
150 src
= xcalloc(src_size
, sizeof(struct cache_entry
*));
152 subposns
= xcalloc(len
, sizeof(struct tree_list_entry
*));
154 if (cache_name
&& !strcmp(cache_name
, first
)) {
156 src
[0] = active_cache
[o
->pos
];
157 remove_cache_entry_at(o
->pos
);
160 for (i
= 0; i
< len
; i
++) {
161 struct cache_entry
*ce
;
164 (posns
[i
] != df_conflict_list
&&
165 strcmp(first
, posns
[i
]->name
))) {
169 if (posns
[i
] == df_conflict_list
) {
170 src
[i
+ o
->merge
] = o
->df_conflict_entry
;
174 if (S_ISDIR(posns
[i
]->mode
)) {
175 struct tree
*tree
= lookup_tree(posns
[i
]->sha1
);
178 subposns
[i
] = create_tree_entry_list(tree
);
179 posns
[i
] = posns
[i
]->next
;
180 src
[i
+ o
->merge
] = o
->df_conflict_entry
;
186 else if (i
+ 1 < o
->head_idx
)
188 else if (i
+ 1 > o
->head_idx
)
193 ce
= xcalloc(1, ce_size
);
194 ce
->ce_mode
= create_ce_mode(posns
[i
]->mode
);
195 ce
->ce_flags
= create_ce_flags(baselen
+ pathlen
,
197 memcpy(ce
->name
, base
, baselen
);
198 memcpy(ce
->name
+ baselen
, first
, pathlen
+ 1);
202 hashcpy(ce
->sha1
, posns
[i
]->sha1
);
203 src
[i
+ o
->merge
] = ce
;
204 subposns
[i
] = df_conflict_list
;
205 posns
[i
] = posns
[i
]->next
;
212 printf("%s:\n", first
);
213 for (i
= 0; i
< src_size
; i
++) {
216 printf("%s\n", sha1_to_hex(src
[i
]->sha1
));
224 printf("Added %d entries\n", ret
);
228 for (i
= 0; i
< src_size
; i
++) {
230 add_cache_entry(src
[i
], ADD_CACHE_OK_TO_ADD
|ADD_CACHE_SKIP_DFCHECK
);
236 char *newbase
= xmalloc(baselen
+ 2 + pathlen
);
237 memcpy(newbase
, base
, baselen
);
238 memcpy(newbase
+ baselen
, first
, pathlen
);
239 newbase
[baselen
+ pathlen
] = '/';
240 newbase
[baselen
+ pathlen
+ 1] = '\0';
241 if (unpack_trees_rec(subposns
, len
, newbase
, o
,
244 goto leave_directory
;
254 pop_exclude_per_directory(o
->dir
, i_stk
);
258 /* Unlink the last component and attempt to remove leading
259 * directories, in case this unlink is the removal of the
260 * last entry in the directory -- empty directories are removed.
262 static void unlink_entry(char *name
, char *last_symlink
)
266 if (has_symlink_leading_path(name
, last_symlink
))
273 cp
= strrchr(name
, '/');
280 status
= rmdir(name
);
289 static struct checkout state
;
290 static void check_updates(struct cache_entry
**src
, int nr
,
291 struct unpack_trees_options
*o
)
293 unsigned short mask
= htons(CE_UPDATE
);
294 unsigned cnt
= 0, total
= 0;
295 struct progress progress
;
296 char last_symlink
[PATH_MAX
];
298 if (o
->update
&& o
->verbose_update
) {
299 for (total
= cnt
= 0; cnt
< nr
; cnt
++) {
300 struct cache_entry
*ce
= src
[cnt
];
301 if (!ce
->ce_mode
|| ce
->ce_flags
& mask
)
305 start_progress_delay(&progress
, "Checking %u files out...",
310 *last_symlink
= '\0';
312 struct cache_entry
*ce
= *src
++;
315 if (!ce
->ce_mode
|| ce
->ce_flags
& mask
)
316 display_progress(&progress
, ++cnt
);
319 unlink_entry(ce
->name
, last_symlink
);
322 if (ce
->ce_flags
& mask
) {
323 ce
->ce_flags
&= ~mask
;
325 checkout_entry(ce
, &state
, NULL
);
326 *last_symlink
= '\0';
331 stop_progress(&progress
);;
334 int unpack_trees(struct object_list
*trees
, struct unpack_trees_options
*o
)
336 unsigned len
= object_list_length(trees
);
337 struct tree_entry_list
**posns
;
339 struct object_list
*posn
= trees
;
340 struct tree_entry_list df_conflict_list
;
341 static struct cache_entry
*dfc
;
343 memset(&df_conflict_list
, 0, sizeof(df_conflict_list
));
344 df_conflict_list
.next
= &df_conflict_list
;
345 memset(&state
, 0, sizeof(state
));
349 state
.refresh_cache
= 1;
354 dfc
= xcalloc(1, sizeof(struct cache_entry
) + 1);
355 o
->df_conflict_entry
= dfc
;
358 posns
= xmalloc(len
* sizeof(struct tree_entry_list
*));
359 for (i
= 0; i
< len
; i
++) {
360 posns
[i
] = create_tree_entry_list((struct tree
*) posn
->item
);
363 if (unpack_trees_rec(posns
, len
, o
->prefix
? o
->prefix
: "",
364 o
, &df_conflict_list
))
368 if (o
->trivial_merges_only
&& o
->nontrivial_merge
)
369 die("Merge requires file-level merging");
371 check_updates(active_cache
, active_nr
, o
);
375 /* Here come the merge functions */
377 static void reject_merge(struct cache_entry
*ce
)
379 die("Entry '%s' would be overwritten by merge. Cannot merge.",
383 static int same(struct cache_entry
*a
, struct cache_entry
*b
)
389 return a
->ce_mode
== b
->ce_mode
&&
390 !hashcmp(a
->sha1
, b
->sha1
);
395 * When a CE gets turned into an unmerged entry, we
396 * want it to be up-to-date
398 static void verify_uptodate(struct cache_entry
*ce
,
399 struct unpack_trees_options
*o
)
403 if (o
->index_only
|| o
->reset
)
406 if (!lstat(ce
->name
, &st
)) {
407 unsigned changed
= ce_match_stat(ce
, &st
, 1);
411 * NEEDSWORK: the current default policy is to allow
412 * submodule to be out of sync wrt the supermodule
413 * index. This needs to be tightened later for
414 * submodules that are marked to be automatically
417 if (S_ISGITLINK(ntohl(ce
->ce_mode
)))
423 die("Entry '%s' not uptodate. Cannot merge.", ce
->name
);
426 static void invalidate_ce_path(struct cache_entry
*ce
)
429 cache_tree_invalidate_path(active_cache_tree
, ce
->name
);
433 * Check that checking out ce->sha1 in subdir ce->name is not
434 * going to overwrite any working files.
436 * Currently, git does not checkout subprojects during a superproject
437 * checkout, so it is not going to overwrite anything.
439 static int verify_clean_submodule(struct cache_entry
*ce
, const char *action
,
440 struct unpack_trees_options
*o
)
445 static int verify_clean_subdirectory(struct cache_entry
*ce
, const char *action
,
446 struct unpack_trees_options
*o
)
449 * we are about to extract "ce->name"; we would not want to lose
450 * anything in the existing directory there.
457 unsigned char sha1
[20];
459 if (S_ISGITLINK(ntohl(ce
->ce_mode
)) &&
460 resolve_gitlink_ref(ce
->name
, "HEAD", sha1
) == 0) {
461 /* If we are not going to update the submodule, then
464 if (!hashcmp(sha1
, ce
->sha1
))
466 return verify_clean_submodule(ce
, action
, o
);
470 * First let's make sure we do not have a local modification
473 namelen
= strlen(ce
->name
);
474 pos
= cache_name_pos(ce
->name
, namelen
);
476 return cnt
; /* we have it as nondirectory */
478 for (i
= pos
; i
< active_nr
; i
++) {
479 struct cache_entry
*ce
= active_cache
[i
];
480 int len
= ce_namelen(ce
);
482 strncmp(ce
->name
, ce
->name
, namelen
) ||
483 ce
->name
[namelen
] != '/')
486 * ce->name is an entry in the subdirectory.
489 verify_uptodate(ce
, o
);
496 * Then we need to make sure that we do not lose a locally
497 * present file that is not ignored.
499 pathbuf
= xmalloc(namelen
+ 2);
500 memcpy(pathbuf
, ce
->name
, namelen
);
501 strcpy(pathbuf
+namelen
, "/");
503 memset(&d
, 0, sizeof(d
));
505 d
.exclude_per_dir
= o
->dir
->exclude_per_dir
;
506 i
= read_directory(&d
, ce
->name
, pathbuf
, namelen
+1, NULL
);
508 die("Updating '%s' would lose untracked files in it",
515 * We do not want to remove or overwrite a working tree file that
516 * is not tracked, unless it is ignored.
518 static void verify_absent(struct cache_entry
*ce
, const char *action
,
519 struct unpack_trees_options
*o
)
523 if (o
->index_only
|| o
->reset
|| !o
->update
)
526 if (has_symlink_leading_path(ce
->name
, NULL
))
529 if (!lstat(ce
->name
, &st
)) {
532 if (o
->dir
&& excluded(o
->dir
, ce
->name
))
534 * ce->name is explicitly excluded, so it is Ok to
538 if (S_ISDIR(st
.st_mode
)) {
540 * We are checking out path "foo" and
541 * found "foo/." in the working tree.
542 * This is tricky -- if we have modified
543 * files that are in "foo/" we would lose
546 cnt
= verify_clean_subdirectory(ce
, action
, o
);
549 * If this removed entries from the index,
550 * what that means is:
552 * (1) the caller unpack_trees_rec() saw path/foo
553 * in the index, and it has not removed it because
554 * it thinks it is handling 'path' as blob with
556 * (2) we will return "ok, we placed a merged entry
557 * in the index" which would cause o->pos to be
558 * incremented by one;
559 * (3) however, original o->pos now has 'path/foo'
560 * marked with "to be removed".
562 * We need to increment it by the number of
563 * deleted entries here.
570 * The previous round may already have decided to
571 * delete this path, which is in a subdirectory that
572 * is being replaced with a blob.
574 cnt
= cache_name_pos(ce
->name
, strlen(ce
->name
));
576 struct cache_entry
*ce
= active_cache
[cnt
];
577 if (!ce_stage(ce
) && !ce
->ce_mode
)
581 die("Untracked working tree file '%s' "
582 "would be %s by merge.", ce
->name
, action
);
586 static int merged_entry(struct cache_entry
*merge
, struct cache_entry
*old
,
587 struct unpack_trees_options
*o
)
589 merge
->ce_flags
|= htons(CE_UPDATE
);
592 * See if we can re-use the old CE directly?
593 * That way we get the uptodate stat info.
595 * This also removes the UPDATE flag on
598 if (same(old
, merge
)) {
601 verify_uptodate(old
, o
);
602 invalidate_ce_path(old
);
606 verify_absent(merge
, "overwritten", o
);
607 invalidate_ce_path(merge
);
610 merge
->ce_flags
&= ~htons(CE_STAGEMASK
);
611 add_cache_entry(merge
, ADD_CACHE_OK_TO_ADD
|ADD_CACHE_OK_TO_REPLACE
);
615 static int deleted_entry(struct cache_entry
*ce
, struct cache_entry
*old
,
616 struct unpack_trees_options
*o
)
619 verify_uptodate(old
, o
);
621 verify_absent(ce
, "removed", o
);
623 add_cache_entry(ce
, ADD_CACHE_OK_TO_ADD
|ADD_CACHE_OK_TO_REPLACE
);
624 invalidate_ce_path(ce
);
628 static int keep_entry(struct cache_entry
*ce
, struct unpack_trees_options
*o
)
630 add_cache_entry(ce
, ADD_CACHE_OK_TO_ADD
);
635 static void show_stage_entry(FILE *o
,
636 const char *label
, const struct cache_entry
*ce
)
639 fprintf(o
, "%s (missing)\n", label
);
641 fprintf(o
, "%s%06o %s %d\t%s\n",
644 sha1_to_hex(ce
->sha1
),
650 int threeway_merge(struct cache_entry
**stages
,
651 struct unpack_trees_options
*o
)
653 struct cache_entry
*index
;
654 struct cache_entry
*head
;
655 struct cache_entry
*remote
= stages
[o
->head_idx
+ 1];
658 int remote_match
= 0;
660 int df_conflict_head
= 0;
661 int df_conflict_remote
= 0;
663 int any_anc_missing
= 0;
664 int no_anc_exists
= 1;
667 for (i
= 1; i
< o
->head_idx
; i
++) {
668 if (!stages
[i
] || stages
[i
] == o
->df_conflict_entry
)
675 head
= stages
[o
->head_idx
];
677 if (head
== o
->df_conflict_entry
) {
678 df_conflict_head
= 1;
682 if (remote
== o
->df_conflict_entry
) {
683 df_conflict_remote
= 1;
687 /* First, if there's a #16 situation, note that to prevent #13
690 if (!same(remote
, head
)) {
691 for (i
= 1; i
< o
->head_idx
; i
++) {
692 if (same(stages
[i
], head
)) {
695 if (same(stages
[i
], remote
)) {
701 /* We start with cases where the index is allowed to match
702 * something other than the head: #14(ALT) and #2ALT, where it
703 * is permitted to match the result instead.
705 /* #14, #14ALT, #2ALT */
706 if (remote
&& !df_conflict_head
&& head_match
&& !remote_match
) {
707 if (index
&& !same(index
, remote
) && !same(index
, head
))
709 return merged_entry(remote
, index
, o
);
712 * If we have an entry in the index cache, then we want to
713 * make sure that it matches head.
715 if (index
&& !same(index
, head
)) {
721 if (same(head
, remote
))
722 return merged_entry(head
, index
, o
);
724 if (!df_conflict_remote
&& remote_match
&& !head_match
)
725 return merged_entry(head
, index
, o
);
729 if (!head
&& !remote
&& any_anc_missing
)
732 /* Under the new "aggressive" rule, we resolve mostly trivial
733 * cases that we historically had git-merge-one-file resolve.
736 int head_deleted
= !head
&& !df_conflict_head
;
737 int remote_deleted
= !remote
&& !df_conflict_remote
;
738 struct cache_entry
*ce
= NULL
;
747 for (i
= 1; i
< o
->head_idx
; i
++) {
748 if (stages
[i
] && stages
[i
] != o
->df_conflict_entry
) {
757 * Deleted in one and unchanged in the other.
759 if ((head_deleted
&& remote_deleted
) ||
760 (head_deleted
&& remote
&& remote_match
) ||
761 (remote_deleted
&& head
&& head_match
)) {
763 return deleted_entry(index
, index
, o
);
764 else if (ce
&& !head_deleted
)
765 verify_absent(ce
, "removed", o
);
769 * Added in both, identically.
771 if (no_anc_exists
&& head
&& remote
&& same(head
, remote
))
772 return merged_entry(head
, index
, o
);
776 /* Below are "no merge" cases, which require that the index be
777 * up-to-date to avoid the files getting overwritten with
778 * conflict resolution files.
781 verify_uptodate(index
, o
);
784 o
->nontrivial_merge
= 1;
786 /* #2, #3, #4, #6, #7, #9, #10, #11. */
788 if (!head_match
|| !remote_match
) {
789 for (i
= 1; i
< o
->head_idx
; i
++) {
790 if (stages
[i
] && stages
[i
] != o
->df_conflict_entry
) {
791 keep_entry(stages
[i
], o
);
799 fprintf(stderr
, "read-tree: warning #16 detected\n");
800 show_stage_entry(stderr
, "head ", stages
[head_match
]);
801 show_stage_entry(stderr
, "remote ", stages
[remote_match
]);
804 if (head
) { count
+= keep_entry(head
, o
); }
805 if (remote
) { count
+= keep_entry(remote
, o
); }
812 * The rule is to "carry forward" what is in the index without losing
813 * information across a "fast forward", favoring a successful merge
814 * over a merge failure when it makes sense. For details of the
815 * "carry forward" rule, please see <Documentation/git-read-tree.txt>.
818 int twoway_merge(struct cache_entry
**src
,
819 struct unpack_trees_options
*o
)
821 struct cache_entry
*current
= src
[0];
822 struct cache_entry
*oldtree
= src
[1];
823 struct cache_entry
*newtree
= src
[2];
825 if (o
->merge_size
!= 2)
826 return error("Cannot do a twoway merge of %d trees",
829 if (oldtree
== o
->df_conflict_entry
)
831 if (newtree
== o
->df_conflict_entry
)
835 if ((!oldtree
&& !newtree
) || /* 4 and 5 */
836 (!oldtree
&& newtree
&&
837 same(current
, newtree
)) || /* 6 and 7 */
838 (oldtree
&& newtree
&&
839 same(oldtree
, newtree
)) || /* 14 and 15 */
840 (oldtree
&& newtree
&&
841 !same(oldtree
, newtree
) && /* 18 and 19 */
842 same(current
, newtree
))) {
843 return keep_entry(current
, o
);
845 else if (oldtree
&& !newtree
&& same(current
, oldtree
)) {
847 return deleted_entry(oldtree
, current
, o
);
849 else if (oldtree
&& newtree
&&
850 same(current
, oldtree
) && !same(current
, newtree
)) {
852 return merged_entry(newtree
, current
, o
);
855 /* all other failures */
857 reject_merge(oldtree
);
859 reject_merge(current
);
861 reject_merge(newtree
);
866 return merged_entry(newtree
, current
, o
);
868 return deleted_entry(oldtree
, current
, o
);
874 * Keep the index entries at stage0, collapse stage1 but make sure
875 * stage0 does not have anything there.
877 int bind_merge(struct cache_entry
**src
,
878 struct unpack_trees_options
*o
)
880 struct cache_entry
*old
= src
[0];
881 struct cache_entry
*a
= src
[1];
883 if (o
->merge_size
!= 1)
884 return error("Cannot do a bind merge of %d trees\n",
887 die("Entry '%s' overlaps. Cannot bind.", a
->name
);
889 return keep_entry(old
, o
);
891 return merged_entry(a
, NULL
, o
);
898 * - take the stat information from stage0, take the data from stage1
900 int oneway_merge(struct cache_entry
**src
,
901 struct unpack_trees_options
*o
)
903 struct cache_entry
*old
= src
[0];
904 struct cache_entry
*a
= src
[1];
906 if (o
->merge_size
!= 1)
907 return error("Cannot do a oneway merge of %d trees",
911 return deleted_entry(old
, old
, o
);
912 if (old
&& same(old
, a
)) {
915 if (lstat(old
->name
, &st
) ||
916 ce_match_stat(old
, &st
, 1))
917 old
->ce_flags
|= htons(CE_UPDATE
);
919 return keep_entry(old
, o
);
921 return merged_entry(a
, old
, o
);