unsigned char peeled[20];
};
-struct ref_array {
+struct ref_dir {
int nr, alloc;
/*
*/
int sorted;
- struct ref_entry **refs;
+ struct ref_entry **entries;
};
/* ISSYMREF=0x01, ISPACKED=0x02 and ISBROKEN=0x04 are public interfaces */
free(entry);
}
-/* Add a ref_entry to the end of the ref_array (unsorted). */
-static void add_ref(struct ref_array *refs, struct ref_entry *ref)
+/* Add a ref_entry to the end of the ref_dir (unsorted). */
+static void add_ref(struct ref_dir *refs, struct ref_entry *ref)
{
- ALLOC_GROW(refs->refs, refs->nr + 1, refs->alloc);
- refs->refs[refs->nr++] = ref;
+ ALLOC_GROW(refs->entries, refs->nr + 1, refs->alloc);
+ refs->entries[refs->nr++] = ref;
}
-static void clear_ref_array(struct ref_array *array)
+static void clear_ref_dir(struct ref_dir *dir)
{
int i;
- for (i = 0; i < array->nr; i++)
- free_ref_entry(array->refs[i]);
- free(array->refs);
- array->sorted = array->nr = array->alloc = 0;
- array->refs = NULL;
+ for (i = 0; i < dir->nr; i++)
+ free_ref_entry(dir->entries[i]);
+ free(dir->entries);
+ dir->sorted = dir->nr = dir->alloc = 0;
+ dir->entries = NULL;
}
static int ref_entry_cmp(const void *a, const void *b)
return strcmp(one->name, two->name);
}
-static void sort_ref_array(struct ref_array *array);
+static void sort_ref_dir(struct ref_dir *dir);
-static struct ref_entry *search_ref_array(struct ref_array *array, const char *refname)
+static struct ref_entry *search_ref_dir(struct ref_dir *dir, const char *refname)
{
struct ref_entry *e, **r;
int len;
if (refname == NULL)
return NULL;
- if (!array->nr)
+ if (!dir->nr)
return NULL;
- sort_ref_array(array);
+ sort_ref_dir(dir);
len = strlen(refname) + 1;
e = xmalloc(sizeof(struct ref_entry) + len);
memcpy(e->name, refname, len);
- r = bsearch(&e, array->refs, array->nr, sizeof(*array->refs), ref_entry_cmp);
+ r = bsearch(&e, dir->entries, dir->nr, sizeof(*dir->entries), ref_entry_cmp);
free(e);
}
/*
- * Sort the entries in array (if they are not already sorted).
+ * Sort the entries in dir (if they are not already sorted).
*/
-static void sort_ref_array(struct ref_array *array)
+static void sort_ref_dir(struct ref_dir *dir)
{
int i, j;
* This check also prevents passing a zero-length array to qsort(),
* which is a problem on some platforms.
*/
- if (array->sorted == array->nr)
+ if (dir->sorted == dir->nr)
return;
- qsort(array->refs, array->nr, sizeof(*array->refs), ref_entry_cmp);
+ qsort(dir->entries, dir->nr, sizeof(*dir->entries), ref_entry_cmp);
- /* Remove any duplicates from the ref_array */
+ /* Remove any duplicates from the ref_dir */
i = 0;
- for (j = 1; j < array->nr; j++) {
- if (is_dup_ref(array->refs[i], array->refs[j])) {
- free_ref_entry(array->refs[j]);
+ for (j = 1; j < dir->nr; j++) {
+ if (is_dup_ref(dir->entries[i], dir->entries[j])) {
+ free_ref_entry(dir->entries[j]);
continue;
}
- array->refs[++i] = array->refs[j];
+ dir->entries[++i] = dir->entries[j];
}
- array->sorted = array->nr = i + 1;
+ dir->sorted = dir->nr = i + 1;
}
#define DO_FOR_EACH_INCLUDE_BROKEN 01
}
/*
- * Call fn for each reference in array that has index in the range
- * offset <= index < array->nr. This function does not sort the
- * array; sorting should be done by the caller.
+ * Call fn for each reference in dir that has index in the range
+ * offset <= index < dir->nr. This function does not sort the dir;
+ * sorting should be done by the caller.
*/
-static int do_for_each_ref_in_array(struct ref_array *array, int offset,
- const char *base,
- each_ref_fn fn, int trim, int flags, void *cb_data)
+static int do_for_each_ref_in_dir(struct ref_dir *dir, int offset,
+ const char *base,
+ each_ref_fn fn, int trim, int flags, void *cb_data)
{
int i;
- assert(array->sorted == array->nr);
- for (i = offset; i < array->nr; i++) {
- int retval = do_one_ref(base, fn, trim, flags, cb_data, array->refs[i]);
+ assert(dir->sorted == dir->nr);
+ for (i = offset; i < dir->nr; i++) {
+ int retval = do_one_ref(base, fn, trim, flags, cb_data, dir->entries[i]);
if (retval)
return retval;
}
}
/*
- * Call fn for each reference in the union of array1 and array2, in
- * order by refname. If an entry appears in both array1 and array2,
- * then only process the version that is in array2. The input arrays
- * must already be sorted.
+ * Call fn for each reference in the union of dir1 and dir2, in order
+ * by refname. If an entry appears in both dir1 and dir2, then only
+ * process the version that is in dir2. The input dirs must already
+ * be sorted.
*/
-static int do_for_each_ref_in_arrays(struct ref_array *array1,
- struct ref_array *array2,
- const char *base, each_ref_fn fn, int trim,
- int flags, void *cb_data)
+static int do_for_each_ref_in_dirs(struct ref_dir *dir1,
+ struct ref_dir *dir2,
+ const char *base, each_ref_fn fn, int trim,
+ int flags, void *cb_data)
{
int retval;
int i1 = 0, i2 = 0;
- assert(array1->sorted == array1->nr);
- assert(array2->sorted == array2->nr);
- while (i1 < array1->nr && i2 < array2->nr) {
- struct ref_entry *e1 = array1->refs[i1];
- struct ref_entry *e2 = array2->refs[i2];
+ assert(dir1->sorted == dir1->nr);
+ assert(dir2->sorted == dir2->nr);
+ while (i1 < dir1->nr && i2 < dir2->nr) {
+ struct ref_entry *e1 = dir1->entries[i1];
+ struct ref_entry *e2 = dir2->entries[i2];
int cmp = strcmp(e1->name, e2->name);
if (cmp < 0) {
retval = do_one_ref(base, fn, trim, flags, cb_data, e1);
if (retval)
return retval;
}
- if (i1 < array1->nr)
- return do_for_each_ref_in_array(array1, i1,
- base, fn, trim, flags, cb_data);
- if (i2 < array2->nr)
- return do_for_each_ref_in_array(array2, i2,
- base, fn, trim, flags, cb_data);
+ if (i1 < dir1->nr)
+ return do_for_each_ref_in_dir(dir1, i1,
+ base, fn, trim, flags, cb_data);
+ if (i2 < dir2->nr)
+ return do_for_each_ref_in_dir(dir2, i2,
+ base, fn, trim, flags, cb_data);
return 0;
}
* operation).
*/
static int is_refname_available(const char *refname, const char *oldrefname,
- struct ref_array *array)
+ struct ref_dir *dir)
{
struct name_conflict_cb data;
data.refname = refname;
data.oldrefname = oldrefname;
data.conflicting_refname = NULL;
- sort_ref_array(array);
- if (do_for_each_ref_in_array(array, 0, "", name_conflict_fn,
- 0, DO_FOR_EACH_INCLUDE_BROKEN,
- &data)) {
+ sort_ref_dir(dir);
+ if (do_for_each_ref_in_dir(dir, 0, "", name_conflict_fn,
+ 0, DO_FOR_EACH_INCLUDE_BROKEN,
+ &data)) {
error("'%s' exists; cannot create '%s'",
data.conflicting_refname, refname);
return 0;
struct ref_cache *next;
char did_loose;
char did_packed;
- struct ref_array loose;
- struct ref_array packed;
+ struct ref_dir loose;
+ struct ref_dir packed;
/* The submodule name, or "" for the main repo. */
char name[FLEX_ARRAY];
} *ref_cache;
static void clear_packed_ref_cache(struct ref_cache *refs)
{
if (refs->did_packed)
- clear_ref_array(&refs->packed);
+ clear_ref_dir(&refs->packed);
refs->did_packed = 0;
}
static void clear_loose_ref_cache(struct ref_cache *refs)
{
if (refs->did_loose)
- clear_ref_array(&refs->loose);
+ clear_ref_dir(&refs->loose);
refs->did_loose = 0;
}
return line;
}
-static void read_packed_refs(FILE *f, struct ref_array *array)
+static void read_packed_refs(FILE *f, struct ref_dir *dir)
{
struct ref_entry *last = NULL;
char refline[PATH_MAX];
refname = parse_ref_line(refline, sha1);
if (refname) {
last = create_ref_entry(refname, sha1, flag, 1);
- add_ref(array, last);
+ add_ref(dir, last);
continue;
}
if (last &&
}
}
-static struct ref_array *get_packed_refs(struct ref_cache *refs)
+static struct ref_dir *get_packed_refs(struct ref_cache *refs)
{
if (!refs->did_packed) {
const char *packed_refs_file;
}
static void get_ref_dir(struct ref_cache *refs, const char *base,
- struct ref_array *array)
+ struct ref_dir *dir)
{
- DIR *dir;
+ DIR *d;
const char *path;
if (*refs->name)
else
path = git_path("%s", base);
- dir = opendir(path);
-
- if (dir) {
+ d = opendir(path);
+ if (d) {
struct dirent *de;
int baselen = strlen(base);
char *refname = xmalloc(baselen + 257);
if (baselen && base[baselen-1] != '/')
refname[baselen++] = '/';
- while ((de = readdir(dir)) != NULL) {
+ while ((de = readdir(d)) != NULL) {
unsigned char sha1[20];
struct stat st;
int flag;
if (stat(refdir, &st) < 0)
continue;
if (S_ISDIR(st.st_mode)) {
- get_ref_dir(refs, refname, array);
+ get_ref_dir(refs, refname, dir);
continue;
}
if (*refs->name) {
hashclr(sha1);
flag |= REF_ISBROKEN;
}
- add_ref(array, create_ref_entry(refname, sha1, flag, 1));
+ add_ref(dir, create_ref_entry(refname, sha1, flag, 1));
}
free(refname);
- closedir(dir);
+ closedir(d);
}
}
-static struct ref_array *get_loose_refs(struct ref_cache *refs)
+static struct ref_dir *get_loose_refs(struct ref_cache *refs)
{
if (!refs->did_loose) {
get_ref_dir(refs, "refs", &refs->loose);
const char *refname, unsigned char *sha1)
{
struct ref_entry *ref;
- struct ref_array *array = get_packed_refs(refs);
+ struct ref_dir *dir = get_packed_refs(refs);
- ref = search_ref_array(array, refname);
+ ref = search_ref_dir(dir, refname);
if (ref == NULL)
return -1;
*/
static int get_packed_ref(const char *refname, unsigned char *sha1)
{
- struct ref_array *packed = get_packed_refs(get_ref_cache(NULL));
- struct ref_entry *entry = search_ref_array(packed, refname);
+ struct ref_dir *packed = get_packed_refs(get_ref_cache(NULL));
+ struct ref_entry *entry = search_ref_dir(packed, refname);
if (entry) {
hashcpy(sha1, entry->u.value.sha1);
return 0;
return -1;
if ((flag & REF_ISPACKED)) {
- struct ref_array *array = get_packed_refs(get_ref_cache(NULL));
- struct ref_entry *r = search_ref_array(array, refname);
+ struct ref_dir *dir = get_packed_refs(get_ref_cache(NULL));
+ struct ref_entry *r = search_ref_dir(dir, refname);
if (r != NULL && r->flag & REF_KNOWS_PEELED) {
hashcpy(sha1, r->u.value.peeled);
int trim, int flags, void *cb_data)
{
struct ref_cache *refs = get_ref_cache(submodule);
- struct ref_array *packed_refs = get_packed_refs(refs);
- struct ref_array *loose_refs = get_loose_refs(refs);
- sort_ref_array(packed_refs);
- sort_ref_array(loose_refs);
- return do_for_each_ref_in_arrays(packed_refs,
- loose_refs,
- base, fn, trim, flags, cb_data);
+ struct ref_dir *packed_refs = get_packed_refs(refs);
+ struct ref_dir *loose_refs = get_loose_refs(refs);
+ sort_ref_dir(packed_refs);
+ sort_ref_dir(loose_refs);
+ return do_for_each_ref_in_dirs(packed_refs,
+ loose_refs,
+ base, fn, trim, flags, cb_data);
}
static int do_head_ref(const char *submodule, each_ref_fn fn, void *cb_data)
static int repack_without_ref(const char *refname)
{
struct repack_without_ref_sb data;
- struct ref_array *packed = get_packed_refs(get_ref_cache(NULL));
- sort_ref_array(packed);
- if (search_ref_array(packed, refname) == NULL)
+ struct ref_dir *packed = get_packed_refs(get_ref_cache(NULL));
+ sort_ref_dir(packed);
+ if (search_ref_dir(packed, refname) == NULL)
return 0;
data.refname = refname;
data.fd = hold_lock_file_for_update(&packlock, git_path("packed-refs"), 0);
unable_to_lock_error(git_path("packed-refs"), errno);
return error("cannot delete '%s' from packed refs", refname);
}
- do_for_each_ref_in_array(packed, 0, "", repack_without_ref_fn, 0, 0, &data);
+ do_for_each_ref_in_dir(packed, 0, "", repack_without_ref_fn, 0, 0, &data);
return commit_lock_file(&packlock);
}
static int do_for_each_reflog(const char *base, each_ref_fn fn, void *cb_data)
{
- DIR *dir = opendir(git_path("logs/%s", base));
+ DIR *d = opendir(git_path("logs/%s", base));
int retval = 0;
- if (dir) {
+ if (d) {
struct dirent *de;
int baselen = strlen(base);
char *log = xmalloc(baselen + 257);
if (baselen && base[baselen-1] != '/')
log[baselen++] = '/';
- while ((de = readdir(dir)) != NULL) {
+ while ((de = readdir(d)) != NULL) {
struct stat st;
int namelen;
break;
}
free(log);
- closedir(dir);
+ closedir(d);
}
else if (*base)
return errno;
projects / git.git / blobdiff