blame: use a helper function in blame_chunk()

The same code for splitting a blame_entry at a particular line was used
twice in blame_chunk(), and I'll use the helper again in an upcoming
patch.

Signed-off-by: Barret Rhoden <brho@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/blame.c b/blame.c
index 43861437f749849e85d448eba692b42488ec459d..b6f8ba75f95bf705ad443c9be907f6395debc951 100644 (file)
--- a/blame.c
+++ b/blame.c
@@ -838,6 +838,27 @@ static struct blame_entry *reverse_blame(struct blame_entry *head,
        return tail;
 }
 
        return tail;
 }
 

+/*
+ * Splits a blame entry into two entries at 'len' lines.  The original 'e'
+ * consists of len lines, i.e. [e->lno, e->lno + len), and the second part,
+ * which is returned, consists of the remainder: [e->lno + len, e->lno +
+ * e->num_lines).  The caller needs to sort out the reference counting for the
+ * new entry's suspect.
+ */
+static struct blame_entry *split_blame_at(struct blame_entry *e, int len,
+                                         struct blame_origin *new_suspect)
+{
+       struct blame_entry *n = xcalloc(1, sizeof(struct blame_entry));
+
+       n->suspect = new_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;
+       return n;
+}
+

 /*
  * Process one hunk from the patch between the current suspect for
  * blame_entry e and its parent.  This first blames any unfinished
 /*
  * Process one hunk from the patch between the current suspect for
  * blame_entry e and its parent.  This first blames any unfinished


@@ -864,14 +885,9 @@ static void blame_chunk(struct blame_entry ***dstq, struct blame_entry ***srcq,
                 */
                if (e->s_lno + e->num_lines > tlno) {
                        /* Move second half to a new record */
                 */
                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;
+                       struct blame_entry *n;
+
+                       n = split_blame_at(e, tlno - e->s_lno, e->suspect);

                        /* Push new record to diffp */
                        n->next = diffp;
                        diffp = n;
                        /* Push new record to diffp */
                        n->next = diffp;
                        diffp = n;


@@ -918,14 +934,10 @@ static void blame_chunk(struct blame_entry ***dstq, struct blame_entry ***srcq,
                         * Move second half to a new record to be
                         * processed by later chunks
                         */
                         * 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;
+                       struct blame_entry *n;
+
+                       n = split_blame_at(e, same - e->s_lno,
+                                          blame_origin_incref(e->suspect));

                        /* Push new record to samep */
                        n->next = samep;
                        samep = n;
                        /* Push new record to samep */
                        n->next = samep;
                        samep = n;