git
/
sequencer.c
6817 строк · 188.3 Кб
1#define USE_THE_REPOSITORY_VARIABLE2/*54* To accommodate common filesystem limitations, where the loose refs' file55* names must not exceed `NAME_MAX`, the labels generated by `git rebase56* --rebase-merges` need to be truncated if the corresponding commit subjects57* are too long.58* Add some margin to stay clear from reaching `NAME_MAX`.59*/60#define GIT_MAX_LABEL_LENGTH ((NAME_MAX) - (LOCK_SUFFIX_LEN) - 16)61/*76* The file containing rebase commands, comments, and empty lines.77* This file is created by "git rebase -i" then edited by the user. As78* the lines are processed, they are removed from the front of this79* file and written to the tail of 'done'.80*/81GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")82GIT_PATH_FUNC(rebase_path_todo_backup, "rebase-merge/git-rebase-todo.backup")83/*87* The rebase command lines that have already been processed. A line88* is moved here when it is first handled, before any associated user89* actions.90*/91static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")92/*93* The file to keep track of how many commands were already processed (e.g.94* for the prompt).95*/96static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum")97/*98* The file to keep track of how many commands are to be processed in total99* (e.g. for the prompt).100*/101static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end")102/*103* The commit message that is planned to be used for any changes that104* need to be committed following a user interaction.105*/106static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")107/*108* The file into which is accumulated the suggested commit message for109* squash/fixup commands. When the first of a series of squash/fixups110* is seen, the file is created and the commit message from the111* previous commit and from the first squash/fixup commit are written112* to it. The commit message for each subsequent squash/fixup commit113* is appended to the file as it is processed.114*/115static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")116/*117* If the current series of squash/fixups has not yet included a squash118* command, then this file exists and holds the commit message of the119* original "pick" commit. (If the series ends without a "squash"120* command, then this can be used as the commit message of the combined121* commit without opening the editor.)122*/123static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")124/*125* This file contains the list fixup/squash commands that have been126* accumulated into message-fixup or message-squash so far.127*/128static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")129/*130* A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and131* GIT_AUTHOR_DATE that will be used for the commit that is currently132* being rebased.133*/134static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")135/*136* When an "edit" rebase command is being processed, the SHA1 of the137* commit to be edited is recorded in this file. When "git rebase138* --continue" is executed, if there are any staged changes then they139* will be amended to the HEAD commit, but only provided the HEAD140* commit is still the commit to be edited. When any other rebase141* command is processed, this file is deleted.142*/143static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")144/*145* When we stop at a given patch via the "edit" command, this file contains146* the commit object name of the corresponding patch.147*/148static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")149/*150* When we stop for the user to resolve conflicts this file contains151* the patch of the commit that is being picked.152*/153static GIT_PATH_FUNC(rebase_path_patch, "rebase-merge/patch")154/*155* For the post-rewrite hook, we make a list of rewritten commits and156* their new sha1s. The rewritten-pending list keeps the sha1s of157* commits that have been processed, but not committed yet,158* e.g. because they are waiting for a 'squash' command.159*/160static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")161static GIT_PATH_FUNC(rebase_path_rewritten_pending,162"rebase-merge/rewritten-pending")163/*165* The path of the file containing the OID of the "squash onto" commit, i.e.166* the dummy commit used for `reset [new root]`.167*/168static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")169/*171* The path of the file listing refs that need to be deleted after the rebase172* finishes. This is used by the `label` command to record the need for cleanup.173*/174static GIT_PATH_FUNC(rebase_path_refs_to_delete, "rebase-merge/refs-to-delete")175/*177* The update-refs file stores a list of refs that will be updated at the end178* of the rebase sequence. The 'update-ref <ref>' commands in the todo file179* update the OIDs for the refs in this file, but the refs are not updated180* until the end of the rebase sequence.181*182* rebase_path_update_refs() returns the path to this file for a given183* worktree directory. For the current worktree, pass the_repository->gitdir.184*/185static char *rebase_path_update_refs(const char *wt_git_dir)186{187return xstrfmt("%s/rebase-merge/update-refs", wt_git_dir);188}189/*191* The following files are written by git-rebase just after parsing the192* command-line.193*/194static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")195static GIT_PATH_FUNC(rebase_path_cdate_is_adate, "rebase-merge/cdate_is_adate")196static GIT_PATH_FUNC(rebase_path_ignore_date, "rebase-merge/ignore_date")197static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")198static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")199static GIT_PATH_FUNC(rebase_path_quiet, "rebase-merge/quiet")200static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")201static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")202static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")203static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")204static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")205static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")206static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")207static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec, "rebase-merge/reschedule-failed-exec")208static GIT_PATH_FUNC(rebase_path_no_reschedule_failed_exec, "rebase-merge/no-reschedule-failed-exec")209static GIT_PATH_FUNC(rebase_path_drop_redundant_commits, "rebase-merge/drop_redundant_commits")210static GIT_PATH_FUNC(rebase_path_keep_redundant_commits, "rebase-merge/keep_redundant_commits")211/*213* A 'struct replay_ctx' represents the private state of the sequencer.214*/215struct replay_ctx {216/*217* The commit message that will be used except at the end of a218* chain of fixup and squash commands.219*/220struct strbuf message;221/*222* The list of completed fixup and squash commands in the223* current chain.224*/225struct strbuf current_fixups;226/*227* Stores the reflog message that will be used when creating a228* commit. Points to a static buffer and should not be free()'d.229*/230const char *reflog_message;231/*232* The number of completed fixup and squash commands in the233* current chain.234*/235int current_fixup_count;236/*237* Whether message contains a commit message.238*/239unsigned have_message :1;240};241{244struct replay_ctx *ctx = xcalloc(1, sizeof(*ctx));245}251/**253* A 'struct update_refs_record' represents a value in the update-refs254* list. We use a string_list to map refs to these (before, after) pairs.255*/256struct update_ref_record {257struct object_id before;258struct object_id after;259};260{263struct update_ref_record *rec;264}275{279struct replay_opts *opts = cb;280* pull.twohead is allowed to be multi-valued; we only316* care about the first value.317*/318char *tmp = strchr(opts->default_strategy, ' ');319if (tmp)320*tmp = '\0';321}322return ret;323}324}330{333opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;334git_config(git_sequencer_config, opts);335}336{339return opts->action == REPLAY_INTERACTIVE_REBASE;340}341{344if (is_rebase_i(opts))345return rebase_path();346return git_path_seq_dir();347}348{351if (is_rebase_i(opts))352return rebase_path_todo();353return git_path_todo_file();354}355/*357* Returns 0 for non-conforming footer358* Returns 1 for conforming footer359* Returns 2 when sob exists within conforming footer360* Returns 3 when sob exists within conforming footer as last entry361*/362static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,363size_t ignore_footer)364{365struct trailer_iterator iter;366size_t i = 0;367int found_sob = 0, found_sob_last = 0;368char saved_char;369}398{401static struct strbuf buf = STRBUF_INIT;402}408{411strbuf_release(&ctx->current_fixups);412strbuf_release(&ctx->message);413}414{417struct replay_ctx *ctx = opts->ctx;418}430{433struct strbuf buf = STRBUF_INIT;434int ret = 0;435}461{464switch (opts->action) {465case REPLAY_REVERT:466return N_("revert");467case REPLAY_PICK:468return N_("cherry-pick");469case REPLAY_INTERACTIVE_REBASE:470return N_("rebase");471}472die(_("unknown action: %d"), opts->action);473}474{484return repo_find_unique_abbrev(r, &commit->object.oid, DEFAULT_ABBREV);485}486{489const char *abbrev, *subject;490int subject_len;491}504{507free(msg->parent_label);508free(msg->label);509free(msg->subject);510repo_unuse_commit_buffer(the_repository, commit, msg->message);511}512"\"git add/rm <conflicted_files>\", then run \"git rebase --continue\".\n"516"You can instead skip this commit: run \"git rebase --skip\".\n"517"To abort and get back to the state before \"git rebase\", run "518"\"git rebase --abort\".");519{523const char *msg;524* A conflict has occurred but the porcelain534* (typically rebase --interactive) wants to take care535* of the commit itself so remove CHERRY_PICK_HEAD536*/537refs_delete_ref(get_main_ref_store(r), "", "CHERRY_PICK_HEAD",538NULL, REF_NO_DEREF);539return;540}541}567{571struct lock_file msg_file = LOCK_INIT;572}591{595int orig_len = buf->len;596}615{618return lookup_tree(r, the_hash_algo->empty_tree);619}620{623if (repo_read_index_unmerged(repo))624return error_resolve_conflict(action_name(opts));625}633{636struct object_id head;637}647{654struct ref_transaction *transaction;655struct strbuf sb = STRBUF_INIT;656struct strbuf err = STRBUF_INIT;657}685{689if (!cleanup_arg || !strcmp(cleanup_arg, "default"))690return use_editor ? COMMIT_MSG_CLEANUP_ALL :691COMMIT_MSG_CLEANUP_SPACE;692else if (!strcmp(cleanup_arg, "verbatim"))693return COMMIT_MSG_CLEANUP_NONE;694else if (!strcmp(cleanup_arg, "whitespace"))695return COMMIT_MSG_CLEANUP_SPACE;696else if (!strcmp(cleanup_arg, "strip"))697return COMMIT_MSG_CLEANUP_ALL;698else if (!strcmp(cleanup_arg, "scissors"))699return use_editor ? COMMIT_MSG_CLEANUP_SCISSORS :700COMMIT_MSG_CLEANUP_SPACE;701else702die(_("Invalid cleanup mode %s"), cleanup_arg);703}704/*706* NB using int rather than enum cleanup_mode to stop clang's707* -Wtautological-constant-out-of-range-compare complaining that the comparison708* is always true.709*/710static const char *describe_cleanup_mode(int cleanup_mode)711{712static const char *modes[] = { "whitespace",713"verbatim",714"scissors",715"strip" };716}722{726int i;727}747{754struct merge_options o;755struct merge_result result;756struct tree *next_tree, *base_tree, *head_tree;757int clean, show_output;758int i;759struct lock_file index_lock = LOCK_INIT;760* TODO: merge_switch_to_result will update index/working tree;790* we only really want to do that if !result.clean || this is791* the final patch to be picked. But determining this is the792* final patch would take some work, and "head_tree" would need793* to be replace with the tree the index matched before we794* started doing any picks.795*/796merge_switch_to_result(&o, head_tree, &result, 1, show_output);797clean = result.clean;798} else {799ensure_full_index(r->index);800clean = merge_trees(&o, head_tree, next_tree, base_tree);801if (is_rebase_i(opts) && clean <= 0)802fputs(o.obuf.buf, stdout);803strbuf_release(&o.obuf);804}805if (clean < 0) {806rollback_lock_file(&index_lock);807return clean;808}809* TRANSLATORS: %s will be "revert", "cherry-pick" or814* "rebase".815*/816return error(_("%s: Unable to write new index file"),817_(action_name(opts)));818}825{828if (!cache_tree_fully_valid(istate->cache_tree))829if (cache_tree_update(istate, 0)) {830error(_("unable to update cache tree"));831return NULL;832}833}836{839struct object_id head_oid, *cache_tree_oid;840const struct object_id *head_tree_oid;841struct commit *head_commit;842struct index_state *istate = r->index;843const char *head_name;844* If head_commit is NULL, check_commit, called from861* lookup_commit, would have indicated that head_commit is not862* a commit object already. repo_parse_commit() will return failure863* without further complaints in such a case. Otherwise, if864* the commit is invalid, repo_parse_commit() will complain. So865* there is nothing for us to say here. Just return failure.866*/867if (repo_parse_commit(r, head_commit))868return -1;869}878{881struct strbuf buf = STRBUF_INIT;882const char *eol;883int res;884}925/**927* Take a series of KEY='VALUE' lines where VALUE part is928* sq-quoted, and append <KEY, VALUE> at the end of the string list929*/930static int parse_key_value_squoted(char *buf, struct string_list *list)931{932while (*buf) {933struct string_list_item *item;934char *np;935char *cp = strchr(buf, '=');936if (!cp) {937np = strchrnul(buf, '\n');938return error(_("no key present in '%.*s'"),939(int) (np - buf), buf);940}941np = strchrnul(cp, '\n');942*cp++ = '\0';943item = string_list_append(list, buf);944}955/**957* Reads and parses the state directory's "author-script" file, and sets name,958* email and date accordingly.959* Returns 0 on success, -1 if the file could not be parsed.960*961* The author script is of the format:962*963* GIT_AUTHOR_NAME='$author_name'964* GIT_AUTHOR_EMAIL='$author_email'965* GIT_AUTHOR_DATE='$author_date'966*967* where $author_name, $author_email and $author_date are quoted. We are strict968* with our parsing, as the file was meant to be eval'd in the now-removed969* git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs970* from what this function expects, it is better to bail out than to do971* something that the user does not expect.972*/973int read_author_script(const char *path, char **name, char **email, char **date,974int allow_missing)975{976struct strbuf buf = STRBUF_INIT;977struct string_list kv = STRING_LIST_INIT_DUP;978int retval = -1; /* assume failure */979int i, name_i = -2, email_i = -2, date_i = -2, err = 0;980}1031/*1033* Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a1034* file with shell quoting into struct strvec. Returns -1 on1035* error, 0 otherwise.1036*/1037static int read_env_script(struct strvec *env)1038{1039char *name, *email, *date;1040}1054{1057size_t len;1058const char *a;1059}1066{1069int i;1070const char *date;1071* If GIT_AUTHOR_DATE is missing we should have already errored out when1078* reading the script1079*/1080BUG("GIT_AUTHOR_DATE missing from author script");1081}1082"If these changes are meant to be squashed into the previous commit, run:\n"1086"\n"1087" git commit --amend %s\n"1088"\n"1089"If they are meant to go into a new commit, run:\n"1090"\n"1091" git commit %s\n"1092"\n"1093"In both cases, once you're done, continue with:\n"1094"\n"1095" git rebase --continue\n");1096{1107struct strbuf buf = STRBUF_INIT;1108int rc;1109}1121/*1123* If we are cherry-pick, and if the merge did not result in1124* hand-editing, we will hit this commit and inherit the original1125* author date and name.1126*1127* If we are revert, or if our cherry-pick results in a hand merge,1128* we had better say that the current user is responsible for that.1129*1130* An exception is when run_git_commit() is called during an1131* interactive rebase: in that case, we will want to retain the1132* author metadata.1133*/1134static int run_git_commit(const char *defmsg,1135struct replay_opts *opts,1136unsigned int flags)1137{1138struct replay_ctx *ctx = opts->ctx;1139struct child_process cmd = CHILD_PROCESS_INIT;1140}1202{1205int i, eol;1206const char *nl;1207}1228{1232if (verbose || /* Truncate the message just before the diff, if any. */1233cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS)1234strbuf_setlen(msgbuf, wt_status_locate_end(msgbuf->buf, msgbuf->len));1235if (cleanup_mode != COMMIT_MSG_CLEANUP_NONE)1236strbuf_stripspace(msgbuf,1237cleanup_mode == COMMIT_MSG_CLEANUP_ALL ? comment_line_str : NULL);1238}1239/*1241* Find out if the message in the strbuf contains only whitespace and1242* Signed-off-by lines.1243*/1244int message_is_empty(const struct strbuf *sb,1245enum commit_msg_cleanup_mode cleanup_mode)1246{1247if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)1248return 0;1249return rest_is_empty(sb, 0);1250}1251/*1253* See if the user edited the message in the editor or left what1254* was in the template intact1255*/1256int template_untouched(const struct strbuf *sb, const char *template_file,1257enum commit_msg_cleanup_mode cleanup_mode)1258{1259struct strbuf tmpl = STRBUF_INIT;1260const char *start;1261}1275{1281struct ref_transaction *transaction;1282struct strbuf sb = STRBUF_INIT;1283const char *nl;1284int ret = 0;1285}1313{1317struct child_process proc = CHILD_PROCESS_INIT;1318int code;1319struct strbuf sb = STRBUF_INIT;1320const char *hook_path = find_hook(the_repository, "post-rewrite");1321}1341{1346struct notes_rewrite_cfg *cfg;1347}1356{1361int ret = 0;1362const char *name, *arg1 = NULL, *arg2 = NULL;1363}1380"on your username and hostname. Please check that they are accurate.\n"1384"You can suppress this message by setting them explicitly. Run the\n"1385"following command and follow the instructions in your editor to edit\n"1386"your configuration file:\n"1387"\n"1388" git config --global --edit\n"1389"\n"1390"After doing this, you may fix the identity used for this commit with:\n"1391"\n"1392" git commit --amend --reset-author\n");1393"on your username and hostname. Please check that they are accurate.\n"1397"You can suppress this message by setting them explicitly:\n"1398"\n"1399" git config --global user.name \"Your Name\"\n"1400" git config --global user.email you@example.com\n"1401"\n"1402"After doing this, you may fix the identity used for this commit with:\n"1403"\n"1404" git commit --amend --reset-author\n");1405{1408char *user_config = interpolate_path("~/.gitconfig", 0);1409char *xdg_config = xdg_config_home("config");1410int config_exists = file_exists(user_config) || file_exists(xdg_config);1411}1421{1427struct rev_info rev;1428struct commit *commit;1429struct strbuf format = STRBUF_INIT;1430const char *head;1431struct pretty_print_context pctx = {0};1432struct strbuf author_ident = STRBUF_INIT;1433struct strbuf committer_ident = STRBUF_INIT;1434struct ref_store *refs;1435}1505{1508struct commit *current_head;1509struct object_id oid;1510}1528/*1530* Try to commit without forking 'git commit'. In some cases we need1531* to run 'git commit' to display an error message1532*1533* Returns:1534* -1 - error unable to commit1535* 0 - success1536* 1 - run 'git commit'1537*/1538static int try_to_commit(struct repository *r,1539struct strbuf *msg, const char *author,1540struct replay_opts *opts, unsigned int flags,1541struct object_id *oid)1542{1543struct replay_ctx *ctx = opts->ctx;1544struct object_id tree;1545struct commit *current_head = NULL;1546struct commit_list *parents = NULL;1547struct commit_extra_header *extra = NULL;1548struct strbuf err = STRBUF_INIT;1549struct strbuf commit_msg = STRBUF_INIT;1550char *amend_author = NULL;1551const char *committer = NULL;1552const char *hook_commit = NULL;1553enum commit_msg_cleanup_mode cleanup;1554int res = 0;1555}1724{1727if (refs_update_ref(get_main_ref_store(the_repository), "rebase", "REBASE_HEAD", oid,1728NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))1729return error(_("could not update %s"), "REBASE_HEAD");1730}1733{1739int res = 1;1740}1772{1775const struct object_id *ptree_oid;1776}1792/*1794* Should empty commits be allowed? Return status:1795* <0: Error in is_index_unchanged(r) or is_original_commit_empty(commit)1796* 0: Halt on empty commit1797* 1: Allow empty commit1798* 2: Drop empty commit1799*/1800static int allow_empty(struct repository *r,1801struct replay_opts *opts,1802struct commit *commit)1803{1804int index_unchanged, originally_empty;1805* For a commit that is initially empty, allow_empty determines if it1808* should be kept or not1809*1810* For a commit that becomes empty, keep_redundant_commits and1811* drop_redundant_commits determine whether the commit should be kept or1812* dropped. If neither is specified, halt.1813*/1814index_unchanged = is_index_unchanged(r);1815if (index_unchanged < 0)1816return index_unchanged;1817if (!index_unchanged)1818return 0; /* we do not have to say --allow-empty */1819}1832{1856if (command < TODO_COMMENT)1857return todo_command_info[command].str;1858if (command == TODO_COMMENT)1859return comment_line_str;1860die(_("unknown command: %d"), command);1861}1862{1865if (command < TODO_COMMENT)1866return todo_command_info[command].c;1867return 0;1868}1869{1872return TODO_NOOP <= command;1873}1874{1877return command == TODO_FIXUP || command == TODO_SQUASH;1878}1879/* Does this command create a (non-merge) commit? */1881static int is_pick_or_similar(enum todo_command command)1882{1883switch (command) {1884case TODO_PICK:1885case TODO_REVERT:1886case TODO_EDIT:1887case TODO_REWORD:1888case TODO_FIXUP:1889case TODO_SQUASH:1890return 1;1891default:1892return 0;1893}1894}1895{1910return command == TODO_FIXUP && ((flag & TODO_REPLACE_FIXUP_MSG) ||1911(flag & TODO_EDIT_FIXUP_MSG));1912}1913/*1915* Wrapper around strbuf_add_commented_lines() which avoids double1916* commenting commit subjects.1917*/1918static void add_commented_lines(struct strbuf *buf, const void *str, size_t len)1919{1920const char *s = str;1921while (starts_with_mem(s, len, comment_line_str)) {1922size_t count;1923const char *n = memchr(s, '\n', len);1924if (!n)1925count = len;1926else1927count = n - s + 1;1928strbuf_add(buf, s, count);1929s += count;1930len -= count;1931}1932strbuf_add_commented_lines(buf, s, len, comment_line_str);1933}1934/* Does the current fixup chain contain a squash command? */1936static int seen_squash(struct replay_ctx *ctx)1937{1938return starts_with(ctx->current_fixups.buf, "squash") ||1939strstr(ctx->current_fixups.buf, "\nsquash");1940}1941{1944strbuf_setlen(buf1, 2);1945strbuf_addf(buf1, _(nth_commit_msg_fmt), n);1946strbuf_addch(buf1, '\n');1947strbuf_setlen(buf2, 2);1948strbuf_addf(buf2, _(skip_nth_commit_msg_fmt), n);1949strbuf_addch(buf2, '\n');1950}1951/*1953* Comment out any un-commented commit messages, updating the message comments1954* to say they will be skipped but do not comment out the empty lines that1955* surround commit messages and their comments.1956*/1957static void update_squash_message_for_fixup(struct strbuf *msg)1958{1959void (*copy_lines)(struct strbuf *, const void *, size_t) = strbuf_add;1960struct strbuf buf1 = STRBUF_INIT, buf2 = STRBUF_INIT;1961const char *s, *start;1962char *orig_msg;1963size_t orig_msg_len;1964int i = 1;1965* Copy the last message, preserving the blank line1975* preceding the current line1976*/1977off = (s > start + 1 && s[-2] == '\n') ? 1 : 0;1978copy_lines(msg, start, s - start - off);1979if (off)1980strbuf_addch(msg, '\n');1981/*1982* The next message needs to be commented out but the1983* message header is already commented out so just copy1984* it and the blank line that follows it.1985*/1986strbuf_addbuf(msg, &buf2);1987if (*next == '\n')1988strbuf_addch(msg, *next++);1989start = s = next;1990copy_lines = add_commented_lines;1991update_comment_bufs(&buf1, &buf2, ++i);1992} else if (skip_prefix(s, buf2.buf, &next)) {1993off = (s > start + 1 && s[-2] == '\n') ? 1 : 0;1994copy_lines(msg, start, s - start - off);1995start = s - off;1996s = next;1997copy_lines = strbuf_add;1998update_comment_bufs(&buf1, &buf2, ++i);1999} else {2000s = strchr(s, '\n');2001if (s)2002s++;2003}2004}2005copy_lines(msg, start, orig_msg_len - (start - orig_msg));2006free(orig_msg);2007strbuf_release(&buf1);2008strbuf_release(&buf2);2009}2010{2015struct replay_ctx *ctx = opts->ctx;2016const char *fixup_msg;2017size_t commented_len = 0, fixup_off;2018/*2019* amend is non-interactive and not normally used with fixup!2020* or squash! commits, so only comment out those subjects when2021* squashing commit messages.2022*/2023if (starts_with(body, "amend!") ||2024((command == TODO_SQUASH || seen_squash(ctx)) &&2025(starts_with(body, "squash!") || starts_with(body, "fixup!"))))2026commented_len = commit_subject_length(body);2027* We're replacing the commit message so we need to2041* append the Signed-off-by: trailer if the user2042* requested '--signoff'.2043*/2044if (opts->signoff)2045append_signoff(buf, 0, 0);2046}2065{2072struct replay_ctx *ctx = opts->ctx;2073struct strbuf buf = STRBUF_INIT;2074int res = 0;2075const char *message, *body;2076const char *encoding = get_commit_output_encoding();2077}2166{2169struct strbuf buf = STRBUF_INIT;2170struct object_id newoid;2171FILE *out;2172}2191{2195FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");2196}2206* Note that we only handle the case of non-conflicted2211* commits; continue_single_pick() handles the conflicted2212* commits itself instead of calling this function.2213*/2214return (opts->action == REPLAY_REVERT && isatty(0)) ? 1 : 0;2215return opts->edit;2216}2217{2221if (opts->commit_use_reference) {2222struct pretty_print_context ctx = {2223.abbrev = DEFAULT_ABBREV,2224.date_mode.type = DATE_SHORT,2225};2226repo_format_commit_message(the_repository, commit,2227"%h (%s, %ad)", msgbuf, &ctx);2228} else {2229strbuf_addstr(msgbuf, oid_to_hex(&commit->object.oid));2230}2231}2232{2238struct replay_ctx *ctx = opts->ctx;2239unsigned int flags = should_edit(opts) ? EDIT_MSG : 0;2240const char *msg_file = should_edit(opts) ? NULL : git_path_merge_msg(r);2241struct object_id head;2242struct commit *base, *next, *parent;2243const char *base_label, *next_label;2244char *author = NULL;2245struct commit_message msg = { NULL, NULL, NULL, NULL };2246int res, unborn = 0, reword = 0, allow, drop_commit;2247enum todo_command command = item->command;2248struct commit *commit = item->commit;2249* We do not intend to commit immediately. We just want to2253* merge the differences in, so let's compute the tree2254* that represents the "current" state for the merge machinery2255* to work on.2256*/2257if (write_index_as_tree(&head, r->index, r->index_file, 0, NULL))2258return error(_("your index file is unmerged."));2259} else {2260unborn = repo_get_oid(r, "HEAD", &head);2261/* Do we want to generate a root commit? */2262if (is_pick_or_similar(command) && opts->have_squash_onto &&2263oideq(&head, &opts->squash_onto)) {2264if (is_fixup(command))2265return error(_("cannot fixup root commit"));2266flags |= CREATE_ROOT_COMMIT;2267unborn = 1;2268} else if (unborn)2269oidcpy(&head, the_hash_algo->empty_tree);2270if (index_differs_from(r, unborn ? empty_tree_oid_hex(the_repository->hash_algo) : "HEAD",2271NULL, 0))2272return error_dirty_index(r, opts);2273}2274discard_index(r->index);2275* Non-first parent explicitly specified as mainline for2298* non-merge commit2299*/2300return error(_("commit %s does not have parent %d"),2301oid_to_hex(&commit->object.oid), opts->mainline);2302else2303parent = commit->parents->item;2304"revert" or "pick", the second %s a SHA1. */2325return error(_("%s: cannot parse parent commit %s"),2326command_to_string(command),2327oid_to_hex(&parent->object.oid));2328* "commit" is an existing commit. We would want to apply2331* the difference it introduces since its first parent "prev"2332* on top of the current HEAD if we are cherry-pick. Or the2333* reverse of it if we are revert.2334*/2335* We don't touch pre-existing repeated reverts, because2349* theoretically these can be nested arbitrarily deeply,2350* thus requiring excessive complexity to deal with.2351*/2352!starts_with(orig_subject, "Revert \"")) {2353strbuf_addstr(&ctx->message, "Reapply \"");2354strbuf_addstr(&ctx->message, orig_subject);2355} else {2356strbuf_addstr(&ctx->message, "Revert \"");2357strbuf_addstr(&ctx->message, msg.subject);2358strbuf_addstr(&ctx->message, "\"");2359}2360strbuf_addstr(&ctx->message, "\n\nThis reverts commit ");2361refer_to_commit(opts, &ctx->message, commit);2362* If the merge was clean or if it failed due to conflict, we write2455* CHERRY_PICK_HEAD for the subsequent invocation of commit to use.2456* However, if the merge did not even start, then we don't want to2457* write it at all.2458*/2459if ((command == TODO_PICK || command == TODO_REWORD ||2460command == TODO_EDIT) && !opts->no_commit &&2461(res == 0 || res == 1) &&2462refs_update_ref(get_main_ref_store(the_repository), NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,2463REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))2464res = -1;2465if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&2466refs_update_ref(get_main_ref_store(the_repository), NULL, "REVERT_HEAD", &commit->object.oid, NULL,2467REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))2468res = -1;2469}2530{2533/*2534* picking (but not reverting) ranges (but not individual revisions)2535* should be done in reverse2536*/2537if (opts->action == REPLAY_PICK && !opts->revs->no_walk)2538opts->revs->reverse ^= 1;2539}2545{2549struct lock_file index_lock = LOCK_INIT;2550int index_fd = repo_hold_locked_index(r, &index_lock, 0);2551if (repo_read_index(r) < 0) {2552rollback_lock_file(&index_lock);2553return error(_("git %s: failed to read the index"),2554action_name(opts));2555}2556refresh_index(r->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);2557* If we are resolving merges in any way other than "ort", then2568* expand the sparse index.2569*/2570if (opts->strategy && strcmp(opts->strategy, "ort"))2571ensure_full_index(r->index);2572return 0;2573}2574{2577strbuf_release(&todo_list->buf);2578FREE_AND_NULL(todo_list->items);2579todo_list->nr = todo_list->alloc = 0;2580}2581{2584ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);2585return todo_list->items + todo_list->nr++;2586}2587{2591return todo_list->buf.buf + item->arg_offset;2592}2593{2596const char *str = todo_command_info[command].str;2597const char nick = todo_command_info[command].c;2598const char *p = *bol;2599}2604{2607switch (command) {2608case TODO_LABEL:2609/*2610* '#' is not a valid label as the merge command uses it to2611* separate merge parents from the commit subject.2612*/2613if (!strcmp(arg, "#") ||2614check_refname_format(arg, REFNAME_ALLOW_ONELEVEL))2615return error(_("'%s' is not a valid label"), arg);2616break;2617}2632{2635switch(command) {2636case TODO_PICK:2637error(_("'%s' does not accept merge commits"),2638todo_command_info[command].str);2639advise_if_enabled(ADVICE_REBASE_TODO_ERROR, _(2640/*2641* TRANSLATORS: 'pick' and 'merge -C' should not be2642* translated.2643*/2644"'pick' does not take a merge commit. If you wanted to\n"2645"replay the merge, use 'merge -C' on the commit."));2646return -1;2647* TRANSLATORS: 'reword' and 'merge -c' should not be2654* translated.2655*/2656"'reword' does not take a merge commit. If you wanted to\n"2657"replay the merge and reword the commit message, use\n"2658"'merge -c' on the commit"));2659return -1;2660* TRANSLATORS: 'edit', 'merge -C' and 'break' should2667* not be translated.2668*/2669"'edit' does not take a merge commit. If you wanted to\n"2670"replay the merge, use 'merge -C' on the commit, and then\n"2671"'break' to give the control back to you so that you can\n"2672"do 'git commit --amend && git rebase --continue'."));2673return -1;2674}2686{2691struct object_id commit_oid;2692char *end_of_object_name;2693int i, saved, status, padding;2694}2800{2803const char *todo_file, *bol;2804struct strbuf buf = STRBUF_INIT;2805int ret = 0;2806}2827{2831struct todo_item *item;2832char *p = buf, *next_p;2833int i, res = 0, fixup_okay = file_exists(rebase_path_done());2834}2870{2873int count = 0, i;2874}2881{2884return index < todo_list->nr ?2885todo_list->items[index].offset_in_buf : todo_list->buf.len;2886}2887{2890return todo_list->buf.buf + get_item_line_offset(todo_list, index);2891}2892{2895return get_item_line_offset(todo_list, index + 1)2896- get_item_line_offset(todo_list, index);2897}2898{2901int fd;2902ssize_t len;2903}2913{2916struct strbuf buf = STRBUF_INIT;2917const char *eol;2918const char *todo_path = git_path_todo_file();2919int ret = 0;2920}2938{2941struct replay_opts opts = REPLAY_OPTS_INIT;2942int need_cleanup = 0;2943}2975{2978FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");2979}2985{2990const char *todo_file = get_todo_path(opts);2991int res;2992}3041{3045if (!value)3046return config_error_nonbool(var);3047free(*dest);3048*dest = xstrdup(value);3049return 0;3050}3051{3056struct replay_opts *opts = data;3057int error_flag = 1;3058}3106{3109int i;3110int count;3111const char **argv;3112char *strategy_opts_string = raw_opts;3113}3129{3132strbuf_reset(buf);3133if (!read_oneliner(buf, rebase_path_strategy(), 0))3134return;3135opts->strategy = strbuf_detach(buf, NULL);3136if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))3137return;3138}3141{3144struct replay_ctx *ctx = opts->ctx;3145* The function git_parse_source(), called from git_config_from_file(),3233* may die() in case of a syntactically incorrect file. We do not care3234* about this case, though, because we wrote that file ourselves, so we3235* are pretty certain that it is syntactically correct.3236*/3237if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)3238return error(_("malformed options sheet: '%s'"),3239git_path_opts_file());3240return 0;3241}3242{3245struct strbuf buf = STRBUF_INIT;3246* Quote strategy options so that they can be read correctly3249* by split_cmdline().3250*/3251quote_cmdline(&buf, opts->xopts.v);3252write_file(rebase_path_strategy_opts(), "%s\n", buf.buf);3253strbuf_release(&buf);3254}3255{3259if (head_name)3260write_file(rebase_path_head_name(), "%s\n", head_name);3261if (onto)3262write_file(rebase_path_onto(), "%s\n",3263oid_to_hex(&onto->object.oid));3264if (orig_head)3265write_file(rebase_path_orig_head(), "%s\n",3266oid_to_hex(orig_head));3267}3301{3305enum todo_command command = opts->action == REPLAY_PICK ?3306TODO_PICK : TODO_REVERT;3307const char *command_string = todo_command_info[command].str;3308const char *encoding;3309struct commit *commit;3310}3342{3345enum replay_action action;3346const char *in_progress_error = NULL;3347const char *in_progress_advice = NULL;3348unsigned int advise_skip =3349refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD") ||3350refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD");3351}3381{3384return write_message(head, strlen(head), git_path_head_file(), 1);3385}3386{3389struct strbuf sb = STRBUF_INIT;3390struct object_id expected_head, actual_head;3391}3410{3413struct child_process cmd = CHILD_PROCESS_INIT;3414}3423{3426struct object_id head_oid;3427}3437{3440struct object_id head;3441}3446{3449FILE *f;3450struct object_id oid;3451struct strbuf buf = STRBUF_INIT;3452const char *p;3453* There is no multiple-cherry-pick in progress.3458* If CHERRY_PICK_HEAD or REVERT_HEAD indicates3459* a single-cherry-pick in progress, abort that.3460*/3461return rollback_single_pick(r);3462}3463if (!f)3464return error_errno(_("cannot open '%s'"), git_path_head_file());3465if (strbuf_getline_lf(&buf, f)) {3466error(_("cannot read '%s': %s"), git_path_head_file(),3467ferror(f) ? strerror(errno) : _("unexpected end of file"));3468fclose(f);3469goto fail;3470}3471fclose(f);3472if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {3473error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),3474git_path_head_file());3475goto fail;3476}3477if (is_null_oid(&oid)) {3478error(_("cannot abort from a branch yet to be born"));3479goto fail;3480}3481}3495{3498enum replay_action action = -1;3499sequencer_get_last_command(r, &action);3500* Check whether the subcommand requested to skip the commit is actually3503* in progress and that it's safe to skip the commit.3504*3505* opts->action tells us which subcommand requested to skip the commit.3506* If the corresponding .git/<ACTION>_HEAD exists, we know that the3507* action is in progress and we can skip the commit.3508*3509* Otherwise we check that the last instruction was related to the3510* particular subcommand we're trying to execute and barf if that's not3511* the case.3512*3513* Finally we check that the rollback is "safe", i.e., has the HEAD3514* moved? In this case, it doesn't make sense to "reset the merge" and3515* "skip the commit" as the user already handled this by committing. But3516* we'd not want to barf here, instead give advice on how to proceed. We3517* only need to check that when .git/<ACTION>_HEAD doesn't exist because3518* it gets removed when the user commits, so if it still exists we're3519* sure the user can't have committed before.3520*/3521switch (opts->action) {3522case REPLAY_REVERT:3523if (!refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD")) {3524if (action != REPLAY_REVERT)3525return error(_("no revert in progress"));3526if (!rollback_is_safe())3527goto give_advice;3528}3529break;3530case REPLAY_PICK:3531if (!refs_ref_exists(get_main_ref_store(r),3532"CHERRY_PICK_HEAD")) {3533if (action != REPLAY_PICK)3534return error(_("no cherry-pick in progress"));3535if (!rollback_is_safe())3536goto give_advice;3537}3538break;3539default:3540BUG("unexpected action in sequencer_skip");3541}3542}3560{3564struct lock_file todo_lock = LOCK_INIT;3565const char *todo_path = get_todo_path(opts);3566int next = todo_list->current, offset, fd;3567* rebase -i writes "git-rebase-todo" without the currently executing3570* command, appending it to "done" instead.3571*/3572if (is_rebase_i(opts) && !reschedule)3573next++;3574}3602{3605const char *opts_file = git_path_opts_file();3606int res = 0;3607}3664{3669struct rev_info log_tree_opt;3670const char *subject;3671char hex[GIT_MAX_HEXSZ + 1];3672int res = 0;3673}3713{3716struct object_id head;3717char *p;3718}3725{3732struct replay_ctx *ctx = opts->ctx;3733* Write the commit message to be used by "git rebase3736* --continue". If a "fixup" or "squash" command has conflicts3737* then we will have already written rebase_path_message() in3738* error_failed_squash(). If an "edit" command was3739* fast-forwarded then we don't have a message in ctx->message3740* and rely on make_patch() to write rebase_path_message()3741* instead.3742*/3743if (ctx->have_message && !file_exists(rebase_path_message()) &&3744write_message(ctx->message.buf, ctx->message.len,3745rebase_path_message(), 0))3746return error(_("could not write commit message file"));3747* We don't have the hash of the parent so3771* just print the line from the todo file.3772*/3773fprintf_ln(stderr, _("Could not merge %.*s"),3774subject_len, subject);3775}3776}3779{3786if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))3787return error(_("could not copy '%s' to '%s'"),3788rebase_path_squash_msg(), rebase_path_message());3789unlink(git_path_merge_msg(r));3790if (copy_file(git_path_merge_msg(r), rebase_path_message(), 0666))3791return error(_("could not copy '%s' to '%s'"),3792rebase_path_message(),3793git_path_merge_msg(r));3794return error_with_patch(r, commit, subject, subject_len, opts, 1, 0);3795}3796{3799struct child_process cmd = CHILD_PROCESS_INIT;3800int dirty, status;3801}3840{3844va_list ap;3845struct lock_file lock = LOCK_INIT;3846int fd = hold_lock_file_for_update(&lock, filename,3847LOCK_REPORT_ON_ERROR);3848struct strbuf buf = STRBUF_INIT;3849}3877{3880struct ref_store *refs = get_main_ref_store(r);3881struct ref_transaction *transaction;3882struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;3883struct strbuf msg = STRBUF_INIT;3884int ret = 0;3885struct object_id head_oid;3886}3918{3921if (!opts->reflog_action) {3922opts->reflog_action = getenv(GIT_REFLOG_ACTION);3923opts->reflog_action =3924xstrdup(opts->reflog_action ? opts->reflog_action3925: action_name(opts));3926}3927}3930{3935va_list ap;3936static struct strbuf buf = STRBUF_INIT;3937}3951{3955struct commit *commit;3956struct object_id oid;3957}3973{3978struct strbuf ref_name = STRBUF_INIT;3979struct object_id oid;3980struct lock_file lock = LOCK_INIT;3981struct tree_desc desc = { 0 };3982struct tree *tree;3983struct unpack_trees_options unpack_tree_opts = { 0 };3984int ret = 0;3985}4068{4074struct replay_ctx *ctx = opts->ctx;4075int run_commit_flags = 0;4076struct strbuf ref_name = STRBUF_INIT;4077struct commit *head_commit, *merge_commit, *i;4078struct commit_list *bases = NULL, *j;4079struct commit_list *to_merge = NULL, **tail = &to_merge;4080const char *strategy = !opts->xopts.nr &&4081(!opts->strategy ||4082!strcmp(opts->strategy, "recursive") ||4083!strcmp(opts->strategy, "ort")) ?4084NULL : opts->strategy;4085struct merge_options o;4086int merge_arg_len, oneline_offset, can_fast_forward, ret, k;4087static struct lock_file lock;4088const char *p;4089* For octopus merges, the arg starts with the list of revisions to be4103* merged. The list is optionally followed by '#' and the oneline.4104*/4105merge_arg_len = oneline_offset = arg_len;4106for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {4107if (!*p)4108break;4109if (*p == '#' && (!p[1] || isspace(p[1]))) {4110p += 1 + strspn(p + 1, " \t\n");4111oneline_offset = p - arg;4112break;4113}4114k = strcspn(p, " \t\n");4115if (!k)4116continue;4117merge_commit = lookup_label(r, p, k, &ref_name);4118if (!merge_commit) {4119ret = error(_("unable to parse '%.*s'"), k, p);4120goto leave_merge;4121}4122tail = &commit_list_insert(merge_commit, tail)->next;4123p += k;4124merge_arg_len = p - arg;4125}4126* When the user tells us to "merge" something into a4136* "[new root]", let's simply fast-forward to the merge head.4137*/4138rollback_lock_file(&lock);4139if (to_merge->next)4140ret = error(_("octopus merge cannot be executed on "4141"top of a [new root]"));4142else4143ret = fast_forward_to(r, &to_merge->item->object.oid,4144&head_commit->object.oid, 0,4145opts);4146goto leave_merge;4147}4148* If HEAD is not identical to the first parent of the original merge4151* commit, we cannot fast-forward.4152*/4153can_fast_forward = opts->allow_ff && commit && commit->parents &&4154oideq(&commit->parents->item->object.oid,4155&head_commit->object.oid);4156* If any merge head is different from the original one, we cannot4159* fast-forward.4160*/4161if (can_fast_forward) {4162struct commit_list *p = commit->parents->next;4163* If the number of merge heads differs from the original merge4172* commit, we cannot fast-forward.4173*/4174if (j || p)4175can_fast_forward = 0;4176}4177* TODO: Should use merge_incore_recursive() and4322* merge_switch_to_result(), skipping the call to4323* merge_switch_to_result() when we don't actually need to4324* update the index and working copy immediately.4325*/4326ret = merge_ort_recursive(&o,4327head_commit, merge_commit, bases,4328&i);4329} else {4330ret = merge_recursive(&o, head_commit, merge_commit, bases,4331&i);4332}4333if (ret <= 0)4334fputs(o.obuf.buf, stdout);4335strbuf_release(&o.obuf);4336if (ret < 0) {4337error(_("could not even attempt to merge '%.*s'"),4338merge_arg_len, arg);4339unlink(git_path_merge_msg(r));4340goto leave_merge;4341}4342/*4343* The return value of merge_recursive() is 1 on clean, and 0 on4344* unclean merge.4345*4346* Let's reverse that, so that do_merge() returns 0 upon success and4347* 1 upon failed merge (keeping the return value -1 for the cases where4348* we will want to reschedule the `merge` command).4349*/4350ret = !ret;4351* In case of problems, we now want to return a positive4364* value (a negative one would indicate that the `merge`4365* command needs to be rescheduled).4366*/4367ret = !!run_git_commit(git_path_merge_msg(r), opts,4368run_commit_flags);4369}4385{4388int result = 0;4389struct lock_file lock = LOCK_INIT;4390FILE *fp = NULL;4391struct string_list_item *item;4392char *path;4393}4434/*4436* Parse the update-refs file for the current rebase, then remove the4437* refs that do not appear in the todo_list (and have not had updated4438* values stored) and add refs that are in the todo_list but not4439* represented in the update-refs file.4440*4441* If there are changes to the update-refs list, then write the new state4442* to disk.4443*/4444void todo_list_filter_update_refs(struct repository *r,4445struct todo_list *todo_list)4446{4447int i;4448int updated = 0;4449struct string_list update_refs = STRING_LIST_INIT_DUP;4450* For each item in the update_refs list, if it has no updated4455* value and does not appear in the todo_list, then remove it4456* from the update_refs list.4457*/4458for (i = 0; i < update_refs.nr; i++) {4459int j;4460int found = 0;4461const char *ref = update_refs.items[i].string;4462size_t reflen = strlen(ref);4463struct update_ref_record *rec = update_refs.items[i].util;4464* For each todo_item, check if its ref is in the update_refs list.4497* If not, then add it as an un-updated ref.4498*/4499for (i = 0; i < todo_list->nr; i++) {4500struct todo_item *item = &todo_list->items[i];4501const char *arg = todo_list->buf.buf + item->arg_offset;4502int j, found = 0;4503}4530{4533struct string_list_item *item;4534struct string_list list = STRING_LIST_INIT_DUP;4535}4552{4555int res = 0;4556struct string_list_item *item;4557struct string_list refs_to_oids = STRING_LIST_INIT_DUP;4558struct ref_store *refs = get_main_ref_store(r);4559struct strbuf update_msg = STRBUF_INIT;4560struct strbuf error_msg = STRBUF_INIT;4561}4603{4606int i = todo_list->current;4607}4618{4621int i;4622}4629{4634struct strbuf buf = STRBUF_INIT;4635struct lock_file lock_file = LOCK_INIT;4636int fd;4637}4686{4689create_autostash_internal(r, path, NULL);4690}4691{4694create_autostash_internal(r, NULL, refname);4695}4696{4699struct child_process child = CHILD_PROCESS_INIT;4700int ret = 0;4701}4739{4742struct strbuf stash_oid = STRBUF_INIT;4743int ret = 0;4744}4758{4761return apply_save_autostash(path, 0);4762}4763{4766return apply_save_autostash(path, 1);4767}4768{4771return apply_save_autostash_oid(stash_oid, 1);4772}4773{4777struct object_id stash_oid;4778char stash_oid_hex[GIT_MAX_HEXSZ + 1];4779int flag, ret;4780}4798{4801return apply_save_autostash_ref(r, refname, 0);4802}4803{4806return apply_save_autostash_ref(r, refname, 1);4807}4808{4813struct reset_head_opts ropts = {4814.oid = onto,4815.orig_head = orig_head,4816.flags = RESET_HEAD_DETACH | RESET_ORIG_HEAD |4817RESET_HEAD_RUN_POST_CHECKOUT_HOOK,4818.head_msg = reflog_message(opts, "start", "checkout %s",4819onto_name),4820.default_reflog_action = sequencer_reflog_action(opts)4821};4822if (reset_head(r, &ropts)) {4823apply_autostash(rebase_path_autostash());4824sequencer_remove_state(opts);4825return error(_("could not detach HEAD"));4826}4827}4830{4833struct object_id head;4834struct commit *commit;4835struct commit_message message;4836}4848{4853int offset;4854struct strbuf buf = STRBUF_INIT;4855}4872"\n"4876" %.*s"4877"\n"4878"It has been rescheduled; To edit the command before continuing, please\n"4879"edit the todo list first:\n"4880"\n"4881" git rebase --edit-todo\n"4882" git rebase --continue\n");4883{4889struct replay_ctx *ctx = opts->ctx;4890int res;4891struct todo_item *item = todo_list->items + todo_list->current;4892const char *arg = todo_item_get_arg(todo_list, item);4893if (is_rebase_i(opts))4894ctx->reflog_message = reflog_message(4895opts, command_to_string(item->command), NULL);4896* If we are rewording and have either4929* fast-forwarded already, or are about to4930* create a new root commit, we want to amend,4931* otherwise we do not.4932*/4933if (item->command == TODO_REWORD &&4934!repo_get_oid(r, "HEAD", &oid) &&4935(oideq(&item->commit->object.oid, &oid) ||4936(opts->have_squash_onto &&4937oideq(&opts->squash_onto, &oid))))4938to_amend = 1;4939}4946{4951struct replay_ctx *ctx = opts->ctx;4952int res = 0, reschedule = 0;4953* Sequence of picks finished successfully; cleanup by5175* removing the .git/sequencer directory5176*/5177return sequencer_remove_state(opts);5178}5179{5182struct child_process cmd = CHILD_PROCESS_INIT;5183* continue_single_pick() handles the case of recovering from a5193* conflict. should_edit() doesn't handle that case; for a conflict,5194* we want to edit if the user asked for it, or if they didn't specify5195* and stdin is a tty.5196*/5197if (!opts->edit || (opts->edit < 0 && !isatty(0)))5198/*5199* Include --cleanup=strip as well because we don't want the5200* "# Conflicts:" messages.5201*/5202strvec_pushl(&cmd.args, "--no-edit", "--cleanup=strip", NULL);5203}5206{5211struct replay_ctx *ctx = opts->ctx;5212unsigned int flags = ALLOW_EMPTY | EDIT_MSG;5213unsigned int final_fixup = 0, is_clean;5214struct strbuf rev = STRBUF_INIT;5215int ret;5216* When skipping a failed fixup/squash, we need to edit the5257* commit message, the current fixup list and count, and if it5258* was the last fixup/squash in the chain, we need to clean up5259* the commit message and if there was a squash, let the user5260* edit it.5261*/5262if (!is_clean || !ctx->current_fixup_count)5263; /* this is not the final fixup */5264else if (!oideq(&head, &to_amend) ||5265!file_exists(rebase_path_stopped_sha())) {5266/* was a final fixup or squash done manually? */5267if (!is_fixup(peek_command(todo_list, 0))) {5268unlink(rebase_path_fixup_msg());5269unlink(rebase_path_squash_msg());5270unlink(rebase_path_current_fixups());5271strbuf_reset(&ctx->current_fixups);5272ctx->current_fixup_count = 0;5273}5274} else {5275/* we are in a fixup/squash chain */5276const char *p = ctx->current_fixups.buf;5277int len = ctx->current_fixups.len;5278* If a fixup/squash in a fixup/squash chain failed, the5294* commit message is already correct, no need to commit5295* it again.5296*5297* Only if it is the final command in the fixup/squash5298* chain, and only if the chain is longer than a single5299* fixup/squash command (which was just skipped), do we5300* actually need to re-commit with a cleaned up commit5301* message.5302*/5303if (ctx->current_fixup_count > 0 &&5304!is_fixup(peek_command(todo_list, 0))) {5305final_fixup = 1;5306/*5307* If there was not a single "squash" in the5308* chain, we only need to clean up the commit5309* message, no need to bother the user with5310* opening the commit message in the editor.5311*/5312if (!starts_with(p, "squash ") &&5313!strstr(p, "\nsquash "))5314flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;5315} else if (is_fixup(peek_command(todo_list, 0))) {5316/*5317* We need to update the squash message to skip5318* the latest commit message.5319*/5320struct commit *commit;5321const char *msg;5322const char *path = rebase_path_squash_msg();5323const char *encoding = get_commit_output_encoding();5324* Whether final fixup or not, we just cleaned up the commit5393* message...5394*/5395unlink(rebase_path_current_fixups());5396strbuf_reset(&ctx->current_fixups);5397ctx->current_fixup_count = 0;5398}5399}5406{5409struct replay_ctx *ctx = opts->ctx;5410struct todo_list todo_list = TODO_LIST_INIT;5411int res;5412}5470{5475int check_todo;5476struct todo_item item;5477}5485{5489struct todo_list todo_list = TODO_LIST_INIT;5490struct object_id oid;5491int i, res;5492* If we were called as "git cherry-pick <commit>", just5524* cherry-pick/revert it, set CHERRY_PICK_HEAD /5525* REVERT_HEAD, and don't touch the sequencer state.5526* This means it is possible to cherry-pick in the middle5527* of a cherry-pick sequence.5528*/5529if (opts->revs->cmdline.nr == 1 &&5530opts->revs->cmdline.rev->whence == REV_CMD_REV &&5531opts->revs->no_walk &&5532!opts->revs->cmdline.rev->flags) {5533struct commit *cmit;5534* Start a new cherry-pick/ revert sequence; but5555* first, make sure that an existing one isn't in5556* progress5557*/5558}5587{5590unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;5591struct strbuf sob = STRBUF_INIT;5592int has_footer;5593* If the whole message buffer is equal to the sob, pretend that we5603* found a conforming footer with a matching sob5604*/5605if (msgbuf->len - ignore_footer == sob.len &&5606!strncmp(msgbuf->buf, sob.buf, sob.len))5607has_footer = 3;5608else5609has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);5610* The buffer is completely empty. Leave foom for5618* the title and body to be filled in by the user.5619*/5620append_newlines = "\n\n";5621} else if (len == 1) {5622/*5623* Buffer contains a single newline. Add another5624* so that we leave room for the title and body.5625*/5626append_newlines = "\n";5627} else if (msgbuf->buf[len - 2] != '\n') {5628/*5629* Buffer ends with a single newline. Add another5630* so that there is an empty line between the message5631* body and the sob.5632*/5633append_newlines = "\n";5634} /* else, the buffer already ends with two newlines. */5635}5647{5657const struct labels_entry *a, *b;5658}5664{5680struct labels_entry *labels_entry;5681struct string_entry *string_entry;5682struct object_id dummy;5683int i;5684* For "uninteresting" commits, i.e. commits that are not to be5691* rebased, and which can therefore not be labeled, we use a unique5692* abbreviation of the commit name. This is slightly more complicated5693* than calling repo_find_unique_abbrev() because we also need to make5694* sure that the abbreviation does not conflict with any other5695* label.5696*5697* We disallow "interesting" commits to be labeled by a string that5698* is a valid full-length hash, to ensure that we always can find an5699* abbreviation for any uninteresting commit's names that does not5700* clash with any other label.5701*/5702strbuf_reset(&state->buf);5703if (!label) {5704char *p;5705* We may need to extend the abbreviated hash so that there is5714* no conflicting label.5715*/5716if (hashmap_get_from_hash(&state->labels, strihash(p), p)) {5717size_t i = strlen(p) + 1;5718* Sanitize labels by replacing non-alpha-numeric characters5736* (including white-space ones) by dashes, as they might be5737* illegal in file names (and hence in ref names).5738*5739* Note that we retain non-ASCII UTF-8 characters (identified5740* via the most significant bit). They should be all acceptable5741* in file names.5742*5743* As we will use the labels as names of (loose) refs, it is5744* vital that the name not be longer than the maximum component5745* size of the file system (`NAME_MAX`). We are careful to5746* truncate the label accordingly, allowing for the `.lock`5747* suffix and for the label to be UTF-8 encoded (i.e. we avoid5748* truncating in the middle of a character).5749*/5750for (; *label && buf->len + 1 < max_len; label++)5751if (isalnum(*label) ||5752(!label_is_utf8 && (*label & 0x80)))5753strbuf_addch(buf, *label);5754else if (*label & 0x80) {5755const char *p = label;5756* If the label already exists, or if the label is a5783* valid full OID, or the label is a '#' (which we use5784* as a separator between merge heads and oneline), we5785* append a dash and a number to make it unique.5786*/5787size_t len = buf->len;5788}5812{5817int keep_empty = flags & TODO_LIST_KEEP_EMPTY;5818int rebase_cousins = flags & TODO_LIST_REBASE_COUSINS;5819int root_with_onto = flags & TODO_LIST_ROOT_WITH_ONTO;5820int skipped_commit = 0;5821struct strbuf buf = STRBUF_INIT, oneline = STRBUF_INIT;5822struct strbuf label = STRBUF_INIT;5823struct commit_list *commits = NULL, **tail = &commits, *iter;5824struct commit_list *tips = NULL, **tips_tail = &tips;5825struct commit *commit;5826struct oidmap commit2todo = OIDMAP_INIT;5827struct string_entry *entry;5828struct oidset interesting = OIDSET_INIT, child_seen = OIDSET_INIT,5829shown = OIDSET_INIT;5830struct label_state state =5831{ OIDMAP_INIT, { NULL }, STRBUF_INIT, GIT_MAX_LABEL_LENGTH };5832* First phase:5860* - get onelines for all commits5861* - gather all branch tips (i.e. 2nd or later parents of merges)5862* - label all branch tips5863*/5864while ((commit = get_revision(revs))) {5865struct commit_list *to_merge;5866const char *p1, *p2;5867struct object_id *oid;5868int is_empty;5869* Second phase:5950* - label branch points5951* - add HEAD to the branch tips5952*/5953for (iter = commits; iter; iter = iter->next) {5954struct commit_list *parent = iter->item->parents;5955for (; parent; parent = parent->next) {5956struct object_id *oid = &parent->item->object.oid;5957if (!oidset_contains(&interesting, oid))5958continue;5959if (oidset_insert(&child_seen, oid))5960label_oid(oid, "branch-point", &state);5961}5962* Third phase: output the todo list. This is a bit tricky, as we5971* want to avoid jumping back and forth between revisions. To5972* accomplish that goal, we walk backwards from the branch tips,5973* gathering commits not yet shown, reversing the list on the fly,5974* then outputting that list (labeling revisions as needed).5975*/5976strbuf_addf(out, "%s onto\n", cmd_label);5977for (iter = tips; iter; iter = iter->next) {5978struct commit_list *list = NULL, *iter2;5979}6058{6062char *format = NULL;6063struct pretty_print_context pp = {0};6064struct rev_info revs;6065struct commit *commit;6066int keep_empty = flags & TODO_LIST_KEEP_EMPTY;6067const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";6068int rebase_merges = flags & TODO_LIST_REBASE_MERGES;6069int reapply_cherry_picks = flags & TODO_LIST_REAPPLY_CHERRY_PICKS;6070int skipped_commit = 0;6071int ret = 0;6072}6136/*6138* Add commands after pick and (series of) squash/fixup commands6139* in the todo list.6140*/6141static void todo_list_add_exec_commands(struct todo_list *todo_list,6142struct string_list *commands)6143{6144struct strbuf *buf = &todo_list->buf;6145size_t base_offset = buf->len;6146int i, insert, nr = 0, alloc = 0;6147struct todo_item *items = NULL, *base_items = NULL;6148* Insert <commands> after every pick. Here, fixup/squash chains6166* are considered part of the pick, so we insert the commands *after*6167* those chains if there are any.6168*6169* As we insert the exec commands immediately after rearranging6170* any fixups and before the user edits the list, a fixup chain6171* can never contain comments (any comments are empty picks that6172* have been commented out because the user did not specify6173* --keep-empty). So, it is safe to insert an exec command6174* without looking at the command following a comment.6175*/6176insert = 0;6177for (i = 0; i < todo_list->nr; i++) {6178enum todo_command command = todo_list->items[i].command;6179if (insert && !is_fixup(command)) {6180ALLOC_GROW(items, nr + commands->nr, alloc);6181COPY_ARRAY(items + nr, base_items, commands->nr);6182nr += commands->nr;6183}6207{6212struct todo_item *item;6213int i, max = todo_list->nr;6214}6267{6272int res;6273struct strbuf buf = STRBUF_INIT;6274}6285/* skip picking commits whose parents are unchanged */6287static int skip_unnecessary_picks(struct repository *r,6288struct todo_list *todo_list,6289struct object_id *base_oid)6290{6291struct object_id *parent_oid;6292int i;6293}6333{6346const struct name_decoration *decoration = get_name_decoration(&commit->object);6347const char *head_ref = refs_resolve_ref_unsafe(get_main_ref_store(the_repository),6348"HEAD",6349RESOLVE_REF_READING,6350NULL,6351NULL);6352* If the branch is the current HEAD, then it will be6360* updated by the default rebase behavior.6361*/6362if (head_ref && !strcmp(head_ref, decoration->name)) {6363decoration = decoration->next;6364continue;6365}6366}6398/*6400* For each 'pick' command, find out if the commit has a decoration in6401* refs/heads/. If so, then add a 'label for-update-refs/' command.6402*/6403static int todo_list_add_update_ref_commands(struct todo_list *todo_list)6404{6405int i, res;6406static struct string_list decorate_refs_exclude = STRING_LIST_INIT_NODUP;6407static struct string_list decorate_refs_exclude_config = STRING_LIST_INIT_NODUP;6408static struct string_list decorate_refs_include = STRING_LIST_INIT_NODUP;6409struct decoration_filter decoration_filter = {6410.include_ref_pattern = &decorate_refs_include,6411.exclude_ref_pattern = &decorate_refs_exclude,6412.exclude_ref_config_pattern = &decorate_refs_exclude_config,6413};6414struct todo_add_branch_context ctx = {6415.buf = &todo_list->buf,6416.refs_to_oids = STRING_LIST_INIT_DUP,6417};6418}6458{6466char shortonto[GIT_MAX_HEXSZ + 1];6467const char *todo_file = rebase_path_todo();6468struct todo_list new_todo = TODO_LIST_INIT;6469struct strbuf *buf = &todo_list->buf, buf2 = STRBUF_INIT;6470struct object_id oid = onto->object.oid;6471int res;6472}6558{6570const struct subject2item_entry *a, *b;6571}6577}6585/*6587* Rearrange the todo list that has both "pick commit-id msg" and "pick6588* commit-id fixup!/squash! msg" in it so that the latter is put immediately6589* after the former, and change "pick" to "fixup"/"squash".6590*6591* Note that if the config has specified a custom instruction format, each log6592* message will have to be retrieved from the commit (as the oneline in the6593* script cannot be trusted) in order to normalize the autosquash arrangement.6594*/6595int todo_list_rearrange_squash(struct todo_list *todo_list)6596{6597struct hashmap subject2item;6598int rearranged = 0, *next, *tail, i, nr = 0;6599char **subjects;6600struct commit_todo_item commit_todo;6601struct todo_item *items = NULL;6602* The hashmap maps onelines to the respective todo list index.6606*6607* If any items need to be rearranged, the next[i] value will indicate6608* which item was moved directly after the i'th.6609*6610* In that case, last[i] will indicate the index of the latest item to6611* be moved to appear after the i'th.6612*/6613hashmap_init(&subject2item, subject2item_cmp, NULL, todo_list->nr);6614ALLOC_ARRAY(next, todo_list->nr);6615ALLOC_ARRAY(tail, todo_list->nr);6616ALLOC_ARRAY(subjects, todo_list->nr);6617for (i = 0; i < todo_list->nr; i++) {6618struct strbuf buf = STRBUF_INIT;6619struct todo_item *item = todo_list->items + i;6620const char *commit_buffer, *subject, *p;6621size_t subject_len;6622int i2 = -1;6623struct subject2item_entry *entry;6624* Initially, all commands are 'pick's. If it is a6718* fixup or a squash now, we have rearranged it.6719*/6720if (is_fixup(command))6721continue;6722}6746{6749if (refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD")) {6750struct object_id cherry_pick_head, rebase_head;6751}6767{6771int result = 0;6772FILE *fp = NULL;6773struct strbuf ref = STRBUF_INIT;6774struct strbuf hash = STRBUF_INIT;6775struct update_ref_record *rec = NULL;6776}6818