Merge branch 'jc/reflog-reverse-walk' into nd/branch-show-rebase-bisect-state
authorJunio C Hamano <gitster@pobox.com>
Wed, 13 Mar 2013 16:29:23 +0000 (09:29 -0700)
committerJunio C Hamano <gitster@pobox.com>
Wed, 13 Mar 2013 16:29:23 +0000 (09:29 -0700)
* jc/reflog-reverse-walk:
reflog: add for_each_reflog_ent_reverse() API
for_each_recent_reflog_ent(): simplify opening of a reflog file
for_each_reflog_ent(): extract a helper to process a single entry

1  2 
refs.c
diff --combined refs.c
index 29628253087fb0d54a8f7a45938624527f35d4a8,8e24060d804346823cd2d89a94ff431617a56194..69da0d57cfbfa0e8f545fe106614df41190c5d7f
--- 1/refs.c
--- 2/refs.c
+++ b/refs.c
@@@ -333,12 -333,14 +333,12 @@@ struct string_slice 
  
  static int ref_entry_cmp_sslice(const void *key_, const void *ent_)
  {
 -      struct string_slice *key = (struct string_slice *)key_;
 -      struct ref_entry *ent = *(struct ref_entry **)ent_;
 -      int entlen = strlen(ent->name);
 -      int cmplen = key->len < entlen ? key->len : entlen;
 -      int cmp = memcmp(key->str, ent->name, cmplen);
 +      const struct string_slice *key = key_;
 +      const struct ref_entry *ent = *(const struct ref_entry * const *)ent_;
 +      int cmp = strncmp(key->str, ent->name, key->len);
        if (cmp)
                return cmp;
 -      return key->len - entlen;
 +      return '\0' - (unsigned char)ent->name[key->len];
  }
  
  /*
@@@ -1200,8 -1202,6 +1200,8 @@@ int peel_ref(const char *refname, unsig
        if (current_ref && (current_ref->name == refname
                || !strcmp(current_ref->name, refname))) {
                if (current_ref->flag & REF_KNOWS_PEELED) {
 +                      if (is_null_sha1(current_ref->u.value.peeled))
 +                          return -1;
                        hashcpy(sha1, current_ref->u.value.peeled);
                        return 0;
                }
        }
  
  fallback:
 -      o = parse_object(base);
 -      if (o && o->type == OBJ_TAG) {
 -              o = deref_tag(o, refname, 0);
 +      o = lookup_unknown_object(base);
 +      if (o->type == OBJ_NONE) {
 +              int type = sha1_object_info(base, NULL);
 +              if (type < 0)
 +                      return -1;
 +              o->type = type;
 +      }
 +
 +      if (o->type == OBJ_TAG) {
 +              o = deref_tag_noverify(o);
                if (o) {
                        hashcpy(sha1, o->sha1);
                        return 0;
@@@ -1742,8 -1735,7 +1742,8 @@@ static struct lock_file packlock
  static int repack_without_ref(const char *refname)
  {
        struct repack_without_ref_sb data;
 -      struct ref_dir *packed = get_packed_refs(get_ref_cache(NULL));
 +      struct ref_cache *refs = get_ref_cache(NULL);
 +      struct ref_dir *packed = get_packed_refs(refs);
        if (find_ref(packed, refname) == NULL)
                return 0;
        data.refname = refname;
                unable_to_lock_error(git_path("packed-refs"), errno);
                return error("cannot delete '%s' from packed refs", refname);
        }
 +      clear_packed_ref_cache(refs);
 +      packed = get_packed_refs(refs);
        do_for_each_ref_in_dir(packed, 0, "", repack_without_ref_fn, 0, 0, &data);
        return commit_lock_file(&packlock);
  }
@@@ -1763,24 -1753,32 +1763,24 @@@ int delete_ref(const char *refname, con
        struct ref_lock *lock;
        int err, i = 0, ret = 0, flag = 0;
  
 -      lock = lock_ref_sha1_basic(refname, sha1, 0, &flag);
 +      lock = lock_ref_sha1_basic(refname, sha1, delopt, &flag);
        if (!lock)
                return 1;
        if (!(flag & REF_ISPACKED) || flag & REF_ISSYMREF) {
                /* loose */
 -              const char *path;
 -
 -              if (!(delopt & REF_NODEREF)) {
 -                      i = strlen(lock->lk->filename) - 5; /* .lock */
 -                      lock->lk->filename[i] = 0;
 -                      path = lock->lk->filename;
 -              } else {
 -                      path = git_path("%s", refname);
 -              }
 -              err = unlink_or_warn(path);
 +              i = strlen(lock->lk->filename) - 5; /* .lock */
 +              lock->lk->filename[i] = 0;
 +              err = unlink_or_warn(lock->lk->filename);
                if (err && errno != ENOENT)
                        ret = 1;
  
 -              if (!(delopt & REF_NODEREF))
 -                      lock->lk->filename[i] = '.';
 +              lock->lk->filename[i] = '.';
        }
        /* removing the loose one could have resurrected an earlier
         * packed one.  Also, if it was not loose we need to repack
         * without it.
         */
 -      ret |= repack_without_ref(refname);
 +      ret |= repack_without_ref(lock->ref_name);
  
        unlink_or_warn(git_path("logs/%s", lock->ref_name));
        invalidate_ref_cache(NULL);
@@@ -2292,59 -2290,117 +2292,117 @@@ int read_ref_at(const char *refname, un
        return 1;
  }
  
- int for_each_recent_reflog_ent(const char *refname, each_reflog_ent_fn fn, long ofs, void *cb_data)
+ static int show_one_reflog_ent(struct strbuf *sb, each_reflog_ent_fn fn, void *cb_data)
+ {
+       unsigned char osha1[20], nsha1[20];
+       char *email_end, *message;
+       unsigned long timestamp;
+       int tz;
+       /* old SP new SP name <email> SP time TAB msg LF */
+       if (sb->len < 83 || sb->buf[sb->len - 1] != '\n' ||
+           get_sha1_hex(sb->buf, osha1) || sb->buf[40] != ' ' ||
+           get_sha1_hex(sb->buf + 41, nsha1) || sb->buf[81] != ' ' ||
+           !(email_end = strchr(sb->buf + 82, '>')) ||
+           email_end[1] != ' ' ||
+           !(timestamp = strtoul(email_end + 2, &message, 10)) ||
+           !message || message[0] != ' ' ||
+           (message[1] != '+' && message[1] != '-') ||
+           !isdigit(message[2]) || !isdigit(message[3]) ||
+           !isdigit(message[4]) || !isdigit(message[5]))
+               return 0; /* corrupt? */
+       email_end[1] = '\0';
+       tz = strtol(message + 1, NULL, 10);
+       if (message[6] != '\t')
+               message += 6;
+       else
+               message += 7;
+       return fn(osha1, nsha1, sb->buf + 82, timestamp, tz, message, cb_data);
+ }
+ static char *find_beginning_of_line(char *bob, char *scan)
+ {
+       while (bob < scan && *(--scan) != '\n')
+               ; /* keep scanning backwards */
+       /*
+        * Return either beginning of the buffer, or LF at the end of
+        * the previous line.
+        */
+       return scan;
+ }
+ int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn, void *cb_data)
  {
-       const char *logfile;
-       FILE *logfp;
        struct strbuf sb = STRBUF_INIT;
-       int ret = 0;
+       FILE *logfp;
+       long pos;
+       int ret = 0, at_tail = 1;
  
-       logfile = git_path("logs/%s", refname);
-       logfp = fopen(logfile, "r");
+       logfp = fopen(git_path("logs/%s", refname), "r");
        if (!logfp)
                return -1;
  
-       if (ofs) {
-               struct stat statbuf;
-               if (fstat(fileno(logfp), &statbuf) ||
-                   statbuf.st_size < ofs ||
-                   fseek(logfp, -ofs, SEEK_END) ||
-                   strbuf_getwholeline(&sb, logfp, '\n')) {
-                       fclose(logfp);
-                       strbuf_release(&sb);
-                       return -1;
+       /* Jump to the end */
+       if (fseek(logfp, 0, SEEK_END) < 0)
+               return error("cannot seek back reflog for %s: %s",
+                            refname, strerror(errno));
+       pos = ftell(logfp);
+       while (!ret && 0 < pos) {
+               int cnt;
+               size_t nread;
+               char buf[BUFSIZ];
+               char *endp, *scanp;
+               /* Fill next block from the end */
+               cnt = (sizeof(buf) < pos) ? sizeof(buf) : pos;
+               if (fseek(logfp, pos - cnt, SEEK_SET))
+                       return error("cannot seek back reflog for %s: %s",
+                                    refname, strerror(errno));
+               nread = fread(buf, cnt, 1, logfp);
+               if (nread < 0)
+                       return error("cannot read %d bytes from reflog for %s: %s",
+                                    cnt, refname, strerror(errno));
+               pos -= cnt;
+               scanp = endp = buf + cnt;
+               if (at_tail && scanp[-1] == '\n')
+                       /* Looking at the final LF at the end of the file */
+                       scanp--;
+               at_tail = 0;
+               while (buf < scanp) {
+                       /*
+                        * terminating LF of the previous line, or the beginning
+                        * of the buffer.
+                        */
+                       char *bp;
+                       bp = find_beginning_of_line(buf, scanp);
+                       if (*bp != '\n') {
+                               strbuf_splice(&sb, 0, 0, buf, endp - buf);
+                               if (pos)
+                                       break; /* need to fill another block */
+                               scanp = buf - 1; /* leave loop */
+                       } else {
+                               /*
+                                * (bp + 1) thru endp is the beginning of the
+                                * current line we have in sb
+                                */
+                               strbuf_splice(&sb, 0, 0, bp + 1, endp - (bp + 1));
+                               scanp = bp;
+                               endp = bp + 1;
+                       }
+                       ret = show_one_reflog_ent(&sb, fn, cb_data);
+                       strbuf_reset(&sb);
+                       if (ret)
+                               break;
                }
-       }
  
-       while (!strbuf_getwholeline(&sb, logfp, '\n')) {
-               unsigned char osha1[20], nsha1[20];
-               char *email_end, *message;
-               unsigned long timestamp;
-               int tz;
-               /* old SP new SP name <email> SP time TAB msg LF */
-               if (sb.len < 83 || sb.buf[sb.len - 1] != '\n' ||
-                   get_sha1_hex(sb.buf, osha1) || sb.buf[40] != ' ' ||
-                   get_sha1_hex(sb.buf + 41, nsha1) || sb.buf[81] != ' ' ||
-                   !(email_end = strchr(sb.buf + 82, '>')) ||
-                   email_end[1] != ' ' ||
-                   !(timestamp = strtoul(email_end + 2, &message, 10)) ||
-                   !message || message[0] != ' ' ||
-                   (message[1] != '+' && message[1] != '-') ||
-                   !isdigit(message[2]) || !isdigit(message[3]) ||
-                   !isdigit(message[4]) || !isdigit(message[5]))
-                       continue; /* corrupt? */
-               email_end[1] = '\0';
-               tz = strtol(message + 1, NULL, 10);
-               if (message[6] != '\t')
-                       message += 6;
-               else
-                       message += 7;
-               ret = fn(osha1, nsha1, sb.buf + 82, timestamp, tz, message,
-                        cb_data);
-               if (ret)
-                       break;
        }
+       if (!ret && sb.len)
+               ret = show_one_reflog_ent(&sb, fn, cb_data);
        fclose(logfp);
        strbuf_release(&sb);
        return ret;
  
  int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn, void *cb_data)
  {
-       return for_each_recent_reflog_ent(refname, fn, 0, cb_data);
- }
+       FILE *logfp;
+       struct strbuf sb = STRBUF_INIT;
+       int ret = 0;
+       logfp = fopen(git_path("logs/%s", refname), "r");
+       if (!logfp)
+               return -1;
  
+       while (!ret && !strbuf_getwholeline(&sb, logfp, '\n'))
+               ret = show_one_reflog_ent(&sb, fn, cb_data);
+       fclose(logfp);
+       strbuf_release(&sb);
+       return ret;
+ }
  /*
   * Call fn for each reflog in the namespace indicated by name.  name
   * must be empty or end with '/'.  Name will be used as a scratch