* Based on git-branch.sh by Junio C Hamano.

*/

#include "config.h"

#include "color.h"

#include "editor.h"

#include "environment.h"

#include "refs.h"

#include "commit.h"

#include "gettext.h"

#include "object-name.h"

#include "remote.h"

#include "parse-options.h"

#include "branch.h"

#include "diff.h"

#include "revision.h"

#include "string-list.h"

#include "column.h"

#include "worktree.h"

#include "help.h"

#include "commit-reach.h"

static const char * const builtin_branch_usage[] = {

N_("git branch [<options>] [-r | -a] [--merged] [--no-merged]"),

define_list_config_array(color_branch_slots);

{

const char *slot_name;

return 0;

}

}

static const char *branch_get_color(enum color_branch ix)

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

if (merged)

warning(_("deleting branch '%s' that has been merged to\n"

name, reference_name);

else

warning(_("not deleting branch '%s' that is not yet merged to\n"

name, reference_name);

}

free(reference_name_to_free);

{

struct commit *rev = lookup_commit_reference(the_repository, oid);

if (!force && !rev) {

return -1;

}

if (!force && !branch_merged(kinds, branchname, rev, head_rev)) {

"If you are sure you want to delete it, "

return -1;

}

return 0;

struct strbuf buf = STRBUF_INIT;

strbuf_addf(&buf, "branch.%s", branchname);

if (git_config_rename_section(buf.buf, NULL) < 0)

strbuf_release(&buf);

}

if (kinds == FILTER_REFS_BRANCHES) {

const char *path;

if ((path = branch_checked_out(name))) {

bname.buf, path);

ret = 1;

continue;

&oid, &flags);

if (!target) {

if (remote_branch) {

} else {

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

char *virtual_target = resolve_refdup(virtual_name,

"Did you forget --remote?"),

bname.buf);

else

FREE_AND_NULL(virtual_target);

}

ret = 1;

static struct strbuf buf = STRBUF_INIT;

strbuf_reset(&buf);

return buf.buf;

}

continue;

if (is_worktree_being_rebased(wt, target))

target, wt->path);

if (is_worktree_being_bisected(wt, target))

target, wt->path);

}

}

if (ref_exists(oldref.buf))

recovery = 1;

else

}

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

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

if (oldref_usage & IS_HEAD)

else

}

/*

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

rename_ref(oldref.buf, newref.buf, logmsg.buf))

if (copy && copy_existing_ref(oldref.buf, newref.buf, logmsg.buf))

if (recovery) {

if (copy)

interpreted_oldname);

else

interpreted_oldname);

}

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

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

logmsg.buf))

strbuf_release(&logmsg);

strbuf_addf(&oldsection, "branch.%s", interpreted_oldname);

strbuf_addf(&newsection, "branch.%s", interpreted_newname);

if (!copy && git_config_rename_section(oldsection.buf, newsection.buf) < 0)

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

strbuf_release(&oldref);

strbuf_release(&newref);

strbuf_release(&oldsection);

exists = !read_branch_desc(&buf, branch_name);

if (!buf.len || buf.buf[buf.len-1] != '\n')

strbuf_addch(&buf, '\n');

_("Please edit the description for the branch\n"

" %s\n"

"Lines starting with '%c' will be stripped.\n"),

strbuf_release(&buf);

return -1;

}

strbuf_addf(&name, "branch.%s.description", branch_name);

if (buf.len || exists)

int reflog = 0, quiet = 0, icase = 0, force = 0,

recurse_submodules_explicit = 0;

enum branch_track track;

static struct ref_sorting *sorting;

struct string_list sorting_options = STRING_LIST_INIT_DUP;

struct ref_format format = REF_FORMAT_INIT;

OPT_STRING('u', "set-upstream-to", &new_upstream, N_("upstream"), N_("change the upstream info")),

OPT_BOOL(0, "unset-upstream", &unset_upstream, N_("unset the upstream info")),

OPT__COLOR(&branch_use_color, N_("use colored output")),

OPT_CONTAINS(&filter.with_commit, N_("print only branches that contain the commit")),

OPT_NO_CONTAINS(&filter.no_commit, N_("print only branches that don't contain the commit")),

OPT_WITH(&filter.with_commit, N_("print only branches that contain the commit")),

OPT__ABBREV(&filter.abbrev),

OPT_GROUP(N_("Specific git-branch actions:")),

OPT_BIT('d', "delete", &delete, N_("delete fully merged branch"), 1),

OPT_BIT('D', NULL, &delete, N_("delete branch (even if not merged)"), 2),

OPT_BIT('m', "move", &rename, N_("move/rename a branch and its reflog"), 1),

setup_ref_filter_porcelain_msg();

filter.kind = FILTER_REFS_BRANCHES;

filter.abbrev = -1;

head = resolve_refdup("HEAD", 0, &head_oid, NULL);

if (!head)

if (!strcmp(head, "HEAD"))

filter.detached = 1;

else if (!skip_prefix(head, "refs/heads/", &head))

if (list)

setup_auto_pager("branch", 1);

if (delete) {

if (!argc)

die(_("branch name required"));

print_columns(&output, colopts, NULL);

string_list_clear(&output, 0);

ref_sorting_release(sorting);

return 0;

} else if (edit_description) {

const char *branch_name;

if (!argc) {

if (filter.detached)

branch_name = head;

} else if (argc == 1) {

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

strbuf_addf(&branch_ref, "refs/heads/%s", branch_name);

if (!ref_exists(branch_ref.buf))

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

branch_name);

else if (!edit_branch_description(branch_name))

ret = 0; /* happy */

if (!argc)

die(_("branch name required"));

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

else if (argc == 1)

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

else if (argc == 2)

if (!branch) {

if (!argc || !strcmp(argv[0], "HEAD"))

die(_("could not set upstream of HEAD to %s when "

new_upstream);

die(_("no such branch '%s'"), argv[0]);

}

if (!ref_exists(branch->refname)) {

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

die(_("branch '%s' does not exist"), branch->name);

}

if (!branch) {

if (!argc || !strcmp(argv[0], "HEAD"))

die(_("could not unset upstream of HEAD when "

die(_("no such branch '%s'"), argv[0]);

}

if (!branch_has_merge_config(branch))

strbuf_reset(&buf);

strbuf_addf(&buf, "branch.%s.remote", branch->name);

const char *start_name = argc == 2 ? argv[1] : head;

if (filter.kind != FILTER_REFS_BRANCHES)

"Did you mean to use: -a|-r --list <pattern>?"));

if (track == BRANCH_TRACK_OVERRIDE)

if (recurse_submodules) {

create_branches_recursively(the_repository, branch_name,