🌐 AI搜索 & 代理 主页
Google Git
Sign in
chromium / external / github.com / git / git / refs/tags/v2.29.0 / . / branch.c
blob: 9c9dae1eae321c6878607a3b624a187fcb176380 [file] [log] [blame]
Brian Gesiak303d1d02014-02-28 06:43:33[diff] [blame]1#include "git-compat-util.h"
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]2#include "cache.h"
Brandon Williamsb2141fc2017-06-14 18:07:36[diff] [blame]3#include "config.h"
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]4#include "branch.h"
5#include "refs.h"
Brandon Williamsec0cb492018-05-16 22:57:48[diff] [blame]6#include "refspec.h"
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]7#include "remote.h"
Phillip Woodb07d9bf2019-04-16 10:18:41[diff] [blame]8#include "sequencer.h"
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]9#include "commit.h"
Michael Rappazzoac6c5612015-10-02 11:55:31[diff] [blame]10#include "worktree.h"
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]11
12struct tracking {
Brandon Williams0ad4a5f2018-05-16 22:57:49[diff] [blame]13 struct refspec_item spec;
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]14 char *src;
15 const char *remote;
16 int matches;
17};
18
19static int find_tracked_branch(struct remote *remote, void *priv)
20{
21 struct tracking *tracking = priv;
22
23 if (!remote_find_tracking(remote, &tracking->spec)) {
24 if (++tracking->matches == 1) {
25 tracking->src = tracking->spec.src;
26 tracking->remote = remote->name;
27 } else {
28 free(tracking->spec.src);
Ævar Arnfjörð Bjarmasonce528de2018-08-17 13:02:50[diff] [blame]29 FREE_AND_NULL(tracking->src);
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]30 }
31 tracking->spec.src = NULL;
32 }
33
34 return 0;
35}
36
Junio C Hamanoa9f2c132009-03-04 06:29:55[diff] [blame]37static int should_setup_rebase(const char *origin)
Dustin Sallingsc998ae92008-05-10 22:36:29[diff] [blame]38{
39 switch (autorebase) {
40 case AUTOREBASE_NEVER:
41 return 0;
42 case AUTOREBASE_LOCAL:
Junio C Hamanoa9f2c132009-03-04 06:29:55[diff] [blame]43 return origin == NULL;
Dustin Sallingsc998ae92008-05-10 22:36:29[diff] [blame]44 case AUTOREBASE_REMOTE:
Junio C Hamanoa9f2c132009-03-04 06:29:55[diff] [blame]45 return origin != NULL;
Dustin Sallingsc998ae92008-05-10 22:36:29[diff] [blame]46 case AUTOREBASE_ALWAYS:
47 return 1;
48 }
49 return 0;
50}
51
Patrick Steinhardt27852b22016-02-22 11:23:23[diff] [blame]52static const char tracking_advice[] =
53N_("\n"
54"After fixing the error cause you may try to fix up\n"
55"the remote tracking information by invoking\n"
56"\"git branch --set-upstream-to=%s%s%s\".");
57
58int install_branch_config(int flag, const char *local, const char *origin, const char *remote)
Junio C Hamanoa9f2c132009-03-04 06:29:55[diff] [blame]59{
Jeff Kingcf4fff52014-06-18 19:44:19[diff] [blame]60 const char *shortname = NULL;
Junio C Hamanoa9f2c132009-03-04 06:29:55[diff] [blame]61 struct strbuf key = STRBUF_INIT;
62 int rebasing = should_setup_rebase(origin);
63
Jeff Kingcf4fff52014-06-18 19:44:19[diff] [blame]64 if (skip_prefix(remote, "refs/heads/", &shortname)
Matthieu Moy85e22332010-01-18 20:44:12[diff] [blame]65 && !strcmp(local, shortname)
66 && !origin) {
Jiang Xinbc554df2013-04-16 03:37:50[diff] [blame]67 warning(_("Not setting branch %s as its own upstream."),
Matthieu Moy85e22332010-01-18 20:44:12[diff] [blame]68 local);
Patrick Steinhardt27852b22016-02-22 11:23:23[diff] [blame]69 return 0;
Matthieu Moy85e22332010-01-18 20:44:12[diff] [blame]70 }
71
Junio C Hamanoa9f2c132009-03-04 06:29:55[diff] [blame]72 strbuf_addf(&key, "branch.%s.remote", local);
Patrick Steinhardt30598ad2016-02-22 11:23:35[diff] [blame]73 if (git_config_set_gently(key.buf, origin ? origin : ".") < 0)
Patrick Steinhardt27852b22016-02-22 11:23:23[diff] [blame]74 goto out_err;
Junio C Hamanoa9f2c132009-03-04 06:29:55[diff] [blame]75
76 strbuf_reset(&key);
77 strbuf_addf(&key, "branch.%s.merge", local);
Patrick Steinhardt30598ad2016-02-22 11:23:35[diff] [blame]78 if (git_config_set_gently(key.buf, remote) < 0)
Patrick Steinhardt27852b22016-02-22 11:23:23[diff] [blame]79 goto out_err;
Junio C Hamanoa9f2c132009-03-04 06:29:55[diff] [blame]80
81 if (rebasing) {
82 strbuf_reset(&key);
83 strbuf_addf(&key, "branch.%s.rebase", local);
Patrick Steinhardt30598ad2016-02-22 11:23:35[diff] [blame]84 if (git_config_set_gently(key.buf, "true") < 0)
Patrick Steinhardt27852b22016-02-22 11:23:23[diff] [blame]85 goto out_err;
Junio C Hamanoa9f2c132009-03-04 06:29:55[diff] [blame]86 }
Nguyễn Thái Ngọc Duyd53a35032012-06-07 12:05:10[diff] [blame]87 strbuf_release(&key);
Junio C Hamanoa9f2c132009-03-04 06:29:55[diff] [blame]88
Junio C Hamano72f60082009-03-10 08:20:42[diff] [blame]89 if (flag & BRANCH_CONFIG_VERBOSE) {
Junio C Hamano1d9aaed2014-03-31 23:31:19[diff] [blame]90 if (shortname) {
Adam9fe0cf32014-03-10 05:32:01[diff] [blame]91 if (origin)
92 printf_ln(rebasing ?
Kaartic Sivaraam9c93ff72017-08-17 02:54:25[diff] [blame]93 _("Branch '%s' set up to track remote branch '%s' from '%s' by rebasing.") :
94 _("Branch '%s' set up to track remote branch '%s' from '%s'."),
Adam9fe0cf32014-03-10 05:32:01[diff] [blame]95 local, shortname, origin);
96 else
97 printf_ln(rebasing ?
Kaartic Sivaraam9c93ff72017-08-17 02:54:25[diff] [blame]98 _("Branch '%s' set up to track local branch '%s' by rebasing.") :
99 _("Branch '%s' set up to track local branch '%s'."),
Adam9fe0cf32014-03-10 05:32:01[diff] [blame]100 local, shortname);
101 } else {
102 if (origin)
103 printf_ln(rebasing ?
Kaartic Sivaraam9c93ff72017-08-17 02:54:25[diff] [blame]104 _("Branch '%s' set up to track remote ref '%s' by rebasing.") :
105 _("Branch '%s' set up to track remote ref '%s'."),
Adam9fe0cf32014-03-10 05:32:01[diff] [blame]106 local, remote);
107 else
108 printf_ln(rebasing ?
Kaartic Sivaraam9c93ff72017-08-17 02:54:25[diff] [blame]109 _("Branch '%s' set up to track local ref '%s' by rebasing.") :
110 _("Branch '%s' set up to track local ref '%s'."),
Adam9fe0cf32014-03-10 05:32:01[diff] [blame]111 local, remote);
112 }
Junio C Hamano72f60082009-03-10 08:20:42[diff] [blame]113 }
Patrick Steinhardt27852b22016-02-22 11:23:23[diff] [blame]114
115 return 0;
116
117out_err:
118 strbuf_release(&key);
119 error(_("Unable to write upstream branch configuration"));
120
121 advise(_(tracking_advice),
122 origin ? origin : "",
123 origin ? "/" : "",
124 shortname ? shortname : remote);
125
126 return -1;
Junio C Hamanoa9f2c132009-03-04 06:29:55[diff] [blame]127}
128
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]129/*
130 * This is called when new_ref is branched off of orig_ref, and tries
131 * to infer the settings for branch.<new_ref>.{remote,merge} from the
132 * config.
133 */
Patrick Steinhardt27852b22016-02-22 11:23:23[diff] [blame]134static void setup_tracking(const char *new_ref, const char *orig_ref,
135 enum branch_track track, int quiet)
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]136{
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]137 struct tracking tracking;
Jeff Kingf9a482e2012-03-26 23:51:01[diff] [blame]138 int config_flags = quiet ? 0 : BRANCH_CONFIG_VERBOSE;
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]139
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]140 memset(&tracking, 0, sizeof(tracking));
141 tracking.spec.dst = (char *)orig_ref;
Jay Soffian9ed36cf2008-02-19 16:24:37[diff] [blame]142 if (for_each_remote(find_tracked_branch, &tracking))
Patrick Steinhardt27852b22016-02-22 11:23:23[diff] [blame]143 return;
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]144
Jay Soffian9ed36cf2008-02-19 16:24:37[diff] [blame]145 if (!tracking.matches)
146 switch (track) {
147 case BRANCH_TRACK_ALWAYS:
148 case BRANCH_TRACK_EXPLICIT:
Ilari Liusvaara4fc50062010-01-18 20:44:11[diff] [blame]149 case BRANCH_TRACK_OVERRIDE:
Jay Soffian9ed36cf2008-02-19 16:24:37[diff] [blame]150 break;
151 default:
Patrick Steinhardt27852b22016-02-22 11:23:23[diff] [blame]152 return;
Jay Soffian9ed36cf2008-02-19 16:24:37[diff] [blame]153 }
154
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]155 if (tracking.matches > 1)
Patrick Steinhardt27852b22016-02-22 11:23:23[diff] [blame]156 die(_("Not tracking: ambiguous information for ref %s"),
157 orig_ref);
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]158
Patrick Steinhardt27852b22016-02-22 11:23:23[diff] [blame]159 if (install_branch_config(config_flags, new_ref, tracking.remote,
160 tracking.src ? tracking.src : orig_ref) < 0)
161 exit(-1);
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]162
Junio C Hamanoa9f2c132009-03-04 06:29:55[diff] [blame]163 free(tracking.src);
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]164}
165
Junio C Hamano6f9a3322011-09-22 03:19:38[diff] [blame]166int read_branch_desc(struct strbuf *buf, const char *branch_name)
167{
Tanay Abhra540b0f42014-08-07 17:56:42[diff] [blame]168 char *v = NULL;
Junio C Hamano6f9a3322011-09-22 03:19:38[diff] [blame]169 struct strbuf name = STRBUF_INIT;
170 strbuf_addf(&name, "branch.%s.description", branch_name);
Tanay Abhra540b0f42014-08-07 17:56:42[diff] [blame]171 if (git_config_get_string(name.buf, &v)) {
172 strbuf_release(&name);
173 return -1;
174 }
175 strbuf_addstr(buf, v);
176 free(v);
Junio C Hamano6f9a3322011-09-22 03:19:38[diff] [blame]177 strbuf_release(&name);
178 return 0;
179}
180
Junio C Hamanobc1c9c02017-10-13 04:45:40[diff] [blame]181/*
182 * Check if 'name' can be a valid name for a branch; die otherwise.
183 * Return 1 if the named branch already exists; return 0 otherwise.
184 * Fill ref with the full refname for the branch.
185 */
186int validate_branchname(const char *name, struct strbuf *ref)
Conrad Irwin55c4a672011-08-20 21:49:48[diff] [blame]187{
Conrad Irwin55c4a672011-08-20 21:49:48[diff] [blame]188 if (strbuf_check_branch_ref(ref, name))
Jiang Xinbc554df2013-04-16 03:37:50[diff] [blame]189 die(_("'%s' is not a valid branch name."), name);
Conrad Irwin55c4a672011-08-20 21:49:48[diff] [blame]190
Junio C Hamanobc1c9c02017-10-13 04:45:40[diff] [blame]191 return ref_exists(ref->buf);
192}
Conrad Irwin55c4a672011-08-20 21:49:48[diff] [blame]193
Junio C Hamanobc1c9c02017-10-13 04:45:40[diff] [blame]194/*
195 * Check if a branch 'name' can be created as a new branch; die otherwise.
196 * 'force' can be used when it is OK for the named branch already exists.
197 * Return 1 if the named branch already exists; return 0 otherwise.
198 * Fill ref with the full refname for the branch.
199 */
200int validate_new_branchname(const char *name, struct strbuf *ref, int force)
201{
202 const char *head;
203
204 if (!validate_branchname(name, ref))
Conrad Irwin55c4a672011-08-20 21:49:48[diff] [blame]205 return 0;
Conrad Irwin55c4a672011-08-20 21:49:48[diff] [blame]206
Junio C Hamano8280c4c2017-10-13 03:57:02[diff] [blame]207 if (!force)
208 die(_("A branch named '%s' already exists."),
209 ref->buf + strlen("refs/heads/"));
Conrad Irwin55c4a672011-08-20 21:49:48[diff] [blame]210
Junio C Hamano8280c4c2017-10-13 03:57:02[diff] [blame]211 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
212 if (!is_bare_repository() && head && !strcmp(head, ref->buf))
213 die(_("Cannot force update the current branch."));
214
Conrad Irwin55c4a672011-08-20 21:49:48[diff] [blame]215 return 1;
216}
217
Johan Herland41c21f22013-04-21 21:52:05[diff] [blame]218static int check_tracking_branch(struct remote *remote, void *cb_data)
219{
220 char *tracking_branch = cb_data;
Brandon Williams0ad4a5f2018-05-16 22:57:49[diff] [blame]221 struct refspec_item query;
222 memset(&query, 0, sizeof(struct refspec_item));
Johan Herland41c21f22013-04-21 21:52:05[diff] [blame]223 query.dst = tracking_branch;
Per Cederqvist1d7358c2013-09-08 20:58:15[diff] [blame]224 return !remote_find_tracking(remote, &query);
Johan Herland41c21f22013-04-21 21:52:05[diff] [blame]225}
226
227static int validate_remote_tracking_branch(char *ref)
228{
229 return !for_each_remote(check_tracking_branch, ref);
230}
231
Jeff Kinge2b6aa52013-04-02 19:03:55[diff] [blame]232static const char upstream_not_branch[] =
Jeff King1a15d002013-04-02 19:04:51[diff] [blame]233N_("Cannot setup tracking information; starting point '%s' is not a branch.");
Jeff Kinga5e91c72013-04-02 19:04:27[diff] [blame]234static const char upstream_missing[] =
Jeff Kingcaa20362013-04-02 19:05:12[diff] [blame]235N_("the requested upstream branch '%s' does not exist");
236static const char upstream_advice[] =
237N_("\n"
238"If you are planning on basing your work on an upstream\n"
239"branch that already exists at the remote, you may need to\n"
240"run \"git fetch\" to retrieve it.\n"
241"\n"
242"If you are planning to push out a new local branch that\n"
243"will track its remote counterpart, you may want to use\n"
244"\"git push -u\" to set the upstream config as you push.");
Jeff Kinge2b6aa52013-04-02 19:03:55[diff] [blame]245
Nguyễn Thái Ngọc Duy4edce172018-11-10 05:49:00[diff] [blame]246void create_branch(struct repository *r,
247 const char *name, const char *start_name,
Kaartic Sivaraame2bbd0c2017-11-18 17:26:46[diff] [blame]248 int force, int clobber_head_ok, int reflog,
Jeff Kingf9a482e2012-03-26 23:51:01[diff] [blame]249 int quiet, enum branch_track track)
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]250{
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]251 struct commit *commit;
brian m. carlson48713bf2017-05-01 02:29:00[diff] [blame]252 struct object_id oid;
Jeff King3818b252017-03-28 19:46:36[diff] [blame]253 char *real_ref;
Junio C Hamano8415d5c2009-02-14 07:08:05[diff] [blame]254 struct strbuf ref = STRBUF_INIT;
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]255 int forcing = 0;
Ilari Liusvaara4fc50062010-01-18 20:44:11[diff] [blame]256 int dont_change_ref = 0;
257 int explicit_tracking = 0;
258
259 if (track == BRANCH_TRACK_EXPLICIT || track == BRANCH_TRACK_OVERRIDE)
260 explicit_tracking = 1;
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]261
Junio C Hamano0faff982017-12-27 19:16:25[diff] [blame]262 if ((track == BRANCH_TRACK_OVERRIDE || clobber_head_ok)
Junio C Hamanobc1c9c02017-10-13 04:45:40[diff] [blame]263 ? validate_branchname(name, &ref)
264 : validate_new_branchname(name, &ref, force)) {
Conrad Irwin55c4a672011-08-20 21:49:48[diff] [blame]265 if (!force)
Ilari Liusvaara4fc50062010-01-18 20:44:11[diff] [blame]266 dont_change_ref = 1;
Conrad Irwin55c4a672011-08-20 21:49:48[diff] [blame]267 else
268 forcing = 1;
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]269 }
270
271 real_ref = NULL;
Denton Liue3d65392019-04-27 12:02:22[diff] [blame]272 if (get_oid_mb(start_name, &oid)) {
Jeff Kingcaa20362013-04-02 19:05:12[diff] [blame]273 if (explicit_tracking) {
274 if (advice_set_upstream_failure) {
275 error(_(upstream_missing), start_name);
276 advise(_(upstream_advice));
277 exit(1);
278 }
Jeff King1a15d002013-04-02 19:04:51[diff] [blame]279 die(_(upstream_missing), start_name);
Jeff Kingcaa20362013-04-02 19:05:12[diff] [blame]280 }
Jiang Xinbc554df2013-04-16 03:37:50[diff] [blame]281 die(_("Not a valid object name: '%s'."), start_name);
Jeff Kinga5e91c72013-04-02 19:04:27[diff] [blame]282 }
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]283
Jonathan Tanf24c30e2020-09-01 22:28:09[diff] [blame]284 switch (dwim_ref(start_name, strlen(start_name), &oid, &real_ref, 0)) {
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]285 case 0:
286 /* Not branching from any existing branch */
Ilari Liusvaara4fc50062010-01-18 20:44:11[diff] [blame]287 if (explicit_tracking)
Jeff King1a15d002013-04-02 19:04:51[diff] [blame]288 die(_(upstream_not_branch), start_name);
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]289 break;
290 case 1:
Johan Herland21b5b1e2011-02-16 23:12:20[diff] [blame]291 /* Unique completion -- good, only if it is a real branch */
Christian Couder59556542013-11-30 20:55:40[diff] [blame]292 if (!starts_with(real_ref, "refs/heads/") &&
Johan Herland41c21f22013-04-21 21:52:05[diff] [blame]293 validate_remote_tracking_branch(real_ref)) {
Johan Herland21b5b1e2011-02-16 23:12:20[diff] [blame]294 if (explicit_tracking)
Jeff King1a15d002013-04-02 19:04:51[diff] [blame]295 die(_(upstream_not_branch), start_name);
Johan Herland21b5b1e2011-02-16 23:12:20[diff] [blame]296 else
297 real_ref = NULL;
298 }
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]299 break;
300 default:
Jiang Xinbc554df2013-04-16 03:37:50[diff] [blame]301 die(_("Ambiguous object name: '%s'."), start_name);
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]302 break;
303 }
304
Nguyễn Thái Ngọc Duy4edce172018-11-10 05:49:00[diff] [blame]305 if ((commit = lookup_commit_reference(r, &oid)) == NULL)
Jiang Xinbc554df2013-04-16 03:37:50[diff] [blame]306 die(_("Not a valid branch point: '%s'."), start_name);
brian m. carlson48713bf2017-05-01 02:29:00[diff] [blame]307 oidcpy(&oid, &commit->object.oid);
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]308
Ronnie Sahlbergd43f9902014-04-16 23:21:53[diff] [blame]309 if (reflog)
Cornelius Weig341fb282017-01-27 10:09:47[diff] [blame]310 log_all_ref_updates = LOG_REFS_NORMAL;
Ronnie Sahlbergd43f9902014-04-16 23:21:53[diff] [blame]311
312 if (!dont_change_ref) {
313 struct ref_transaction *transaction;
314 struct strbuf err = STRBUF_INIT;
Jeff Kingcddac452017-03-28 19:46:40[diff] [blame]315 char *msg;
Jeff King3818b252017-03-28 19:46:36[diff] [blame]316
317 if (forcing)
Jeff Kingcddac452017-03-28 19:46:40[diff] [blame]318 msg = xstrfmt("branch: Reset to %s", start_name);
Jeff King3818b252017-03-28 19:46:36[diff] [blame]319 else
Jeff Kingcddac452017-03-28 19:46:40[diff] [blame]320 msg = xstrfmt("branch: Created from %s", start_name);
Ronnie Sahlbergd43f9902014-04-16 23:21:53[diff] [blame]321
322 transaction = ref_transaction_begin(&err);
323 if (!transaction ||
Michael Haggerty1d147bd2015-02-17 17:00:15[diff] [blame]324 ref_transaction_update(transaction, ref.buf,
brian m. carlson89f3bbd2017-10-15 22:06:53[diff] [blame]325 &oid, forcing ? NULL : &null_oid,
Michael Haggerty1d147bd2015-02-17 17:00:15[diff] [blame]326 0, msg, &err) ||
Ronnie Sahlbergdb7516a2014-04-30 19:22:42[diff] [blame]327 ref_transaction_commit(transaction, &err))
Ronnie Sahlbergd43f9902014-04-16 23:21:53[diff] [blame]328 die("%s", err.buf);
329 ref_transaction_free(transaction);
330 strbuf_release(&err);
Jeff Kingcddac452017-03-28 19:46:40[diff] [blame]331 free(msg);
Ronnie Sahlbergd43f9902014-04-16 23:21:53[diff] [blame]332 }
333
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]334 if (real_ref && track)
Felipe Contreras82a06722013-08-30 21:56:46[diff] [blame]335 setup_tracking(ref.buf + 11, real_ref, track, quiet);
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]336
Junio C Hamano8415d5c2009-02-14 07:08:05[diff] [blame]337 strbuf_release(&ref);
Jay Soffian9ed36cf2008-02-19 16:24:37[diff] [blame]338 free(real_ref);
Daniel Barkalowe496c002008-02-07 16:40:08[diff] [blame]339}
Daniel Barkalowc369e7b2008-02-07 16:40:16[diff] [blame]340
Nguyễn Thái Ngọc Duyb6433552019-05-09 10:10:27[diff] [blame]341void remove_merge_branch_state(struct repository *r)
Daniel Barkalowc369e7b2008-02-07 16:40:16[diff] [blame]342{
Nguyễn Thái Ngọc Duy4edce172018-11-10 05:49:00[diff] [blame]343 unlink(git_path_merge_head(r));
344 unlink(git_path_merge_rr(r));
345 unlink(git_path_merge_msg(r));
346 unlink(git_path_merge_mode(r));
Denton Liua03b5552020-04-07 14:28:07[diff] [blame]347 save_autostash(git_path_merge_autostash(r));
Nguyễn Thái Ngọc Duyb6433552019-05-09 10:10:27[diff] [blame]348}
349
Junio C Hamanof496b062019-07-09 22:25:44[diff] [blame]350void remove_branch_state(struct repository *r, int verbose)
Nguyễn Thái Ngọc Duyb6433552019-05-09 10:10:27[diff] [blame]351{
Junio C Hamanof496b062019-07-09 22:25:44[diff] [blame]352 sequencer_post_commit_cleanup(r, verbose);
Nguyễn Thái Ngọc Duy4edce172018-11-10 05:49:00[diff] [blame]353 unlink(git_path_squash_msg(r));
Nguyễn Thái Ngọc Duyb6433552019-05-09 10:10:27[diff] [blame]354 remove_merge_branch_state(r);
Daniel Barkalowc369e7b2008-02-07 16:40:16[diff] [blame]355}
Eric Sunshineed89f842015-07-17 23:00:04[diff] [blame]356
Nguyễn Thái Ngọc Duy8d9fdd72016-04-22 13:01:33[diff] [blame]357void die_if_checked_out(const char *branch, int ignore_current_worktree)
David Turner41af6562015-08-10 17:52:44[diff] [blame]358{
Nguyễn Thái Ngọc Duyd3b9ac02016-04-22 13:01:27[diff] [blame]359 const struct worktree *wt;
David Turner41af6562015-08-10 17:52:44[diff] [blame]360
Nguyễn Thái Ngọc Duyd3b9ac02016-04-22 13:01:27[diff] [blame]361 wt = find_shared_symref("HEAD", branch);
Nguyễn Thái Ngọc Duy8d9fdd72016-04-22 13:01:33[diff] [blame]362 if (!wt || (ignore_current_worktree && wt->is_current))
Nguyễn Thái Ngọc Duyd3b9ac02016-04-22 13:01:27[diff] [blame]363 return;
364 skip_prefix(branch, "refs/heads/", &branch);
365 die(_("'%s' is already checked out at '%s'"),
366 branch, wt->path);
Eric Sunshineed89f842015-07-17 23:00:04[diff] [blame]367}
Kazuki Yamaguchi70999e92016-03-27 14:37:14[diff] [blame]368
Kyle Meyer39ee4c62017-02-21 01:10:35[diff] [blame]369int replace_each_worktree_head_symref(const char *oldref, const char *newref,
370 const char *logmsg)
Kazuki Yamaguchi70999e92016-03-27 14:37:14[diff] [blame]371{
372 int ret = 0;
Eric Sunshine03f24652020-06-19 23:35:44[diff] [blame]373 struct worktree **worktrees = get_worktrees();
Kazuki Yamaguchi70999e92016-03-27 14:37:14[diff] [blame]374 int i;
375
376 for (i = 0; worktrees[i]; i++) {
Nguyễn Thái Ngọc Duyd026a252017-04-24 10:01:24[diff] [blame]377 struct ref_store *refs;
378
Kazuki Yamaguchi70999e92016-03-27 14:37:14[diff] [blame]379 if (worktrees[i]->is_detached)
380 continue;
Nguyễn Thái Ngọc Duy31824d12017-08-24 10:41:24[diff] [blame]381 if (!worktrees[i]->head_ref)
382 continue;
383 if (strcmp(oldref, worktrees[i]->head_ref))
Kazuki Yamaguchi70999e92016-03-27 14:37:14[diff] [blame]384 continue;
385
Nguyễn Thái Ngọc Duyd026a252017-04-24 10:01:24[diff] [blame]386 refs = get_worktree_ref_store(worktrees[i]);
387 if (refs_create_symref(refs, "HEAD", newref, logmsg))
388 ret = error(_("HEAD of working tree %s is not updated"),
389 worktrees[i]->path);
Kazuki Yamaguchi70999e92016-03-27 14:37:14[diff] [blame]390 }
391
392 free_worktrees(worktrees);
393 return ret;
394}