1 #include "git-compat-util.h"
5 #include "environment.h"
8 #include "object-name.h"
12 #include "repository.h"
13 #include "sequencer.h"
16 #include "submodule-config.h"
17 #include "run-command.h"
21 struct refspec_item spec
;
22 struct string_list
*srcs
;
27 struct find_tracked_branch_cb
{
28 struct tracking
*tracking
;
29 struct string_list ambiguous_remotes
;
32 static int find_tracked_branch(struct remote
*remote
, void *priv
)
34 struct find_tracked_branch_cb
*ftb
= priv
;
35 struct tracking
*tracking
= ftb
->tracking
;
37 if (!remote_find_tracking(remote
, &tracking
->spec
)) {
38 switch (++tracking
->matches
) {
40 string_list_append_nodup(tracking
->srcs
, tracking
->spec
.src
);
41 tracking
->remote
= remote
->name
;
44 /* there are at least two remotes; backfill the first one */
45 string_list_append(&ftb
->ambiguous_remotes
, tracking
->remote
);
48 string_list_append(&ftb
->ambiguous_remotes
, remote
->name
);
49 free(tracking
->spec
.src
);
50 string_list_clear(tracking
->srcs
, 0);
53 /* remote_find_tracking() searches by src if present */
54 tracking
->spec
.src
= NULL
;
59 static int should_setup_rebase(const char *origin
)
62 case AUTOREBASE_NEVER
:
64 case AUTOREBASE_LOCAL
:
65 return origin
== NULL
;
66 case AUTOREBASE_REMOTE
:
67 return origin
!= NULL
;
68 case AUTOREBASE_ALWAYS
:
75 * Install upstream tracking configuration for a branch; specifically, add
76 * `branch.<name>.remote` and `branch.<name>.merge` entries.
78 * `flag` contains integer flags for options; currently only
79 * BRANCH_CONFIG_VERBOSE is checked.
81 * `local` is the name of the branch whose configuration we're installing.
83 * `origin` is the name of the remote owning the upstream branches. NULL means
84 * the upstream branches are local to this repo.
86 * `remotes` is a list of refs that are upstream of local
88 static int install_branch_config_multiple_remotes(int flag
, const char *local
,
89 const char *origin
, struct string_list
*remotes
)
91 const char *shortname
= NULL
;
92 struct strbuf key
= STRBUF_INIT
;
93 struct string_list_item
*item
;
94 int rebasing
= should_setup_rebase(origin
);
97 BUG("must provide at least one remote for branch config");
98 if (rebasing
&& remotes
->nr
> 1)
99 die(_("cannot inherit upstream tracking configuration of "
100 "multiple refs when rebasing is requested"));
103 * If the new branch is trying to track itself, something has gone
104 * wrong. Warn the user and don't proceed any further.
107 for_each_string_list_item(item
, remotes
)
108 if (skip_prefix(item
->string
, "refs/heads/", &shortname
)
109 && !strcmp(local
, shortname
)) {
110 warning(_("not setting branch '%s' as its own upstream"),
115 strbuf_addf(&key
, "branch.%s.remote", local
);
116 if (git_config_set_gently(key
.buf
, origin
? origin
: ".") < 0)
120 strbuf_addf(&key
, "branch.%s.merge", local
);
122 * We want to overwrite any existing config with all the branches in
123 * "remotes". Override any existing config, then write our branches. If
124 * more than one is provided, use CONFIG_REGEX_NONE to preserve what
125 * we've written so far.
127 if (git_config_set_gently(key
.buf
, NULL
) < 0)
129 for_each_string_list_item(item
, remotes
)
130 if (git_config_set_multivar_gently(key
.buf
, item
->string
, CONFIG_REGEX_NONE
, 0) < 0)
135 strbuf_addf(&key
, "branch.%s.rebase", local
);
136 if (git_config_set_gently(key
.buf
, "true") < 0)
139 strbuf_release(&key
);
141 if (flag
& BRANCH_CONFIG_VERBOSE
) {
142 struct strbuf tmp_ref_name
= STRBUF_INIT
;
143 struct string_list friendly_ref_names
= STRING_LIST_INIT_DUP
;
145 for_each_string_list_item(item
, remotes
) {
146 shortname
= item
->string
;
147 skip_prefix(shortname
, "refs/heads/", &shortname
);
149 strbuf_addf(&tmp_ref_name
, "%s/%s",
151 string_list_append_nodup(
153 strbuf_detach(&tmp_ref_name
, NULL
));
156 &friendly_ref_names
, shortname
);
160 if (remotes
->nr
== 1) {
162 * Rebasing is only allowed in the case of a single
166 _("branch '%s' set up to track '%s' by rebasing.") :
167 _("branch '%s' set up to track '%s'."),
168 local
, friendly_ref_names
.items
[0].string
);
170 printf_ln(_("branch '%s' set up to track:"), local
);
171 for_each_string_list_item(item
, &friendly_ref_names
)
172 printf_ln(" %s", item
->string
);
175 string_list_clear(&friendly_ref_names
, 0);
181 strbuf_release(&key
);
182 error(_("unable to write upstream branch configuration"));
184 advise(_("\nAfter fixing the error cause you may try to fix up\n"
185 "the remote tracking information by invoking:"));
186 if (remotes
->nr
== 1)
187 advise(" git branch --set-upstream-to=%s%s%s",
188 origin
? origin
: "",
190 remotes
->items
[0].string
);
192 advise(" git config --add branch.\"%s\".remote %s",
193 local
, origin
? origin
: ".");
194 for_each_string_list_item(item
, remotes
)
195 advise(" git config --add branch.\"%s\".merge %s",
196 local
, item
->string
);
202 int install_branch_config(int flag
, const char *local
, const char *origin
,
206 struct string_list remotes
= STRING_LIST_INIT_DUP
;
208 string_list_append(&remotes
, remote
);
209 ret
= install_branch_config_multiple_remotes(flag
, local
, origin
, &remotes
);
210 string_list_clear(&remotes
, 0);
214 static int inherit_tracking(struct tracking
*tracking
, const char *orig_ref
)
216 const char *bare_ref
;
217 struct branch
*branch
;
221 skip_prefix(orig_ref
, "refs/heads/", &bare_ref
);
223 branch
= branch_get(bare_ref
);
224 if (!branch
->remote_name
) {
225 warning(_("asked to inherit tracking from '%s', but no remote is set"),
230 if (branch
->merge_nr
< 1 || !branch
->merge_name
|| !branch
->merge_name
[0]) {
231 warning(_("asked to inherit tracking from '%s', but no merge configuration is set"),
236 tracking
->remote
= branch
->remote_name
;
237 for (i
= 0; i
< branch
->merge_nr
; i
++)
238 string_list_append(tracking
->srcs
, branch
->merge_name
[i
]);
243 * Used internally to set the branch.<new_ref>.{remote,merge} config
244 * settings so that branch 'new_ref' tracks 'orig_ref'. Unlike
245 * dwim_and_setup_tracking(), this does not do DWIM, i.e. "origin/main"
246 * will not be expanded to "refs/remotes/origin/main", so it is not safe
247 * for 'orig_ref' to be raw user input.
249 static void setup_tracking(const char *new_ref
, const char *orig_ref
,
250 enum branch_track track
, int quiet
)
252 struct tracking tracking
;
253 struct string_list tracking_srcs
= STRING_LIST_INIT_DUP
;
254 int config_flags
= quiet
? 0 : BRANCH_CONFIG_VERBOSE
;
255 struct find_tracked_branch_cb ftb_cb
= {
256 .tracking
= &tracking
,
257 .ambiguous_remotes
= STRING_LIST_INIT_DUP
,
261 BUG("asked to set up tracking, but tracking is disallowed");
263 memset(&tracking
, 0, sizeof(tracking
));
264 tracking
.spec
.dst
= (char *)orig_ref
;
265 tracking
.srcs
= &tracking_srcs
;
266 if (track
!= BRANCH_TRACK_INHERIT
)
267 for_each_remote(find_tracked_branch
, &ftb_cb
);
268 else if (inherit_tracking(&tracking
, orig_ref
))
271 if (!tracking
.matches
)
273 /* If ref is not remote, still use local */
274 case BRANCH_TRACK_ALWAYS
:
275 case BRANCH_TRACK_EXPLICIT
:
276 case BRANCH_TRACK_OVERRIDE
:
277 /* Remote matches not evaluated */
278 case BRANCH_TRACK_INHERIT
:
280 /* Otherwise, if no remote don't track */
286 * This check does not apply to BRANCH_TRACK_INHERIT;
287 * that supports multiple entries in tracking_srcs but
288 * leaves tracking.matches at 0.
290 if (tracking
.matches
> 1) {
291 int status
= die_message(_("not tracking: ambiguous information for ref '%s'"),
293 if (advice_enabled(ADVICE_AMBIGUOUS_FETCH_REFSPEC
)) {
294 struct strbuf remotes_advice
= STRBUF_INIT
;
295 struct string_list_item
*item
;
297 for_each_string_list_item(item
, &ftb_cb
.ambiguous_remotes
)
299 * TRANSLATORS: This is a line listing a remote with duplicate
300 * refspecs in the advice message below. For RTL languages you'll
301 * probably want to swap the "%s" and leading " " space around.
303 strbuf_addf(&remotes_advice
, _(" %s\n"), item
->string
);
306 * TRANSLATORS: The second argument is a \n-delimited list of
307 * duplicate refspecs, composed above.
309 advise(_("There are multiple remotes whose fetch refspecs map to the remote\n"
310 "tracking ref '%s':\n"
313 "This is typically a configuration error.\n"
315 "To support setting up tracking branches, ensure that\n"
316 "different remotes' fetch refspecs map into different\n"
317 "tracking namespaces."), orig_ref
,
319 strbuf_release(&remotes_advice
);
324 if (track
== BRANCH_TRACK_SIMPLE
) {
326 * Only track if remote branch name matches.
327 * Reaching into items[0].string is safe because
328 * we know there is at least one and not more than
329 * one entry (because only BRANCH_TRACK_INHERIT can
330 * produce more than one entry).
332 const char *tracked_branch
;
333 if (!skip_prefix(tracking
.srcs
->items
[0].string
,
334 "refs/heads/", &tracked_branch
) ||
335 strcmp(tracked_branch
, new_ref
))
339 if (tracking
.srcs
->nr
< 1)
340 string_list_append(tracking
.srcs
, orig_ref
);
341 if (install_branch_config_multiple_remotes(config_flags
, new_ref
,
342 tracking
.remote
, tracking
.srcs
) < 0)
346 string_list_clear(&tracking_srcs
, 0);
347 string_list_clear(&ftb_cb
.ambiguous_remotes
, 0);
350 int read_branch_desc(struct strbuf
*buf
, const char *branch_name
)
353 struct strbuf name
= STRBUF_INIT
;
354 strbuf_addf(&name
, "branch.%s.description", branch_name
);
355 if (git_config_get_string(name
.buf
, &v
)) {
356 strbuf_release(&name
);
359 strbuf_addstr(buf
, v
);
361 strbuf_release(&name
);
366 * Check if 'name' can be a valid name for a branch; die otherwise.
367 * Return 1 if the named branch already exists; return 0 otherwise.
368 * Fill ref with the full refname for the branch.
370 int validate_branchname(const char *name
, struct strbuf
*ref
)
372 if (strbuf_check_branch_ref(ref
, name
))
373 die(_("'%s' is not a valid branch name"), name
);
375 return ref_exists(ref
->buf
);
378 static int initialized_checked_out_branches
;
379 static struct strmap current_checked_out_branches
= STRMAP_INIT
;
381 static void prepare_checked_out_branches(void)
384 struct worktree
**worktrees
;
386 if (initialized_checked_out_branches
)
388 initialized_checked_out_branches
= 1;
390 worktrees
= get_worktrees();
392 while (worktrees
[i
]) {
394 struct wt_status_state state
= { 0 };
395 struct worktree
*wt
= worktrees
[i
++];
396 struct string_list update_refs
= STRING_LIST_INIT_DUP
;
402 old
= strmap_put(¤t_checked_out_branches
,
408 if (wt_status_check_rebase(wt
, &state
) &&
409 (state
.rebase_in_progress
|| state
.rebase_interactive_in_progress
) &&
411 struct strbuf ref
= STRBUF_INIT
;
412 strbuf_addf(&ref
, "refs/heads/%s", state
.branch
);
413 old
= strmap_put(¤t_checked_out_branches
,
417 strbuf_release(&ref
);
419 wt_status_state_free_buffers(&state
);
421 if (wt_status_check_bisect(wt
, &state
) &&
423 struct strbuf ref
= STRBUF_INIT
;
424 strbuf_addf(&ref
, "refs/heads/%s", state
.branch
);
425 old
= strmap_put(¤t_checked_out_branches
,
429 strbuf_release(&ref
);
431 wt_status_state_free_buffers(&state
);
433 if (!sequencer_get_update_refs_state(get_worktree_git_dir(wt
),
435 struct string_list_item
*item
;
436 for_each_string_list_item(item
, &update_refs
) {
437 old
= strmap_put(¤t_checked_out_branches
,
442 string_list_clear(&update_refs
, 1);
446 free_worktrees(worktrees
);
449 const char *branch_checked_out(const char *refname
)
451 prepare_checked_out_branches();
452 return strmap_get(¤t_checked_out_branches
, refname
);
456 * Check if a branch 'name' can be created as a new branch; die otherwise.
457 * 'force' can be used when it is OK for the named branch already exists.
458 * Return 1 if the named branch already exists; return 0 otherwise.
459 * Fill ref with the full refname for the branch.
461 int validate_new_branchname(const char *name
, struct strbuf
*ref
, int force
)
464 if (!validate_branchname(name
, ref
))
468 die(_("a branch named '%s' already exists"),
469 ref
->buf
+ strlen("refs/heads/"));
471 if ((path
= branch_checked_out(ref
->buf
)))
472 die(_("cannot force update the branch '%s' "
473 "checked out at '%s'"),
474 ref
->buf
+ strlen("refs/heads/"), path
);
479 static int check_tracking_branch(struct remote
*remote
, void *cb_data
)
481 char *tracking_branch
= cb_data
;
482 struct refspec_item query
;
484 memset(&query
, 0, sizeof(struct refspec_item
));
485 query
.dst
= tracking_branch
;
486 res
= !remote_find_tracking(remote
, &query
);
491 static int validate_remote_tracking_branch(char *ref
)
493 return !for_each_remote(check_tracking_branch
, ref
);
496 static const char upstream_not_branch
[] =
497 N_("cannot set up tracking information; starting point '%s' is not a branch");
498 static const char upstream_missing
[] =
499 N_("the requested upstream branch '%s' does not exist");
500 static const char upstream_advice
[] =
502 "If you are planning on basing your work on an upstream\n"
503 "branch that already exists at the remote, you may need to\n"
504 "run \"git fetch\" to retrieve it.\n"
506 "If you are planning to push out a new local branch that\n"
507 "will track its remote counterpart, you may want to use\n"
508 "\"git push -u\" to set the upstream config as you push.");
511 * DWIMs a user-provided ref to determine the starting point for a
512 * branch and validates it, where:
514 * - r is the repository to validate the branch for
516 * - start_name is the ref that we would like to test. This is
517 * expanded with DWIM and assigned to out_real_ref.
519 * - track is the tracking mode of the new branch. If tracking is
520 * explicitly requested, start_name must be a branch (because
521 * otherwise start_name cannot be tracked)
523 * - out_oid is an out parameter containing the object_id of start_name
525 * - out_real_ref is an out parameter containing the full, 'real' form
526 * of start_name e.g. refs/heads/main instead of main
529 static void dwim_branch_start(struct repository
*r
, const char *start_name
,
530 enum branch_track track
, char **out_real_ref
,
531 struct object_id
*out_oid
)
533 struct commit
*commit
;
534 struct object_id oid
;
536 int explicit_tracking
= 0;
538 if (track
== BRANCH_TRACK_EXPLICIT
|| track
== BRANCH_TRACK_OVERRIDE
)
539 explicit_tracking
= 1;
542 if (repo_get_oid_mb(r
, start_name
, &oid
)) {
543 if (explicit_tracking
) {
544 int code
= die_message(_(upstream_missing
), start_name
);
545 advise_if_enabled(ADVICE_SET_UPSTREAM_FAILURE
,
549 die(_("not a valid object name: '%s'"), start_name
);
552 switch (repo_dwim_ref(r
, start_name
, strlen(start_name
), &oid
,
555 /* Not branching from any existing branch */
556 if (explicit_tracking
)
557 die(_(upstream_not_branch
), start_name
);
560 /* Unique completion -- good, only if it is a real branch */
561 if (!starts_with(real_ref
, "refs/heads/") &&
562 validate_remote_tracking_branch(real_ref
)) {
563 if (explicit_tracking
)
564 die(_(upstream_not_branch
), start_name
);
566 FREE_AND_NULL(real_ref
);
570 die(_("ambiguous object name: '%s'"), start_name
);
574 if (!(commit
= lookup_commit_reference(r
, &oid
)))
575 die(_("not a valid branch point: '%s'"), start_name
);
577 *out_real_ref
= real_ref
;
581 oidcpy(out_oid
, &commit
->object
.oid
);
583 FREE_AND_NULL(real_ref
);
586 void create_branch(struct repository
*r
,
587 const char *name
, const char *start_name
,
588 int force
, int clobber_head_ok
, int reflog
,
589 int quiet
, enum branch_track track
, int dry_run
)
591 struct object_id oid
;
593 struct strbuf ref
= STRBUF_INIT
;
595 struct ref_transaction
*transaction
;
596 struct strbuf err
= STRBUF_INIT
;
599 if (track
== BRANCH_TRACK_OVERRIDE
)
600 BUG("'track' cannot be BRANCH_TRACK_OVERRIDE. Did you mean to call dwim_and_setup_tracking()?");
601 if (clobber_head_ok
&& !force
)
602 BUG("'clobber_head_ok' can only be used with 'force'");
604 if (clobber_head_ok
?
605 validate_branchname(name
, &ref
) :
606 validate_new_branchname(name
, &ref
, force
)) {
610 dwim_branch_start(r
, start_name
, track
, &real_ref
, &oid
);
615 log_all_ref_updates
= LOG_REFS_NORMAL
;
618 msg
= xstrfmt("branch: Reset to %s", start_name
);
620 msg
= xstrfmt("branch: Created from %s", start_name
);
621 transaction
= ref_transaction_begin(&err
);
623 ref_transaction_update(transaction
, ref
.buf
,
624 &oid
, forcing
? NULL
: null_oid(),
626 ref_transaction_commit(transaction
, &err
))
628 ref_transaction_free(transaction
);
629 strbuf_release(&err
);
632 if (real_ref
&& track
)
633 setup_tracking(ref
.buf
+ 11, real_ref
, track
, quiet
);
636 strbuf_release(&ref
);
640 void dwim_and_setup_tracking(struct repository
*r
, const char *new_ref
,
641 const char *orig_ref
, enum branch_track track
,
644 char *real_orig_ref
= NULL
;
645 dwim_branch_start(r
, orig_ref
, track
, &real_orig_ref
, NULL
);
646 setup_tracking(new_ref
, real_orig_ref
, track
, quiet
);
651 * Creates a branch in a submodule by calling
652 * create_branches_recursively() in a child process. The child process
653 * is necessary because install_branch_config_multiple_remotes() (which
654 * is called by setup_tracking()) does not support writing configs to
657 static int submodule_create_branch(struct repository
*r
,
658 const struct submodule
*submodule
,
659 const char *name
, const char *start_oid
,
660 const char *tracking_name
, int force
,
661 int reflog
, int quiet
,
662 enum branch_track track
, int dry_run
)
665 struct child_process child
= CHILD_PROCESS_INIT
;
666 struct strbuf child_err
= STRBUF_INIT
;
667 struct strbuf out_buf
= STRBUF_INIT
;
668 char *out_prefix
= xstrfmt("submodule '%s': ", submodule
->name
);
671 child
.stdout_to_stderr
= 1;
673 prepare_other_repo_env(&child
.env
, r
->gitdir
);
675 * submodule_create_branch() is indirectly invoked by "git
676 * branch", but we cannot invoke "git branch" in the child
677 * process. "git branch" accepts a branch name and start point,
678 * where the start point is assumed to provide both the OID
679 * (start_oid) and the branch to use for tracking
680 * (tracking_name). But when recursing through submodules,
681 * start_oid and tracking name need to be specified separately
682 * (see create_branches_recursively()).
684 strvec_pushl(&child
.args
, "submodule--helper", "create-branch", NULL
);
686 strvec_push(&child
.args
, "--dry-run");
688 strvec_push(&child
.args
, "--force");
690 strvec_push(&child
.args
, "--quiet");
692 strvec_push(&child
.args
, "--create-reflog");
695 case BRANCH_TRACK_NEVER
:
696 strvec_push(&child
.args
, "--no-track");
698 case BRANCH_TRACK_ALWAYS
:
699 case BRANCH_TRACK_EXPLICIT
:
700 strvec_push(&child
.args
, "--track=direct");
702 case BRANCH_TRACK_OVERRIDE
:
703 BUG("BRANCH_TRACK_OVERRIDE cannot be used when creating a branch.");
705 case BRANCH_TRACK_INHERIT
:
706 strvec_push(&child
.args
, "--track=inherit");
708 case BRANCH_TRACK_UNSPECIFIED
:
709 /* Default for "git checkout". Do not pass --track. */
710 case BRANCH_TRACK_REMOTE
:
711 /* Default for "git branch". Do not pass --track. */
712 case BRANCH_TRACK_SIMPLE
:
713 /* Config-driven only. Do not pass --track. */
717 strvec_pushl(&child
.args
, name
, start_oid
, tracking_name
, NULL
);
719 if ((ret
= start_command(&child
)))
721 ret
= finish_command(&child
);
722 strbuf_read(&child_err
, child
.err
, 0);
723 strbuf_add_lines(&out_buf
, out_prefix
, child_err
.buf
, child_err
.len
);
726 fprintf(stderr
, "%s", out_buf
.buf
);
728 printf("%s", out_buf
.buf
);
730 strbuf_release(&child_err
);
731 strbuf_release(&out_buf
);
735 void create_branches_recursively(struct repository
*r
, const char *name
,
736 const char *start_commitish
,
737 const char *tracking_name
, int force
,
738 int reflog
, int quiet
, enum branch_track track
,
742 char *branch_point
= NULL
;
743 struct object_id super_oid
;
744 struct submodule_entry_list submodule_entry_list
;
746 /* Perform dwim on start_commitish to get super_oid and branch_point. */
747 dwim_branch_start(r
, start_commitish
, BRANCH_TRACK_NEVER
,
748 &branch_point
, &super_oid
);
751 * If we were not given an explicit name to track, then assume we are at
752 * the top level and, just like the non-recursive case, the tracking
753 * name is the branch point.
756 tracking_name
= branch_point
;
758 submodules_of_tree(r
, &super_oid
, &submodule_entry_list
);
760 * Before creating any branches, first check that the branch can
761 * be created in every submodule.
763 for (i
= 0; i
< submodule_entry_list
.entry_nr
; i
++) {
764 if (!submodule_entry_list
.entries
[i
].repo
) {
765 int code
= die_message(
766 _("submodule '%s': unable to find submodule"),
767 submodule_entry_list
.entries
[i
].submodule
->name
);
768 if (advice_enabled(ADVICE_SUBMODULES_NOT_UPDATED
))
769 advise(_("You may try updating the submodules using 'git checkout --no-recurse-submodules %s && git submodule update --init'"),
774 if (submodule_create_branch(
775 submodule_entry_list
.entries
[i
].repo
,
776 submodule_entry_list
.entries
[i
].submodule
, name
,
777 oid_to_hex(&submodule_entry_list
.entries
[i
]
779 tracking_name
, force
, reflog
, quiet
, track
, 1))
780 die(_("submodule '%s': cannot create branch '%s'"),
781 submodule_entry_list
.entries
[i
].submodule
->name
,
785 create_branch(r
, name
, start_commitish
, force
, 0, reflog
, quiet
,
786 BRANCH_TRACK_NEVER
, dry_run
);
790 * NEEDSWORK If tracking was set up in the superproject but not the
791 * submodule, users might expect "git branch --recurse-submodules" to
792 * fail or give a warning, but this is not yet implemented because it is
793 * tedious to determine whether or not tracking was set up in the
797 setup_tracking(name
, tracking_name
, track
, quiet
);
799 for (i
= 0; i
< submodule_entry_list
.entry_nr
; i
++) {
800 if (submodule_create_branch(
801 submodule_entry_list
.entries
[i
].repo
,
802 submodule_entry_list
.entries
[i
].submodule
, name
,
803 oid_to_hex(&submodule_entry_list
.entries
[i
]
805 tracking_name
, force
, reflog
, quiet
, track
, 0))
806 die(_("submodule '%s': cannot create branch '%s'"),
807 submodule_entry_list
.entries
[i
].submodule
->name
,
809 repo_clear(submodule_entry_list
.entries
[i
].repo
);
813 void remove_merge_branch_state(struct repository
*r
)
815 unlink(git_path_merge_head(r
));
816 unlink(git_path_merge_rr(r
));
817 unlink(git_path_merge_msg(r
));
818 unlink(git_path_merge_mode(r
));
819 unlink(git_path_auto_merge(r
));
820 save_autostash(git_path_merge_autostash(r
));
823 void remove_branch_state(struct repository
*r
, int verbose
)
825 sequencer_post_commit_cleanup(r
, verbose
);
826 unlink(git_path_squash_msg(r
));
827 remove_merge_branch_state(r
);
830 void die_if_checked_out(const char *branch
, int ignore_current_worktree
)
832 struct worktree
**worktrees
= get_worktrees();
834 for (int i
= 0; worktrees
[i
]; i
++) {
835 if (worktrees
[i
]->is_current
&& ignore_current_worktree
)
838 if (is_shared_symref(worktrees
[i
], "HEAD", branch
)) {
839 skip_prefix(branch
, "refs/heads/", &branch
);
840 die(_("'%s' is already checked out at '%s'"),
841 branch
, worktrees
[i
]->path
);
845 free_worktrees(worktrees
);