refs.c: rename ref_array -> ref_dir

This purely textual change is in preparation for storing references
hierarchically, when the old ref_array structure will represent one
"directory" of references.  Rename functions that deal with this
structure analogously, and also rename the structure's "refs" member
to "entries".

Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/refs.c b/refs.c
index 416c97f8c973947c4f73fbab22bfcc29f7fdceb1..4e0cfb2af7c0057df8a15d76dac64ca2d057c344 100644 (file)
--- a/refs.c
+++ b/refs.c
@@ -106,7 +106,7 @@ struct ref_value {
        unsigned char peeled[20];
 };
 
-struct ref_array {
+struct ref_dir {
        int nr, alloc;
 
        /*
@@ -117,7 +117,7 @@ struct ref_array {
         */
        int sorted;
 
-       struct ref_entry **refs;
+       struct ref_entry **entries;
 };
 
 /* ISSYMREF=0x01, ISPACKED=0x02 and ISBROKEN=0x04 are public interfaces */
@@ -156,21 +156,21 @@ static void free_ref_entry(struct ref_entry *entry)
        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)
@@ -180,9 +180,9 @@ 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;
@@ -190,14 +190,14 @@ static struct ref_entry *search_ref_array(struct ref_array *array, const char *r
        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);
 
@@ -227,9 +227,9 @@ static int is_dup_ref(const struct ref_entry *ref1, const struct ref_entry *ref2
 }
 
 /*
- * 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;
 
@@ -237,21 +237,21 @@ static void sort_ref_array(struct ref_array *array)
         * 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
@@ -280,18 +280,18 @@ static int do_one_ref(const char *base, each_ref_fn fn, int trim,
 }
 
 /*
- * 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;
        }
@@ -299,24 +299,24 @@ static int do_for_each_ref_in_array(struct ref_array *array, int offset,
 }
 
 /*
- * 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);
@@ -335,12 +335,12 @@ static int do_for_each_ref_in_arrays(struct ref_array *array1,
                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;
 }
 
@@ -386,17 +386,17 @@ static int name_conflict_fn(const char *existingrefname, const unsigned char *sh
  * 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;
@@ -412,8 +412,8 @@ static struct ref_cache {
        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;
@@ -421,14 +421,14 @@ static struct 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;
 }
 
@@ -507,7 +507,7 @@ static const char *parse_ref_line(char *line, unsigned char *sha1)
        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];
@@ -529,7 +529,7 @@ static void read_packed_refs(FILE *f, struct ref_array *array)
                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 &&
@@ -541,7 +541,7 @@ static void read_packed_refs(FILE *f, struct ref_array *array)
        }
 }
 
-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;
@@ -568,9 +568,9 @@ void add_packed_ref(const char *refname, const unsigned char *sha1)
 }
 
 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)
@@ -578,9 +578,8 @@ static void get_ref_dir(struct ref_cache *refs, const char *base,
        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);
@@ -589,7 +588,7 @@ static void get_ref_dir(struct ref_cache *refs, const char *base,
                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;
@@ -610,7 +609,7 @@ static void get_ref_dir(struct ref_cache *refs, const char *base,
                        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) {
@@ -624,14 +623,14 @@ static void get_ref_dir(struct ref_cache *refs, const char *base,
                                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);
@@ -653,9 +652,9 @@ static int resolve_gitlink_packed_ref(struct ref_cache *refs,
                                      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;
 
@@ -726,8 +725,8 @@ int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sh
  */
 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;
@@ -903,8 +902,8 @@ int peel_ref(const char *refname, unsigned char *sha1)
                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);
@@ -962,13 +961,13 @@ static int do_for_each_ref(const char *submodule, const char *base, each_ref_fn
                           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)
@@ -1403,9 +1402,9 @@ static struct lock_file packlock;
 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);
@@ -1413,7 +1412,7 @@ static int repack_without_ref(const char *refname)
                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);
 }
 
@@ -2024,10 +2023,10 @@ int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn, void *cb_dat
 
 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);
@@ -2036,7 +2035,7 @@ static int do_for_each_reflog(const char *base, each_ref_fn fn, void *cb_data)
                if (baselen && base[baselen-1] != '/')
                        log[baselen++] = '/';
 
-               while ((de = readdir(dir)) != NULL) {
+               while ((de = readdir(d)) != NULL) {
                        struct stat st;
                        int namelen;
 
@@ -2063,7 +2062,7 @@ static int do_for_each_reflog(const char *base, each_ref_fn fn, void *cb_data)
                                break;
                }
                free(log);
-               closedir(dir);
+               closedir(d);
        }
        else if (*base)
                return errno;