builtin / rebase.con commit Merge branch 'nd/show-gitcomp-compilation-fix' into maint (bf29f07)
   1/*
   2 * "git rebase" builtin command
   3 *
   4 * Copyright (c) 2018 Pratik Karki
   5 */
   6
   7#include "builtin.h"
   8#include "run-command.h"
   9#include "exec-cmd.h"
  10#include "argv-array.h"
  11#include "dir.h"
  12#include "packfile.h"
  13#include "refs.h"
  14#include "quote.h"
  15#include "config.h"
  16#include "cache-tree.h"
  17#include "unpack-trees.h"
  18#include "lockfile.h"
  19#include "parse-options.h"
  20#include "commit.h"
  21#include "diff.h"
  22#include "wt-status.h"
  23#include "revision.h"
  24#include "commit-reach.h"
  25#include "rerere.h"
  26#include "branch.h"
  27
  28static char const * const builtin_rebase_usage[] = {
  29        N_("git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] "
  30                "[<upstream>] [<branch>]"),
  31        N_("git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] "
  32                "--root [<branch>]"),
  33        N_("git rebase --continue | --abort | --skip | --edit-todo"),
  34        NULL
  35};
  36
  37static GIT_PATH_FUNC(apply_dir, "rebase-apply")
  38static GIT_PATH_FUNC(merge_dir, "rebase-merge")
  39
  40enum rebase_type {
  41        REBASE_UNSPECIFIED = -1,
  42        REBASE_AM,
  43        REBASE_MERGE,
  44        REBASE_INTERACTIVE,
  45        REBASE_PRESERVE_MERGES
  46};
  47
  48static int use_builtin_rebase(void)
  49{
  50        struct child_process cp = CHILD_PROCESS_INIT;
  51        struct strbuf out = STRBUF_INIT;
  52        int ret, env = git_env_bool("GIT_TEST_REBASE_USE_BUILTIN", -1);
  53
  54        if (env != -1)
  55                return env;
  56
  57        argv_array_pushl(&cp.args,
  58                         "config", "--bool", "rebase.usebuiltin", NULL);
  59        cp.git_cmd = 1;
  60        if (capture_command(&cp, &out, 6)) {
  61                strbuf_release(&out);
  62                return 1;
  63        }
  64
  65        strbuf_trim(&out);
  66        ret = !strcmp("true", out.buf);
  67        strbuf_release(&out);
  68        return ret;
  69}
  70
  71struct rebase_options {
  72        enum rebase_type type;
  73        const char *state_dir;
  74        struct commit *upstream;
  75        const char *upstream_name;
  76        const char *upstream_arg;
  77        char *head_name;
  78        struct object_id orig_head;
  79        struct commit *onto;
  80        const char *onto_name;
  81        const char *revisions;
  82        const char *switch_to;
  83        int root;
  84        struct object_id *squash_onto;
  85        struct commit *restrict_revision;
  86        int dont_finish_rebase;
  87        enum {
  88                REBASE_NO_QUIET = 1<<0,
  89                REBASE_VERBOSE = 1<<1,
  90                REBASE_DIFFSTAT = 1<<2,
  91                REBASE_FORCE = 1<<3,
  92                REBASE_INTERACTIVE_EXPLICIT = 1<<4,
  93        } flags;
  94        struct argv_array git_am_opts;
  95        const char *action;
  96        int signoff;
  97        int allow_rerere_autoupdate;
  98        int keep_empty;
  99        int autosquash;
 100        char *gpg_sign_opt;
 101        int autostash;
 102        char *cmd;
 103        int allow_empty_message;
 104        int rebase_merges, rebase_cousins;
 105        char *strategy, *strategy_opts;
 106        struct strbuf git_format_patch_opt;
 107};
 108
 109static int is_interactive(struct rebase_options *opts)
 110{
 111        return opts->type == REBASE_INTERACTIVE ||
 112                opts->type == REBASE_PRESERVE_MERGES;
 113}
 114
 115static void imply_interactive(struct rebase_options *opts, const char *option)
 116{
 117        switch (opts->type) {
 118        case REBASE_AM:
 119                die(_("%s requires an interactive rebase"), option);
 120                break;
 121        case REBASE_INTERACTIVE:
 122        case REBASE_PRESERVE_MERGES:
 123                break;
 124        case REBASE_MERGE:
 125                /* we silently *upgrade* --merge to --interactive if needed */
 126        default:
 127                opts->type = REBASE_INTERACTIVE; /* implied */
 128                break;
 129        }
 130}
 131
 132/* Returns the filename prefixed by the state_dir */
 133static const char *state_dir_path(const char *filename, struct rebase_options *opts)
 134{
 135        static struct strbuf path = STRBUF_INIT;
 136        static size_t prefix_len;
 137
 138        if (!prefix_len) {
 139                strbuf_addf(&path, "%s/", opts->state_dir);
 140                prefix_len = path.len;
 141        }
 142
 143        strbuf_setlen(&path, prefix_len);
 144        strbuf_addstr(&path, filename);
 145        return path.buf;
 146}
 147
 148/* Read one file, then strip line endings */
 149static int read_one(const char *path, struct strbuf *buf)
 150{
 151        if (strbuf_read_file(buf, path, 0) < 0)
 152                return error_errno(_("could not read '%s'"), path);
 153        strbuf_trim_trailing_newline(buf);
 154        return 0;
 155}
 156
 157/* Initialize the rebase options from the state directory. */
 158static int read_basic_state(struct rebase_options *opts)
 159{
 160        struct strbuf head_name = STRBUF_INIT;
 161        struct strbuf buf = STRBUF_INIT;
 162        struct object_id oid;
 163
 164        if (read_one(state_dir_path("head-name", opts), &head_name) ||
 165            read_one(state_dir_path("onto", opts), &buf))
 166                return -1;
 167        opts->head_name = starts_with(head_name.buf, "refs/") ?
 168                xstrdup(head_name.buf) : NULL;
 169        strbuf_release(&head_name);
 170        if (get_oid(buf.buf, &oid))
 171                return error(_("could not get 'onto': '%s'"), buf.buf);
 172        opts->onto = lookup_commit_or_die(&oid, buf.buf);
 173
 174        /*
 175         * We always write to orig-head, but interactive rebase used to write to
 176         * head. Fall back to reading from head to cover for the case that the
 177         * user upgraded git with an ongoing interactive rebase.
 178         */
 179        strbuf_reset(&buf);
 180        if (file_exists(state_dir_path("orig-head", opts))) {
 181                if (read_one(state_dir_path("orig-head", opts), &buf))
 182                        return -1;
 183        } else if (read_one(state_dir_path("head", opts), &buf))
 184                return -1;
 185        if (get_oid(buf.buf, &opts->orig_head))
 186                return error(_("invalid orig-head: '%s'"), buf.buf);
 187
 188        strbuf_reset(&buf);
 189        if (read_one(state_dir_path("quiet", opts), &buf))
 190                return -1;
 191        if (buf.len)
 192                opts->flags &= ~REBASE_NO_QUIET;
 193        else
 194                opts->flags |= REBASE_NO_QUIET;
 195
 196        if (file_exists(state_dir_path("verbose", opts)))
 197                opts->flags |= REBASE_VERBOSE;
 198
 199        if (file_exists(state_dir_path("signoff", opts))) {
 200                opts->signoff = 1;
 201                opts->flags |= REBASE_FORCE;
 202        }
 203
 204        if (file_exists(state_dir_path("allow_rerere_autoupdate", opts))) {
 205                strbuf_reset(&buf);
 206                if (read_one(state_dir_path("allow_rerere_autoupdate", opts),
 207                            &buf))
 208                        return -1;
 209                if (!strcmp(buf.buf, "--rerere-autoupdate"))
 210                        opts->allow_rerere_autoupdate = 1;
 211                else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
 212                        opts->allow_rerere_autoupdate = 0;
 213                else
 214                        warning(_("ignoring invalid allow_rerere_autoupdate: "
 215                                  "'%s'"), buf.buf);
 216        } else
 217                opts->allow_rerere_autoupdate = -1;
 218
 219        if (file_exists(state_dir_path("gpg_sign_opt", opts))) {
 220                strbuf_reset(&buf);
 221                if (read_one(state_dir_path("gpg_sign_opt", opts),
 222                            &buf))
 223                        return -1;
 224                free(opts->gpg_sign_opt);
 225                opts->gpg_sign_opt = xstrdup(buf.buf);
 226        }
 227
 228        if (file_exists(state_dir_path("strategy", opts))) {
 229                strbuf_reset(&buf);
 230                if (read_one(state_dir_path("strategy", opts), &buf))
 231                        return -1;
 232                free(opts->strategy);
 233                opts->strategy = xstrdup(buf.buf);
 234        }
 235
 236        if (file_exists(state_dir_path("strategy_opts", opts))) {
 237                strbuf_reset(&buf);
 238                if (read_one(state_dir_path("strategy_opts", opts), &buf))
 239                        return -1;
 240                free(opts->strategy_opts);
 241                opts->strategy_opts = xstrdup(buf.buf);
 242        }
 243
 244        strbuf_release(&buf);
 245
 246        return 0;
 247}
 248
 249static int apply_autostash(struct rebase_options *opts)
 250{
 251        const char *path = state_dir_path("autostash", opts);
 252        struct strbuf autostash = STRBUF_INIT;
 253        struct child_process stash_apply = CHILD_PROCESS_INIT;
 254
 255        if (!file_exists(path))
 256                return 0;
 257
 258        if (read_one(path, &autostash))
 259                return error(_("Could not read '%s'"), path);
 260        /* Ensure that the hash is not mistaken for a number */
 261        strbuf_addstr(&autostash, "^0");
 262        argv_array_pushl(&stash_apply.args,
 263                         "stash", "apply", autostash.buf, NULL);
 264        stash_apply.git_cmd = 1;
 265        stash_apply.no_stderr = stash_apply.no_stdout =
 266                stash_apply.no_stdin = 1;
 267        if (!run_command(&stash_apply))
 268                printf(_("Applied autostash.\n"));
 269        else {
 270                struct argv_array args = ARGV_ARRAY_INIT;
 271                int res = 0;
 272
 273                argv_array_pushl(&args,
 274                                 "stash", "store", "-m", "autostash", "-q",
 275                                 autostash.buf, NULL);
 276                if (run_command_v_opt(args.argv, RUN_GIT_CMD))
 277                        res = error(_("Cannot store %s"), autostash.buf);
 278                argv_array_clear(&args);
 279                strbuf_release(&autostash);
 280                if (res)
 281                        return res;
 282
 283                fprintf(stderr,
 284                        _("Applying autostash resulted in conflicts.\n"
 285                          "Your changes are safe in the stash.\n"
 286                          "You can run \"git stash pop\" or \"git stash drop\" "
 287                          "at any time.\n"));
 288        }
 289
 290        strbuf_release(&autostash);
 291        return 0;
 292}
 293
 294static int finish_rebase(struct rebase_options *opts)
 295{
 296        struct strbuf dir = STRBUF_INIT;
 297        const char *argv_gc_auto[] = { "gc", "--auto", NULL };
 298
 299        delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
 300        apply_autostash(opts);
 301        close_all_packs(the_repository->objects);
 302        /*
 303         * We ignore errors in 'gc --auto', since the
 304         * user should see them.
 305         */
 306        run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
 307        strbuf_addstr(&dir, opts->state_dir);
 308        remove_dir_recursively(&dir, 0);
 309        strbuf_release(&dir);
 310
 311        return 0;
 312}
 313
 314static struct commit *peel_committish(const char *name)
 315{
 316        struct object *obj;
 317        struct object_id oid;
 318
 319        if (get_oid(name, &oid))
 320                return NULL;
 321        obj = parse_object(the_repository, &oid);
 322        return (struct commit *)peel_to_type(name, 0, obj, OBJ_COMMIT);
 323}
 324
 325static void add_var(struct strbuf *buf, const char *name, const char *value)
 326{
 327        if (!value)
 328                strbuf_addf(buf, "unset %s; ", name);
 329        else {
 330                strbuf_addf(buf, "%s=", name);
 331                sq_quote_buf(buf, value);
 332                strbuf_addstr(buf, "; ");
 333        }
 334}
 335
 336static const char *resolvemsg =
 337N_("Resolve all conflicts manually, mark them as resolved with\n"
 338"\"git add/rm <conflicted_files>\", then run \"git rebase --continue\".\n"
 339"You can instead skip this commit: run \"git rebase --skip\".\n"
 340"To abort and get back to the state before \"git rebase\", run "
 341"\"git rebase --abort\".");
 342
 343static int run_specific_rebase(struct rebase_options *opts)
 344{
 345        const char *argv[] = { NULL, NULL };
 346        struct strbuf script_snippet = STRBUF_INIT, buf = STRBUF_INIT;
 347        int status;
 348        const char *backend, *backend_func;
 349
 350        if (opts->type == REBASE_INTERACTIVE) {
 351                /* Run builtin interactive rebase */
 352                struct child_process child = CHILD_PROCESS_INIT;
 353
 354                argv_array_pushf(&child.env_array, "GIT_CHERRY_PICK_HELP=%s",
 355                                 resolvemsg);
 356                if (!(opts->flags & REBASE_INTERACTIVE_EXPLICIT)) {
 357                        argv_array_push(&child.env_array, "GIT_EDITOR=:");
 358                        opts->autosquash = 0;
 359                }
 360
 361                child.git_cmd = 1;
 362                argv_array_push(&child.args, "rebase--interactive");
 363
 364                if (opts->action)
 365                        argv_array_pushf(&child.args, "--%s", opts->action);
 366                if (opts->keep_empty)
 367                        argv_array_push(&child.args, "--keep-empty");
 368                if (opts->rebase_merges)
 369                        argv_array_push(&child.args, "--rebase-merges");
 370                if (opts->rebase_cousins)
 371                        argv_array_push(&child.args, "--rebase-cousins");
 372                if (opts->autosquash)
 373                        argv_array_push(&child.args, "--autosquash");
 374                if (opts->flags & REBASE_VERBOSE)
 375                        argv_array_push(&child.args, "--verbose");
 376                if (opts->flags & REBASE_FORCE)
 377                        argv_array_push(&child.args, "--no-ff");
 378                if (opts->restrict_revision)
 379                        argv_array_pushf(&child.args,
 380                                         "--restrict-revision=^%s",
 381                                         oid_to_hex(&opts->restrict_revision->object.oid));
 382                if (opts->upstream)
 383                        argv_array_pushf(&child.args, "--upstream=%s",
 384                                         oid_to_hex(&opts->upstream->object.oid));
 385                if (opts->onto)
 386                        argv_array_pushf(&child.args, "--onto=%s",
 387                                         oid_to_hex(&opts->onto->object.oid));
 388                if (opts->squash_onto)
 389                        argv_array_pushf(&child.args, "--squash-onto=%s",
 390                                         oid_to_hex(opts->squash_onto));
 391                if (opts->onto_name)
 392                        argv_array_pushf(&child.args, "--onto-name=%s",
 393                                         opts->onto_name);
 394                argv_array_pushf(&child.args, "--head-name=%s",
 395                                 opts->head_name ?
 396                                 opts->head_name : "detached HEAD");
 397                if (opts->strategy)
 398                        argv_array_pushf(&child.args, "--strategy=%s",
 399                                         opts->strategy);
 400                if (opts->strategy_opts)
 401                        argv_array_pushf(&child.args, "--strategy-opts=%s",
 402                                         opts->strategy_opts);
 403                if (opts->switch_to)
 404                        argv_array_pushf(&child.args, "--switch-to=%s",
 405                                         opts->switch_to);
 406                if (opts->cmd)
 407                        argv_array_pushf(&child.args, "--cmd=%s", opts->cmd);
 408                if (opts->allow_empty_message)
 409                        argv_array_push(&child.args, "--allow-empty-message");
 410                if (opts->allow_rerere_autoupdate > 0)
 411                        argv_array_push(&child.args, "--rerere-autoupdate");
 412                else if (opts->allow_rerere_autoupdate == 0)
 413                        argv_array_push(&child.args, "--no-rerere-autoupdate");
 414                if (opts->gpg_sign_opt)
 415                        argv_array_push(&child.args, opts->gpg_sign_opt);
 416                if (opts->signoff)
 417                        argv_array_push(&child.args, "--signoff");
 418
 419                status = run_command(&child);
 420                goto finished_rebase;
 421        }
 422
 423        add_var(&script_snippet, "GIT_DIR", absolute_path(get_git_dir()));
 424        add_var(&script_snippet, "state_dir", opts->state_dir);
 425
 426        add_var(&script_snippet, "upstream_name", opts->upstream_name);
 427        add_var(&script_snippet, "upstream", opts->upstream ?
 428                oid_to_hex(&opts->upstream->object.oid) : NULL);
 429        add_var(&script_snippet, "head_name",
 430                opts->head_name ? opts->head_name : "detached HEAD");
 431        add_var(&script_snippet, "orig_head", oid_to_hex(&opts->orig_head));
 432        add_var(&script_snippet, "onto", opts->onto ?
 433                oid_to_hex(&opts->onto->object.oid) : NULL);
 434        add_var(&script_snippet, "onto_name", opts->onto_name);
 435        add_var(&script_snippet, "revisions", opts->revisions);
 436        add_var(&script_snippet, "restrict_revision", opts->restrict_revision ?
 437                oid_to_hex(&opts->restrict_revision->object.oid) : NULL);
 438        add_var(&script_snippet, "GIT_QUIET",
 439                opts->flags & REBASE_NO_QUIET ? "" : "t");
 440        sq_quote_argv_pretty(&buf, opts->git_am_opts.argv);
 441        add_var(&script_snippet, "git_am_opt", buf.buf);
 442        strbuf_release(&buf);
 443        add_var(&script_snippet, "verbose",
 444                opts->flags & REBASE_VERBOSE ? "t" : "");
 445        add_var(&script_snippet, "diffstat",
 446                opts->flags & REBASE_DIFFSTAT ? "t" : "");
 447        add_var(&script_snippet, "force_rebase",
 448                opts->flags & REBASE_FORCE ? "t" : "");
 449        if (opts->switch_to)
 450                add_var(&script_snippet, "switch_to", opts->switch_to);
 451        add_var(&script_snippet, "action", opts->action ? opts->action : "");
 452        add_var(&script_snippet, "signoff", opts->signoff ? "--signoff" : "");
 453        add_var(&script_snippet, "allow_rerere_autoupdate",
 454                opts->allow_rerere_autoupdate < 0 ? "" :
 455                opts->allow_rerere_autoupdate ?
 456                "--rerere-autoupdate" : "--no-rerere-autoupdate");
 457        add_var(&script_snippet, "keep_empty", opts->keep_empty ? "yes" : "");
 458        add_var(&script_snippet, "autosquash", opts->autosquash ? "t" : "");
 459        add_var(&script_snippet, "gpg_sign_opt", opts->gpg_sign_opt);
 460        add_var(&script_snippet, "cmd", opts->cmd);
 461        add_var(&script_snippet, "allow_empty_message",
 462                opts->allow_empty_message ?  "--allow-empty-message" : "");
 463        add_var(&script_snippet, "rebase_merges",
 464                opts->rebase_merges ? "t" : "");
 465        add_var(&script_snippet, "rebase_cousins",
 466                opts->rebase_cousins ? "t" : "");
 467        add_var(&script_snippet, "strategy", opts->strategy);
 468        add_var(&script_snippet, "strategy_opts", opts->strategy_opts);
 469        add_var(&script_snippet, "rebase_root", opts->root ? "t" : "");
 470        add_var(&script_snippet, "squash_onto",
 471                opts->squash_onto ? oid_to_hex(opts->squash_onto) : "");
 472        add_var(&script_snippet, "git_format_patch_opt",
 473                opts->git_format_patch_opt.buf);
 474
 475        if (is_interactive(opts) &&
 476            !(opts->flags & REBASE_INTERACTIVE_EXPLICIT)) {
 477                strbuf_addstr(&script_snippet,
 478                              "GIT_EDITOR=:; export GIT_EDITOR; ");
 479                opts->autosquash = 0;
 480        }
 481
 482        switch (opts->type) {
 483        case REBASE_AM:
 484                backend = "git-rebase--am";
 485                backend_func = "git_rebase__am";
 486                break;
 487        case REBASE_MERGE:
 488                backend = "git-rebase--merge";
 489                backend_func = "git_rebase__merge";
 490                break;
 491        case REBASE_PRESERVE_MERGES:
 492                backend = "git-rebase--preserve-merges";
 493                backend_func = "git_rebase__preserve_merges";
 494                break;
 495        default:
 496                BUG("Unhandled rebase type %d", opts->type);
 497                break;
 498        }
 499
 500        strbuf_addf(&script_snippet,
 501                    ". git-sh-setup && . git-rebase--common &&"
 502                    " . %s && %s", backend, backend_func);
 503        argv[0] = script_snippet.buf;
 504
 505        status = run_command_v_opt(argv, RUN_USING_SHELL);
 506finished_rebase:
 507        if (opts->dont_finish_rebase)
 508                ; /* do nothing */
 509        else if (opts->type == REBASE_INTERACTIVE)
 510                ; /* interactive rebase cleans up after itself */
 511        else if (status == 0) {
 512                if (!file_exists(state_dir_path("stopped-sha", opts)))
 513                        finish_rebase(opts);
 514        } else if (status == 2) {
 515                struct strbuf dir = STRBUF_INIT;
 516
 517                apply_autostash(opts);
 518                strbuf_addstr(&dir, opts->state_dir);
 519                remove_dir_recursively(&dir, 0);
 520                strbuf_release(&dir);
 521                die("Nothing to do");
 522        }
 523
 524        strbuf_release(&script_snippet);
 525
 526        return status ? -1 : 0;
 527}
 528
 529#define GIT_REFLOG_ACTION_ENVIRONMENT "GIT_REFLOG_ACTION"
 530
 531#define RESET_HEAD_DETACH (1<<0)
 532#define RESET_HEAD_HARD (1<<1)
 533
 534static int reset_head(struct object_id *oid, const char *action,
 535                      const char *switch_to_branch, unsigned flags,
 536                      const char *reflog_orig_head, const char *reflog_head)
 537{
 538        unsigned detach_head = flags & RESET_HEAD_DETACH;
 539        unsigned reset_hard = flags & RESET_HEAD_HARD;
 540        struct object_id head_oid;
 541        struct tree_desc desc[2] = { { NULL }, { NULL } };
 542        struct lock_file lock = LOCK_INIT;
 543        struct unpack_trees_options unpack_tree_opts;
 544        struct tree *tree;
 545        const char *reflog_action;
 546        struct strbuf msg = STRBUF_INIT;
 547        size_t prefix_len;
 548        struct object_id *orig = NULL, oid_orig,
 549                *old_orig = NULL, oid_old_orig;
 550        int ret = 0, nr = 0;
 551
 552        if (switch_to_branch && !starts_with(switch_to_branch, "refs/"))
 553                BUG("Not a fully qualified branch: '%s'", switch_to_branch);
 554
 555        if (hold_locked_index(&lock, LOCK_REPORT_ON_ERROR) < 0) {
 556                ret = -1;
 557                goto leave_reset_head;
 558        }
 559
 560        if ((!oid || !reset_hard) && get_oid("HEAD", &head_oid)) {
 561                ret = error(_("could not determine HEAD revision"));
 562                goto leave_reset_head;
 563        }
 564
 565        if (!oid)
 566                oid = &head_oid;
 567
 568        memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
 569        setup_unpack_trees_porcelain(&unpack_tree_opts, action);
 570        unpack_tree_opts.head_idx = 1;
 571        unpack_tree_opts.src_index = the_repository->index;
 572        unpack_tree_opts.dst_index = the_repository->index;
 573        unpack_tree_opts.fn = reset_hard ? oneway_merge : twoway_merge;
 574        unpack_tree_opts.update = 1;
 575        unpack_tree_opts.merge = 1;
 576        if (!detach_head)
 577                unpack_tree_opts.reset = 1;
 578
 579        if (read_index_unmerged(the_repository->index) < 0) {
 580                ret = error(_("could not read index"));
 581                goto leave_reset_head;
 582        }
 583
 584        if (!reset_hard && !fill_tree_descriptor(&desc[nr++], &head_oid)) {
 585                ret = error(_("failed to find tree of %s"),
 586                            oid_to_hex(&head_oid));
 587                goto leave_reset_head;
 588        }
 589
 590        if (!fill_tree_descriptor(&desc[nr++], oid)) {
 591                ret = error(_("failed to find tree of %s"), oid_to_hex(oid));
 592                goto leave_reset_head;
 593        }
 594
 595        if (unpack_trees(nr, desc, &unpack_tree_opts)) {
 596                ret = -1;
 597                goto leave_reset_head;
 598        }
 599
 600        tree = parse_tree_indirect(oid);
 601        prime_cache_tree(the_repository->index, tree);
 602
 603        if (write_locked_index(the_repository->index, &lock, COMMIT_LOCK) < 0) {
 604                ret = error(_("could not write index"));
 605                goto leave_reset_head;
 606        }
 607
 608        reflog_action = getenv(GIT_REFLOG_ACTION_ENVIRONMENT);
 609        strbuf_addf(&msg, "%s: ", reflog_action ? reflog_action : "rebase");
 610        prefix_len = msg.len;
 611
 612        if (!get_oid("ORIG_HEAD", &oid_old_orig))
 613                old_orig = &oid_old_orig;
 614        if (!get_oid("HEAD", &oid_orig)) {
 615                orig = &oid_orig;
 616                if (!reflog_orig_head) {
 617                        strbuf_addstr(&msg, "updating ORIG_HEAD");
 618                        reflog_orig_head = msg.buf;
 619                }
 620                update_ref(reflog_orig_head, "ORIG_HEAD", orig, old_orig, 0,
 621                           UPDATE_REFS_MSG_ON_ERR);
 622        } else if (old_orig)
 623                delete_ref(NULL, "ORIG_HEAD", old_orig, 0);
 624        if (!reflog_head) {
 625                strbuf_setlen(&msg, prefix_len);
 626                strbuf_addstr(&msg, "updating HEAD");
 627                reflog_head = msg.buf;
 628        }
 629        if (!switch_to_branch)
 630                ret = update_ref(reflog_head, "HEAD", oid, orig,
 631                                 detach_head ? REF_NO_DEREF : 0,
 632                                 UPDATE_REFS_MSG_ON_ERR);
 633        else {
 634                ret = create_symref("HEAD", switch_to_branch, msg.buf);
 635                if (!ret)
 636                        ret = update_ref(reflog_head, "HEAD", oid, NULL, 0,
 637                                         UPDATE_REFS_MSG_ON_ERR);
 638        }
 639
 640leave_reset_head:
 641        strbuf_release(&msg);
 642        rollback_lock_file(&lock);
 643        while (nr)
 644                free((void *)desc[--nr].buffer);
 645        return ret;
 646}
 647
 648static int rebase_config(const char *var, const char *value, void *data)
 649{
 650        struct rebase_options *opts = data;
 651
 652        if (!strcmp(var, "rebase.stat")) {
 653                if (git_config_bool(var, value))
 654                        opts->flags |= REBASE_DIFFSTAT;
 655                else
 656                        opts->flags &= !REBASE_DIFFSTAT;
 657                return 0;
 658        }
 659
 660        if (!strcmp(var, "rebase.autosquash")) {
 661                opts->autosquash = git_config_bool(var, value);
 662                return 0;
 663        }
 664
 665        if (!strcmp(var, "commit.gpgsign")) {
 666                free(opts->gpg_sign_opt);
 667                opts->gpg_sign_opt = git_config_bool(var, value) ?
 668                        xstrdup("-S") : NULL;
 669                return 0;
 670        }
 671
 672        if (!strcmp(var, "rebase.autostash")) {
 673                opts->autostash = git_config_bool(var, value);
 674                return 0;
 675        }
 676
 677        return git_default_config(var, value, data);
 678}
 679
 680/*
 681 * Determines whether the commits in from..to are linear, i.e. contain
 682 * no merge commits. This function *expects* `from` to be an ancestor of
 683 * `to`.
 684 */
 685static int is_linear_history(struct commit *from, struct commit *to)
 686{
 687        while (to && to != from) {
 688                parse_commit(to);
 689                if (!to->parents)
 690                        return 1;
 691                if (to->parents->next)
 692                        return 0;
 693                to = to->parents->item;
 694        }
 695        return 1;
 696}
 697
 698static int can_fast_forward(struct commit *onto, struct object_id *head_oid,
 699                            struct object_id *merge_base)
 700{
 701        struct commit *head = lookup_commit(the_repository, head_oid);
 702        struct commit_list *merge_bases;
 703        int res;
 704
 705        if (!head)
 706                return 0;
 707
 708        merge_bases = get_merge_bases(onto, head);
 709        if (merge_bases && !merge_bases->next) {
 710                oidcpy(merge_base, &merge_bases->item->object.oid);
 711                res = oideq(merge_base, &onto->object.oid);
 712        } else {
 713                oidcpy(merge_base, &null_oid);
 714                res = 0;
 715        }
 716        free_commit_list(merge_bases);
 717        return res && is_linear_history(onto, head);
 718}
 719
 720/* -i followed by -m is still -i */
 721static int parse_opt_merge(const struct option *opt, const char *arg, int unset)
 722{
 723        struct rebase_options *opts = opt->value;
 724
 725        BUG_ON_OPT_NEG(unset);
 726        BUG_ON_OPT_ARG(arg);
 727
 728        if (!is_interactive(opts))
 729                opts->type = REBASE_MERGE;
 730
 731        return 0;
 732}
 733
 734/* -i followed by -p is still explicitly interactive, but -p alone is not */
 735static int parse_opt_interactive(const struct option *opt, const char *arg,
 736                                 int unset)
 737{
 738        struct rebase_options *opts = opt->value;
 739
 740        BUG_ON_OPT_NEG(unset);
 741        BUG_ON_OPT_ARG(arg);
 742
 743        opts->type = REBASE_INTERACTIVE;
 744        opts->flags |= REBASE_INTERACTIVE_EXPLICIT;
 745
 746        return 0;
 747}
 748
 749static void NORETURN error_on_missing_default_upstream(void)
 750{
 751        struct branch *current_branch = branch_get(NULL);
 752
 753        printf(_("%s\n"
 754                 "Please specify which branch you want to rebase against.\n"
 755                 "See git-rebase(1) for details.\n"
 756                 "\n"
 757                 "    git rebase '<branch>'\n"
 758                 "\n"),
 759                current_branch ? _("There is no tracking information for "
 760                        "the current branch.") :
 761                        _("You are not currently on a branch."));
 762
 763        if (current_branch) {
 764                const char *remote = current_branch->remote_name;
 765
 766                if (!remote)
 767                        remote = _("<remote>");
 768
 769                printf(_("If you wish to set tracking information for this "
 770                         "branch you can do so with:\n"
 771                         "\n"
 772                         "    git branch --set-upstream-to=%s/<branch> %s\n"
 773                         "\n"),
 774                       remote, current_branch->name);
 775        }
 776        exit(1);
 777}
 778
 779static void set_reflog_action(struct rebase_options *options)
 780{
 781        const char *env;
 782        struct strbuf buf = STRBUF_INIT;
 783
 784        if (!is_interactive(options))
 785                return;
 786
 787        env = getenv(GIT_REFLOG_ACTION_ENVIRONMENT);
 788        if (env && strcmp("rebase", env))
 789                return; /* only override it if it is "rebase" */
 790
 791        strbuf_addf(&buf, "rebase -i (%s)", options->action);
 792        setenv(GIT_REFLOG_ACTION_ENVIRONMENT, buf.buf, 1);
 793        strbuf_release(&buf);
 794}
 795
 796int cmd_rebase(int argc, const char **argv, const char *prefix)
 797{
 798        struct rebase_options options = {
 799                .type = REBASE_UNSPECIFIED,
 800                .flags = REBASE_NO_QUIET,
 801                .git_am_opts = ARGV_ARRAY_INIT,
 802                .allow_rerere_autoupdate  = -1,
 803                .allow_empty_message = 1,
 804                .git_format_patch_opt = STRBUF_INIT,
 805        };
 806        const char *branch_name;
 807        int ret, flags, total_argc, in_progress = 0;
 808        int ok_to_skip_pre_rebase = 0;
 809        struct strbuf msg = STRBUF_INIT;
 810        struct strbuf revisions = STRBUF_INIT;
 811        struct strbuf buf = STRBUF_INIT;
 812        struct object_id merge_base;
 813        enum {
 814                NO_ACTION,
 815                ACTION_CONTINUE,
 816                ACTION_SKIP,
 817                ACTION_ABORT,
 818                ACTION_QUIT,
 819                ACTION_EDIT_TODO,
 820                ACTION_SHOW_CURRENT_PATCH,
 821        } action = NO_ACTION;
 822        const char *gpg_sign = NULL;
 823        struct string_list exec = STRING_LIST_INIT_NODUP;
 824        const char *rebase_merges = NULL;
 825        int fork_point = -1;
 826        struct string_list strategy_options = STRING_LIST_INIT_NODUP;
 827        struct object_id squash_onto;
 828        char *squash_onto_name = NULL;
 829        struct option builtin_rebase_options[] = {
 830                OPT_STRING(0, "onto", &options.onto_name,
 831                           N_("revision"),
 832                           N_("rebase onto given branch instead of upstream")),
 833                OPT_BOOL(0, "no-verify", &ok_to_skip_pre_rebase,
 834                         N_("allow pre-rebase hook to run")),
 835                OPT_NEGBIT('q', "quiet", &options.flags,
 836                           N_("be quiet. implies --no-stat"),
 837                           REBASE_NO_QUIET| REBASE_VERBOSE | REBASE_DIFFSTAT),
 838                OPT_BIT('v', "verbose", &options.flags,
 839                        N_("display a diffstat of what changed upstream"),
 840                        REBASE_NO_QUIET | REBASE_VERBOSE | REBASE_DIFFSTAT),
 841                {OPTION_NEGBIT, 'n', "no-stat", &options.flags, NULL,
 842                        N_("do not show diffstat of what changed upstream"),
 843                        PARSE_OPT_NOARG, NULL, REBASE_DIFFSTAT },
 844                OPT_BOOL(0, "signoff", &options.signoff,
 845                         N_("add a Signed-off-by: line to each commit")),
 846                OPT_PASSTHRU_ARGV(0, "ignore-whitespace", &options.git_am_opts,
 847                                  NULL, N_("passed to 'git am'"),
 848                                  PARSE_OPT_NOARG),
 849                OPT_PASSTHRU_ARGV(0, "committer-date-is-author-date",
 850                                  &options.git_am_opts, NULL,
 851                                  N_("passed to 'git am'"), PARSE_OPT_NOARG),
 852                OPT_PASSTHRU_ARGV(0, "ignore-date", &options.git_am_opts, NULL,
 853                                  N_("passed to 'git am'"), PARSE_OPT_NOARG),
 854                OPT_PASSTHRU_ARGV('C', NULL, &options.git_am_opts, N_("n"),
 855                                  N_("passed to 'git apply'"), 0),
 856                OPT_PASSTHRU_ARGV(0, "whitespace", &options.git_am_opts,
 857                                  N_("action"), N_("passed to 'git apply'"), 0),
 858                OPT_BIT('f', "force-rebase", &options.flags,
 859                        N_("cherry-pick all commits, even if unchanged"),
 860                        REBASE_FORCE),
 861                OPT_BIT(0, "no-ff", &options.flags,
 862                        N_("cherry-pick all commits, even if unchanged"),
 863                        REBASE_FORCE),
 864                OPT_CMDMODE(0, "continue", &action, N_("continue"),
 865                            ACTION_CONTINUE),
 866                OPT_CMDMODE(0, "skip", &action,
 867                            N_("skip current patch and continue"), ACTION_SKIP),
 868                OPT_CMDMODE(0, "abort", &action,
 869                            N_("abort and check out the original branch"),
 870                            ACTION_ABORT),
 871                OPT_CMDMODE(0, "quit", &action,
 872                            N_("abort but keep HEAD where it is"), ACTION_QUIT),
 873                OPT_CMDMODE(0, "edit-todo", &action, N_("edit the todo list "
 874                            "during an interactive rebase"), ACTION_EDIT_TODO),
 875                OPT_CMDMODE(0, "show-current-patch", &action,
 876                            N_("show the patch file being applied or merged"),
 877                            ACTION_SHOW_CURRENT_PATCH),
 878                { OPTION_CALLBACK, 'm', "merge", &options, NULL,
 879                        N_("use merging strategies to rebase"),
 880                        PARSE_OPT_NOARG | PARSE_OPT_NONEG,
 881                        parse_opt_merge },
 882                { OPTION_CALLBACK, 'i', "interactive", &options, NULL,
 883                        N_("let the user edit the list of commits to rebase"),
 884                        PARSE_OPT_NOARG | PARSE_OPT_NONEG,
 885                        parse_opt_interactive },
 886                OPT_SET_INT('p', "preserve-merges", &options.type,
 887                            N_("try to recreate merges instead of ignoring "
 888                               "them"), REBASE_PRESERVE_MERGES),
 889                OPT_BOOL(0, "rerere-autoupdate",
 890                         &options.allow_rerere_autoupdate,
 891                         N_("allow rerere to update index with resolved "
 892                            "conflict")),
 893                OPT_BOOL('k', "keep-empty", &options.keep_empty,
 894                         N_("preserve empty commits during rebase")),
 895                OPT_BOOL(0, "autosquash", &options.autosquash,
 896                         N_("move commits that begin with "
 897                            "squash!/fixup! under -i")),
 898                { OPTION_STRING, 'S', "gpg-sign", &gpg_sign, N_("key-id"),
 899                        N_("GPG-sign commits"),
 900                        PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
 901                OPT_BOOL(0, "autostash", &options.autostash,
 902                         N_("automatically stash/stash pop before and after")),
 903                OPT_STRING_LIST('x', "exec", &exec, N_("exec"),
 904                                N_("add exec lines after each commit of the "
 905                                   "editable list")),
 906                OPT_BOOL(0, "allow-empty-message",
 907                         &options.allow_empty_message,
 908                         N_("allow rebasing commits with empty messages")),
 909                {OPTION_STRING, 'r', "rebase-merges", &rebase_merges,
 910                        N_("mode"),
 911                        N_("try to rebase merges instead of skipping them"),
 912                        PARSE_OPT_OPTARG, NULL, (intptr_t)""},
 913                OPT_BOOL(0, "fork-point", &fork_point,
 914                         N_("use 'merge-base --fork-point' to refine upstream")),
 915                OPT_STRING('s', "strategy", &options.strategy,
 916                           N_("strategy"), N_("use the given merge strategy")),
 917                OPT_STRING_LIST('X', "strategy-option", &strategy_options,
 918                                N_("option"),
 919                                N_("pass the argument through to the merge "
 920                                   "strategy")),
 921                OPT_BOOL(0, "root", &options.root,
 922                         N_("rebase all reachable commits up to the root(s)")),
 923                OPT_END(),
 924        };
 925        int i;
 926
 927        /*
 928         * NEEDSWORK: Once the builtin rebase has been tested enough
 929         * and git-legacy-rebase.sh is retired to contrib/, this preamble
 930         * can be removed.
 931         */
 932
 933        if (!use_builtin_rebase()) {
 934                const char *path = mkpath("%s/git-legacy-rebase",
 935                                          git_exec_path());
 936
 937                if (sane_execvp(path, (char **)argv) < 0)
 938                        die_errno(_("could not exec %s"), path);
 939                else
 940                        BUG("sane_execvp() returned???");
 941        }
 942
 943        if (argc == 2 && !strcmp(argv[1], "-h"))
 944                usage_with_options(builtin_rebase_usage,
 945                                   builtin_rebase_options);
 946
 947        prefix = setup_git_directory();
 948        trace_repo_setup(prefix);
 949        setup_work_tree();
 950
 951        git_config(rebase_config, &options);
 952
 953        strbuf_reset(&buf);
 954        strbuf_addf(&buf, "%s/applying", apply_dir());
 955        if(file_exists(buf.buf))
 956                die(_("It looks like 'git am' is in progress. Cannot rebase."));
 957
 958        if (is_directory(apply_dir())) {
 959                options.type = REBASE_AM;
 960                options.state_dir = apply_dir();
 961        } else if (is_directory(merge_dir())) {
 962                strbuf_reset(&buf);
 963                strbuf_addf(&buf, "%s/rewritten", merge_dir());
 964                if (is_directory(buf.buf)) {
 965                        options.type = REBASE_PRESERVE_MERGES;
 966                        options.flags |= REBASE_INTERACTIVE_EXPLICIT;
 967                } else {
 968                        strbuf_reset(&buf);
 969                        strbuf_addf(&buf, "%s/interactive", merge_dir());
 970                        if(file_exists(buf.buf)) {
 971                                options.type = REBASE_INTERACTIVE;
 972                                options.flags |= REBASE_INTERACTIVE_EXPLICIT;
 973                        } else
 974                                options.type = REBASE_MERGE;
 975                }
 976                options.state_dir = merge_dir();
 977        }
 978
 979        if (options.type != REBASE_UNSPECIFIED)
 980                in_progress = 1;
 981
 982        total_argc = argc;
 983        argc = parse_options(argc, argv, prefix,
 984                             builtin_rebase_options,
 985                             builtin_rebase_usage, 0);
 986
 987        if (action != NO_ACTION && total_argc != 2) {
 988                usage_with_options(builtin_rebase_usage,
 989                                   builtin_rebase_options);
 990        }
 991
 992        if (argc > 2)
 993                usage_with_options(builtin_rebase_usage,
 994                                   builtin_rebase_options);
 995
 996        if (action != NO_ACTION && !in_progress)
 997                die(_("No rebase in progress?"));
 998        setenv(GIT_REFLOG_ACTION_ENVIRONMENT, "rebase", 0);
 999
1000        if (action == ACTION_EDIT_TODO && !is_interactive(&options))
1001                die(_("The --edit-todo action can only be used during "
1002                      "interactive rebase."));
1003
1004        switch (action) {
1005        case ACTION_CONTINUE: {
1006                struct object_id head;
1007                struct lock_file lock_file = LOCK_INIT;
1008                int fd;
1009
1010                options.action = "continue";
1011                set_reflog_action(&options);
1012
1013                /* Sanity check */
1014                if (get_oid("HEAD", &head))
1015                        die(_("Cannot read HEAD"));
1016
1017                fd = hold_locked_index(&lock_file, 0);
1018                if (read_index(the_repository->index) < 0)
1019                        die(_("could not read index"));
1020                refresh_index(the_repository->index, REFRESH_QUIET, NULL, NULL,
1021                              NULL);
1022                if (0 <= fd)
1023                        update_index_if_able(the_repository->index,
1024                                             &lock_file);
1025                rollback_lock_file(&lock_file);
1026
1027                if (has_unstaged_changes(1)) {
1028                        puts(_("You must edit all merge conflicts and then\n"
1029                               "mark them as resolved using git add"));
1030                        exit(1);
1031                }
1032                if (read_basic_state(&options))
1033                        exit(1);
1034                goto run_rebase;
1035        }
1036        case ACTION_SKIP: {
1037                struct string_list merge_rr = STRING_LIST_INIT_DUP;
1038
1039                options.action = "skip";
1040                set_reflog_action(&options);
1041
1042                rerere_clear(&merge_rr);
1043                string_list_clear(&merge_rr, 1);
1044
1045                if (reset_head(NULL, "reset", NULL, RESET_HEAD_HARD,
1046                               NULL, NULL) < 0)
1047                        die(_("could not discard worktree changes"));
1048                remove_branch_state();
1049                if (read_basic_state(&options))
1050                        exit(1);
1051                goto run_rebase;
1052        }
1053        case ACTION_ABORT: {
1054                struct string_list merge_rr = STRING_LIST_INIT_DUP;
1055                options.action = "abort";
1056                set_reflog_action(&options);
1057
1058                rerere_clear(&merge_rr);
1059                string_list_clear(&merge_rr, 1);
1060
1061                if (read_basic_state(&options))
1062                        exit(1);
1063                if (reset_head(&options.orig_head, "reset",
1064                               options.head_name, RESET_HEAD_HARD,
1065                               NULL, NULL) < 0)
1066                        die(_("could not move back to %s"),
1067                            oid_to_hex(&options.orig_head));
1068                remove_branch_state();
1069                ret = finish_rebase(&options);
1070                goto cleanup;
1071        }
1072        case ACTION_QUIT: {
1073                strbuf_reset(&buf);
1074                strbuf_addstr(&buf, options.state_dir);
1075                ret = !!remove_dir_recursively(&buf, 0);
1076                if (ret)
1077                        die(_("could not remove '%s'"), options.state_dir);
1078                goto cleanup;
1079        }
1080        case ACTION_EDIT_TODO:
1081                options.action = "edit-todo";
1082                options.dont_finish_rebase = 1;
1083                goto run_rebase;
1084        case ACTION_SHOW_CURRENT_PATCH:
1085                options.action = "show-current-patch";
1086                options.dont_finish_rebase = 1;
1087                goto run_rebase;
1088        case NO_ACTION:
1089                break;
1090        default:
1091                BUG("action: %d", action);
1092        }
1093
1094        /* Make sure no rebase is in progress */
1095        if (in_progress) {
1096                const char *last_slash = strrchr(options.state_dir, '/');
1097                const char *state_dir_base =
1098                        last_slash ? last_slash + 1 : options.state_dir;
1099                const char *cmd_live_rebase =
1100                        "git rebase (--continue | --abort | --skip)";
1101                strbuf_reset(&buf);
1102                strbuf_addf(&buf, "rm -fr \"%s\"", options.state_dir);
1103                die(_("It seems that there is already a %s directory, and\n"
1104                      "I wonder if you are in the middle of another rebase.  "
1105                      "If that is the\n"
1106                      "case, please try\n\t%s\n"
1107                      "If that is not the case, please\n\t%s\n"
1108                      "and run me again.  I am stopping in case you still "
1109                      "have something\n"
1110                      "valuable there.\n"),
1111                    state_dir_base, cmd_live_rebase, buf.buf);
1112        }
1113
1114        for (i = 0; i < options.git_am_opts.argc; i++) {
1115                const char *option = options.git_am_opts.argv[i], *p;
1116                if (!strcmp(option, "--committer-date-is-author-date") ||
1117                    !strcmp(option, "--ignore-date") ||
1118                    !strcmp(option, "--whitespace=fix") ||
1119                    !strcmp(option, "--whitespace=strip"))
1120                        options.flags |= REBASE_FORCE;
1121                else if (skip_prefix(option, "-C", &p)) {
1122                        while (*p)
1123                                if (!isdigit(*(p++)))
1124                                        die(_("switch `C' expects a "
1125                                              "numerical value"));
1126                } else if (skip_prefix(option, "--whitespace=", &p)) {
1127                        if (*p && strcmp(p, "warn") && strcmp(p, "nowarn") &&
1128                            strcmp(p, "error") && strcmp(p, "error-all"))
1129                                die("Invalid whitespace option: '%s'", p);
1130                }
1131        }
1132
1133        if (!(options.flags & REBASE_NO_QUIET))
1134                argv_array_push(&options.git_am_opts, "-q");
1135
1136        if (options.keep_empty)
1137                imply_interactive(&options, "--keep-empty");
1138
1139        if (gpg_sign) {
1140                free(options.gpg_sign_opt);
1141                options.gpg_sign_opt = xstrfmt("-S%s", gpg_sign);
1142        }
1143
1144        if (exec.nr) {
1145                int i;
1146
1147                imply_interactive(&options, "--exec");
1148
1149                strbuf_reset(&buf);
1150                for (i = 0; i < exec.nr; i++)
1151                        strbuf_addf(&buf, "exec %s\n", exec.items[i].string);
1152                options.cmd = xstrdup(buf.buf);
1153        }
1154
1155        if (rebase_merges) {
1156                if (!*rebase_merges)
1157                        ; /* default mode; do nothing */
1158                else if (!strcmp("rebase-cousins", rebase_merges))
1159                        options.rebase_cousins = 1;
1160                else if (strcmp("no-rebase-cousins", rebase_merges))
1161                        die(_("Unknown mode: %s"), rebase_merges);
1162                options.rebase_merges = 1;
1163                imply_interactive(&options, "--rebase-merges");
1164        }
1165
1166        if (strategy_options.nr) {
1167                int i;
1168
1169                if (!options.strategy)
1170                        options.strategy = "recursive";
1171
1172                strbuf_reset(&buf);
1173                for (i = 0; i < strategy_options.nr; i++)
1174                        strbuf_addf(&buf, " --%s",
1175                                    strategy_options.items[i].string);
1176                options.strategy_opts = xstrdup(buf.buf);
1177        }
1178
1179        if (options.strategy) {
1180                options.strategy = xstrdup(options.strategy);
1181                switch (options.type) {
1182                case REBASE_AM:
1183                        die(_("--strategy requires --merge or --interactive"));
1184                case REBASE_MERGE:
1185                case REBASE_INTERACTIVE:
1186                case REBASE_PRESERVE_MERGES:
1187                        /* compatible */
1188                        break;
1189                case REBASE_UNSPECIFIED:
1190                        options.type = REBASE_MERGE;
1191                        break;
1192                default:
1193                        BUG("unhandled rebase type (%d)", options.type);
1194                }
1195        }
1196
1197        if (options.root && !options.onto_name)
1198                imply_interactive(&options, "--root without --onto");
1199
1200        if (isatty(2) && options.flags & REBASE_NO_QUIET)
1201                strbuf_addstr(&options.git_format_patch_opt, " --progress");
1202
1203        switch (options.type) {
1204        case REBASE_MERGE:
1205        case REBASE_INTERACTIVE:
1206        case REBASE_PRESERVE_MERGES:
1207                options.state_dir = merge_dir();
1208                break;
1209        case REBASE_AM:
1210                options.state_dir = apply_dir();
1211                break;
1212        default:
1213                /* the default rebase backend is `--am` */
1214                options.type = REBASE_AM;
1215                options.state_dir = apply_dir();
1216                break;
1217        }
1218
1219        if (options.git_am_opts.argc) {
1220                /* all am options except -q are compatible only with --am */
1221                for (i = options.git_am_opts.argc - 1; i >= 0; i--)
1222                        if (strcmp(options.git_am_opts.argv[i], "-q"))
1223                                break;
1224
1225                if (is_interactive(&options) && i >= 0)
1226                        die(_("error: cannot combine interactive options "
1227                              "(--interactive, --exec, --rebase-merges, "
1228                              "--preserve-merges, --keep-empty, --root + "
1229                              "--onto) with am options (%s)"), buf.buf);
1230                if (options.type == REBASE_MERGE && i >= 0)
1231                        die(_("error: cannot combine merge options (--merge, "
1232                              "--strategy, --strategy-option) with am options "
1233                              "(%s)"), buf.buf);
1234        }
1235
1236        if (options.signoff) {
1237                if (options.type == REBASE_PRESERVE_MERGES)
1238                        die("cannot combine '--signoff' with "
1239                            "'--preserve-merges'");
1240                argv_array_push(&options.git_am_opts, "--signoff");
1241                options.flags |= REBASE_FORCE;
1242        }
1243
1244        if (options.type == REBASE_PRESERVE_MERGES)
1245                /*
1246                 * Note: incompatibility with --signoff handled in signoff block above
1247                 * Note: incompatibility with --interactive is just a strong warning;
1248                 *       git-rebase.txt caveats with "unless you know what you are doing"
1249                 */
1250                if (options.rebase_merges)
1251                        die(_("error: cannot combine '--preserve-merges' with "
1252                              "'--rebase-merges'"));
1253
1254        if (options.rebase_merges) {
1255                if (strategy_options.nr)
1256                        die(_("error: cannot combine '--rebase-merges' with "
1257                              "'--strategy-option'"));
1258                if (options.strategy)
1259                        die(_("error: cannot combine '--rebase-merges' with "
1260                              "'--strategy'"));
1261        }
1262
1263        if (!options.root) {
1264                if (argc < 1) {
1265                        struct branch *branch;
1266
1267                        branch = branch_get(NULL);
1268                        options.upstream_name = branch_get_upstream(branch,
1269                                                                    NULL);
1270                        if (!options.upstream_name)
1271                                error_on_missing_default_upstream();
1272                        if (fork_point < 0)
1273                                fork_point = 1;
1274                } else {
1275                        options.upstream_name = argv[0];
1276                        argc--;
1277                        argv++;
1278                        if (!strcmp(options.upstream_name, "-"))
1279                                options.upstream_name = "@{-1}";
1280                }
1281                options.upstream = peel_committish(options.upstream_name);
1282                if (!options.upstream)
1283                        die(_("invalid upstream '%s'"), options.upstream_name);
1284                options.upstream_arg = options.upstream_name;
1285        } else {
1286                if (!options.onto_name) {
1287                        if (commit_tree("", 0, the_hash_algo->empty_tree, NULL,
1288                                        &squash_onto, NULL, NULL) < 0)
1289                                die(_("Could not create new root commit"));
1290                        options.squash_onto = &squash_onto;
1291                        options.onto_name = squash_onto_name =
1292                                xstrdup(oid_to_hex(&squash_onto));
1293                }
1294                options.upstream_name = NULL;
1295                options.upstream = NULL;
1296                if (argc > 1)
1297                        usage_with_options(builtin_rebase_usage,
1298                                           builtin_rebase_options);
1299                options.upstream_arg = "--root";
1300        }
1301
1302        /* Make sure the branch to rebase onto is valid. */
1303        if (!options.onto_name)
1304                options.onto_name = options.upstream_name;
1305        if (strstr(options.onto_name, "...")) {
1306                if (get_oid_mb(options.onto_name, &merge_base) < 0)
1307                        die(_("'%s': need exactly one merge base"),
1308                            options.onto_name);
1309                options.onto = lookup_commit_or_die(&merge_base,
1310                                                    options.onto_name);
1311        } else {
1312                options.onto = peel_committish(options.onto_name);
1313                if (!options.onto)
1314                        die(_("Does not point to a valid commit '%s'"),
1315                                options.onto_name);
1316        }
1317
1318        /*
1319         * If the branch to rebase is given, that is the branch we will rebase
1320         * branch_name -- branch/commit being rebased, or
1321         *                HEAD (already detached)
1322         * orig_head -- commit object name of tip of the branch before rebasing
1323         * head_name -- refs/heads/<that-branch> or NULL (detached HEAD)
1324         */
1325        if (argc == 1) {
1326                /* Is it "rebase other branchname" or "rebase other commit"? */
1327                branch_name = argv[0];
1328                options.switch_to = argv[0];
1329
1330                /* Is it a local branch? */
1331                strbuf_reset(&buf);
1332                strbuf_addf(&buf, "refs/heads/%s", branch_name);
1333                if (!read_ref(buf.buf, &options.orig_head))
1334                        options.head_name = xstrdup(buf.buf);
1335                /* If not is it a valid ref (branch or commit)? */
1336                else if (!get_oid(branch_name, &options.orig_head))
1337                        options.head_name = NULL;
1338                else
1339                        die(_("fatal: no such branch/commit '%s'"),
1340                            branch_name);
1341        } else if (argc == 0) {
1342                /* Do not need to switch branches, we are already on it. */
1343                options.head_name =
1344                        xstrdup_or_null(resolve_ref_unsafe("HEAD", 0, NULL,
1345                                         &flags));
1346                if (!options.head_name)
1347                        die(_("No such ref: %s"), "HEAD");
1348                if (flags & REF_ISSYMREF) {
1349                        if (!skip_prefix(options.head_name,
1350                                         "refs/heads/", &branch_name))
1351                                branch_name = options.head_name;
1352
1353                } else {
1354                        free(options.head_name);
1355                        options.head_name = NULL;
1356                        branch_name = "HEAD";
1357                }
1358                if (get_oid("HEAD", &options.orig_head))
1359                        die(_("Could not resolve HEAD to a revision"));
1360        } else
1361                BUG("unexpected number of arguments left to parse");
1362
1363        if (fork_point > 0) {
1364                struct commit *head =
1365                        lookup_commit_reference(the_repository,
1366                                                &options.orig_head);
1367                options.restrict_revision =
1368                        get_fork_point(options.upstream_name, head);
1369        }
1370
1371        if (read_index(the_repository->index) < 0)
1372                die(_("could not read index"));
1373
1374        if (options.autostash) {
1375                struct lock_file lock_file = LOCK_INIT;
1376                int fd;
1377
1378                fd = hold_locked_index(&lock_file, 0);
1379                refresh_cache(REFRESH_QUIET);
1380                if (0 <= fd)
1381                        update_index_if_able(&the_index, &lock_file);
1382                rollback_lock_file(&lock_file);
1383
1384                if (has_unstaged_changes(1) || has_uncommitted_changes(1)) {
1385                        const char *autostash =
1386                                state_dir_path("autostash", &options);
1387                        struct child_process stash = CHILD_PROCESS_INIT;
1388                        struct object_id oid;
1389                        struct commit *head =
1390                                lookup_commit_reference(the_repository,
1391                                                        &options.orig_head);
1392
1393                        argv_array_pushl(&stash.args,
1394                                         "stash", "create", "autostash", NULL);
1395                        stash.git_cmd = 1;
1396                        stash.no_stdin = 1;
1397                        strbuf_reset(&buf);
1398                        if (capture_command(&stash, &buf, GIT_MAX_HEXSZ))
1399                                die(_("Cannot autostash"));
1400                        strbuf_trim_trailing_newline(&buf);
1401                        if (get_oid(buf.buf, &oid))
1402                                die(_("Unexpected stash response: '%s'"),
1403                                    buf.buf);
1404                        strbuf_reset(&buf);
1405                        strbuf_add_unique_abbrev(&buf, &oid, DEFAULT_ABBREV);
1406
1407                        if (safe_create_leading_directories_const(autostash))
1408                                die(_("Could not create directory for '%s'"),
1409                                    options.state_dir);
1410                        write_file(autostash, "%s", oid_to_hex(&oid));
1411                        printf(_("Created autostash: %s\n"), buf.buf);
1412                        if (reset_head(&head->object.oid, "reset --hard",
1413                                       NULL, RESET_HEAD_HARD, NULL, NULL) < 0)
1414                                die(_("could not reset --hard"));
1415                        printf(_("HEAD is now at %s"),
1416                               find_unique_abbrev(&head->object.oid,
1417                                                  DEFAULT_ABBREV));
1418                        strbuf_reset(&buf);
1419                        pp_commit_easy(CMIT_FMT_ONELINE, head, &buf);
1420                        if (buf.len > 0)
1421                                printf(" %s", buf.buf);
1422                        putchar('\n');
1423
1424                        if (discard_index(the_repository->index) < 0 ||
1425                                read_index(the_repository->index) < 0)
1426                                die(_("could not read index"));
1427                }
1428        }
1429
1430        if (require_clean_work_tree("rebase",
1431                                    _("Please commit or stash them."), 1, 1)) {
1432                ret = 1;
1433                goto cleanup;
1434        }
1435
1436        /*
1437         * Now we are rebasing commits upstream..orig_head (or with --root,
1438         * everything leading up to orig_head) on top of onto.
1439         */
1440
1441        /*
1442         * Check if we are already based on onto with linear history,
1443         * but this should be done only when upstream and onto are the same
1444         * and if this is not an interactive rebase.
1445         */
1446        if (can_fast_forward(options.onto, &options.orig_head, &merge_base) &&
1447            !is_interactive(&options) && !options.restrict_revision &&
1448            options.upstream &&
1449            !oidcmp(&options.upstream->object.oid, &options.onto->object.oid)) {
1450                int flag;
1451
1452                if (!(options.flags & REBASE_FORCE)) {
1453                        /* Lazily switch to the target branch if needed... */
1454                        if (options.switch_to) {
1455                                struct object_id oid;
1456
1457                                if (get_oid(options.switch_to, &oid) < 0) {
1458                                        ret = !!error(_("could not parse '%s'"),
1459                                                      options.switch_to);
1460                                        goto cleanup;
1461                                }
1462
1463                                strbuf_reset(&buf);
1464                                strbuf_addf(&buf, "%s: checkout %s",
1465                                            getenv(GIT_REFLOG_ACTION_ENVIRONMENT),
1466                                            options.switch_to);
1467                                if (reset_head(&oid, "checkout",
1468                                               options.head_name, 0,
1469                                               NULL, buf.buf) < 0) {
1470                                        ret = !!error(_("could not switch to "
1471                                                        "%s"),
1472                                                      options.switch_to);
1473                                        goto cleanup;
1474                                }
1475                        }
1476
1477                        if (!(options.flags & REBASE_NO_QUIET))
1478                                ; /* be quiet */
1479                        else if (!strcmp(branch_name, "HEAD") &&
1480                                 resolve_ref_unsafe("HEAD", 0, NULL, &flag))
1481                                puts(_("HEAD is up to date."));
1482                        else
1483                                printf(_("Current branch %s is up to date.\n"),
1484                                       branch_name);
1485                        ret = !!finish_rebase(&options);
1486                        goto cleanup;
1487                } else if (!(options.flags & REBASE_NO_QUIET))
1488                        ; /* be quiet */
1489                else if (!strcmp(branch_name, "HEAD") &&
1490                         resolve_ref_unsafe("HEAD", 0, NULL, &flag))
1491                        puts(_("HEAD is up to date, rebase forced."));
1492                else
1493                        printf(_("Current branch %s is up to date, rebase "
1494                                 "forced.\n"), branch_name);
1495        }
1496
1497        /* If a hook exists, give it a chance to interrupt*/
1498        if (!ok_to_skip_pre_rebase &&
1499            run_hook_le(NULL, "pre-rebase", options.upstream_arg,
1500                        argc ? argv[0] : NULL, NULL))
1501                die(_("The pre-rebase hook refused to rebase."));
1502
1503        if (options.flags & REBASE_DIFFSTAT) {
1504                struct diff_options opts;
1505
1506                if (options.flags & REBASE_VERBOSE) {
1507                        if (is_null_oid(&merge_base))
1508                                printf(_("Changes to %s:\n"),
1509                                       oid_to_hex(&options.onto->object.oid));
1510                        else
1511                                printf(_("Changes from %s to %s:\n"),
1512                                       oid_to_hex(&merge_base),
1513                                       oid_to_hex(&options.onto->object.oid));
1514                }
1515
1516                /* We want color (if set), but no pager */
1517                diff_setup(&opts);
1518                opts.stat_width = -1; /* use full terminal width */
1519                opts.stat_graph_width = -1; /* respect statGraphWidth config */
1520                opts.output_format |=
1521                        DIFF_FORMAT_SUMMARY | DIFF_FORMAT_DIFFSTAT;
1522                opts.detect_rename = DIFF_DETECT_RENAME;
1523                diff_setup_done(&opts);
1524                diff_tree_oid(is_null_oid(&merge_base) ?
1525                              the_hash_algo->empty_tree : &merge_base,
1526                              &options.onto->object.oid, "", &opts);
1527                diffcore_std(&opts);
1528                diff_flush(&opts);
1529        }
1530
1531        if (is_interactive(&options))
1532                goto run_rebase;
1533
1534        /* Detach HEAD and reset the tree */
1535        if (options.flags & REBASE_NO_QUIET)
1536                printf(_("First, rewinding head to replay your work on top of "
1537                         "it...\n"));
1538
1539        strbuf_addf(&msg, "%s: checkout %s",
1540                    getenv(GIT_REFLOG_ACTION_ENVIRONMENT), options.onto_name);
1541        if (reset_head(&options.onto->object.oid, "checkout", NULL,
1542                       RESET_HEAD_DETACH, NULL, msg.buf))
1543                die(_("Could not detach HEAD"));
1544        strbuf_release(&msg);
1545
1546        /*
1547         * If the onto is a proper descendant of the tip of the branch, then
1548         * we just fast-forwarded.
1549         */
1550        strbuf_reset(&msg);
1551        if (!oidcmp(&merge_base, &options.orig_head)) {
1552                printf(_("Fast-forwarded %s to %s.\n"),
1553                        branch_name, options.onto_name);
1554                strbuf_addf(&msg, "rebase finished: %s onto %s",
1555                        options.head_name ? options.head_name : "detached HEAD",
1556                        oid_to_hex(&options.onto->object.oid));
1557                reset_head(NULL, "Fast-forwarded", options.head_name, 0,
1558                           "HEAD", msg.buf);
1559                strbuf_release(&msg);
1560                ret = !!finish_rebase(&options);
1561                goto cleanup;
1562        }
1563
1564        strbuf_addf(&revisions, "%s..%s",
1565                    options.root ? oid_to_hex(&options.onto->object.oid) :
1566                    (options.restrict_revision ?
1567                     oid_to_hex(&options.restrict_revision->object.oid) :
1568                     oid_to_hex(&options.upstream->object.oid)),
1569                    oid_to_hex(&options.orig_head));
1570
1571        options.revisions = revisions.buf;
1572
1573run_rebase:
1574        ret = !!run_specific_rebase(&options);
1575
1576cleanup:
1577        strbuf_release(&revisions);
1578        free(options.head_name);
1579        free(options.gpg_sign_opt);
1580        free(options.cmd);
1581        free(squash_onto_name);
1582        return ret;
1583}