2006-10-23 21:27:45 +00:00
|
|
|
/*
|
|
|
|
* Builtin "git branch"
|
|
|
|
*
|
2007-07-12 05:52:45 +00:00
|
|
|
* Copyright (c) 2006 Kristian Høgsberg <krh@redhat.com>
|
2006-10-23 21:27:45 +00:00
|
|
|
* Based on git-branch.sh by Junio C Hamano.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "cache.h"
|
2006-12-19 22:34:12 +00:00
|
|
|
#include "color.h"
|
2006-10-23 21:27:45 +00:00
|
|
|
#include "refs.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "builtin.h"
|
2007-07-10 17:50:44 +00:00
|
|
|
#include "remote.h"
|
2007-10-07 16:26:21 +00:00
|
|
|
#include "parse-options.h"
|
2008-02-07 16:40:08 +00:00
|
|
|
#include "branch.h"
|
2008-07-23 22:13:41 +00:00
|
|
|
#include "diff.h"
|
|
|
|
#include "revision.h"
|
2007-10-07 16:26:21 +00:00
|
|
|
|
|
|
|
static const char * const builtin_branch_usage[] = {
|
2008-07-13 13:36:15 +00:00
|
|
|
"git branch [options] [-r | -a] [--merged | --no-merged]",
|
|
|
|
"git branch [options] [-l] [-f] <branchname> [<start-point>]",
|
|
|
|
"git branch [options] [-r] (-d | -D) <branchname>",
|
|
|
|
"git branch [options] (-m | -M) [<oldbranch>] <newbranch>",
|
2007-10-07 16:26:21 +00:00
|
|
|
NULL
|
|
|
|
};
|
2006-10-23 21:27:45 +00:00
|
|
|
|
2006-12-18 07:58:16 +00:00
|
|
|
#define REF_LOCAL_BRANCH 0x01
|
|
|
|
#define REF_REMOTE_BRANCH 0x02
|
2006-10-23 21:27:45 +00:00
|
|
|
|
|
|
|
static const char *head;
|
|
|
|
static unsigned char head_sha1[20];
|
|
|
|
|
2008-02-18 07:26:03 +00:00
|
|
|
static int branch_use_color = -1;
|
2006-12-12 06:41:52 +00:00
|
|
|
static char branch_colors[][COLOR_MAXLEN] = {
|
|
|
|
"\033[m", /* reset */
|
|
|
|
"", /* PLAIN (normal) */
|
|
|
|
"\033[31m", /* REMOTE (red) */
|
2006-12-13 18:55:21 +00:00
|
|
|
"", /* LOCAL (normal) */
|
|
|
|
"\033[32m", /* CURRENT (green) */
|
2006-12-12 06:41:52 +00:00
|
|
|
};
|
|
|
|
enum color_branch {
|
|
|
|
COLOR_BRANCH_RESET = 0,
|
|
|
|
COLOR_BRANCH_PLAIN = 1,
|
|
|
|
COLOR_BRANCH_REMOTE = 2,
|
|
|
|
COLOR_BRANCH_LOCAL = 3,
|
|
|
|
COLOR_BRANCH_CURRENT = 4,
|
|
|
|
};
|
|
|
|
|
2008-07-09 00:55:47 +00:00
|
|
|
static enum merge_filter {
|
|
|
|
NO_FILTER = 0,
|
|
|
|
SHOW_NOT_MERGED,
|
|
|
|
SHOW_MERGED,
|
|
|
|
} merge_filter;
|
|
|
|
static unsigned char merge_filter_ref[20];
|
2008-04-17 20:24:50 +00:00
|
|
|
|
2006-12-12 06:41:52 +00:00
|
|
|
static int parse_branch_color_slot(const char *var, int ofs)
|
|
|
|
{
|
|
|
|
if (!strcasecmp(var+ofs, "plain"))
|
|
|
|
return COLOR_BRANCH_PLAIN;
|
|
|
|
if (!strcasecmp(var+ofs, "reset"))
|
|
|
|
return COLOR_BRANCH_RESET;
|
|
|
|
if (!strcasecmp(var+ofs, "remote"))
|
|
|
|
return COLOR_BRANCH_REMOTE;
|
|
|
|
if (!strcasecmp(var+ofs, "local"))
|
|
|
|
return COLOR_BRANCH_LOCAL;
|
|
|
|
if (!strcasecmp(var+ofs, "current"))
|
|
|
|
return COLOR_BRANCH_CURRENT;
|
|
|
|
die("bad config variable '%s'", var);
|
|
|
|
}
|
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
static int git_branch_config(const char *var, const char *value, void *cb)
|
2006-12-12 06:41:52 +00:00
|
|
|
{
|
|
|
|
if (!strcmp(var, "color.branch")) {
|
2007-12-06 01:26:11 +00:00
|
|
|
branch_use_color = git_config_colorbool(var, value, -1);
|
2006-12-12 06:41:52 +00:00
|
|
|
return 0;
|
|
|
|
}
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
if (!prefixcmp(var, "color.branch.")) {
|
2006-12-12 06:41:52 +00:00
|
|
|
int slot = parse_branch_color_slot(var, 13);
|
2008-02-11 18:45:50 +00:00
|
|
|
if (!value)
|
|
|
|
return config_error_nonbool(var);
|
2006-12-12 06:41:52 +00:00
|
|
|
color_parse(value, var, branch_colors[slot]);
|
|
|
|
return 0;
|
|
|
|
}
|
2008-05-14 17:46:53 +00:00
|
|
|
return git_color_default_config(var, value, cb);
|
2006-12-12 06:41:52 +00:00
|
|
|
}
|
|
|
|
|
2007-06-07 20:45:00 +00:00
|
|
|
static const char *branch_get_color(enum color_branch ix)
|
2006-12-12 06:41:52 +00:00
|
|
|
{
|
2008-02-18 07:26:03 +00:00
|
|
|
if (branch_use_color > 0)
|
2006-12-12 06:41:52 +00:00
|
|
|
return branch_colors[ix];
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2006-12-18 22:42:16 +00:00
|
|
|
static int delete_branches(int argc, const char **argv, int force, int kinds)
|
2006-10-23 21:27:45 +00:00
|
|
|
{
|
2006-11-25 07:10:23 +00:00
|
|
|
struct commit *rev, *head_rev = head_rev;
|
2006-10-23 21:27:45 +00:00
|
|
|
unsigned char sha1[20];
|
2006-12-18 22:42:16 +00:00
|
|
|
char *name = NULL;
|
2006-12-18 07:58:16 +00:00
|
|
|
const char *fmt, *remote;
|
2007-06-09 12:40:35 +00:00
|
|
|
char section[PATH_MAX];
|
2006-10-23 21:27:45 +00:00
|
|
|
int i;
|
2006-12-18 22:42:16 +00:00
|
|
|
int ret = 0;
|
2006-10-23 21:27:45 +00:00
|
|
|
|
2006-12-18 07:58:16 +00:00
|
|
|
switch (kinds) {
|
|
|
|
case REF_REMOTE_BRANCH:
|
|
|
|
fmt = "refs/remotes/%s";
|
|
|
|
remote = "remote ";
|
|
|
|
force = 1;
|
|
|
|
break;
|
|
|
|
case REF_LOCAL_BRANCH:
|
|
|
|
fmt = "refs/heads/%s";
|
|
|
|
remote = "";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
die("cannot use -a with -d");
|
|
|
|
}
|
2006-10-23 21:27:45 +00:00
|
|
|
|
2006-11-25 07:10:23 +00:00
|
|
|
if (!force) {
|
|
|
|
head_rev = lookup_commit_reference(head_sha1);
|
|
|
|
if (!head_rev)
|
|
|
|
die("Couldn't look up commit object for HEAD");
|
|
|
|
}
|
2006-10-23 21:27:45 +00:00
|
|
|
for (i = 0; i < argc; i++) {
|
2006-12-18 22:42:16 +00:00
|
|
|
if (kinds == REF_LOCAL_BRANCH && !strcmp(head, argv[i])) {
|
|
|
|
error("Cannot delete the branch '%s' "
|
|
|
|
"which you are currently on.", argv[i]);
|
|
|
|
ret = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
Avoid unnecessary "if-before-free" tests.
This change removes all obvious useless if-before-free tests.
E.g., it replaces code like this:
if (some_expression)
free (some_expression);
with the now-equivalent:
free (some_expression);
It is equivalent not just because POSIX has required free(NULL)
to work for a long time, but simply because it has worked for
so long that no reasonable porting target fails the test.
Here's some evidence from nearly 1.5 years ago:
http://www.winehq.org/pipermail/wine-patches/2006-October/031544.html
FYI, the change below was prepared by running the following:
git ls-files -z | xargs -0 \
perl -0x3b -pi -e \
's/\bif\s*\(\s*(\S+?)(?:\s*!=\s*NULL)?\s*\)\s+(free\s*\(\s*\1\s*\))/$2/s'
Note however, that it doesn't handle brace-enclosed blocks like
"if (x) { free (x); }". But that's ok, since there were none like
that in git sources.
Beware: if you do use the above snippet, note that it can
produce syntactically invalid C code. That happens when the
affected "if"-statement has a matching "else".
E.g., it would transform this
if (x)
free (x);
else
foo ();
into this:
free (x);
else
foo ();
There were none of those here, either.
If you're interested in automating detection of the useless
tests, you might like the useless-if-before-free script in gnulib:
[it *does* detect brace-enclosed free statements, and has a --name=S
option to make it detect free-like functions with different names]
http://git.sv.gnu.org/gitweb/?p=gnulib.git;a=blob;f=build-aux/useless-if-before-free
Addendum:
Remove one more (in imap-send.c), spotted by Jean-Luc Herren <jlh@gmx.ch>.
Signed-off-by: Jim Meyering <meyering@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-31 17:26:32 +00:00
|
|
|
free(name);
|
2006-10-23 21:27:45 +00:00
|
|
|
|
2006-12-18 07:58:16 +00:00
|
|
|
name = xstrdup(mkpath(fmt, argv[i]));
|
2006-12-18 22:42:16 +00:00
|
|
|
if (!resolve_ref(name, sha1, 1, NULL)) {
|
|
|
|
error("%sbranch '%s' not found.",
|
|
|
|
remote, argv[i]);
|
|
|
|
ret = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2006-10-23 21:27:45 +00:00
|
|
|
|
|
|
|
rev = lookup_commit_reference(sha1);
|
2006-12-18 22:42:16 +00:00
|
|
|
if (!rev) {
|
|
|
|
error("Couldn't look up commit object for '%s'", name);
|
|
|
|
ret = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2006-10-23 21:27:45 +00:00
|
|
|
|
|
|
|
/* This checks whether the merge bases of branch and
|
|
|
|
* HEAD contains branch -- which means that the HEAD
|
|
|
|
* contains everything in both.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (!force &&
|
2007-01-09 07:22:31 +00:00
|
|
|
!in_merge_bases(rev, &head_rev, 1)) {
|
2007-11-03 02:39:44 +00:00
|
|
|
error("The branch '%s' is not an ancestor of "
|
2006-12-18 22:42:16 +00:00
|
|
|
"your current HEAD.\n"
|
|
|
|
"If you are sure you want to delete it, "
|
|
|
|
"run 'git branch -D %s'.", argv[i], argv[i]);
|
|
|
|
ret = 1;
|
|
|
|
continue;
|
2006-10-23 21:27:45 +00:00
|
|
|
}
|
|
|
|
|
2006-12-18 22:42:16 +00:00
|
|
|
if (delete_ref(name, sha1)) {
|
|
|
|
error("Error deleting %sbranch '%s'", remote,
|
2006-12-18 07:58:16 +00:00
|
|
|
argv[i]);
|
2006-12-18 22:42:16 +00:00
|
|
|
ret = 1;
|
2007-06-09 12:40:35 +00:00
|
|
|
} else {
|
2006-12-18 07:58:16 +00:00
|
|
|
printf("Deleted %sbranch %s.\n", remote, argv[i]);
|
2007-06-09 12:40:35 +00:00
|
|
|
snprintf(section, sizeof(section), "branch.%s",
|
|
|
|
argv[i]);
|
|
|
|
if (git_config_rename_section(section, NULL) < 0)
|
|
|
|
warning("Update of config-file failed");
|
|
|
|
}
|
2006-10-23 21:27:45 +00:00
|
|
|
}
|
|
|
|
|
Avoid unnecessary "if-before-free" tests.
This change removes all obvious useless if-before-free tests.
E.g., it replaces code like this:
if (some_expression)
free (some_expression);
with the now-equivalent:
free (some_expression);
It is equivalent not just because POSIX has required free(NULL)
to work for a long time, but simply because it has worked for
so long that no reasonable porting target fails the test.
Here's some evidence from nearly 1.5 years ago:
http://www.winehq.org/pipermail/wine-patches/2006-October/031544.html
FYI, the change below was prepared by running the following:
git ls-files -z | xargs -0 \
perl -0x3b -pi -e \
's/\bif\s*\(\s*(\S+?)(?:\s*!=\s*NULL)?\s*\)\s+(free\s*\(\s*\1\s*\))/$2/s'
Note however, that it doesn't handle brace-enclosed blocks like
"if (x) { free (x); }". But that's ok, since there were none like
that in git sources.
Beware: if you do use the above snippet, note that it can
produce syntactically invalid C code. That happens when the
affected "if"-statement has a matching "else".
E.g., it would transform this
if (x)
free (x);
else
foo ();
into this:
free (x);
else
foo ();
There were none of those here, either.
If you're interested in automating detection of the useless
tests, you might like the useless-if-before-free script in gnulib:
[it *does* detect brace-enclosed free statements, and has a --name=S
option to make it detect free-like functions with different names]
http://git.sv.gnu.org/gitweb/?p=gnulib.git;a=blob;f=build-aux/useless-if-before-free
Addendum:
Remove one more (in imap-send.c), spotted by Jean-Luc Herren <jlh@gmx.ch>.
Signed-off-by: Jim Meyering <meyering@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-31 17:26:32 +00:00
|
|
|
free(name);
|
2006-12-18 22:42:16 +00:00
|
|
|
|
|
|
|
return(ret);
|
2006-10-23 21:27:45 +00:00
|
|
|
}
|
|
|
|
|
2006-11-21 19:31:24 +00:00
|
|
|
struct ref_item {
|
|
|
|
char *name;
|
|
|
|
unsigned int kind;
|
2008-07-23 22:13:41 +00:00
|
|
|
struct commit *commit;
|
2006-11-21 19:31:24 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ref_list {
|
2008-07-23 22:13:41 +00:00
|
|
|
struct rev_info revs;
|
2006-11-24 13:45:10 +00:00
|
|
|
int index, alloc, maxwidth;
|
2006-11-21 19:31:24 +00:00
|
|
|
struct ref_item *list;
|
2007-11-07 22:58:09 +00:00
|
|
|
struct commit_list *with_commit;
|
2006-11-21 19:31:24 +00:00
|
|
|
int kinds;
|
|
|
|
};
|
|
|
|
|
2008-07-23 22:13:41 +00:00
|
|
|
static int has_commit(struct commit *commit, struct commit_list *with_commit)
|
2007-11-07 22:58:09 +00:00
|
|
|
{
|
|
|
|
if (!with_commit)
|
|
|
|
return 1;
|
|
|
|
while (with_commit) {
|
|
|
|
struct commit *other;
|
|
|
|
|
|
|
|
other = with_commit->item;
|
|
|
|
with_commit = with_commit->next;
|
|
|
|
if (in_merge_bases(other, &commit, 1))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-11-21 19:31:24 +00:00
|
|
|
static int append_ref(const char *refname, const unsigned char *sha1, int flags, void *cb_data)
|
2006-10-23 21:27:45 +00:00
|
|
|
{
|
2006-11-21 19:31:24 +00:00
|
|
|
struct ref_list *ref_list = (struct ref_list*)(cb_data);
|
|
|
|
struct ref_item *newitem;
|
2008-07-23 22:13:41 +00:00
|
|
|
struct commit *commit;
|
2008-07-23 21:52:47 +00:00
|
|
|
int kind;
|
2006-11-24 13:45:10 +00:00
|
|
|
int len;
|
2006-11-21 19:31:24 +00:00
|
|
|
|
|
|
|
/* Detect kind */
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
if (!prefixcmp(refname, "refs/heads/")) {
|
2006-11-21 19:31:24 +00:00
|
|
|
kind = REF_LOCAL_BRANCH;
|
|
|
|
refname += 11;
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
} else if (!prefixcmp(refname, "refs/remotes/")) {
|
2006-11-21 19:31:24 +00:00
|
|
|
kind = REF_REMOTE_BRANCH;
|
|
|
|
refname += 13;
|
2008-07-23 21:52:47 +00:00
|
|
|
} else
|
|
|
|
return 0;
|
2006-11-21 19:31:24 +00:00
|
|
|
|
2008-07-23 22:13:41 +00:00
|
|
|
commit = lookup_commit_reference_gently(sha1, 1);
|
|
|
|
if (!commit)
|
|
|
|
return error("branch '%s' does not point at a commit", refname);
|
|
|
|
|
2007-11-07 22:58:09 +00:00
|
|
|
/* Filter with with_commit if specified */
|
2008-07-23 22:13:41 +00:00
|
|
|
if (!has_commit(commit, ref_list->with_commit))
|
2007-11-07 22:58:09 +00:00
|
|
|
return 0;
|
|
|
|
|
2006-11-21 19:31:24 +00:00
|
|
|
/* Don't add types the caller doesn't want */
|
|
|
|
if ((kind & ref_list->kinds) == 0)
|
|
|
|
return 0;
|
|
|
|
|
2008-07-26 10:27:23 +00:00
|
|
|
if (merge_filter != NO_FILTER)
|
2008-07-23 22:13:41 +00:00
|
|
|
add_pending_object(&ref_list->revs,
|
2008-07-26 10:27:23 +00:00
|
|
|
(struct object *)commit, refname);
|
2008-04-17 20:24:50 +00:00
|
|
|
|
2006-11-21 19:31:24 +00:00
|
|
|
/* Resize buffer */
|
|
|
|
if (ref_list->index >= ref_list->alloc) {
|
|
|
|
ref_list->alloc = alloc_nr(ref_list->alloc);
|
|
|
|
ref_list->list = xrealloc(ref_list->list,
|
|
|
|
ref_list->alloc * sizeof(struct ref_item));
|
2006-10-23 21:27:45 +00:00
|
|
|
}
|
|
|
|
|
2006-11-21 19:31:24 +00:00
|
|
|
/* Record the new item */
|
|
|
|
newitem = &(ref_list->list[ref_list->index++]);
|
|
|
|
newitem->name = xstrdup(refname);
|
|
|
|
newitem->kind = kind;
|
2008-07-23 22:13:41 +00:00
|
|
|
newitem->commit = commit;
|
2006-11-24 13:45:10 +00:00
|
|
|
len = strlen(newitem->name);
|
|
|
|
if (len > ref_list->maxwidth)
|
|
|
|
ref_list->maxwidth = len;
|
2006-10-23 21:27:45 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-11-21 19:31:24 +00:00
|
|
|
static void free_ref_list(struct ref_list *ref_list)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ref_list->index; i++)
|
|
|
|
free(ref_list->list[i].name);
|
|
|
|
free(ref_list->list);
|
|
|
|
}
|
|
|
|
|
2006-10-23 21:27:45 +00:00
|
|
|
static int ref_cmp(const void *r1, const void *r2)
|
|
|
|
{
|
2006-11-21 19:31:24 +00:00
|
|
|
struct ref_item *c1 = (struct ref_item *)(r1);
|
|
|
|
struct ref_item *c2 = (struct ref_item *)(r2);
|
|
|
|
|
|
|
|
if (c1->kind != c2->kind)
|
|
|
|
return c1->kind - c2->kind;
|
|
|
|
return strcmp(c1->name, c2->name);
|
2006-10-23 21:27:45 +00:00
|
|
|
}
|
|
|
|
|
2008-07-02 07:52:41 +00:00
|
|
|
static void fill_tracking_info(char *stat, const char *branch_name)
|
|
|
|
{
|
|
|
|
int ours, theirs;
|
|
|
|
struct branch *branch = branch_get(branch_name);
|
|
|
|
|
2008-07-06 09:54:56 +00:00
|
|
|
if (!stat_tracking_info(branch, &ours, &theirs) || (!ours && !theirs))
|
2008-07-02 07:52:41 +00:00
|
|
|
return;
|
|
|
|
if (!ours)
|
|
|
|
sprintf(stat, "[behind %d] ", theirs);
|
|
|
|
else if (!theirs)
|
|
|
|
sprintf(stat, "[ahead %d] ", ours);
|
|
|
|
else
|
|
|
|
sprintf(stat, "[ahead %d, behind %d] ", ours, theirs);
|
|
|
|
}
|
|
|
|
|
2007-01-03 20:10:09 +00:00
|
|
|
static void print_ref_item(struct ref_item *item, int maxwidth, int verbose,
|
|
|
|
int abbrev, int current)
|
2006-11-24 13:45:10 +00:00
|
|
|
{
|
2007-01-03 20:10:09 +00:00
|
|
|
char c;
|
|
|
|
int color;
|
2008-07-23 22:13:41 +00:00
|
|
|
struct commit *commit = item->commit;
|
|
|
|
|
|
|
|
if (merge_filter != NO_FILTER) {
|
|
|
|
int is_merged = !!(item->commit->object.flags & UNINTERESTING);
|
|
|
|
if (is_merged != (merge_filter == SHOW_MERGED))
|
|
|
|
return;
|
|
|
|
}
|
2006-11-24 13:45:10 +00:00
|
|
|
|
2007-01-03 20:10:09 +00:00
|
|
|
switch (item->kind) {
|
|
|
|
case REF_LOCAL_BRANCH:
|
|
|
|
color = COLOR_BRANCH_LOCAL;
|
|
|
|
break;
|
|
|
|
case REF_REMOTE_BRANCH:
|
|
|
|
color = COLOR_BRANCH_REMOTE;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
color = COLOR_BRANCH_PLAIN;
|
|
|
|
break;
|
|
|
|
}
|
2006-11-24 13:45:10 +00:00
|
|
|
|
2007-01-03 20:10:09 +00:00
|
|
|
c = ' ';
|
|
|
|
if (current) {
|
|
|
|
c = '*';
|
|
|
|
color = COLOR_BRANCH_CURRENT;
|
|
|
|
}
|
2006-11-24 13:45:10 +00:00
|
|
|
|
2007-01-03 20:10:09 +00:00
|
|
|
if (verbose) {
|
2007-09-10 10:35:06 +00:00
|
|
|
struct strbuf subject;
|
2007-06-11 07:34:54 +00:00
|
|
|
const char *sub = " **** invalid ref ****";
|
2008-07-02 07:52:41 +00:00
|
|
|
char stat[128];
|
2007-06-11 07:34:54 +00:00
|
|
|
|
2007-09-10 10:35:06 +00:00
|
|
|
strbuf_init(&subject, 0);
|
2008-07-06 09:54:56 +00:00
|
|
|
stat[0] = '\0';
|
2007-09-10 10:35:06 +00:00
|
|
|
|
2008-07-23 22:13:41 +00:00
|
|
|
commit = item->commit;
|
2007-06-11 07:34:54 +00:00
|
|
|
if (commit && !parse_commit(commit)) {
|
2007-09-10 10:35:06 +00:00
|
|
|
pretty_print_commit(CMIT_FMT_ONELINE, commit,
|
2007-10-31 21:55:17 +00:00
|
|
|
&subject, 0, NULL, NULL, 0, 0);
|
2007-09-10 10:35:06 +00:00
|
|
|
sub = subject.buf;
|
2007-06-11 07:34:54 +00:00
|
|
|
}
|
2008-07-02 07:52:41 +00:00
|
|
|
|
|
|
|
if (item->kind == REF_LOCAL_BRANCH)
|
|
|
|
fill_tracking_info(stat, item->name);
|
|
|
|
|
|
|
|
printf("%c %s%-*s%s %s %s%s\n", c, branch_get_color(color),
|
2007-01-03 20:10:09 +00:00
|
|
|
maxwidth, item->name,
|
|
|
|
branch_get_color(COLOR_BRANCH_RESET),
|
2008-07-23 22:13:41 +00:00
|
|
|
find_unique_abbrev(item->commit->object.sha1, abbrev),
|
2008-07-02 07:52:41 +00:00
|
|
|
stat, sub);
|
2007-09-10 10:35:06 +00:00
|
|
|
strbuf_release(&subject);
|
2007-01-03 20:10:09 +00:00
|
|
|
} else {
|
|
|
|
printf("%c %s%s%s\n", c, branch_get_color(color), item->name,
|
|
|
|
branch_get_color(COLOR_BRANCH_RESET));
|
|
|
|
}
|
2006-11-24 13:45:10 +00:00
|
|
|
}
|
|
|
|
|
2007-11-07 22:58:09 +00:00
|
|
|
static void print_ref_list(int kinds, int detached, int verbose, int abbrev, struct commit_list *with_commit)
|
2006-10-23 21:27:45 +00:00
|
|
|
{
|
|
|
|
int i;
|
2006-11-21 19:31:24 +00:00
|
|
|
struct ref_list ref_list;
|
2008-07-23 22:13:41 +00:00
|
|
|
struct commit *head_commit = lookup_commit_reference_gently(head_sha1, 1);
|
2006-10-23 21:27:45 +00:00
|
|
|
|
2006-11-21 19:31:24 +00:00
|
|
|
memset(&ref_list, 0, sizeof(ref_list));
|
|
|
|
ref_list.kinds = kinds;
|
2007-11-07 22:58:09 +00:00
|
|
|
ref_list.with_commit = with_commit;
|
2008-07-23 22:13:41 +00:00
|
|
|
if (merge_filter != NO_FILTER)
|
|
|
|
init_revisions(&ref_list.revs, NULL);
|
2006-11-21 19:31:24 +00:00
|
|
|
for_each_ref(append_ref, &ref_list);
|
2008-07-23 22:13:41 +00:00
|
|
|
if (merge_filter != NO_FILTER) {
|
|
|
|
struct commit *filter;
|
|
|
|
filter = lookup_commit_reference_gently(merge_filter_ref, 0);
|
|
|
|
filter->object.flags |= UNINTERESTING;
|
|
|
|
add_pending_object(&ref_list.revs,
|
|
|
|
(struct object *) filter, "");
|
|
|
|
ref_list.revs.limited = 1;
|
|
|
|
prepare_revision_walk(&ref_list.revs);
|
|
|
|
}
|
2006-10-23 21:27:45 +00:00
|
|
|
|
2006-11-21 19:31:24 +00:00
|
|
|
qsort(ref_list.list, ref_list.index, sizeof(struct ref_item), ref_cmp);
|
2006-10-23 21:27:45 +00:00
|
|
|
|
2007-01-03 20:10:10 +00:00
|
|
|
detached = (detached && (kinds & REF_LOCAL_BRANCH));
|
2008-07-23 22:13:41 +00:00
|
|
|
if (detached && head_commit && has_commit(head_commit, with_commit)) {
|
2007-01-03 20:10:10 +00:00
|
|
|
struct ref_item item;
|
2007-03-07 01:44:17 +00:00
|
|
|
item.name = xstrdup("(no branch)");
|
2007-01-03 20:10:10 +00:00
|
|
|
item.kind = REF_LOCAL_BRANCH;
|
2008-07-23 22:13:41 +00:00
|
|
|
item.commit = head_commit;
|
2007-01-03 20:10:10 +00:00
|
|
|
if (strlen(item.name) > ref_list.maxwidth)
|
2008-07-23 22:13:41 +00:00
|
|
|
ref_list.maxwidth = strlen(item.name);
|
2007-01-03 20:10:10 +00:00
|
|
|
print_ref_item(&item, ref_list.maxwidth, verbose, abbrev, 1);
|
2007-03-07 01:44:17 +00:00
|
|
|
free(item.name);
|
2007-01-03 20:10:10 +00:00
|
|
|
}
|
|
|
|
|
2006-11-21 19:31:24 +00:00
|
|
|
for (i = 0; i < ref_list.index; i++) {
|
2007-01-03 20:10:10 +00:00
|
|
|
int current = !detached &&
|
|
|
|
(ref_list.list[i].kind == REF_LOCAL_BRANCH) &&
|
2007-01-03 20:10:09 +00:00
|
|
|
!strcmp(ref_list.list[i].name, head);
|
|
|
|
print_ref_item(&ref_list.list[i], ref_list.maxwidth, verbose,
|
|
|
|
abbrev, current);
|
2006-10-23 21:27:45 +00:00
|
|
|
}
|
2006-11-21 19:31:24 +00:00
|
|
|
|
|
|
|
free_ref_list(&ref_list);
|
2006-10-23 21:27:45 +00:00
|
|
|
}
|
|
|
|
|
2006-11-28 14:47:40 +00:00
|
|
|
static void rename_branch(const char *oldname, const char *newname, int force)
|
|
|
|
{
|
2006-11-30 02:16:56 +00:00
|
|
|
char oldref[PATH_MAX], newref[PATH_MAX], logmsg[PATH_MAX*2 + 100];
|
2006-11-28 14:47:40 +00:00
|
|
|
unsigned char sha1[20];
|
2007-04-06 12:13:00 +00:00
|
|
|
char oldsection[PATH_MAX], newsection[PATH_MAX];
|
2006-11-28 14:47:40 +00:00
|
|
|
|
2007-01-02 07:31:08 +00:00
|
|
|
if (!oldname)
|
2007-02-04 04:49:16 +00:00
|
|
|
die("cannot rename the current branch while not on any.");
|
2007-01-02 07:31:08 +00:00
|
|
|
|
2006-11-28 14:47:40 +00:00
|
|
|
if (snprintf(oldref, sizeof(oldref), "refs/heads/%s", oldname) > sizeof(oldref))
|
|
|
|
die("Old branchname too long");
|
|
|
|
|
|
|
|
if (check_ref_format(oldref))
|
|
|
|
die("Invalid branch name: %s", oldref);
|
|
|
|
|
|
|
|
if (snprintf(newref, sizeof(newref), "refs/heads/%s", newname) > sizeof(newref))
|
|
|
|
die("New branchname too long");
|
|
|
|
|
|
|
|
if (check_ref_format(newref))
|
|
|
|
die("Invalid branch name: %s", newref);
|
|
|
|
|
|
|
|
if (resolve_ref(newref, sha1, 1, NULL) && !force)
|
|
|
|
die("A branch named '%s' already exists.", newname);
|
|
|
|
|
2006-11-30 02:16:56 +00:00
|
|
|
snprintf(logmsg, sizeof(logmsg), "Branch: renamed %s to %s",
|
|
|
|
oldref, newref);
|
|
|
|
|
|
|
|
if (rename_ref(oldref, newref, logmsg))
|
2006-11-28 14:47:40 +00:00
|
|
|
die("Branch rename failed");
|
|
|
|
|
2007-01-26 22:26:10 +00:00
|
|
|
/* no need to pass logmsg here as HEAD didn't really move */
|
|
|
|
if (!strcmp(oldname, head) && create_symref("HEAD", newref, NULL))
|
2006-11-28 14:47:40 +00:00
|
|
|
die("Branch renamed to %s, but HEAD is not updated!", newname);
|
2007-04-06 12:13:00 +00:00
|
|
|
|
|
|
|
snprintf(oldsection, sizeof(oldsection), "branch.%s", oldref + 11);
|
|
|
|
snprintf(newsection, sizeof(newsection), "branch.%s", newref + 11);
|
|
|
|
if (git_config_rename_section(oldsection, newsection) < 0)
|
|
|
|
die("Branch is renamed, but update of config-file failed");
|
2006-11-28 14:47:40 +00:00
|
|
|
}
|
|
|
|
|
2007-11-07 22:58:09 +00:00
|
|
|
static int opt_parse_with_commit(const struct option *opt, const char *arg, int unset)
|
|
|
|
{
|
|
|
|
unsigned char sha1[20];
|
|
|
|
struct commit *commit;
|
|
|
|
|
|
|
|
if (!arg)
|
|
|
|
return -1;
|
|
|
|
if (get_sha1(arg, sha1))
|
|
|
|
die("malformed object name %s", arg);
|
|
|
|
commit = lookup_commit_reference(sha1);
|
|
|
|
if (!commit)
|
|
|
|
die("no such commit %s", arg);
|
|
|
|
commit_list_insert(commit, opt->value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-09 00:55:47 +00:00
|
|
|
static int opt_parse_merge_filter(const struct option *opt, const char *arg, int unset)
|
|
|
|
{
|
|
|
|
merge_filter = ((opt->long_name[0] == 'n')
|
|
|
|
? SHOW_NOT_MERGED
|
|
|
|
: SHOW_MERGED);
|
|
|
|
if (unset)
|
|
|
|
merge_filter = SHOW_NOT_MERGED; /* b/c for --no-merged */
|
|
|
|
if (!arg)
|
|
|
|
arg = "HEAD";
|
|
|
|
if (get_sha1(arg, merge_filter_ref))
|
|
|
|
die("malformed object name %s", arg);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-23 21:27:45 +00:00
|
|
|
int cmd_branch(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2007-11-07 10:20:28 +00:00
|
|
|
int delete = 0, rename = 0, force_create = 0;
|
2007-01-03 20:10:10 +00:00
|
|
|
int verbose = 0, abbrev = DEFAULT_ABBREV, detached = 0;
|
2008-02-19 16:24:37 +00:00
|
|
|
int reflog = 0;
|
|
|
|
enum branch_track track;
|
2007-11-07 10:20:28 +00:00
|
|
|
int kinds = REF_LOCAL_BRANCH;
|
2007-11-07 22:58:09 +00:00
|
|
|
struct commit_list *with_commit = NULL;
|
2007-10-07 16:26:21 +00:00
|
|
|
|
|
|
|
struct option options[] = {
|
|
|
|
OPT_GROUP("Generic options"),
|
|
|
|
OPT__VERBOSE(&verbose),
|
2008-02-19 16:24:37 +00:00
|
|
|
OPT_SET_INT( 0 , "track", &track, "set up tracking mode (see git-pull(1))",
|
|
|
|
BRANCH_TRACK_EXPLICIT),
|
2007-10-07 16:26:21 +00:00
|
|
|
OPT_BOOLEAN( 0 , "color", &branch_use_color, "use colored output"),
|
2007-11-07 10:20:28 +00:00
|
|
|
OPT_SET_INT('r', NULL, &kinds, "act on remote-tracking branches",
|
|
|
|
REF_REMOTE_BRANCH),
|
2008-07-09 00:31:51 +00:00
|
|
|
{
|
|
|
|
OPTION_CALLBACK, 0, "contains", &with_commit, "commit",
|
|
|
|
"print only branches that contain the commit",
|
|
|
|
PARSE_OPT_LASTARG_DEFAULT,
|
|
|
|
opt_parse_with_commit, (intptr_t)"HEAD",
|
|
|
|
},
|
2007-11-07 22:58:09 +00:00
|
|
|
{
|
|
|
|
OPTION_CALLBACK, 0, "with", &with_commit, "commit",
|
|
|
|
"print only branches that contain the commit",
|
2008-07-09 00:31:51 +00:00
|
|
|
PARSE_OPT_HIDDEN | PARSE_OPT_LASTARG_DEFAULT,
|
|
|
|
opt_parse_with_commit, (intptr_t) "HEAD",
|
2007-11-07 22:58:09 +00:00
|
|
|
},
|
2007-10-07 16:26:21 +00:00
|
|
|
OPT__ABBREV(&abbrev),
|
|
|
|
|
|
|
|
OPT_GROUP("Specific git-branch actions:"),
|
2007-11-07 10:20:28 +00:00
|
|
|
OPT_SET_INT('a', NULL, &kinds, "list both remote-tracking and local branches",
|
|
|
|
REF_REMOTE_BRANCH | REF_LOCAL_BRANCH),
|
|
|
|
OPT_BIT('d', NULL, &delete, "delete fully merged branch", 1),
|
|
|
|
OPT_BIT('D', NULL, &delete, "delete branch (even if not merged)", 2),
|
|
|
|
OPT_BIT('m', NULL, &rename, "move/rename a branch and its reflog", 1),
|
|
|
|
OPT_BIT('M', NULL, &rename, "move/rename a branch, even if target exists", 2),
|
|
|
|
OPT_BOOLEAN('l', NULL, &reflog, "create the branch's reflog"),
|
|
|
|
OPT_BOOLEAN('f', NULL, &force_create, "force creation (when already exists)"),
|
2008-07-09 00:55:47 +00:00
|
|
|
{
|
|
|
|
OPTION_CALLBACK, 0, "no-merged", &merge_filter_ref,
|
|
|
|
"commit", "print only not merged branches",
|
|
|
|
PARSE_OPT_LASTARG_DEFAULT | PARSE_OPT_NONEG,
|
|
|
|
opt_parse_merge_filter, (intptr_t) "HEAD",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
OPTION_CALLBACK, 0, "merged", &merge_filter_ref,
|
|
|
|
"commit", "print only merged branches",
|
|
|
|
PARSE_OPT_LASTARG_DEFAULT | PARSE_OPT_NONEG,
|
|
|
|
opt_parse_merge_filter, (intptr_t) "HEAD",
|
|
|
|
},
|
2007-10-07 16:26:21 +00:00
|
|
|
OPT_END(),
|
|
|
|
};
|
2006-10-23 21:27:45 +00:00
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
git_config(git_branch_config, NULL);
|
2008-02-18 07:26:03 +00:00
|
|
|
|
|
|
|
if (branch_use_color == -1)
|
|
|
|
branch_use_color = git_use_color_default;
|
|
|
|
|
2008-02-19 16:24:37 +00:00
|
|
|
track = git_branch_track;
|
2006-11-28 14:47:40 +00:00
|
|
|
|
2007-05-20 12:19:17 +00:00
|
|
|
head = resolve_ref("HEAD", head_sha1, 0, NULL);
|
2006-10-23 21:27:45 +00:00
|
|
|
if (!head)
|
|
|
|
die("Failed to resolve HEAD as a valid ref.");
|
2007-05-20 12:19:17 +00:00
|
|
|
head = xstrdup(head);
|
2007-01-03 20:10:10 +00:00
|
|
|
if (!strcmp(head, "HEAD")) {
|
|
|
|
detached = 1;
|
2007-10-07 16:26:21 +00:00
|
|
|
} else {
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
if (prefixcmp(head, "refs/heads/"))
|
2007-01-03 20:10:10 +00:00
|
|
|
die("HEAD not found below refs/heads!");
|
|
|
|
head += 11;
|
|
|
|
}
|
2008-07-09 00:55:47 +00:00
|
|
|
hashcpy(merge_filter_ref, head_sha1);
|
|
|
|
|
|
|
|
argc = parse_options(argc, argv, options, builtin_branch_usage, 0);
|
|
|
|
if (!!delete + !!rename + !!force_create > 1)
|
|
|
|
usage_with_options(builtin_branch_usage, options);
|
2006-10-23 21:27:45 +00:00
|
|
|
|
|
|
|
if (delete)
|
2007-11-07 10:20:28 +00:00
|
|
|
return delete_branches(argc, argv, delete > 1, kinds);
|
2007-10-07 16:26:21 +00:00
|
|
|
else if (argc == 0)
|
2007-11-07 22:58:09 +00:00
|
|
|
print_ref_list(kinds, detached, verbose, abbrev, with_commit);
|
2007-10-07 16:26:21 +00:00
|
|
|
else if (rename && (argc == 1))
|
2007-11-07 10:20:28 +00:00
|
|
|
rename_branch(head, argv[0], rename > 1);
|
2007-10-07 16:26:21 +00:00
|
|
|
else if (rename && (argc == 2))
|
2007-11-07 10:20:28 +00:00
|
|
|
rename_branch(argv[0], argv[1], rename > 1);
|
2007-10-07 16:26:21 +00:00
|
|
|
else if (argc <= 2)
|
2008-02-07 16:40:08 +00:00
|
|
|
create_branch(head, argv[0], (argc == 2) ? argv[1] : head,
|
2007-03-08 21:59:54 +00:00
|
|
|
force_create, reflog, track);
|
2006-10-23 21:27:45 +00:00
|
|
|
else
|
2007-10-07 16:26:21 +00:00
|
|
|
usage_with_options(builtin_branch_usage, options);
|
2006-10-23 21:27:45 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|