diff.c: emit_diff_symbol learns DIFF_SYMBOL_HEADER
[gitweb.git] / blame.c
diff --git a/blame.c b/blame.c
index b04b8f58aaf718208ab13e5cbfd8cd2a4444cbd7..91e26e93e8a23d0af63e1bc8a74e9f7690276ab4 100644 (file)
--- a/blame.c
+++ b/blame.c
-/*
- * Copyright (C) 2006, Fredrik Kuivinen <freku045@student.liu.se>
- */
-
-#include <assert.h>
-#include <time.h>
-#include <sys/time.h>
-#include <math.h>
-
 #include "cache.h"
 #include "refs.h"
-#include "tag.h"
-#include "commit.h"
-#include "tree.h"
-#include "blob.h"
+#include "cache-tree.h"
+#include "mergesort.h"
 #include "diff.h"
 #include "diffcore.h"
-#include "revision.h"
-#include "xdiff-interface.h"
-
-#define DEBUG 0
-
-static const char blame_usage[] = "[-c] [-l] [-t] [-S <revs-file>] [--] file [commit]\n"
-       "  -c, --compatibility Use the same output mode as git-annotate (Default: off)\n"
-       "  -l, --long          Show long commit SHA1 (Default: off)\n"
-       "  -t, --time          Show raw timestamp (Default: off)\n"
-       "  -S, --revs-file     Use revisions from revs-file instead of calling git-rev-list\n"
-       "  -h, --help          This message";
-
-static struct commit **blame_lines;
-static int num_blame_lines;
-static char* blame_contents;
-static int blame_len;
-
-struct util_info {
-       int *line_map;
-       unsigned char sha1[20]; /* blob sha, not commit! */
-       char *buf;
-       unsigned long size;
-       int num_lines;
-       const char* pathname;
-
-       void* topo_data;
-};
+#include "tag.h"
+#include "blame.h"
 
-struct chunk {
-       int off1, len1; /* --- */
-       int off2, len2; /* +++ */
-};
+void blame_origin_decref(struct blame_origin *o)
+{
+       if (o && --o->refcnt <= 0) {
+               struct blame_origin *p, *l = NULL;
+               if (o->previous)
+                       blame_origin_decref(o->previous);
+               free(o->file.ptr);
+               /* Should be present exactly once in commit chain */
+               for (p = o->commit->util; p; l = p, p = p->next) {
+                       if (p == o) {
+                               if (l)
+                                       l->next = p->next;
+                               else
+                                       o->commit->util = p->next;
+                               free(o);
+                               return;
+                       }
+               }
+               die("internal error in blame_origin_decref");
+       }
+}
 
-struct patch {
-       struct chunk *chunks;
-       int num;
-};
+/*
+ * Given a commit and a path in it, create a new origin structure.
+ * The callers that add blame to the scoreboard should use
+ * get_origin() to obtain shared, refcounted copy instead of calling
+ * this function directly.
+ */
+static struct blame_origin *make_origin(struct commit *commit, const char *path)
+{
+       struct blame_origin *o;
+       FLEX_ALLOC_STR(o, path, path);
+       o->commit = commit;
+       o->refcnt = 1;
+       o->next = commit->util;
+       commit->util = o;
+       return o;
+}
 
-static void get_blob(struct commit *commit);
+/*
+ * Locate an existing origin or create a new one.
+ * This moves the origin to front position in the commit util list.
+ */
+static struct blame_origin *get_origin(struct commit *commit, const char *path)
+{
+       struct blame_origin *o, *l;
+
+       for (o = commit->util, l = NULL; o; l = o, o = o->next) {
+               if (!strcmp(o->path, path)) {
+                       /* bump to front */
+                       if (l) {
+                               l->next = o->next;
+                               o->next = commit->util;
+                               commit->util = o;
+                       }
+                       return blame_origin_incref(o);
+               }
+       }
+       return make_origin(commit, path);
+}
 
-/* Only used for statistics */
-static int num_get_patch = 0;
-static int num_commits = 0;
-static int patch_time = 0;
 
-struct blame_diff_state {
-       struct xdiff_emit_state xm;
-       struct patch *ret;
-};
 
-static void process_u0_diff(void *state_, char *line, unsigned long len)
+static void verify_working_tree_path(struct commit *work_tree, const char *path)
 {
-       struct blame_diff_state *state = state_;
-       struct chunk *chunk;
-
-       if (len < 4 || line[0] != '@' || line[1] != '@')
-               return;
+       struct commit_list *parents;
+       int pos;
 
-       if (DEBUG)
-               printf("chunk line: %.*s", (int)len, line);
-       state->ret->num++;
-       state->ret->chunks = xrealloc(state->ret->chunks,
-                                     sizeof(struct chunk) * state->ret->num);
-       chunk = &state->ret->chunks[state->ret->num - 1];
+       for (parents = work_tree->parents; parents; parents = parents->next) {
+               const struct object_id *commit_oid = &parents->item->object.oid;
+               struct object_id blob_oid;
+               unsigned mode;
 
-       assert(!strncmp(line, "@@ -", 4));
-
-       if (parse_hunk_header(line, len,
-                             &chunk->off1, &chunk->len1,
-                             &chunk->off2, &chunk->len2)) {
-               state->ret->num--;
-               return;
+               if (!get_tree_entry(commit_oid->hash, path, blob_oid.hash, &mode) &&
+                   sha1_object_info(blob_oid.hash, NULL) == OBJ_BLOB)
+                       return;
        }
 
-       if (chunk->len1 == 0)
-               chunk->off1++;
-       if (chunk->len2 == 0)
-               chunk->off2++;
+       pos = cache_name_pos(path, strlen(path));
+       if (pos >= 0)
+               ; /* path is in the index */
+       else if (-1 - pos < active_nr &&
+                !strcmp(active_cache[-1 - pos]->name, path))
+               ; /* path is in the index, unmerged */
+       else
+               die("no such path '%s' in HEAD", path);
+}
 
-       if (chunk->off1 > 0)
-               chunk->off1--;
-       if (chunk->off2 > 0)
-               chunk->off2--;
+static struct commit_list **append_parent(struct commit_list **tail, const struct object_id *oid)
+{
+       struct commit *parent;
 
-       assert(chunk->off1 >= 0);
-       assert(chunk->off2 >= 0);
+       parent = lookup_commit_reference(oid);
+       if (!parent)
+               die("no such commit %s", oid_to_hex(oid));
+       return &commit_list_insert(parent, tail)->next;
 }
 
-static struct patch *get_patch(struct commit *commit, struct commit *other)
+static void append_merge_parents(struct commit_list **tail)
 {
-       struct blame_diff_state state;
-       xpparam_t xpp;
-       xdemitconf_t xecfg;
-       mmfile_t file_c, file_o;
-       xdemitcb_t ecb;
-       struct util_info *info_c = (struct util_info *)commit->util;
-       struct util_info *info_o = (struct util_info *)other->util;
-       struct timeval tv_start, tv_end;
+       int merge_head;
+       struct strbuf line = STRBUF_INIT;
 
-       get_blob(commit);
-       file_c.ptr = info_c->buf;
-       file_c.size = info_c->size;
+       merge_head = open(git_path_merge_head(), O_RDONLY);
+       if (merge_head < 0) {
+               if (errno == ENOENT)
+                       return;
+               die("cannot open '%s' for reading", git_path_merge_head());
+       }
 
-       get_blob(other);
-       file_o.ptr = info_o->buf;
-       file_o.size = info_o->size;
+       while (!strbuf_getwholeline_fd(&line, merge_head, '\n')) {
+               struct object_id oid;
+               if (line.len < GIT_SHA1_HEXSZ || get_oid_hex(line.buf, &oid))
+                       die("unknown line in '%s': %s", git_path_merge_head(), line.buf);
+               tail = append_parent(tail, &oid);
+       }
+       close(merge_head);
+       strbuf_release(&line);
+}
 
-       gettimeofday(&tv_start, NULL);
+/*
+ * This isn't as simple as passing sb->buf and sb->len, because we
+ * want to transfer ownership of the buffer to the commit (so we
+ * must use detach).
+ */
+static void set_commit_buffer_from_strbuf(struct commit *c, struct strbuf *sb)
+{
+       size_t len;
+       void *buf = strbuf_detach(sb, &len);
+       set_commit_buffer(c, buf, len);
+}
+
+/*
+ * Prepare a dummy commit that represents the work tree (or staged) item.
+ * Note that annotating work tree item never works in the reverse.
+ */
+static struct commit *fake_working_tree_commit(struct diff_options *opt,
+                                              const char *path,
+                                              const char *contents_from)
+{
+       struct commit *commit;
+       struct blame_origin *origin;
+       struct commit_list **parent_tail, *parent;
+       struct object_id head_oid;
+       struct strbuf buf = STRBUF_INIT;
+       const char *ident;
+       time_t now;
+       int size, len;
+       struct cache_entry *ce;
+       unsigned mode;
+       struct strbuf msg = STRBUF_INIT;
+
+       read_cache();
+       time(&now);
+       commit = alloc_commit_node();
+       commit->object.parsed = 1;
+       commit->date = now;
+       parent_tail = &commit->parents;
+
+       if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, head_oid.hash, NULL))
+               die("no such ref: HEAD");
+
+       parent_tail = append_parent(parent_tail, &head_oid);
+       append_merge_parents(parent_tail);
+       verify_working_tree_path(commit, path);
+
+       origin = make_origin(commit, path);
+
+       ident = fmt_ident("Not Committed Yet", "not.committed.yet", NULL, 0);
+       strbuf_addstr(&msg, "tree 0000000000000000000000000000000000000000\n");
+       for (parent = commit->parents; parent; parent = parent->next)
+               strbuf_addf(&msg, "parent %s\n",
+                           oid_to_hex(&parent->item->object.oid));
+       strbuf_addf(&msg,
+                   "author %s\n"
+                   "committer %s\n\n"
+                   "Version of %s from %s\n",
+                   ident, ident, path,
+                   (!contents_from ? path :
+                    (!strcmp(contents_from, "-") ? "standard input" : contents_from)));
+       set_commit_buffer_from_strbuf(commit, &msg);
+
+       if (!contents_from || strcmp("-", contents_from)) {
+               struct stat st;
+               const char *read_from;
+               char *buf_ptr;
+               unsigned long buf_len;
+
+               if (contents_from) {
+                       if (stat(contents_from, &st) < 0)
+                               die_errno("Cannot stat '%s'", contents_from);
+                       read_from = contents_from;
+               }
+               else {
+                       if (lstat(path, &st) < 0)
+                               die_errno("Cannot lstat '%s'", path);
+                       read_from = path;
+               }
+               mode = canon_mode(st.st_mode);
+
+               switch (st.st_mode & S_IFMT) {
+               case S_IFREG:
+                       if (DIFF_OPT_TST(opt, ALLOW_TEXTCONV) &&
+                           textconv_object(read_from, mode, &null_oid, 0, &buf_ptr, &buf_len))
+                               strbuf_attach(&buf, buf_ptr, buf_len, buf_len + 1);
+                       else if (strbuf_read_file(&buf, read_from, st.st_size) != st.st_size)
+                               die_errno("cannot open or read '%s'", read_from);
+                       break;
+               case S_IFLNK:
+                       if (strbuf_readlink(&buf, read_from, st.st_size) < 0)
+                               die_errno("cannot readlink '%s'", read_from);
+                       break;
+               default:
+                       die("unsupported file type %s", read_from);
+               }
+       }
+       else {
+               /* Reading from stdin */
+               mode = 0;
+               if (strbuf_read(&buf, 0, 0) < 0)
+                       die_errno("failed to read from stdin");
+       }
+       convert_to_git(&the_index, path, buf.buf, buf.len, &buf, 0);
+       origin->file.ptr = buf.buf;
+       origin->file.size = buf.len;
+       pretend_sha1_file(buf.buf, buf.len, OBJ_BLOB, origin->blob_oid.hash);
+
+       /*
+        * Read the current index, replace the path entry with
+        * origin->blob_sha1 without mucking with its mode or type
+        * bits; we are not going to write this index out -- we just
+        * want to run "diff-index --cached".
+        */
+       discard_cache();
+       read_cache();
+
+       len = strlen(path);
+       if (!mode) {
+               int pos = cache_name_pos(path, len);
+               if (0 <= pos)
+                       mode = active_cache[pos]->ce_mode;
+               else
+                       /* Let's not bother reading from HEAD tree */
+                       mode = S_IFREG | 0644;
+       }
+       size = cache_entry_size(len);
+       ce = xcalloc(1, size);
+       oidcpy(&ce->oid, &origin->blob_oid);
+       memcpy(ce->name, path, len);
+       ce->ce_flags = create_ce_flags(0);
+       ce->ce_namelen = len;
+       ce->ce_mode = create_ce_mode(mode);
+       add_cache_entry(ce, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE);
+
+       cache_tree_invalidate_path(&the_index, path);
+
+       return commit;
+}
 
-       xpp.flags = XDF_NEED_MINIMAL;
-       xecfg.ctxlen = 0;
-       xecfg.flags = 0;
-       ecb.outf = xdiff_outf;
-       ecb.priv = &state;
-       memset(&state, 0, sizeof(state));
-       state.xm.consume = process_u0_diff;
-       state.ret = xmalloc(sizeof(struct patch));
-       state.ret->chunks = NULL;
-       state.ret->num = 0;
 
-       xdl_diff(&file_c, &file_o, &xpp, &xecfg, &ecb);
 
-       gettimeofday(&tv_end, NULL);
-       patch_time += 1000000 * (tv_end.tv_sec - tv_start.tv_sec) +
-               tv_end.tv_usec - tv_start.tv_usec;
+static int diff_hunks(mmfile_t *file_a, mmfile_t *file_b,
+                     xdl_emit_hunk_consume_func_t hunk_func, void *cb_data, int xdl_opts)
+{
+       xpparam_t xpp = {0};
+       xdemitconf_t xecfg = {0};
+       xdemitcb_t ecb = {NULL};
+
+       xpp.flags = xdl_opts;
+       xecfg.hunk_func = hunk_func;
+       ecb.priv = cb_data;
+       return xdi_diff(file_a, file_b, &xpp, &xecfg, &ecb);
+}
 
-       num_get_patch++;
-       return state.ret;
+/*
+ * Given an origin, prepare mmfile_t structure to be used by the
+ * diff machinery
+ */
+static void fill_origin_blob(struct diff_options *opt,
+                            struct blame_origin *o, mmfile_t *file, int *num_read_blob)
+{
+       if (!o->file.ptr) {
+               enum object_type type;
+               unsigned long file_size;
+
+               (*num_read_blob)++;
+               if (DIFF_OPT_TST(opt, ALLOW_TEXTCONV) &&
+                   textconv_object(o->path, o->mode, &o->blob_oid, 1, &file->ptr, &file_size))
+                       ;
+               else
+                       file->ptr = read_sha1_file(o->blob_oid.hash, &type,
+                                                  &file_size);
+               file->size = file_size;
+
+               if (!file->ptr)
+                       die("Cannot read blob %s for path %s",
+                           oid_to_hex(&o->blob_oid),
+                           o->path);
+               o->file = *file;
+       }
+       else
+               *file = o->file;
 }
 
-static void free_patch(struct patch *p)
+static void drop_origin_blob(struct blame_origin *o)
 {
-       free(p->chunks);
-       free(p);
+       if (o->file.ptr) {
+               FREE_AND_NULL(o->file.ptr);
+       }
 }
 
-static int get_blob_sha1_internal(const unsigned char *sha1, const char *base,
-                                 int baselen, const char *pathname,
-                                 unsigned mode, int stage);
+/*
+ * Any merge of blames happens on lists of blames that arrived via
+ * different parents in a single suspect.  In this case, we want to
+ * sort according to the suspect line numbers as opposed to the final
+ * image line numbers.  The function body is somewhat longish because
+ * it avoids unnecessary writes.
+ */
 
-static unsigned char blob_sha1[20];
-static const char* blame_file;
-static int get_blob_sha1(struct tree *t, const char *pathname,
-                        unsigned char *sha1)
+static struct blame_entry *blame_merge(struct blame_entry *list1,
+                                      struct blame_entry *list2)
 {
-       int i;
-       const char *pathspec[2];
-       blame_file = pathname;
-       pathspec[0] = pathname;
-       pathspec[1] = NULL;
-       memset(blob_sha1, 0, sizeof(blob_sha1));
-       read_tree_recursive(t, "", 0, 0, pathspec, get_blob_sha1_internal);
-
-       for (i = 0; i < 20; i++) {
-               if (blob_sha1[i] != 0)
-                       break;
+       struct blame_entry *p1 = list1, *p2 = list2,
+               **tail = &list1;
+
+       if (!p1)
+               return p2;
+       if (!p2)
+               return p1;
+
+       if (p1->s_lno <= p2->s_lno) {
+               do {
+                       tail = &p1->next;
+                       if ((p1 = *tail) == NULL) {
+                               *tail = p2;
+                               return list1;
+                       }
+               } while (p1->s_lno <= p2->s_lno);
        }
+       for (;;) {
+               *tail = p2;
+               do {
+                       tail = &p2->next;
+                       if ((p2 = *tail) == NULL)  {
+                               *tail = p1;
+                               return list1;
+                       }
+               } while (p1->s_lno > p2->s_lno);
+               *tail = p1;
+               do {
+                       tail = &p1->next;
+                       if ((p1 = *tail) == NULL) {
+                               *tail = p2;
+                               return list1;
+                       }
+               } while (p1->s_lno <= p2->s_lno);
+       }
+}
 
-       if (i == 20)
-               return -1;
-
-       memcpy(sha1, blob_sha1, 20);
-       return 0;
+static void *get_next_blame(const void *p)
+{
+       return ((struct blame_entry *)p)->next;
 }
 
-static int get_blob_sha1_internal(const unsigned char *sha1, const char *base,
-                                 int baselen, const char *pathname,
-                                 unsigned mode, int stage)
+static void set_next_blame(void *p1, void *p2)
 {
-       if (S_ISDIR(mode))
-               return READ_TREE_RECURSIVE;
+       ((struct blame_entry *)p1)->next = p2;
+}
 
-       if (strncmp(blame_file, base, baselen) ||
-           strcmp(blame_file + baselen, pathname))
-               return -1;
+/*
+ * Final image line numbers are all different, so we don't need a
+ * three-way comparison here.
+ */
 
-       memcpy(blob_sha1, sha1, 20);
-       return -1;
+static int compare_blame_final(const void *p1, const void *p2)
+{
+       return ((struct blame_entry *)p1)->lno > ((struct blame_entry *)p2)->lno
+               ? 1 : -1;
 }
 
-static void get_blob(struct commit *commit)
+static int compare_blame_suspect(const void *p1, const void *p2)
 {
-       struct util_info *info = commit->util;
-       char type[20];
-
-       if (info->buf)
-               return;
+       const struct blame_entry *s1 = p1, *s2 = p2;
+       /*
+        * to allow for collating suspects, we sort according to the
+        * respective pointer value as the primary sorting criterion.
+        * The actual relation is pretty unimportant as long as it
+        * establishes a total order.  Comparing as integers gives us
+        * that.
+        */
+       if (s1->suspect != s2->suspect)
+               return (intptr_t)s1->suspect > (intptr_t)s2->suspect ? 1 : -1;
+       if (s1->s_lno == s2->s_lno)
+               return 0;
+       return s1->s_lno > s2->s_lno ? 1 : -1;
+}
 
-       info->buf = read_sha1_file(info->sha1, type, &info->size);
+void blame_sort_final(struct blame_scoreboard *sb)
+{
+       sb->ent = llist_mergesort(sb->ent, get_next_blame, set_next_blame,
+                                 compare_blame_final);
+}
 
-       assert(!strcmp(type, blob_type));
+static int compare_commits_by_reverse_commit_date(const void *a,
+                                                 const void *b,
+                                                 void *c)
+{
+       return -compare_commits_by_commit_date(a, b, c);
 }
 
-/* For debugging only */
-static void print_patch(struct patch *p)
+/*
+ * For debugging -- origin is refcounted, and this asserts that
+ * we do not underflow.
+ */
+static void sanity_check_refcnt(struct blame_scoreboard *sb)
 {
-       int i;
-       printf("Num chunks: %d\n", p->num);
-       for (i = 0; i < p->num; i++) {
-               printf("%d,%d %d,%d\n", p->chunks[i].off1, p->chunks[i].len1,
-                      p->chunks[i].off2, p->chunks[i].len2);
+       int baa = 0;
+       struct blame_entry *ent;
+
+       for (ent = sb->ent; ent; ent = ent->next) {
+               /* Nobody should have zero or negative refcnt */
+               if (ent->suspect->refcnt <= 0) {
+                       fprintf(stderr, "%s in %s has negative refcnt %d\n",
+                               ent->suspect->path,
+                               oid_to_hex(&ent->suspect->commit->object.oid),
+                               ent->suspect->refcnt);
+                       baa = 1;
+               }
        }
+       if (baa)
+               sb->on_sanity_fail(sb, baa);
 }
 
-#if DEBUG
-/* For debugging only */
-static void print_map(struct commit *cmit, struct commit *other)
+/*
+ * If two blame entries that are next to each other came from
+ * contiguous lines in the same origin (i.e. <commit, path> pair),
+ * merge them together.
+ */
+void blame_coalesce(struct blame_scoreboard *sb)
 {
-       struct util_info *util = cmit->util;
-       struct util_info *util2 = other->util;
+       struct blame_entry *ent, *next;
+
+       for (ent = sb->ent; ent && (next = ent->next); ent = next) {
+               if (ent->suspect == next->suspect &&
+                   ent->s_lno + ent->num_lines == next->s_lno) {
+                       ent->num_lines += next->num_lines;
+                       ent->next = next->next;
+                       blame_origin_decref(next->suspect);
+                       free(next);
+                       ent->score = 0;
+                       next = ent; /* again */
+               }
+       }
 
-       int i;
-       int max =
-           util->num_lines >
-           util2->num_lines ? util->num_lines : util2->num_lines;
-       int num;
-
-       for (i = 0; i < max; i++) {
-               printf("i: %d ", i);
-               num = -1;
-
-               if (i < util->num_lines) {
-                       num = util->line_map[i];
-                       printf("%d\t", num);
-               } else
-                       printf("\t");
+       if (sb->debug) /* sanity */
+               sanity_check_refcnt(sb);
+}
 
-               if (i < util2->num_lines) {
-                       int num2 = util2->line_map[i];
-                       printf("%d\t", num2);
-                       if (num != -1 && num2 != num)
-                               printf("---");
-               } else
-                       printf("\t");
+/*
+ * Merge the given sorted list of blames into a preexisting origin.
+ * If there were no previous blames to that commit, it is entered into
+ * the commit priority queue of the score board.
+ */
 
-               printf("\n");
+static void queue_blames(struct blame_scoreboard *sb, struct blame_origin *porigin,
+                        struct blame_entry *sorted)
+{
+       if (porigin->suspects)
+               porigin->suspects = blame_merge(porigin->suspects, sorted);
+       else {
+               struct blame_origin *o;
+               for (o = porigin->commit->util; o; o = o->next) {
+                       if (o->suspects) {
+                               porigin->suspects = sorted;
+                               return;
+                       }
+               }
+               porigin->suspects = sorted;
+               prio_queue_put(&sb->commits, porigin->commit);
        }
 }
-#endif
 
-/* p is a patch from commit to other. */
-static void fill_line_map(struct commit *commit, struct commit *other,
-                         struct patch *p)
+/*
+ * Fill the blob_sha1 field of an origin if it hasn't, so that later
+ * call to fill_origin_blob() can use it to locate the data.  blob_sha1
+ * for an origin is also used to pass the blame for the entire file to
+ * the parent to detect the case where a child's blob is identical to
+ * that of its parent's.
+ *
+ * This also fills origin->mode for corresponding tree path.
+ */
+static int fill_blob_sha1_and_mode(struct blame_origin *origin)
 {
-       struct util_info *util = commit->util;
-       struct util_info *util2 = other->util;
-       int *map = util->line_map;
-       int *map2 = util2->line_map;
-       int cur_chunk = 0;
-       int i1, i2;
-
-       if (p->num && DEBUG)
-               print_patch(p);
+       if (!is_null_oid(&origin->blob_oid))
+               return 0;
+       if (get_tree_entry(origin->commit->object.oid.hash,
+                          origin->path,
+                          origin->blob_oid.hash, &origin->mode))
+               goto error_out;
+       if (sha1_object_info(origin->blob_oid.hash, NULL) != OBJ_BLOB)
+               goto error_out;
+       return 0;
+ error_out:
+       oidclr(&origin->blob_oid);
+       origin->mode = S_IFINVALID;
+       return -1;
+}
 
-       if (DEBUG)
-               printf("num lines 1: %d num lines 2: %d\n", util->num_lines,
-                      util2->num_lines);
+/*
+ * We have an origin -- check if the same path exists in the
+ * parent and return an origin structure to represent it.
+ */
+static struct blame_origin *find_origin(struct commit *parent,
+                                 struct blame_origin *origin)
+{
+       struct blame_origin *porigin;
+       struct diff_options diff_opts;
+       const char *paths[2];
+
+       /* First check any existing origins */
+       for (porigin = parent->util; porigin; porigin = porigin->next)
+               if (!strcmp(porigin->path, origin->path)) {
+                       /*
+                        * The same path between origin and its parent
+                        * without renaming -- the most common case.
+                        */
+                       return blame_origin_incref (porigin);
+               }
 
-       for (i1 = 0, i2 = 0; i1 < util->num_lines; i1++, i2++) {
-               struct chunk *chunk = NULL;
-               if (cur_chunk < p->num)
-                       chunk = &p->chunks[cur_chunk];
+       /* See if the origin->path is different between parent
+        * and origin first.  Most of the time they are the
+        * same and diff-tree is fairly efficient about this.
+        */
+       diff_setup(&diff_opts);
+       DIFF_OPT_SET(&diff_opts, RECURSIVE);
+       diff_opts.detect_rename = 0;
+       diff_opts.output_format = DIFF_FORMAT_NO_OUTPUT;
+       paths[0] = origin->path;
+       paths[1] = NULL;
 
-               if (chunk && chunk->off1 == i1) {
-                       if (DEBUG && i2 != chunk->off2)
-                               printf("i2: %d off2: %d\n", i2, chunk->off2);
+       parse_pathspec(&diff_opts.pathspec,
+                      PATHSPEC_ALL_MAGIC & ~PATHSPEC_LITERAL,
+                      PATHSPEC_LITERAL_PATH, "", paths);
+       diff_setup_done(&diff_opts);
 
-                       assert(i2 == chunk->off2);
+       if (is_null_oid(&origin->commit->object.oid))
+               do_diff_cache(&parent->tree->object.oid, &diff_opts);
+       else
+               diff_tree_oid(&parent->tree->object.oid,
+                             &origin->commit->tree->object.oid,
+                             "", &diff_opts);
+       diffcore_std(&diff_opts);
 
-                       i1--;
-                       i2--;
-                       if (chunk->len1 > 0)
-                               i1 += chunk->len1;
+       if (!diff_queued_diff.nr) {
+               /* The path is the same as parent */
+               porigin = get_origin(parent, origin->path);
+               oidcpy(&porigin->blob_oid, &origin->blob_oid);
+               porigin->mode = origin->mode;
+       } else {
+               /*
+                * Since origin->path is a pathspec, if the parent
+                * commit had it as a directory, we will see a whole
+                * bunch of deletion of files in the directory that we
+                * do not care about.
+                */
+               int i;
+               struct diff_filepair *p = NULL;
+               for (i = 0; i < diff_queued_diff.nr; i++) {
+                       const char *name;
+                       p = diff_queued_diff.queue[i];
+                       name = p->one->path ? p->one->path : p->two->path;
+                       if (!strcmp(name, origin->path))
+                               break;
+               }
+               if (!p)
+                       die("internal error in blame::find_origin");
+               switch (p->status) {
+               default:
+                       die("internal error in blame::find_origin (%c)",
+                           p->status);
+               case 'M':
+                       porigin = get_origin(parent, origin->path);
+                       oidcpy(&porigin->blob_oid, &p->one->oid);
+                       porigin->mode = p->one->mode;
+                       break;
+               case 'A':
+               case 'T':
+                       /* Did not exist in parent, or type changed */
+                       break;
+               }
+       }
+       diff_flush(&diff_opts);
+       clear_pathspec(&diff_opts.pathspec);
+       return porigin;
+}
 
-                       if (chunk->len2 > 0)
-                               i2 += chunk->len2;
+/*
+ * We have an origin -- find the path that corresponds to it in its
+ * parent and return an origin structure to represent it.
+ */
+static struct blame_origin *find_rename(struct commit *parent,
+                                 struct blame_origin *origin)
+{
+       struct blame_origin *porigin = NULL;
+       struct diff_options diff_opts;
+       int i;
 
-                       cur_chunk++;
-               } else {
-                       if (i2 >= util2->num_lines)
-                               break;
+       diff_setup(&diff_opts);
+       DIFF_OPT_SET(&diff_opts, RECURSIVE);
+       diff_opts.detect_rename = DIFF_DETECT_RENAME;
+       diff_opts.output_format = DIFF_FORMAT_NO_OUTPUT;
+       diff_opts.single_follow = origin->path;
+       diff_setup_done(&diff_opts);
 
-                       if (map[i1] != map2[i2] && map[i1] != -1) {
-                               if (DEBUG)
-                                       printf("map: i1: %d %d %p i2: %d %d %p\n",
-                                              i1, map[i1],
-                                              (void *) (i1 != -1 ? blame_lines[map[i1]] : NULL),
-                                              i2, map2[i2],
-                                              (void *) (i2 != -1 ? blame_lines[map2[i2]] : NULL));
-                               if (map2[i2] != -1 &&
-                                   blame_lines[map[i1]] &&
-                                   !blame_lines[map2[i2]])
-                                       map[i1] = map2[i2];
-                       }
+       if (is_null_oid(&origin->commit->object.oid))
+               do_diff_cache(&parent->tree->object.oid, &diff_opts);
+       else
+               diff_tree_oid(&parent->tree->object.oid,
+                             &origin->commit->tree->object.oid,
+                             "", &diff_opts);
+       diffcore_std(&diff_opts);
 
-                       if (map[i1] == -1 && map2[i2] != -1)
-                               map[i1] = map2[i2];
+       for (i = 0; i < diff_queued_diff.nr; i++) {
+               struct diff_filepair *p = diff_queued_diff.queue[i];
+               if ((p->status == 'R' || p->status == 'C') &&
+                   !strcmp(p->two->path, origin->path)) {
+                       porigin = get_origin(parent, p->one->path);
+                       oidcpy(&porigin->blob_oid, &p->one->oid);
+                       porigin->mode = p->one->mode;
+                       break;
                }
-
-               if (DEBUG > 1)
-                       printf("l1: %d l2: %d i1: %d i2: %d\n",
-                              map[i1], map2[i2], i1, i2);
        }
+       diff_flush(&diff_opts);
+       clear_pathspec(&diff_opts.pathspec);
+       return porigin;
 }
 
-static int map_line(struct commit *commit, int line)
+/*
+ * Append a new blame entry to a given output queue.
+ */
+static void add_blame_entry(struct blame_entry ***queue,
+                           const struct blame_entry *src)
 {
-       struct util_info *info = commit->util;
-       assert(line >= 0 && line < info->num_lines);
-       return info->line_map[line];
+       struct blame_entry *e = xmalloc(sizeof(*e));
+       memcpy(e, src, sizeof(*e));
+       blame_origin_incref(e->suspect);
+
+       e->next = **queue;
+       **queue = e;
+       *queue = &e->next;
 }
 
-static struct util_info* get_util(struct commit *commit)
+/*
+ * src typically is on-stack; we want to copy the information in it to
+ * a malloced blame_entry that gets added to the given queue.  The
+ * origin of dst loses a refcnt.
+ */
+static void dup_entry(struct blame_entry ***queue,
+                     struct blame_entry *dst, struct blame_entry *src)
 {
-       struct util_info *util = commit->util;
+       blame_origin_incref(src->suspect);
+       blame_origin_decref(dst->suspect);
+       memcpy(dst, src, sizeof(*src));
+       dst->next = **queue;
+       **queue = dst;
+       *queue = &dst->next;
+}
 
-       if (util)
-               return util;
+const char *blame_nth_line(struct blame_scoreboard *sb, long lno)
+{
+       return sb->final_buf + sb->lineno[lno];
+}
+
+/*
+ * It is known that lines between tlno to same came from parent, and e
+ * has an overlap with that range.  it also is known that parent's
+ * line plno corresponds to e's line tlno.
+ *
+ *                <---- e ----->
+ *                   <------>
+ *                   <------------>
+ *             <------------>
+ *             <------------------>
+ *
+ * Split e into potentially three parts; before this chunk, the chunk
+ * to be blamed for the parent, and after that portion.
+ */
+static void split_overlap(struct blame_entry *split,
+                         struct blame_entry *e,
+                         int tlno, int plno, int same,
+                         struct blame_origin *parent)
+{
+       int chunk_end_lno;
+       memset(split, 0, sizeof(struct blame_entry [3]));
+
+       if (e->s_lno < tlno) {
+               /* there is a pre-chunk part not blamed on parent */
+               split[0].suspect = blame_origin_incref(e->suspect);
+               split[0].lno = e->lno;
+               split[0].s_lno = e->s_lno;
+               split[0].num_lines = tlno - e->s_lno;
+               split[1].lno = e->lno + tlno - e->s_lno;
+               split[1].s_lno = plno;
+       }
+       else {
+               split[1].lno = e->lno;
+               split[1].s_lno = plno + (e->s_lno - tlno);
+       }
 
-       util = xmalloc(sizeof(struct util_info));
-       util->buf = NULL;
-       util->size = 0;
-       util->line_map = NULL;
-       util->num_lines = -1;
-       util->pathname = NULL;
-       commit->util = util;
-       return util;
+       if (same < e->s_lno + e->num_lines) {
+               /* there is a post-chunk part not blamed on parent */
+               split[2].suspect = blame_origin_incref(e->suspect);
+               split[2].lno = e->lno + (same - e->s_lno);
+               split[2].s_lno = e->s_lno + (same - e->s_lno);
+               split[2].num_lines = e->s_lno + e->num_lines - same;
+               chunk_end_lno = split[2].lno;
+       }
+       else
+               chunk_end_lno = e->lno + e->num_lines;
+       split[1].num_lines = chunk_end_lno - split[1].lno;
+
+       /*
+        * if it turns out there is nothing to blame the parent for,
+        * forget about the splitting.  !split[1].suspect signals this.
+        */
+       if (split[1].num_lines < 1)
+               return;
+       split[1].suspect = blame_origin_incref(parent);
 }
 
-static int fill_util_info(struct commit *commit)
+/*
+ * split_overlap() divided an existing blame e into up to three parts
+ * in split.  Any assigned blame is moved to queue to
+ * reflect the split.
+ */
+static void split_blame(struct blame_entry ***blamed,
+                       struct blame_entry ***unblamed,
+                       struct blame_entry *split,
+                       struct blame_entry *e)
 {
-       struct util_info *util = commit->util;
+       if (split[0].suspect && split[2].suspect) {
+               /* The first part (reuse storage for the existing entry e) */
+               dup_entry(unblamed, e, &split[0]);
 
-       assert(util);
-       assert(util->pathname);
+               /* The last part -- me */
+               add_blame_entry(unblamed, &split[2]);
 
-       if (get_blob_sha1(commit->tree, util->pathname, util->sha1))
-               return 1;
-       else
-               return 0;
+               /* ... and the middle part -- parent */
+               add_blame_entry(blamed, &split[1]);
+       }
+       else if (!split[0].suspect && !split[2].suspect)
+               /*
+                * The parent covers the entire area; reuse storage for
+                * e and replace it with the parent.
+                */
+               dup_entry(blamed, e, &split[1]);
+       else if (split[0].suspect) {
+               /* me and then parent */
+               dup_entry(unblamed, e, &split[0]);
+               add_blame_entry(blamed, &split[1]);
+       }
+       else {
+               /* parent and then me */
+               dup_entry(blamed, e, &split[1]);
+               add_blame_entry(unblamed, &split[2]);
+       }
 }
 
-static void alloc_line_map(struct commit *commit)
+/*
+ * After splitting the blame, the origins used by the
+ * on-stack blame_entry should lose one refcnt each.
+ */
+static void decref_split(struct blame_entry *split)
 {
-       struct util_info *util = commit->util;
        int i;
 
-       if (util->line_map)
-               return;
+       for (i = 0; i < 3; i++)
+               blame_origin_decref(split[i].suspect);
+}
 
-       get_blob(commit);
+/*
+ * reverse_blame reverses the list given in head, appending tail.
+ * That allows us to build lists in reverse order, then reverse them
+ * afterwards.  This can be faster than building the list in proper
+ * order right away.  The reason is that building in proper order
+ * requires writing a link in the _previous_ element, while building
+ * in reverse order just requires placing the list head into the
+ * _current_ element.
+ */
+
+static struct blame_entry *reverse_blame(struct blame_entry *head,
+                                        struct blame_entry *tail)
+{
+       while (head) {
+               struct blame_entry *next = head->next;
+               head->next = tail;
+               tail = head;
+               head = next;
+       }
+       return tail;
+}
 
-       util->num_lines = 0;
-       for (i = 0; i < util->size; i++) {
-               if (util->buf[i] == '\n')
-                       util->num_lines++;
+/*
+ * Process one hunk from the patch between the current suspect for
+ * blame_entry e and its parent.  This first blames any unfinished
+ * entries before the chunk (which is where target and parent start
+ * differing) on the parent, and then splits blame entries at the
+ * start and at the end of the difference region.  Since use of -M and
+ * -C options may lead to overlapping/duplicate source line number
+ * ranges, all we can rely on from sorting/merging is the order of the
+ * first suspect line number.
+ */
+static void blame_chunk(struct blame_entry ***dstq, struct blame_entry ***srcq,
+                       int tlno, int offset, int same,
+                       struct blame_origin *parent)
+{
+       struct blame_entry *e = **srcq;
+       struct blame_entry *samep = NULL, *diffp = NULL;
+
+       while (e && e->s_lno < tlno) {
+               struct blame_entry *next = e->next;
+               /*
+                * current record starts before differing portion.  If
+                * it reaches into it, we need to split it up and
+                * examine the second part separately.
+                */
+               if (e->s_lno + e->num_lines > tlno) {
+                       /* Move second half to a new record */
+                       int len = tlno - e->s_lno;
+                       struct blame_entry *n = xcalloc(1, sizeof (struct blame_entry));
+                       n->suspect = e->suspect;
+                       n->lno = e->lno + len;
+                       n->s_lno = e->s_lno + len;
+                       n->num_lines = e->num_lines - len;
+                       e->num_lines = len;
+                       e->score = 0;
+                       /* Push new record to diffp */
+                       n->next = diffp;
+                       diffp = n;
+               } else
+                       blame_origin_decref(e->suspect);
+               /* Pass blame for everything before the differing
+                * chunk to the parent */
+               e->suspect = blame_origin_incref(parent);
+               e->s_lno += offset;
+               e->next = samep;
+               samep = e;
+               e = next;
+       }
+       /*
+        * As we don't know how much of a common stretch after this
+        * diff will occur, the currently blamed parts are all that we
+        * can assign to the parent for now.
+        */
+
+       if (samep) {
+               **dstq = reverse_blame(samep, **dstq);
+               *dstq = &samep->next;
        }
-       if(util->buf[util->size - 1] != '\n')
-               util->num_lines++;
+       /*
+        * Prepend the split off portions: everything after e starts
+        * after the blameable portion.
+        */
+       e = reverse_blame(diffp, e);
+
+       /*
+        * Now retain records on the target while parts are different
+        * from the parent.
+        */
+       samep = NULL;
+       diffp = NULL;
+       while (e && e->s_lno < same) {
+               struct blame_entry *next = e->next;
+
+               /*
+                * If current record extends into sameness, need to split.
+                */
+               if (e->s_lno + e->num_lines > same) {
+                       /*
+                        * Move second half to a new record to be
+                        * processed by later chunks
+                        */
+                       int len = same - e->s_lno;
+                       struct blame_entry *n = xcalloc(1, sizeof (struct blame_entry));
+                       n->suspect = blame_origin_incref(e->suspect);
+                       n->lno = e->lno + len;
+                       n->s_lno = e->s_lno + len;
+                       n->num_lines = e->num_lines - len;
+                       e->num_lines = len;
+                       e->score = 0;
+                       /* Push new record to samep */
+                       n->next = samep;
+                       samep = n;
+               }
+               e->next = diffp;
+               diffp = e;
+               e = next;
+       }
+       **srcq = reverse_blame(diffp, reverse_blame(samep, e));
+       /* Move across elements that are in the unblamable portion */
+       if (diffp)
+               *srcq = &diffp->next;
+}
+
+struct blame_chunk_cb_data {
+       struct blame_origin *parent;
+       long offset;
+       struct blame_entry **dstq;
+       struct blame_entry **srcq;
+};
 
-       util->line_map = xmalloc(sizeof(int) * util->num_lines);
+/* diff chunks are from parent to target */
+static int blame_chunk_cb(long start_a, long count_a,
+                         long start_b, long count_b, void *data)
+{
+       struct blame_chunk_cb_data *d = data;
+       if (start_a - start_b != d->offset)
+               die("internal error in blame::blame_chunk_cb");
+       blame_chunk(&d->dstq, &d->srcq, start_b, start_a - start_b,
+                   start_b + count_b, d->parent);
+       d->offset = start_a + count_a - (start_b + count_b);
+       return 0;
+}
 
-       for (i = 0; i < util->num_lines; i++)
-               util->line_map[i] = -1;
+/*
+ * We are looking at the origin 'target' and aiming to pass blame
+ * for the lines it is suspected to its parent.  Run diff to find
+ * which lines came from parent and pass blame for them.
+ */
+static void pass_blame_to_parent(struct blame_scoreboard *sb,
+                                struct blame_origin *target,
+                                struct blame_origin *parent)
+{
+       mmfile_t file_p, file_o;
+       struct blame_chunk_cb_data d;
+       struct blame_entry *newdest = NULL;
+
+       if (!target->suspects)
+               return; /* nothing remains for this target */
+
+       d.parent = parent;
+       d.offset = 0;
+       d.dstq = &newdest; d.srcq = &target->suspects;
+
+       fill_origin_blob(&sb->revs->diffopt, parent, &file_p, &sb->num_read_blob);
+       fill_origin_blob(&sb->revs->diffopt, target, &file_o, &sb->num_read_blob);
+       sb->num_get_patch++;
+
+       if (diff_hunks(&file_p, &file_o, blame_chunk_cb, &d, sb->xdl_opts))
+               die("unable to generate diff (%s -> %s)",
+                   oid_to_hex(&parent->commit->object.oid),
+                   oid_to_hex(&target->commit->object.oid));
+       /* The rest are the same as the parent */
+       blame_chunk(&d.dstq, &d.srcq, INT_MAX, d.offset, INT_MAX, parent);
+       *d.dstq = NULL;
+       queue_blames(sb, parent, newdest);
+
+       return;
+}
+
+/*
+ * The lines in blame_entry after splitting blames many times can become
+ * very small and trivial, and at some point it becomes pointless to
+ * blame the parents.  E.g. "\t\t}\n\t}\n\n" appears everywhere in any
+ * ordinary C program, and it is not worth to say it was copied from
+ * totally unrelated file in the parent.
+ *
+ * Compute how trivial the lines in the blame_entry are.
+ */
+unsigned blame_entry_score(struct blame_scoreboard *sb, struct blame_entry *e)
+{
+       unsigned score;
+       const char *cp, *ep;
+
+       if (e->score)
+               return e->score;
+
+       score = 1;
+       cp = blame_nth_line(sb, e->lno);
+       ep = blame_nth_line(sb, e->lno + e->num_lines);
+       while (cp < ep) {
+               unsigned ch = *((unsigned char *)cp);
+               if (isalnum(ch))
+                       score++;
+               cp++;
+       }
+       e->score = score;
+       return score;
 }
 
-static void init_first_commit(struct commit* commit, const char* filename)
+/*
+ * best_so_far[] and this[] are both a split of an existing blame_entry
+ * that passes blame to the parent.  Maintain best_so_far the best split
+ * so far, by comparing this and best_so_far and copying this into
+ * bst_so_far as needed.
+ */
+static void copy_split_if_better(struct blame_scoreboard *sb,
+                                struct blame_entry *best_so_far,
+                                struct blame_entry *this)
 {
-       struct util_info* util = commit->util;
        int i;
 
-       util->pathname = filename;
-       if (fill_util_info(commit))
-               die("fill_util_info failed");
+       if (!this[1].suspect)
+               return;
+       if (best_so_far[1].suspect) {
+               if (blame_entry_score(sb, &this[1]) < blame_entry_score(sb, &best_so_far[1]))
+                       return;
+       }
+
+       for (i = 0; i < 3; i++)
+               blame_origin_incref(this[i].suspect);
+       decref_split(best_so_far);
+       memcpy(best_so_far, this, sizeof(struct blame_entry [3]));
+}
+
+/*
+ * We are looking at a part of the final image represented by
+ * ent (tlno and same are offset by ent->s_lno).
+ * tlno is where we are looking at in the final image.
+ * up to (but not including) same match preimage.
+ * plno is where we are looking at in the preimage.
+ *
+ * <-------------- final image ---------------------->
+ *       <------ent------>
+ *         ^tlno ^same
+ *    <---------preimage----->
+ *         ^plno
+ *
+ * All line numbers are 0-based.
+ */
+static void handle_split(struct blame_scoreboard *sb,
+                        struct blame_entry *ent,
+                        int tlno, int plno, int same,
+                        struct blame_origin *parent,
+                        struct blame_entry *split)
+{
+       if (ent->num_lines <= tlno)
+               return;
+       if (tlno < same) {
+               struct blame_entry this[3];
+               tlno += ent->s_lno;
+               same += ent->s_lno;
+               split_overlap(this, ent, tlno, plno, same, parent);
+               copy_split_if_better(sb, split, this);
+               decref_split(this);
+       }
+}
 
-       alloc_line_map(commit);
+struct handle_split_cb_data {
+       struct blame_scoreboard *sb;
+       struct blame_entry *ent;
+       struct blame_origin *parent;
+       struct blame_entry *split;
+       long plno;
+       long tlno;
+};
 
-       util = commit->util;
+static int handle_split_cb(long start_a, long count_a,
+                          long start_b, long count_b, void *data)
+{
+       struct handle_split_cb_data *d = data;
+       handle_split(d->sb, d->ent, d->tlno, d->plno, start_b, d->parent,
+                    d->split);
+       d->plno = start_a + count_a;
+       d->tlno = start_b + count_b;
+       return 0;
+}
 
-       for (i = 0; i < util->num_lines; i++)
-               util->line_map[i] = i;
+/*
+ * Find the lines from parent that are the same as ent so that
+ * we can pass blames to it.  file_p has the blob contents for
+ * the parent.
+ */
+static void find_copy_in_blob(struct blame_scoreboard *sb,
+                             struct blame_entry *ent,
+                             struct blame_origin *parent,
+                             struct blame_entry *split,
+                             mmfile_t *file_p)
+{
+       const char *cp;
+       mmfile_t file_o;
+       struct handle_split_cb_data d;
+
+       memset(&d, 0, sizeof(d));
+       d.sb = sb; d.ent = ent; d.parent = parent; d.split = split;
+       /*
+        * Prepare mmfile that contains only the lines in ent.
+        */
+       cp = blame_nth_line(sb, ent->lno);
+       file_o.ptr = (char *) cp;
+       file_o.size = blame_nth_line(sb, ent->lno + ent->num_lines) - cp;
+
+       /*
+        * file_o is a part of final image we are annotating.
+        * file_p partially may match that image.
+        */
+       memset(split, 0, sizeof(struct blame_entry [3]));
+       if (diff_hunks(file_p, &file_o, handle_split_cb, &d, sb->xdl_opts))
+               die("unable to generate diff (%s)",
+                   oid_to_hex(&parent->commit->object.oid));
+       /* remainder, if any, all match the preimage */
+       handle_split(sb, ent, d.tlno, d.plno, ent->num_lines, parent, split);
 }
 
+/* Move all blame entries from list *source that have a score smaller
+ * than score_min to the front of list *small.
+ * Returns a pointer to the link pointing to the old head of the small list.
+ */
 
-static void process_commits(struct rev_info *rev, const char *path,
-                           struct commit** initial)
+static struct blame_entry **filter_small(struct blame_scoreboard *sb,
+                                        struct blame_entry **small,
+                                        struct blame_entry **source,
+                                        unsigned score_min)
 {
-       int i;
-       struct util_info* util;
-       int lines_left;
-       int *blame_p;
-       int *new_lines;
-       int new_lines_len;
-
-       struct commit* commit = get_revision(rev);
-       assert(commit);
-       init_first_commit(commit, path);
-
-       util = commit->util;
-       num_blame_lines = util->num_lines;
-       blame_lines = xmalloc(sizeof(struct commit *) * num_blame_lines);
-       blame_contents = util->buf;
-       blame_len = util->size;
-
-       for (i = 0; i < num_blame_lines; i++)
-               blame_lines[i] = NULL;
-
-       lines_left = num_blame_lines;
-       blame_p = xmalloc(sizeof(int) * num_blame_lines);
-       new_lines = xmalloc(sizeof(int) * num_blame_lines);
-       do {
-               struct commit_list *parents;
-               int num_parents;
-               struct util_info *util;
+       struct blame_entry *p = *source;
+       struct blame_entry *oldsmall = *small;
+       while (p) {
+               if (blame_entry_score(sb, p) <= score_min) {
+                       *small = p;
+                       small = &p->next;
+                       p = *small;
+               } else {
+                       *source = p;
+                       source = &p->next;
+                       p = *source;
+               }
+       }
+       *small = oldsmall;
+       *source = NULL;
+       return small;
+}
 
-               if (DEBUG)
-                       printf("\nProcessing commit: %d %s\n", num_commits,
-                              sha1_to_hex(commit->object.sha1));
+/*
+ * See if lines currently target is suspected for can be attributed to
+ * parent.
+ */
+static void find_move_in_parent(struct blame_scoreboard *sb,
+                               struct blame_entry ***blamed,
+                               struct blame_entry **toosmall,
+                               struct blame_origin *target,
+                               struct blame_origin *parent)
+{
+       struct blame_entry *e, split[3];
+       struct blame_entry *unblamed = target->suspects;
+       struct blame_entry *leftover = NULL;
+       mmfile_t file_p;
 
-               if (lines_left == 0)
-                       return;
+       if (!unblamed)
+               return; /* nothing remains for this target */
 
-               num_commits++;
-               memset(blame_p, 0, sizeof(int) * num_blame_lines);
-               new_lines_len = 0;
-               num_parents = 0;
-               for (parents = commit->parents;
-                    parents != NULL; parents = parents->next)
-                       num_parents++;
+       fill_origin_blob(&sb->revs->diffopt, parent, &file_p, &sb->num_read_blob);
+       if (!file_p.ptr)
+               return;
 
-               if(num_parents == 0)
-                       *initial = commit;
+       /* At each iteration, unblamed has a NULL-terminated list of
+        * entries that have not yet been tested for blame.  leftover
+        * contains the reversed list of entries that have been tested
+        * without being assignable to the parent.
+        */
+       do {
+               struct blame_entry **unblamedtail = &unblamed;
+               struct blame_entry *next;
+               for (e = unblamed; e; e = next) {
+                       next = e->next;
+                       find_copy_in_blob(sb, e, parent, split, &file_p);
+                       if (split[1].suspect &&
+                           sb->move_score < blame_entry_score(sb, &split[1])) {
+                               split_blame(blamed, &unblamedtail, split, e);
+                       } else {
+                               e->next = leftover;
+                               leftover = e;
+                       }
+                       decref_split(split);
+               }
+               *unblamedtail = NULL;
+               toosmall = filter_small(sb, toosmall, &unblamed, sb->move_score);
+       } while (unblamed);
+       target->suspects = reverse_blame(leftover, NULL);
+}
 
-               if (fill_util_info(commit))
-                       continue;
+struct blame_list {
+       struct blame_entry *ent;
+       struct blame_entry split[3];
+};
+
+/*
+ * Count the number of entries the target is suspected for,
+ * and prepare a list of entry and the best split.
+ */
+static struct blame_list *setup_blame_list(struct blame_entry *unblamed,
+                                          int *num_ents_p)
+{
+       struct blame_entry *e;
+       int num_ents, i;
+       struct blame_list *blame_list = NULL;
+
+       for (e = unblamed, num_ents = 0; e; e = e->next)
+               num_ents++;
+       if (num_ents) {
+               blame_list = xcalloc(num_ents, sizeof(struct blame_list));
+               for (e = unblamed, i = 0; e; e = e->next)
+                       blame_list[i++].ent = e;
+       }
+       *num_ents_p = num_ents;
+       return blame_list;
+}
 
-               alloc_line_map(commit);
-               util = commit->util;
+/*
+ * For lines target is suspected for, see if we can find code movement
+ * across file boundary from the parent commit.  porigin is the path
+ * in the parent we already tried.
+ */
+static void find_copy_in_parent(struct blame_scoreboard *sb,
+                               struct blame_entry ***blamed,
+                               struct blame_entry **toosmall,
+                               struct blame_origin *target,
+                               struct commit *parent,
+                               struct blame_origin *porigin,
+                               int opt)
+{
+       struct diff_options diff_opts;
+       int i, j;
+       struct blame_list *blame_list;
+       int num_ents;
+       struct blame_entry *unblamed = target->suspects;
+       struct blame_entry *leftover = NULL;
 
-               for (parents = commit->parents;
-                    parents != NULL; parents = parents->next) {
-                       struct commit *parent = parents->item;
-                       struct patch *patch;
+       if (!unblamed)
+               return; /* nothing remains for this target */
 
-                       if (parse_commit(parent) < 0)
-                               die("parse_commit error");
+       diff_setup(&diff_opts);
+       DIFF_OPT_SET(&diff_opts, RECURSIVE);
+       diff_opts.output_format = DIFF_FORMAT_NO_OUTPUT;
+
+       diff_setup_done(&diff_opts);
+
+       /* Try "find copies harder" on new path if requested;
+        * we do not want to use diffcore_rename() actually to
+        * match things up; find_copies_harder is set only to
+        * force diff_tree_oid() to feed all filepairs to diff_queue,
+        * and this code needs to be after diff_setup_done(), which
+        * usually makes find-copies-harder imply copy detection.
+        */
+       if ((opt & PICKAXE_BLAME_COPY_HARDEST)
+           || ((opt & PICKAXE_BLAME_COPY_HARDER)
+               && (!porigin || strcmp(target->path, porigin->path))))
+               DIFF_OPT_SET(&diff_opts, FIND_COPIES_HARDER);
+
+       if (is_null_oid(&target->commit->object.oid))
+               do_diff_cache(&parent->tree->object.oid, &diff_opts);
+       else
+               diff_tree_oid(&parent->tree->object.oid,
+                             &target->commit->tree->object.oid,
+                             "", &diff_opts);
 
-                       if (DEBUG)
-                               printf("parent: %s\n",
-                                      sha1_to_hex(parent->object.sha1));
+       if (!DIFF_OPT_TST(&diff_opts, FIND_COPIES_HARDER))
+               diffcore_std(&diff_opts);
 
-                       if (fill_util_info(parent)) {
-                               num_parents--;
+       do {
+               struct blame_entry **unblamedtail = &unblamed;
+               blame_list = setup_blame_list(unblamed, &num_ents);
+
+               for (i = 0; i < diff_queued_diff.nr; i++) {
+                       struct diff_filepair *p = diff_queued_diff.queue[i];
+                       struct blame_origin *norigin;
+                       mmfile_t file_p;
+                       struct blame_entry this[3];
+
+                       if (!DIFF_FILE_VALID(p->one))
+                               continue; /* does not exist in parent */
+                       if (S_ISGITLINK(p->one->mode))
+                               continue; /* ignore git links */
+                       if (porigin && !strcmp(p->one->path, porigin->path))
+                               /* find_move already dealt with this path */
+                               continue;
+
+                       norigin = get_origin(parent, p->one->path);
+                       oidcpy(&norigin->blob_oid, &p->one->oid);
+                       norigin->mode = p->one->mode;
+                       fill_origin_blob(&sb->revs->diffopt, norigin, &file_p, &sb->num_read_blob);
+                       if (!file_p.ptr)
                                continue;
-                       }
 
-                       patch = get_patch(parent, commit);
-                        alloc_line_map(parent);
-                        fill_line_map(parent, commit, patch);
-
-                        for (i = 0; i < patch->num; i++) {
-                            int l;
-                            for (l = 0; l < patch->chunks[i].len2; l++) {
-                                int mapped_line =
-                                    map_line(commit, patch->chunks[i].off2 + l);
-                                if (mapped_line != -1) {
-                                    blame_p[mapped_line]++;
-                                    if (blame_p[mapped_line] == num_parents)
-                                        new_lines[new_lines_len++] = mapped_line;
-                                }
-                            }
+                       for (j = 0; j < num_ents; j++) {
+                               find_copy_in_blob(sb, blame_list[j].ent,
+                                                 norigin, this, &file_p);
+                               copy_split_if_better(sb, blame_list[j].split,
+                                                    this);
+                               decref_split(this);
                        }
-                        free_patch(patch);
+                       blame_origin_decref(norigin);
                }
 
-               if (DEBUG)
-                       printf("parents: %d\n", num_parents);
-
-               for (i = 0; i < new_lines_len; i++) {
-                       int mapped_line = new_lines[i];
-                       if (blame_lines[mapped_line] == NULL) {
-                               blame_lines[mapped_line] = commit;
-                               lines_left--;
-                               if (DEBUG)
-                                       printf("blame: mapped: %d i: %d\n",
-                                              mapped_line, i);
+               for (j = 0; j < num_ents; j++) {
+                       struct blame_entry *split = blame_list[j].split;
+                       if (split[1].suspect &&
+                           sb->copy_score < blame_entry_score(sb, &split[1])) {
+                               split_blame(blamed, &unblamedtail, split,
+                                           blame_list[j].ent);
+                       } else {
+                               blame_list[j].ent->next = leftover;
+                               leftover = blame_list[j].ent;
                        }
+                       decref_split(split);
                }
-       } while ((commit = get_revision(rev)) != NULL);
+               free(blame_list);
+               *unblamedtail = NULL;
+               toosmall = filter_small(sb, toosmall, &unblamed, sb->copy_score);
+       } while (unblamed);
+       target->suspects = reverse_blame(leftover, NULL);
+       diff_flush(&diff_opts);
+       clear_pathspec(&diff_opts.pathspec);
 }
 
-
-static int compare_tree_path(struct rev_info* revs,
-                            struct commit* c1, struct commit* c2)
+/*
+ * The blobs of origin and porigin exactly match, so everything
+ * origin is suspected for can be blamed on the parent.
+ */
+static void pass_whole_blame(struct blame_scoreboard *sb,
+                            struct blame_origin *origin, struct blame_origin *porigin)
 {
-       int ret;
-       const char* paths[2];
-       struct util_info* util = c2->util;
-       paths[0] = util->pathname;
-       paths[1] = NULL;
+       struct blame_entry *e, *suspects;
 
-       diff_tree_setup_paths(get_pathspec(revs->prefix, paths),
-                             &revs->pruning);
-       ret = rev_compare_tree(revs, c1->tree, c2->tree);
-       diff_tree_release_paths(&revs->pruning);
-       return ret;
+       if (!porigin->file.ptr && origin->file.ptr) {
+               /* Steal its file */
+               porigin->file = origin->file;
+               origin->file.ptr = NULL;
+       }
+       suspects = origin->suspects;
+       origin->suspects = NULL;
+       for (e = suspects; e; e = e->next) {
+               blame_origin_incref(porigin);
+               blame_origin_decref(e->suspect);
+               e->suspect = porigin;
+       }
+       queue_blames(sb, porigin, suspects);
 }
 
-
-static int same_tree_as_empty_path(struct rev_info *revs, struct tree* t1,
-                                  const char* path)
+/*
+ * We pass blame from the current commit to its parents.  We keep saying
+ * "parent" (and "porigin"), but what we mean is to find scapegoat to
+ * exonerate ourselves.
+ */
+static struct commit_list *first_scapegoat(struct rev_info *revs, struct commit *commit,
+                                       int reverse)
 {
-       int ret;
-       const char* paths[2];
-       paths[0] = path;
-       paths[1] = NULL;
-
-       diff_tree_setup_paths(get_pathspec(revs->prefix, paths),
-                             &revs->pruning);
-       ret = rev_same_tree_as_empty(revs, t1);
-       diff_tree_release_paths(&revs->pruning);
-       return ret;
+       if (!reverse) {
+               if (revs->first_parent_only &&
+                   commit->parents &&
+                   commit->parents->next) {
+                       free_commit_list(commit->parents->next);
+                       commit->parents->next = NULL;
+               }
+               return commit->parents;
+       }
+       return lookup_decoration(&revs->children, &commit->object);
 }
 
-static const char* find_rename(struct commit* commit, struct commit* parent)
+static int num_scapegoats(struct rev_info *revs, struct commit *commit, int reverse)
 {
-       struct util_info* cutil = commit->util;
-       struct diff_options diff_opts;
-       const char *paths[1];
-       int i;
+       struct commit_list *l = first_scapegoat(revs, commit, reverse);
+       return commit_list_count(l);
+}
 
-       if (DEBUG) {
-               printf("find_rename commit: %s ",
-                      sha1_to_hex(commit->object.sha1));
-               puts(sha1_to_hex(parent->object.sha1));
+/* Distribute collected unsorted blames to the respected sorted lists
+ * in the various origins.
+ */
+static void distribute_blame(struct blame_scoreboard *sb, struct blame_entry *blamed)
+{
+       blamed = llist_mergesort(blamed, get_next_blame, set_next_blame,
+                                compare_blame_suspect);
+       while (blamed)
+       {
+               struct blame_origin *porigin = blamed->suspect;
+               struct blame_entry *suspects = NULL;
+               do {
+                       struct blame_entry *next = blamed->next;
+                       blamed->next = suspects;
+                       suspects = blamed;
+                       blamed = next;
+               } while (blamed && blamed->suspect == porigin);
+               suspects = reverse_blame(suspects, NULL);
+               queue_blames(sb, porigin, suspects);
        }
+}
 
-       diff_setup(&diff_opts);
-       diff_opts.recursive = 1;
-       diff_opts.detect_rename = DIFF_DETECT_RENAME;
-       paths[0] = NULL;
-       diff_tree_setup_paths(paths, &diff_opts);
-       if (diff_setup_done(&diff_opts) < 0)
-               die("diff_setup_done failed");
+#define MAXSG 16
 
-       diff_tree_sha1(commit->tree->object.sha1, parent->tree->object.sha1,
-                      "", &diff_opts);
-       diffcore_std(&diff_opts);
+static void pass_blame(struct blame_scoreboard *sb, struct blame_origin *origin, int opt)
+{
+       struct rev_info *revs = sb->revs;
+       int i, pass, num_sg;
+       struct commit *commit = origin->commit;
+       struct commit_list *sg;
+       struct blame_origin *sg_buf[MAXSG];
+       struct blame_origin *porigin, **sg_origin = sg_buf;
+       struct blame_entry *toosmall = NULL;
+       struct blame_entry *blames, **blametail = &blames;
+
+       num_sg = num_scapegoats(revs, commit, sb->reverse);
+       if (!num_sg)
+               goto finish;
+       else if (num_sg < ARRAY_SIZE(sg_buf))
+               memset(sg_buf, 0, sizeof(sg_buf));
+       else
+               sg_origin = xcalloc(num_sg, sizeof(*sg_origin));
+
+       /*
+        * The first pass looks for unrenamed path to optimize for
+        * common cases, then we look for renames in the second pass.
+        */
+       for (pass = 0; pass < 2 - sb->no_whole_file_rename; pass++) {
+               struct blame_origin *(*find)(struct commit *, struct blame_origin *);
+               find = pass ? find_rename : find_origin;
+
+               for (i = 0, sg = first_scapegoat(revs, commit, sb->reverse);
+                    i < num_sg && sg;
+                    sg = sg->next, i++) {
+                       struct commit *p = sg->item;
+                       int j, same;
+
+                       if (sg_origin[i])
+                               continue;
+                       if (parse_commit(p))
+                               continue;
+                       porigin = find(p, origin);
+                       if (!porigin)
+                               continue;
+                       if (!oidcmp(&porigin->blob_oid, &origin->blob_oid)) {
+                               pass_whole_blame(sb, origin, porigin);
+                               blame_origin_decref(porigin);
+                               goto finish;
+                       }
+                       for (j = same = 0; j < i; j++)
+                               if (sg_origin[j] &&
+                                   !oidcmp(&sg_origin[j]->blob_oid, &porigin->blob_oid)) {
+                                       same = 1;
+                                       break;
+                               }
+                       if (!same)
+                               sg_origin[i] = porigin;
+                       else
+                               blame_origin_decref(porigin);
+               }
+       }
 
-       for (i = 0; i < diff_queued_diff.nr; i++) {
-               struct diff_filepair *p = diff_queued_diff.queue[i];
+       sb->num_commits++;
+       for (i = 0, sg = first_scapegoat(revs, commit, sb->reverse);
+            i < num_sg && sg;
+            sg = sg->next, i++) {
+               struct blame_origin *porigin = sg_origin[i];
+               if (!porigin)
+                       continue;
+               if (!origin->previous) {
+                       blame_origin_incref(porigin);
+                       origin->previous = porigin;
+               }
+               pass_blame_to_parent(sb, origin, porigin);
+               if (!origin->suspects)
+                       goto finish;
+       }
 
-               if (p->status == 'R' && !strcmp(p->one->path, cutil->pathname)) {
-                       if (DEBUG)
-                               printf("rename %s -> %s\n", p->one->path, p->two->path);
-                       return p->two->path;
+       /*
+        * Optionally find moves in parents' files.
+        */
+       if (opt & PICKAXE_BLAME_MOVE) {
+               filter_small(sb, &toosmall, &origin->suspects, sb->move_score);
+               if (origin->suspects) {
+                       for (i = 0, sg = first_scapegoat(revs, commit, sb->reverse);
+                            i < num_sg && sg;
+                            sg = sg->next, i++) {
+                               struct blame_origin *porigin = sg_origin[i];
+                               if (!porigin)
+                                       continue;
+                               find_move_in_parent(sb, &blametail, &toosmall, origin, porigin);
+                               if (!origin->suspects)
+                                       break;
+                       }
                }
        }
 
-       return 0;
+       /*
+        * Optionally find copies from parents' files.
+        */
+       if (opt & PICKAXE_BLAME_COPY) {
+               if (sb->copy_score > sb->move_score)
+                       filter_small(sb, &toosmall, &origin->suspects, sb->copy_score);
+               else if (sb->copy_score < sb->move_score) {
+                       origin->suspects = blame_merge(origin->suspects, toosmall);
+                       toosmall = NULL;
+                       filter_small(sb, &toosmall, &origin->suspects, sb->copy_score);
+               }
+               if (!origin->suspects)
+                       goto finish;
+
+               for (i = 0, sg = first_scapegoat(revs, commit, sb->reverse);
+                    i < num_sg && sg;
+                    sg = sg->next, i++) {
+                       struct blame_origin *porigin = sg_origin[i];
+                       find_copy_in_parent(sb, &blametail, &toosmall,
+                                           origin, sg->item, porigin, opt);
+                       if (!origin->suspects)
+                               goto finish;
+               }
+       }
+
+finish:
+       *blametail = NULL;
+       distribute_blame(sb, blames);
+       /*
+        * prepend toosmall to origin->suspects
+        *
+        * There is no point in sorting: this ends up on a big
+        * unsorted list in the caller anyway.
+        */
+       if (toosmall) {
+               struct blame_entry **tail = &toosmall;
+               while (*tail)
+                       tail = &(*tail)->next;
+               *tail = origin->suspects;
+               origin->suspects = toosmall;
+       }
+       for (i = 0; i < num_sg; i++) {
+               if (sg_origin[i]) {
+                       drop_origin_blob(sg_origin[i]);
+                       blame_origin_decref(sg_origin[i]);
+               }
+       }
+       drop_origin_blob(origin);
+       if (sg_buf != sg_origin)
+               free(sg_origin);
 }
 
-static void simplify_commit(struct rev_info *revs, struct commit *commit)
+/*
+ * The main loop -- while we have blobs with lines whose true origin
+ * is still unknown, pick one blob, and allow its lines to pass blames
+ * to its parents. */
+void assign_blame(struct blame_scoreboard *sb, int opt)
 {
-       struct commit_list **pp, *parent;
+       struct rev_info *revs = sb->revs;
+       struct commit *commit = prio_queue_get(&sb->commits);
 
-       if (!commit->tree)
-               return;
+       while (commit) {
+               struct blame_entry *ent;
+               struct blame_origin *suspect = commit->util;
 
-       if (!commit->parents) {
-               struct util_info* util = commit->util;
-               if (!same_tree_as_empty_path(revs, commit->tree,
-                                            util->pathname))
-                       commit->object.flags |= TREECHANGE;
-               return;
-       }
-
-       pp = &commit->parents;
-       while ((parent = *pp) != NULL) {
-               struct commit *p = parent->item;
+               /* find one suspect to break down */
+               while (suspect && !suspect->suspects)
+                       suspect = suspect->next;
 
-               if (p->object.flags & UNINTERESTING) {
-                       pp = &parent->next;
+               if (!suspect) {
+                       commit = prio_queue_get(&sb->commits);
                        continue;
                }
 
-               parse_commit(p);
-               switch (compare_tree_path(revs, p, commit)) {
-               case REV_TREE_SAME:
-                       parent->next = NULL;
-                       commit->parents = parent;
-                       get_util(p)->pathname = get_util(commit)->pathname;
-                       return;
-
-               case REV_TREE_NEW:
-               {
-
-                       struct util_info* util = commit->util;
-                       if (revs->remove_empty_trees &&
-                           same_tree_as_empty_path(revs, p->tree,
-                                                   util->pathname)) {
-                               const char* new_name = find_rename(commit, p);
-                               if (new_name) {
-                                       struct util_info* putil = get_util(p);
-                                       if (!putil->pathname)
-                                               putil->pathname = strdup(new_name);
-                               } else {
-                                       *pp = parent->next;
+               assert(commit == suspect->commit);
+
+               /*
+                * We will use this suspect later in the loop,
+                * so hold onto it in the meantime.
+                */
+               blame_origin_incref(suspect);
+               parse_commit(commit);
+               if (sb->reverse ||
+                   (!(commit->object.flags & UNINTERESTING) &&
+                    !(revs->max_age != -1 && commit->date < revs->max_age)))
+                       pass_blame(sb, suspect, opt);
+               else {
+                       commit->object.flags |= UNINTERESTING;
+                       if (commit->object.parsed)
+                               mark_parents_uninteresting(commit);
+               }
+               /* treat root commit as boundary */
+               if (!commit->parents && !sb->show_root)
+                       commit->object.flags |= UNINTERESTING;
+
+               /* Take responsibility for the remaining entries */
+               ent = suspect->suspects;
+               if (ent) {
+                       suspect->guilty = 1;
+                       for (;;) {
+                               struct blame_entry *next = ent->next;
+                               if (sb->found_guilty_entry)
+                                       sb->found_guilty_entry(ent, sb->found_guilty_entry_data);
+                               if (next) {
+                                       ent = next;
                                        continue;
                                }
+                               ent->next = sb->ent;
+                               sb->ent = suspect->suspects;
+                               suspect->suspects = NULL;
+                               break;
                        }
                }
+               blame_origin_decref(suspect);
 
-               /* fallthrough */
-               case REV_TREE_DIFFERENT:
-                       pp = &parent->next;
-                       if (!get_util(p)->pathname)
-                               get_util(p)->pathname =
-                                       get_util(commit)->pathname;
-                       continue;
-               }
-               die("bad tree compare for commit %s",
-                   sha1_to_hex(commit->object.sha1));
+               if (sb->debug) /* sanity */
+                       sanity_check_refcnt(sb);
        }
-       commit->object.flags |= TREECHANGE;
 }
 
-
-struct commit_info
+static const char *get_next_line(const char *start, const char *end)
 {
-       char* author;
-       char* author_mail;
-       unsigned long author_time;
-       char* author_tz;
-};
+       const char *nl = memchr(start, '\n', end - start);
+       return nl ? nl + 1 : end;
+}
 
-static void get_commit_info(struct commit* commit, struct commit_info* ret)
+/*
+ * To allow quick access to the contents of nth line in the
+ * final image, prepare an index in the scoreboard.
+ */
+static int prepare_lines(struct blame_scoreboard *sb)
 {
-       int len;
-       char* tmp;
-       static char author_buf[1024];
+       const char *buf = sb->final_buf;
+       unsigned long len = sb->final_buf_size;
+       const char *end = buf + len;
+       const char *p;
+       int *lineno;
+       int num = 0;
 
-       tmp = strstr(commit->buffer, "\nauthor ") + 8;
-       len = strchr(tmp, '\n') - tmp;
-       ret->author = author_buf;
-       memcpy(ret->author, tmp, len);
+       for (p = buf; p < end; p = get_next_line(p, end))
+               num++;
 
-       tmp = ret->author;
-       tmp += len;
-       *tmp = 0;
-       while(*tmp != ' ')
-               tmp--;
-       ret->author_tz = tmp+1;
+       ALLOC_ARRAY(sb->lineno, num + 1);
+       lineno = sb->lineno;
 
-       *tmp = 0;
-       while(*tmp != ' ')
-               tmp--;
-       ret->author_time = strtoul(tmp, NULL, 10);
+       for (p = buf; p < end; p = get_next_line(p, end))
+               *lineno++ = p - buf;
 
-       *tmp = 0;
-       while(*tmp != ' ')
-               tmp--;
-       ret->author_mail = tmp + 1;
+       *lineno = len;
 
-       *tmp = 0;
+       sb->num_lines = num;
+       return sb->num_lines;
 }
 
-static const char* format_time(unsigned long time, const char* tz_str,
-                              int show_raw_time)
+static struct commit *find_single_final(struct rev_info *revs,
+                                       const char **name_p)
 {
-       static char time_buf[128];
-       time_t t = time;
-       int minutes, tz;
-       struct tm *tm;
+       int i;
+       struct commit *found = NULL;
+       const char *name = NULL;
 
-       if (show_raw_time) {
-               sprintf(time_buf, "%lu %s", time, tz_str);
-               return time_buf;
+       for (i = 0; i < revs->pending.nr; i++) {
+               struct object *obj = revs->pending.objects[i].item;
+               if (obj->flags & UNINTERESTING)
+                       continue;
+               obj = deref_tag(obj, NULL, 0);
+               if (obj->type != OBJ_COMMIT)
+                       die("Non commit %s?", revs->pending.objects[i].name);
+               if (found)
+                       die("More than one commit to dig from %s and %s?",
+                           revs->pending.objects[i].name, name);
+               found = (struct commit *)obj;
+               name = revs->pending.objects[i].name;
        }
-
-       tz = atoi(tz_str);
-       minutes = tz < 0 ? -tz : tz;
-       minutes = (minutes / 100)*60 + (minutes % 100);
-       minutes = tz < 0 ? -minutes : minutes;
-       t = time + minutes * 60;
-       tm = gmtime(&t);
-
-       strftime(time_buf, sizeof(time_buf), "%Y-%m-%d %H:%M:%S ", tm);
-       strcat(time_buf, tz_str);
-       return time_buf;
+       if (name_p)
+               *name_p = name;
+       return found;
 }
 
-static void topo_setter(struct commit* c, void* data)
+static struct commit *dwim_reverse_initial(struct rev_info *revs,
+                                          const char **name_p)
 {
-       struct util_info* util = c->util;
-       util->topo_data = data;
+       /*
+        * DWIM "git blame --reverse ONE -- PATH" as
+        * "git blame --reverse ONE..HEAD -- PATH" but only do so
+        * when it makes sense.
+        */
+       struct object *obj;
+       struct commit *head_commit;
+       struct object_id head_oid;
+
+       if (revs->pending.nr != 1)
+               return NULL;
+
+       /* Is that sole rev a committish? */
+       obj = revs->pending.objects[0].item;
+       obj = deref_tag(obj, NULL, 0);
+       if (obj->type != OBJ_COMMIT)
+               return NULL;
+
+       /* Do we have HEAD? */
+       if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, head_oid.hash, NULL))
+               return NULL;
+       head_commit = lookup_commit_reference_gently(&head_oid, 1);
+       if (!head_commit)
+               return NULL;
+
+       /* Turn "ONE" into "ONE..HEAD" then */
+       obj->flags |= UNINTERESTING;
+       add_pending_object(revs, &head_commit->object, "HEAD");
+
+       if (name_p)
+               *name_p = revs->pending.objects[0].name;
+       return (struct commit *)obj;
 }
 
-static void* topo_getter(struct commit* c)
+static struct commit *find_single_initial(struct rev_info *revs,
+                                         const char **name_p)
 {
-       struct util_info* util = c->util;
-       return util->topo_data;
+       int i;
+       struct commit *found = NULL;
+       const char *name = NULL;
+
+       /*
+        * There must be one and only one negative commit, and it must be
+        * the boundary.
+        */
+       for (i = 0; i < revs->pending.nr; i++) {
+               struct object *obj = revs->pending.objects[i].item;
+               if (!(obj->flags & UNINTERESTING))
+                       continue;
+               obj = deref_tag(obj, NULL, 0);
+               if (obj->type != OBJ_COMMIT)
+                       die("Non commit %s?", revs->pending.objects[i].name);
+               if (found)
+                       die("More than one commit to dig up from, %s and %s?",
+                           revs->pending.objects[i].name, name);
+               found = (struct commit *) obj;
+               name = revs->pending.objects[i].name;
+       }
+
+       if (!name)
+               found = dwim_reverse_initial(revs, &name);
+       if (!name)
+               die("No commit to dig up from?");
+
+       if (name_p)
+               *name_p = name;
+       return found;
 }
 
-static int read_ancestry(const char *graft_file,
-                        unsigned char **start_sha1)
+void init_scoreboard(struct blame_scoreboard *sb)
 {
-       FILE *fp = fopen(graft_file, "r");
-       char buf[1024];
-       if (!fp)
-               return -1;
-       while (fgets(buf, sizeof(buf), fp)) {
-               /* The format is just "Commit Parent1 Parent2 ...\n" */
-               int len = strlen(buf);
-               struct commit_graft *graft = read_graft_line(buf, len);
-               register_commit_graft(graft, 0);
-               if (!*start_sha1)
-                       *start_sha1 = graft->sha1;
-       }
-       fclose(fp);
-       return 0;
+       memset(sb, 0, sizeof(struct blame_scoreboard));
+       sb->move_score = BLAME_DEFAULT_MOVE_SCORE;
+       sb->copy_score = BLAME_DEFAULT_COPY_SCORE;
 }
 
-int main(int argc, const char **argv)
+void setup_scoreboard(struct blame_scoreboard *sb, const char *path, struct blame_origin **orig)
 {
-       int i;
-       struct commit *initial = NULL;
-       unsigned char sha1[20], *sha1_p = NULL;
-
-       const char *filename = NULL, *commit = NULL;
-       char filename_buf[256];
-       int sha1_len = 8;
-       int compatibility = 0;
-       int show_raw_time = 0;
-       int options = 1;
-       struct commit* start_commit;
-
-       const char* args[10];
-       struct rev_info rev;
-
-       struct commit_info ci;
-       const char *buf;
-       int max_digits;
-       int longest_file, longest_author;
-       int found_rename;
-
-       const char* prefix = setup_git_directory();
-       git_config(git_default_config);
-
-       for(i = 1; i < argc; i++) {
-               if(options) {
-                       if(!strcmp(argv[i], "-h") ||
-                          !strcmp(argv[i], "--help"))
-                               usage(blame_usage);
-                       else if(!strcmp(argv[i], "-l") ||
-                               !strcmp(argv[i], "--long")) {
-                               sha1_len = 40;
-                               continue;
-                       } else if(!strcmp(argv[i], "-c") ||
-                                 !strcmp(argv[i], "--compatibility")) {
-                               compatibility = 1;
-                               continue;
-                       } else if(!strcmp(argv[i], "-t") ||
-                                 !strcmp(argv[i], "--time")) {
-                               show_raw_time = 1;
-                               continue;
-                       } else if(!strcmp(argv[i], "-S")) {
-                               if (i + 1 < argc &&
-                                   !read_ancestry(argv[i + 1], &sha1_p)) {
-                                       compatibility = 1;
-                                       i++;
-                                       continue;
-                               }
-                               usage(blame_usage);
-                       } else if(!strcmp(argv[i], "--")) {
-                               options = 0;
-                               continue;
-                       } else if(argv[i][0] == '-')
-                               usage(blame_usage);
-                       else
-                               options = 0;
-               }
+       const char *final_commit_name = NULL;
+       struct blame_origin *o;
+       struct commit *final_commit = NULL;
+       enum object_type type;
+
+       if (sb->reverse && sb->contents_from)
+               die(_("--contents and --reverse do not blend well."));
+
+       if (!sb->reverse) {
+               sb->final = find_single_final(sb->revs, &final_commit_name);
+               sb->commits.compare = compare_commits_by_commit_date;
+       } else {
+               sb->final = find_single_initial(sb->revs, &final_commit_name);
+               sb->commits.compare = compare_commits_by_reverse_commit_date;
+       }
 
-               if(!options) {
-                       if(!filename)
-                               filename = argv[i];
-                       else if(!commit)
-                               commit = argv[i];
-                       else
-                               usage(blame_usage);
-               }
+       if (sb->final && sb->contents_from)
+               die(_("cannot use --contents with final commit object name"));
+
+       if (sb->reverse && sb->revs->first_parent_only)
+               sb->revs->children.name = NULL;
+
+       if (!sb->final) {
+               /*
+                * "--not A B -- path" without anything positive;
+                * do not default to HEAD, but use the working tree
+                * or "--contents".
+                */
+               setup_work_tree();
+               sb->final = fake_working_tree_commit(&sb->revs->diffopt,
+                                                    path, sb->contents_from);
+               add_pending_object(sb->revs, &(sb->final->object), ":");
        }
 
-       if(!filename)
-               usage(blame_usage);
-       if (commit && sha1_p)
-               usage(blame_usage);
-       else if(!commit)
-               commit = "HEAD";
+       if (sb->reverse && sb->revs->first_parent_only) {
+               final_commit = find_single_final(sb->revs, NULL);
+               if (!final_commit)
+                       die(_("--reverse and --first-parent together require specified latest commit"));
+       }
 
-       if(prefix)
-               sprintf(filename_buf, "%s%s", prefix, filename);
-       else
-               strcpy(filename_buf, filename);
-       filename = filename_buf;
-
-       if (!sha1_p) {
-               if (get_sha1(commit, sha1))
-                       die("get_sha1 failed, commit '%s' not found", commit);
-               sha1_p = sha1;
-       }
-       start_commit = lookup_commit_reference(sha1_p);
-       get_util(start_commit)->pathname = filename;
-       if (fill_util_info(start_commit)) {
-               printf("%s not found in %s\n", filename, commit);
-               return 1;
-       }
-
-
-       init_revisions(&rev);
-       rev.remove_empty_trees = 1;
-       rev.topo_order = 1;
-       rev.prune_fn = simplify_commit;
-       rev.topo_setter = topo_setter;
-       rev.topo_getter = topo_getter;
-       rev.parents = 1;
-       rev.limited = 1;
-
-       commit_list_insert(start_commit, &rev.commits);
-
-       args[0] = filename;
-       args[1] = NULL;
-       diff_tree_setup_paths(args, &rev.pruning);
-       prepare_revision_walk(&rev);
-       process_commits(&rev, filename, &initial);
-
-       buf = blame_contents;
-       for (max_digits = 1, i = 10; i <= num_blame_lines + 1; max_digits++)
-               i *= 10;
-
-       longest_file = 0;
-       longest_author = 0;
-       found_rename = 0;
-       for (i = 0; i < num_blame_lines; i++) {
-               struct commit *c = blame_lines[i];
-               struct util_info* u;
-               if (!c)
-                       c = initial;
-               u = c->util;
-
-               if (!found_rename && strcmp(filename, u->pathname))
-                       found_rename = 1;
-               if (longest_file < strlen(u->pathname))
-                       longest_file = strlen(u->pathname);
-               get_commit_info(c, &ci);
-               if (longest_author < strlen(ci.author))
-                       longest_author = strlen(ci.author);
-       }
-
-       for (i = 0; i < num_blame_lines; i++) {
-               struct commit *c = blame_lines[i];
-               struct util_info* u;
-
-               if (!c)
-                       c = initial;
-
-               u = c->util;
-               get_commit_info(c, &ci);
-               fwrite(sha1_to_hex(c->object.sha1), sha1_len, 1, stdout);
-               if(compatibility) {
-                       printf("\t(%10s\t%10s\t%d)", ci.author,
-                              format_time(ci.author_time, ci.author_tz,
-                                          show_raw_time),
-                              i+1);
-               } else {
-                       if (found_rename)
-                               printf(" %-*.*s", longest_file, longest_file,
-                                      u->pathname);
-                       printf(" (%-*.*s %10s %*d) ",
-                              longest_author, longest_author, ci.author,
-                              format_time(ci.author_time, ci.author_tz,
-                                          show_raw_time),
-                              max_digits, i+1);
+       /*
+        * If we have bottom, this will mark the ancestors of the
+        * bottom commits we would reach while traversing as
+        * uninteresting.
+        */
+       if (prepare_revision_walk(sb->revs))
+               die(_("revision walk setup failed"));
+
+       if (sb->reverse && sb->revs->first_parent_only) {
+               struct commit *c = final_commit;
+
+               sb->revs->children.name = "children";
+               while (c->parents &&
+                      oidcmp(&c->object.oid, &sb->final->object.oid)) {
+                       struct commit_list *l = xcalloc(1, sizeof(*l));
+
+                       l->item = c;
+                       if (add_decoration(&sb->revs->children,
+                                          &c->parents->item->object, l))
+                               die("BUG: not unique item in first-parent chain");
+                       c = c->parents->item;
                }
 
-               if(i == num_blame_lines - 1) {
-                       fwrite(buf, blame_len - (buf - blame_contents),
-                              1, stdout);
-                       if(blame_contents[blame_len-1] != '\n')
-                               putc('\n', stdout);
-               } else {
-                       char* next_buf = strchr(buf, '\n') + 1;
-                       fwrite(buf, next_buf - buf, 1, stdout);
-                       buf = next_buf;
-               }
+               if (oidcmp(&c->object.oid, &sb->final->object.oid))
+                       die(_("--reverse --first-parent together require range along first-parent chain"));
        }
 
-       if (DEBUG) {
-               printf("num get patch: %d\n", num_get_patch);
-               printf("num commits: %d\n", num_commits);
-               printf("patch time: %f\n", patch_time / 1000000.0);
-               printf("initial: %s\n", sha1_to_hex(initial->object.sha1));
+       if (is_null_oid(&sb->final->object.oid)) {
+               o = sb->final->util;
+               sb->final_buf = xmemdupz(o->file.ptr, o->file.size);
+               sb->final_buf_size = o->file.size;
+       }
+       else {
+               o = get_origin(sb->final, path);
+               if (fill_blob_sha1_and_mode(o))
+                       die(_("no such path %s in %s"), path, final_commit_name);
+
+               if (DIFF_OPT_TST(&sb->revs->diffopt, ALLOW_TEXTCONV) &&
+                   textconv_object(path, o->mode, &o->blob_oid, 1, (char **) &sb->final_buf,
+                                   &sb->final_buf_size))
+                       ;
+               else
+                       sb->final_buf = read_sha1_file(o->blob_oid.hash, &type,
+                                                      &sb->final_buf_size);
+
+               if (!sb->final_buf)
+                       die(_("cannot read blob %s for path %s"),
+                           oid_to_hex(&o->blob_oid),
+                           path);
        }
+       sb->num_read_blob++;
+       prepare_lines(sb);
 
-       return 0;
+       if (orig)
+               *orig = o;
+}
+
+
+
+struct blame_entry *blame_entry_prepend(struct blame_entry *head,
+                                       long start, long end,
+                                       struct blame_origin *o)
+{
+       struct blame_entry *new_head = xcalloc(1, sizeof(struct blame_entry));
+       new_head->lno = start;
+       new_head->num_lines = end - start;
+       new_head->suspect = o;
+       new_head->s_lno = start;
+       new_head->next = head;
+       blame_origin_incref(o);
+       return new_head;
 }