+#include "builtin.h"

+#include "editor.h"

+#include "environment.h"

+#include "gettext.h"

+#include "object-name.h"

+#include "path.h"

+static int omit_empty = 0;

+static int git_branch_config(const char *var, const char *value,

+ const struct config_context *ctx, void *cb)

+ if (git_color_config(var, value, cb) < 0)

+ return -1;

+

+ return git_default_config(var, value, ctx, cb);

+ merged = reference_rev ? repo_in_merge_bases(the_repository, rev,

+ reference_rev) : 0;

+ * return the result of the repo_in_merge_bases() above without

+ (head_rev ? repo_in_merge_bases(the_repository, rev, head_rev) : 0) != merged) {

+ const char *fmt_remotes = "refs/remotes/%s";

+ fmt = fmt_remotes;

+ if (!force)

+ "used by worktree at '%s'"),

+ if (remote_branch) {

+ error(_("remote-tracking branch '%s' not found."), bname.buf);

+ } else {

+ char *virtual_name = mkpathdup(fmt_remotes, bname.buf);

+ char *virtual_target = resolve_refdup(virtual_name,

+ RESOLVE_REF_READING

+ | RESOLVE_REF_NO_RECURSE

+ | RESOLVE_REF_ALLOW_BAD_NAME,

+ &oid, &flags);

+ FREE_AND_NULL(virtual_name);

+

+ if (virtual_target)

+ error(_("branch '%s' not found.\n"

+ "Did you forget --remote?"),

+ bname.buf);

+ else

+ error(_("branch '%s' not found."), bname.buf);

+ FREE_AND_NULL(virtual_target);

+ }

+ : repo_find_unique_abbrev(the_repository, &oid, DEFAULT_ABBREV));

+ while (strbuf_expand_step(&buf, &s))

+ strbuf_addstr(&buf, "%%");

+ filter_ahead_behind(the_repository, format, &array);

+ if (out.len || !omit_empty)

+ putchar('\n');

+static void reject_rebase_or_bisect_branch(struct worktree **worktrees,

+ const char *target)

+}

+/*

+ * Update all per-worktree HEADs pointing at the old ref to point the new ref.

+ * This will be used when renaming a branch. Returns 0 if successful, non-zero

+ * otherwise.

+ */

+static int replace_each_worktree_head_symref(struct worktree **worktrees,

+ const char *oldref, const char *newref,

+ const char *logmsg)

+{

+ int ret = 0;

+ int i;

+

+ for (i = 0; worktrees[i]; i++) {

+ struct ref_store *refs;

+

+ if (worktrees[i]->is_detached)

+ continue;

+ if (!worktrees[i]->head_ref)

+ continue;

+ if (strcmp(oldref, worktrees[i]->head_ref))

+ continue;

+

+ refs = get_worktree_ref_store(worktrees[i]);

+ if (refs_create_symref(refs, "HEAD", newref, logmsg))

+ ret = error(_("HEAD of working tree %s is not updated"),

+ worktrees[i]->path);

+ }

+

+ return ret;

+#define IS_HEAD 1

+#define IS_ORPHAN 2

+

+ int recovery = 0, oldref_usage = 0;

+ struct worktree **worktrees = get_worktrees();

+ for (int i = 0; worktrees[i]; i++) {

+ struct worktree *wt = worktrees[i];

+

+ if (wt->head_ref && !strcmp(oldref.buf, wt->head_ref)) {

+ oldref_usage |= IS_HEAD;

+ if (is_null_oid(&wt->head_oid))

+ oldref_usage |= IS_ORPHAN;

+ break;

+ }

+ }

+

+ if ((copy || !(oldref_usage & IS_HEAD)) && !ref_exists(oldref.buf)) {

+ if (oldref_usage & IS_HEAD)

+ reject_rebase_or_bisect_branch(worktrees, oldref.buf);

+ if (!copy && !(oldref_usage & IS_ORPHAN) &&

+ if (!copy && (oldref_usage & IS_HEAD) &&

+ replace_each_worktree_head_symref(worktrees, oldref.buf, newref.buf,

+ logmsg.buf))

+ if (copy && strcmp(interpreted_oldname, interpreted_newname) && git_config_copy_section(oldsection.buf, newsection.buf) < 0)

+ strbuf_release(&oldref);

+ strbuf_release(&newref);

+ free_worktrees(worktrees);

+ strbuf_commented_addf(&buf, comment_line_char,

+ strbuf_stripspace(&buf, comment_line_char);

+ struct ref_filter filter = REF_FILTER_INIT;

+ OPT_SET_INT_F('r', "remotes", &filter.kind, N_("act on remote-tracking branches"),

+ FILTER_REFS_REMOTES,

+ PARSE_OPT_NONEG),

+ OPT_SET_INT_F('a', "all", &filter.kind, N_("list both remote-tracking and local branches"),

+ FILTER_REFS_REMOTES | FILTER_REFS_BRANCHES,

+ PARSE_OPT_NONEG),

+ OPT_BOOL(0, "omit-empty", &omit_empty,

+ N_("do not output a newline after empty formatted refs")),

+ UNLEAK(sorting_options);

+

+ ref_filter_clear(&filter);

+ struct strbuf buf = STRBUF_INIT;

+ int ret = 1; /* assume failure */

+ } else if (argc == 1) {

+ strbuf_branchname(&buf, argv[0], INTERPRET_BRANCH_LOCAL);

+ branch_name = buf.buf;

+ } else {

+ }

+ if (!ref_exists(branch_ref.buf))

+ error((!argc || branch_checked_out(branch_ref.buf))

+ ? _("No commit on branch '%s' yet.")

+ : _("No branch named '%s'."),

+ branch_name);

+ else if (!edit_branch_description(branch_name))

+ ret = 0; /* happy */

+

+ strbuf_release(&buf);

+ return ret;

+ } else if (copy || rename) {

+ else if ((argc == 1) && filter.detached)

+ die(copy? _("cannot copy the current branch while not on any.")

+ : _("cannot rename the current branch while not on any."));

+ copy_or_rename_branch(head, argv[0], copy, copy + rename > 1);

+ copy_or_rename_branch(argv[0], argv[1], copy, copy + rename > 1);

+ die(copy? _("too many branches for a copy operation")

+ : _("too many arguments for a rename operation"));

+ struct branch *branch;

+ struct strbuf buf = STRBUF_INIT;

+ if (!argc)

+ branch = branch_get(NULL);

+ else if (argc == 1) {

+ strbuf_branchname(&buf, argv[0], INTERPRET_BRANCH_LOCAL);

+ branch = branch_get(buf.buf);

+ } else

+ if (!argc || branch_checked_out(branch->refname))

+ strbuf_release(&buf);

+ struct branch *branch;

+ if (!argc)

+ branch = branch_get(NULL);

+ else if (argc == 1) {

+ strbuf_branchname(&buf, argv[0], INTERPRET_BRANCH_LOCAL);

+ branch = branch_get(buf.buf);

+ } else

+ strbuf_reset(&buf);