2005-08-04 05:15:49 +00:00
|
|
|
#include "cache.h"
|
2005-10-14 01:57:40 +00:00
|
|
|
#include "tag.h"
|
2005-08-04 05:15:49 +00:00
|
|
|
#include "commit.h"
|
2005-10-14 01:57:40 +00:00
|
|
|
#include "tree.h"
|
|
|
|
#include "blob.h"
|
2006-04-19 18:56:53 +00:00
|
|
|
#include "tree-walk.h"
|
2006-05-17 09:56:09 +00:00
|
|
|
#include "refs.h"
|
2005-08-04 05:15:49 +00:00
|
|
|
|
|
|
|
static int find_short_object_filename(int len, const char *name, unsigned char *sha1)
|
|
|
|
{
|
2005-10-03 04:40:51 +00:00
|
|
|
struct alternate_object_database *alt;
|
2005-08-04 05:15:49 +00:00
|
|
|
char hex[40];
|
2005-10-03 04:40:51 +00:00
|
|
|
int found = 0;
|
|
|
|
static struct alternate_object_database *fakeent;
|
|
|
|
|
|
|
|
if (!fakeent) {
|
|
|
|
const char *objdir = get_object_directory();
|
|
|
|
int objdir_len = strlen(objdir);
|
|
|
|
int entlen = objdir_len + 43;
|
|
|
|
fakeent = xmalloc(sizeof(*fakeent) + entlen);
|
|
|
|
memcpy(fakeent->base, objdir, objdir_len);
|
|
|
|
fakeent->name = fakeent->base + objdir_len + 1;
|
|
|
|
fakeent->name[-1] = '/';
|
|
|
|
}
|
|
|
|
fakeent->next = alt_odb_list;
|
2005-08-04 05:15:49 +00:00
|
|
|
|
|
|
|
sprintf(hex, "%.2s", name);
|
2005-10-03 04:40:51 +00:00
|
|
|
for (alt = fakeent; alt && found < 2; alt = alt->next) {
|
2005-08-04 05:15:49 +00:00
|
|
|
struct dirent *de;
|
2005-10-03 04:40:51 +00:00
|
|
|
DIR *dir;
|
|
|
|
sprintf(alt->name, "%.2s/", name);
|
|
|
|
dir = opendir(alt->base);
|
|
|
|
if (!dir)
|
|
|
|
continue;
|
2005-08-04 05:15:49 +00:00
|
|
|
while ((de = readdir(dir)) != NULL) {
|
|
|
|
if (strlen(de->d_name) != 38)
|
|
|
|
continue;
|
2005-10-03 04:40:51 +00:00
|
|
|
if (memcmp(de->d_name, name + 2, len - 2))
|
2005-08-04 05:15:49 +00:00
|
|
|
continue;
|
2005-10-03 04:40:51 +00:00
|
|
|
if (!found) {
|
|
|
|
memcpy(hex + 2, de->d_name, 38);
|
|
|
|
found++;
|
|
|
|
}
|
|
|
|
else if (memcmp(hex + 2, de->d_name, 38)) {
|
|
|
|
found = 2;
|
2005-08-04 05:15:49 +00:00
|
|
|
break;
|
2005-10-03 04:40:51 +00:00
|
|
|
}
|
2005-08-04 05:15:49 +00:00
|
|
|
}
|
|
|
|
closedir(dir);
|
|
|
|
}
|
|
|
|
if (found == 1)
|
|
|
|
return get_sha1_hex(hex, sha1) == 0;
|
2005-10-03 04:40:51 +00:00
|
|
|
return found;
|
2005-08-04 05:15:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int match_sha(unsigned len, const unsigned char *a, const unsigned char *b)
|
|
|
|
{
|
|
|
|
do {
|
|
|
|
if (*a != *b)
|
|
|
|
return 0;
|
|
|
|
a++;
|
|
|
|
b++;
|
|
|
|
len -= 2;
|
|
|
|
} while (len > 1);
|
|
|
|
if (len)
|
|
|
|
if ((*a ^ *b) & 0xf0)
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int find_short_packed_object(int len, const unsigned char *match, unsigned char *sha1)
|
|
|
|
{
|
|
|
|
struct packed_git *p;
|
2007-04-04 20:49:04 +00:00
|
|
|
const unsigned char *found_sha1 = NULL;
|
2005-10-03 04:40:51 +00:00
|
|
|
int found = 0;
|
2005-08-04 05:15:49 +00:00
|
|
|
|
|
|
|
prepare_packed_git();
|
2005-10-03 04:40:51 +00:00
|
|
|
for (p = packed_git; p && found < 2; p = p->next) {
|
2007-05-29 23:29:51 +00:00
|
|
|
uint32_t num, last;
|
|
|
|
uint32_t first = 0;
|
|
|
|
open_pack_index(p);
|
|
|
|
num = p->num_objects;
|
|
|
|
last = num;
|
2005-08-04 05:15:49 +00:00
|
|
|
while (first < last) {
|
2007-03-07 01:44:19 +00:00
|
|
|
uint32_t mid = (first + last) / 2;
|
2007-04-04 20:49:04 +00:00
|
|
|
const unsigned char *now;
|
2005-08-04 05:15:49 +00:00
|
|
|
int cmp;
|
|
|
|
|
2007-04-04 20:49:04 +00:00
|
|
|
now = nth_packed_object_sha1(p, mid);
|
2006-08-17 18:54:57 +00:00
|
|
|
cmp = hashcmp(match, now);
|
2005-08-04 05:15:49 +00:00
|
|
|
if (!cmp) {
|
|
|
|
first = mid;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (cmp > 0) {
|
|
|
|
first = mid+1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
last = mid;
|
|
|
|
}
|
|
|
|
if (first < num) {
|
2007-04-04 20:49:04 +00:00
|
|
|
const unsigned char *now, *next;
|
|
|
|
now = nth_packed_object_sha1(p, first);
|
2005-08-04 05:15:49 +00:00
|
|
|
if (match_sha(len, match, now)) {
|
2007-04-04 20:49:04 +00:00
|
|
|
next = nth_packed_object_sha1(p, first+1);
|
|
|
|
if (!next|| !match_sha(len, match, next)) {
|
2005-10-03 04:40:51 +00:00
|
|
|
/* unique within this pack */
|
|
|
|
if (!found) {
|
2007-04-04 20:49:04 +00:00
|
|
|
found_sha1 = now;
|
2005-10-03 04:40:51 +00:00
|
|
|
found++;
|
|
|
|
}
|
2006-08-17 18:54:57 +00:00
|
|
|
else if (hashcmp(found_sha1, now)) {
|
2005-10-03 04:40:51 +00:00
|
|
|
found = 2;
|
|
|
|
break;
|
|
|
|
}
|
2005-10-03 04:40:51 +00:00
|
|
|
}
|
2005-10-03 04:40:51 +00:00
|
|
|
else {
|
|
|
|
/* not even unique within this pack */
|
2005-10-03 04:40:51 +00:00
|
|
|
found = 2;
|
|
|
|
break;
|
2005-08-04 05:15:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-10-03 04:40:51 +00:00
|
|
|
if (found == 1)
|
2006-08-23 06:49:00 +00:00
|
|
|
hashcpy(sha1, found_sha1);
|
2005-10-03 04:40:51 +00:00
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
2005-10-11 22:22:48 +00:00
|
|
|
#define SHORT_NAME_NOT_FOUND (-1)
|
|
|
|
#define SHORT_NAME_AMBIGUOUS (-2)
|
|
|
|
|
2005-10-03 04:40:51 +00:00
|
|
|
static int find_unique_short_object(int len, char *canonical,
|
|
|
|
unsigned char *res, unsigned char *sha1)
|
|
|
|
{
|
|
|
|
int has_unpacked, has_packed;
|
|
|
|
unsigned char unpacked_sha1[20], packed_sha1[20];
|
|
|
|
|
2007-05-26 05:25:11 +00:00
|
|
|
prepare_alt_odb();
|
2005-10-03 04:40:51 +00:00
|
|
|
has_unpacked = find_short_object_filename(len, canonical, unpacked_sha1);
|
|
|
|
has_packed = find_short_packed_object(len, res, packed_sha1);
|
|
|
|
if (!has_unpacked && !has_packed)
|
2005-10-11 22:22:48 +00:00
|
|
|
return SHORT_NAME_NOT_FOUND;
|
2005-10-03 04:40:51 +00:00
|
|
|
if (1 < has_unpacked || 1 < has_packed)
|
2005-10-11 22:22:48 +00:00
|
|
|
return SHORT_NAME_AMBIGUOUS;
|
2005-10-03 04:40:51 +00:00
|
|
|
if (has_unpacked != has_packed) {
|
2006-08-23 06:49:00 +00:00
|
|
|
hashcpy(sha1, (has_packed ? packed_sha1 : unpacked_sha1));
|
2005-10-03 04:40:51 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/* Both have unique ones -- do they match? */
|
2006-08-17 18:54:57 +00:00
|
|
|
if (hashcmp(packed_sha1, unpacked_sha1))
|
2006-01-26 11:26:15 +00:00
|
|
|
return SHORT_NAME_AMBIGUOUS;
|
2006-08-23 06:49:00 +00:00
|
|
|
hashcpy(sha1, packed_sha1);
|
2005-08-04 05:15:49 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-11 22:22:48 +00:00
|
|
|
static int get_short_sha1(const char *name, int len, unsigned char *sha1,
|
|
|
|
int quietly)
|
2005-08-04 05:15:49 +00:00
|
|
|
{
|
2005-10-11 22:22:48 +00:00
|
|
|
int i, status;
|
2005-08-04 05:15:49 +00:00
|
|
|
char canonical[40];
|
|
|
|
unsigned char res[20];
|
|
|
|
|
2006-10-19 01:34:41 +00:00
|
|
|
if (len < MINIMUM_ABBREV || len > 40)
|
2005-09-19 22:16:03 +00:00
|
|
|
return -1;
|
2006-08-23 20:57:23 +00:00
|
|
|
hashclr(res);
|
2005-08-04 05:15:49 +00:00
|
|
|
memset(canonical, 'x', 40);
|
2005-09-19 22:16:03 +00:00
|
|
|
for (i = 0; i < len ;i++) {
|
2005-08-04 05:15:49 +00:00
|
|
|
unsigned char c = name[i];
|
|
|
|
unsigned char val;
|
|
|
|
if (c >= '0' && c <= '9')
|
|
|
|
val = c - '0';
|
|
|
|
else if (c >= 'a' && c <= 'f')
|
|
|
|
val = c - 'a' + 10;
|
|
|
|
else if (c >= 'A' && c <='F') {
|
|
|
|
val = c - 'A' + 10;
|
|
|
|
c -= 'A' - 'a';
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return -1;
|
|
|
|
canonical[i] = c;
|
|
|
|
if (!(i & 1))
|
|
|
|
val <<= 4;
|
|
|
|
res[i >> 1] |= val;
|
|
|
|
}
|
2005-10-03 04:40:51 +00:00
|
|
|
|
2005-10-11 22:22:48 +00:00
|
|
|
status = find_unique_short_object(i, canonical, res, sha1);
|
|
|
|
if (!quietly && (status == SHORT_NAME_AMBIGUOUS))
|
|
|
|
return error("short SHA1 %.*s is ambiguous.", len, canonical);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *find_unique_abbrev(const unsigned char *sha1, int len)
|
|
|
|
{
|
2008-03-02 07:35:32 +00:00
|
|
|
int status, exists;
|
2005-10-11 22:22:48 +00:00
|
|
|
static char hex[41];
|
2005-12-14 01:21:41 +00:00
|
|
|
|
2008-03-02 07:35:32 +00:00
|
|
|
exists = has_sha1_file(sha1);
|
2005-10-11 22:22:48 +00:00
|
|
|
memcpy(hex, sha1_to_hex(sha1), 40);
|
2006-08-09 20:17:04 +00:00
|
|
|
if (len == 40 || !len)
|
2005-12-14 01:21:41 +00:00
|
|
|
return hex;
|
2005-10-11 22:22:48 +00:00
|
|
|
while (len < 40) {
|
|
|
|
unsigned char sha1_ret[20];
|
|
|
|
status = get_short_sha1(hex, len, sha1_ret, 1);
|
2008-03-02 07:35:32 +00:00
|
|
|
if (exists
|
|
|
|
? !status
|
|
|
|
: status == SHORT_NAME_NOT_FOUND) {
|
2005-10-11 22:22:48 +00:00
|
|
|
hex[len] = 0;
|
|
|
|
return hex;
|
|
|
|
}
|
|
|
|
len++;
|
|
|
|
}
|
2008-03-02 07:35:32 +00:00
|
|
|
return hex;
|
2005-08-04 05:15:49 +00:00
|
|
|
}
|
|
|
|
|
2005-12-15 20:54:00 +00:00
|
|
|
static int ambiguous_path(const char *path, int len)
|
Be more careful about reference parsing
This does two things:
- we don't allow "." and ".." as components of a refname. Thus get_sha1()
will not accept "./refname" as being the same as "refname" any more.
- git-rev-parse stops doing revision translation after seeing a pathname,
to match the brhaviour of all the tools (once we see a pathname,
everything else will also be parsed as a pathname).
Basically, if you did
git log *
and "gitk" was somewhere in the "*", we don't want to replace the filename
"gitk" with the SHA1 of the branch with the same name.
Of course, if there is any change of ambiguity, you should always use "--"
to make it explicit what are filenames and what are revisions, but this
makes the normal cases sane. The refname rule also means that instead of
the "--", you can do the same thing we're used to doing with filenames
that start with a slash: use "./filename" instead, and now it's a
filename, not an option (and not a revision).
So "git log ./*.c" is now actually a perfectly valid thing to do, even if
the first C-file might have the same name as a branch.
Trivial test:
git-rev-parse gitk ./gitk gitk
should output something like
9843c3074dfbf57117565f6b7c93e3e6812857ee
./gitk
gitk
where the "./gitk" isn't seen as a revision, and the second "gitk" is a
filename simply because we've seen filenames already, and thus stopped
doing revision parsing.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-28 19:41:49 +00:00
|
|
|
{
|
|
|
|
int slash = 1;
|
2005-12-15 20:54:00 +00:00
|
|
|
int cnt;
|
Be more careful about reference parsing
This does two things:
- we don't allow "." and ".." as components of a refname. Thus get_sha1()
will not accept "./refname" as being the same as "refname" any more.
- git-rev-parse stops doing revision translation after seeing a pathname,
to match the brhaviour of all the tools (once we see a pathname,
everything else will also be parsed as a pathname).
Basically, if you did
git log *
and "gitk" was somewhere in the "*", we don't want to replace the filename
"gitk" with the SHA1 of the branch with the same name.
Of course, if there is any change of ambiguity, you should always use "--"
to make it explicit what are filenames and what are revisions, but this
makes the normal cases sane. The refname rule also means that instead of
the "--", you can do the same thing we're used to doing with filenames
that start with a slash: use "./filename" instead, and now it's a
filename, not an option (and not a revision).
So "git log ./*.c" is now actually a perfectly valid thing to do, even if
the first C-file might have the same name as a branch.
Trivial test:
git-rev-parse gitk ./gitk gitk
should output something like
9843c3074dfbf57117565f6b7c93e3e6812857ee
./gitk
gitk
where the "./gitk" isn't seen as a revision, and the second "gitk" is a
filename simply because we've seen filenames already, and thus stopped
doing revision parsing.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-28 19:41:49 +00:00
|
|
|
|
2005-12-15 20:54:00 +00:00
|
|
|
for (cnt = 0; cnt < len; cnt++) {
|
Be more careful about reference parsing
This does two things:
- we don't allow "." and ".." as components of a refname. Thus get_sha1()
will not accept "./refname" as being the same as "refname" any more.
- git-rev-parse stops doing revision translation after seeing a pathname,
to match the brhaviour of all the tools (once we see a pathname,
everything else will also be parsed as a pathname).
Basically, if you did
git log *
and "gitk" was somewhere in the "*", we don't want to replace the filename
"gitk" with the SHA1 of the branch with the same name.
Of course, if there is any change of ambiguity, you should always use "--"
to make it explicit what are filenames and what are revisions, but this
makes the normal cases sane. The refname rule also means that instead of
the "--", you can do the same thing we're used to doing with filenames
that start with a slash: use "./filename" instead, and now it's a
filename, not an option (and not a revision).
So "git log ./*.c" is now actually a perfectly valid thing to do, even if
the first C-file might have the same name as a branch.
Trivial test:
git-rev-parse gitk ./gitk gitk
should output something like
9843c3074dfbf57117565f6b7c93e3e6812857ee
./gitk
gitk
where the "./gitk" isn't seen as a revision, and the second "gitk" is a
filename simply because we've seen filenames already, and thus stopped
doing revision parsing.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-28 19:41:49 +00:00
|
|
|
switch (*path++) {
|
|
|
|
case '\0':
|
|
|
|
break;
|
|
|
|
case '/':
|
|
|
|
if (slash)
|
|
|
|
break;
|
|
|
|
slash = 1;
|
|
|
|
continue;
|
|
|
|
case '.':
|
|
|
|
continue;
|
|
|
|
default:
|
|
|
|
slash = 0;
|
|
|
|
continue;
|
|
|
|
}
|
2005-12-17 08:00:50 +00:00
|
|
|
break;
|
Be more careful about reference parsing
This does two things:
- we don't allow "." and ".." as components of a refname. Thus get_sha1()
will not accept "./refname" as being the same as "refname" any more.
- git-rev-parse stops doing revision translation after seeing a pathname,
to match the brhaviour of all the tools (once we see a pathname,
everything else will also be parsed as a pathname).
Basically, if you did
git log *
and "gitk" was somewhere in the "*", we don't want to replace the filename
"gitk" with the SHA1 of the branch with the same name.
Of course, if there is any change of ambiguity, you should always use "--"
to make it explicit what are filenames and what are revisions, but this
makes the normal cases sane. The refname rule also means that instead of
the "--", you can do the same thing we're used to doing with filenames
that start with a slash: use "./filename" instead, and now it's a
filename, not an option (and not a revision).
So "git log ./*.c" is now actually a perfectly valid thing to do, even if
the first C-file might have the same name as a branch.
Trivial test:
git-rev-parse gitk ./gitk gitk
should output something like
9843c3074dfbf57117565f6b7c93e3e6812857ee
./gitk
gitk
where the "./gitk" isn't seen as a revision, and the second "gitk" is a
filename simply because we've seen filenames already, and thus stopped
doing revision parsing.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-28 19:41:49 +00:00
|
|
|
}
|
2005-12-15 20:54:00 +00:00
|
|
|
return slash;
|
Be more careful about reference parsing
This does two things:
- we don't allow "." and ".." as components of a refname. Thus get_sha1()
will not accept "./refname" as being the same as "refname" any more.
- git-rev-parse stops doing revision translation after seeing a pathname,
to match the brhaviour of all the tools (once we see a pathname,
everything else will also be parsed as a pathname).
Basically, if you did
git log *
and "gitk" was somewhere in the "*", we don't want to replace the filename
"gitk" with the SHA1 of the branch with the same name.
Of course, if there is any change of ambiguity, you should always use "--"
to make it explicit what are filenames and what are revisions, but this
makes the normal cases sane. The refname rule also means that instead of
the "--", you can do the same thing we're used to doing with filenames
that start with a slash: use "./filename" instead, and now it's a
filename, not an option (and not a revision).
So "git log ./*.c" is now actually a perfectly valid thing to do, even if
the first C-file might have the same name as a branch.
Trivial test:
git-rev-parse gitk ./gitk gitk
should output something like
9843c3074dfbf57117565f6b7c93e3e6812857ee
./gitk
gitk
where the "./gitk" isn't seen as a revision, and the second "gitk" is a
filename simply because we've seen filenames already, and thus stopped
doing revision parsing.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-28 19:41:49 +00:00
|
|
|
}
|
|
|
|
|
2007-01-19 09:15:15 +00:00
|
|
|
int dwim_ref(const char *str, int len, unsigned char *sha1, char **ref)
|
2005-08-04 05:15:49 +00:00
|
|
|
{
|
2007-01-19 09:15:15 +00:00
|
|
|
const char **p, *r;
|
|
|
|
int refs_found = 0;
|
|
|
|
|
|
|
|
*ref = NULL;
|
add refname_match()
We use at least two rulesets for matching abbreviated refnames with
full refnames (starting with 'refs/'). git-rev-parse and git-fetch
use slightly different rules.
This commit introduces a new function refname_match
(const char *abbrev_name, const char *full_name, const char **rules).
abbrev_name is expanded using the rules and matched against full_name.
If a match is found the function returns true. rules is a NULL-terminate
list of format patterns with "%.*s", for example:
const char *ref_rev_parse_rules[] = {
"%.*s",
"refs/%.*s",
"refs/tags/%.*s",
"refs/heads/%.*s",
"refs/remotes/%.*s",
"refs/remotes/%.*s/HEAD",
NULL
};
Asterisks are included in the format strings because this is the form
required in sha1_name.c. Sharing the list with the functions there is
a good idea to avoid duplicating the rules. Hopefully this
facilitates unified matching rules in the future.
This commit makes the rules used by rev-parse for resolving refs to
sha1s available for string comparison. Before this change, the rules
were buried in get_sha1*() and dwim_ref().
A follow-up commit will refactor the rules used by fetch.
refname_match() will be used for matching refspecs in git-send-pack.
Thanks to Daniel Barkalow <barkalow@iabervon.org> for pointing
out that ref_matches_abbrev in remote.c solves a similar problem
and care should be taken to avoid confusion.
Signed-off-by: Steffen Prohaska <prohaska@zib.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-11 14:01:46 +00:00
|
|
|
for (p = ref_rev_parse_rules; *p; p++) {
|
2008-10-26 22:07:24 +00:00
|
|
|
char fullref[PATH_MAX];
|
2007-01-19 09:15:15 +00:00
|
|
|
unsigned char sha1_from_ref[20];
|
|
|
|
unsigned char *this_result;
|
|
|
|
|
|
|
|
this_result = refs_found ? sha1_from_ref : sha1;
|
2008-10-26 22:07:24 +00:00
|
|
|
mksnpath(fullref, sizeof(fullref), *p, len, str);
|
|
|
|
r = resolve_ref(fullref, this_result, 1, NULL);
|
2007-01-19 09:15:15 +00:00
|
|
|
if (r) {
|
|
|
|
if (!refs_found++)
|
|
|
|
*ref = xstrdup(r);
|
|
|
|
if (!warn_ambiguous_refs)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return refs_found;
|
|
|
|
}
|
|
|
|
|
2007-02-09 00:28:23 +00:00
|
|
|
int dwim_log(const char *str, int len, unsigned char *sha1, char **log)
|
2007-02-04 02:49:16 +00:00
|
|
|
{
|
|
|
|
const char **p;
|
|
|
|
int logs_found = 0;
|
|
|
|
|
|
|
|
*log = NULL;
|
add refname_match()
We use at least two rulesets for matching abbreviated refnames with
full refnames (starting with 'refs/'). git-rev-parse and git-fetch
use slightly different rules.
This commit introduces a new function refname_match
(const char *abbrev_name, const char *full_name, const char **rules).
abbrev_name is expanded using the rules and matched against full_name.
If a match is found the function returns true. rules is a NULL-terminate
list of format patterns with "%.*s", for example:
const char *ref_rev_parse_rules[] = {
"%.*s",
"refs/%.*s",
"refs/tags/%.*s",
"refs/heads/%.*s",
"refs/remotes/%.*s",
"refs/remotes/%.*s/HEAD",
NULL
};
Asterisks are included in the format strings because this is the form
required in sha1_name.c. Sharing the list with the functions there is
a good idea to avoid duplicating the rules. Hopefully this
facilitates unified matching rules in the future.
This commit makes the rules used by rev-parse for resolving refs to
sha1s available for string comparison. Before this change, the rules
were buried in get_sha1*() and dwim_ref().
A follow-up commit will refactor the rules used by fetch.
refname_match() will be used for matching refspecs in git-send-pack.
Thanks to Daniel Barkalow <barkalow@iabervon.org> for pointing
out that ref_matches_abbrev in remote.c solves a similar problem
and care should be taken to avoid confusion.
Signed-off-by: Steffen Prohaska <prohaska@zib.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-11 14:01:46 +00:00
|
|
|
for (p = ref_rev_parse_rules; *p; p++) {
|
2007-02-04 02:49:16 +00:00
|
|
|
struct stat st;
|
2007-02-09 07:24:51 +00:00
|
|
|
unsigned char hash[20];
|
|
|
|
char path[PATH_MAX];
|
|
|
|
const char *ref, *it;
|
|
|
|
|
2008-10-26 22:07:24 +00:00
|
|
|
mksnpath(path, sizeof(path), *p, len, str);
|
2008-07-24 00:22:58 +00:00
|
|
|
ref = resolve_ref(path, hash, 1, NULL);
|
2007-02-09 07:24:51 +00:00
|
|
|
if (!ref)
|
|
|
|
continue;
|
2007-02-04 02:49:16 +00:00
|
|
|
if (!stat(git_path("logs/%s", path), &st) &&
|
2007-02-09 07:24:51 +00:00
|
|
|
S_ISREG(st.st_mode))
|
|
|
|
it = path;
|
|
|
|
else if (strcmp(ref, path) &&
|
|
|
|
!stat(git_path("logs/%s", ref), &st) &&
|
|
|
|
S_ISREG(st.st_mode))
|
|
|
|
it = ref;
|
|
|
|
else
|
|
|
|
continue;
|
|
|
|
if (!logs_found++) {
|
|
|
|
*log = xstrdup(it);
|
|
|
|
hashcpy(sha1, hash);
|
2007-02-04 02:49:16 +00:00
|
|
|
}
|
2007-02-09 07:24:51 +00:00
|
|
|
if (!warn_ambiguous_refs)
|
|
|
|
break;
|
2007-02-04 02:49:16 +00:00
|
|
|
}
|
|
|
|
return logs_found;
|
|
|
|
}
|
|
|
|
|
2007-01-19 09:15:15 +00:00
|
|
|
static int get_sha1_basic(const char *str, int len, unsigned char *sha1)
|
|
|
|
{
|
2006-05-17 09:56:09 +00:00
|
|
|
static const char *warning = "warning: refname '%.*s' is ambiguous.\n";
|
2006-09-12 03:17:35 +00:00
|
|
|
char *real_ref = NULL;
|
2006-10-06 06:16:15 +00:00
|
|
|
int refs_found = 0;
|
|
|
|
int at, reflog_len;
|
2005-08-04 05:15:49 +00:00
|
|
|
|
2005-08-13 18:05:25 +00:00
|
|
|
if (len == 40 && !get_sha1_hex(str, sha1))
|
2005-08-04 05:15:49 +00:00
|
|
|
return 0;
|
|
|
|
|
2006-10-06 06:16:15 +00:00
|
|
|
/* basic@{time or number} format to query ref-log */
|
2006-10-24 04:15:34 +00:00
|
|
|
reflog_len = at = 0;
|
2006-10-06 06:16:15 +00:00
|
|
|
if (str[len-1] == '}') {
|
2007-02-01 22:29:33 +00:00
|
|
|
for (at = 0; at < len - 1; at++) {
|
2006-10-06 06:16:15 +00:00
|
|
|
if (str[at] == '@' && str[at+1] == '{') {
|
|
|
|
reflog_len = (len-1) - (at+2);
|
|
|
|
len = at;
|
|
|
|
break;
|
|
|
|
}
|
2006-05-17 09:56:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Be more careful about reference parsing
This does two things:
- we don't allow "." and ".." as components of a refname. Thus get_sha1()
will not accept "./refname" as being the same as "refname" any more.
- git-rev-parse stops doing revision translation after seeing a pathname,
to match the brhaviour of all the tools (once we see a pathname,
everything else will also be parsed as a pathname).
Basically, if you did
git log *
and "gitk" was somewhere in the "*", we don't want to replace the filename
"gitk" with the SHA1 of the branch with the same name.
Of course, if there is any change of ambiguity, you should always use "--"
to make it explicit what are filenames and what are revisions, but this
makes the normal cases sane. The refname rule also means that instead of
the "--", you can do the same thing we're used to doing with filenames
that start with a slash: use "./filename" instead, and now it's a
filename, not an option (and not a revision).
So "git log ./*.c" is now actually a perfectly valid thing to do, even if
the first C-file might have the same name as a branch.
Trivial test:
git-rev-parse gitk ./gitk gitk
should output something like
9843c3074dfbf57117565f6b7c93e3e6812857ee
./gitk
gitk
where the "./gitk" isn't seen as a revision, and the second "gitk" is a
filename simply because we've seen filenames already, and thus stopped
doing revision parsing.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-28 19:41:49 +00:00
|
|
|
/* Accept only unambiguous ref paths. */
|
2007-02-01 22:29:33 +00:00
|
|
|
if (len && ambiguous_path(str, len))
|
Be more careful about reference parsing
This does two things:
- we don't allow "." and ".." as components of a refname. Thus get_sha1()
will not accept "./refname" as being the same as "refname" any more.
- git-rev-parse stops doing revision translation after seeing a pathname,
to match the brhaviour of all the tools (once we see a pathname,
everything else will also be parsed as a pathname).
Basically, if you did
git log *
and "gitk" was somewhere in the "*", we don't want to replace the filename
"gitk" with the SHA1 of the branch with the same name.
Of course, if there is any change of ambiguity, you should always use "--"
to make it explicit what are filenames and what are revisions, but this
makes the normal cases sane. The refname rule also means that instead of
the "--", you can do the same thing we're used to doing with filenames
that start with a slash: use "./filename" instead, and now it's a
filename, not an option (and not a revision).
So "git log ./*.c" is now actually a perfectly valid thing to do, even if
the first C-file might have the same name as a branch.
Trivial test:
git-rev-parse gitk ./gitk gitk
should output something like
9843c3074dfbf57117565f6b7c93e3e6812857ee
./gitk
gitk
where the "./gitk" isn't seen as a revision, and the second "gitk" is a
filename simply because we've seen filenames already, and thus stopped
doing revision parsing.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-10-28 19:41:49 +00:00
|
|
|
return -1;
|
|
|
|
|
2007-02-01 22:29:33 +00:00
|
|
|
if (!len && reflog_len) {
|
|
|
|
/* allow "@{...}" to mean the current branch reflog */
|
|
|
|
refs_found = dwim_ref("HEAD", 4, sha1, &real_ref);
|
2007-02-04 02:49:16 +00:00
|
|
|
} else if (reflog_len)
|
|
|
|
refs_found = dwim_log(str, len, sha1, &real_ref);
|
|
|
|
else
|
2007-02-01 22:29:33 +00:00
|
|
|
refs_found = dwim_ref(str, len, sha1, &real_ref);
|
2006-05-17 09:56:09 +00:00
|
|
|
|
|
|
|
if (!refs_found)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (warn_ambiguous_refs && refs_found > 1)
|
|
|
|
fprintf(stderr, warning, len, str);
|
|
|
|
|
2006-10-06 06:16:15 +00:00
|
|
|
if (reflog_len) {
|
|
|
|
int nth, i;
|
|
|
|
unsigned long at_time;
|
2007-01-19 09:19:05 +00:00
|
|
|
unsigned long co_time;
|
|
|
|
int co_tz, co_cnt;
|
|
|
|
|
2007-02-01 17:33:23 +00:00
|
|
|
/* Is it asking for N-th entry, or approxidate? */
|
2006-10-06 06:16:15 +00:00
|
|
|
for (i = nth = 0; 0 <= nth && i < reflog_len; i++) {
|
|
|
|
char ch = str[at+2+i];
|
|
|
|
if ('0' <= ch && ch <= '9')
|
|
|
|
nth = nth * 10 + ch - '0';
|
|
|
|
else
|
|
|
|
nth = -1;
|
|
|
|
}
|
|
|
|
if (0 <= nth)
|
|
|
|
at_time = 0;
|
2008-04-30 04:13:58 +00:00
|
|
|
else {
|
|
|
|
char *tmp = xstrndup(str + at + 2, reflog_len);
|
|
|
|
at_time = approxidate(tmp);
|
|
|
|
free(tmp);
|
|
|
|
}
|
2007-01-19 09:19:05 +00:00
|
|
|
if (read_ref_at(real_ref, at_time, nth, sha1, NULL,
|
|
|
|
&co_time, &co_tz, &co_cnt)) {
|
|
|
|
if (at_time)
|
|
|
|
fprintf(stderr,
|
|
|
|
"warning: Log for '%.*s' only goes "
|
|
|
|
"back to %s.\n", len, str,
|
2007-07-14 06:14:52 +00:00
|
|
|
show_date(co_time, co_tz, DATE_RFC2822));
|
2007-01-19 09:19:05 +00:00
|
|
|
else
|
|
|
|
fprintf(stderr,
|
|
|
|
"warning: Log for '%.*s' only has "
|
|
|
|
"%d entries.\n", len, str, co_cnt);
|
|
|
|
}
|
2006-05-17 09:56:09 +00:00
|
|
|
}
|
|
|
|
|
2006-09-12 03:17:35 +00:00
|
|
|
free(real_ref);
|
2006-05-17 09:56:09 +00:00
|
|
|
return 0;
|
2005-08-04 05:15:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int get_sha1_1(const char *name, int len, unsigned char *sha1);
|
|
|
|
|
|
|
|
static int get_parent(const char *name, int len,
|
|
|
|
unsigned char *result, int idx)
|
|
|
|
{
|
|
|
|
unsigned char sha1[20];
|
|
|
|
int ret = get_sha1_1(name, len, sha1);
|
|
|
|
struct commit *commit;
|
|
|
|
struct commit_list *p;
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
commit = lookup_commit_reference(sha1);
|
|
|
|
if (!commit)
|
|
|
|
return -1;
|
|
|
|
if (parse_commit(commit))
|
|
|
|
return -1;
|
|
|
|
if (!idx) {
|
2006-08-23 06:49:00 +00:00
|
|
|
hashcpy(result, commit->object.sha1);
|
2005-08-04 05:15:49 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
p = commit->parents;
|
|
|
|
while (p) {
|
|
|
|
if (!--idx) {
|
2006-08-23 06:49:00 +00:00
|
|
|
hashcpy(result, p->item->object.sha1);
|
2005-08-04 05:15:49 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
p = p->next;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2005-08-21 09:43:54 +00:00
|
|
|
static int get_nth_ancestor(const char *name, int len,
|
|
|
|
unsigned char *result, int generation)
|
|
|
|
{
|
|
|
|
unsigned char sha1[20];
|
2008-03-14 18:49:40 +00:00
|
|
|
struct commit *commit;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = get_sha1_1(name, len, sha1);
|
2005-08-21 09:43:54 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2008-03-14 18:49:40 +00:00
|
|
|
commit = lookup_commit_reference(sha1);
|
|
|
|
if (!commit)
|
|
|
|
return -1;
|
2005-08-21 09:43:54 +00:00
|
|
|
|
|
|
|
while (generation--) {
|
2008-03-14 18:49:40 +00:00
|
|
|
if (parse_commit(commit) || !commit->parents)
|
2005-08-21 09:43:54 +00:00
|
|
|
return -1;
|
2008-03-14 18:49:40 +00:00
|
|
|
commit = commit->parents->item;
|
2005-08-21 09:43:54 +00:00
|
|
|
}
|
2008-03-14 18:49:40 +00:00
|
|
|
hashcpy(result, commit->object.sha1);
|
2005-08-21 09:43:54 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-12-24 08:51:01 +00:00
|
|
|
struct object *peel_to_type(const char *name, int namelen,
|
|
|
|
struct object *o, enum object_type expected_type)
|
|
|
|
{
|
|
|
|
if (name && !namelen)
|
|
|
|
namelen = strlen(name);
|
|
|
|
if (!o) {
|
|
|
|
unsigned char sha1[20];
|
|
|
|
if (get_sha1_1(name, namelen, sha1))
|
|
|
|
return NULL;
|
|
|
|
o = parse_object(sha1);
|
|
|
|
}
|
|
|
|
while (1) {
|
|
|
|
if (!o || (!o->parsed && !parse_object(o->sha1)))
|
|
|
|
return NULL;
|
|
|
|
if (o->type == expected_type)
|
|
|
|
return o;
|
|
|
|
if (o->type == OBJ_TAG)
|
|
|
|
o = ((struct tag*) o)->tagged;
|
|
|
|
else if (o->type == OBJ_COMMIT)
|
|
|
|
o = &(((struct commit *) o)->tree->object);
|
|
|
|
else {
|
|
|
|
if (name)
|
|
|
|
error("%.*s: expected %s type, but the object "
|
|
|
|
"dereferences to %s type",
|
|
|
|
namelen, name, typename(expected_type),
|
|
|
|
typename(o->type));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-10-14 01:57:40 +00:00
|
|
|
static int peel_onion(const char *name, int len, unsigned char *sha1)
|
|
|
|
{
|
|
|
|
unsigned char outer[20];
|
|
|
|
const char *sp;
|
Shrink "struct object" a bit
This shrinks "struct object" by a small amount, by getting rid of the
"struct type *" pointer and replacing it with a 3-bit bitfield instead.
In addition, we merge the bitfields and the "flags" field, which
incidentally should also remove a useless 4-byte padding from the object
when in 64-bit mode.
Now, our "struct object" is still too damn large, but it's now less
obviously bloated, and of the remaining fields, only the "util" (which is
not used by most things) is clearly something that should be eventually
discarded.
This shrinks the "git-rev-list --all" memory use by about 2.5% on the
kernel archive (and, perhaps more importantly, on the larger mozilla
archive). That may not sound like much, but I suspect it's more on a
64-bit platform.
There are other remaining inefficiencies (the parent lists, for example,
probably have horrible malloc overhead), but this was pretty obvious.
Most of the patch is just changing the comparison of the "type" pointer
from one of the constant string pointers to the appropriate new TYPE_xxx
small integer constant.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-14 23:45:13 +00:00
|
|
|
unsigned int expected_type = 0;
|
2005-10-14 01:57:40 +00:00
|
|
|
struct object *o;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* "ref^{type}" dereferences ref repeatedly until you cannot
|
|
|
|
* dereference anymore, or you get an object of given type,
|
|
|
|
* whichever comes first. "ref^{}" means just dereference
|
|
|
|
* tags until you get a non-tag. "ref^0" is a shorthand for
|
|
|
|
* "ref^{commit}". "commit^{tree}" could be used to find the
|
|
|
|
* top-level tree of the given commit.
|
|
|
|
*/
|
|
|
|
if (len < 4 || name[len-1] != '}')
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
for (sp = name + len - 1; name <= sp; sp--) {
|
|
|
|
int ch = *sp;
|
|
|
|
if (ch == '{' && name < sp && sp[-1] == '^')
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (sp <= name)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
sp++; /* beginning of type name, or closing brace for empty */
|
|
|
|
if (!strncmp(commit_type, sp, 6) && sp[6] == '}')
|
2006-07-12 03:45:31 +00:00
|
|
|
expected_type = OBJ_COMMIT;
|
2005-10-14 01:57:40 +00:00
|
|
|
else if (!strncmp(tree_type, sp, 4) && sp[4] == '}')
|
2006-07-12 03:45:31 +00:00
|
|
|
expected_type = OBJ_TREE;
|
2005-10-14 01:57:40 +00:00
|
|
|
else if (!strncmp(blob_type, sp, 4) && sp[4] == '}')
|
2006-07-12 03:45:31 +00:00
|
|
|
expected_type = OBJ_BLOB;
|
2005-10-14 01:57:40 +00:00
|
|
|
else if (sp[0] == '}')
|
2006-07-12 03:45:31 +00:00
|
|
|
expected_type = OBJ_NONE;
|
2005-10-14 01:57:40 +00:00
|
|
|
else
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (get_sha1_1(name, sp - name - 2, outer))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
o = parse_object(outer);
|
|
|
|
if (!o)
|
|
|
|
return -1;
|
Shrink "struct object" a bit
This shrinks "struct object" by a small amount, by getting rid of the
"struct type *" pointer and replacing it with a 3-bit bitfield instead.
In addition, we merge the bitfields and the "flags" field, which
incidentally should also remove a useless 4-byte padding from the object
when in 64-bit mode.
Now, our "struct object" is still too damn large, but it's now less
obviously bloated, and of the remaining fields, only the "util" (which is
not used by most things) is clearly something that should be eventually
discarded.
This shrinks the "git-rev-list --all" memory use by about 2.5% on the
kernel archive (and, perhaps more importantly, on the larger mozilla
archive). That may not sound like much, but I suspect it's more on a
64-bit platform.
There are other remaining inefficiencies (the parent lists, for example,
probably have horrible malloc overhead), but this was pretty obvious.
Most of the patch is just changing the comparison of the "type" pointer
from one of the constant string pointers to the appropriate new TYPE_xxx
small integer constant.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-14 23:45:13 +00:00
|
|
|
if (!expected_type) {
|
2005-11-02 23:19:13 +00:00
|
|
|
o = deref_tag(o, name, sp - name - 2);
|
2005-10-20 05:48:16 +00:00
|
|
|
if (!o || (!o->parsed && !parse_object(o->sha1)))
|
|
|
|
return -1;
|
2006-08-23 06:49:00 +00:00
|
|
|
hashcpy(sha1, o->sha1);
|
2005-10-14 01:57:40 +00:00
|
|
|
}
|
|
|
|
else {
|
2007-12-24 08:51:01 +00:00
|
|
|
/*
|
|
|
|
* At this point, the syntax look correct, so
|
2005-10-14 01:57:40 +00:00
|
|
|
* if we do not get the needed object, we should
|
|
|
|
* barf.
|
|
|
|
*/
|
2007-12-24 08:51:01 +00:00
|
|
|
o = peel_to_type(name, len, o, expected_type);
|
|
|
|
if (o) {
|
|
|
|
hashcpy(sha1, o->sha1);
|
|
|
|
return 0;
|
2005-10-14 01:57:40 +00:00
|
|
|
}
|
2007-12-24 08:51:01 +00:00
|
|
|
return -1;
|
2005-10-14 01:57:40 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-09-20 23:11:08 +00:00
|
|
|
static int get_describe_name(const char *name, int len, unsigned char *sha1)
|
|
|
|
{
|
|
|
|
const char *cp;
|
|
|
|
|
|
|
|
for (cp = name + len - 1; name + 2 <= cp; cp--) {
|
|
|
|
char ch = *cp;
|
|
|
|
if (hexval(ch) & ~0377) {
|
|
|
|
/* We must be looking at g in "SOMETHING-g"
|
|
|
|
* for it to be describe output.
|
|
|
|
*/
|
|
|
|
if (ch == 'g' && cp[-1] == '-') {
|
|
|
|
cp++;
|
|
|
|
len -= cp - name;
|
|
|
|
return get_short_sha1(cp, len, sha1, 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2005-08-04 05:15:49 +00:00
|
|
|
static int get_sha1_1(const char *name, int len, unsigned char *sha1)
|
|
|
|
{
|
2006-02-03 07:48:36 +00:00
|
|
|
int ret, has_suffix;
|
2005-08-21 09:43:54 +00:00
|
|
|
const char *cp;
|
2005-08-04 05:15:49 +00:00
|
|
|
|
2008-03-14 18:49:40 +00:00
|
|
|
/*
|
|
|
|
* "name~3" is "name^^^", "name~" is "name~1", and "name^" is "name^1".
|
2005-08-21 09:43:54 +00:00
|
|
|
*/
|
2006-02-03 07:48:36 +00:00
|
|
|
has_suffix = 0;
|
2005-08-21 09:43:54 +00:00
|
|
|
for (cp = name + len - 1; name <= cp; cp--) {
|
|
|
|
int ch = *cp;
|
|
|
|
if ('0' <= ch && ch <= '9')
|
|
|
|
continue;
|
2006-02-03 07:48:36 +00:00
|
|
|
if (ch == '~' || ch == '^')
|
|
|
|
has_suffix = ch;
|
2005-08-21 09:43:54 +00:00
|
|
|
break;
|
|
|
|
}
|
2006-02-03 07:48:36 +00:00
|
|
|
|
|
|
|
if (has_suffix) {
|
|
|
|
int num = 0;
|
2005-08-21 09:43:54 +00:00
|
|
|
int len1 = cp - name;
|
|
|
|
cp++;
|
|
|
|
while (cp < name + len)
|
2006-02-03 07:48:36 +00:00
|
|
|
num = num * 10 + *cp++ - '0';
|
2008-03-14 18:49:40 +00:00
|
|
|
if (!num && len1 == len - 1)
|
|
|
|
num = 1;
|
|
|
|
if (has_suffix == '^')
|
2006-02-03 07:48:36 +00:00
|
|
|
return get_parent(name, len1, sha1, num);
|
|
|
|
/* else if (has_suffix == '~') -- goes without saying */
|
|
|
|
return get_nth_ancestor(name, len1, sha1, num);
|
2005-08-21 09:43:54 +00:00
|
|
|
}
|
|
|
|
|
2005-10-14 01:57:40 +00:00
|
|
|
ret = peel_onion(name, len, sha1);
|
|
|
|
if (!ret)
|
|
|
|
return 0;
|
|
|
|
|
2005-08-04 05:15:49 +00:00
|
|
|
ret = get_sha1_basic(name, len, sha1);
|
|
|
|
if (!ret)
|
|
|
|
return 0;
|
2006-09-20 23:11:08 +00:00
|
|
|
|
|
|
|
/* It could be describe output that is "SOMETHING-gXXXX" */
|
|
|
|
ret = get_describe_name(name, len, sha1);
|
|
|
|
if (!ret)
|
|
|
|
return 0;
|
|
|
|
|
2005-10-11 22:22:48 +00:00
|
|
|
return get_short_sha1(name, len, sha1, 0);
|
2005-08-04 05:15:49 +00:00
|
|
|
}
|
|
|
|
|
2007-02-24 02:08:20 +00:00
|
|
|
static int handle_one_ref(const char *path,
|
|
|
|
const unsigned char *sha1, int flag, void *cb_data)
|
|
|
|
{
|
|
|
|
struct commit_list **list = cb_data;
|
|
|
|
struct object *object = parse_object(sha1);
|
|
|
|
if (!object)
|
|
|
|
return 0;
|
2008-02-18 07:31:54 +00:00
|
|
|
if (object->type == OBJ_TAG) {
|
2007-02-24 02:08:20 +00:00
|
|
|
object = deref_tag(object, path, strlen(path));
|
2008-02-18 07:31:54 +00:00
|
|
|
if (!object)
|
|
|
|
return 0;
|
|
|
|
}
|
2007-02-24 02:08:20 +00:00
|
|
|
if (object->type != OBJ_COMMIT)
|
|
|
|
return 0;
|
|
|
|
insert_by_date((struct commit *)object, list);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This interprets names like ':/Initial revision of "git"' by searching
|
|
|
|
* through history and returning the first commit whose message starts
|
|
|
|
* with the given string.
|
|
|
|
*
|
|
|
|
* For future extension, ':/!' is reserved. If you want to match a message
|
|
|
|
* beginning with a '!', you have to repeat the exclamation mark.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define ONELINE_SEEN (1u<<20)
|
2007-03-12 18:30:38 +00:00
|
|
|
static int get_sha1_oneline(const char *prefix, unsigned char *sha1)
|
2007-02-24 02:08:20 +00:00
|
|
|
{
|
|
|
|
struct commit_list *list = NULL, *backup = NULL, *l;
|
2007-03-12 18:30:38 +00:00
|
|
|
int retval = -1;
|
2007-12-03 18:42:39 +00:00
|
|
|
char *temp_commit_buffer = NULL;
|
2007-02-24 02:08:20 +00:00
|
|
|
|
|
|
|
if (prefix[0] == '!') {
|
|
|
|
if (prefix[1] != '!')
|
|
|
|
die ("Invalid search pattern: %s", prefix);
|
|
|
|
prefix++;
|
|
|
|
}
|
|
|
|
for_each_ref(handle_one_ref, &list);
|
|
|
|
for (l = list; l; l = l->next)
|
|
|
|
commit_list_insert(l->item, &backup);
|
2007-03-11 18:49:08 +00:00
|
|
|
while (list) {
|
2007-02-24 02:08:20 +00:00
|
|
|
char *p;
|
2007-03-12 18:30:38 +00:00
|
|
|
struct commit *commit;
|
2007-12-03 18:42:39 +00:00
|
|
|
enum object_type type;
|
|
|
|
unsigned long size;
|
2007-03-11 18:49:08 +00:00
|
|
|
|
|
|
|
commit = pop_most_recent_commit(&list, ONELINE_SEEN);
|
2008-02-18 20:47:53 +00:00
|
|
|
if (!parse_object(commit->object.sha1))
|
|
|
|
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(temp_commit_buffer);
|
2007-12-03 18:42:39 +00:00
|
|
|
if (commit->buffer)
|
|
|
|
p = commit->buffer;
|
|
|
|
else {
|
|
|
|
p = read_sha1_file(commit->object.sha1, &type, &size);
|
|
|
|
if (!p)
|
|
|
|
continue;
|
|
|
|
temp_commit_buffer = p;
|
|
|
|
}
|
|
|
|
if (!(p = strstr(p, "\n\n")))
|
2007-02-24 02:08:20 +00:00
|
|
|
continue;
|
|
|
|
if (!prefixcmp(p + 2, prefix)) {
|
|
|
|
hashcpy(sha1, commit->object.sha1);
|
2007-03-12 18:30:38 +00:00
|
|
|
retval = 0;
|
2007-02-24 02:08:20 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
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(temp_commit_buffer);
|
2007-02-24 02:08:20 +00:00
|
|
|
free_commit_list(list);
|
|
|
|
for (l = backup; l; l = l->next)
|
|
|
|
clear_commit_marks(l->item, ONELINE_SEEN);
|
2007-03-12 18:30:38 +00:00
|
|
|
return retval;
|
2007-02-24 02:08:20 +00:00
|
|
|
}
|
|
|
|
|
2005-08-04 05:15:49 +00:00
|
|
|
/*
|
|
|
|
* This is like "get_sha1_basic()", except it allows "sha1 expressions",
|
|
|
|
* notably "xyz^" for "parent of xyz"
|
|
|
|
*/
|
|
|
|
int get_sha1(const char *name, unsigned char *sha1)
|
|
|
|
{
|
2006-04-19 18:56:07 +00:00
|
|
|
unsigned unused;
|
2007-04-23 20:55:05 +00:00
|
|
|
return get_sha1_with_mode(name, sha1, &unused);
|
|
|
|
}
|
|
|
|
|
|
|
|
int get_sha1_with_mode(const char *name, unsigned char *sha1, unsigned *mode)
|
|
|
|
{
|
|
|
|
int ret, bracket_depth;
|
2006-04-22 00:31:04 +00:00
|
|
|
int namelen = strlen(name);
|
|
|
|
const char *cp;
|
2006-04-18 23:45:16 +00:00
|
|
|
|
2007-04-23 20:55:05 +00:00
|
|
|
*mode = S_IFINVALID;
|
2006-04-22 00:31:04 +00:00
|
|
|
ret = get_sha1_1(name, namelen, sha1);
|
|
|
|
if (!ret)
|
|
|
|
return ret;
|
|
|
|
/* sha1:path --> object name of path in ent sha1
|
|
|
|
* :path -> object name of path in index
|
|
|
|
* :[0-3]:path -> object name of path in index at stage
|
|
|
|
*/
|
|
|
|
if (name[0] == ':') {
|
|
|
|
int stage = 0;
|
|
|
|
struct cache_entry *ce;
|
|
|
|
int pos;
|
2007-02-24 02:08:20 +00:00
|
|
|
if (namelen > 2 && name[1] == '/')
|
|
|
|
return get_sha1_oneline(name + 2, sha1);
|
2006-04-22 00:31:04 +00:00
|
|
|
if (namelen < 3 ||
|
|
|
|
name[2] != ':' ||
|
|
|
|
name[1] < '0' || '3' < name[1])
|
|
|
|
cp = name + 1;
|
|
|
|
else {
|
|
|
|
stage = name[1] - '0';
|
|
|
|
cp = name + 3;
|
2006-04-18 23:45:16 +00:00
|
|
|
}
|
2006-04-22 00:31:04 +00:00
|
|
|
namelen = namelen - (cp - name);
|
|
|
|
if (!active_cache)
|
|
|
|
read_cache();
|
|
|
|
pos = cache_name_pos(cp, namelen);
|
|
|
|
if (pos < 0)
|
|
|
|
pos = -pos - 1;
|
|
|
|
while (pos < active_nr) {
|
|
|
|
ce = active_cache[pos];
|
|
|
|
if (ce_namelen(ce) != namelen ||
|
|
|
|
memcmp(ce->name, cp, namelen))
|
|
|
|
break;
|
|
|
|
if (ce_stage(ce) == stage) {
|
2006-08-23 06:49:00 +00:00
|
|
|
hashcpy(sha1, ce->sha1);
|
2008-01-15 00:03:17 +00:00
|
|
|
*mode = ce->ce_mode;
|
2006-04-22 00:31:04 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2006-05-08 22:44:06 +00:00
|
|
|
pos++;
|
2006-04-22 00:31:04 +00:00
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
2006-05-19 07:29:43 +00:00
|
|
|
for (cp = name, bracket_depth = 0; *cp; cp++) {
|
|
|
|
if (*cp == '{')
|
|
|
|
bracket_depth++;
|
|
|
|
else if (bracket_depth && *cp == '}')
|
|
|
|
bracket_depth--;
|
|
|
|
else if (!bracket_depth && *cp == ':')
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (*cp == ':') {
|
2006-04-22 00:31:04 +00:00
|
|
|
unsigned char tree_sha1[20];
|
|
|
|
if (!get_sha1_1(name, cp-name, tree_sha1))
|
|
|
|
return get_tree_entry(tree_sha1, cp+1, sha1,
|
2007-04-23 20:55:05 +00:00
|
|
|
mode);
|
2006-04-18 23:45:16 +00:00
|
|
|
}
|
|
|
|
return ret;
|
2005-08-04 05:15:49 +00:00
|
|
|
}
|