Merge branch 'jp/get-ref-dir-unsorted'
* jp/get-ref-dir-unsorted: refs.c: free duplicate entries in the ref array instead of leaking them refs.c: abort ref search if ref array is empty refs.c: ensure struct whose member may be passed to realloc is initialized refs: Use binary search to lookup refs faster Don't sort ref_list too early Conflicts: refs.c
This commit is contained in:
Junio C Hamano
commit
2c5c66be6e
349
refs.c
349
refs.c
@ -8,14 +8,18 @@
|
||||
#define REF_KNOWS_PEELED 04
|
||||
#define REF_BROKEN 010
|
||||
|
||||
struct ref_list {
|
||||
struct ref_list *next;
|
||||
struct ref_entry {
|
||||
unsigned char flag; /* ISSYMREF? ISPACKED? */
|
||||
unsigned char sha1[20];
|
||||
unsigned char peeled[20];
|
||||
char name[FLEX_ARRAY];
|
||||
};
|
||||
|
||||
struct ref_array {
|
||||
int nr, alloc;
|
||||
struct ref_entry **refs;
|
||||
};
|
||||
|
||||
static const char *parse_ref_line(char *line, unsigned char *sha1)
|
||||
{
|
||||
/*
|
||||
@ -44,110 +48,86 @@ static const char *parse_ref_line(char *line, unsigned char *sha1)
|
||||
return line;
|
||||
}
|
||||
|
||||
static struct ref_list *add_ref(const char *name, const unsigned char *sha1,
|
||||
int flag, struct ref_list *list,
|
||||
struct ref_list **new_entry)
|
||||
static void add_ref(const char *name, const unsigned char *sha1,
|
||||
int flag, struct ref_array *refs,
|
||||
struct ref_entry **new_entry)
|
||||
{
|
||||
int len;
|
||||
struct ref_list *entry;
|
||||
struct ref_entry *entry;
|
||||
|
||||
/* Allocate it and add it in.. */
|
||||
len = strlen(name) + 1;
|
||||
entry = xmalloc(sizeof(struct ref_list) + len);
|
||||
entry = xmalloc(sizeof(struct ref_entry) + len);
|
||||
hashcpy(entry->sha1, sha1);
|
||||
hashclr(entry->peeled);
|
||||
if (check_refname_format(name, REFNAME_ALLOW_ONELEVEL|REFNAME_DOT_COMPONENT))
|
||||
die("Reference has invalid format: '%s'", name);
|
||||
memcpy(entry->name, name, len);
|
||||
entry->flag = flag;
|
||||
entry->next = list;
|
||||
if (new_entry)
|
||||
*new_entry = entry;
|
||||
return entry;
|
||||
ALLOC_GROW(refs->refs, refs->nr + 1, refs->alloc);
|
||||
refs->refs[refs->nr++] = entry;
|
||||
}
|
||||
|
||||
/* merge sort the ref list */
|
||||
static struct ref_list *sort_ref_list(struct ref_list *list)
|
||||
static int ref_entry_cmp(const void *a, const void *b)
|
||||
{
|
||||
int psize, qsize, last_merge_count, cmp;
|
||||
struct ref_list *p, *q, *l, *e;
|
||||
struct ref_list *new_list = list;
|
||||
int k = 1;
|
||||
int merge_count = 0;
|
||||
struct ref_entry *one = *(struct ref_entry **)a;
|
||||
struct ref_entry *two = *(struct ref_entry **)b;
|
||||
return strcmp(one->name, two->name);
|
||||
}
|
||||
|
||||
if (!list)
|
||||
return list;
|
||||
static void sort_ref_array(struct ref_array *array)
|
||||
{
|
||||
int i = 0, j = 1;
|
||||
|
||||
do {
|
||||
last_merge_count = merge_count;
|
||||
merge_count = 0;
|
||||
/* Nothing to sort unless there are at least two entries */
|
||||
if (array->nr < 2)
|
||||
return;
|
||||
|
||||
psize = 0;
|
||||
qsort(array->refs, array->nr, sizeof(*array->refs), ref_entry_cmp);
|
||||
|
||||
p = new_list;
|
||||
q = new_list;
|
||||
new_list = NULL;
|
||||
l = NULL;
|
||||
/* Remove any duplicates from the ref_array */
|
||||
for (; j < array->nr; j++) {
|
||||
struct ref_entry *a = array->refs[i];
|
||||
struct ref_entry *b = array->refs[j];
|
||||
if (!strcmp(a->name, b->name)) {
|
||||
if (hashcmp(a->sha1, b->sha1))
|
||||
die("Duplicated ref, and SHA1s don't match: %s",
|
||||
a->name);
|
||||
warning("Duplicated ref: %s", a->name);
|
||||
free(b);
|
||||
continue;
|
||||
}
|
||||
i++;
|
||||
array->refs[i] = array->refs[j];
|
||||
}
|
||||
array->nr = i + 1;
|
||||
}
|
||||
|
||||
while (p) {
|
||||
merge_count++;
|
||||
static struct ref_entry *search_ref_array(struct ref_array *array, const char *name)
|
||||
{
|
||||
struct ref_entry *e, **r;
|
||||
int len;
|
||||
|
||||
while (psize < k && q->next) {
|
||||
q = q->next;
|
||||
psize++;
|
||||
}
|
||||
qsize = k;
|
||||
if (name == NULL)
|
||||
return NULL;
|
||||
|
||||
while ((psize > 0) || (qsize > 0 && q)) {
|
||||
if (qsize == 0 || !q) {
|
||||
e = p;
|
||||
p = p->next;
|
||||
psize--;
|
||||
} else if (psize == 0) {
|
||||
e = q;
|
||||
q = q->next;
|
||||
qsize--;
|
||||
} else {
|
||||
cmp = strcmp(q->name, p->name);
|
||||
if (cmp < 0) {
|
||||
e = q;
|
||||
q = q->next;
|
||||
qsize--;
|
||||
} else if (cmp > 0) {
|
||||
e = p;
|
||||
p = p->next;
|
||||
psize--;
|
||||
} else {
|
||||
if (hashcmp(q->sha1, p->sha1))
|
||||
die("Duplicated ref, and SHA1s don't match: %s",
|
||||
q->name);
|
||||
warning("Duplicated ref: %s", q->name);
|
||||
e = q;
|
||||
q = q->next;
|
||||
qsize--;
|
||||
free(e);
|
||||
e = p;
|
||||
p = p->next;
|
||||
psize--;
|
||||
}
|
||||
}
|
||||
if (!array->nr)
|
||||
return NULL;
|
||||
|
||||
e->next = NULL;
|
||||
len = strlen(name) + 1;
|
||||
e = xmalloc(sizeof(struct ref_entry) + len);
|
||||
memcpy(e->name, name, len);
|
||||
|
||||
if (l)
|
||||
l->next = e;
|
||||
if (!new_list)
|
||||
new_list = e;
|
||||
l = e;
|
||||
}
|
||||
r = bsearch(&e, array->refs, array->nr, sizeof(*array->refs), ref_entry_cmp);
|
||||
|
||||
p = q;
|
||||
};
|
||||
free(e);
|
||||
|
||||
k = k * 2;
|
||||
} while ((last_merge_count != merge_count) || (last_merge_count != 1));
|
||||
if (r == NULL)
|
||||
return NULL;
|
||||
|
||||
return new_list;
|
||||
return *r;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -158,32 +138,32 @@ static struct cached_refs {
|
||||
struct cached_refs *next;
|
||||
char did_loose;
|
||||
char did_packed;
|
||||
struct ref_list *loose;
|
||||
struct ref_list *packed;
|
||||
struct ref_array loose;
|
||||
struct ref_array packed;
|
||||
/* The submodule name, or "" for the main repo. */
|
||||
char name[FLEX_ARRAY];
|
||||
} *cached_refs;
|
||||
|
||||
static struct ref_list *current_ref;
|
||||
static struct ref_entry *current_ref;
|
||||
|
||||
static struct ref_list *extra_refs;
|
||||
static struct ref_array extra_refs;
|
||||
|
||||
static void free_ref_list(struct ref_list *list)
|
||||
static void free_ref_array(struct ref_array *array)
|
||||
{
|
||||
struct ref_list *next;
|
||||
for ( ; list; list = next) {
|
||||
next = list->next;
|
||||
free(list);
|
||||
}
|
||||
int i;
|
||||
for (i = 0; i < array->nr; i++)
|
||||
free(array->refs[i]);
|
||||
free(array->refs);
|
||||
array->nr = array->alloc = 0;
|
||||
array->refs = NULL;
|
||||
}
|
||||
|
||||
static void clear_cached_refs(struct cached_refs *ca)
|
||||
{
|
||||
if (ca->did_loose && ca->loose)
|
||||
free_ref_list(ca->loose);
|
||||
if (ca->did_packed && ca->packed)
|
||||
free_ref_list(ca->packed);
|
||||
ca->loose = ca->packed = NULL;
|
||||
if (ca->did_loose)
|
||||
free_ref_array(&ca->loose);
|
||||
if (ca->did_packed)
|
||||
free_ref_array(&ca->packed);
|
||||
ca->did_loose = ca->did_packed = 0;
|
||||
}
|
||||
|
||||
@ -194,10 +174,7 @@ static struct cached_refs *create_cached_refs(const char *submodule)
|
||||
if (!submodule)
|
||||
submodule = "";
|
||||
len = strlen(submodule) + 1;
|
||||
refs = xmalloc(sizeof(struct cached_refs) + len);
|
||||
refs->next = NULL;
|
||||
refs->did_loose = refs->did_packed = 0;
|
||||
refs->loose = refs->packed = NULL;
|
||||
refs = xcalloc(1, sizeof(struct cached_refs) + len);
|
||||
memcpy(refs->name, submodule, len);
|
||||
return refs;
|
||||
}
|
||||
@ -234,10 +211,9 @@ static void invalidate_cached_refs(void)
|
||||
}
|
||||
}
|
||||
|
||||
static struct ref_list *read_packed_refs(FILE *f)
|
||||
static void read_packed_refs(FILE *f, struct ref_array *array)
|
||||
{
|
||||
struct ref_list *list = NULL;
|
||||
struct ref_list *last = NULL;
|
||||
struct ref_entry *last = NULL;
|
||||
char refline[PATH_MAX];
|
||||
int flag = REF_ISPACKED;
|
||||
|
||||
@ -256,7 +232,7 @@ static struct ref_list *read_packed_refs(FILE *f)
|
||||
|
||||
name = parse_ref_line(refline, sha1);
|
||||
if (name) {
|
||||
list = add_ref(name, sha1, flag, list, &last);
|
||||
add_ref(name, sha1, flag, array, &last);
|
||||
continue;
|
||||
}
|
||||
if (last &&
|
||||
@ -266,21 +242,20 @@ static struct ref_list *read_packed_refs(FILE *f)
|
||||
!get_sha1_hex(refline + 1, sha1))
|
||||
hashcpy(last->peeled, sha1);
|
||||
}
|
||||
return sort_ref_list(list);
|
||||
sort_ref_array(array);
|
||||
}
|
||||
|
||||
void add_extra_ref(const char *name, const unsigned char *sha1, int flag)
|
||||
{
|
||||
extra_refs = add_ref(name, sha1, flag, extra_refs, NULL);
|
||||
add_ref(name, sha1, flag, &extra_refs, NULL);
|
||||
}
|
||||
|
||||
void clear_extra_refs(void)
|
||||
{
|
||||
free_ref_list(extra_refs);
|
||||
extra_refs = NULL;
|
||||
free_ref_array(&extra_refs);
|
||||
}
|
||||
|
||||
static struct ref_list *get_packed_refs(const char *submodule)
|
||||
static struct ref_array *get_packed_refs(const char *submodule)
|
||||
{
|
||||
struct cached_refs *refs = get_cached_refs(submodule);
|
||||
|
||||
@ -293,18 +268,17 @@ static struct ref_list *get_packed_refs(const char *submodule)
|
||||
else
|
||||
packed_refs_file = git_path("packed-refs");
|
||||
f = fopen(packed_refs_file, "r");
|
||||
refs->packed = NULL;
|
||||
if (f) {
|
||||
refs->packed = read_packed_refs(f);
|
||||
read_packed_refs(f, &refs->packed);
|
||||
fclose(f);
|
||||
}
|
||||
refs->did_packed = 1;
|
||||
}
|
||||
return refs->packed;
|
||||
return &refs->packed;
|
||||
}
|
||||
|
||||
static struct ref_list *get_ref_dir(const char *submodule, const char *base,
|
||||
struct ref_list *list)
|
||||
static void get_ref_dir(const char *submodule, const char *base,
|
||||
struct ref_array *array)
|
||||
{
|
||||
DIR *dir;
|
||||
const char *path;
|
||||
@ -347,7 +321,7 @@ static struct ref_list *get_ref_dir(const char *submodule, const char *base,
|
||||
if (stat(refdir, &st) < 0)
|
||||
continue;
|
||||
if (S_ISDIR(st.st_mode)) {
|
||||
list = get_ref_dir(submodule, ref, list);
|
||||
get_ref_dir(submodule, ref, array);
|
||||
continue;
|
||||
}
|
||||
if (submodule) {
|
||||
@ -362,12 +336,11 @@ static struct ref_list *get_ref_dir(const char *submodule, const char *base,
|
||||
hashclr(sha1);
|
||||
flag |= REF_BROKEN;
|
||||
}
|
||||
list = add_ref(ref, sha1, flag, list, NULL);
|
||||
add_ref(ref, sha1, flag, array, NULL);
|
||||
}
|
||||
free(ref);
|
||||
closedir(dir);
|
||||
}
|
||||
return sort_ref_list(list);
|
||||
}
|
||||
|
||||
struct warn_if_dangling_data {
|
||||
@ -404,15 +377,16 @@ void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)
|
||||
for_each_rawref(warn_if_dangling_symref, &data);
|
||||
}
|
||||
|
||||
static struct ref_list *get_loose_refs(const char *submodule)
|
||||
static struct ref_array *get_loose_refs(const char *submodule)
|
||||
{
|
||||
struct cached_refs *refs = get_cached_refs(submodule);
|
||||
|
||||
if (!refs->did_loose) {
|
||||
refs->loose = get_ref_dir(submodule, "refs", NULL);
|
||||
get_ref_dir(submodule, "refs", &refs->loose);
|
||||
sort_ref_array(&refs->loose);
|
||||
refs->did_loose = 1;
|
||||
}
|
||||
return refs->loose;
|
||||
return &refs->loose;
|
||||
}
|
||||
|
||||
/* We allow "recursive" symbolic refs. Only within reason, though */
|
||||
@ -421,28 +395,15 @@ static struct ref_list *get_loose_refs(const char *submodule)
|
||||
|
||||
static int resolve_gitlink_packed_ref(char *name, int pathlen, const char *refname, unsigned char *result)
|
||||
{
|
||||
FILE *f;
|
||||
struct ref_list *packed_refs;
|
||||
struct ref_list *ref;
|
||||
int retval;
|
||||
int retval = -1;
|
||||
struct ref_entry *ref;
|
||||
struct ref_array *array = get_packed_refs(name);
|
||||
|
||||
strcpy(name + pathlen, "packed-refs");
|
||||
f = fopen(name, "r");
|
||||
if (!f)
|
||||
return -1;
|
||||
packed_refs = read_packed_refs(f);
|
||||
fclose(f);
|
||||
ref = packed_refs;
|
||||
retval = -1;
|
||||
while (ref) {
|
||||
if (!strcmp(ref->name, refname)) {
|
||||
retval = 0;
|
||||
memcpy(result, ref->sha1, 20);
|
||||
break;
|
||||
}
|
||||
ref = ref->next;
|
||||
ref = search_ref_array(array, refname);
|
||||
if (ref != NULL) {
|
||||
memcpy(result, ref->sha1, 20);
|
||||
retval = 0;
|
||||
}
|
||||
free_ref_list(packed_refs);
|
||||
return retval;
|
||||
}
|
||||
|
||||
@ -515,13 +476,11 @@ int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *re
|
||||
*/
|
||||
static int get_packed_ref(const char *ref, unsigned char *sha1)
|
||||
{
|
||||
struct ref_list *list = get_packed_refs(NULL);
|
||||
while (list) {
|
||||
if (!strcmp(ref, list->name)) {
|
||||
hashcpy(sha1, list->sha1);
|
||||
return 0;
|
||||
}
|
||||
list = list->next;
|
||||
struct ref_array *packed = get_packed_refs(NULL);
|
||||
struct ref_entry *entry = search_ref_array(packed, ref);
|
||||
if (entry) {
|
||||
hashcpy(sha1, entry->sha1);
|
||||
return 0;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
@ -649,7 +608,7 @@ int read_ref(const char *ref, unsigned char *sha1)
|
||||
|
||||
#define DO_FOR_EACH_INCLUDE_BROKEN 01
|
||||
static int do_one_ref(const char *base, each_ref_fn fn, int trim,
|
||||
int flags, void *cb_data, struct ref_list *entry)
|
||||
int flags, void *cb_data, struct ref_entry *entry)
|
||||
{
|
||||
if (prefixcmp(entry->name, base))
|
||||
return 0;
|
||||
@ -695,18 +654,12 @@ int peel_ref(const char *ref, unsigned char *sha1)
|
||||
return -1;
|
||||
|
||||
if ((flag & REF_ISPACKED)) {
|
||||
struct ref_list *list = get_packed_refs(NULL);
|
||||
struct ref_array *array = get_packed_refs(NULL);
|
||||
struct ref_entry *r = search_ref_array(array, ref);
|
||||
|
||||
while (list) {
|
||||
if (!strcmp(list->name, ref)) {
|
||||
if (list->flag & REF_KNOWS_PEELED) {
|
||||
hashcpy(sha1, list->peeled);
|
||||
return 0;
|
||||
}
|
||||
/* older pack-refs did not leave peeled ones */
|
||||
break;
|
||||
}
|
||||
list = list->next;
|
||||
if (r != NULL && r->flag & REF_KNOWS_PEELED) {
|
||||
hashcpy(sha1, r->peeled);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
@ -725,36 +678,39 @@ fallback:
|
||||
static int do_for_each_ref(const char *submodule, const char *base, each_ref_fn fn,
|
||||
int trim, int flags, void *cb_data)
|
||||
{
|
||||
int retval = 0;
|
||||
struct ref_list *packed = get_packed_refs(submodule);
|
||||
struct ref_list *loose = get_loose_refs(submodule);
|
||||
int retval = 0, i, p = 0, l = 0;
|
||||
struct ref_array *packed = get_packed_refs(submodule);
|
||||
struct ref_array *loose = get_loose_refs(submodule);
|
||||
|
||||
struct ref_list *extra;
|
||||
struct ref_array *extra = &extra_refs;
|
||||
|
||||
for (extra = extra_refs; extra; extra = extra->next)
|
||||
retval = do_one_ref(base, fn, trim, flags, cb_data, extra);
|
||||
for (i = 0; i < extra->nr; i++)
|
||||
retval = do_one_ref(base, fn, trim, flags, cb_data, extra->refs[i]);
|
||||
|
||||
while (packed && loose) {
|
||||
struct ref_list *entry;
|
||||
int cmp = strcmp(packed->name, loose->name);
|
||||
while (p < packed->nr && l < loose->nr) {
|
||||
struct ref_entry *entry;
|
||||
int cmp = strcmp(packed->refs[p]->name, loose->refs[l]->name);
|
||||
if (!cmp) {
|
||||
packed = packed->next;
|
||||
p++;
|
||||
continue;
|
||||
}
|
||||
if (cmp > 0) {
|
||||
entry = loose;
|
||||
loose = loose->next;
|
||||
entry = loose->refs[l++];
|
||||
} else {
|
||||
entry = packed;
|
||||
packed = packed->next;
|
||||
entry = packed->refs[p++];
|
||||
}
|
||||
retval = do_one_ref(base, fn, trim, flags, cb_data, entry);
|
||||
if (retval)
|
||||
goto end_each;
|
||||
}
|
||||
|
||||
for (packed = packed ? packed : loose; packed; packed = packed->next) {
|
||||
retval = do_one_ref(base, fn, trim, flags, cb_data, packed);
|
||||
if (l < loose->nr) {
|
||||
p = l;
|
||||
packed = loose;
|
||||
}
|
||||
|
||||
for (; p < packed->nr; p++) {
|
||||
retval = do_one_ref(base, fn, trim, flags, cb_data, packed->refs[p]);
|
||||
if (retval)
|
||||
goto end_each;
|
||||
}
|
||||
@ -1087,24 +1043,24 @@ static int remove_empty_directories(const char *file)
|
||||
}
|
||||
|
||||
static int is_refname_available(const char *ref, const char *oldref,
|
||||
struct ref_list *list, int quiet)
|
||||
struct ref_array *array, int quiet)
|
||||
{
|
||||
int namlen = strlen(ref); /* e.g. 'foo/bar' */
|
||||
while (list) {
|
||||
/* list->name could be 'foo' or 'foo/bar/baz' */
|
||||
if (!oldref || strcmp(oldref, list->name)) {
|
||||
int len = strlen(list->name);
|
||||
int i, namlen = strlen(ref); /* e.g. 'foo/bar' */
|
||||
for (i = 0; i < array->nr; i++ ) {
|
||||
struct ref_entry *entry = array->refs[i];
|
||||
/* entry->name could be 'foo' or 'foo/bar/baz' */
|
||||
if (!oldref || strcmp(oldref, entry->name)) {
|
||||
int len = strlen(entry->name);
|
||||
int cmplen = (namlen < len) ? namlen : len;
|
||||
const char *lead = (namlen < len) ? list->name : ref;
|
||||
if (!strncmp(ref, list->name, cmplen) &&
|
||||
const char *lead = (namlen < len) ? entry->name : ref;
|
||||
if (!strncmp(ref, entry->name, cmplen) &&
|
||||
lead[cmplen] == '/') {
|
||||
if (!quiet)
|
||||
error("'%s' exists; cannot create '%s'",
|
||||
list->name, ref);
|
||||
entry->name, ref);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
list = list->next;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
@ -1207,18 +1163,13 @@ static struct lock_file packlock;
|
||||
|
||||
static int repack_without_ref(const char *refname)
|
||||
{
|
||||
struct ref_list *list, *packed_ref_list;
|
||||
int fd;
|
||||
int found = 0;
|
||||
struct ref_array *packed;
|
||||
struct ref_entry *ref;
|
||||
int fd, i;
|
||||
|
||||
packed_ref_list = get_packed_refs(NULL);
|
||||
for (list = packed_ref_list; list; list = list->next) {
|
||||
if (!strcmp(refname, list->name)) {
|
||||
found = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!found)
|
||||
packed = get_packed_refs(NULL);
|
||||
ref = search_ref_array(packed, refname);
|
||||
if (ref == NULL)
|
||||
return 0;
|
||||
fd = hold_lock_file_for_update(&packlock, git_path("packed-refs"), 0);
|
||||
if (fd < 0) {
|
||||
@ -1226,17 +1177,19 @@ static int repack_without_ref(const char *refname)
|
||||
return error("cannot delete '%s' from packed refs", refname);
|
||||
}
|
||||
|
||||
for (list = packed_ref_list; list; list = list->next) {
|
||||
for (i = 0; i < packed->nr; i++) {
|
||||
char line[PATH_MAX + 100];
|
||||
int len;
|
||||
|
||||
if (!strcmp(refname, list->name))
|
||||
ref = packed->refs[i];
|
||||
|
||||
if (!strcmp(refname, ref->name))
|
||||
continue;
|
||||
len = snprintf(line, sizeof(line), "%s %s\n",
|
||||
sha1_to_hex(list->sha1), list->name);
|
||||
sha1_to_hex(ref->sha1), ref->name);
|
||||
/* this should not happen but just being defensive */
|
||||
if (len > sizeof(line))
|
||||
die("too long a refname '%s'", list->name);
|
||||
die("too long a refname '%s'", ref->name);
|
||||
write_or_die(fd, line, len);
|
||||
}
|
||||
return commit_lock_file(&packlock);
|
||||
@ -1931,7 +1884,7 @@ int update_ref(const char *action, const char *refname,
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ref_exists(char *refname)
|
||||
int ref_exists(const char *refname)
|
||||
{
|
||||
unsigned char sha1[20];
|
||||
return !!resolve_ref(refname, sha1, 1, NULL);
|
||||
|
||||
2
refs.h
2
refs.h
@ -57,7 +57,7 @@ extern void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refn
|
||||
*/
|
||||
extern void add_extra_ref(const char *refname, const unsigned char *sha1, int flags);
|
||||
extern void clear_extra_refs(void);
|
||||
extern int ref_exists(char *);
|
||||
extern int ref_exists(const char *);
|
||||
|
||||
extern int peel_ref(const char *, unsigned char *);
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user