resolve_ref(): extract a function get_packed_ref()

Making it a function and giving it a name makes the code clearer.  I
also have a strong suspicion that the function will find other uses in
the future.

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 79ab0eb95f8998b75246bfbc475e374298649f29..473f7f6bc6b01c69d12dc3997232aa0df2a7ce16 100644 (file)
--- a/refs.c
+++ b/refs.c
@@ -465,6 +465,23 @@ int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *re
        return retval;
 }
 
        return retval;
 }
 

+/*
+ * Try to read ref from the packed references.  On success, set sha1
+ * and return 0; otherwise, return -1.
+ */
+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;
+       }
+       return -1;
+}
+

 /*
  * If the "reading" argument is set, this function finds out what _object_
  * the ref points at by "reading" the ref.  The ref, if it is not symbolic,
 /*
  * If the "reading" argument is set, this function finds out what _object_
  * the ref points at by "reading" the ref.  The ref, if it is not symbolic,


@@ -497,22 +514,26 @@ const char *resolve_ref(const char *ref, unsigned char *sha1, int reading, int *
                        return NULL;
 
                git_snpath(path, sizeof(path), "%s", ref);
                        return NULL;
 
                git_snpath(path, sizeof(path), "%s", ref);

-               /* Special case: non-existing file. */
+

                if (lstat(path, &st) < 0) {
                if (lstat(path, &st) < 0) {

-                       struct ref_list *list = get_packed_refs(NULL);
-                       while (list) {
-                               if (!strcmp(ref, list->name)) {
-                                       hashcpy(sha1, list->sha1);
-                                       if (flag)
-                                               *flag |= REF_ISPACKED;
-                                       return ref;
-                               }
-                               list = list->next;
+                       if (errno != ENOENT)
+                               return NULL;
+                       /*
+                        * The loose reference file does not exist;
+                        * check for a packed reference.
+                        */
+                       if (!get_packed_ref(ref, sha1)) {
+                               if (flag)
+                                       *flag |= REF_ISPACKED;
+                               return ref;

                        }
                        }

-                       if (reading || errno != ENOENT)
+                       /* The reference is not a packed reference, either. */
+                       if (reading) {

                                return NULL;
                                return NULL;

-                       hashclr(sha1);
-                       return ref;
+                       } else {
+                               hashclr(sha1);
+                               return ref;
+                       }

                }
 
                /* Follow "normalized" - ie "refs/.." symlinks by hand */
                }
 
                /* Follow "normalized" - ie "refs/.." symlinks by hand */