kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity
Browse Source

Merge branch 'fk/blame' into next 

* fk/blame:
  git-blame, take 2
  Merge part of 'lt/rev-list' into 'fk/blame'
maint
Junio C Hamano 19 years ago
parent
6f85a78df6 fc675b8cd5
commit
262cc77dab
1 changed files with 485 additions and 365 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 850
      blame.c

850
blame.c
Unescape View File

@ -1,4 +1,10 @@ @@ -1,4 +1,10 @@
/*
* Copyright (C) 2006, Fredrik Kuivinen <freku045@student.liu.se>
*/

#include <assert.h>
#include <time.h>
#include <sys/time.h>

#include "cache.h"
#include "refs.h"
@ -7,436 +13,550 @@ @@ -7,436 +13,550 @@
#include "tree.h"
#include "blob.h"
#include "diff.h"
#include "revision.h"

#define DEBUG 0

struct commit** blame_lines;
struct commit **blame_lines;
int num_blame_lines;

struct util_info
{
int* line_map;
int num_lines;
unsigned char sha1[20]; /* blob sha, not commit! */
char* buf;
unsigned long size;
struct util_info {
int *line_map;
unsigned char sha1[20]; /* blob sha, not commit! */
char *buf;
unsigned long size;
int num_lines;
// const char* path;
};

struct chunk
{
int off1, len1; // ---
int off2, len2; // +++
struct chunk {
int off1, len1; // ---
int off2, len2; // +++
};

struct patch
{
struct chunk* chunks;
int num;
struct patch {
struct chunk *chunks;
int num;
};

static void get_blob(struct commit* commit);
static void get_blob(struct commit *commit);

int num_get_patch = 0;
int num_commits = 0;
/* Only used for statistics */
static int num_get_patch = 0;
static int num_commits = 0;
static int patch_time = 0;

struct patch* get_patch(struct commit* commit, struct commit* other)
#define TEMPFILE_PATH_LEN 60
static struct patch *get_patch(struct commit *commit, struct commit *other)
{
struct patch* ret = xmalloc(sizeof(struct patch));
ret->chunks = NULL;
ret->num = 0;

struct util_info* info_c = (struct util_info*) commit->object.util;
struct util_info* info_o = (struct util_info*) other->object.util;

if(!memcmp(info_c->sha1, info_o->sha1, 20))
return ret;

get_blob(commit);
get_blob(other);

FILE* fout = fopen("/tmp/git-blame-tmp1", "w");
if(!fout)
die("fopen tmp1 failed: %s", strerror(errno));

if(fwrite(info_c->buf, info_c->size, 1, fout) != 1)
die("fwrite 1 failed: %s", strerror(errno));
fclose(fout);

fout = fopen("/tmp/git-blame-tmp2", "w");
if(!fout)
die("fopen tmp2 failed: %s", strerror(errno));

if(fwrite(info_o->buf, info_o->size, 1, fout) != 1)
die("fwrite 2 failed: %s", strerror(errno));
fclose(fout);

FILE* fin = popen("diff -u0 /tmp/git-blame-tmp1 /tmp/git-blame-tmp2", "r");
if(!fin)
die("popen failed: %s", strerror(errno));

char buf[1024];
while(fgets(buf, sizeof(buf), fin)) {
if(buf[0] != '@' || buf[1] != '@')
continue;

if(DEBUG)
printf("chunk line: %s", buf);
ret->num++;
ret->chunks = xrealloc(ret->chunks, sizeof(struct chunk)*ret->num);
struct chunk* chunk = &ret->chunks[ret->num-1];

assert(!strncmp(buf, "@@ -", 4));

char* start = buf+4;
char* sp = index(start, ' ');
*sp = '\0';
if(index(start, ',')) {
int ret = sscanf(start, "%d,%d", &chunk->off1, &chunk->len1);
assert(ret == 2);
} else {
int ret = sscanf(start, "%d", &chunk->off1);
assert(ret == 1);
chunk->len1 = 1;
}
*sp = ' ';

start = sp+1;
sp = index(start, ' ');
*sp = '\0';
if(index(start, ',')) {
int ret = sscanf(start, "%d,%d", &chunk->off2, &chunk->len2);
assert(ret == 2);
} else {
int ret = sscanf(start, "%d", &chunk->off2);
assert(ret == 1);
chunk->len2 = 1;
}
*sp = ' ';

if(chunk->off1 > 0)
chunk->off1 -= 1;
if(chunk->off2 > 0)
chunk->off2 -= 1;

assert(chunk->off1 >= 0);
assert(chunk->off2 >= 0);
}
fclose(fin);

num_get_patch++;
return ret;
struct patch *ret;
struct util_info *info_c = (struct util_info *)commit->object.util;
struct util_info *info_o = (struct util_info *)other->object.util;
char tmp_path1[TEMPFILE_PATH_LEN], tmp_path2[TEMPFILE_PATH_LEN];
char diff_cmd[TEMPFILE_PATH_LEN*2 + 20];
struct timeval tv_start, tv_end;
int fd;
FILE *fin;
char buf[1024];

ret = xmalloc(sizeof(struct patch));
ret->chunks = NULL;
ret->num = 0;

get_blob(commit);
get_blob(other);

gettimeofday(&tv_start, NULL);

fd = git_mkstemp(tmp_path1, TEMPFILE_PATH_LEN, "git-blame-XXXXXX");
if (fd < 0)
die("unable to create temp-file: %s", strerror(errno));

if (xwrite(fd, info_c->buf, info_c->size) != info_c->size)
die("write failed: %s", strerror(errno));
close(fd);

fd = git_mkstemp(tmp_path2, TEMPFILE_PATH_LEN, "git-blame-XXXXXX");
if (fd < 0)
die("unable to create temp-file: %s", strerror(errno));

if (xwrite(fd, info_o->buf, info_o->size) != info_o->size)
die("write failed: %s", strerror(errno));
close(fd);

sprintf(diff_cmd, "diff -u0 %s %s", tmp_path1, tmp_path2);
fin = popen(diff_cmd, "r");
if (!fin)
die("popen failed: %s", strerror(errno));

while (fgets(buf, sizeof(buf), fin)) {
struct chunk *chunk;
char *start, *sp;

if (buf[0] != '@' || buf[1] != '@')
continue;

if (DEBUG)
printf("chunk line: %s", buf);
ret->num++;
ret->chunks = xrealloc(ret->chunks,
sizeof(struct chunk) * ret->num);
chunk = &ret->chunks[ret->num - 1];

assert(!strncmp(buf, "@@ -", 4));

start = buf + 4;
sp = index(start, ' ');
*sp = '\0';
if (index(start, ',')) {
int ret =
sscanf(start, "%d,%d", &chunk->off1, &chunk->len1);
assert(ret == 2);
} else {
int ret = sscanf(start, "%d", &chunk->off1);
assert(ret == 1);
chunk->len1 = 1;
}
*sp = ' ';

start = sp + 1;
sp = index(start, ' ');
*sp = '\0';
if (index(start, ',')) {
int ret =
sscanf(start, "%d,%d", &chunk->off2, &chunk->len2);
assert(ret == 2);
} else {
int ret = sscanf(start, "%d", &chunk->off2);
assert(ret == 1);
chunk->len2 = 1;
}
*sp = ' ';

if (chunk->len1 == 0)
chunk->off1++;
if (chunk->len2 == 0)
chunk->off2++;

if (chunk->off1 > 0)
chunk->off1--;
if (chunk->off2 > 0)
chunk->off2--;

assert(chunk->off1 >= 0);
assert(chunk->off2 >= 0);
}
pclose(fin);
unlink(tmp_path1);
unlink(tmp_path2);

gettimeofday(&tv_end, NULL);
patch_time += 1000000 * (tv_end.tv_sec - tv_start.tv_sec) +
tv_end.tv_usec - tv_start.tv_usec;

num_get_patch++;
return ret;
}

void free_patch(struct patch* p)
static void free_patch(struct patch *p)
{
free(p->chunks);
free(p);
free(p->chunks);
free(p);
}

static int get_blob_sha1_internal(unsigned char *sha1, const char *base, int baselen,
const char *pathname, unsigned mode, int stage);

static int get_blob_sha1_internal(unsigned char *sha1, const char *base,
int baselen, const char *pathname,
unsigned mode, int stage);

static unsigned char blob_sha1[20];
static int get_blob_sha1(struct tree* t, const char* pathname, unsigned char* sha1)
static int get_blob_sha1(struct tree *t, const char *pathname,
unsigned char *sha1)
{
const char *pathspec[2];
pathspec[0] = pathname;
pathspec[1] = NULL;
memset(blob_sha1, 0, sizeof(blob_sha1));
read_tree_recursive(t, "", 0, 0, pathspec, get_blob_sha1_internal);

int i;
for(i = 0; i < 20; i++) {
if(blob_sha1[i] != 0)
break;
}

if(i == 20)
return -1;

memcpy(sha1, blob_sha1, 20);
return 0;
int i;
const char *pathspec[2];
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;
}

if (i == 20)
return -1;

memcpy(sha1, blob_sha1, 20);
return 0;
}

static int get_blob_sha1_internal(unsigned char *sha1, const char *base, int baselen,
const char *pathname, unsigned mode, int stage)
static int get_blob_sha1_internal(unsigned char *sha1, const char *base,
int baselen, const char *pathname,
unsigned mode, int stage)
{
// printf("Got blob: %s base: '%s' baselen: %d pathname: '%s' mode: %o stage: %d\n",
// sha1_to_hex(sha1), base, baselen, pathname, mode, stage);

if(S_ISDIR(mode))
return READ_TREE_RECURSIVE;
if (S_ISDIR(mode))
return READ_TREE_RECURSIVE;

memcpy(blob_sha1, sha1, 20);
return -1;
memcpy(blob_sha1, sha1, 20);
return -1;
}

static void get_blob(struct commit* commit)
static void get_blob(struct commit *commit)
{
struct util_info* info = commit->object.util;
char type[20];
struct util_info *info = commit->object.util;
char type[20];

if(info->buf)
return;
if (info->buf)
return;

info->buf = read_sha1_file(info->sha1, type, &info->size);
assert(!strcmp(type, "blob"));
info->buf = read_sha1_file(info->sha1, type, &info->size);

assert(!strcmp(type, "blob"));
}

void print_patch(struct patch* p)
/* For debugging only */
static void print_patch(struct patch *p)
{
printf("Num chunks: %d\n", p->num);
int i;
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 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);
}
}

/* For debugging only */
static void print_map(struct commit *cmit, struct commit *other)
{
struct util_info *util = cmit->object.util;
struct util_info *util2 = other->object.util;

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 (i < util2->num_lines) {
int num2 = util2->line_map[i];
printf("%d\t", num2);
if (num != -1 && num2 != num)
printf("---");
} else
printf("\t");

printf("\n");
}
}

// p is a patch from commit to other.
void fill_line_map(struct commit* commit, struct commit* other, struct patch* p)
static void fill_line_map(struct commit *commit, struct commit *other,
struct patch *p)
{
int num_lines = ((struct util_info*) commit->object.util)->num_lines;
int* line_map = ((struct util_info*) commit->object.util)->line_map;
int num_lines2 = ((struct util_info*) other->object.util)->num_lines;
int* line_map2 = ((struct util_info*) other->object.util)->line_map;
int cur_chunk = 0;
int i1, i2;

if(p->num && DEBUG)
print_patch(p);

for(i1 = 0; i1 < num_lines; i1++)
line_map[i1] = -1;

if(DEBUG)
printf("num lines 1: %d num lines 2: %d\n", num_lines, num_lines2);

for(i1 = 0, i2 = 0; i1 < num_lines; i1++, i2++) {
if(DEBUG > 1)
printf("%d %d\n", i1, i2);

if(i2 >= num_lines2)
break;

line_map[i1] = line_map2[i2];

struct chunk* chunk = NULL;
if(cur_chunk < p->num)
chunk = &p->chunks[cur_chunk];

if(chunk && chunk->off1 == i1) {
i2 = chunk->off2;

if(chunk->len1 > 0)
i1 += chunk->len1-1;
if(chunk->len2 > 0)
i2 += chunk->len2-1;
cur_chunk++;
}
}
struct util_info *util = commit->object.util;
struct util_info *util2 = other->object.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 (DEBUG)
printf("num lines 1: %d num lines 2: %d\n", util->num_lines,
util2->num_lines);

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];

if (chunk && chunk->off1 == i1) {
if (DEBUG && i2 != chunk->off2)
printf("i2: %d off2: %d\n", i2, chunk->off2);

assert(i2 == chunk->off2);

i1--;
i2--;
if (chunk->len1 > 0)
i1 += chunk->len1;

if (chunk->len2 > 0)
i2 += chunk->len2;

cur_chunk++;
} else {
if (i2 >= util2->num_lines)
break;

if (map[i1] != map2[i2] && map[i1] != -1) {
if (DEBUG)
printf("map: i1: %d %d %p i2: %d %d %p\n",
i1, map[i1],
i1 != -1 ? blame_lines[map[i1]] : NULL,
i2, map2[i2],
i2 != -1 ? blame_lines[map2[i2]] : NULL);
if (map2[i2] != -1 &&
blame_lines[map[i1]] &&
!blame_lines[map2[i2]])
map[i1] = map2[i2];
}

if (map[i1] == -1 && map2[i2] != -1)
map[i1] = map2[i2];
}

if (DEBUG > 1)
printf("l1: %d l2: %d i1: %d i2: %d\n",
map[i1], map2[i2], i1, i2);
}
}

int map_line(struct commit* commit, int line)
static int map_line(struct commit *commit, int line)
{
struct util_info* info = commit->object.util;
assert(line >= 0 && line < info->num_lines);
return info->line_map[line];
struct util_info *info = commit->object.util;
assert(line >= 0 && line < info->num_lines);
return info->line_map[line];
}

int fill_util_info(struct commit* commit, const char* path)
static int fill_util_info(struct commit *commit, const char *path)
{
if(commit->object.util)
return 0;

struct util_info* util = xmalloc(sizeof(struct util_info));
util->buf = NULL;
util->size = 0;
util->num_lines = -1;
util->line_map = NULL;

commit->object.util = util;

if(get_blob_sha1(commit->tree, path, util->sha1))
return -1;

return 0;
struct util_info *util;
if (commit->object.util)
return 0;

util = xmalloc(sizeof(struct util_info));

if (get_blob_sha1(commit->tree, path, util->sha1)) {
free(util);
return 1;
} else {
util->buf = NULL;
util->size = 0;
util->line_map = NULL;
util->num_lines = -1;
commit->object.util = util;
return 0;
}
}

void alloc_line_map(struct commit* commit)
static void alloc_line_map(struct commit *commit)
{
struct util_info* util = commit->object.util;

if(util->line_map)
return;
struct util_info *util = commit->object.util;
int i;

get_blob(commit);
if (util->line_map)
return;

int i;
util->num_lines = 0;
for(i = 0; i < util->size; i++) {
if(util->buf[i] == '\n')
util->num_lines++;
}
util->line_map = xmalloc(sizeof(int)*util->num_lines);
}
get_blob(commit);

void copy_line_map(struct commit* dst, struct commit* src)
{
struct util_info* u_dst = dst->object.util;
struct util_info* u_src = src->object.util;
util->num_lines = 0;
for (i = 0; i < util->size; i++) {
if (util->buf[i] == '\n')
util->num_lines++;
}
if(util->buf[util->size - 1] != '\n')
util->num_lines++;

u_dst->line_map = u_src->line_map;
u_dst->num_lines = u_src->num_lines;
u_dst->buf = u_src->buf;
u_dst->size = u_src->size;
}
util->line_map = xmalloc(sizeof(int) * util->num_lines);

void process_commits(struct commit_list* list, const char* path)
{
int i;

while(list) {
struct commit* commit = pop_commit(&list);
struct commit_list* parents;
struct util_info* info;

info = commit->object.util;
num_commits++;
if(DEBUG)
printf("\nProcessing commit: %d %s\n", num_commits, sha1_to_hex(commit->object.sha1));
for(parents = commit->parents;
parents != NULL; parents = parents->next) {
struct commit* parent = parents->item;

if(parse_commit(parent) < 0)
die("parse_commit error");

if(DEBUG)
printf("parent: %s\n", sha1_to_hex(parent->object.sha1));

if(fill_util_info(parent, path))
continue;

// Temporarily assign everything to the parent.
int num_blame = 0;
for(i = 0; i < num_blame_lines; i++) {
if(blame_lines[i] == commit) {
num_blame++;
blame_lines[i] = parent;
}
}

if(num_blame == 0)
continue;

struct patch* patch = get_patch(parent, commit);
if(patch->num == 0) {
copy_line_map(parent, commit);
} else {
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_lines[mapped_line] == parent)
blame_lines[mapped_line] = commit;
}
}
free_patch(patch);
}
}
for (i = 0; i < util->num_lines; i++)
util->line_map[i] = -1;
}

#define SEEN 1
struct commit_list* get_commit_list(struct commit* commit, const char* pathname)
static void init_first_commit(struct commit* commit, const char* filename)
{
struct commit_list* ret = NULL;
struct commit_list* process = NULL;
unsigned char sha1[20];

commit_list_insert(commit, &process);

while(process) {
struct commit* com = pop_commit(&process);
if(com->object.flags & SEEN)
continue;
struct util_info* util;
int i;

com->object.flags |= SEEN;
commit_list_insert(com, &ret);
struct commit_list* parents;
if (fill_util_info(commit, filename))
die("fill_util_info failed");

parse_commit(com);
alloc_line_map(commit);

for(parents = com->parents;
parents != NULL; parents = parents->next) {
struct commit* parent = parents->item;
util = commit->object.util;
num_blame_lines = util->num_lines;

parse_commit(parent);
for (i = 0; i < num_blame_lines; i++)
util->line_map[i] = i;
}

if(!get_blob_sha1(parent->tree, pathname, sha1))
commit_list_insert(parent, &process);
}
}

return ret;
static void process_commits(struct rev_info *rev, const char *path,
struct commit** initial)
{
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->object.util;
num_blame_lines = util->num_lines;
blame_lines = xmalloc(sizeof(struct commit *) * num_blame_lines);
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;

if (DEBUG)
printf("\nProcessing commit: %d %s\n", num_commits,
sha1_to_hex(commit->object.sha1));

if (lines_left == 0)
return;

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++;

if(num_parents == 0)
*initial = commit;

if(fill_util_info(commit, path))
continue;

alloc_line_map(commit);
util = commit->object.util;

for (parents = commit->parents;
parents != NULL; parents = parents->next) {
struct commit *parent = parents->item;
struct patch *patch;

if (parse_commit(parent) < 0)
die("parse_commit error");

if (DEBUG)
printf("parent: %s\n",
sha1_to_hex(parent->object.sha1));

if(fill_util_info(parent, path)) {
num_parents--;
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;
}
}
}
free_patch(patch);
}

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);
}
}
} while ((commit = get_revision(rev)) != NULL);
}

int main(int argc, const char **argv)
{
unsigned char sha1[20];
struct commit *commit;
const char* filename;
int i;

setup_git_directory();

if (argc != 3)
die("Usage: blame commit-ish file");

if (get_sha1(argv[1], sha1))
die("get_sha1 failed");

commit = lookup_commit_reference(sha1);

filename = argv[2];

struct commit_list* list = get_commit_list(commit, filename);
sort_in_topological_order(&list, 1);

if(fill_util_info(commit, filename)) {
printf("%s not found in %s\n", filename, argv[1]);
return 0;
}
alloc_line_map(commit);

struct util_info* util = commit->object.util;
num_blame_lines = util->num_lines;
blame_lines = xmalloc(sizeof(struct commit*)*num_blame_lines);


for(i = 0; i < num_blame_lines; i++) {
blame_lines[i] = commit;

((struct util_info*) commit->object.util)->line_map[i] = i;
}

process_commits(list, filename);

for(i = 0; i < num_blame_lines; i++) {
printf("%d %s\n", i+1-1, sha1_to_hex(blame_lines[i]->object.sha1));
// printf("%d %s\n", i+1-1, find_unique_abbrev(blame_lines[i]->object.sha1, 6));
}

if(DEBUG) {
printf("num get patch: %d\n", num_get_patch);
printf("num commits: %d\n", num_commits);
}

return 0;
int i;
struct commit *initial = NULL;
unsigned char sha1[20];
const char* filename;
int num_args;
const char* args[10];
struct rev_info rev;

setup_git_directory();

if (argc != 3)
die("Usage: blame commit-ish file");


filename = argv[2];

{
struct commit* commit;
if (get_sha1(argv[1], sha1))
die("get_sha1 failed");
commit = lookup_commit_reference(sha1);

if (fill_util_info(commit, filename)) {
printf("%s not found in %s\n", filename, argv[1]);
return 1;
}
}

num_args = 0;
args[num_args++] = NULL;
args[num_args++] = "--topo-order";
args[num_args++] = "--remove-empty";
args[num_args++] = argv[1];
args[num_args++] = "--";
args[num_args++] = filename;
args[num_args] = NULL;

setup_revisions(num_args, args, &rev, "HEAD");
prepare_revision_walk(&rev);
process_commits(&rev, filename, &initial);

for (i = 0; i < num_blame_lines; i++) {
struct commit *c = blame_lines[i];
if (!c)
c = initial;

printf("%d %.8s\n", i, sha1_to_hex(c->object.sha1));
// printf("%d %s\n", i, find_unique_abbrev(blame_lines[i]->object.sha1, 6));
}

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));
}

return 0;
}

Write Preview
Loading…
Cancel
Save