blob: 7c20e049a23abf3418f8e85fdc7662e78fcee7ab [file] [log] [blame]
Lars Hjemlic31820c2006-10-23 23:27:45 +02001/*
2 * Builtin "git branch"
3 *
Junio C Hamanod972cce2007-07-11 22:52:45 -07004 * Copyright (c) 2006 Kristian Høgsberg <krh@redhat.com>
Lars Hjemlic31820c2006-10-23 23:27:45 +02005 * Based on git-branch.sh by Junio C Hamano.
6 */
7
8#include "cache.h"
Brandon Williamsb2141fc2017-06-14 11:07:36 -07009#include "config.h"
Junio C Hamano85023572006-12-19 14:34:12 -080010#include "color.h"
Elijah Newren4e120822023-04-11 00:41:57 -070011#include "editor.h"
Elijah Newren7ee24e12023-03-21 06:25:57 +000012#include "environment.h"
Lars Hjemlic31820c2006-10-23 23:27:45 +020013#include "refs.h"
14#include "commit.h"
15#include "builtin.h"
Elijah Newrenf394e092023-03-21 06:25:54 +000016#include "gettext.h"
Elijah Newrendabab1d2023-04-11 00:41:49 -070017#include "object-name.h"
Johannes Schindelin6f084a52007-07-10 18:50:44 +010018#include "remote.h"
Pierre Habouzita8dfd5e2007-10-07 18:26:21 +020019#include "parse-options.h"
Daniel Barkalowe496c002008-02-07 11:40:08 -050020#include "branch.h"
Junio C Hamano68067ca2008-07-23 15:13:41 -070021#include "diff.h"
22#include "revision.h"
Nguyễn Thái Ngọc Duyebe31ef2012-04-13 17:54:38 +070023#include "string-list.h"
24#include "column.h"
Nguyễn Thái Ngọc Duy1452bd62012-08-26 01:17:12 +070025#include "utf8.h"
Nguyễn Thái Ngọc Duyc8183cd2013-03-13 18:42:53 +070026#include "wt-status.h"
Karthik Nayak1511b222015-09-23 23:41:11 +053027#include "ref-filter.h"
Kazuki Yamaguchif2922442016-03-29 18:38:39 +090028#include "worktree.h"
Nguyễn Thái Ngọc Duy3ac68a92018-05-26 15:55:24 +020029#include "help.h"
Derrick Stolee64043552018-07-20 16:33:04 +000030#include "commit-reach.h"
Elijah Newrend5ebb502023-03-21 06:26:01 +000031#include "wrapper.h"
Lars Hjemlic31820c2006-10-23 23:27:45 +020032
Pierre Habouzita8dfd5e2007-10-07 18:26:21 +020033static const char * const builtin_branch_usage[] = {
Aaron Lipman21bf9332020-09-15 22:08:40 -040034 N_("git branch [<options>] [-r | -a] [--merged] [--no-merged]"),
Glen Choo961b1302022-01-28 16:04:45 -080035 N_("git branch [<options>] [-f] [--recurse-submodules] <branch-name> [<start-point>]"),
36 N_("git branch [<options>] [-l] [<pattern>...]"),
Alex Henrie9c9b4f22015-01-13 00:44:47 -070037 N_("git branch [<options>] [-r] (-d | -D) <branch-name>..."),
38 N_("git branch [<options>] (-m | -M) [<old-branch>] <new-branch>"),
Sahil Dua52d59cc2017-06-18 23:19:16 +020039 N_("git branch [<options>] (-c | -C) [<old-branch>] <new-branch>"),
Karthik Nayakaa3bc552015-09-23 23:41:13 +053040 N_("git branch [<options>] [-r | -a] [--points-at]"),
Karthik Nayak3d9e4ce2017-01-10 14:19:53 +053041 N_("git branch [<options>] [-r | -a] [--format]"),
Pierre Habouzita8dfd5e2007-10-07 18:26:21 +020042 NULL
43};
Lars Hjemlic31820c2006-10-23 23:27:45 +020044
Lars Hjemlic31820c2006-10-23 23:27:45 +020045static const char *head;
brian m. carlson0c77cd22017-02-21 23:47:26 +000046static struct object_id head_oid;
Glen Choo961b1302022-01-28 16:04:45 -080047static int recurse_submodules = 0;
48static int submodule_propagate_branches = 0;
Øystein Walleaabfdc92023-04-07 19:53:16 +020049static int omit_empty = 0;
Lars Hjemlic31820c2006-10-23 23:27:45 +020050
Matthias Kestenholz6b2f2d92008-02-18 08:26:03 +010051static int branch_use_color = -1;
Andy Parkinsa1158ca2006-12-12 06:41:52 +000052static char branch_colors[][COLOR_MAXLEN] = {
Arjen Laarhovendc6ebd42009-02-13 22:53:40 +010053 GIT_COLOR_RESET,
Karthik Nayak949af062017-01-10 14:19:52 +053054 GIT_COLOR_NORMAL, /* PLAIN */
55 GIT_COLOR_RED, /* REMOTE */
56 GIT_COLOR_NORMAL, /* LOCAL */
57 GIT_COLOR_GREEN, /* CURRENT */
58 GIT_COLOR_BLUE, /* UPSTREAM */
Nickolai Belakovskiab313812019-04-28 22:19:43 -070059 GIT_COLOR_CYAN, /* WORKTREE */
Andy Parkinsa1158ca2006-12-12 06:41:52 +000060};
61enum color_branch {
Arjen Laarhoven74bb2df2009-02-13 22:53:41 +010062 BRANCH_COLOR_RESET = 0,
63 BRANCH_COLOR_PLAIN = 1,
64 BRANCH_COLOR_REMOTE = 2,
65 BRANCH_COLOR_LOCAL = 3,
Felipe Contrerasdbda21f2013-04-14 21:37:49 -050066 BRANCH_COLOR_CURRENT = 4,
Nickolai Belakovskiab313812019-04-28 22:19:43 -070067 BRANCH_COLOR_UPSTREAM = 5,
68 BRANCH_COLOR_WORKTREE = 6
Andy Parkinsa1158ca2006-12-12 06:41:52 +000069};
70
Nguyễn Thái Ngọc Duya73b3682018-05-26 15:55:21 +020071static const char *color_branch_slots[] = {
72 [BRANCH_COLOR_RESET] = "reset",
73 [BRANCH_COLOR_PLAIN] = "plain",
74 [BRANCH_COLOR_REMOTE] = "remote",
75 [BRANCH_COLOR_LOCAL] = "local",
76 [BRANCH_COLOR_CURRENT] = "current",
77 [BRANCH_COLOR_UPSTREAM] = "upstream",
Nickolai Belakovskiab313812019-04-28 22:19:43 -070078 [BRANCH_COLOR_WORKTREE] = "worktree",
Nguyễn Thái Ngọc Duya73b3682018-05-26 15:55:21 +020079};
80
Nguyễn Thái Ngọc Duyebe31ef2012-04-13 17:54:38 +070081static struct string_list output = STRING_LIST_INIT_DUP;
82static unsigned int colopts;
83
Nguyễn Thái Ngọc Duy3ac68a92018-05-26 15:55:24 +020084define_list_config_array(color_branch_slots);
Andy Parkinsa1158ca2006-12-12 06:41:52 +000085
Johannes Schindelinef90d6d2008-05-14 18:46:53 +010086static int git_branch_config(const char *var, const char *value, void *cb)
Andy Parkinsa1158ca2006-12-12 06:41:52 +000087{
René Scharfee3f1da92014-10-04 20:54:50 +020088 const char *slot_name;
Samuel Maftoul560ae1c2018-08-16 11:35:08 +020089
90 if (!strcmp(var, "branch.sort")) {
91 if (!value)
92 return config_error_nonbool(var);
Junio C Hamano98e7ab62021-10-20 12:23:53 -070093 string_list_append(cb, value);
Samuel Maftoul560ae1c2018-08-16 11:35:08 +020094 return 0;
95 }
René Scharfee3f1da92014-10-04 20:54:50 +020096
Christian Couder59556542013-11-30 21:55:40 +010097 if (starts_with(var, "column."))
Nguyễn Thái Ngọc Duyebe31ef2012-04-13 17:54:38 +070098 return git_column_config(var, value, "branch", &colopts);
Andy Parkinsa1158ca2006-12-12 06:41:52 +000099 if (!strcmp(var, "color.branch")) {
Jeff Kinge269eb72011-08-17 22:03:48 -0700100 branch_use_color = git_config_colorbool(var, value);
Andy Parkinsa1158ca2006-12-12 06:41:52 +0000101 return 0;
102 }
René Scharfee3f1da92014-10-04 20:54:50 +0200103 if (skip_prefix(var, "color.branch.", &slot_name)) {
Nguyễn Thái Ngọc Duya73b3682018-05-26 15:55:21 +0200104 int slot = LOOKUP_CONFIG(color_branch_slots, slot_name);
Jeff King8b8e8622009-12-12 07:25:24 -0500105 if (slot < 0)
106 return 0;
Junio C Hamano5768c982008-02-11 10:45:50 -0800107 if (!value)
108 return config_error_nonbool(var);
Jeff Kingf6c5a292014-10-07 15:33:09 -0400109 return color_parse(value, branch_colors[slot]);
Andy Parkinsa1158ca2006-12-12 06:41:52 +0000110 }
Glen Choo961b1302022-01-28 16:04:45 -0800111 if (!strcmp(var, "submodule.recurse")) {
112 recurse_submodules = git_config_bool(var, value);
113 return 0;
114 }
115 if (!strcasecmp(var, "submodule.propagateBranches")) {
116 submodule_propagate_branches = git_config_bool(var, value);
117 return 0;
118 }
119
Jeff King33c643b2017-10-13 13:24:31 -0400120 return git_color_default_config(var, value, cb);
Andy Parkinsa1158ca2006-12-12 06:41:52 +0000121}
122
Pierre Habouzit52fae7d2007-06-07 22:45:00 +0200123static const char *branch_get_color(enum color_branch ix)
Andy Parkinsa1158ca2006-12-12 06:41:52 +0000124{
Jeff Kingdaa0c3d2011-08-17 22:04:23 -0700125 if (want_color(branch_use_color))
Andy Parkinsa1158ca2006-12-12 06:41:52 +0000126 return branch_colors[ix];
127 return "";
128}
129
Junio C Hamano99c419c2009-12-29 22:43:04 -0800130static int branch_merged(int kind, const char *name,
131 struct commit *rev, struct commit *head_rev)
132{
133 /*
134 * This checks whether the merge bases of branch and HEAD (or
135 * the other branch this branch builds upon) contains the
136 * branch, which means that the branch has already been merged
137 * safely to HEAD (or the other branch).
138 */
139 struct commit *reference_rev = NULL;
140 const char *reference_name = NULL;
Nguyễn Thái Ngọc Duy96ec7b12011-12-13 21:17:48 +0700141 void *reference_name_to_free = NULL;
Junio C Hamano99c419c2009-12-29 22:43:04 -0800142 int merged;
143
Karthik Nayak1511b222015-09-23 23:41:11 +0530144 if (kind == FILTER_REFS_BRANCHES) {
Junio C Hamano99c419c2009-12-29 22:43:04 -0800145 struct branch *branch = branch_get(name);
Jeff King3a429d02015-05-21 00:45:32 -0400146 const char *upstream = branch_get_upstream(branch, NULL);
brian m. carlson0c77cd22017-02-21 23:47:26 +0000147 struct object_id oid;
Junio C Hamano99c419c2009-12-29 22:43:04 -0800148
Jeff Kinga9f9f8c2015-05-21 00:45:28 -0400149 if (upstream &&
Nguyễn Thái Ngọc Duy96ec7b12011-12-13 21:17:48 +0700150 (reference_name = reference_name_to_free =
Jeff Kinga9f9f8c2015-05-21 00:45:28 -0400151 resolve_refdup(upstream, RESOLVE_REF_READING,
brian m. carlson0f2dc722017-10-15 22:06:55 +0000152 &oid, NULL)) != NULL)
Stefan Beller2122f672018-06-28 18:21:58 -0700153 reference_rev = lookup_commit_reference(the_repository,
154 &oid);
Junio C Hamano99c419c2009-12-29 22:43:04 -0800155 }
156 if (!reference_rev)
157 reference_rev = head_rev;
158
Ævar Arnfjörð Bjarmasoncb338c22023-03-28 15:58:47 +0200159 merged = reference_rev ? repo_in_merge_bases(the_repository, rev,
160 reference_rev) : 0;
Junio C Hamano99c419c2009-12-29 22:43:04 -0800161
162 /*
163 * After the safety valve is fully redefined to "check with
164 * upstream, if any, otherwise with HEAD", we should just
Ævar Arnfjörð Bjarmasonc7c33f52023-03-28 15:58:57 +0200165 * return the result of the repo_in_merge_bases() above without
Junio C Hamano99c419c2009-12-29 22:43:04 -0800166 * any of the following code, but during the transition period,
167 * a gentle reminder is in order.
168 */
169 if ((head_rev != reference_rev) &&
Ævar Arnfjörð Bjarmasoncb338c22023-03-28 15:58:47 +0200170 (head_rev ? repo_in_merge_bases(the_repository, rev, head_rev) : 0) != merged) {
Junio C Hamano99c419c2009-12-29 22:43:04 -0800171 if (merged)
Ævar Arnfjörð Bjarmason49df4b02011-02-22 23:41:34 +0000172 warning(_("deleting branch '%s' that has been merged to\n"
Junio C Hamano6c80cd22011-04-01 17:55:55 -0700173 " '%s', but not yet merged to HEAD."),
Junio C Hamano99c419c2009-12-29 22:43:04 -0800174 name, reference_name);
175 else
Ævar Arnfjörð Bjarmason49df4b02011-02-22 23:41:34 +0000176 warning(_("not deleting branch '%s' that is not yet merged to\n"
177 " '%s', even though it is merged to HEAD."),
Junio C Hamano99c419c2009-12-29 22:43:04 -0800178 name, reference_name);
179 }
Nguyễn Thái Ngọc Duy96ec7b12011-12-13 21:17:48 +0700180 free(reference_name_to_free);
Junio C Hamano99c419c2009-12-29 22:43:04 -0800181 return merged;
182}
183
René Scharfef5d0e162012-10-18 14:02:51 +0200184static int check_branch_commit(const char *branchname, const char *refname,
brian m. carlson0c77cd22017-02-21 23:47:26 +0000185 const struct object_id *oid, struct commit *head_rev,
René Scharfef5d0e162012-10-18 14:02:51 +0200186 int kinds, int force)
187{
Stefan Beller2122f672018-06-28 18:21:58 -0700188 struct commit *rev = lookup_commit_reference(the_repository, oid);
René Scharfe597a9772021-08-27 20:35:35 +0200189 if (!force && !rev) {
René Scharfef5d0e162012-10-18 14:02:51 +0200190 error(_("Couldn't look up commit object for '%s'"), refname);
191 return -1;
192 }
193 if (!force && !branch_merged(kinds, branchname, rev, head_rev)) {
194 error(_("The branch '%s' is not fully merged.\n"
195 "If you are sure you want to delete it, "
196 "run 'git branch -D %s'."), branchname, branchname);
197 return -1;
198 }
199 return 0;
200}
201
René Scharfe22ed7922012-10-18 14:04:08 +0200202static void delete_branch_config(const char *branchname)
203{
204 struct strbuf buf = STRBUF_INIT;
205 strbuf_addf(&buf, "branch.%s", branchname);
206 if (git_config_rename_section(buf.buf, NULL) < 0)
207 warning(_("Update of config-file failed"));
208 strbuf_release(&buf);
209}
210
Jeff Kingd65ddf12012-03-26 19:51:06 -0400211static int delete_branches(int argc, const char **argv, int force, int kinds,
212 int quiet)
Lars Hjemlic31820c2006-10-23 23:27:45 +0200213{
René Scharfef5d0e162012-10-18 14:02:51 +0200214 struct commit *head_rev = NULL;
brian m. carlson0c77cd22017-02-21 23:47:26 +0000215 struct object_id oid;
Quy Tonthatb8e9a002006-12-19 09:42:16 +1100216 char *name = NULL;
Ævar Arnfjörð Bjarmasonc1798372012-04-30 15:33:12 +0000217 const char *fmt;
Lars Hjemlic31820c2006-10-23 23:27:45 +0200218 int i;
Quy Tonthatb8e9a002006-12-19 09:42:16 +1100219 int ret = 0;
Ævar Arnfjörð Bjarmasonc1798372012-04-30 15:33:12 +0000220 int remote_branch = 0;
Junio C Hamano8415d5c2009-02-13 23:08:05 -0800221 struct strbuf bname = STRBUF_INIT;
Jeff King6b145e02017-03-02 03:23:10 -0500222 unsigned allowed_interpret;
Phil Hord81989072021-01-20 19:23:32 -0800223 struct string_list refs_to_delete = STRING_LIST_INIT_DUP;
224 struct string_list_item *item;
225 int branch_name_pos;
Clement Mabileau4c643fb2023-04-05 11:43:20 +0000226 const char *fmt_remotes = "refs/remotes/%s";
Lars Hjemlic31820c2006-10-23 23:27:45 +0200227
Junio C Hamanof3d985c2006-12-17 23:58:16 -0800228 switch (kinds) {
Karthik Nayak1511b222015-09-23 23:41:11 +0530229 case FILTER_REFS_REMOTES:
Clement Mabileau4c643fb2023-04-05 11:43:20 +0000230 fmt = fmt_remotes;
Ævar Arnfjörð Bjarmasonc1798372012-04-30 15:33:12 +0000231 /* For subsequent UI messages */
232 remote_branch = 1;
Jeff King6b145e02017-03-02 03:23:10 -0500233 allowed_interpret = INTERPRET_BRANCH_REMOTE;
Ævar Arnfjörð Bjarmasonc1798372012-04-30 15:33:12 +0000234
Junio C Hamanof3d985c2006-12-17 23:58:16 -0800235 force = 1;
236 break;
Karthik Nayak1511b222015-09-23 23:41:11 +0530237 case FILTER_REFS_BRANCHES:
Junio C Hamanof3d985c2006-12-17 23:58:16 -0800238 fmt = "refs/heads/%s";
Jeff King6b145e02017-03-02 03:23:10 -0500239 allowed_interpret = INTERPRET_BRANCH_LOCAL;
Junio C Hamanof3d985c2006-12-17 23:58:16 -0800240 break;
241 default:
Ævar Arnfjörð Bjarmason49df4b02011-02-22 23:41:34 +0000242 die(_("cannot use -a with -d"));
Junio C Hamanof3d985c2006-12-17 23:58:16 -0800243 }
Phil Hord81989072021-01-20 19:23:32 -0800244 branch_name_pos = strcspn(fmt, "%");
Lars Hjemlic31820c2006-10-23 23:27:45 +0200245
Jeff Kingeb20e632022-11-02 01:27:49 -0400246 if (!force)
Stefan Beller2122f672018-06-28 18:21:58 -0700247 head_rev = lookup_commit_reference(the_repository, &head_oid);
Anders Kaseorgc8dd4912021-12-01 14:15:43 -0800248
Stefan Bellera9155c52017-10-03 15:17:40 -0700249 for (i = 0; i < argc; i++, strbuf_reset(&bname)) {
Michael Haggerty8bb04552016-04-25 10:42:19 +0200250 char *target = NULL;
René Scharfe0fe700e2012-10-18 14:07:11 +0200251 int flags = 0;
252
Jeff King6b145e02017-03-02 03:23:10 -0500253 strbuf_branchname(&bname, argv[i], allowed_interpret);
Kazuki Yamaguchif2922442016-03-29 18:38:39 +0900254 free(name);
255 name = mkpathdup(fmt, bname.buf);
256
257 if (kinds == FILTER_REFS_BRANCHES) {
Derrick Stoleeb489b9d2022-06-14 19:27:32 +0000258 const char *path;
259 if ((path = branch_checked_out(name))) {
Kazuki Yamaguchif2922442016-03-29 18:38:39 +0900260 error(_("Cannot delete branch '%s' "
261 "checked out at '%s'"),
Derrick Stoleeb489b9d2022-06-14 19:27:32 +0000262 bname.buf, path);
Kazuki Yamaguchif2922442016-03-29 18:38:39 +0900263 ret = 1;
264 continue;
265 }
Quy Tonthatb8e9a002006-12-19 09:42:16 +1100266 }
Lars Hjemlic31820c2006-10-23 23:27:45 +0200267
Michael Haggerty8bb04552016-04-25 10:42:19 +0200268 target = resolve_refdup(name,
269 RESOLVE_REF_READING
270 | RESOLVE_REF_NO_RECURSE
271 | RESOLVE_REF_ALLOW_BAD_NAME,
brian m. carlson0f2dc722017-10-15 22:06:55 +0000272 &oid, &flags);
Ronnie Sahlberg18f29fc2014-09-11 10:34:36 -0700273 if (!target) {
Clement Mabileau4c643fb2023-04-05 11:43:20 +0000274 if (remote_branch) {
275 error(_("remote-tracking branch '%s' not found."), bname.buf);
276 } else {
277 char *virtual_name = mkpathdup(fmt_remotes, bname.buf);
278 char *virtual_target = resolve_refdup(virtual_name,
279 RESOLVE_REF_READING
280 | RESOLVE_REF_NO_RECURSE
281 | RESOLVE_REF_ALLOW_BAD_NAME,
282 &oid, &flags);
283 FREE_AND_NULL(virtual_name);
284
285 if (virtual_target)
286 error(_("branch '%s' not found.\n"
287 "Did you forget --remote?"),
288 bname.buf);
289 else
290 error(_("branch '%s' not found."), bname.buf);
291 FREE_AND_NULL(virtual_target);
292 }
Quy Tonthatb8e9a002006-12-19 09:42:16 +1100293 ret = 1;
294 continue;
295 }
Lars Hjemlic31820c2006-10-23 23:27:45 +0200296
Ronnie Sahlbergd0f810f2014-09-03 11:45:43 -0700297 if (!(flags & (REF_ISSYMREF|REF_ISBROKEN)) &&
brian m. carlson0c77cd22017-02-21 23:47:26 +0000298 check_branch_commit(bname.buf, name, &oid, head_rev, kinds,
René Scharfef5d0e162012-10-18 14:02:51 +0200299 force)) {
Quy Tonthatb8e9a002006-12-19 09:42:16 +1100300 ret = 1;
Michael Haggerty8bb04552016-04-25 10:42:19 +0200301 goto next;
Lars Hjemlic31820c2006-10-23 23:27:45 +0200302 }
303
Phil Hord81989072021-01-20 19:23:32 -0800304 item = string_list_append(&refs_to_delete, name);
305 item->util = xstrdup((flags & REF_ISBROKEN) ? "broken"
306 : (flags & REF_ISSYMREF) ? target
Ævar Arnfjörð Bjarmasond850b7a2023-03-28 15:58:46 +0200307 : repo_find_unique_abbrev(the_repository, &oid, DEFAULT_ABBREV));
Michael Haggerty8bb04552016-04-25 10:42:19 +0200308
309 next:
310 free(target);
Lars Hjemlic31820c2006-10-23 23:27:45 +0200311 }
Lars Hjemlic31820c2006-10-23 23:27:45 +0200312
Phil Hord81989072021-01-20 19:23:32 -0800313 if (delete_refs(NULL, &refs_to_delete, REF_NO_DEREF))
314 ret = 1;
315
316 for_each_string_list_item(item, &refs_to_delete) {
317 char *describe_ref = item->util;
318 char *name = item->string;
319 if (!ref_exists(name)) {
320 char *refname = name + branch_name_pos;
321 if (!quiet)
322 printf(remote_branch
323 ? _("Deleted remote-tracking branch %s (was %s).\n")
324 : _("Deleted branch %s (was %s).\n"),
325 name + branch_name_pos, describe_ref);
326
327 delete_branch_config(refname);
328 }
329 free(describe_ref);
330 }
331 string_list_clear(&refs_to_delete, 0);
332
Jim Meyering8e0f7002008-01-31 18:26:32 +0100333 free(name);
Stefan Bellera9155c52017-10-03 15:17:40 -0700334 strbuf_release(&bname);
Quy Tonthatb8e9a002006-12-19 09:42:16 +1100335
Stefan Bellera9155c52017-10-03 15:17:40 -0700336 return ret;
Lars Hjemlic31820c2006-10-23 23:27:45 +0200337}
Lars Hjemlic31820c2006-10-23 23:27:45 +0200338
Karthik Nayak1511b222015-09-23 23:41:11 +0530339static int calc_maxwidth(struct ref_array *refs, int remote_bonus)
Lars Hjemlib6f637d2008-07-26 12:27:25 +0200340{
Karthik Nayak1051e402015-09-23 23:41:06 +0530341 int i, max = 0;
Karthik Nayak1511b222015-09-23 23:41:11 +0530342 for (i = 0; i < refs->nr; i++) {
343 struct ref_array_item *it = refs->items[i];
Karthik Nayakaedcb7d2015-09-23 23:41:12 +0530344 const char *desc = it->refname;
Karthik Nayak1051e402015-09-23 23:41:06 +0530345 int w;
346
Karthik Nayakaedcb7d2015-09-23 23:41:12 +0530347 skip_prefix(it->refname, "refs/heads/", &desc);
348 skip_prefix(it->refname, "refs/remotes/", &desc);
Karthik Nayak949af062017-01-10 14:19:52 +0530349 if (it->kind == FILTER_REFS_DETACHED_HEAD) {
350 char *head_desc = get_head_description();
351 w = utf8_strwidth(head_desc);
352 free(head_desc);
353 } else
354 w = utf8_strwidth(desc);
Karthik Nayakaedcb7d2015-09-23 23:41:12 +0530355
Karthik Nayak1511b222015-09-23 23:41:11 +0530356 if (it->kind == FILTER_REFS_REMOTES)
Karthik Nayak1051e402015-09-23 23:41:06 +0530357 w += remote_bonus;
358 if (w > max)
359 max = w;
Lars Hjemlib6f637d2008-07-26 12:27:25 +0200360 }
Karthik Nayak1051e402015-09-23 23:41:06 +0530361 return max;
Lars Hjemlib6f637d2008-07-26 12:27:25 +0200362}
363
Karthik Nayak949af062017-01-10 14:19:52 +0530364static const char *quote_literal_for_format(const char *s)
365{
366 static struct strbuf buf = STRBUF_INIT;
367
368 strbuf_reset(&buf);
René Scharfe44ccb332023-06-17 22:41:44 +0200369 while (strbuf_expand_step(&buf, &s))
370 strbuf_addstr(&buf, "%%");
Karthik Nayak949af062017-01-10 14:19:52 +0530371 return buf.buf;
372}
373
374static char *build_format(struct ref_filter *filter, int maxwidth, const char *remote_prefix)
375{
376 struct strbuf fmt = STRBUF_INIT;
377 struct strbuf local = STRBUF_INIT;
378 struct strbuf remote = STRBUF_INIT;
379
Nickolai Belakovskiab313812019-04-28 22:19:43 -0700380 strbuf_addf(&local, "%%(if)%%(HEAD)%%(then)* %s%%(else)%%(if)%%(worktreepath)%%(then)+ %s%%(else) %s%%(end)%%(end)",
381 branch_get_color(BRANCH_COLOR_CURRENT),
382 branch_get_color(BRANCH_COLOR_WORKTREE),
383 branch_get_color(BRANCH_COLOR_LOCAL));
Jeff King7ca260a2017-07-09 06:00:45 -0400384 strbuf_addf(&remote, " %s",
385 branch_get_color(BRANCH_COLOR_REMOTE));
Karthik Nayak949af062017-01-10 14:19:52 +0530386
387 if (filter->verbose) {
Junio C Hamanoac5bbc02017-03-08 14:13:09 -0800388 struct strbuf obname = STRBUF_INIT;
389
390 if (filter->abbrev < 0)
391 strbuf_addf(&obname, "%%(objectname:short)");
392 else if (!filter->abbrev)
393 strbuf_addf(&obname, "%%(objectname)");
394 else
395 strbuf_addf(&obname, "%%(objectname:short=%d)", filter->abbrev);
396
Karthik Nayak949af062017-01-10 14:19:52 +0530397 strbuf_addf(&local, "%%(align:%d,left)%%(refname:lstrip=2)%%(end)", maxwidth);
René Scharfe72d4a9a2017-10-01 16:44:20 +0200398 strbuf_addstr(&local, branch_get_color(BRANCH_COLOR_RESET));
Junio C Hamanoac5bbc02017-03-08 14:13:09 -0800399 strbuf_addf(&local, " %s ", obname.buf);
Karthik Nayak949af062017-01-10 14:19:52 +0530400
401 if (filter->verbose > 1)
Nickolai Belakovski6e938142019-04-28 22:19:44 -0700402 {
403 strbuf_addf(&local, "%%(if:notequals=*)%%(HEAD)%%(then)%%(if)%%(worktreepath)%%(then)(%s%%(worktreepath)%s) %%(end)%%(end)",
404 branch_get_color(BRANCH_COLOR_WORKTREE), branch_get_color(BRANCH_COLOR_RESET));
Karthik Nayak949af062017-01-10 14:19:52 +0530405 strbuf_addf(&local, "%%(if)%%(upstream)%%(then)[%s%%(upstream:short)%s%%(if)%%(upstream:track)"
406 "%%(then): %%(upstream:track,nobracket)%%(end)] %%(end)%%(contents:subject)",
407 branch_get_color(BRANCH_COLOR_UPSTREAM), branch_get_color(BRANCH_COLOR_RESET));
Nickolai Belakovski6e938142019-04-28 22:19:44 -0700408 }
Karthik Nayak949af062017-01-10 14:19:52 +0530409 else
410 strbuf_addf(&local, "%%(if)%%(upstream:track)%%(then)%%(upstream:track) %%(end)%%(contents:subject)");
411
Jeff King7ca260a2017-07-09 06:00:45 -0400412 strbuf_addf(&remote, "%%(align:%d,left)%s%%(refname:lstrip=2)%%(end)%s"
Junio C Hamanoac5bbc02017-03-08 14:13:09 -0800413 "%%(if)%%(symref)%%(then) -> %%(symref:short)"
414 "%%(else) %s %%(contents:subject)%%(end)",
Jeff King7ca260a2017-07-09 06:00:45 -0400415 maxwidth, quote_literal_for_format(remote_prefix),
Junio C Hamanoac5bbc02017-03-08 14:13:09 -0800416 branch_get_color(BRANCH_COLOR_RESET), obname.buf);
417 strbuf_release(&obname);
Karthik Nayak949af062017-01-10 14:19:52 +0530418 } else {
419 strbuf_addf(&local, "%%(refname:lstrip=2)%s%%(if)%%(symref)%%(then) -> %%(symref:short)%%(end)",
420 branch_get_color(BRANCH_COLOR_RESET));
Jeff King7ca260a2017-07-09 06:00:45 -0400421 strbuf_addf(&remote, "%s%%(refname:lstrip=2)%s%%(if)%%(symref)%%(then) -> %%(symref:short)%%(end)",
422 quote_literal_for_format(remote_prefix),
Karthik Nayak949af062017-01-10 14:19:52 +0530423 branch_get_color(BRANCH_COLOR_RESET));
424 }
425
426 strbuf_addf(&fmt, "%%(if:notequals=refs/remotes)%%(refname:rstrip=-2)%%(then)%s%%(else)%s%%(end)", local.buf, remote.buf);
427
428 strbuf_release(&local);
429 strbuf_release(&remote);
430 return strbuf_detach(&fmt, NULL);
431}
432
Ævar Arnfjörð Bjarmasond72d4f92021-10-20 20:27:21 +0200433static void print_ref_list(struct ref_filter *filter, struct ref_sorting *sorting,
434 struct ref_format *format, struct string_list *output)
Lars Hjemlic31820c2006-10-23 23:27:45 +0200435{
436 int i;
Karthik Nayak1511b222015-09-23 23:41:11 +0530437 struct ref_array array;
ZheNing Hu844c3f02021-04-20 16:52:11 +0000438 struct strbuf out = STRBUF_INIT;
439 struct strbuf err = STRBUF_INIT;
Karthik Nayak1051e402015-09-23 23:41:06 +0530440 int maxwidth = 0;
441 const char *remote_prefix = "";
Karthik Nayak3d9e4ce2017-01-10 14:19:53 +0530442 char *to_free = NULL;
Lars Hjemlic31820c2006-10-23 23:27:45 +0200443
Karthik Nayak35257aa2015-07-07 21:36:12 +0530444 /*
Karthik Nayak1051e402015-09-23 23:41:06 +0530445 * If we are listing more than just remote branches,
446 * then remote branches will have a "remotes/" prefix.
447 * We need to account for this in the width.
Karthik Nayak35257aa2015-07-07 21:36:12 +0530448 */
Karthik Nayak1511b222015-09-23 23:41:11 +0530449 if (filter->kind != FILTER_REFS_REMOTES)
Karthik Nayak1051e402015-09-23 23:41:06 +0530450 remote_prefix = "remotes/";
Carlos Martín Nieto6c41e972012-02-27 16:11:53 +0100451
Karthik Nayak1511b222015-09-23 23:41:11 +0530452 memset(&array, 0, sizeof(array));
Stefan Beller81c3ce32014-08-10 23:33:26 +0200453
Jeff King17633342021-09-24 14:48:05 -0400454 filter_refs(&array, filter, filter->kind);
Jeff King8376a702014-09-18 06:49:43 -0400455
Karthik Nayak1511b222015-09-23 23:41:11 +0530456 if (filter->verbose)
457 maxwidth = calc_maxwidth(&array, strlen(remote_prefix));
Jeff King8376a702014-09-18 06:49:43 -0400458
Jeff King4a68e362017-07-13 11:01:18 -0400459 if (!format->format)
460 format->format = to_free = build_format(filter, maxwidth, remote_prefix);
Jeff King11b087a2017-07-13 11:09:32 -0400461 format->use_color = branch_use_color;
Jeff King2eda0102017-07-13 10:56:10 -0400462
463 if (verify_ref_format(format))
464 die(_("unable to parse format string"));
Karthik Nayak949af062017-01-10 14:19:52 +0530465
Derrick Stolee49abcd22023-03-20 11:26:54 +0000466 filter_ahead_behind(the_repository, format, &array);
Karthik Nayakaedcb7d2015-09-23 23:41:12 +0530467 ref_array_sort(sorting, &array);
Jeff King8376a702014-09-18 06:49:43 -0400468
Karthik Nayak949af062017-01-10 14:19:52 +0530469 for (i = 0; i < array.nr; i++) {
ZheNing Hu844c3f02021-04-20 16:52:11 +0000470 strbuf_reset(&err);
471 strbuf_reset(&out);
Olga Telezhnaya3019eca2018-03-29 12:49:45 +0000472 if (format_ref_array_item(array.items[i], format, &out, &err))
473 die("%s", err.buf);
Karthik Nayak949af062017-01-10 14:19:52 +0530474 if (column_active(colopts)) {
475 assert(!filter->verbose && "--column and --verbose are incompatible");
476 /* format to a string_list to let print_columns() do its job */
Ævar Arnfjörð Bjarmasond72d4f92021-10-20 20:27:21 +0200477 string_list_append(output, out.buf);
Karthik Nayak949af062017-01-10 14:19:52 +0530478 } else {
479 fwrite(out.buf, 1, out.len, stdout);
Øystein Walleaabfdc92023-04-07 19:53:16 +0200480 if (out.len || !omit_empty)
481 putchar('\n');
Karthik Nayak949af062017-01-10 14:19:52 +0530482 }
Karthik Nayak949af062017-01-10 14:19:52 +0530483 }
Lars Hjemlic31820c2006-10-23 23:27:45 +0200484
ZheNing Hu844c3f02021-04-20 16:52:11 +0000485 strbuf_release(&err);
486 strbuf_release(&out);
Karthik Nayak1511b222015-09-23 23:41:11 +0530487 ref_array_clear(&array);
Karthik Nayak3d9e4ce2017-01-10 14:19:53 +0530488 free(to_free);
Lars Hjemlic31820c2006-10-23 23:27:45 +0200489}
490
Daniels Umanovskis0ecb1fc2018-10-25 21:04:21 +0200491static void print_current_branch_name(void)
492{
493 int flags;
494 const char *refname = resolve_ref_unsafe("HEAD", 0, NULL, &flags);
495 const char *shortname;
496 if (!refname)
497 die(_("could not resolve HEAD"));
498 else if (!(flags & REF_ISSYMREF))
499 return;
500 else if (skip_prefix(refname, "refs/heads/", &shortname))
501 puts(shortname);
502 else
503 die(_("HEAD (%s) points outside of refs/heads/"), refname);
504}
505
Rubén Justod7f4ca62023-03-27 00:33:09 +0200506static void reject_rebase_or_bisect_branch(struct worktree **worktrees,
507 const char *target)
Nguyễn Thái Ngọc Duy14ace5b2016-04-22 20:01:36 +0700508{
Nguyễn Thái Ngọc Duy14ace5b2016-04-22 20:01:36 +0700509 int i;
510
511 for (i = 0; worktrees[i]; i++) {
512 struct worktree *wt = worktrees[i];
513
514 if (!wt->is_detached)
515 continue;
516
517 if (is_worktree_being_rebased(wt, target))
518 die(_("Branch %s is being rebased at %s"),
519 target, wt->path);
520
521 if (is_worktree_being_bisected(wt, target))
522 die(_("Branch %s is being bisected at %s"),
523 target, wt->path);
524 }
Nguyễn Thái Ngọc Duy14ace5b2016-04-22 20:01:36 +0700525}
526
Rubén Justo2e8af492023-03-27 00:33:02 +0200527/*
528 * Update all per-worktree HEADs pointing at the old ref to point the new ref.
529 * This will be used when renaming a branch. Returns 0 if successful, non-zero
530 * otherwise.
531 */
Rubén Justod7f4ca62023-03-27 00:33:09 +0200532static int replace_each_worktree_head_symref(struct worktree **worktrees,
533 const char *oldref, const char *newref,
Rubén Justo2e8af492023-03-27 00:33:02 +0200534 const char *logmsg)
535{
536 int ret = 0;
Rubén Justo2e8af492023-03-27 00:33:02 +0200537 int i;
538
539 for (i = 0; worktrees[i]; i++) {
540 struct ref_store *refs;
541
542 if (worktrees[i]->is_detached)
543 continue;
544 if (!worktrees[i]->head_ref)
545 continue;
546 if (strcmp(oldref, worktrees[i]->head_ref))
547 continue;
548
549 refs = get_worktree_ref_store(worktrees[i]);
550 if (refs_create_symref(refs, "HEAD", newref, logmsg))
551 ret = error(_("HEAD of working tree %s is not updated"),
552 worktrees[i]->path);
553 }
554
Rubén Justo2e8af492023-03-27 00:33:02 +0200555 return ret;
556}
557
Rubén Justo7a6ccdf2023-03-27 00:33:17 +0200558#define IS_HEAD 1
Rubén Justoa675ad12023-03-27 00:33:27 +0200559#define IS_ORPHAN 2
Rubén Justo7a6ccdf2023-03-27 00:33:17 +0200560
Sahil Dua52d59cc2017-06-18 23:19:16 +0200561static void copy_or_rename_branch(const char *oldname, const char *newname, int copy, int force)
Lars Hjemlic976d412006-11-28 15:47:40 +0100562{
Miklos Vajnada3f78a2008-11-17 21:48:37 +0100563 struct strbuf oldref = STRBUF_INIT, newref = STRBUF_INIT, logmsg = STRBUF_INIT;
Miklos Vajnada3f78a2008-11-17 21:48:37 +0100564 struct strbuf oldsection = STRBUF_INIT, newsection = STRBUF_INIT;
Kaartic Sivaraam255073c2017-12-01 11:29:33 +0530565 const char *interpreted_oldname = NULL;
566 const char *interpreted_newname = NULL;
Rubén Justo7a6ccdf2023-03-27 00:33:17 +0200567 int recovery = 0, oldref_usage = 0;
Rubén Justod7f4ca62023-03-27 00:33:09 +0200568 struct worktree **worktrees = get_worktrees();
Lars Hjemlic976d412006-11-28 15:47:40 +0100569
Junio C Hamanocbdffe42009-03-21 13:27:31 -0700570 if (strbuf_check_branch_ref(&oldref, oldname)) {
571 /*
572 * Bad name --- this could be an attempt to rename a
573 * ref that we used to allow to be created by accident.
574 */
Nguyễn Thái Ngọc Duyc6893322011-11-13 17:22:14 +0700575 if (ref_exists(oldref.buf))
Junio C Hamanocbdffe42009-03-21 13:27:31 -0700576 recovery = 1;
577 else
Ævar Arnfjörð Bjarmason49df4b02011-02-22 23:41:34 +0000578 die(_("Invalid branch name: '%s'"), oldname);
Junio C Hamanocbdffe42009-03-21 13:27:31 -0700579 }
Lars Hjemlic976d412006-11-28 15:47:40 +0100580
Rubén Justo7a6ccdf2023-03-27 00:33:17 +0200581 for (int i = 0; worktrees[i]; i++) {
582 struct worktree *wt = worktrees[i];
583
584 if (wt->head_ref && !strcmp(oldref.buf, wt->head_ref)) {
585 oldref_usage |= IS_HEAD;
Rubén Justoa675ad12023-03-27 00:33:27 +0200586 if (is_null_oid(&wt->head_oid))
587 oldref_usage |= IS_ORPHAN;
Rubén Justo7a6ccdf2023-03-27 00:33:17 +0200588 break;
589 }
590 }
591
592 if ((copy || !(oldref_usage & IS_HEAD)) && !ref_exists(oldref.buf)) {
593 if (oldref_usage & IS_HEAD)
Rubén Justobcfc82b2022-10-08 02:39:43 +0200594 die(_("No commit on branch '%s' yet."), oldname);
595 else
596 die(_("No branch named '%s'."), oldname);
597 }
598
Jonathan Nieder3f594812011-11-25 20:30:02 -0600599 /*
600 * A command like "git branch -M currentbranch currentbranch" cannot
601 * cause the worktree to become inconsistent with HEAD, so allow it.
602 */
Junio C Hamanobc1c9c02017-10-13 13:45:40 +0900603 if (!strcmp(oldname, newname))
604 validate_branchname(newname, &newref);
605 else
606 validate_new_branchname(newname, &newref, force);
Lars Hjemlic976d412006-11-28 15:47:40 +0100607
Rubén Justod7f4ca62023-03-27 00:33:09 +0200608 reject_rebase_or_bisect_branch(worktrees, oldref.buf);
Nguyễn Thái Ngọc Duy14ace5b2016-04-22 20:01:36 +0700609
Kaartic Sivaraam255073c2017-12-01 11:29:33 +0530610 if (!skip_prefix(oldref.buf, "refs/heads/", &interpreted_oldname) ||
611 !skip_prefix(newref.buf, "refs/heads/", &interpreted_newname)) {
Johannes Schindelin033abf92018-05-02 11:38:39 +0200612 BUG("expected prefix missing for refs");
Kaartic Sivaraam255073c2017-12-01 11:29:33 +0530613 }
614
Sahil Dua52d59cc2017-06-18 23:19:16 +0200615 if (copy)
616 strbuf_addf(&logmsg, "Branch: copied %s to %s",
617 oldref.buf, newref.buf);
618 else
619 strbuf_addf(&logmsg, "Branch: renamed %s to %s",
620 oldref.buf, newref.buf);
Lars Hjemli678d0f42006-11-30 03:16:56 +0100621
Rubén Justoa675ad12023-03-27 00:33:27 +0200622 if (!copy && !(oldref_usage & IS_ORPHAN) &&
Johannes Schindelincfaff3a2020-12-11 11:36:55 +0000623 rename_ref(oldref.buf, newref.buf, logmsg.buf))
Ævar Arnfjörð Bjarmason49df4b02011-02-22 23:41:34 +0000624 die(_("Branch rename failed"));
Sahil Dua52d59cc2017-06-18 23:19:16 +0200625 if (copy && copy_existing_ref(oldref.buf, newref.buf, logmsg.buf))
626 die(_("Branch copy failed"));
Lars Hjemlic976d412006-11-28 15:47:40 +0100627
Sahil Dua52d59cc2017-06-18 23:19:16 +0200628 if (recovery) {
629 if (copy)
Kaartic Sivaraama48ebe92017-11-18 22:56:47 +0530630 warning(_("Created a copy of a misnamed branch '%s'"),
Kaartic Sivaraam255073c2017-12-01 11:29:33 +0530631 interpreted_oldname);
Sahil Dua52d59cc2017-06-18 23:19:16 +0200632 else
633 warning(_("Renamed a misnamed branch '%s' away"),
Kaartic Sivaraam255073c2017-12-01 11:29:33 +0530634 interpreted_oldname);
Sahil Dua52d59cc2017-06-18 23:19:16 +0200635 }
Junio C Hamanocbdffe42009-03-21 13:27:31 -0700636
Rubén Justo3521c632023-03-27 00:33:40 +0200637 if (!copy && (oldref_usage & IS_HEAD) &&
Rubén Justod7f4ca62023-03-27 00:33:09 +0200638 replace_each_worktree_head_symref(worktrees, oldref.buf, newref.buf,
639 logmsg.buf))
Ævar Arnfjörð Bjarmason49df4b02011-02-22 23:41:34 +0000640 die(_("Branch renamed to %s, but HEAD is not updated!"), newname);
Lars Hjemli19eba152007-04-06 14:13:00 +0200641
Kyle Meyer39ee4c62017-02-20 20:10:35 -0500642 strbuf_release(&logmsg);
643
Kaartic Sivaraam255073c2017-12-01 11:29:33 +0530644 strbuf_addf(&oldsection, "branch.%s", interpreted_oldname);
Kaartic Sivaraam255073c2017-12-01 11:29:33 +0530645 strbuf_addf(&newsection, "branch.%s", interpreted_newname);
Sahil Dua52d59cc2017-06-18 23:19:16 +0200646 if (!copy && git_config_rename_section(oldsection.buf, newsection.buf) < 0)
Ævar Arnfjörð Bjarmason49df4b02011-02-22 23:41:34 +0000647 die(_("Branch is renamed, but update of config-file failed"));
Rubén Justocfbd1732022-11-17 02:36:52 +0100648 if (copy && strcmp(interpreted_oldname, interpreted_newname) && git_config_copy_section(oldsection.buf, newsection.buf) < 0)
Sahil Dua52d59cc2017-06-18 23:19:16 +0200649 die(_("Branch is copied, but update of config-file failed"));
Rubén Justocfbd1732022-11-17 02:36:52 +0100650 strbuf_release(&oldref);
651 strbuf_release(&newref);
Miklos Vajnada3f78a2008-11-17 21:48:37 +0100652 strbuf_release(&oldsection);
653 strbuf_release(&newsection);
Rubén Justod7f4ca62023-03-27 00:33:09 +0200654 free_worktrees(worktrees);
Lars Hjemlic976d412006-11-28 15:47:40 +0100655}
656
Jeff Kingc10388c2017-04-20 17:08:41 -0400657static GIT_PATH_FUNC(edit_description, "EDIT_DESCRIPTION")
Junio C Hamanob7200e82011-09-20 15:10:08 -0700658
659static int edit_branch_description(const char *branch_name)
660{
Junio C Hamanoe288b3d2022-09-30 11:06:22 -0700661 int exists;
Junio C Hamanob7200e82011-09-20 15:10:08 -0700662 struct strbuf buf = STRBUF_INIT;
663 struct strbuf name = STRBUF_INIT;
664
Junio C Hamanoe288b3d2022-09-30 11:06:22 -0700665 exists = !read_branch_desc(&buf, branch_name);
Junio C Hamanob7200e82011-09-20 15:10:08 -0700666 if (!buf.len || buf.buf[buf.len-1] != '\n')
667 strbuf_addch(&buf, '\n');
Junio C Hamanoeff80a92013-01-16 20:18:48 +0100668 strbuf_commented_addf(&buf,
Vasco Almeidab18237f2016-06-17 21:54:15 +0000669 _("Please edit the description for the branch\n"
670 " %s\n"
671 "Lines starting with '%c' will be stripped.\n"),
Junio C Hamanoeff80a92013-01-16 20:18:48 +0100672 branch_name, comment_line_char);
Jeff Kingc10388c2017-04-20 17:08:41 -0400673 write_file_buf(edit_description(), buf.buf, buf.len);
Junio C Hamanob7200e82011-09-20 15:10:08 -0700674 strbuf_reset(&buf);
Jeff Kingc10388c2017-04-20 17:08:41 -0400675 if (launch_editor(edit_description(), &buf, NULL)) {
Junio C Hamanob7200e82011-09-20 15:10:08 -0700676 strbuf_release(&buf);
677 return -1;
678 }
Tobias Klauser63af4a82015-10-16 17:16:42 +0200679 strbuf_stripspace(&buf, 1);
Junio C Hamanob7200e82011-09-20 15:10:08 -0700680
681 strbuf_addf(&name, "branch.%s.description", branch_name);
Junio C Hamanoe288b3d2022-09-30 11:06:22 -0700682 if (buf.len || exists)
683 git_config_set(name.buf, buf.len ? buf.buf : NULL);
Junio C Hamanob7200e82011-09-20 15:10:08 -0700684 strbuf_release(&name);
685 strbuf_release(&buf);
686
Patrick Steinhardtbd25f892016-02-22 12:23:25 +0100687 return 0;
Junio C Hamanob7200e82011-09-20 15:10:08 -0700688}
689
Lars Hjemlic31820c2006-10-23 23:27:45 +0200690int cmd_branch(int argc, const char **argv, const char *prefix)
691{
Glen Choo6e0a2ca2022-01-28 16:04:44 -0800692 /* possible actions */
693 int delete = 0, rename = 0, copy = 0, list = 0,
694 unset_upstream = 0, show_current = 0, edit_description = 0;
Carlos Martín Nieto6183d822012-08-20 15:47:38 +0200695 const char *new_upstream = NULL;
Glen Choo6e0a2ca2022-01-28 16:04:44 -0800696 int noncreate_actions = 0;
697 /* possible options */
Glen Choo961b1302022-01-28 16:04:45 -0800698 int reflog = 0, quiet = 0, icase = 0, force = 0,
699 recurse_submodules_explicit = 0;
Jay Soffian9ed36cf2008-02-19 11:24:37 -0500700 enum branch_track track;
Karthik Nayak1511b222015-09-23 23:41:11 +0530701 struct ref_filter filter;
Junio C Hamano98e7ab62021-10-20 12:23:53 -0700702 static struct ref_sorting *sorting;
703 struct string_list sorting_options = STRING_LIST_INIT_DUP;
Jeff King4a68e362017-07-13 11:01:18 -0400704 struct ref_format format = REF_FORMAT_INIT;
Pierre Habouzita8dfd5e2007-10-07 18:26:21 +0200705
706 struct option options[] = {
Nguyễn Thái Ngọc Duy24a85212012-08-20 19:31:55 +0700707 OPT_GROUP(N_("Generic options")),
Karthik Nayak1511b222015-09-23 23:41:11 +0530708 OPT__VERBOSE(&filter.verbose,
Nguyễn Thái Ngọc Duy24a85212012-08-20 19:31:55 +0700709 N_("show hash and subject, give twice for upstream branch")),
710 OPT__QUIET(&quiet, N_("suppress informational messages")),
René Scharfe6327f0e2022-01-20 13:35:54 +0100711 OPT_CALLBACK_F('t', "track", &track, "(direct|inherit)",
Josh Steadmond3115662021-12-20 19:30:23 -0800712 N_("set branch tracking configuration"),
Josh Steadmon15f00282022-01-18 12:49:46 -0800713 PARSE_OPT_OPTARG,
Josh Steadmond3115662021-12-20 19:30:23 -0800714 parse_opt_tracking_mode),
Nguyễn Thái Ngọc Duy3e4a67b2018-05-20 17:42:58 +0200715 OPT_SET_INT_F(0, "set-upstream", &track, N_("do not use"),
716 BRANCH_TRACK_OVERRIDE, PARSE_OPT_HIDDEN),
Vasco Almeidaab868852016-04-08 20:02:45 +0000717 OPT_STRING('u', "set-upstream-to", &new_upstream, N_("upstream"), N_("change the upstream info")),
Dimitriy Ryazantcev11de8dd2019-12-08 11:26:47 +0200718 OPT_BOOL(0, "unset-upstream", &unset_upstream, N_("unset the upstream info")),
Nguyễn Thái Ngọc Duy24a85212012-08-20 19:31:55 +0700719 OPT__COLOR(&branch_use_color, N_("use colored output")),
Karthik Nayak1511b222015-09-23 23:41:11 +0530720 OPT_SET_INT('r', "remotes", &filter.kind, N_("act on remote-tracking branches"),
721 FILTER_REFS_REMOTES),
722 OPT_CONTAINS(&filter.with_commit, N_("print only branches that contain the commit")),
Ævar Arnfjörð Bjarmasonac3f5a32017-03-24 18:40:57 +0000723 OPT_NO_CONTAINS(&filter.no_commit, N_("print only branches that don't contain the commit")),
Karthik Nayak1511b222015-09-23 23:41:11 +0530724 OPT_WITH(&filter.with_commit, N_("print only branches that contain the commit")),
Ævar Arnfjörð Bjarmasonac3f5a32017-03-24 18:40:57 +0000725 OPT_WITHOUT(&filter.no_commit, N_("print only branches that don't contain the commit")),
Karthik Nayak1511b222015-09-23 23:41:11 +0530726 OPT__ABBREV(&filter.abbrev),
Pierre Habouzita8dfd5e2007-10-07 18:26:21 +0200727
Nguyễn Thái Ngọc Duy24a85212012-08-20 19:31:55 +0700728 OPT_GROUP(N_("Specific git-branch actions:")),
Karthik Nayak1511b222015-09-23 23:41:11 +0530729 OPT_SET_INT('a', "all", &filter.kind, N_("list both remote-tracking and local branches"),
730 FILTER_REFS_REMOTES | FILTER_REFS_BRANCHES),
Nguyễn Thái Ngọc Duy24a85212012-08-20 19:31:55 +0700731 OPT_BIT('d', "delete", &delete, N_("delete fully merged branch"), 1),
732 OPT_BIT('D', NULL, &delete, N_("delete branch (even if not merged)"), 2),
733 OPT_BIT('m', "move", &rename, N_("move/rename a branch and its reflog"), 1),
734 OPT_BIT('M', NULL, &rename, N_("move/rename a branch, even if target exists"), 2),
Øystein Walleaabfdc92023-04-07 19:53:16 +0200735 OPT_BOOL(0, "omit-empty", &omit_empty,
736 N_("do not output a newline after empty formatted refs")),
Sahil Dua52d59cc2017-06-18 23:19:16 +0200737 OPT_BIT('c', "copy", &copy, N_("copy a branch and its reflog"), 1),
738 OPT_BIT('C', NULL, &copy, N_("copy a branch, even if target exists"), 2),
Jeff Kinga15d5982018-06-22 05:24:59 -0400739 OPT_BOOL('l', "list", &list, N_("list branch names")),
Daniels Umanovskis0ecb1fc2018-10-25 21:04:21 +0200740 OPT_BOOL(0, "show-current", &show_current, N_("show current branch name")),
Jeff King055930b2018-06-22 05:24:14 -0400741 OPT_BOOL(0, "create-reflog", &reflog, N_("create the branch's reflog")),
Stefan Bellerd5d09d42013-08-03 13:51:19 +0200742 OPT_BOOL(0, "edit-description", &edit_description,
743 N_("edit the description for the branch")),
Nguyễn Thái Ngọc Duyc01b56a2018-02-09 18:01:47 +0700744 OPT__FORCE(&force, N_("force creation, move/rename, deletion"), PARSE_OPT_NOCOMPLETE),
Karthik Nayak1511b222015-09-23 23:41:11 +0530745 OPT_MERGED(&filter, N_("print only branches that are merged")),
746 OPT_NO_MERGED(&filter, N_("print only branches that are not merged")),
Nguyễn Thái Ngọc Duy24a85212012-08-20 19:31:55 +0700747 OPT_COLUMN(0, "column", &colopts, N_("list branches in columns")),
Junio C Hamano98e7ab62021-10-20 12:23:53 -0700748 OPT_REF_SORT(&sorting_options),
Denton Liu203c8532020-04-28 04:36:28 -0400749 OPT_CALLBACK(0, "points-at", &filter.points_at, N_("object"),
750 N_("print only branches of the object"), parse_opt_object_name),
Nguyễn Thái Ngọc Duy3bb16a82016-12-04 09:52:25 +0700751 OPT_BOOL('i', "ignore-case", &icase, N_("sorting and filtering are case insensitive")),
Glen Choo961b1302022-01-28 16:04:45 -0800752 OPT_BOOL(0, "recurse-submodules", &recurse_submodules_explicit, N_("recurse through submodules")),
Jeff King4a68e362017-07-13 11:01:18 -0400753 OPT_STRING( 0 , "format", &format.format, N_("format"), N_("format to use for the output")),
Pierre Habouzita8dfd5e2007-10-07 18:26:21 +0200754 OPT_END(),
755 };
Lars Hjemlic31820c2006-10-23 23:27:45 +0200756
Karthik Nayak56b43602017-01-10 14:19:51 +0530757 setup_ref_filter_porcelain_msg();
758
Karthik Nayak1511b222015-09-23 23:41:11 +0530759 memset(&filter, 0, sizeof(filter));
760 filter.kind = FILTER_REFS_BRANCHES;
761 filter.abbrev = -1;
762
Nguyễn Thái Ngọc Duy1dacfbc2010-10-22 01:42:58 -0500763 if (argc == 2 && !strcmp(argv[1], "-h"))
764 usage_with_options(builtin_branch_usage, options);
765
Junio C Hamano98e7ab62021-10-20 12:23:53 -0700766 git_config(git_branch_config, &sorting_options);
Matthias Kestenholz6b2f2d92008-02-18 08:26:03 +0100767
Jay Soffian9ed36cf2008-02-19 11:24:37 -0500768 track = git_branch_track;
Lars Hjemlic976d412006-11-28 15:47:40 +0100769
brian m. carlson0f2dc722017-10-15 22:06:55 +0000770 head = resolve_refdup("HEAD", 0, &head_oid, NULL);
Lars Hjemlic31820c2006-10-23 23:27:45 +0200771 if (!head)
Ævar Arnfjörð Bjarmason49df4b02011-02-22 23:41:34 +0000772 die(_("Failed to resolve HEAD as a valid ref."));
René Scharfee3f1da92014-10-04 20:54:50 +0200773 if (!strcmp(head, "HEAD"))
Karthik Nayak1511b222015-09-23 23:41:11 +0530774 filter.detached = 1;
René Scharfee3f1da92014-10-04 20:54:50 +0200775 else if (!skip_prefix(head, "refs/heads/", &head))
776 die(_("HEAD not found below refs/heads!"));
Nguyễn Thái Ngọc Duyebe31ef2012-04-13 17:54:38 +0700777
Stephen Boyd37782922009-05-23 11:53:12 -0700778 argc = parse_options(argc, argv, prefix, options, builtin_branch_usage,
779 0);
Michael J Grubercddd1272011-08-28 16:54:31 +0200780
Daniels Umanovskis0ecb1fc2018-10-25 21:04:21 +0200781 if (!delete && !rename && !copy && !edit_description && !new_upstream &&
782 !show_current && !unset_upstream && argc == 0)
Michael J Grubercddd1272011-08-28 16:54:31 +0200783 list = 1;
784
Aaron Lipman21bf9332020-09-15 22:08:40 -0400785 if (filter.with_commit || filter.no_commit ||
786 filter.reachable_from || filter.unreachable_from || filter.points_at.nr)
Jeff Kingd0403502013-01-31 01:46:11 -0500787 list = 1;
788
Glen Choo6e0a2ca2022-01-28 16:04:44 -0800789 noncreate_actions = !!delete + !!rename + !!copy + !!new_upstream +
790 !!show_current + !!list + !!edit_description +
791 !!unset_upstream;
792 if (noncreate_actions > 1)
Junio C Hamano049716b2008-07-08 17:55:47 -0700793 usage_with_options(builtin_branch_usage, options);
Lars Hjemlic31820c2006-10-23 23:27:45 +0200794
Glen Choo961b1302022-01-28 16:04:45 -0800795 if (recurse_submodules_explicit) {
796 if (!submodule_propagate_branches)
797 die(_("branch with --recurse-submodules can only be used if submodule.propagateBranches is enabled"));
798 if (noncreate_actions)
799 die(_("--recurse-submodules can only be used to create branches"));
800 }
801
802 recurse_submodules =
803 (recurse_submodules || recurse_submodules_explicit) &&
804 submodule_propagate_branches;
805
Karthik Nayak1511b222015-09-23 23:41:11 +0530806 if (filter.abbrev == -1)
807 filter.abbrev = DEFAULT_ABBREV;
Nguyễn Thái Ngọc Duy3bb16a82016-12-04 09:52:25 +0700808 filter.ignore_case = icase;
809
Nguyễn Thái Ngọc Duyebe31ef2012-04-13 17:54:38 +0700810 finalize_colopts(&colopts, -1);
Karthik Nayak1511b222015-09-23 23:41:11 +0530811 if (filter.verbose) {
Nguyễn Thái Ngọc Duyebe31ef2012-04-13 17:54:38 +0700812 if (explicitly_enable_column(colopts))
Jean-Noël Avila12909b62022-01-05 20:02:16 +0000813 die(_("options '%s' and '%s' cannot be used together"), "--column", "--verbose");
Nguyễn Thái Ngọc Duyebe31ef2012-04-13 17:54:38 +0700814 colopts = 0;
815 }
Namhyung Kimb792c062011-07-01 15:06:08 +0900816
Michael J Gruber356e91f2014-12-08 17:28:45 +0100817 if (force) {
818 delete *= 2;
819 rename *= 2;
Sahil Dua52d59cc2017-06-18 23:19:16 +0200820 copy *= 2;
Michael J Gruber356e91f2014-12-08 17:28:45 +0100821 }
822
Martin Ågrend74b5412017-11-19 16:03:49 +0100823 if (list)
Martin Ågren0ae19de2017-11-19 16:03:50 +0100824 setup_auto_pager("branch", 1);
Martin Ågrend74b5412017-11-19 16:03:49 +0100825
Nguyễn Thái Ngọc Duy640d0402013-01-28 08:18:14 +0700826 if (delete) {
827 if (!argc)
828 die(_("branch name required"));
Karthik Nayak1511b222015-09-23 23:41:11 +0530829 return delete_branches(argc, argv, delete > 1, filter.kind, quiet);
Daniels Umanovskis0ecb1fc2018-10-25 21:04:21 +0200830 } else if (show_current) {
831 print_current_branch_name();
832 return 0;
Nguyễn Thái Ngọc Duy640d0402013-01-28 08:18:14 +0700833 } else if (list) {
Ævar Arnfjörð Bjarmasonffdd02a2021-01-06 11:01:35 +0100834 /* git branch --list also shows HEAD when it is detached */
Karthik Nayak1511b222015-09-23 23:41:11 +0530835 if ((filter.kind & FILTER_REFS_BRANCHES) && filter.detached)
836 filter.kind |= FILTER_REFS_DETACHED_HEAD;
837 filter.name_patterns = argv;
Nguyễn Thái Ngọc Duy3bb16a82016-12-04 09:52:25 +0700838 /*
839 * If no sorting parameter is given then we default to sorting
840 * by 'refname'. This would give us an alphabetically sorted
841 * array with the 'HEAD' ref at the beginning followed by
Robert P. J. Day30aa96c2018-06-07 07:53:36 -0400842 * local branches 'refs/heads/...' and finally remote-tracking
Nguyễn Thái Ngọc Duy3bb16a82016-12-04 09:52:25 +0700843 * branches 'refs/remotes/...'.
844 */
Junio C Hamano98e7ab62021-10-20 12:23:53 -0700845 sorting = ref_sorting_options(&sorting_options);
Ævar Arnfjörð Bjarmason7c269a72021-01-07 10:51:51 +0100846 ref_sorting_set_sort_flags_all(sorting, REF_SORTING_ICASE, icase);
Ævar Arnfjörð Bjarmason2708ce62021-01-07 10:51:52 +0100847 ref_sorting_set_sort_flags_all(
848 sorting, REF_SORTING_DETACHED_HEAD_FIRST, 1);
Ævar Arnfjörð Bjarmasond72d4f92021-10-20 20:27:21 +0200849 print_ref_list(&filter, sorting, &format, &output);
Nguyễn Thái Ngọc Duyebe31ef2012-04-13 17:54:38 +0700850 print_columns(&output, colopts, NULL);
851 string_list_clear(&output, 0);
Ævar Arnfjörð Bjarmasond72d4f92021-10-20 20:27:21 +0200852 ref_sorting_release(sorting);
Karthik Nayakca417992015-09-24 23:39:08 +0530853 return 0;
Tao Qingyun2e3c8942018-10-16 22:19:20 +0800854 } else if (edit_description) {
Junio C Hamanob7200e82011-09-20 15:10:08 -0700855 const char *branch_name;
Junio C Hamanoc2d17ba2012-02-05 17:13:36 -0800856 struct strbuf branch_ref = STRBUF_INIT;
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200857 struct strbuf buf = STRBUF_INIT;
858 int ret = 1; /* assume failure */
Junio C Hamanoc2d17ba2012-02-05 17:13:36 -0800859
Nguyễn Thái Ngọc Duy75135b22013-01-28 08:18:13 +0700860 if (!argc) {
Karthik Nayak1511b222015-09-23 23:41:11 +0530861 if (filter.detached)
Nguyễn Thái Ngọc Duy045e3882013-01-28 08:18:16 +0700862 die(_("Cannot give description to detached HEAD"));
Junio C Hamanob7200e82011-09-20 15:10:08 -0700863 branch_name = head;
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200864 } else if (argc == 1) {
865 strbuf_branchname(&buf, argv[0], INTERPRET_BRANCH_LOCAL);
866 branch_name = buf.buf;
867 } else {
Nguyễn Thái Ngọc Duy43722c42013-01-28 08:18:15 +0700868 die(_("cannot edit description of more than one branch"));
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200869 }
Junio C Hamanoc2d17ba2012-02-05 17:13:36 -0800870
871 strbuf_addf(&branch_ref, "refs/heads/%s", branch_name);
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200872 if (!ref_exists(branch_ref.buf))
Rubén Justo7a6ccdf2023-03-27 00:33:17 +0200873 error((!argc || branch_checked_out(branch_ref.buf))
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200874 ? _("No commit on branch '%s' yet.")
875 : _("No branch named '%s'."),
876 branch_name);
877 else if (!edit_branch_description(branch_name))
878 ret = 0; /* happy */
Junio C Hamanoc2d17ba2012-02-05 17:13:36 -0800879
Junio C Hamanoc2d17ba2012-02-05 17:13:36 -0800880 strbuf_release(&branch_ref);
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200881 strbuf_release(&buf);
Junio C Hamanoc2d17ba2012-02-05 17:13:36 -0800882
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200883 return ret;
Rubén Justo77e72672022-10-26 01:01:29 +0200884 } else if (copy || rename) {
Sahil Dua52d59cc2017-06-18 23:19:16 +0200885 if (!argc)
886 die(_("branch name required"));
Rubén Justo77e72672022-10-26 01:01:29 +0200887 else if ((argc == 1) && filter.detached)
888 die(copy? _("cannot copy the current branch while not on any.")
889 : _("cannot rename the current branch while not on any."));
Sahil Dua52d59cc2017-06-18 23:19:16 +0200890 else if (argc == 1)
Rubén Justo77e72672022-10-26 01:01:29 +0200891 copy_or_rename_branch(head, argv[0], copy, copy + rename > 1);
Sahil Dua52d59cc2017-06-18 23:19:16 +0200892 else if (argc == 2)
Rubén Justo77e72672022-10-26 01:01:29 +0200893 copy_or_rename_branch(argv[0], argv[1], copy, copy + rename > 1);
Sahil Dua52d59cc2017-06-18 23:19:16 +0200894 else
Rubén Justo77e72672022-10-26 01:01:29 +0200895 die(copy? _("too many branches for a copy operation")
896 : _("too many arguments for a rename operation"));
Carlos Martín Nieto6183d822012-08-20 15:47:38 +0200897 } else if (new_upstream) {
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200898 struct branch *branch;
899 struct strbuf buf = STRBUF_INIT;
Carlos Martín Nieto6183d822012-08-20 15:47:38 +0200900
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200901 if (!argc)
902 branch = branch_get(NULL);
903 else if (argc == 1) {
904 strbuf_branchname(&buf, argv[0], INTERPRET_BRANCH_LOCAL);
905 branch = branch_get(buf.buf);
906 } else
Kaartic Sivaraamf7776232017-08-21 19:06:08 +0530907 die(_("too many arguments to set new upstream"));
Nguyễn Thái Ngọc Duy8efb8892013-02-23 19:22:27 +0700908
909 if (!branch) {
910 if (!argc || !strcmp(argv[0], "HEAD"))
911 die(_("could not set upstream of HEAD to %s when "
912 "it does not point to any branch."),
913 new_upstream);
914 die(_("no such branch '%s'"), argv[0]);
915 }
916
Rubén Justobcfc82b2022-10-08 02:39:43 +0200917 if (!ref_exists(branch->refname)) {
Rubén Justo7a6ccdf2023-03-27 00:33:17 +0200918 if (!argc || branch_checked_out(branch->refname))
Rubén Justobcfc82b2022-10-08 02:39:43 +0200919 die(_("No commit on branch '%s' yet."), branch->name);
Carlos Martín Nieto6183d822012-08-20 15:47:38 +0200920 die(_("branch '%s' does not exist"), branch->name);
Rubén Justobcfc82b2022-10-08 02:39:43 +0200921 }
Carlos Martín Nieto6183d822012-08-20 15:47:38 +0200922
Glen Chooe89f1512022-01-28 16:04:41 -0800923 dwim_and_setup_tracking(the_repository, branch->name,
924 new_upstream, BRANCH_TRACK_OVERRIDE,
925 quiet);
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200926 strbuf_release(&buf);
Carlos Martín Nietob84869e2012-08-30 19:23:12 +0200927 } else if (unset_upstream) {
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200928 struct branch *branch;
Carlos Martín Nietob84869e2012-08-30 19:23:12 +0200929 struct strbuf buf = STRBUF_INIT;
930
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200931 if (!argc)
932 branch = branch_get(NULL);
933 else if (argc == 1) {
934 strbuf_branchname(&buf, argv[0], INTERPRET_BRANCH_LOCAL);
935 branch = branch_get(buf.buf);
936 } else
Kaartic Sivaraamf7776232017-08-21 19:06:08 +0530937 die(_("too many arguments to unset upstream"));
Nguyễn Thái Ngọc Duy8efb8892013-02-23 19:22:27 +0700938
939 if (!branch) {
940 if (!argc || !strcmp(argv[0], "HEAD"))
941 die(_("could not unset upstream of HEAD when "
942 "it does not point to any branch."));
943 die(_("no such branch '%s'"), argv[0]);
944 }
945
Felipe Contreras54d07f22013-10-31 03:25:38 -0600946 if (!branch_has_merge_config(branch))
Carlos Martín Nietob84869e2012-08-30 19:23:12 +0200947 die(_("Branch '%s' has no upstream information"), branch->name);
Carlos Martín Nietob84869e2012-08-30 19:23:12 +0200948
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200949 strbuf_reset(&buf);
Carlos Martín Nietob84869e2012-08-30 19:23:12 +0200950 strbuf_addf(&buf, "branch.%s.remote", branch->name);
Derrick Stolee504ee122020-11-25 22:12:49 +0000951 git_config_set_multivar(buf.buf, NULL, NULL, CONFIG_FLAGS_MULTI_REPLACE);
Carlos Martín Nietob84869e2012-08-30 19:23:12 +0200952 strbuf_reset(&buf);
953 strbuf_addf(&buf, "branch.%s.merge", branch->name);
Derrick Stolee504ee122020-11-25 22:12:49 +0000954 git_config_set_multivar(buf.buf, NULL, NULL, CONFIG_FLAGS_MULTI_REPLACE);
Carlos Martín Nietob84869e2012-08-30 19:23:12 +0200955 strbuf_release(&buf);
Glen Choo6e0a2ca2022-01-28 16:04:44 -0800956 } else if (!noncreate_actions && argc > 0 && argc <= 2) {
Glen Choo961b1302022-01-28 16:04:45 -0800957 const char *branch_name = argv[0];
958 const char *start_name = argc == 2 ? argv[1] : head;
959
Karthik Nayak1511b222015-09-23 23:41:11 +0530960 if (filter.kind != FILTER_REFS_BRANCHES)
Philip Oakley1fde99c2019-05-29 00:16:05 +0100961 die(_("The -a, and -r, options to 'git branch' do not take a branch name.\n"
962 "Did you mean to use: -a|-r --list <pattern>?"));
Carlos Martín Nietob347d062012-08-30 19:23:13 +0200963
964 if (track == BRANCH_TRACK_OVERRIDE)
Kaartic Sivaraam52668842017-08-17 08:24:24 +0530965 die(_("the '--set-upstream' option is no longer supported. Please use '--track' or '--set-upstream-to' instead."));
Carlos Martín Nietob347d062012-08-30 19:23:13 +0200966
Glen Choo961b1302022-01-28 16:04:45 -0800967 if (recurse_submodules) {
968 create_branches_recursively(the_repository, branch_name,
969 start_name, NULL, force,
970 reflog, quiet, track, 0);
971 return 0;
972 }
973 create_branch(the_repository, branch_name, start_name, force, 0,
974 reflog, quiet, track, 0);
Matthieu Moy6e8f9932009-12-30 15:45:31 +0100975 } else
Pierre Habouzita8dfd5e2007-10-07 18:26:21 +0200976 usage_with_options(builtin_branch_usage, options);
Lars Hjemlic31820c2006-10-23 23:27:45 +0200977
978 return 0;
979}