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