1 #include "git-compat-util.h"
11 #include "submodule-config.h"
12 #include "run-command.h"
16 struct refspec_item spec
;
17 struct string_list
*srcs
;
22 struct find_tracked_branch_cb
{
23 struct tracking
*tracking
;
24 struct string_list ambiguous_remotes
;
27 static int find_tracked_branch(struct remote
*remote
, void *priv
)
29 struct find_tracked_branch_cb
*ftb
= priv
;
30 struct tracking
*tracking
= ftb
->tracking
;
32 if (!remote_find_tracking(remote
, &tracking
->spec
)) {
33 switch (++tracking
->matches
) {
35 string_list_append(tracking
->srcs
, tracking
->spec
.src
);
36 tracking
->remote
= remote
->name
;
39 /* there are at least two remotes; backfill the first one */
40 string_list_append(&ftb
->ambiguous_remotes
, tracking
->remote
);
43 string_list_append(&ftb
->ambiguous_remotes
, remote
->name
);
44 free(tracking
->spec
.src
);
45 string_list_clear(tracking
->srcs
, 0);
48 /* remote_find_tracking() searches by src if present */
49 tracking
->spec
.src
= NULL
;
54 static int should_setup_rebase(const char *origin
)
57 case AUTOREBASE_NEVER
:
59 case AUTOREBASE_LOCAL
:
60 return origin
== NULL
;
61 case AUTOREBASE_REMOTE
:
62 return origin
!= NULL
;
63 case AUTOREBASE_ALWAYS
:
70 * Install upstream tracking configuration for a branch; specifically, add
71 * `branch.<name>.remote` and `branch.<name>.merge` entries.
73 * `flag` contains integer flags for options; currently only
74 * BRANCH_CONFIG_VERBOSE is checked.
76 * `local` is the name of the branch whose configuration we're installing.
78 * `origin` is the name of the remote owning the upstream branches. NULL means
79 * the upstream branches are local to this repo.
81 * `remotes` is a list of refs that are upstream of local
83 static int install_branch_config_multiple_remotes(int flag
, const char *local
,
84 const char *origin
, struct string_list
*remotes
)
86 const char *shortname
= NULL
;
87 struct strbuf key
= STRBUF_INIT
;
88 struct string_list_item
*item
;
89 int rebasing
= should_setup_rebase(origin
);
92 BUG("must provide at least one remote for branch config");
93 if (rebasing
&& remotes
->nr
> 1)
94 die(_("cannot inherit upstream tracking configuration of "
95 "multiple refs when rebasing is requested"));
98 * If the new branch is trying to track itself, something has gone
99 * wrong. Warn the user and don't proceed any further.
102 for_each_string_list_item(item
, remotes
)
103 if (skip_prefix(item
->string
, "refs/heads/", &shortname
)
104 && !strcmp(local
, shortname
)) {
105 warning(_("not setting branch '%s' as its own upstream"),
110 strbuf_addf(&key
, "branch.%s.remote", local
);
111 if (git_config_set_gently(key
.buf
, origin
? origin
: ".") < 0)
115 strbuf_addf(&key
, "branch.%s.merge", local
);
117 * We want to overwrite any existing config with all the branches in
118 * "remotes". Override any existing config, then write our branches. If
119 * more than one is provided, use CONFIG_REGEX_NONE to preserve what
120 * we've written so far.
122 if (git_config_set_gently(key
.buf
, NULL
) < 0)
124 for_each_string_list_item(item
, remotes
)
125 if (git_config_set_multivar_gently(key
.buf
, item
->string
, CONFIG_REGEX_NONE
, 0) < 0)
130 strbuf_addf(&key
, "branch.%s.rebase", local
);
131 if (git_config_set_gently(key
.buf
, "true") < 0)
134 strbuf_release(&key
);
136 if (flag
& BRANCH_CONFIG_VERBOSE
) {
137 struct strbuf tmp_ref_name
= STRBUF_INIT
;
138 struct string_list friendly_ref_names
= STRING_LIST_INIT_DUP
;
140 for_each_string_list_item(item
, remotes
) {
141 shortname
= item
->string
;
142 skip_prefix(shortname
, "refs/heads/", &shortname
);
144 strbuf_addf(&tmp_ref_name
, "%s/%s",
146 string_list_append_nodup(
148 strbuf_detach(&tmp_ref_name
, NULL
));
151 &friendly_ref_names
, shortname
);
155 if (remotes
->nr
== 1) {
157 * Rebasing is only allowed in the case of a single
161 _("branch '%s' set up to track '%s' by rebasing.") :
162 _("branch '%s' set up to track '%s'."),
163 local
, friendly_ref_names
.items
[0].string
);
165 printf_ln(_("branch '%s' set up to track:"), local
);
166 for_each_string_list_item(item
, &friendly_ref_names
)
167 printf_ln(" %s", item
->string
);
170 string_list_clear(&friendly_ref_names
, 0);
176 strbuf_release(&key
);
177 error(_("unable to write upstream branch configuration"));
179 advise(_("\nAfter fixing the error cause you may try to fix up\n"
180 "the remote tracking information by invoking:"));
181 if (remotes
->nr
== 1)
182 advise(" git branch --set-upstream-to=%s%s%s",
183 origin
? origin
: "",
185 remotes
->items
[0].string
);
187 advise(" git config --add branch.\"%s\".remote %s",
188 local
, origin
? origin
: ".");
189 for_each_string_list_item(item
, remotes
)
190 advise(" git config --add branch.\"%s\".merge %s",
191 local
, item
->string
);
197 int install_branch_config(int flag
, const char *local
, const char *origin
,
201 struct string_list remotes
= STRING_LIST_INIT_DUP
;
203 string_list_append(&remotes
, remote
);
204 ret
= install_branch_config_multiple_remotes(flag
, local
, origin
, &remotes
);
205 string_list_clear(&remotes
, 0);
209 static int inherit_tracking(struct tracking
*tracking
, const char *orig_ref
)
211 const char *bare_ref
;
212 struct branch
*branch
;
216 skip_prefix(orig_ref
, "refs/heads/", &bare_ref
);
218 branch
= branch_get(bare_ref
);
219 if (!branch
->remote_name
) {
220 warning(_("asked to inherit tracking from '%s', but no remote is set"),
225 if (branch
->merge_nr
< 1 || !branch
->merge_name
|| !branch
->merge_name
[0]) {
226 warning(_("asked to inherit tracking from '%s', but no merge configuration is set"),
231 tracking
->remote
= xstrdup(branch
->remote_name
);
232 for (i
= 0; i
< branch
->merge_nr
; i
++)
233 string_list_append(tracking
->srcs
, branch
->merge_name
[i
]);
238 * Used internally to set the branch.<new_ref>.{remote,merge} config
239 * settings so that branch 'new_ref' tracks 'orig_ref'. Unlike
240 * dwim_and_setup_tracking(), this does not do DWIM, i.e. "origin/main"
241 * will not be expanded to "refs/remotes/origin/main", so it is not safe
242 * for 'orig_ref' to be raw user input.
244 static void setup_tracking(const char *new_ref
, const char *orig_ref
,
245 enum branch_track track
, int quiet
)
247 struct tracking tracking
;
248 struct string_list tracking_srcs
= STRING_LIST_INIT_DUP
;
249 int config_flags
= quiet
? 0 : BRANCH_CONFIG_VERBOSE
;
250 struct find_tracked_branch_cb ftb_cb
= {
251 .tracking
= &tracking
,
252 .ambiguous_remotes
= STRING_LIST_INIT_DUP
,
256 BUG("asked to set up tracking, but tracking is disallowed");
258 memset(&tracking
, 0, sizeof(tracking
));
259 tracking
.spec
.dst
= (char *)orig_ref
;
260 tracking
.srcs
= &tracking_srcs
;
261 if (track
!= BRANCH_TRACK_INHERIT
)
262 for_each_remote(find_tracked_branch
, &ftb_cb
);
263 else if (inherit_tracking(&tracking
, orig_ref
))
266 if (!tracking
.matches
)
268 /* If ref is not remote, still use local */
269 case BRANCH_TRACK_ALWAYS
:
270 case BRANCH_TRACK_EXPLICIT
:
271 case BRANCH_TRACK_OVERRIDE
:
272 /* Remote matches not evaluated */
273 case BRANCH_TRACK_INHERIT
:
275 /* Otherwise, if no remote don't track */
281 * This check does not apply to BRANCH_TRACK_INHERIT;
282 * that supports multiple entries in tracking_srcs but
283 * leaves tracking.matches at 0.
285 if (tracking
.matches
> 1) {
286 int status
= die_message(_("not tracking: ambiguous information for ref '%s'"),
288 if (advice_enabled(ADVICE_AMBIGUOUS_FETCH_REFSPEC
)) {
289 struct strbuf remotes_advice
= STRBUF_INIT
;
290 struct string_list_item
*item
;
292 for_each_string_list_item(item
, &ftb_cb
.ambiguous_remotes
)
294 * TRANSLATORS: This is a line listing a remote with duplicate
295 * refspecs in the advice message below. For RTL languages you'll
296 * probably want to swap the "%s" and leading " " space around.
298 strbuf_addf(&remotes_advice
, _(" %s\n"), item
->string
);
301 * TRANSLATORS: The second argument is a \n-delimited list of
302 * duplicate refspecs, composed above.
304 advise(_("There are multiple remotes whose fetch refspecs map to the remote\n"
305 "tracking ref '%s':\n"
308 "This is typically a configuration error.\n"
310 "To support setting up tracking branches, ensure that\n"
311 "different remotes' fetch refspecs map into different\n"
312 "tracking namespaces."), orig_ref
,
314 strbuf_release(&remotes_advice
);
319 if (track
== BRANCH_TRACK_SIMPLE
) {
321 * Only track if remote branch name matches.
322 * Reaching into items[0].string is safe because
323 * we know there is at least one and not more than
324 * one entry (because only BRANCH_TRACK_INHERIT can
325 * produce more than one entry).
327 const char *tracked_branch
;
328 if (!skip_prefix(tracking
.srcs
->items
[0].string
,
329 "refs/heads/", &tracked_branch
) ||
330 strcmp(tracked_branch
, new_ref
))
334 if (tracking
.srcs
->nr
< 1)
335 string_list_append(tracking
.srcs
, orig_ref
);
336 if (install_branch_config_multiple_remotes(config_flags
, new_ref
,
337 tracking
.remote
, tracking
.srcs
) < 0)
341 string_list_clear(&tracking_srcs
, 0);
342 string_list_clear(&ftb_cb
.ambiguous_remotes
, 0);
345 int read_branch_desc(struct strbuf
*buf
, const char *branch_name
)
348 struct strbuf name
= STRBUF_INIT
;
349 strbuf_addf(&name
, "branch.%s.description", branch_name
);
350 if (git_config_get_string(name
.buf
, &v
)) {
351 strbuf_release(&name
);
354 strbuf_addstr(buf
, v
);
356 strbuf_release(&name
);
361 * Check if 'name' can be a valid name for a branch; die otherwise.
362 * Return 1 if the named branch already exists; return 0 otherwise.
363 * Fill ref with the full refname for the branch.
365 int validate_branchname(const char *name
, struct strbuf
*ref
)
367 if (strbuf_check_branch_ref(ref
, name
))
368 die(_("'%s' is not a valid branch name"), name
);
370 return ref_exists(ref
->buf
);
373 static int initialized_checked_out_branches
;
374 static struct strmap current_checked_out_branches
= STRMAP_INIT
;
376 static void prepare_checked_out_branches(void)
379 struct worktree
**worktrees
;
381 if (initialized_checked_out_branches
)
383 initialized_checked_out_branches
= 1;
385 worktrees
= get_worktrees();
387 while (worktrees
[i
]) {
389 struct wt_status_state state
= { 0 };
390 struct worktree
*wt
= worktrees
[i
++];
391 struct string_list update_refs
= STRING_LIST_INIT_DUP
;
397 old
= strmap_put(¤t_checked_out_branches
,
403 if (wt_status_check_rebase(wt
, &state
) &&
404 (state
.rebase_in_progress
|| state
.rebase_interactive_in_progress
) &&
406 struct strbuf ref
= STRBUF_INIT
;
407 strbuf_addf(&ref
, "refs/heads/%s", state
.branch
);
408 old
= strmap_put(¤t_checked_out_branches
,
412 strbuf_release(&ref
);
414 wt_status_state_free_buffers(&state
);
416 if (wt_status_check_bisect(wt
, &state
) &&
418 struct strbuf ref
= STRBUF_INIT
;
419 strbuf_addf(&ref
, "refs/heads/%s", state
.branch
);
420 old
= strmap_put(¤t_checked_out_branches
,
424 strbuf_release(&ref
);
426 wt_status_state_free_buffers(&state
);
428 if (!sequencer_get_update_refs_state(get_worktree_git_dir(wt
),
430 struct string_list_item
*item
;
431 for_each_string_list_item(item
, &update_refs
) {
432 old
= strmap_put(¤t_checked_out_branches
,
437 string_list_clear(&update_refs
, 1);
441 free_worktrees(worktrees
);
444 const char *branch_checked_out(const char *refname
)
446 prepare_checked_out_branches();
447 return strmap_get(¤t_checked_out_branches
, refname
);
451 * Check if a branch 'name' can be created as a new branch; die otherwise.
452 * 'force' can be used when it is OK for the named branch already exists.
453 * Return 1 if the named branch already exists; return 0 otherwise.
454 * Fill ref with the full refname for the branch.
456 int validate_new_branchname(const char *name
, struct strbuf
*ref
, int force
)
459 if (!validate_branchname(name
, ref
))
463 die(_("a branch named '%s' already exists"),
464 ref
->buf
+ strlen("refs/heads/"));
466 if ((path
= branch_checked_out(ref
->buf
)))
467 die(_("cannot force update the branch '%s' "
468 "checked out at '%s'"),
469 ref
->buf
+ strlen("refs/heads/"), path
);
474 static int check_tracking_branch(struct remote
*remote
, void *cb_data
)
476 char *tracking_branch
= cb_data
;
477 struct refspec_item query
;
478 memset(&query
, 0, sizeof(struct refspec_item
));
479 query
.dst
= tracking_branch
;
480 return !remote_find_tracking(remote
, &query
);
483 static int validate_remote_tracking_branch(char *ref
)
485 return !for_each_remote(check_tracking_branch
, ref
);
488 static const char upstream_not_branch
[] =
489 N_("cannot set up tracking information; starting point '%s' is not a branch");
490 static const char upstream_missing
[] =
491 N_("the requested upstream branch '%s' does not exist");
492 static const char upstream_advice
[] =
494 "If you are planning on basing your work on an upstream\n"
495 "branch that already exists at the remote, you may need to\n"
496 "run \"git fetch\" to retrieve it.\n"
498 "If you are planning to push out a new local branch that\n"
499 "will track its remote counterpart, you may want to use\n"
500 "\"git push -u\" to set the upstream config as you push.");
503 * DWIMs a user-provided ref to determine the starting point for a
504 * branch and validates it, where:
506 * - r is the repository to validate the branch for
508 * - start_name is the ref that we would like to test. This is
509 * expanded with DWIM and assigned to out_real_ref.
511 * - track is the tracking mode of the new branch. If tracking is
512 * explicitly requested, start_name must be a branch (because
513 * otherwise start_name cannot be tracked)
515 * - out_oid is an out parameter containing the object_id of start_name
517 * - out_real_ref is an out parameter containing the full, 'real' form
518 * of start_name e.g. refs/heads/main instead of main
521 static void dwim_branch_start(struct repository
*r
, const char *start_name
,
522 enum branch_track track
, char **out_real_ref
,
523 struct object_id
*out_oid
)
525 struct commit
*commit
;
526 struct object_id oid
;
528 int explicit_tracking
= 0;
530 if (track
== BRANCH_TRACK_EXPLICIT
|| track
== BRANCH_TRACK_OVERRIDE
)
531 explicit_tracking
= 1;
534 if (repo_get_oid_mb(the_repository
, start_name
, &oid
)) {
535 if (explicit_tracking
) {
536 int code
= die_message(_(upstream_missing
), start_name
);
537 advise_if_enabled(ADVICE_SET_UPSTREAM_FAILURE
,
541 die(_("not a valid object name: '%s'"), start_name
);
544 switch (repo_dwim_ref(the_repository
, start_name
, strlen(start_name
),
545 &oid
, &real_ref
, 0)) {
547 /* Not branching from any existing branch */
548 if (explicit_tracking
)
549 die(_(upstream_not_branch
), start_name
);
552 /* Unique completion -- good, only if it is a real branch */
553 if (!starts_with(real_ref
, "refs/heads/") &&
554 validate_remote_tracking_branch(real_ref
)) {
555 if (explicit_tracking
)
556 die(_(upstream_not_branch
), start_name
);
558 FREE_AND_NULL(real_ref
);
562 die(_("ambiguous object name: '%s'"), start_name
);
566 if (!(commit
= lookup_commit_reference(r
, &oid
)))
567 die(_("not a valid branch point: '%s'"), start_name
);
569 *out_real_ref
= real_ref
;
573 oidcpy(out_oid
, &commit
->object
.oid
);
575 FREE_AND_NULL(real_ref
);
578 void create_branch(struct repository
*r
,
579 const char *name
, const char *start_name
,
580 int force
, int clobber_head_ok
, int reflog
,
581 int quiet
, enum branch_track track
, int dry_run
)
583 struct object_id oid
;
585 struct strbuf ref
= STRBUF_INIT
;
587 struct ref_transaction
*transaction
;
588 struct strbuf err
= STRBUF_INIT
;
591 if (track
== BRANCH_TRACK_OVERRIDE
)
592 BUG("'track' cannot be BRANCH_TRACK_OVERRIDE. Did you mean to call dwim_and_setup_tracking()?");
593 if (clobber_head_ok
&& !force
)
594 BUG("'clobber_head_ok' can only be used with 'force'");
596 if (clobber_head_ok
?
597 validate_branchname(name
, &ref
) :
598 validate_new_branchname(name
, &ref
, force
)) {
602 dwim_branch_start(r
, start_name
, track
, &real_ref
, &oid
);
607 log_all_ref_updates
= LOG_REFS_NORMAL
;
610 msg
= xstrfmt("branch: Reset to %s", start_name
);
612 msg
= xstrfmt("branch: Created from %s", start_name
);
613 transaction
= ref_transaction_begin(&err
);
615 ref_transaction_update(transaction
, ref
.buf
,
616 &oid
, forcing
? NULL
: null_oid(),
618 ref_transaction_commit(transaction
, &err
))
620 ref_transaction_free(transaction
);
621 strbuf_release(&err
);
624 if (real_ref
&& track
)
625 setup_tracking(ref
.buf
+ 11, real_ref
, track
, quiet
);
628 strbuf_release(&ref
);
632 void dwim_and_setup_tracking(struct repository
*r
, const char *new_ref
,
633 const char *orig_ref
, enum branch_track track
,
637 dwim_branch_start(r
, orig_ref
, track
, &real_orig_ref
, NULL
);
638 setup_tracking(new_ref
, real_orig_ref
, track
, quiet
);
642 * Creates a branch in a submodule by calling
643 * create_branches_recursively() in a child process. The child process
644 * is necessary because install_branch_config_multiple_remotes() (which
645 * is called by setup_tracking()) does not support writing configs to
648 static int submodule_create_branch(struct repository
*r
,
649 const struct submodule
*submodule
,
650 const char *name
, const char *start_oid
,
651 const char *tracking_name
, int force
,
652 int reflog
, int quiet
,
653 enum branch_track track
, int dry_run
)
656 struct child_process child
= CHILD_PROCESS_INIT
;
657 struct strbuf child_err
= STRBUF_INIT
;
658 struct strbuf out_buf
= STRBUF_INIT
;
659 char *out_prefix
= xstrfmt("submodule '%s': ", submodule
->name
);
662 child
.stdout_to_stderr
= 1;
664 prepare_other_repo_env(&child
.env
, r
->gitdir
);
666 * submodule_create_branch() is indirectly invoked by "git
667 * branch", but we cannot invoke "git branch" in the child
668 * process. "git branch" accepts a branch name and start point,
669 * where the start point is assumed to provide both the OID
670 * (start_oid) and the branch to use for tracking
671 * (tracking_name). But when recursing through submodules,
672 * start_oid and tracking name need to be specified separately
673 * (see create_branches_recursively()).
675 strvec_pushl(&child
.args
, "submodule--helper", "create-branch", NULL
);
677 strvec_push(&child
.args
, "--dry-run");
679 strvec_push(&child
.args
, "--force");
681 strvec_push(&child
.args
, "--quiet");
683 strvec_push(&child
.args
, "--create-reflog");
686 case BRANCH_TRACK_NEVER
:
687 strvec_push(&child
.args
, "--no-track");
689 case BRANCH_TRACK_ALWAYS
:
690 case BRANCH_TRACK_EXPLICIT
:
691 strvec_push(&child
.args
, "--track=direct");
693 case BRANCH_TRACK_OVERRIDE
:
694 BUG("BRANCH_TRACK_OVERRIDE cannot be used when creating a branch.");
696 case BRANCH_TRACK_INHERIT
:
697 strvec_push(&child
.args
, "--track=inherit");
699 case BRANCH_TRACK_UNSPECIFIED
:
700 /* Default for "git checkout". Do not pass --track. */
701 case BRANCH_TRACK_REMOTE
:
702 /* Default for "git branch". Do not pass --track. */
703 case BRANCH_TRACK_SIMPLE
:
704 /* Config-driven only. Do not pass --track. */
708 strvec_pushl(&child
.args
, name
, start_oid
, tracking_name
, NULL
);
710 if ((ret
= start_command(&child
)))
712 ret
= finish_command(&child
);
713 strbuf_read(&child_err
, child
.err
, 0);
714 strbuf_add_lines(&out_buf
, out_prefix
, child_err
.buf
, child_err
.len
);
717 fprintf(stderr
, "%s", out_buf
.buf
);
719 printf("%s", out_buf
.buf
);
721 strbuf_release(&child_err
);
722 strbuf_release(&out_buf
);
726 void create_branches_recursively(struct repository
*r
, const char *name
,
727 const char *start_commitish
,
728 const char *tracking_name
, int force
,
729 int reflog
, int quiet
, enum branch_track track
,
733 char *branch_point
= NULL
;
734 struct object_id super_oid
;
735 struct submodule_entry_list submodule_entry_list
;
737 /* Perform dwim on start_commitish to get super_oid and branch_point. */
738 dwim_branch_start(r
, start_commitish
, BRANCH_TRACK_NEVER
,
739 &branch_point
, &super_oid
);
742 * If we were not given an explicit name to track, then assume we are at
743 * the top level and, just like the non-recursive case, the tracking
744 * name is the branch point.
747 tracking_name
= branch_point
;
749 submodules_of_tree(r
, &super_oid
, &submodule_entry_list
);
751 * Before creating any branches, first check that the branch can
752 * be created in every submodule.
754 for (i
= 0; i
< submodule_entry_list
.entry_nr
; i
++) {
755 if (!submodule_entry_list
.entries
[i
].repo
) {
756 int code
= die_message(
757 _("submodule '%s': unable to find submodule"),
758 submodule_entry_list
.entries
[i
].submodule
->name
);
759 if (advice_enabled(ADVICE_SUBMODULES_NOT_UPDATED
))
760 advise(_("You may try updating the submodules using 'git checkout --no-recurse-submodules %s && git submodule update --init'"),
765 if (submodule_create_branch(
766 submodule_entry_list
.entries
[i
].repo
,
767 submodule_entry_list
.entries
[i
].submodule
, name
,
768 oid_to_hex(&submodule_entry_list
.entries
[i
]
770 tracking_name
, force
, reflog
, quiet
, track
, 1))
771 die(_("submodule '%s': cannot create branch '%s'"),
772 submodule_entry_list
.entries
[i
].submodule
->name
,
776 create_branch(the_repository
, name
, start_commitish
, force
, 0, reflog
, quiet
,
777 BRANCH_TRACK_NEVER
, dry_run
);
781 * NEEDSWORK If tracking was set up in the superproject but not the
782 * submodule, users might expect "git branch --recurse-submodules" to
783 * fail or give a warning, but this is not yet implemented because it is
784 * tedious to determine whether or not tracking was set up in the
788 setup_tracking(name
, tracking_name
, track
, quiet
);
790 for (i
= 0; i
< submodule_entry_list
.entry_nr
; i
++) {
791 if (submodule_create_branch(
792 submodule_entry_list
.entries
[i
].repo
,
793 submodule_entry_list
.entries
[i
].submodule
, name
,
794 oid_to_hex(&submodule_entry_list
.entries
[i
]
796 tracking_name
, force
, reflog
, quiet
, track
, 0))
797 die(_("submodule '%s': cannot create branch '%s'"),
798 submodule_entry_list
.entries
[i
].submodule
->name
,
800 repo_clear(submodule_entry_list
.entries
[i
].repo
);
804 void remove_merge_branch_state(struct repository
*r
)
806 unlink(git_path_merge_head(r
));
807 unlink(git_path_merge_rr(r
));
808 unlink(git_path_merge_msg(r
));
809 unlink(git_path_merge_mode(r
));
810 unlink(git_path_auto_merge(r
));
811 save_autostash(git_path_merge_autostash(r
));
814 void remove_branch_state(struct repository
*r
, int verbose
)
816 sequencer_post_commit_cleanup(r
, verbose
);
817 unlink(git_path_squash_msg(r
));
818 remove_merge_branch_state(r
);
821 void die_if_checked_out(const char *branch
, int ignore_current_worktree
)
823 struct worktree
**worktrees
= get_worktrees();
824 const struct worktree
*wt
;
826 wt
= find_shared_symref(worktrees
, "HEAD", branch
);
827 if (wt
&& (!ignore_current_worktree
|| !wt
->is_current
)) {
828 skip_prefix(branch
, "refs/heads/", &branch
);
829 die(_("'%s' is already checked out at '%s'"), branch
, wt
->path
);
832 free_worktrees(worktrees
);
835 int replace_each_worktree_head_symref(const char *oldref
, const char *newref
,
839 struct worktree
**worktrees
= get_worktrees();
842 for (i
= 0; worktrees
[i
]; i
++) {
843 struct ref_store
*refs
;
845 if (worktrees
[i
]->is_detached
)
847 if (!worktrees
[i
]->head_ref
)
849 if (strcmp(oldref
, worktrees
[i
]->head_ref
))
852 refs
= get_worktree_ref_store(worktrees
[i
]);
853 if (refs_create_symref(refs
, "HEAD", newref
, logmsg
))
854 ret
= error(_("HEAD of working tree %s is not updated"),
858 free_worktrees(worktrees
);