blame.c

   1 /*
   2  * Copyright (C) 2006, Fredrik Kuivinen <freku045@student.liu.se>
   3  */
   4
   5 #include <assert.h>
   6 #include <time.h>
   7 #include <sys/time.h>
   8 #include <math.h>
   9
  10 #include "cache.h"
  11 #include "refs.h"
  12 #include "tag.h"
  13 #include "commit.h"
  14 #include "tree.h"
  15 #include "blob.h"
  16 #include "diff.h"
  17 #include "diffcore.h"
  18 #include "revision.h"
  19 #include "xdiff-interface.h"
  20
  21 #define DEBUG 0
  22
  23 static const char blame_usage[] = "[-c] [-l] [--] file [commit]\n"
  24         "  -c, --compability Use the same output mode as git-annotate (Default: off)\n"
  25         "  -l, --long        Show long commit SHA1 (Default: off)\n"
  26         "  -h, --help        This message";
  27
  28 static struct commit **blame_lines;
  29 static int num_blame_lines;
  30 static char* blame_contents;
  31 static int blame_len;
  32
  33 struct util_info {
  34         int *line_map;
  35         unsigned char sha1[20]; /* blob sha, not commit! */
  36         char *buf;
  37         unsigned long size;
  38         int num_lines;
  39         const char* pathname;
  40
  41         void* topo_data;
  42 };
  43
  44 struct chunk {
  45         int off1, len1; // ---
  46         int off2, len2; // +++
  47 };
  48
  49 struct patch {
  50         struct chunk *chunks;
  51         int num;
  52 };
  53
  54 static void get_blob(struct commit *commit);
  55
  56 /* Only used for statistics */
  57 static int num_get_patch = 0;
  58 static int num_commits = 0;
  59 static int patch_time = 0;
  60
  61 struct blame_diff_state {
  62         struct xdiff_emit_state xm;
  63         struct patch *ret;
  64 };
  65
  66 static void process_u0_diff(void *state_, char *line, unsigned long len)
  67 {
  68         struct blame_diff_state *state = state_;
  69         struct chunk *chunk;
  70
  71         if (len < 4 || line[0] != '@' || line[1] != '@')
  72                 return;
  73
  74         if (DEBUG)
  75                 printf("chunk line: %.*s", (int)len, line);
  76         state->ret->num++;
  77         state->ret->chunks = xrealloc(state->ret->chunks,
  78                                       sizeof(struct chunk) * state->ret->num);
  79         chunk = &state->ret->chunks[state->ret->num - 1];
  80
  81         assert(!strncmp(line, "@@ -", 4));
  82
  83         if (parse_hunk_header(line, len,
  84                               &chunk->off1, &chunk->len1,
  85                               &chunk->off2, &chunk->len2)) {
  86                 state->ret->num--;
  87                 return;
  88         }
  89
  90         if (chunk->len1 == 0)
  91                 chunk->off1++;
  92         if (chunk->len2 == 0)
  93                 chunk->off2++;
  94
  95         if (chunk->off1 > 0)
  96                 chunk->off1--;
  97         if (chunk->off2 > 0)
  98                 chunk->off2--;
  99
 100         assert(chunk->off1 >= 0);
 101         assert(chunk->off2 >= 0);
 102 }
 103
 104 static struct patch *get_patch(struct commit *commit, struct commit *other)
 105 {
 106         struct blame_diff_state state;
 107         xpparam_t xpp;
 108         xdemitconf_t xecfg;
 109         mmfile_t file_c, file_o;
 110         xdemitcb_t ecb;
 111         struct util_info *info_c = (struct util_info *)commit->object.util;
 112         struct util_info *info_o = (struct util_info *)other->object.util;
 113         struct timeval tv_start, tv_end;
 114
 115         get_blob(commit);
 116         file_c.ptr = info_c->buf;
 117         file_c.size = info_c->size;
 118
 119         get_blob(other);
 120         file_o.ptr = info_o->buf;
 121         file_o.size = info_o->size;
 122
 123         gettimeofday(&tv_start, NULL);
 124
 125         xpp.flags = XDF_NEED_MINIMAL;
 126         xecfg.ctxlen = 0;
 127         xecfg.flags = 0;
 128         ecb.outf = xdiff_outf;
 129         ecb.priv = &state;
 130         memset(&state, 0, sizeof(state));
 131         state.xm.consume = process_u0_diff;
 132         state.ret = xmalloc(sizeof(struct patch));
 133         state.ret->chunks = NULL;
 134         state.ret->num = 0;
 135
 136         xdl_diff(&file_c, &file_o, &xpp, &xecfg, &ecb);
 137
 138         gettimeofday(&tv_end, NULL);
 139         patch_time += 1000000 * (tv_end.tv_sec - tv_start.tv_sec) +
 140                 tv_end.tv_usec - tv_start.tv_usec;
 141
 142         num_get_patch++;
 143         return state.ret;
 144 }
 145
 146 static void free_patch(struct patch *p)
 147 {
 148         free(p->chunks);
 149         free(p);
 150 }
 151
 152 static int get_blob_sha1_internal(unsigned char *sha1, const char *base,
 153                                   int baselen, const char *pathname,
 154                                   unsigned mode, int stage);
 155
 156 static unsigned char blob_sha1[20];
 157 static const char* blame_file;
 158 static int get_blob_sha1(struct tree *t, const char *pathname,
 159                          unsigned char *sha1)
 160 {
 161         int i;
 162         const char *pathspec[2];
 163         blame_file = pathname;
 164         pathspec[0] = pathname;
 165         pathspec[1] = NULL;
 166         memset(blob_sha1, 0, sizeof(blob_sha1));
 167         read_tree_recursive(t, "", 0, 0, pathspec, get_blob_sha1_internal);
 168
 169         for (i = 0; i < 20; i++) {
 170                 if (blob_sha1[i] != 0)
 171                         break;
 172         }
 173
 174         if (i == 20)
 175                 return -1;
 176
 177         memcpy(sha1, blob_sha1, 20);
 178         return 0;
 179 }
 180
 181 static int get_blob_sha1_internal(unsigned char *sha1, const char *base,
 182                                   int baselen, const char *pathname,
 183                                   unsigned mode, int stage)
 184 {
 185         if (S_ISDIR(mode))
 186                 return READ_TREE_RECURSIVE;
 187
 188         if (strncmp(blame_file, base, baselen) ||
 189             strcmp(blame_file + baselen, pathname))
 190                 return -1;
 191
 192         memcpy(blob_sha1, sha1, 20);
 193         return -1;
 194 }
 195
 196 static void get_blob(struct commit *commit)
 197 {
 198         struct util_info *info = commit->object.util;
 199         char type[20];
 200
 201         if (info->buf)
 202                 return;
 203
 204         info->buf = read_sha1_file(info->sha1, type, &info->size);
 205
 206         assert(!strcmp(type, blob_type));
 207 }
 208
 209 /* For debugging only */
 210 static void print_patch(struct patch *p)
 211 {
 212         int i;
 213         printf("Num chunks: %d\n", p->num);
 214         for (i = 0; i < p->num; i++) {
 215                 printf("%d,%d %d,%d\n", p->chunks[i].off1, p->chunks[i].len1,
 216                        p->chunks[i].off2, p->chunks[i].len2);
 217         }
 218 }
 219
 220 #if DEBUG
 221 /* For debugging only */
 222 static void print_map(struct commit *cmit, struct commit *other)
 223 {
 224         struct util_info *util = cmit->object.util;
 225         struct util_info *util2 = other->object.util;
 226
 227         int i;
 228         int max =
 229             util->num_lines >
 230             util2->num_lines ? util->num_lines : util2->num_lines;
 231         int num;
 232
 233         for (i = 0; i < max; i++) {
 234                 printf("i: %d ", i);
 235                 num = -1;
 236
 237                 if (i < util->num_lines) {
 238                         num = util->line_map[i];
 239                         printf("%d\t", num);
 240                 } else
 241                         printf("\t");
 242
 243                 if (i < util2->num_lines) {
 244                         int num2 = util2->line_map[i];
 245                         printf("%d\t", num2);
 246                         if (num != -1 && num2 != num)
 247                                 printf("---");
 248                 } else
 249                         printf("\t");
 250
 251                 printf("\n");
 252         }
 253 }
 254 #endif
 255
 256 // p is a patch from commit to other.
 257 static void fill_line_map(struct commit *commit, struct commit *other,
 258                           struct patch *p)
 259 {
 260         struct util_info *util = commit->object.util;
 261         struct util_info *util2 = other->object.util;
 262         int *map = util->line_map;
 263         int *map2 = util2->line_map;
 264         int cur_chunk = 0;
 265         int i1, i2;
 266
 267         if (p->num && DEBUG)
 268                 print_patch(p);
 269
 270         if (DEBUG)
 271                 printf("num lines 1: %d num lines 2: %d\n", util->num_lines,
 272                        util2->num_lines);
 273
 274         for (i1 = 0, i2 = 0; i1 < util->num_lines; i1++, i2++) {
 275                 struct chunk *chunk = NULL;
 276                 if (cur_chunk < p->num)
 277                         chunk = &p->chunks[cur_chunk];
 278
 279                 if (chunk && chunk->off1 == i1) {
 280                         if (DEBUG && i2 != chunk->off2)
 281                                 printf("i2: %d off2: %d\n", i2, chunk->off2);
 282
 283                         assert(i2 == chunk->off2);
 284
 285                         i1--;
 286                         i2--;
 287                         if (chunk->len1 > 0)
 288                                 i1 += chunk->len1;
 289
 290                         if (chunk->len2 > 0)
 291                                 i2 += chunk->len2;
 292
 293                         cur_chunk++;
 294                 } else {
 295                         if (i2 >= util2->num_lines)
 296                                 break;
 297
 298                         if (map[i1] != map2[i2] && map[i1] != -1) {
 299                                 if (DEBUG)
 300                                         printf("map: i1: %d %d %p i2: %d %d %p\n",
 301                                                i1, map[i1],
 302                                                i1 != -1 ? blame_lines[map[i1]] : NULL,
 303                                                i2, map2[i2],
 304                                                i2 != -1 ? blame_lines[map2[i2]] : NULL);
 305                                 if (map2[i2] != -1 &&
 306                                     blame_lines[map[i1]] &&
 307                                     !blame_lines[map2[i2]])
 308                                         map[i1] = map2[i2];
 309                         }
 310
 311                         if (map[i1] == -1 && map2[i2] != -1)
 312                                 map[i1] = map2[i2];
 313                 }
 314
 315                 if (DEBUG > 1)
 316                         printf("l1: %d l2: %d i1: %d i2: %d\n",
 317                                map[i1], map2[i2], i1, i2);
 318         }
 319 }
 320
 321 static int map_line(struct commit *commit, int line)
 322 {
 323         struct util_info *info = commit->object.util;
 324         assert(line >= 0 && line < info->num_lines);
 325         return info->line_map[line];
 326 }
 327
 328 static struct util_info* get_util(struct commit *commit)
 329 {
 330         struct util_info *util = commit->object.util;
 331
 332         if (util)
 333                 return util;
 334
 335         util = xmalloc(sizeof(struct util_info));
 336         util->buf = NULL;
 337         util->size = 0;
 338         util->line_map = NULL;
 339         util->num_lines = -1;
 340         util->pathname = NULL;
 341         commit->object.util = util;
 342         return util;
 343 }
 344
 345 static int fill_util_info(struct commit *commit)
 346 {
 347         struct util_info *util = commit->object.util;
 348
 349         assert(util);
 350         assert(util->pathname);
 351
 352         if (get_blob_sha1(commit->tree, util->pathname, util->sha1))
 353                 return 1;
 354         else
 355                 return 0;
 356 }
 357
 358 static void alloc_line_map(struct commit *commit)
 359 {
 360         struct util_info *util = commit->object.util;
 361         int i;
 362
 363         if (util->line_map)
 364                 return;
 365
 366         get_blob(commit);
 367
 368         util->num_lines = 0;
 369         for (i = 0; i < util->size; i++) {
 370                 if (util->buf[i] == '\n')
 371                         util->num_lines++;
 372         }
 373         if(util->buf[util->size - 1] != '\n')
 374                 util->num_lines++;
 375
 376         util->line_map = xmalloc(sizeof(int) * util->num_lines);
 377
 378         for (i = 0; i < util->num_lines; i++)
 379                 util->line_map[i] = -1;
 380 }
 381
 382 static void init_first_commit(struct commit* commit, const char* filename)
 383 {
 384         struct util_info* util = commit->object.util;
 385         int i;
 386
 387         util->pathname = filename;
 388         if (fill_util_info(commit))
 389                 die("fill_util_info failed");
 390
 391         alloc_line_map(commit);
 392
 393         util = commit->object.util;
 394
 395         for (i = 0; i < util->num_lines; i++)
 396                 util->line_map[i] = i;
 397 }
 398
 399
 400 static void process_commits(struct rev_info *rev, const char *path,
 401                             struct commit** initial)
 402 {
 403         int i;
 404         struct util_info* util;
 405         int lines_left;
 406         int *blame_p;
 407         int *new_lines;
 408         int new_lines_len;
 409
 410         struct commit* commit = get_revision(rev);
 411         assert(commit);
 412         init_first_commit(commit, path);
 413
 414         util = commit->object.util;
 415         num_blame_lines = util->num_lines;
 416         blame_lines = xmalloc(sizeof(struct commit *) * num_blame_lines);
 417         blame_contents = util->buf;
 418         blame_len = util->size;
 419
 420         for (i = 0; i < num_blame_lines; i++)
 421                 blame_lines[i] = NULL;
 422
 423         lines_left = num_blame_lines;
 424         blame_p = xmalloc(sizeof(int) * num_blame_lines);
 425         new_lines = xmalloc(sizeof(int) * num_blame_lines);
 426         do {
 427                 struct commit_list *parents;
 428                 int num_parents;
 429                 struct util_info *util;
 430
 431                 if (DEBUG)
 432                         printf("\nProcessing commit: %d %s\n", num_commits,
 433                                sha1_to_hex(commit->object.sha1));
 434
 435                 if (lines_left == 0)
 436                         return;
 437
 438                 num_commits++;
 439                 memset(blame_p, 0, sizeof(int) * num_blame_lines);
 440                 new_lines_len = 0;
 441                 num_parents = 0;
 442                 for (parents = commit->parents;
 443                      parents != NULL; parents = parents->next)
 444                         num_parents++;
 445
 446                 if(num_parents == 0)
 447                         *initial = commit;
 448
 449                 if (fill_util_info(commit))
 450                         continue;
 451
 452                 alloc_line_map(commit);
 453                 util = commit->object.util;
 454
 455                 for (parents = commit->parents;
 456                      parents != NULL; parents = parents->next) {
 457                         struct commit *parent = parents->item;
 458                         struct patch *patch;
 459
 460                         if (parse_commit(parent) < 0)
 461                                 die("parse_commit error");
 462
 463                         if (DEBUG)
 464                                 printf("parent: %s\n",
 465                                        sha1_to_hex(parent->object.sha1));
 466
 467                         if (fill_util_info(parent)) {
 468                                 num_parents--;
 469                                 continue;
 470                         }
 471
 472                         patch = get_patch(parent, commit);
 473                         alloc_line_map(parent);
 474                         fill_line_map(parent, commit, patch);
 475
 476                         for (i = 0; i < patch->num; i++) {
 477                             int l;
 478                             for (l = 0; l < patch->chunks[i].len2; l++) {
 479                                 int mapped_line =
 480                                     map_line(commit, patch->chunks[i].off2 + l);
 481                                 if (mapped_line != -1) {
 482                                     blame_p[mapped_line]++;
 483                                     if (blame_p[mapped_line] == num_parents)
 484                                         new_lines[new_lines_len++] = mapped_line;
 485                                 }
 486                             }
 487                         }
 488                         free_patch(patch);
 489                 }
 490
 491                 if (DEBUG)
 492                         printf("parents: %d\n", num_parents);
 493
 494                 for (i = 0; i < new_lines_len; i++) {
 495                         int mapped_line = new_lines[i];
 496                         if (blame_lines[mapped_line] == NULL) {
 497                                 blame_lines[mapped_line] = commit;
 498                                 lines_left--;
 499                                 if (DEBUG)
 500                                         printf("blame: mapped: %d i: %d\n",
 501                                                mapped_line, i);
 502                         }
 503                 }
 504         } while ((commit = get_revision(rev)) != NULL);
 505 }
 506
 507
 508 static int compare_tree_path(struct rev_info* revs,
 509                              struct commit* c1, struct commit* c2)
 510 {
 511         int ret;
 512         const char* paths[2];
 513         struct util_info* util = c2->object.util;
 514         paths[0] = util->pathname;
 515         paths[1] = NULL;
 516
 517         diff_tree_setup_paths(get_pathspec(revs->prefix, paths),
 518                               &revs->diffopt);
 519         ret = rev_compare_tree(revs, c1->tree, c2->tree);
 520         diff_tree_release_paths(&revs->diffopt);
 521         return ret;
 522 }
 523
 524
 525 static int same_tree_as_empty_path(struct rev_info *revs, struct tree* t1,
 526                                    const char* path)
 527 {
 528         int ret;
 529         const char* paths[2];
 530         paths[0] = path;
 531         paths[1] = NULL;
 532
 533         diff_tree_setup_paths(get_pathspec(revs->prefix, paths),
 534                               &revs->diffopt);
 535         ret = rev_same_tree_as_empty(revs, t1);
 536         diff_tree_release_paths(&revs->diffopt);
 537         return ret;
 538 }
 539
 540 static const char* find_rename(struct commit* commit, struct commit* parent)
 541 {
 542         struct util_info* cutil = commit->object.util;
 543         struct diff_options diff_opts;
 544         const char *paths[1];
 545         int i;
 546
 547         if (DEBUG) {
 548                 printf("find_rename commit: %s ",
 549                        sha1_to_hex(commit->object.sha1));
 550                 puts(sha1_to_hex(parent->object.sha1));
 551         }
 552
 553         diff_setup(&diff_opts);
 554         diff_opts.recursive = 1;
 555         diff_opts.detect_rename = DIFF_DETECT_RENAME;
 556         paths[0] = NULL;
 557         diff_tree_setup_paths(paths, &diff_opts);
 558         if (diff_setup_done(&diff_opts) < 0)
 559                 die("diff_setup_done failed");
 560
 561         diff_tree_sha1(commit->tree->object.sha1, parent->tree->object.sha1,
 562                        "", &diff_opts);
 563         diffcore_std(&diff_opts);
 564
 565         for (i = 0; i < diff_queued_diff.nr; i++) {
 566                 struct diff_filepair *p = diff_queued_diff.queue[i];
 567
 568                 if (p->status == 'R' && !strcmp(p->one->path, cutil->pathname)) {
 569                         if (DEBUG)
 570                                 printf("rename %s -> %s\n", p->one->path, p->two->path);
 571                         return p->two->path;
 572                 }
 573         }
 574
 575         return 0;
 576 }
 577
 578 static void simplify_commit(struct rev_info *revs, struct commit *commit)
 579 {
 580         struct commit_list **pp, *parent;
 581
 582         if (!commit->tree)
 583                 return;
 584
 585         if (!commit->parents) {
 586                 struct util_info* util = commit->object.util;
 587                 if (!same_tree_as_empty_path(revs, commit->tree,
 588                                              util->pathname))
 589                         commit->object.flags |= TREECHANGE;
 590                 return;
 591         }
 592
 593         pp = &commit->parents;
 594         while ((parent = *pp) != NULL) {
 595                 struct commit *p = parent->item;
 596
 597                 if (p->object.flags & UNINTERESTING) {
 598                         pp = &parent->next;
 599                         continue;
 600                 }
 601
 602                 parse_commit(p);
 603                 switch (compare_tree_path(revs, p, commit)) {
 604                 case REV_TREE_SAME:
 605                         parent->next = NULL;
 606                         commit->parents = parent;
 607                         get_util(p)->pathname = get_util(commit)->pathname;
 608                         return;
 609
 610                 case REV_TREE_NEW:
 611                 {
 612
 613                         struct util_info* util = commit->object.util;
 614                         if (revs->remove_empty_trees &&
 615                             same_tree_as_empty_path(revs, p->tree,
 616                                                     util->pathname)) {
 617                                 const char* new_name = find_rename(commit, p);
 618                                 if (new_name) {
 619                                         struct util_info* putil = get_util(p);
 620                                         if (!putil->pathname)
 621                                                 putil->pathname = strdup(new_name);
 622                                 } else {
 623                                         *pp = parent->next;
 624                                         continue;
 625                                 }
 626                         }
 627                 }
 628
 629                 /* fallthrough */
 630                 case REV_TREE_DIFFERENT:
 631                         pp = &parent->next;
 632                         if (!get_util(p)->pathname)
 633                                 get_util(p)->pathname =
 634                                         get_util(commit)->pathname;
 635                         continue;
 636                 }
 637                 die("bad tree compare for commit %s",
 638                     sha1_to_hex(commit->object.sha1));
 639         }
 640         commit->object.flags |= TREECHANGE;
 641 }
 642
 643
 644 struct commit_info
 645 {
 646         char* author;
 647         char* author_mail;
 648         unsigned long author_time;
 649         char* author_tz;
 650 };
 651
 652 static void get_commit_info(struct commit* commit, struct commit_info* ret)
 653 {
 654         int len;
 655         char* tmp;
 656         static char author_buf[1024];
 657
 658         tmp = strstr(commit->buffer, "\nauthor ") + 8;
 659         len = strchr(tmp, '\n') - tmp;
 660         ret->author = author_buf;
 661         memcpy(ret->author, tmp, len);
 662
 663         tmp = ret->author;
 664         tmp += len;
 665         *tmp = 0;
 666         while(*tmp != ' ')
 667                 tmp--;
 668         ret->author_tz = tmp+1;
 669
 670         *tmp = 0;
 671         while(*tmp != ' ')
 672                 tmp--;
 673         ret->author_time = strtoul(tmp, NULL, 10);
 674
 675         *tmp = 0;
 676         while(*tmp != ' ')
 677                 tmp--;
 678         ret->author_mail = tmp + 1;
 679
 680         *tmp = 0;
 681 }
 682
 683 static const char* format_time(unsigned long time, const char* tz_str)
 684 {
 685         static char time_buf[128];
 686         time_t t = time;
 687         int minutes, tz;
 688         struct tm *tm;
 689
 690         tz = atoi(tz_str);
 691         minutes = tz < 0 ? -tz : tz;
 692         minutes = (minutes / 100)*60 + (minutes % 100);
 693         minutes = tz < 0 ? -minutes : minutes;
 694         t = time + minutes * 60;
 695         tm = gmtime(&t);
 696
 697         strftime(time_buf, sizeof(time_buf), "%Y-%m-%d %H:%M:%S ", tm);
 698         strcat(time_buf, tz_str);
 699         return time_buf;
 700 }
 701
 702 static void topo_setter(struct commit* c, void* data)
 703 {
 704         struct util_info* util = c->object.util;
 705         util->topo_data = data;
 706 }
 707
 708 static void* topo_getter(struct commit* c)
 709 {
 710         struct util_info* util = c->object.util;
 711         return util->topo_data;
 712 }
 713
 714 static int read_ancestry(const char *graft_file,
 715                          unsigned char **start_sha1)
 716 {
 717         FILE *fp = fopen(graft_file, "r");
 718         char buf[1024];
 719         if (!fp)
 720                 return -1;
 721         while (fgets(buf, sizeof(buf), fp)) {
 722                 /* The format is just "Commit Parent1 Parent2 ...\n" */
 723                 int len = strlen(buf);
 724                 struct commit_graft *graft = read_graft_line(buf, len);
 725                 register_commit_graft(graft, 0);
 726                 if (!*start_sha1)
 727                         *start_sha1 = graft->sha1;
 728         }
 729         fclose(fp);
 730         return 0;
 731 }
 732
 733 int main(int argc, const char **argv)
 734 {
 735         int i;
 736         struct commit *initial = NULL;
 737         unsigned char sha1[20], *sha1_p = NULL;
 738
 739         const char *filename = NULL, *commit = NULL;
 740         char filename_buf[256];
 741         int sha1_len = 8;
 742         int compability = 0;
 743         int options = 1;
 744         struct commit* start_commit;
 745
 746         const char* args[10];
 747         struct rev_info rev;
 748
 749         struct commit_info ci;
 750         const char *buf;
 751         int max_digits;
 752         int longest_file, longest_author;
 753         int found_rename;
 754
 755         const char* prefix = setup_git_directory();
 756         git_config(git_default_config);
 757
 758         for(i = 1; i < argc; i++) {
 759                 if(options) {
 760                         if(!strcmp(argv[i], "-h") ||
 761                            !strcmp(argv[i], "--help"))
 762                                 usage(blame_usage);
 763                         else if(!strcmp(argv[i], "-l") ||
 764                                 !strcmp(argv[i], "--long")) {
 765                                 sha1_len = 40;
 766                                 continue;
 767                         } else if(!strcmp(argv[i], "-c") ||
 768                                   !strcmp(argv[i], "--compability")) {
 769                                 compability = 1;
 770                                 continue;
 771                         } else if(!strcmp(argv[i], "-S")) {
 772                                 if (i + 1 < argc &&
 773                                     !read_ancestry(argv[i + 1], &sha1_p)) {
 774                                         compability = 1;
 775                                         i++;
 776                                         continue;
 777                                 }
 778                                 usage(blame_usage);
 779                         } else if(!strcmp(argv[i], "--")) {
 780                                 options = 0;
 781                                 continue;
 782                         } else if(argv[i][0] == '-')
 783                                 usage(blame_usage);
 784                         else
 785                                 options = 0;
 786                 }
 787
 788                 if(!options) {
 789                         if(!filename)
 790                                 filename = argv[i];
 791                         else if(!commit)
 792                                 commit = argv[i];
 793                         else
 794                                 usage(blame_usage);
 795                 }
 796         }
 797
 798         if(!filename)
 799                 usage(blame_usage);
 800         if (commit && sha1_p)
 801                 usage(blame_usage);
 802         else if(!commit)
 803                 commit = "HEAD";
 804
 805         if(prefix)
 806                 sprintf(filename_buf, "%s%s", prefix, filename);
 807         else
 808                 strcpy(filename_buf, filename);
 809         filename = filename_buf;
 810
 811         if (!sha1_p) {
 812                 if (get_sha1(commit, sha1))
 813                         die("get_sha1 failed, commit '%s' not found", commit);
 814                 sha1_p = sha1;
 815         }
 816         start_commit = lookup_commit_reference(sha1_p);
 817         get_util(start_commit)->pathname = filename;
 818         if (fill_util_info(start_commit)) {
 819                 printf("%s not found in %s\n", filename, commit);
 820                 return 1;
 821         }
 822
 823
 824         init_revisions(&rev);
 825         rev.remove_empty_trees = 1;
 826         rev.topo_order = 1;
 827         rev.prune_fn = simplify_commit;
 828         rev.topo_setter = topo_setter;
 829         rev.topo_getter = topo_getter;
 830         rev.parents = 1;
 831         rev.limited = 1;
 832
 833         commit_list_insert(start_commit, &rev.commits);
 834
 835         args[0] = filename;
 836         args[1] = NULL;
 837         diff_tree_setup_paths(args, &rev.diffopt);
 838         prepare_revision_walk(&rev);
 839         process_commits(&rev, filename, &initial);
 840
 841         buf = blame_contents;
 842         for (max_digits = 1, i = 10; i <= num_blame_lines + 1; max_digits++)
 843                 i *= 10;
 844
 845         longest_file = 0;
 846         longest_author = 0;
 847         found_rename = 0;
 848         for (i = 0; i < num_blame_lines; i++) {
 849                 struct commit *c = blame_lines[i];
 850                 struct util_info* u;
 851                 if (!c)
 852                         c = initial;
 853                 u = c->object.util;
 854
 855                 if (!found_rename && strcmp(filename, u->pathname))
 856                         found_rename = 1;
 857                 if (longest_file < strlen(u->pathname))
 858                         longest_file = strlen(u->pathname);
 859                 get_commit_info(c, &ci);
 860                 if (longest_author < strlen(ci.author))
 861                         longest_author = strlen(ci.author);
 862         }
 863
 864         for (i = 0; i < num_blame_lines; i++) {
 865                 struct commit *c = blame_lines[i];
 866                 struct util_info* u;
 867
 868                 if (!c)
 869                         c = initial;
 870
 871                 u = c->object.util;
 872                 get_commit_info(c, &ci);
 873                 fwrite(sha1_to_hex(c->object.sha1), sha1_len, 1, stdout);
 874                 if(compability) {
 875                         printf("\t(%10s\t%10s\t%d)", ci.author,
 876                                format_time(ci.author_time, ci.author_tz), i+1);
 877                 } else {
 878                         if (found_rename)
 879                                 printf(" %-*.*s", longest_file, longest_file,
 880                                        u->pathname);
 881                         printf(" (%-*.*s %10s %*d) ",
 882                                longest_author, longest_author, ci.author,
 883                                format_time(ci.author_time, ci.author_tz),
 884                                max_digits, i+1);
 885                 }
 886
 887                 if(i == num_blame_lines - 1) {
 888                         fwrite(buf, blame_len - (buf - blame_contents),
 889                                1, stdout);
 890                         if(blame_contents[blame_len-1] != '\n')
 891                                 putc('\n', stdout);
 892                 } else {
 893                         char* next_buf = strchr(buf, '\n') + 1;
 894                         fwrite(buf, next_buf - buf, 1, stdout);
 895                         buf = next_buf;
 896                 }
 897         }
 898
 899         if (DEBUG) {
 900                 printf("num get patch: %d\n", num_get_patch);
 901                 printf("num commits: %d\n", num_commits);
 902                 printf("patch time: %f\n", patch_time / 1000000.0);
 903                 printf("initial: %s\n", sha1_to_hex(initial->object.sha1));
 904         }
 905
 906         return 0;
 907 }