X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=read-tree.c;h=32fb6faa1cfeecd2c1d67685cc2de8a52b447aed;hb=72fdfb50f721460e4cdff16fbe9c72d4ce6c668c;hp=390fe2f0275c05e10b64f6164d7bcad624069ed3;hpb=7dd43575f8641c8a73b1e976715056ebdc773904;p=git.git diff --git a/read-tree.c b/read-tree.c index 390fe2f0..32fb6faa 100644 --- a/read-tree.c +++ b/read-tree.c @@ -9,10 +9,17 @@ #include "object.h" #include "tree.h" +#include +#include static int merge = 0; static int update = 0; static int index_only = 0; +static int nontrivial_merge = 0; +static int trivial_merges_only = 0; +static int aggressive = 0; +static int verbose_update = 0; +static volatile int progress_update = 0; static int head_idx = -1; static int merge_size = 0; @@ -235,6 +242,57 @@ static void reject_merge(struct cache_entry *ce) ce->name); } +/* Unlink the last component and attempt to remove leading + * directories, in case this unlink is the removal of the + * last entry in the directory -- empty directories are removed. + */ +static void unlink_entry(char *name) +{ + char *cp, *prev; + + if (unlink(name)) + return; + prev = NULL; + while (1) { + int status; + cp = strrchr(name, '/'); + if (prev) + *prev = '/'; + if (!cp) + break; + + *cp = 0; + status = rmdir(name); + if (status) { + *cp = '/'; + break; + } + prev = cp; + } +} + +static void progress_interval(int signum) +{ + progress_update = 1; +} + +static void setup_progress_signal(void) +{ + struct sigaction sa; + struct itimerval v; + + memset(&sa, 0, sizeof(sa)); + sa.sa_handler = progress_interval; + sigemptyset(&sa.sa_mask); + sa.sa_flags = SA_RESTART; + sigaction(SIGALRM, &sa, NULL); + + v.it_interval.tv_sec = 1; + v.it_interval.tv_usec = 0; + v.it_value = v.it_interval; + setitimer(ITIMER_REAL, &v, NULL); +} + static void check_updates(struct cache_entry **src, int nr) { static struct checkout state = { @@ -244,11 +302,46 @@ static void check_updates(struct cache_entry **src, int nr) .refresh_cache = 1, }; unsigned short mask = htons(CE_UPDATE); + unsigned last_percent = 200, cnt = 0, total = 0; + + if (update && verbose_update) { + for (total = cnt = 0; cnt < nr; cnt++) { + struct cache_entry *ce = src[cnt]; + if (!ce->ce_mode || ce->ce_flags & mask) + total++; + } + + /* Don't bother doing this for very small updates */ + if (total < 250) + total = 0; + + if (total) { + fprintf(stderr, "Checking files out...\n"); + setup_progress_signal(); + progress_update = 1; + } + cnt = 0; + } + while (nr--) { struct cache_entry *ce = *src++; + + if (total) { + if (!ce->ce_mode || ce->ce_flags & mask) { + unsigned percent; + cnt++; + percent = (cnt * 100) / total; + if (percent != last_percent || + progress_update) { + fprintf(stderr, "%4u%% (%u/%u) done\r", + percent, cnt, total); + last_percent = percent; + } + } + } if (!ce->ce_mode) { if (update) - unlink(ce->name); + unlink_entry(ce->name); continue; } if (ce->ce_flags & mask) { @@ -257,23 +350,33 @@ static void check_updates(struct cache_entry **src, int nr) checkout_entry(ce, &state); } } + if (total) { + signal(SIGALRM, SIG_IGN); + fputc('\n', stderr); + } } static int unpack_trees(merge_fn_t fn) { int indpos = 0; unsigned len = object_list_length(trees); - struct tree_entry_list **posns = - xmalloc(len * sizeof(struct tree_entry_list *)); + struct tree_entry_list **posns; int i; struct object_list *posn = trees; merge_size = len; - for (i = 0; i < len; i++) { - posns[i] = ((struct tree *) posn->item)->entries; - posn = posn->next; + + if (len) { + posns = xmalloc(len * sizeof(struct tree_entry_list *)); + for (i = 0; i < len; i++) { + posns[i] = ((struct tree *) posn->item)->entries; + posn = posn->next; + } + if (unpack_trees_rec(posns, len, "", fn, &indpos)) + return -1; } - if (unpack_trees_rec(posns, len, "", fn, &indpos)) - return -1; + + if (trivial_merges_only && nontrivial_merge) + die("Merge requires file-level merging"); check_updates(active_cache, active_nr); return 0; @@ -387,11 +490,14 @@ static int threeway_merge(struct cache_entry **stages) int df_conflict_remote = 0; int any_anc_missing = 0; + int no_anc_exists = 1; int i; for (i = 1; i < head_idx; i++) { if (!stages[i]) any_anc_missing = 1; + else + no_anc_exists = 0; } index = stages[0]; @@ -452,6 +558,31 @@ static int threeway_merge(struct cache_entry **stages) if (!head && !remote && any_anc_missing) return 0; + /* Under the new "aggressive" rule, we resolve mostly trivial + * cases that we historically had git-merge-one-file resolve. + */ + if (aggressive) { + int head_deleted = !head && !df_conflict_head; + int remote_deleted = !remote && !df_conflict_remote; + /* + * Deleted in both. + * Deleted in one and unchanged in the other. + */ + if ((head_deleted && remote_deleted) || + (head_deleted && remote && remote_match) || + (remote_deleted && head && head_match)) { + if (index) + return deleted_entry(index, index); + return 0; + } + /* + * Added in both, identically. + */ + if (no_anc_exists && head && remote && same(head, remote)) + return merged_entry(head, index); + + } + /* Below are "no merge" cases, which require that the index be * up-to-date to avoid the files getting overwritten with * conflict resolution files. @@ -460,6 +591,8 @@ static int threeway_merge(struct cache_entry **stages) verify_uptodate(index); } + nontrivial_merge = 1; + /* #2, #3, #4, #6, #7, #9, #11. */ count = 0; if (!head_match || !remote_match) { @@ -498,7 +631,7 @@ static int twoway_merge(struct cache_entry **src) struct cache_entry *oldtree = src[1], *newtree = src[2]; if (merge_size != 2) - return error("Cannot do a twoway merge of %d trees\n", + return error("Cannot do a twoway merge of %d trees", merge_size); if (current) { @@ -550,7 +683,7 @@ static int oneway_merge(struct cache_entry **src) struct cache_entry *a = src[1]; if (merge_size != 1) - return error("Cannot do a oneway merge of %d trees\n", + return error("Cannot do a oneway merge of %d trees", merge_size); if (!a) @@ -593,10 +726,14 @@ int main(int argc, char **argv) unsigned char sha1[20]; merge_fn_t fn = NULL; + setup_git_directory(); + newfd = hold_index_file_for_update(&cache_file, get_index_file()); if (newfd < 0) die("unable to create new cachefile"); + git_config(git_default_config); + merge = 0; reset = 0; for (i = 1; i < argc; i++) { @@ -610,6 +747,11 @@ int main(int argc, char **argv) continue; } + if (!strcmp(arg, "-v")) { + verbose_update = 1; + continue; + } + /* "-i" means "index only", meaning that a merge will * not even look at the working tree. */ @@ -629,6 +771,16 @@ int main(int argc, char **argv) continue; } + if (!strcmp(arg, "--trivial")) { + trivial_merges_only = 1; + continue; + } + + if (!strcmp(arg, "--aggressive")) { + aggressive = 1; + continue; + } + /* "-m" stands for "merge", meaning we start in stage 1 */ if (!strcmp(arg, "-m")) { if (stage || merge)