2006-10-23 21:27:45 +00:00
|
|
|
|
/*
|
|
|
|
|
* Builtin "git branch"
|
|
|
|
|
*
|
|
|
|
|
* Copyright (c) 2006 Kristian H<EFBFBD>gsberg <krh@redhat.com>
|
|
|
|
|
* 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"
|
|
|
|
|
|
|
|
|
|
static const char builtin_branch_usage[] =
|
2007-03-08 09:58:35 +00:00
|
|
|
|
"git-branch [-r] (-d | -D) <branchname> | [--track | --no-track] [-l] [-f] <branchname> [<start-point>] | (-m | -M) [<oldbranch>] <newbranch> | [--color | --no-color] [-r | -a] [-v [--abbrev=<length> | --no-abbrev]]";
|
2006-10-23 21:27:45 +00:00
|
|
|
|
|
2006-12-18 07:58:16 +00:00
|
|
|
|
#define REF_UNKNOWN_TYPE 0x00
|
|
|
|
|
#define REF_LOCAL_BRANCH 0x01
|
|
|
|
|
#define REF_REMOTE_BRANCH 0x02
|
|
|
|
|
#define REF_TAG 0x04
|
2006-10-23 21:27:45 +00:00
|
|
|
|
|
|
|
|
|
static const char *head;
|
|
|
|
|
static unsigned char head_sha1[20];
|
|
|
|
|
|
2007-03-08 09:58:35 +00:00
|
|
|
|
static int branch_track_remotes;
|
|
|
|
|
|
2006-12-12 06:41:52 +00:00
|
|
|
|
static int branch_use_color;
|
|
|
|
|
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,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_branch_config(const char *var, const char *value)
|
|
|
|
|
{
|
|
|
|
|
if (!strcmp(var, "color.branch")) {
|
|
|
|
|
branch_use_color = git_config_colorbool(var, value);
|
|
|
|
|
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);
|
|
|
|
|
color_parse(value, var, branch_colors[slot]);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2007-03-08 09:58:35 +00:00
|
|
|
|
if (!strcmp(var, "branch.autosetupmerge"))
|
|
|
|
|
branch_track_remotes = git_config_bool(var, value);
|
|
|
|
|
|
2006-12-12 06:41:52 +00:00
|
|
|
|
return git_default_config(var, value);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const char *branch_get_color(enum color_branch ix)
|
|
|
|
|
{
|
|
|
|
|
if (branch_use_color)
|
|
|
|
|
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;
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (name)
|
|
|
|
|
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)) {
|
2006-12-18 22:42:16 +00:00
|
|
|
|
error("The branch '%s' is not a strict subset of "
|
|
|
|
|
"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;
|
|
|
|
|
} else
|
2006-12-18 07:58:16 +00:00
|
|
|
|
printf("Deleted %sbranch %s.\n", remote, argv[i]);
|
2006-10-23 21:27:45 +00:00
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-18 22:42:16 +00:00
|
|
|
|
if (name)
|
|
|
|
|
free(name);
|
|
|
|
|
|
|
|
|
|
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;
|
2006-11-24 13:45:10 +00:00
|
|
|
|
unsigned char sha1[20];
|
2006-11-21 19:31:24 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct ref_list {
|
2006-11-24 13:45:10 +00:00
|
|
|
|
int index, alloc, maxwidth;
|
2006-11-21 19:31:24 +00:00
|
|
|
|
struct ref_item *list;
|
|
|
|
|
int kinds;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
int kind = REF_UNKNOWN_TYPE;
|
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;
|
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/tags/")) {
|
2006-11-21 19:31:24 +00:00
|
|
|
|
kind = REF_TAG;
|
|
|
|
|
refname += 10;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Don't add types the caller doesn't want */
|
|
|
|
|
if ((kind & ref_list->kinds) == 0)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* 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;
|
2006-11-24 13:45:10 +00:00
|
|
|
|
hashcpy(newitem->sha1, sha1);
|
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|
|
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;
|
2006-11-24 13:45:10 +00:00
|
|
|
|
struct commit *commit;
|
|
|
|
|
char subject[256];
|
|
|
|
|
|
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) {
|
|
|
|
|
commit = lookup_commit(item->sha1);
|
|
|
|
|
if (commit && !parse_commit(commit))
|
|
|
|
|
pretty_print_commit(CMIT_FMT_ONELINE, commit, ~0,
|
|
|
|
|
subject, sizeof(subject), 0,
|
|
|
|
|
NULL, NULL, 0);
|
|
|
|
|
else
|
|
|
|
|
strcpy(subject, " **** invalid ref ****");
|
|
|
|
|
printf("%c %s%-*s%s %s %s\n", c, branch_get_color(color),
|
|
|
|
|
maxwidth, item->name,
|
|
|
|
|
branch_get_color(COLOR_BRANCH_RESET),
|
|
|
|
|
find_unique_abbrev(item->sha1, abbrev), subject);
|
|
|
|
|
} 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-01-03 20:10:10 +00:00
|
|
|
|
static void print_ref_list(int kinds, int detached, int verbose, int abbrev)
|
2006-10-23 21:27:45 +00:00
|
|
|
|
{
|
|
|
|
|
int i;
|
2006-11-21 19:31:24 +00:00
|
|
|
|
struct ref_list ref_list;
|
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;
|
|
|
|
|
for_each_ref(append_ref, &ref_list);
|
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));
|
|
|
|
|
if (detached) {
|
|
|
|
|
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;
|
|
|
|
|
hashcpy(item.sha1, head_sha1);
|
|
|
|
|
if (strlen(item.name) > ref_list.maxwidth)
|
|
|
|
|
ref_list.maxwidth = strlen(item.name);
|
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|
|
2007-03-08 09:58:35 +00:00
|
|
|
|
static char *config_repo;
|
|
|
|
|
static char *config_remote;
|
|
|
|
|
static const char *start_ref;
|
|
|
|
|
static int start_len;
|
|
|
|
|
static int base_len;
|
|
|
|
|
|
|
|
|
|
static int get_remote_branch_name(const char *value)
|
|
|
|
|
{
|
|
|
|
|
const char *colon;
|
|
|
|
|
const char *end;
|
|
|
|
|
|
|
|
|
|
if (*value == '+')
|
|
|
|
|
value++;
|
|
|
|
|
|
|
|
|
|
colon = strchr(value, ':');
|
|
|
|
|
if (!colon)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
end = value + strlen(value);
|
|
|
|
|
|
|
|
|
|
/* Try an exact match first. */
|
|
|
|
|
if (!strcmp(colon + 1, start_ref)) {
|
|
|
|
|
/* Truncate the value before the colon. */
|
|
|
|
|
nfasprintf(&config_repo, "%.*s", colon - value, value);
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Try with a wildcard match now. */
|
|
|
|
|
if (end - value > 2 && end[-2] == '/' && end[-1] == '*' &&
|
|
|
|
|
colon - value > 2 && colon[-2] == '/' && colon[-1] == '*' &&
|
|
|
|
|
(end - 2) - (colon + 1) == base_len &&
|
|
|
|
|
!strncmp(colon + 1, start_ref, base_len)) {
|
|
|
|
|
/* Replace the star with the remote branch name. */
|
|
|
|
|
nfasprintf(&config_repo, "%.*s%s",
|
|
|
|
|
(colon - 2) - value, value,
|
|
|
|
|
start_ref + base_len);
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int get_remote_config(const char *key, const char *value)
|
|
|
|
|
{
|
|
|
|
|
const char *var;
|
|
|
|
|
if (prefixcmp(key, "remote."))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
var = strrchr(key, '.');
|
|
|
|
|
if (var == key + 6)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (!strcmp(var, ".fetch") && get_remote_branch_name(value))
|
|
|
|
|
nfasprintf(&config_remote, "%.*s", var - (key + 7), key + 7);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
git-fetch, git-branch: Support local --track via a special remote '.'
This patch adds support for a dummy remote '.' to avoid having
to declare a fake remote like
[remote "local"]
url = .
fetch = refs/heads/*:refs/heads/*
Such a builtin remote simplifies the operation of "git-fetch",
which will populate FETCH_HEAD but will not pretend that two
repositories are in use, will not create a thin pack, and will
not perform any useless remapping of names. The speed
improvement is around 20%, and it should improve more if
"git-fetch" is converted to a builtin.
To this end, git-parse-remote is grown with a new kind of
remote, 'builtin'. In git-fetch.sh, we treat the builtin remote
specially in that it needs no pack/store operations. In fact,
doing git-fetch on a builtin remote will simply populate
FETCH_HEAD appropriately.
The patch also improves of the --track/--no-track support,
extending it so that branch.<name>.remote items referring '.'
can be created. Finally, it fixes a typo in git-checkout.sh.
Signed-off-by: Paolo Bonzini <bonzini@gnu.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-03-15 08:23:20 +00:00
|
|
|
|
static void set_branch_merge(const char *name, const char *config_remote,
|
|
|
|
|
const char *config_repo)
|
2007-03-08 09:58:35 +00:00
|
|
|
|
{
|
|
|
|
|
char key[1024];
|
git-fetch, git-branch: Support local --track via a special remote '.'
This patch adds support for a dummy remote '.' to avoid having
to declare a fake remote like
[remote "local"]
url = .
fetch = refs/heads/*:refs/heads/*
Such a builtin remote simplifies the operation of "git-fetch",
which will populate FETCH_HEAD but will not pretend that two
repositories are in use, will not create a thin pack, and will
not perform any useless remapping of names. The speed
improvement is around 20%, and it should improve more if
"git-fetch" is converted to a builtin.
To this end, git-parse-remote is grown with a new kind of
remote, 'builtin'. In git-fetch.sh, we treat the builtin remote
specially in that it needs no pack/store operations. In fact,
doing git-fetch on a builtin remote will simply populate
FETCH_HEAD appropriately.
The patch also improves of the --track/--no-track support,
extending it so that branch.<name>.remote items referring '.'
can be created. Finally, it fixes a typo in git-checkout.sh.
Signed-off-by: Paolo Bonzini <bonzini@gnu.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-03-15 08:23:20 +00:00
|
|
|
|
if (sizeof(key) <=
|
|
|
|
|
snprintf(key, sizeof(key), "branch.%s.remote", name))
|
|
|
|
|
die("what a long branch name you have!");
|
|
|
|
|
git_config_set(key, config_remote);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We do not have to check if we have enough space for
|
|
|
|
|
* the 'merge' key, since it's shorter than the
|
|
|
|
|
* previous 'remote' key, which we already checked.
|
|
|
|
|
*/
|
|
|
|
|
snprintf(key, sizeof(key), "branch.%s.merge", name);
|
|
|
|
|
git_config_set(key, config_repo);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void set_branch_defaults(const char *name, const char *real_ref)
|
|
|
|
|
{
|
2007-03-08 09:58:35 +00:00
|
|
|
|
const char *slash = strrchr(real_ref, '/');
|
|
|
|
|
|
|
|
|
|
if (!slash)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
start_ref = real_ref;
|
|
|
|
|
start_len = strlen(real_ref);
|
|
|
|
|
base_len = slash - real_ref;
|
|
|
|
|
git_config(get_remote_config);
|
git-fetch, git-branch: Support local --track via a special remote '.'
This patch adds support for a dummy remote '.' to avoid having
to declare a fake remote like
[remote "local"]
url = .
fetch = refs/heads/*:refs/heads/*
Such a builtin remote simplifies the operation of "git-fetch",
which will populate FETCH_HEAD but will not pretend that two
repositories are in use, will not create a thin pack, and will
not perform any useless remapping of names. The speed
improvement is around 20%, and it should improve more if
"git-fetch" is converted to a builtin.
To this end, git-parse-remote is grown with a new kind of
remote, 'builtin'. In git-fetch.sh, we treat the builtin remote
specially in that it needs no pack/store operations. In fact,
doing git-fetch on a builtin remote will simply populate
FETCH_HEAD appropriately.
The patch also improves of the --track/--no-track support,
extending it so that branch.<name>.remote items referring '.'
can be created. Finally, it fixes a typo in git-checkout.sh.
Signed-off-by: Paolo Bonzini <bonzini@gnu.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-03-15 08:23:20 +00:00
|
|
|
|
if (!config_repo && !config_remote &&
|
|
|
|
|
!prefixcmp(real_ref, "refs/heads/")) {
|
|
|
|
|
set_branch_merge(name, ".", real_ref);
|
|
|
|
|
printf("Branch %s set up to track local branch %s.\n",
|
|
|
|
|
name, real_ref);
|
|
|
|
|
}
|
2007-03-08 09:58:35 +00:00
|
|
|
|
|
|
|
|
|
if (config_repo && config_remote) {
|
git-fetch, git-branch: Support local --track via a special remote '.'
This patch adds support for a dummy remote '.' to avoid having
to declare a fake remote like
[remote "local"]
url = .
fetch = refs/heads/*:refs/heads/*
Such a builtin remote simplifies the operation of "git-fetch",
which will populate FETCH_HEAD but will not pretend that two
repositories are in use, will not create a thin pack, and will
not perform any useless remapping of names. The speed
improvement is around 20%, and it should improve more if
"git-fetch" is converted to a builtin.
To this end, git-parse-remote is grown with a new kind of
remote, 'builtin'. In git-fetch.sh, we treat the builtin remote
specially in that it needs no pack/store operations. In fact,
doing git-fetch on a builtin remote will simply populate
FETCH_HEAD appropriately.
The patch also improves of the --track/--no-track support,
extending it so that branch.<name>.remote items referring '.'
can be created. Finally, it fixes a typo in git-checkout.sh.
Signed-off-by: Paolo Bonzini <bonzini@gnu.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-03-15 08:23:20 +00:00
|
|
|
|
set_branch_merge(name, config_remote, config_repo);
|
2007-03-08 09:58:35 +00:00
|
|
|
|
printf("Branch %s set up to track remote branch %s.\n",
|
|
|
|
|
name, real_ref);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (config_repo)
|
|
|
|
|
free(config_repo);
|
|
|
|
|
if (config_remote)
|
|
|
|
|
free(config_remote);
|
|
|
|
|
}
|
|
|
|
|
|
2007-01-02 07:31:08 +00:00
|
|
|
|
static void create_branch(const char *name, const char *start_name,
|
2007-03-08 09:58:35 +00:00
|
|
|
|
int force, int reflog, int track)
|
2006-10-23 21:27:45 +00:00
|
|
|
|
{
|
|
|
|
|
struct ref_lock *lock;
|
|
|
|
|
struct commit *commit;
|
|
|
|
|
unsigned char sha1[20];
|
2007-03-08 09:58:35 +00:00
|
|
|
|
char *real_ref, ref[PATH_MAX], msg[PATH_MAX + 20];
|
2007-01-19 19:51:29 +00:00
|
|
|
|
int forcing = 0;
|
2006-10-23 21:27:45 +00:00
|
|
|
|
|
|
|
|
|
snprintf(ref, sizeof ref, "refs/heads/%s", name);
|
|
|
|
|
if (check_ref_format(ref))
|
|
|
|
|
die("'%s' is not a valid branch name.", name);
|
|
|
|
|
|
|
|
|
|
if (resolve_ref(ref, sha1, 1, NULL)) {
|
|
|
|
|
if (!force)
|
|
|
|
|
die("A branch named '%s' already exists.", name);
|
2007-01-20 18:51:37 +00:00
|
|
|
|
else if (!is_bare_repository() && !strcmp(head, name))
|
2006-10-23 21:27:45 +00:00
|
|
|
|
die("Cannot force update the current branch.");
|
2007-01-19 19:51:29 +00:00
|
|
|
|
forcing = 1;
|
2006-10-23 21:27:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
2007-03-08 21:59:54 +00:00
|
|
|
|
real_ref = NULL;
|
|
|
|
|
if (get_sha1(start_name, sha1))
|
|
|
|
|
die("Not a valid object name: '%s'.", start_name);
|
|
|
|
|
|
|
|
|
|
switch (dwim_ref(start_name, strlen(start_name), sha1, &real_ref)) {
|
|
|
|
|
case 0:
|
|
|
|
|
/* Not branching from any existing branch */
|
2007-03-08 09:58:35 +00:00
|
|
|
|
real_ref = NULL;
|
2007-03-08 21:59:54 +00:00
|
|
|
|
break;
|
|
|
|
|
case 1:
|
|
|
|
|
/* Unique completion -- good */
|
|
|
|
|
break;
|
|
|
|
|
default:
|
2007-03-08 09:58:35 +00:00
|
|
|
|
die("Ambiguous object name: '%s'.", start_name);
|
2007-03-08 21:59:54 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2007-01-02 07:31:08 +00:00
|
|
|
|
|
|
|
|
|
if ((commit = lookup_commit_reference(sha1)) == NULL)
|
|
|
|
|
die("Not a valid branch point: '%s'.", start_name);
|
2006-10-23 21:27:45 +00:00
|
|
|
|
hashcpy(sha1, commit->object.sha1);
|
|
|
|
|
|
|
|
|
|
lock = lock_any_ref_for_update(ref, NULL);
|
|
|
|
|
if (!lock)
|
|
|
|
|
die("Failed to lock ref for update: %s.", strerror(errno));
|
|
|
|
|
|
2007-01-19 19:51:29 +00:00
|
|
|
|
if (reflog)
|
2006-10-23 21:27:45 +00:00
|
|
|
|
log_all_ref_updates = 1;
|
2007-01-19 19:51:29 +00:00
|
|
|
|
|
|
|
|
|
if (forcing)
|
|
|
|
|
snprintf(msg, sizeof msg, "branch: Reset from %s",
|
|
|
|
|
start_name);
|
|
|
|
|
else
|
2007-01-02 07:31:08 +00:00
|
|
|
|
snprintf(msg, sizeof msg, "branch: Created from %s",
|
|
|
|
|
start_name);
|
2006-10-23 21:27:45 +00:00
|
|
|
|
|
2007-03-08 09:58:35 +00:00
|
|
|
|
/* When branching off a remote branch, set up so that git-pull
|
|
|
|
|
automatically merges from there. So far, this is only done for
|
|
|
|
|
remotes registered via .git/config. */
|
|
|
|
|
if (real_ref && track)
|
|
|
|
|
set_branch_defaults(name, real_ref);
|
|
|
|
|
|
2006-10-23 21:27:45 +00:00
|
|
|
|
if (write_ref_sha1(lock, sha1, msg) < 0)
|
|
|
|
|
die("Failed to write ref: %s.", strerror(errno));
|
2007-03-08 09:58:35 +00:00
|
|
|
|
|
|
|
|
|
if (real_ref)
|
|
|
|
|
free(real_ref);
|
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-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);
|
|
|
|
|
}
|
|
|
|
|
|
2006-10-23 21:27:45 +00:00
|
|
|
|
int cmd_branch(int argc, const char **argv, const char *prefix)
|
|
|
|
|
{
|
2006-11-21 19:31:24 +00:00
|
|
|
|
int delete = 0, force_delete = 0, force_create = 0;
|
2006-11-28 14:47:40 +00:00
|
|
|
|
int rename = 0, force_rename = 0;
|
2007-01-03 20:10:10 +00:00
|
|
|
|
int verbose = 0, abbrev = DEFAULT_ABBREV, detached = 0;
|
2007-03-08 09:58:35 +00:00
|
|
|
|
int reflog = 0, track;
|
2006-11-21 19:31:24 +00:00
|
|
|
|
int kinds = REF_LOCAL_BRANCH;
|
2006-10-23 21:27:45 +00:00
|
|
|
|
int i;
|
|
|
|
|
|
2006-12-12 06:41:52 +00:00
|
|
|
|
git_config(git_branch_config);
|
2007-03-08 09:58:35 +00:00
|
|
|
|
track = branch_track_remotes;
|
2006-10-23 21:27:45 +00:00
|
|
|
|
|
|
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
|
const char *arg = argv[i];
|
|
|
|
|
|
|
|
|
|
if (arg[0] != '-')
|
|
|
|
|
break;
|
|
|
|
|
if (!strcmp(arg, "--")) {
|
|
|
|
|
i++;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2007-03-08 09:58:35 +00:00
|
|
|
|
if (!strcmp(arg, "--track")) {
|
|
|
|
|
track = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (!strcmp(arg, "--no-track")) {
|
|
|
|
|
track = 0;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2006-10-23 21:27:45 +00:00
|
|
|
|
if (!strcmp(arg, "-d")) {
|
|
|
|
|
delete = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (!strcmp(arg, "-D")) {
|
|
|
|
|
delete = 1;
|
|
|
|
|
force_delete = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (!strcmp(arg, "-f")) {
|
|
|
|
|
force_create = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2006-11-28 14:47:40 +00:00
|
|
|
|
if (!strcmp(arg, "-m")) {
|
|
|
|
|
rename = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (!strcmp(arg, "-M")) {
|
|
|
|
|
rename = 1;
|
|
|
|
|
force_rename = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2006-10-23 21:27:45 +00:00
|
|
|
|
if (!strcmp(arg, "-r")) {
|
2006-11-21 19:31:24 +00:00
|
|
|
|
kinds = REF_REMOTE_BRANCH;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (!strcmp(arg, "-a")) {
|
|
|
|
|
kinds = REF_REMOTE_BRANCH | REF_LOCAL_BRANCH;
|
2006-10-23 21:27:45 +00:00
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (!strcmp(arg, "-l")) {
|
|
|
|
|
reflog = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2007-03-03 00:31:16 +00:00
|
|
|
|
if (!prefixcmp(arg, "--no-abbrev")) {
|
|
|
|
|
abbrev = 0;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
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(arg, "--abbrev=")) {
|
2007-03-03 00:31:16 +00:00
|
|
|
|
abbrev = strtoul(arg + 9, NULL, 10);
|
|
|
|
|
if (abbrev < MINIMUM_ABBREV)
|
|
|
|
|
abbrev = MINIMUM_ABBREV;
|
|
|
|
|
else if (abbrev > 40)
|
|
|
|
|
abbrev = 40;
|
2006-11-24 13:45:10 +00:00
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (!strcmp(arg, "-v")) {
|
|
|
|
|
verbose = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2006-12-12 06:41:52 +00:00
|
|
|
|
if (!strcmp(arg, "--color")) {
|
|
|
|
|
branch_use_color = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (!strcmp(arg, "--no-color")) {
|
|
|
|
|
branch_use_color = 0;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2006-10-23 21:27:45 +00:00
|
|
|
|
usage(builtin_branch_usage);
|
|
|
|
|
}
|
|
|
|
|
|
2006-11-28 14:47:40 +00:00
|
|
|
|
if ((delete && rename) || (delete && force_create) ||
|
|
|
|
|
(rename && force_create))
|
|
|
|
|
usage(builtin_branch_usage);
|
|
|
|
|
|
2006-10-23 21:27:45 +00:00
|
|
|
|
head = xstrdup(resolve_ref("HEAD", head_sha1, 0, NULL));
|
|
|
|
|
if (!head)
|
|
|
|
|
die("Failed to resolve HEAD as a valid ref.");
|
2007-01-03 20:10:10 +00:00
|
|
|
|
if (!strcmp(head, "HEAD")) {
|
|
|
|
|
detached = 1;
|
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
}
|
2006-10-23 21:27:45 +00:00
|
|
|
|
|
|
|
|
|
if (delete)
|
2006-12-18 22:42:16 +00:00
|
|
|
|
return delete_branches(argc - i, argv + i, force_delete, kinds);
|
2006-10-23 21:27:45 +00:00
|
|
|
|
else if (i == argc)
|
2007-01-03 20:10:10 +00:00
|
|
|
|
print_ref_list(kinds, detached, verbose, abbrev);
|
2006-11-28 14:47:40 +00:00
|
|
|
|
else if (rename && (i == argc - 1))
|
|
|
|
|
rename_branch(head, argv[i], force_rename);
|
|
|
|
|
else if (rename && (i == argc - 2))
|
|
|
|
|
rename_branch(argv[i], argv[i + 1], force_rename);
|
2007-03-08 21:59:54 +00:00
|
|
|
|
else if (i == argc - 1 || i == argc - 2)
|
|
|
|
|
create_branch(argv[i], (i == argc - 2) ? argv[i+1] : head,
|
|
|
|
|
force_create, reflog, track);
|
2006-10-23 21:27:45 +00:00
|
|
|
|
else
|
|
|
|
|
usage(builtin_branch_usage);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|