Andrew's git / gitweb.git / read-tree.c
?
read-tree.con commit More accurately detect header lines in read_one_header_line (f30b202)
   1/*
   2 * GIT - The information manager from hell
   3 *
   4 * Copyright (C) Linus Torvalds, 2005
   5 */
   6#define DBRT_DEBUG 1
   7
   8#include "cache.h"
   9
  10#include "object.h"
  11#include "tree.h"
  12#include <sys/time.h>
  13#include <signal.h>
  14
  15static int reset = 0;
  16static int merge = 0;
  17static int update = 0;
  18static int index_only = 0;
  19static int nontrivial_merge = 0;
  20static int trivial_merges_only = 0;
  21static int aggressive = 0;
  22static int verbose_update = 0;
  23static volatile int progress_update = 0;
  24
  25static int head_idx = -1;
  26static int merge_size = 0;
  27
  28static struct object_list *trees = NULL;
  29
  30static struct cache_entry df_conflict_entry = { 
  31};
  32
  33static struct tree_entry_list df_conflict_list = {
  34        .name = NULL,
  35        .next = &df_conflict_list
  36};
  37
  38typedef int (*merge_fn_t)(struct cache_entry **src);
  39
  40static int entcmp(char *name1, int dir1, char *name2, int dir2)
  41{
  42        int len1 = strlen(name1);
  43        int len2 = strlen(name2);
  44        int len = len1 < len2 ? len1 : len2;
  45        int ret = memcmp(name1, name2, len);
  46        unsigned char c1, c2;
  47        if (ret)
  48                return ret;
  49        c1 = name1[len];
  50        c2 = name2[len];
  51        if (!c1 && dir1)
  52                c1 = '/';
  53        if (!c2 && dir2)
  54                c2 = '/';
  55        ret = (c1 < c2) ? -1 : (c1 > c2) ? 1 : 0;
  56        if (c1 && c2 && !ret)
  57                ret = len1 - len2;
  58        return ret;
  59}
  60
  61static int unpack_trees_rec(struct tree_entry_list **posns, int len,
  62                            const char *base, merge_fn_t fn, int *indpos)
  63{
  64        int baselen = strlen(base);
  65        int src_size = len + 1;
  66        do {
  67                int i;
  68                char *first;
  69                int firstdir = 0;
  70                int pathlen;
  71                unsigned ce_size;
  72                struct tree_entry_list **subposns;
  73                struct cache_entry **src;
  74                int any_files = 0;
  75                int any_dirs = 0;
  76                char *cache_name;
  77                int ce_stage;
  78
  79                /* Find the first name in the input. */
  80
  81                first = NULL;
  82                cache_name = NULL;
  83
  84                /* Check the cache */
  85                if (merge && *indpos < active_nr) {
  86                        /* This is a bit tricky: */
  87                        /* If the index has a subdirectory (with
  88                         * contents) as the first name, it'll get a
  89                         * filename like "foo/bar". But that's after
  90                         * "foo", so the entry in trees will get
  91                         * handled first, at which point we'll go into
  92                         * "foo", and deal with "bar" from the index,
  93                         * because the base will be "foo/". The only
  94                         * way we can actually have "foo/bar" first of
  95                         * all the things is if the trees don't
  96                         * contain "foo" at all, in which case we'll
  97                         * handle "foo/bar" without going into the
  98                         * directory, but that's fine (and will return
  99                         * an error anyway, with the added unknown
 100                         * file case.
 101                         */
 102
 103                        cache_name = active_cache[*indpos]->name;
 104                        if (strlen(cache_name) > baselen &&
 105                            !memcmp(cache_name, base, baselen)) {
 106                                cache_name += baselen;
 107                                first = cache_name;
 108                        } else {
 109                                cache_name = NULL;
 110                        }
 111                }
 112
 113#if DBRT_DEBUG > 1
 114                if (first)
 115                        printf("index %s\n", first);
 116#endif
 117                for (i = 0; i < len; i++) {
 118                        if (!posns[i] || posns[i] == &df_conflict_list)
 119                                continue;
 120#if DBRT_DEBUG > 1
 121                        printf("%d %s\n", i + 1, posns[i]->name);
 122#endif
 123                        if (!first || entcmp(first, firstdir,
 124                                             posns[i]->name, 
 125                                             posns[i]->directory) > 0) {
 126                                first = posns[i]->name;
 127                                firstdir = posns[i]->directory;
 128                        }
 129                }
 130                /* No name means we're done */
 131                if (!first)
 132                        return 0;
 133
 134                pathlen = strlen(first);
 135                ce_size = cache_entry_size(baselen + pathlen);
 136
 137                src = xcalloc(src_size, sizeof(struct cache_entry *));
 138
 139                subposns = xcalloc(len, sizeof(struct tree_list_entry *));
 140
 141                if (cache_name && !strcmp(cache_name, first)) {
 142                        any_files = 1;
 143                        src[0] = active_cache[*indpos];
 144                        remove_cache_entry_at(*indpos);
 145                }
 146
 147                for (i = 0; i < len; i++) {
 148                        struct cache_entry *ce;
 149
 150                        if (!posns[i] ||
 151                            (posns[i] != &df_conflict_list &&
 152                             strcmp(first, posns[i]->name))) {
 153                                continue;
 154                        }
 155
 156                        if (posns[i] == &df_conflict_list) {
 157                                src[i + merge] = &df_conflict_entry;
 158                                continue;
 159                        }
 160
 161                        if (posns[i]->directory) {
 162                                any_dirs = 1;
 163                                parse_tree(posns[i]->item.tree);
 164                                subposns[i] = posns[i]->item.tree->entries;
 165                                posns[i] = posns[i]->next;
 166                                src[i + merge] = &df_conflict_entry;
 167                                continue;
 168                        }
 169
 170                        if (!merge)
 171                                ce_stage = 0;
 172                        else if (i + 1 < head_idx)
 173                                ce_stage = 1;
 174                        else if (i + 1 > head_idx)
 175                                ce_stage = 3;
 176                        else
 177                                ce_stage = 2;
 178
 179                        ce = xcalloc(1, ce_size);
 180                        ce->ce_mode = create_ce_mode(posns[i]->mode);
 181                        ce->ce_flags = create_ce_flags(baselen + pathlen,
 182                                                       ce_stage);
 183                        memcpy(ce->name, base, baselen);
 184                        memcpy(ce->name + baselen, first, pathlen + 1);
 185
 186                        any_files = 1;
 187
 188                        memcpy(ce->sha1, posns[i]->item.any->sha1, 20);
 189                        src[i + merge] = ce;
 190                        subposns[i] = &df_conflict_list;
 191                        posns[i] = posns[i]->next;
 192                }
 193                if (any_files) {
 194                        if (merge) {
 195                                int ret;
 196
 197#if DBRT_DEBUG > 1
 198                                printf("%s:\n", first);
 199                                for (i = 0; i < src_size; i++) {
 200                                        printf(" %d ", i);
 201                                        if (src[i])
 202                                                printf("%s\n", sha1_to_hex(src[i]->sha1));
 203                                        else
 204                                                printf("\n");
 205                                }
 206#endif
 207                                ret = fn(src);
 208                                
 209#if DBRT_DEBUG > 1
 210                                printf("Added %d entries\n", ret);
 211#endif
 212                                *indpos += ret;
 213                        } else {
 214                                for (i = 0; i < src_size; i++) {
 215                                        if (src[i]) {
 216                                                add_cache_entry(src[i], ADD_CACHE_OK_TO_ADD|ADD_CACHE_SKIP_DFCHECK);
 217                                        }
 218                                }
 219                        }
 220                }
 221                if (any_dirs) {
 222                        char *newbase = xmalloc(baselen + 2 + pathlen);
 223                        memcpy(newbase, base, baselen);
 224                        memcpy(newbase + baselen, first, pathlen);
 225                        newbase[baselen + pathlen] = '/';
 226                        newbase[baselen + pathlen + 1] = '\0';
 227                        if (unpack_trees_rec(subposns, len, newbase, fn,
 228                                             indpos))
 229                                return -1;
 230                        free(newbase);
 231                }
 232                free(subposns);
 233                free(src);
 234        } while (1);
 235}
 236
 237static void reject_merge(struct cache_entry *ce)
 238{
 239        die("Entry '%s' would be overwritten by merge. Cannot merge.", 
 240            ce->name);
 241}
 242
 243/* Unlink the last component and attempt to remove leading
 244 * directories, in case this unlink is the removal of the
 245 * last entry in the directory -- empty directories are removed.
 246 */
 247static void unlink_entry(char *name)
 248{
 249        char *cp, *prev;
 250
 251        if (unlink(name))
 252                return;
 253        prev = NULL;
 254        while (1) {
 255                int status;
 256                cp = strrchr(name, '/');
 257                if (prev)
 258                        *prev = '/';
 259                if (!cp)
 260                        break;
 261
 262                *cp = 0;
 263                status = rmdir(name);
 264                if (status) {
 265                        *cp = '/';
 266                        break;
 267                }
 268                prev = cp;
 269        }
 270}
 271
 272static void progress_interval(int signum)
 273{
 274        progress_update = 1;
 275}
 276
 277static void setup_progress_signal(void)
 278{
 279        struct sigaction sa;
 280        struct itimerval v;
 281
 282        memset(&sa, 0, sizeof(sa));
 283        sa.sa_handler = progress_interval;
 284        sigemptyset(&sa.sa_mask);
 285        sa.sa_flags = SA_RESTART;
 286        sigaction(SIGALRM, &sa, NULL);
 287
 288        v.it_interval.tv_sec = 1;
 289        v.it_interval.tv_usec = 0;
 290        v.it_value = v.it_interval;
 291        setitimer(ITIMER_REAL, &v, NULL);
 292}
 293
 294static void check_updates(struct cache_entry **src, int nr)
 295{
 296        static struct checkout state = {
 297                .base_dir = "",
 298                .force = 1,
 299                .quiet = 1,
 300                .refresh_cache = 1,
 301        };
 302        unsigned short mask = htons(CE_UPDATE);
 303        unsigned last_percent = 200, cnt = 0, total = 0;
 304
 305        if (update && verbose_update) {
 306                for (total = cnt = 0; cnt < nr; cnt++) {
 307                        struct cache_entry *ce = src[cnt];
 308                        if (!ce->ce_mode || ce->ce_flags & mask)
 309                                total++;
 310                }
 311
 312                /* Don't bother doing this for very small updates */
 313                if (total < 250)
 314                        total = 0;
 315
 316                if (total) {
 317                        fprintf(stderr, "Checking files out...\n");
 318                        setup_progress_signal();
 319                        progress_update = 1;
 320                }
 321                cnt = 0;
 322        }
 323
 324        while (nr--) {
 325                struct cache_entry *ce = *src++;
 326
 327                if (total) {
 328                        if (!ce->ce_mode || ce->ce_flags & mask) {
 329                                unsigned percent;
 330                                cnt++;
 331                                percent = (cnt * 100) / total;
 332                                if (percent != last_percent ||
 333                                    progress_update) {
 334                                        fprintf(stderr, "%4u%% (%u/%u) done\r",
 335                                                percent, cnt, total);
 336                                        last_percent = percent;
 337                                }
 338                        }
 339                }
 340                if (!ce->ce_mode) {
 341                        if (update)
 342                                unlink_entry(ce->name);
 343                        continue;
 344                }
 345                if (ce->ce_flags & mask) {
 346                        ce->ce_flags &= ~mask;
 347                        if (update)
 348                                checkout_entry(ce, &state, NULL);
 349                }
 350        }
 351        if (total) {
 352                signal(SIGALRM, SIG_IGN);
 353                fputc('\n', stderr);
 354        }
 355}
 356
 357static int unpack_trees(merge_fn_t fn)
 358{
 359        int indpos = 0;
 360        unsigned len = object_list_length(trees);
 361        struct tree_entry_list **posns;
 362        int i;
 363        struct object_list *posn = trees;
 364        merge_size = len;
 365
 366        if (len) {
 367                posns = xmalloc(len * sizeof(struct tree_entry_list *));
 368                for (i = 0; i < len; i++) {
 369                        posns[i] = ((struct tree *) posn->item)->entries;
 370                        posn = posn->next;
 371                }
 372                if (unpack_trees_rec(posns, len, "", fn, &indpos))
 373                        return -1;
 374        }
 375
 376        if (trivial_merges_only && nontrivial_merge)
 377                die("Merge requires file-level merging");
 378
 379        check_updates(active_cache, active_nr);
 380        return 0;
 381}
 382
 383static int list_tree(unsigned char *sha1)
 384{
 385        struct tree *tree = parse_tree_indirect(sha1);
 386        if (!tree)
 387                return -1;
 388        object_list_append(&tree->object, &trees);
 389        return 0;
 390}
 391
 392static int same(struct cache_entry *a, struct cache_entry *b)
 393{
 394        if (!!a != !!b)
 395                return 0;
 396        if (!a && !b)
 397                return 1;
 398        return a->ce_mode == b->ce_mode && 
 399                !memcmp(a->sha1, b->sha1, 20);
 400}
 401
 402
 403/*
 404 * When a CE gets turned into an unmerged entry, we
 405 * want it to be up-to-date
 406 */
 407static void verify_uptodate(struct cache_entry *ce)
 408{
 409        struct stat st;
 410
 411        if (index_only || reset)
 412                return;
 413
 414        if (!lstat(ce->name, &st)) {
 415                unsigned changed = ce_match_stat(ce, &st, 1);
 416                if (!changed)
 417                        return;
 418                errno = 0;
 419        }
 420        if (reset) {
 421                ce->ce_flags |= htons(CE_UPDATE);
 422                return;
 423        }
 424        if (errno == ENOENT)
 425                return;
 426        die("Entry '%s' not uptodate. Cannot merge.", ce->name);
 427}
 428
 429/*
 430 * We do not want to remove or overwrite a working tree file that
 431 * is not tracked.
 432 */
 433static void verify_absent(const char *path, const char *action)
 434{
 435        struct stat st;
 436
 437        if (index_only || reset || !update)
 438                return;
 439        if (!lstat(path, &st))
 440                die("Untracked working tree file '%s' "
 441                    "would be %s by merge.", path, action);
 442}
 443
 444static int merged_entry(struct cache_entry *merge, struct cache_entry *old)
 445{
 446        merge->ce_flags |= htons(CE_UPDATE);
 447        if (old) {
 448                /*
 449                 * See if we can re-use the old CE directly?
 450                 * That way we get the uptodate stat info.
 451                 *
 452                 * This also removes the UPDATE flag on
 453                 * a match.
 454                 */
 455                if (same(old, merge)) {
 456                        *merge = *old;
 457                } else {
 458                        verify_uptodate(old);
 459                }
 460        }
 461        else
 462                verify_absent(merge->name, "overwritten");
 463
 464        merge->ce_flags &= ~htons(CE_STAGEMASK);
 465        add_cache_entry(merge, ADD_CACHE_OK_TO_ADD);
 466        return 1;
 467}
 468
 469static int deleted_entry(struct cache_entry *ce, struct cache_entry *old)
 470{
 471        if (old)
 472                verify_uptodate(old);
 473        else
 474                verify_absent(ce->name, "removed");
 475        ce->ce_mode = 0;
 476        add_cache_entry(ce, ADD_CACHE_OK_TO_ADD);
 477        return 1;
 478}
 479
 480static int keep_entry(struct cache_entry *ce)
 481{
 482        add_cache_entry(ce, ADD_CACHE_OK_TO_ADD);
 483        return 1;
 484}
 485
 486#if DBRT_DEBUG
 487static void show_stage_entry(FILE *o,
 488                             const char *label, const struct cache_entry *ce)
 489{
 490        if (!ce)
 491                fprintf(o, "%s (missing)\n", label);
 492        else
 493                fprintf(o, "%s%06o %s %d\t%s\n",
 494                        label,
 495                        ntohl(ce->ce_mode),
 496                        sha1_to_hex(ce->sha1),
 497                        ce_stage(ce),
 498                        ce->name);
 499}
 500#endif
 501
 502static int threeway_merge(struct cache_entry **stages)
 503{
 504        struct cache_entry *index;
 505        struct cache_entry *head; 
 506        struct cache_entry *remote = stages[head_idx + 1];
 507        int count;
 508        int head_match = 0;
 509        int remote_match = 0;
 510        const char *path = NULL;
 511
 512        int df_conflict_head = 0;
 513        int df_conflict_remote = 0;
 514
 515        int any_anc_missing = 0;
 516        int no_anc_exists = 1;
 517        int i;
 518
 519        for (i = 1; i < head_idx; i++) {
 520                if (!stages[i])
 521                        any_anc_missing = 1;
 522                else {
 523                        if (!path)
 524                                path = stages[i]->name;
 525                        no_anc_exists = 0;
 526                }
 527        }
 528
 529        index = stages[0];
 530        head = stages[head_idx];
 531
 532        if (head == &df_conflict_entry) {
 533                df_conflict_head = 1;
 534                head = NULL;
 535        }
 536
 537        if (remote == &df_conflict_entry) {
 538                df_conflict_remote = 1;
 539                remote = NULL;
 540        }
 541
 542        if (!path && index)
 543                path = index->name;
 544        if (!path && head)
 545                path = head->name;
 546        if (!path && remote)
 547                path = remote->name;
 548
 549        /* First, if there's a #16 situation, note that to prevent #13
 550         * and #14.
 551         */
 552        if (!same(remote, head)) {
 553                for (i = 1; i < head_idx; i++) {
 554                        if (same(stages[i], head)) {
 555                                head_match = i;
 556                        }
 557                        if (same(stages[i], remote)) {
 558                                remote_match = i;
 559                        }
 560                }
 561        }
 562
 563        /* We start with cases where the index is allowed to match
 564         * something other than the head: #14(ALT) and #2ALT, where it
 565         * is permitted to match the result instead.
 566         */
 567        /* #14, #14ALT, #2ALT */
 568        if (remote && !df_conflict_head && head_match && !remote_match) {
 569                if (index && !same(index, remote) && !same(index, head))
 570                        reject_merge(index);
 571                return merged_entry(remote, index);
 572        }
 573        /*
 574         * If we have an entry in the index cache, then we want to
 575         * make sure that it matches head.
 576         */
 577        if (index && !same(index, head)) {
 578                reject_merge(index);
 579        }
 580
 581        if (head) {
 582                /* #5ALT, #15 */
 583                if (same(head, remote))
 584                        return merged_entry(head, index);
 585                /* #13, #3ALT */
 586                if (!df_conflict_remote && remote_match && !head_match)
 587                        return merged_entry(head, index);
 588        }
 589
 590        /* #1 */
 591        if (!head && !remote && any_anc_missing)
 592                return 0;
 593
 594        /* Under the new "aggressive" rule, we resolve mostly trivial
 595         * cases that we historically had git-merge-one-file resolve.
 596         */
 597        if (aggressive) {
 598                int head_deleted = !head && !df_conflict_head;
 599                int remote_deleted = !remote && !df_conflict_remote;
 600                /*
 601                 * Deleted in both.
 602                 * Deleted in one and unchanged in the other.
 603                 */
 604                if ((head_deleted && remote_deleted) ||
 605                    (head_deleted && remote && remote_match) ||
 606                    (remote_deleted && head && head_match)) {
 607                        if (index)
 608                                return deleted_entry(index, index);
 609                        else if (path)
 610                                verify_absent(path, "removed");
 611                        return 0;
 612                }
 613                /*
 614                 * Added in both, identically.
 615                 */
 616                if (no_anc_exists && head && remote && same(head, remote))
 617                        return merged_entry(head, index);
 618
 619        }
 620
 621        /* Below are "no merge" cases, which require that the index be
 622         * up-to-date to avoid the files getting overwritten with
 623         * conflict resolution files. 
 624         */
 625        if (index) {
 626                verify_uptodate(index);
 627        }
 628        else if (path)
 629                verify_absent(path, "overwritten");
 630
 631        nontrivial_merge = 1;
 632
 633        /* #2, #3, #4, #6, #7, #9, #11. */
 634        count = 0;
 635        if (!head_match || !remote_match) {
 636                for (i = 1; i < head_idx; i++) {
 637                        if (stages[i]) {
 638                                keep_entry(stages[i]);
 639                                count++;
 640                                break;
 641                        }
 642                }
 643        }
 644#if DBRT_DEBUG
 645        else {
 646                fprintf(stderr, "read-tree: warning #16 detected\n");
 647                show_stage_entry(stderr, "head   ", stages[head_match]);
 648                show_stage_entry(stderr, "remote ", stages[remote_match]);
 649        }
 650#endif
 651        if (head) { count += keep_entry(head); }
 652        if (remote) { count += keep_entry(remote); }
 653        return count;
 654}
 655
 656/*
 657 * Two-way merge.
 658 *
 659 * The rule is to "carry forward" what is in the index without losing
 660 * information across a "fast forward", favoring a successful merge
 661 * over a merge failure when it makes sense.  For details of the
 662 * "carry forward" rule, please see <Documentation/git-read-tree.txt>.
 663 *
 664 */
 665static int twoway_merge(struct cache_entry **src)
 666{
 667        struct cache_entry *current = src[0];
 668        struct cache_entry *oldtree = src[1], *newtree = src[2];
 669
 670        if (merge_size != 2)
 671                return error("Cannot do a twoway merge of %d trees",
 672                             merge_size);
 673
 674        if (current) {
 675                if ((!oldtree && !newtree) || /* 4 and 5 */
 676                    (!oldtree && newtree &&
 677                     same(current, newtree)) || /* 6 and 7 */
 678                    (oldtree && newtree &&
 679                     same(oldtree, newtree)) || /* 14 and 15 */
 680                    (oldtree && newtree &&
 681                     !same(oldtree, newtree) && /* 18 and 19*/
 682                     same(current, newtree))) {
 683                        return keep_entry(current);
 684                }
 685                else if (oldtree && !newtree && same(current, oldtree)) {
 686                        /* 10 or 11 */
 687                        return deleted_entry(oldtree, current);
 688                }
 689                else if (oldtree && newtree &&
 690                         same(current, oldtree) && !same(current, newtree)) {
 691                        /* 20 or 21 */
 692                        return merged_entry(newtree, current);
 693                }
 694                else {
 695                        /* all other failures */
 696                        if (oldtree)
 697                                reject_merge(oldtree);
 698                        if (current)
 699                                reject_merge(current);
 700                        if (newtree)
 701                                reject_merge(newtree);
 702                        return -1;
 703                }
 704        }
 705        else if (newtree)
 706                return merged_entry(newtree, current);
 707        else
 708                return deleted_entry(oldtree, current);
 709}
 710
 711/*
 712 * One-way merge.
 713 *
 714 * The rule is:
 715 * - take the stat information from stage0, take the data from stage1
 716 */
 717static int oneway_merge(struct cache_entry **src)
 718{
 719        struct cache_entry *old = src[0];
 720        struct cache_entry *a = src[1];
 721
 722        if (merge_size != 1)
 723                return error("Cannot do a oneway merge of %d trees",
 724                             merge_size);
 725
 726        if (!a)
 727                return deleted_entry(old, old);
 728        if (old && same(old, a)) {
 729                if (reset) {
 730                        struct stat st;
 731                        if (lstat(old->name, &st) ||
 732                            ce_match_stat(old, &st, 1))
 733                                old->ce_flags |= htons(CE_UPDATE);
 734                }
 735                return keep_entry(old);
 736        }
 737        return merged_entry(a, old);
 738}
 739
 740static int read_cache_unmerged(void)
 741{
 742        int i, deleted;
 743        struct cache_entry **dst;
 744
 745        read_cache();
 746        dst = active_cache;
 747        deleted = 0;
 748        for (i = 0; i < active_nr; i++) {
 749                struct cache_entry *ce = active_cache[i];
 750                if (ce_stage(ce)) {
 751                        deleted++;
 752                        continue;
 753                }
 754                if (deleted)
 755                        *dst = ce;
 756                dst++;
 757        }
 758        active_nr -= deleted;
 759        return deleted;
 760}
 761
 762static const char read_tree_usage[] = "git-read-tree (<sha> | -m [--aggressive] [-u | -i] <sha1> [<sha2> [<sha3>]])";
 763
 764static struct cache_file cache_file;
 765
 766int main(int argc, char **argv)
 767{
 768        int i, newfd, stage = 0;
 769        unsigned char sha1[20];
 770        merge_fn_t fn = NULL;
 771
 772        setup_git_directory();
 773        git_config(git_default_config);
 774
 775        newfd = hold_index_file_for_update(&cache_file, get_index_file());
 776        if (newfd < 0)
 777                die("unable to create new cachefile");
 778
 779        git_config(git_default_config);
 780
 781        merge = 0;
 782        reset = 0;
 783        for (i = 1; i < argc; i++) {
 784                const char *arg = argv[i];
 785
 786                /* "-u" means "update", meaning that a merge will update
 787                 * the working tree.
 788                 */
 789                if (!strcmp(arg, "-u")) {
 790                        update = 1;
 791                        continue;
 792                }
 793
 794                if (!strcmp(arg, "-v")) {
 795                        verbose_update = 1;
 796                        continue;
 797                }
 798
 799                /* "-i" means "index only", meaning that a merge will
 800                 * not even look at the working tree.
 801                 */
 802                if (!strcmp(arg, "-i")) {
 803                        index_only = 1;
 804                        continue;
 805                }
 806
 807                /* This differs from "-m" in that we'll silently ignore unmerged entries */
 808                if (!strcmp(arg, "--reset")) {
 809                        if (stage || merge)
 810                                usage(read_tree_usage);
 811                        reset = 1;
 812                        merge = 1;
 813                        stage = 1;
 814                        read_cache_unmerged();
 815                        continue;
 816                }
 817
 818                if (!strcmp(arg, "--trivial")) {
 819                        trivial_merges_only = 1;
 820                        continue;
 821                }
 822
 823                if (!strcmp(arg, "--aggressive")) {
 824                        aggressive = 1;
 825                        continue;
 826                }
 827
 828                /* "-m" stands for "merge", meaning we start in stage 1 */
 829                if (!strcmp(arg, "-m")) {
 830                        if (stage || merge)
 831                                usage(read_tree_usage);
 832                        if (read_cache_unmerged())
 833                                die("you need to resolve your current index first");
 834                        stage = 1;
 835                        merge = 1;
 836                        continue;
 837                }
 838
 839                /* using -u and -i at the same time makes no sense */
 840                if (1 < index_only + update)
 841                        usage(read_tree_usage);
 842
 843                if (get_sha1(arg, sha1))
 844                        die("Not a valid object name %s", arg);
 845                if (list_tree(sha1) < 0)
 846                        die("failed to unpack tree object %s", arg);
 847                stage++;
 848        }
 849        if ((update||index_only) && !merge)
 850                usage(read_tree_usage);
 851
 852        if (merge) {
 853                if (stage < 2)
 854                        die("just how do you expect me to merge %d trees?", stage-1);
 855                switch (stage - 1) {
 856                case 1:
 857                        fn = oneway_merge;
 858                        break;
 859                case 2:
 860                        fn = twoway_merge;
 861                        break;
 862                case 3:
 863                        fn = threeway_merge;
 864                        break;
 865                default:
 866                        fn = threeway_merge;
 867                        break;
 868                }
 869
 870                if (stage - 1 >= 3)
 871                        head_idx = stage - 2;
 872                else
 873                        head_idx = 1;
 874        }
 875
 876        unpack_trees(fn);
 877        if (write_cache(newfd, active_cache, active_nr) ||
 878            commit_index_file(&cache_file))
 879                die("unable to write new index file");
 880        return 0;
 881}