1/* 2 * Pickaxe 3 * 4 * Copyright (c) 2006, Junio C Hamano 5 */ 6 7#include"cache.h" 8#include"builtin.h" 9#include"blob.h" 10#include"commit.h" 11#include"tag.h" 12#include"tree-walk.h" 13#include"diff.h" 14#include"diffcore.h" 15#include"revision.h" 16#include"quote.h" 17#include"xdiff-interface.h" 18#include"cache-tree.h" 19#include"path-list.h" 20#include"mailmap.h" 21 22static char blame_usage[] = 23"git-blame [-c] [-b] [-l] [--root] [-t] [-f] [-n] [-s] [-p] [-w] [-L n,m] [-S <revs-file>] [-M] [-C] [-C] [--contents <filename>] [--incremental] [commit] [--] file\n" 24" -c Use the same output mode as git-annotate (Default: off)\n" 25" -b Show blank SHA-1 for boundary commits (Default: off)\n" 26" -l Show long commit SHA1 (Default: off)\n" 27" --root Do not treat root commits as boundaries (Default: off)\n" 28" -t Show raw timestamp (Default: off)\n" 29" -f, --show-name Show original filename (Default: auto)\n" 30" -n, --show-number Show original linenumber (Default: off)\n" 31" -s Suppress author name and timestamp (Default: off)\n" 32" -p, --porcelain Show in a format designed for machine consumption\n" 33" -w Ignore whitespace differences\n" 34" -L n,m Process only line range n,m, counting from 1\n" 35" -M, -C Find line movements within and across files\n" 36" --incremental Show blame entries as we find them, incrementally\n" 37" --contents file Use <file>'s contents as the final image\n" 38" -S revs-file Use revisions from revs-file instead of calling git-rev-list\n"; 39 40static int longest_file; 41static int longest_author; 42static int max_orig_digits; 43static int max_digits; 44static int max_score_digits; 45static int show_root; 46static int blank_boundary; 47static int incremental; 48static int cmd_is_annotate; 49static int xdl_opts = XDF_NEED_MINIMAL; 50static struct path_list mailmap; 51 52#ifndef DEBUG 53#define DEBUG 0 54#endif 55 56/* stats */ 57static int num_read_blob; 58static int num_get_patch; 59static int num_commits; 60 61#define PICKAXE_BLAME_MOVE 01 62#define PICKAXE_BLAME_COPY 02 63#define PICKAXE_BLAME_COPY_HARDER 04 64#define PICKAXE_BLAME_COPY_HARDEST 010 65 66/* 67 * blame for a blame_entry with score lower than these thresholds 68 * is not passed to the parent using move/copy logic. 69 */ 70static unsigned blame_move_score; 71static unsigned blame_copy_score; 72#define BLAME_DEFAULT_MOVE_SCORE 20 73#define BLAME_DEFAULT_COPY_SCORE 40 74 75/* bits #0..7 in revision.h, #8..11 used for merge_bases() in commit.c */ 76#define METAINFO_SHOWN (1u<<12) 77#define MORE_THAN_ONE_PATH (1u<<13) 78 79/* 80 * One blob in a commit that is being suspected 81 */ 82struct origin { 83int refcnt; 84struct commit *commit; 85 mmfile_t file; 86unsigned char blob_sha1[20]; 87char path[FLEX_ARRAY]; 88}; 89 90/* 91 * Given an origin, prepare mmfile_t structure to be used by the 92 * diff machinery 93 */ 94static voidfill_origin_blob(struct origin *o, mmfile_t *file) 95{ 96if(!o->file.ptr) { 97enum object_type type; 98 num_read_blob++; 99 file->ptr =read_sha1_file(o->blob_sha1, &type, 100(unsigned long*)(&(file->size))); 101if(!file->ptr) 102die("Cannot read blob%sfor path%s", 103sha1_to_hex(o->blob_sha1), 104 o->path); 105 o->file = *file; 106} 107else 108*file = o->file; 109} 110 111/* 112 * Origin is refcounted and usually we keep the blob contents to be 113 * reused. 114 */ 115staticinlinestruct origin *origin_incref(struct origin *o) 116{ 117if(o) 118 o->refcnt++; 119return o; 120} 121 122static voidorigin_decref(struct origin *o) 123{ 124if(o && --o->refcnt <=0) { 125free(o->file.ptr); 126free(o); 127} 128} 129 130static voiddrop_origin_blob(struct origin *o) 131{ 132if(o->file.ptr) { 133free(o->file.ptr); 134 o->file.ptr = NULL; 135} 136} 137 138/* 139 * Each group of lines is described by a blame_entry; it can be split 140 * as we pass blame to the parents. They form a linked list in the 141 * scoreboard structure, sorted by the target line number. 142 */ 143struct blame_entry { 144struct blame_entry *prev; 145struct blame_entry *next; 146 147/* the first line of this group in the final image; 148 * internally all line numbers are 0 based. 149 */ 150int lno; 151 152/* how many lines this group has */ 153int num_lines; 154 155/* the commit that introduced this group into the final image */ 156struct origin *suspect; 157 158/* true if the suspect is truly guilty; false while we have not 159 * checked if the group came from one of its parents. 160 */ 161char guilty; 162 163/* the line number of the first line of this group in the 164 * suspect's file; internally all line numbers are 0 based. 165 */ 166int s_lno; 167 168/* how significant this entry is -- cached to avoid 169 * scanning the lines over and over. 170 */ 171unsigned score; 172}; 173 174/* 175 * The current state of the blame assignment. 176 */ 177struct scoreboard { 178/* the final commit (i.e. where we started digging from) */ 179struct commit *final; 180 181const char*path; 182 183/* 184 * The contents in the final image. 185 * Used by many functions to obtain contents of the nth line, 186 * indexed with scoreboard.lineno[blame_entry.lno]. 187 */ 188const char*final_buf; 189unsigned long final_buf_size; 190 191/* linked list of blames */ 192struct blame_entry *ent; 193 194/* look-up a line in the final buffer */ 195int num_lines; 196int*lineno; 197}; 198 199staticinlineintsame_suspect(struct origin *a,struct origin *b) 200{ 201if(a == b) 202return1; 203if(a->commit != b->commit) 204return0; 205return!strcmp(a->path, b->path); 206} 207 208static voidsanity_check_refcnt(struct scoreboard *); 209 210/* 211 * If two blame entries that are next to each other came from 212 * contiguous lines in the same origin (i.e. <commit, path> pair), 213 * merge them together. 214 */ 215static voidcoalesce(struct scoreboard *sb) 216{ 217struct blame_entry *ent, *next; 218 219for(ent = sb->ent; ent && (next = ent->next); ent = next) { 220if(same_suspect(ent->suspect, next->suspect) && 221 ent->guilty == next->guilty && 222 ent->s_lno + ent->num_lines == next->s_lno) { 223 ent->num_lines += next->num_lines; 224 ent->next = next->next; 225if(ent->next) 226 ent->next->prev = ent; 227origin_decref(next->suspect); 228free(next); 229 ent->score =0; 230 next = ent;/* again */ 231} 232} 233 234if(DEBUG)/* sanity */ 235sanity_check_refcnt(sb); 236} 237 238/* 239 * Given a commit and a path in it, create a new origin structure. 240 * The callers that add blame to the scoreboard should use 241 * get_origin() to obtain shared, refcounted copy instead of calling 242 * this function directly. 243 */ 244static struct origin *make_origin(struct commit *commit,const char*path) 245{ 246struct origin *o; 247 o =xcalloc(1,sizeof(*o) +strlen(path) +1); 248 o->commit = commit; 249 o->refcnt =1; 250strcpy(o->path, path); 251return o; 252} 253 254/* 255 * Locate an existing origin or create a new one. 256 */ 257static struct origin *get_origin(struct scoreboard *sb, 258struct commit *commit, 259const char*path) 260{ 261struct blame_entry *e; 262 263for(e = sb->ent; e; e = e->next) { 264if(e->suspect->commit == commit && 265!strcmp(e->suspect->path, path)) 266returnorigin_incref(e->suspect); 267} 268returnmake_origin(commit, path); 269} 270 271/* 272 * Fill the blob_sha1 field of an origin if it hasn't, so that later 273 * call to fill_origin_blob() can use it to locate the data. blob_sha1 274 * for an origin is also used to pass the blame for the entire file to 275 * the parent to detect the case where a child's blob is identical to 276 * that of its parent's. 277 */ 278static intfill_blob_sha1(struct origin *origin) 279{ 280unsigned mode; 281 282if(!is_null_sha1(origin->blob_sha1)) 283return0; 284if(get_tree_entry(origin->commit->object.sha1, 285 origin->path, 286 origin->blob_sha1, &mode)) 287goto error_out; 288if(sha1_object_info(origin->blob_sha1, NULL) != OBJ_BLOB) 289goto error_out; 290return0; 291 error_out: 292hashclr(origin->blob_sha1); 293return-1; 294} 295 296/* 297 * We have an origin -- check if the same path exists in the 298 * parent and return an origin structure to represent it. 299 */ 300static struct origin *find_origin(struct scoreboard *sb, 301struct commit *parent, 302struct origin *origin) 303{ 304struct origin *porigin = NULL; 305struct diff_options diff_opts; 306const char*paths[2]; 307 308if(parent->util) { 309/* 310 * Each commit object can cache one origin in that 311 * commit. This is a freestanding copy of origin and 312 * not refcounted. 313 */ 314struct origin *cached = parent->util; 315if(!strcmp(cached->path, origin->path)) { 316/* 317 * The same path between origin and its parent 318 * without renaming -- the most common case. 319 */ 320 porigin =get_origin(sb, parent, cached->path); 321 322/* 323 * If the origin was newly created (i.e. get_origin 324 * would call make_origin if none is found in the 325 * scoreboard), it does not know the blob_sha1, 326 * so copy it. Otherwise porigin was in the 327 * scoreboard and already knows blob_sha1. 328 */ 329if(porigin->refcnt ==1) 330hashcpy(porigin->blob_sha1, cached->blob_sha1); 331return porigin; 332} 333/* otherwise it was not very useful; free it */ 334free(parent->util); 335 parent->util = NULL; 336} 337 338/* See if the origin->path is different between parent 339 * and origin first. Most of the time they are the 340 * same and diff-tree is fairly efficient about this. 341 */ 342diff_setup(&diff_opts); 343DIFF_OPT_SET(&diff_opts, RECURSIVE); 344 diff_opts.detect_rename =0; 345 diff_opts.output_format = DIFF_FORMAT_NO_OUTPUT; 346 paths[0] = origin->path; 347 paths[1] = NULL; 348 349diff_tree_setup_paths(paths, &diff_opts); 350if(diff_setup_done(&diff_opts) <0) 351die("diff-setup"); 352 353if(is_null_sha1(origin->commit->object.sha1)) 354do_diff_cache(parent->tree->object.sha1, &diff_opts); 355else 356diff_tree_sha1(parent->tree->object.sha1, 357 origin->commit->tree->object.sha1, 358"", &diff_opts); 359diffcore_std(&diff_opts); 360 361/* It is either one entry that says "modified", or "created", 362 * or nothing. 363 */ 364if(!diff_queued_diff.nr) { 365/* The path is the same as parent */ 366 porigin =get_origin(sb, parent, origin->path); 367hashcpy(porigin->blob_sha1, origin->blob_sha1); 368} 369else if(diff_queued_diff.nr !=1) 370die("internal error in blame::find_origin"); 371else{ 372struct diff_filepair *p = diff_queued_diff.queue[0]; 373switch(p->status) { 374default: 375die("internal error in blame::find_origin (%c)", 376 p->status); 377case'M': 378 porigin =get_origin(sb, parent, origin->path); 379hashcpy(porigin->blob_sha1, p->one->sha1); 380break; 381case'A': 382case'T': 383/* Did not exist in parent, or type changed */ 384break; 385} 386} 387diff_flush(&diff_opts); 388diff_tree_release_paths(&diff_opts); 389if(porigin) { 390/* 391 * Create a freestanding copy that is not part of 392 * the refcounted origin found in the scoreboard, and 393 * cache it in the commit. 394 */ 395struct origin *cached; 396 397 cached =make_origin(porigin->commit, porigin->path); 398hashcpy(cached->blob_sha1, porigin->blob_sha1); 399 parent->util = cached; 400} 401return porigin; 402} 403 404/* 405 * We have an origin -- find the path that corresponds to it in its 406 * parent and return an origin structure to represent it. 407 */ 408static struct origin *find_rename(struct scoreboard *sb, 409struct commit *parent, 410struct origin *origin) 411{ 412struct origin *porigin = NULL; 413struct diff_options diff_opts; 414int i; 415const char*paths[2]; 416 417diff_setup(&diff_opts); 418DIFF_OPT_SET(&diff_opts, RECURSIVE); 419 diff_opts.detect_rename = DIFF_DETECT_RENAME; 420 diff_opts.output_format = DIFF_FORMAT_NO_OUTPUT; 421 diff_opts.single_follow = origin->path; 422 paths[0] = NULL; 423diff_tree_setup_paths(paths, &diff_opts); 424if(diff_setup_done(&diff_opts) <0) 425die("diff-setup"); 426 427if(is_null_sha1(origin->commit->object.sha1)) 428do_diff_cache(parent->tree->object.sha1, &diff_opts); 429else 430diff_tree_sha1(parent->tree->object.sha1, 431 origin->commit->tree->object.sha1, 432"", &diff_opts); 433diffcore_std(&diff_opts); 434 435for(i =0; i < diff_queued_diff.nr; i++) { 436struct diff_filepair *p = diff_queued_diff.queue[i]; 437if((p->status =='R'|| p->status =='C') && 438!strcmp(p->two->path, origin->path)) { 439 porigin =get_origin(sb, parent, p->one->path); 440hashcpy(porigin->blob_sha1, p->one->sha1); 441break; 442} 443} 444diff_flush(&diff_opts); 445diff_tree_release_paths(&diff_opts); 446return porigin; 447} 448 449/* 450 * Parsing of patch chunks... 451 */ 452struct chunk { 453/* line number in postimage; up to but not including this 454 * line is the same as preimage 455 */ 456int same; 457 458/* preimage line number after this chunk */ 459int p_next; 460 461/* postimage line number after this chunk */ 462int t_next; 463}; 464 465struct patch { 466struct chunk *chunks; 467int num; 468}; 469 470struct blame_diff_state { 471struct xdiff_emit_state xm; 472struct patch *ret; 473unsigned hunk_post_context; 474unsigned hunk_in_pre_context :1; 475}; 476 477static voidprocess_u_diff(void*state_,char*line,unsigned long len) 478{ 479struct blame_diff_state *state = state_; 480struct chunk *chunk; 481int off1, off2, len1, len2, num; 482 483 num = state->ret->num; 484if(len <4|| line[0] !='@'|| line[1] !='@') { 485if(state->hunk_in_pre_context && line[0] ==' ') 486 state->ret->chunks[num -1].same++; 487else{ 488 state->hunk_in_pre_context =0; 489if(line[0] ==' ') 490 state->hunk_post_context++; 491else 492 state->hunk_post_context =0; 493} 494return; 495} 496 497if(num && state->hunk_post_context) { 498 chunk = &state->ret->chunks[num -1]; 499 chunk->p_next -= state->hunk_post_context; 500 chunk->t_next -= state->hunk_post_context; 501} 502 state->ret->num = ++num; 503 state->ret->chunks =xrealloc(state->ret->chunks, 504sizeof(struct chunk) * num); 505 chunk = &state->ret->chunks[num -1]; 506if(parse_hunk_header(line, len, &off1, &len1, &off2, &len2)) { 507 state->ret->num--; 508return; 509} 510 511/* Line numbers in patch output are one based. */ 512 off1--; 513 off2--; 514 515 chunk->same = len2 ? off2 : (off2 +1); 516 517 chunk->p_next = off1 + (len1 ? len1 :1); 518 chunk->t_next = chunk->same + len2; 519 state->hunk_in_pre_context =1; 520 state->hunk_post_context =0; 521} 522 523static struct patch *compare_buffer(mmfile_t *file_p, mmfile_t *file_o, 524int context) 525{ 526struct blame_diff_state state; 527 xpparam_t xpp; 528 xdemitconf_t xecfg; 529 xdemitcb_t ecb; 530 531 xpp.flags = xdl_opts; 532memset(&xecfg,0,sizeof(xecfg)); 533 xecfg.ctxlen = context; 534 ecb.outf = xdiff_outf; 535 ecb.priv = &state; 536memset(&state,0,sizeof(state)); 537 state.xm.consume = process_u_diff; 538 state.ret =xmalloc(sizeof(struct patch)); 539 state.ret->chunks = NULL; 540 state.ret->num =0; 541 542xdi_diff(file_p, file_o, &xpp, &xecfg, &ecb); 543 544if(state.ret->num) { 545struct chunk *chunk; 546 chunk = &state.ret->chunks[state.ret->num -1]; 547 chunk->p_next -= state.hunk_post_context; 548 chunk->t_next -= state.hunk_post_context; 549} 550return state.ret; 551} 552 553/* 554 * Run diff between two origins and grab the patch output, so that 555 * we can pass blame for lines origin is currently suspected for 556 * to its parent. 557 */ 558static struct patch *get_patch(struct origin *parent,struct origin *origin) 559{ 560 mmfile_t file_p, file_o; 561struct patch *patch; 562 563fill_origin_blob(parent, &file_p); 564fill_origin_blob(origin, &file_o); 565if(!file_p.ptr || !file_o.ptr) 566return NULL; 567 patch =compare_buffer(&file_p, &file_o,0); 568 num_get_patch++; 569return patch; 570} 571 572static voidfree_patch(struct patch *p) 573{ 574free(p->chunks); 575free(p); 576} 577 578/* 579 * Link in a new blame entry to the scoreboard. Entries that cover the 580 * same line range have been removed from the scoreboard previously. 581 */ 582static voidadd_blame_entry(struct scoreboard *sb,struct blame_entry *e) 583{ 584struct blame_entry *ent, *prev = NULL; 585 586origin_incref(e->suspect); 587 588for(ent = sb->ent; ent && ent->lno < e->lno; ent = ent->next) 589 prev = ent; 590 591/* prev, if not NULL, is the last one that is below e */ 592 e->prev = prev; 593if(prev) { 594 e->next = prev->next; 595 prev->next = e; 596} 597else{ 598 e->next = sb->ent; 599 sb->ent = e; 600} 601if(e->next) 602 e->next->prev = e; 603} 604 605/* 606 * src typically is on-stack; we want to copy the information in it to 607 * a malloced blame_entry that is already on the linked list of the 608 * scoreboard. The origin of dst loses a refcnt while the origin of src 609 * gains one. 610 */ 611static voiddup_entry(struct blame_entry *dst,struct blame_entry *src) 612{ 613struct blame_entry *p, *n; 614 615 p = dst->prev; 616 n = dst->next; 617origin_incref(src->suspect); 618origin_decref(dst->suspect); 619memcpy(dst, src,sizeof(*src)); 620 dst->prev = p; 621 dst->next = n; 622 dst->score =0; 623} 624 625static const char*nth_line(struct scoreboard *sb,int lno) 626{ 627return sb->final_buf + sb->lineno[lno]; 628} 629 630/* 631 * It is known that lines between tlno to same came from parent, and e 632 * has an overlap with that range. it also is known that parent's 633 * line plno corresponds to e's line tlno. 634 * 635 * <---- e -----> 636 * <------> 637 * <------------> 638 * <------------> 639 * <------------------> 640 * 641 * Split e into potentially three parts; before this chunk, the chunk 642 * to be blamed for the parent, and after that portion. 643 */ 644static voidsplit_overlap(struct blame_entry *split, 645struct blame_entry *e, 646int tlno,int plno,int same, 647struct origin *parent) 648{ 649int chunk_end_lno; 650memset(split,0,sizeof(struct blame_entry [3])); 651 652if(e->s_lno < tlno) { 653/* there is a pre-chunk part not blamed on parent */ 654 split[0].suspect =origin_incref(e->suspect); 655 split[0].lno = e->lno; 656 split[0].s_lno = e->s_lno; 657 split[0].num_lines = tlno - e->s_lno; 658 split[1].lno = e->lno + tlno - e->s_lno; 659 split[1].s_lno = plno; 660} 661else{ 662 split[1].lno = e->lno; 663 split[1].s_lno = plno + (e->s_lno - tlno); 664} 665 666if(same < e->s_lno + e->num_lines) { 667/* there is a post-chunk part not blamed on parent */ 668 split[2].suspect =origin_incref(e->suspect); 669 split[2].lno = e->lno + (same - e->s_lno); 670 split[2].s_lno = e->s_lno + (same - e->s_lno); 671 split[2].num_lines = e->s_lno + e->num_lines - same; 672 chunk_end_lno = split[2].lno; 673} 674else 675 chunk_end_lno = e->lno + e->num_lines; 676 split[1].num_lines = chunk_end_lno - split[1].lno; 677 678/* 679 * if it turns out there is nothing to blame the parent for, 680 * forget about the splitting. !split[1].suspect signals this. 681 */ 682if(split[1].num_lines <1) 683return; 684 split[1].suspect =origin_incref(parent); 685} 686 687/* 688 * split_overlap() divided an existing blame e into up to three parts 689 * in split. Adjust the linked list of blames in the scoreboard to 690 * reflect the split. 691 */ 692static voidsplit_blame(struct scoreboard *sb, 693struct blame_entry *split, 694struct blame_entry *e) 695{ 696struct blame_entry *new_entry; 697 698if(split[0].suspect && split[2].suspect) { 699/* The first part (reuse storage for the existing entry e) */ 700dup_entry(e, &split[0]); 701 702/* The last part -- me */ 703 new_entry =xmalloc(sizeof(*new_entry)); 704memcpy(new_entry, &(split[2]),sizeof(struct blame_entry)); 705add_blame_entry(sb, new_entry); 706 707/* ... and the middle part -- parent */ 708 new_entry =xmalloc(sizeof(*new_entry)); 709memcpy(new_entry, &(split[1]),sizeof(struct blame_entry)); 710add_blame_entry(sb, new_entry); 711} 712else if(!split[0].suspect && !split[2].suspect) 713/* 714 * The parent covers the entire area; reuse storage for 715 * e and replace it with the parent. 716 */ 717dup_entry(e, &split[1]); 718else if(split[0].suspect) { 719/* me and then parent */ 720dup_entry(e, &split[0]); 721 722 new_entry =xmalloc(sizeof(*new_entry)); 723memcpy(new_entry, &(split[1]),sizeof(struct blame_entry)); 724add_blame_entry(sb, new_entry); 725} 726else{ 727/* parent and then me */ 728dup_entry(e, &split[1]); 729 730 new_entry =xmalloc(sizeof(*new_entry)); 731memcpy(new_entry, &(split[2]),sizeof(struct blame_entry)); 732add_blame_entry(sb, new_entry); 733} 734 735if(DEBUG) {/* sanity */ 736struct blame_entry *ent; 737int lno = sb->ent->lno, corrupt =0; 738 739for(ent = sb->ent; ent; ent = ent->next) { 740if(lno != ent->lno) 741 corrupt =1; 742if(ent->s_lno <0) 743 corrupt =1; 744 lno += ent->num_lines; 745} 746if(corrupt) { 747 lno = sb->ent->lno; 748for(ent = sb->ent; ent; ent = ent->next) { 749printf("L%8d l%8d n%8d\n", 750 lno, ent->lno, ent->num_lines); 751 lno = ent->lno + ent->num_lines; 752} 753die("oops"); 754} 755} 756} 757 758/* 759 * After splitting the blame, the origins used by the 760 * on-stack blame_entry should lose one refcnt each. 761 */ 762static voiddecref_split(struct blame_entry *split) 763{ 764int i; 765 766for(i =0; i <3; i++) 767origin_decref(split[i].suspect); 768} 769 770/* 771 * Helper for blame_chunk(). blame_entry e is known to overlap with 772 * the patch hunk; split it and pass blame to the parent. 773 */ 774static voidblame_overlap(struct scoreboard *sb,struct blame_entry *e, 775int tlno,int plno,int same, 776struct origin *parent) 777{ 778struct blame_entry split[3]; 779 780split_overlap(split, e, tlno, plno, same, parent); 781if(split[1].suspect) 782split_blame(sb, split, e); 783decref_split(split); 784} 785 786/* 787 * Find the line number of the last line the target is suspected for. 788 */ 789static intfind_last_in_target(struct scoreboard *sb,struct origin *target) 790{ 791struct blame_entry *e; 792int last_in_target = -1; 793 794for(e = sb->ent; e; e = e->next) { 795if(e->guilty || !same_suspect(e->suspect, target)) 796continue; 797if(last_in_target < e->s_lno + e->num_lines) 798 last_in_target = e->s_lno + e->num_lines; 799} 800return last_in_target; 801} 802 803/* 804 * Process one hunk from the patch between the current suspect for 805 * blame_entry e and its parent. Find and split the overlap, and 806 * pass blame to the overlapping part to the parent. 807 */ 808static voidblame_chunk(struct scoreboard *sb, 809int tlno,int plno,int same, 810struct origin *target,struct origin *parent) 811{ 812struct blame_entry *e; 813 814for(e = sb->ent; e; e = e->next) { 815if(e->guilty || !same_suspect(e->suspect, target)) 816continue; 817if(same <= e->s_lno) 818continue; 819if(tlno < e->s_lno + e->num_lines) 820blame_overlap(sb, e, tlno, plno, same, parent); 821} 822} 823 824/* 825 * We are looking at the origin 'target' and aiming to pass blame 826 * for the lines it is suspected to its parent. Run diff to find 827 * which lines came from parent and pass blame for them. 828 */ 829static intpass_blame_to_parent(struct scoreboard *sb, 830struct origin *target, 831struct origin *parent) 832{ 833int i, last_in_target, plno, tlno; 834struct patch *patch; 835 836 last_in_target =find_last_in_target(sb, target); 837if(last_in_target <0) 838return1;/* nothing remains for this target */ 839 840 patch =get_patch(parent, target); 841 plno = tlno =0; 842for(i =0; i < patch->num; i++) { 843struct chunk *chunk = &patch->chunks[i]; 844 845blame_chunk(sb, tlno, plno, chunk->same, target, parent); 846 plno = chunk->p_next; 847 tlno = chunk->t_next; 848} 849/* The rest (i.e. anything after tlno) are the same as the parent */ 850blame_chunk(sb, tlno, plno, last_in_target, target, parent); 851 852free_patch(patch); 853return0; 854} 855 856/* 857 * The lines in blame_entry after splitting blames many times can become 858 * very small and trivial, and at some point it becomes pointless to 859 * blame the parents. E.g. "\t\t}\n\t}\n\n" appears everywhere in any 860 * ordinary C program, and it is not worth to say it was copied from 861 * totally unrelated file in the parent. 862 * 863 * Compute how trivial the lines in the blame_entry are. 864 */ 865static unsignedent_score(struct scoreboard *sb,struct blame_entry *e) 866{ 867unsigned score; 868const char*cp, *ep; 869 870if(e->score) 871return e->score; 872 873 score =1; 874 cp =nth_line(sb, e->lno); 875 ep =nth_line(sb, e->lno + e->num_lines); 876while(cp < ep) { 877unsigned ch = *((unsigned char*)cp); 878if(isalnum(ch)) 879 score++; 880 cp++; 881} 882 e->score = score; 883return score; 884} 885 886/* 887 * best_so_far[] and this[] are both a split of an existing blame_entry 888 * that passes blame to the parent. Maintain best_so_far the best split 889 * so far, by comparing this and best_so_far and copying this into 890 * bst_so_far as needed. 891 */ 892static voidcopy_split_if_better(struct scoreboard *sb, 893struct blame_entry *best_so_far, 894struct blame_entry *this) 895{ 896int i; 897 898if(!this[1].suspect) 899return; 900if(best_so_far[1].suspect) { 901if(ent_score(sb, &this[1]) <ent_score(sb, &best_so_far[1])) 902return; 903} 904 905for(i =0; i <3; i++) 906origin_incref(this[i].suspect); 907decref_split(best_so_far); 908memcpy(best_so_far,this,sizeof(struct blame_entry [3])); 909} 910 911/* 912 * We are looking at a part of the final image represented by 913 * ent (tlno and same are offset by ent->s_lno). 914 * tlno is where we are looking at in the final image. 915 * up to (but not including) same match preimage. 916 * plno is where we are looking at in the preimage. 917 * 918 * <-------------- final image ----------------------> 919 * <------ent------> 920 * ^tlno ^same 921 * <---------preimage-----> 922 * ^plno 923 * 924 * All line numbers are 0-based. 925 */ 926static voidhandle_split(struct scoreboard *sb, 927struct blame_entry *ent, 928int tlno,int plno,int same, 929struct origin *parent, 930struct blame_entry *split) 931{ 932if(ent->num_lines <= tlno) 933return; 934if(tlno < same) { 935struct blame_entry this[3]; 936 tlno += ent->s_lno; 937 same += ent->s_lno; 938split_overlap(this, ent, tlno, plno, same, parent); 939copy_split_if_better(sb, split,this); 940decref_split(this); 941} 942} 943 944/* 945 * Find the lines from parent that are the same as ent so that 946 * we can pass blames to it. file_p has the blob contents for 947 * the parent. 948 */ 949static voidfind_copy_in_blob(struct scoreboard *sb, 950struct blame_entry *ent, 951struct origin *parent, 952struct blame_entry *split, 953 mmfile_t *file_p) 954{ 955const char*cp; 956int cnt; 957 mmfile_t file_o; 958struct patch *patch; 959int i, plno, tlno; 960 961/* 962 * Prepare mmfile that contains only the lines in ent. 963 */ 964 cp =nth_line(sb, ent->lno); 965 file_o.ptr = (char*) cp; 966 cnt = ent->num_lines; 967 968while(cnt && cp < sb->final_buf + sb->final_buf_size) { 969if(*cp++ =='\n') 970 cnt--; 971} 972 file_o.size = cp - file_o.ptr; 973 974 patch =compare_buffer(file_p, &file_o,1); 975 976/* 977 * file_o is a part of final image we are annotating. 978 * file_p partially may match that image. 979 */ 980memset(split,0,sizeof(struct blame_entry [3])); 981 plno = tlno =0; 982for(i =0; i < patch->num; i++) { 983struct chunk *chunk = &patch->chunks[i]; 984 985handle_split(sb, ent, tlno, plno, chunk->same, parent, split); 986 plno = chunk->p_next; 987 tlno = chunk->t_next; 988} 989/* remainder, if any, all match the preimage */ 990handle_split(sb, ent, tlno, plno, ent->num_lines, parent, split); 991free_patch(patch); 992} 993 994/* 995 * See if lines currently target is suspected for can be attributed to 996 * parent. 997 */ 998static intfind_move_in_parent(struct scoreboard *sb, 999struct origin *target,1000struct origin *parent)1001{1002int last_in_target, made_progress;1003struct blame_entry *e, split[3];1004 mmfile_t file_p;10051006 last_in_target =find_last_in_target(sb, target);1007if(last_in_target <0)1008return1;/* nothing remains for this target */10091010fill_origin_blob(parent, &file_p);1011if(!file_p.ptr)1012return0;10131014 made_progress =1;1015while(made_progress) {1016 made_progress =0;1017for(e = sb->ent; e; e = e->next) {1018if(e->guilty || !same_suspect(e->suspect, target))1019continue;1020find_copy_in_blob(sb, e, parent, split, &file_p);1021if(split[1].suspect &&1022 blame_move_score <ent_score(sb, &split[1])) {1023split_blame(sb, split, e);1024 made_progress =1;1025}1026decref_split(split);1027}1028}1029return0;1030}10311032struct blame_list {1033struct blame_entry *ent;1034struct blame_entry split[3];1035};10361037/*1038 * Count the number of entries the target is suspected for,1039 * and prepare a list of entry and the best split.1040 */1041static struct blame_list *setup_blame_list(struct scoreboard *sb,1042struct origin *target,1043int*num_ents_p)1044{1045struct blame_entry *e;1046int num_ents, i;1047struct blame_list *blame_list = NULL;10481049for(e = sb->ent, num_ents =0; e; e = e->next)1050if(!e->guilty &&same_suspect(e->suspect, target))1051 num_ents++;1052if(num_ents) {1053 blame_list =xcalloc(num_ents,sizeof(struct blame_list));1054for(e = sb->ent, i =0; e; e = e->next)1055if(!e->guilty &&same_suspect(e->suspect, target))1056 blame_list[i++].ent = e;1057}1058*num_ents_p = num_ents;1059return blame_list;1060}10611062/*1063 * For lines target is suspected for, see if we can find code movement1064 * across file boundary from the parent commit. porigin is the path1065 * in the parent we already tried.1066 */1067static intfind_copy_in_parent(struct scoreboard *sb,1068struct origin *target,1069struct commit *parent,1070struct origin *porigin,1071int opt)1072{1073struct diff_options diff_opts;1074const char*paths[1];1075int i, j;1076int retval;1077struct blame_list *blame_list;1078int num_ents;10791080 blame_list =setup_blame_list(sb, target, &num_ents);1081if(!blame_list)1082return1;/* nothing remains for this target */10831084diff_setup(&diff_opts);1085DIFF_OPT_SET(&diff_opts, RECURSIVE);1086 diff_opts.output_format = DIFF_FORMAT_NO_OUTPUT;10871088 paths[0] = NULL;1089diff_tree_setup_paths(paths, &diff_opts);1090if(diff_setup_done(&diff_opts) <0)1091die("diff-setup");10921093/* Try "find copies harder" on new path if requested;1094 * we do not want to use diffcore_rename() actually to1095 * match things up; find_copies_harder is set only to1096 * force diff_tree_sha1() to feed all filepairs to diff_queue,1097 * and this code needs to be after diff_setup_done(), which1098 * usually makes find-copies-harder imply copy detection.1099 */1100if((opt & PICKAXE_BLAME_COPY_HARDEST)1101|| ((opt & PICKAXE_BLAME_COPY_HARDER)1102&& (!porigin ||strcmp(target->path, porigin->path))))1103DIFF_OPT_SET(&diff_opts, FIND_COPIES_HARDER);11041105if(is_null_sha1(target->commit->object.sha1))1106do_diff_cache(parent->tree->object.sha1, &diff_opts);1107else1108diff_tree_sha1(parent->tree->object.sha1,1109 target->commit->tree->object.sha1,1110"", &diff_opts);11111112if(!DIFF_OPT_TST(&diff_opts, FIND_COPIES_HARDER))1113diffcore_std(&diff_opts);11141115 retval =0;1116while(1) {1117int made_progress =0;11181119for(i =0; i < diff_queued_diff.nr; i++) {1120struct diff_filepair *p = diff_queued_diff.queue[i];1121struct origin *norigin;1122 mmfile_t file_p;1123struct blame_entry this[3];11241125if(!DIFF_FILE_VALID(p->one))1126continue;/* does not exist in parent */1127if(porigin && !strcmp(p->one->path, porigin->path))1128/* find_move already dealt with this path */1129continue;11301131 norigin =get_origin(sb, parent, p->one->path);1132hashcpy(norigin->blob_sha1, p->one->sha1);1133fill_origin_blob(norigin, &file_p);1134if(!file_p.ptr)1135continue;11361137for(j =0; j < num_ents; j++) {1138find_copy_in_blob(sb, blame_list[j].ent,1139 norigin,this, &file_p);1140copy_split_if_better(sb, blame_list[j].split,1141this);1142decref_split(this);1143}1144origin_decref(norigin);1145}11461147for(j =0; j < num_ents; j++) {1148struct blame_entry *split = blame_list[j].split;1149if(split[1].suspect &&1150 blame_copy_score <ent_score(sb, &split[1])) {1151split_blame(sb, split, blame_list[j].ent);1152 made_progress =1;1153}1154decref_split(split);1155}1156free(blame_list);11571158if(!made_progress)1159break;1160 blame_list =setup_blame_list(sb, target, &num_ents);1161if(!blame_list) {1162 retval =1;1163break;1164}1165}1166diff_flush(&diff_opts);1167diff_tree_release_paths(&diff_opts);1168return retval;1169}11701171/*1172 * The blobs of origin and porigin exactly match, so everything1173 * origin is suspected for can be blamed on the parent.1174 */1175static voidpass_whole_blame(struct scoreboard *sb,1176struct origin *origin,struct origin *porigin)1177{1178struct blame_entry *e;11791180if(!porigin->file.ptr && origin->file.ptr) {1181/* Steal its file */1182 porigin->file = origin->file;1183 origin->file.ptr = NULL;1184}1185for(e = sb->ent; e; e = e->next) {1186if(!same_suspect(e->suspect, origin))1187continue;1188origin_incref(porigin);1189origin_decref(e->suspect);1190 e->suspect = porigin;1191}1192}11931194/*1195 * We pass blame from the current commit to its parents. We keep saying1196 * "parent" (and "porigin"), but what we mean is to find scapegoat to1197 * exonerate ourselves.1198 */1199static struct commit_list *first_scapegoat(struct commit *commit)1200{1201return commit->parents;1202}12031204static intnum_scapegoats(struct commit *commit)1205{1206int cnt;1207struct commit_list *l =first_scapegoat(commit);1208for(cnt =0; l; l = l->next)1209 cnt++;1210return cnt;1211}12121213#define MAXSG 1612141215static voidpass_blame(struct scoreboard *sb,struct origin *origin,int opt)1216{1217int i, pass, num_sg;1218struct commit *commit = origin->commit;1219struct commit_list *sg;1220struct origin *sg_buf[MAXSG];1221struct origin *porigin, **sg_origin = sg_buf;12221223 num_sg =num_scapegoats(commit);1224if(!num_sg)1225goto finish;1226else if(num_sg <ARRAY_SIZE(sg_buf))1227memset(sg_buf,0,sizeof(sg_buf));1228else1229 sg_origin =xcalloc(num_sg,sizeof(*sg_origin));12301231/*1232 * The first pass looks for unrenamed path to optimize for1233 * common cases, then we look for renames in the second pass.1234 */1235for(pass =0; pass <2; pass++) {1236struct origin *(*find)(struct scoreboard *,1237struct commit *,struct origin *);1238 find = pass ? find_rename : find_origin;12391240for(i =0, sg =first_scapegoat(commit);1241 i < num_sg && sg;1242 sg = sg->next, i++) {1243struct commit *p = sg->item;1244int j, same;12451246if(sg_origin[i])1247continue;1248if(parse_commit(p))1249continue;1250 porigin =find(sb, p, origin);1251if(!porigin)1252continue;1253if(!hashcmp(porigin->blob_sha1, origin->blob_sha1)) {1254pass_whole_blame(sb, origin, porigin);1255origin_decref(porigin);1256goto finish;1257}1258for(j = same =0; j < i; j++)1259if(sg_origin[j] &&1260!hashcmp(sg_origin[j]->blob_sha1,1261 porigin->blob_sha1)) {1262 same =1;1263break;1264}1265if(!same)1266 sg_origin[i] = porigin;1267else1268origin_decref(porigin);1269}1270}12711272 num_commits++;1273for(i =0, sg =first_scapegoat(commit);1274 i < num_sg && sg;1275 sg = sg->next, i++) {1276struct origin *porigin = sg_origin[i];1277if(!porigin)1278continue;1279if(pass_blame_to_parent(sb, origin, porigin))1280goto finish;1281}12821283/*1284 * Optionally find moves in parents' files.1285 */1286if(opt & PICKAXE_BLAME_MOVE)1287for(i =0, sg =first_scapegoat(commit);1288 i < num_sg && sg;1289 sg = sg->next, i++) {1290struct origin *porigin = sg_origin[i];1291if(!porigin)1292continue;1293if(find_move_in_parent(sb, origin, porigin))1294goto finish;1295}12961297/*1298 * Optionally find copies from parents' files.1299 */1300if(opt & PICKAXE_BLAME_COPY)1301for(i =0, sg =first_scapegoat(commit);1302 i < num_sg && sg;1303 sg = sg->next, i++) {1304struct origin *porigin = sg_origin[i];1305if(find_copy_in_parent(sb, origin, sg->item,1306 porigin, opt))1307goto finish;1308}13091310 finish:1311for(i =0; i < num_sg; i++) {1312if(sg_origin[i]) {1313drop_origin_blob(sg_origin[i]);1314origin_decref(sg_origin[i]);1315}1316}1317drop_origin_blob(origin);1318if(sg_buf != sg_origin)1319free(sg_origin);1320}13211322/*1323 * Information on commits, used for output.1324 */1325struct commit_info1326{1327const char*author;1328const char*author_mail;1329unsigned long author_time;1330const char*author_tz;13311332/* filled only when asked for details */1333const char*committer;1334const char*committer_mail;1335unsigned long committer_time;1336const char*committer_tz;13371338const char*summary;1339};13401341/*1342 * Parse author/committer line in the commit object buffer1343 */1344static voidget_ac_line(const char*inbuf,const char*what,1345int bufsz,char*person,const char**mail,1346unsigned long*time,const char**tz)1347{1348int len, tzlen, maillen;1349char*tmp, *endp, *timepos;13501351 tmp =strstr(inbuf, what);1352if(!tmp)1353goto error_out;1354 tmp +=strlen(what);1355 endp =strchr(tmp,'\n');1356if(!endp)1357 len =strlen(tmp);1358else1359 len = endp - tmp;1360if(bufsz <= len) {1361 error_out:1362/* Ugh */1363*mail = *tz ="(unknown)";1364*time =0;1365return;1366}1367memcpy(person, tmp, len);13681369 tmp = person;1370 tmp += len;1371*tmp =0;1372while(*tmp !=' ')1373 tmp--;1374*tz = tmp+1;1375 tzlen = (person+len)-(tmp+1);13761377*tmp =0;1378while(*tmp !=' ')1379 tmp--;1380*time =strtoul(tmp, NULL,10);1381 timepos = tmp;13821383*tmp =0;1384while(*tmp !=' ')1385 tmp--;1386*mail = tmp +1;1387*tmp =0;1388 maillen = timepos - tmp;13891390if(!mailmap.nr)1391return;13921393/*1394 * mailmap expansion may make the name longer.1395 * make room by pushing stuff down.1396 */1397 tmp = person + bufsz - (tzlen +1);1398memmove(tmp, *tz, tzlen);1399 tmp[tzlen] =0;1400*tz = tmp;14011402 tmp = tmp - (maillen +1);1403memmove(tmp, *mail, maillen);1404 tmp[maillen] =0;1405*mail = tmp;14061407/*1408 * Now, convert e-mail using mailmap1409 */1410map_email(&mailmap, tmp +1, person, tmp-person-1);1411}14121413static voidget_commit_info(struct commit *commit,1414struct commit_info *ret,1415int detailed)1416{1417int len;1418char*tmp, *endp;1419static char author_buf[1024];1420static char committer_buf[1024];1421static char summary_buf[1024];14221423/*1424 * We've operated without save_commit_buffer, so1425 * we now need to populate them for output.1426 */1427if(!commit->buffer) {1428enum object_type type;1429unsigned long size;1430 commit->buffer =1431read_sha1_file(commit->object.sha1, &type, &size);1432if(!commit->buffer)1433die("Cannot read commit%s",1434sha1_to_hex(commit->object.sha1));1435}1436 ret->author = author_buf;1437get_ac_line(commit->buffer,"\nauthor ",1438sizeof(author_buf), author_buf, &ret->author_mail,1439&ret->author_time, &ret->author_tz);14401441if(!detailed)1442return;14431444 ret->committer = committer_buf;1445get_ac_line(commit->buffer,"\ncommitter ",1446sizeof(committer_buf), committer_buf, &ret->committer_mail,1447&ret->committer_time, &ret->committer_tz);14481449 ret->summary = summary_buf;1450 tmp =strstr(commit->buffer,"\n\n");1451if(!tmp) {1452 error_out:1453sprintf(summary_buf,"(%s)",sha1_to_hex(commit->object.sha1));1454return;1455}1456 tmp +=2;1457 endp =strchr(tmp,'\n');1458if(!endp)1459 endp = tmp +strlen(tmp);1460 len = endp - tmp;1461if(len >=sizeof(summary_buf) || len ==0)1462goto error_out;1463memcpy(summary_buf, tmp, len);1464 summary_buf[len] =0;1465}14661467/*1468 * To allow LF and other nonportable characters in pathnames,1469 * they are c-style quoted as needed.1470 */1471static voidwrite_filename_info(const char*path)1472{1473printf("filename ");1474write_name_quoted(path, stdout,'\n');1475}14761477/*1478 * The blame_entry is found to be guilty for the range. Mark it1479 * as such, and show it in incremental output.1480 */1481static voidfound_guilty_entry(struct blame_entry *ent)1482{1483if(ent->guilty)1484return;1485 ent->guilty =1;1486if(incremental) {1487struct origin *suspect = ent->suspect;14881489printf("%s %d %d %d\n",1490sha1_to_hex(suspect->commit->object.sha1),1491 ent->s_lno +1, ent->lno +1, ent->num_lines);1492if(!(suspect->commit->object.flags & METAINFO_SHOWN)) {1493struct commit_info ci;1494 suspect->commit->object.flags |= METAINFO_SHOWN;1495get_commit_info(suspect->commit, &ci,1);1496printf("author%s\n", ci.author);1497printf("author-mail%s\n", ci.author_mail);1498printf("author-time%lu\n", ci.author_time);1499printf("author-tz%s\n", ci.author_tz);1500printf("committer%s\n", ci.committer);1501printf("committer-mail%s\n", ci.committer_mail);1502printf("committer-time%lu\n", ci.committer_time);1503printf("committer-tz%s\n", ci.committer_tz);1504printf("summary%s\n", ci.summary);1505if(suspect->commit->object.flags & UNINTERESTING)1506printf("boundary\n");1507}1508write_filename_info(suspect->path);1509maybe_flush_or_die(stdout,"stdout");1510}1511}15121513/*1514 * The main loop -- while the scoreboard has lines whose true origin1515 * is still unknown, pick one blame_entry, and allow its current1516 * suspect to pass blames to its parents.1517 */1518static voidassign_blame(struct scoreboard *sb,struct rev_info *revs,int opt)1519{1520while(1) {1521struct blame_entry *ent;1522struct commit *commit;1523struct origin *suspect = NULL;15241525/* find one suspect to break down */1526for(ent = sb->ent; !suspect && ent; ent = ent->next)1527if(!ent->guilty)1528 suspect = ent->suspect;1529if(!suspect)1530return;/* all done */15311532/*1533 * We will use this suspect later in the loop,1534 * so hold onto it in the meantime.1535 */1536origin_incref(suspect);1537 commit = suspect->commit;1538if(!commit->object.parsed)1539parse_commit(commit);1540if(!(commit->object.flags & UNINTERESTING) &&1541!(revs->max_age != -1&& commit->date < revs->max_age))1542pass_blame(sb, suspect, opt);1543else{1544 commit->object.flags |= UNINTERESTING;1545if(commit->object.parsed)1546mark_parents_uninteresting(commit);1547}1548/* treat root commit as boundary */1549if(!commit->parents && !show_root)1550 commit->object.flags |= UNINTERESTING;15511552/* Take responsibility for the remaining entries */1553for(ent = sb->ent; ent; ent = ent->next)1554if(same_suspect(ent->suspect, suspect))1555found_guilty_entry(ent);1556origin_decref(suspect);15571558if(DEBUG)/* sanity */1559sanity_check_refcnt(sb);1560}1561}15621563static const char*format_time(unsigned long time,const char*tz_str,1564int show_raw_time)1565{1566static char time_buf[128];1567time_t t = time;1568int minutes, tz;1569struct tm *tm;15701571if(show_raw_time) {1572sprintf(time_buf,"%lu%s", time, tz_str);1573return time_buf;1574}15751576 tz =atoi(tz_str);1577 minutes = tz <0? -tz : tz;1578 minutes = (minutes /100)*60+ (minutes %100);1579 minutes = tz <0? -minutes : minutes;1580 t = time + minutes *60;1581 tm =gmtime(&t);15821583strftime(time_buf,sizeof(time_buf),"%Y-%m-%d %H:%M:%S", tm);1584strcat(time_buf, tz_str);1585return time_buf;1586}15871588#define OUTPUT_ANNOTATE_COMPAT 0011589#define OUTPUT_LONG_OBJECT_NAME 0021590#define OUTPUT_RAW_TIMESTAMP 0041591#define OUTPUT_PORCELAIN 0101592#define OUTPUT_SHOW_NAME 0201593#define OUTPUT_SHOW_NUMBER 0401594#define OUTPUT_SHOW_SCORE 01001595#define OUTPUT_NO_AUTHOR 020015961597static voidemit_porcelain(struct scoreboard *sb,struct blame_entry *ent)1598{1599int cnt;1600const char*cp;1601struct origin *suspect = ent->suspect;1602char hex[41];16031604strcpy(hex,sha1_to_hex(suspect->commit->object.sha1));1605printf("%s%c%d %d %d\n",1606 hex,1607 ent->guilty ?' ':'*',// purely for debugging1608 ent->s_lno +1,1609 ent->lno +1,1610 ent->num_lines);1611if(!(suspect->commit->object.flags & METAINFO_SHOWN)) {1612struct commit_info ci;1613 suspect->commit->object.flags |= METAINFO_SHOWN;1614get_commit_info(suspect->commit, &ci,1);1615printf("author%s\n", ci.author);1616printf("author-mail%s\n", ci.author_mail);1617printf("author-time%lu\n", ci.author_time);1618printf("author-tz%s\n", ci.author_tz);1619printf("committer%s\n", ci.committer);1620printf("committer-mail%s\n", ci.committer_mail);1621printf("committer-time%lu\n", ci.committer_time);1622printf("committer-tz%s\n", ci.committer_tz);1623write_filename_info(suspect->path);1624printf("summary%s\n", ci.summary);1625if(suspect->commit->object.flags & UNINTERESTING)1626printf("boundary\n");1627}1628else if(suspect->commit->object.flags & MORE_THAN_ONE_PATH)1629write_filename_info(suspect->path);16301631 cp =nth_line(sb, ent->lno);1632for(cnt =0; cnt < ent->num_lines; cnt++) {1633char ch;1634if(cnt)1635printf("%s %d %d\n", hex,1636 ent->s_lno +1+ cnt,1637 ent->lno +1+ cnt);1638putchar('\t');1639do{1640 ch = *cp++;1641putchar(ch);1642}while(ch !='\n'&&1643 cp < sb->final_buf + sb->final_buf_size);1644}1645}16461647static voidemit_other(struct scoreboard *sb,struct blame_entry *ent,int opt)1648{1649int cnt;1650const char*cp;1651struct origin *suspect = ent->suspect;1652struct commit_info ci;1653char hex[41];1654int show_raw_time = !!(opt & OUTPUT_RAW_TIMESTAMP);16551656get_commit_info(suspect->commit, &ci,1);1657strcpy(hex,sha1_to_hex(suspect->commit->object.sha1));16581659 cp =nth_line(sb, ent->lno);1660for(cnt =0; cnt < ent->num_lines; cnt++) {1661char ch;1662int length = (opt & OUTPUT_LONG_OBJECT_NAME) ?40:8;16631664if(suspect->commit->object.flags & UNINTERESTING) {1665if(blank_boundary)1666memset(hex,' ', length);1667else if(!cmd_is_annotate) {1668 length--;1669putchar('^');1670}1671}16721673printf("%.*s", length, hex);1674if(opt & OUTPUT_ANNOTATE_COMPAT)1675printf("\t(%10s\t%10s\t%d)", ci.author,1676format_time(ci.author_time, ci.author_tz,1677 show_raw_time),1678 ent->lno +1+ cnt);1679else{1680if(opt & OUTPUT_SHOW_SCORE)1681printf(" %*d%02d",1682 max_score_digits, ent->score,1683 ent->suspect->refcnt);1684if(opt & OUTPUT_SHOW_NAME)1685printf(" %-*.*s", longest_file, longest_file,1686 suspect->path);1687if(opt & OUTPUT_SHOW_NUMBER)1688printf(" %*d", max_orig_digits,1689 ent->s_lno +1+ cnt);16901691if(!(opt & OUTPUT_NO_AUTHOR))1692printf(" (%-*.*s%10s",1693 longest_author, longest_author,1694 ci.author,1695format_time(ci.author_time,1696 ci.author_tz,1697 show_raw_time));1698printf(" %*d) ",1699 max_digits, ent->lno +1+ cnt);1700}1701do{1702 ch = *cp++;1703putchar(ch);1704}while(ch !='\n'&&1705 cp < sb->final_buf + sb->final_buf_size);1706}1707}17081709static voidoutput(struct scoreboard *sb,int option)1710{1711struct blame_entry *ent;17121713if(option & OUTPUT_PORCELAIN) {1714for(ent = sb->ent; ent; ent = ent->next) {1715struct blame_entry *oth;1716struct origin *suspect = ent->suspect;1717struct commit *commit = suspect->commit;1718if(commit->object.flags & MORE_THAN_ONE_PATH)1719continue;1720for(oth = ent->next; oth; oth = oth->next) {1721if((oth->suspect->commit != commit) ||1722!strcmp(oth->suspect->path, suspect->path))1723continue;1724 commit->object.flags |= MORE_THAN_ONE_PATH;1725break;1726}1727}1728}17291730for(ent = sb->ent; ent; ent = ent->next) {1731if(option & OUTPUT_PORCELAIN)1732emit_porcelain(sb, ent);1733else{1734emit_other(sb, ent, option);1735}1736}1737}17381739/*1740 * To allow quick access to the contents of nth line in the1741 * final image, prepare an index in the scoreboard.1742 */1743static intprepare_lines(struct scoreboard *sb)1744{1745const char*buf = sb->final_buf;1746unsigned long len = sb->final_buf_size;1747int num =0, incomplete =0, bol =1;17481749if(len && buf[len-1] !='\n')1750 incomplete++;/* incomplete line at the end */1751while(len--) {1752if(bol) {1753 sb->lineno =xrealloc(sb->lineno,1754sizeof(int* ) * (num +1));1755 sb->lineno[num] = buf - sb->final_buf;1756 bol =0;1757}1758if(*buf++ =='\n') {1759 num++;1760 bol =1;1761}1762}1763 sb->lineno =xrealloc(sb->lineno,1764sizeof(int* ) * (num + incomplete +1));1765 sb->lineno[num + incomplete] = buf - sb->final_buf;1766 sb->num_lines = num + incomplete;1767return sb->num_lines;1768}17691770/*1771 * Add phony grafts for use with -S; this is primarily to1772 * support git-cvsserver that wants to give a linear history1773 * to its clients.1774 */1775static intread_ancestry(const char*graft_file)1776{1777FILE*fp =fopen(graft_file,"r");1778char buf[1024];1779if(!fp)1780return-1;1781while(fgets(buf,sizeof(buf), fp)) {1782/* The format is just "Commit Parent1 Parent2 ...\n" */1783int len =strlen(buf);1784struct commit_graft *graft =read_graft_line(buf, len);1785if(graft)1786register_commit_graft(graft,0);1787}1788fclose(fp);1789return0;1790}17911792/*1793 * How many columns do we need to show line numbers in decimal?1794 */1795static intlineno_width(int lines)1796{1797int i, width;17981799for(width =1, i =10; i <= lines +1; width++)1800 i *=10;1801return width;1802}18031804/*1805 * How many columns do we need to show line numbers, authors,1806 * and filenames?1807 */1808static voidfind_alignment(struct scoreboard *sb,int*option)1809{1810int longest_src_lines =0;1811int longest_dst_lines =0;1812unsigned largest_score =0;1813struct blame_entry *e;18141815for(e = sb->ent; e; e = e->next) {1816struct origin *suspect = e->suspect;1817struct commit_info ci;1818int num;18191820if(strcmp(suspect->path, sb->path))1821*option |= OUTPUT_SHOW_NAME;1822 num =strlen(suspect->path);1823if(longest_file < num)1824 longest_file = num;1825if(!(suspect->commit->object.flags & METAINFO_SHOWN)) {1826 suspect->commit->object.flags |= METAINFO_SHOWN;1827get_commit_info(suspect->commit, &ci,1);1828 num =strlen(ci.author);1829if(longest_author < num)1830 longest_author = num;1831}1832 num = e->s_lno + e->num_lines;1833if(longest_src_lines < num)1834 longest_src_lines = num;1835 num = e->lno + e->num_lines;1836if(longest_dst_lines < num)1837 longest_dst_lines = num;1838if(largest_score <ent_score(sb, e))1839 largest_score =ent_score(sb, e);1840}1841 max_orig_digits =lineno_width(longest_src_lines);1842 max_digits =lineno_width(longest_dst_lines);1843 max_score_digits =lineno_width(largest_score);1844}18451846/*1847 * For debugging -- origin is refcounted, and this asserts that1848 * we do not underflow.1849 */1850static voidsanity_check_refcnt(struct scoreboard *sb)1851{1852int baa =0;1853struct blame_entry *ent;18541855for(ent = sb->ent; ent; ent = ent->next) {1856/* Nobody should have zero or negative refcnt */1857if(ent->suspect->refcnt <=0) {1858fprintf(stderr,"%sin%shas negative refcnt%d\n",1859 ent->suspect->path,1860sha1_to_hex(ent->suspect->commit->object.sha1),1861 ent->suspect->refcnt);1862 baa =1;1863}1864}1865for(ent = sb->ent; ent; ent = ent->next) {1866/* Mark the ones that haven't been checked */1867if(0< ent->suspect->refcnt)1868 ent->suspect->refcnt = -ent->suspect->refcnt;1869}1870for(ent = sb->ent; ent; ent = ent->next) {1871/*1872 * ... then pick each and see if they have the the1873 * correct refcnt.1874 */1875int found;1876struct blame_entry *e;1877struct origin *suspect = ent->suspect;18781879if(0< suspect->refcnt)1880continue;1881 suspect->refcnt = -suspect->refcnt;/* Unmark */1882for(found =0, e = sb->ent; e; e = e->next) {1883if(e->suspect != suspect)1884continue;1885 found++;1886}1887if(suspect->refcnt != found) {1888fprintf(stderr,"%sin%shas refcnt%d, not%d\n",1889 ent->suspect->path,1890sha1_to_hex(ent->suspect->commit->object.sha1),1891 ent->suspect->refcnt, found);1892 baa =2;1893}1894}1895if(baa) {1896int opt =0160;1897find_alignment(sb, &opt);1898output(sb, opt);1899die("Baa%d!", baa);1900}1901}19021903/*1904 * Used for the command line parsing; check if the path exists1905 * in the working tree.1906 */1907static inthas_path_in_work_tree(const char*path)1908{1909struct stat st;1910return!lstat(path, &st);1911}19121913static unsignedparse_score(const char*arg)1914{1915char*end;1916unsigned long score =strtoul(arg, &end,10);1917if(*end)1918return0;1919return score;1920}19211922static const char*add_prefix(const char*prefix,const char*path)1923{1924returnprefix_path(prefix, prefix ?strlen(prefix) :0, path);1925}19261927/*1928 * Parsing of (comma separated) one item in the -L option1929 */1930static const char*parse_loc(const char*spec,1931struct scoreboard *sb,long lno,1932long begin,long*ret)1933{1934char*term;1935const char*line;1936long num;1937int reg_error;1938 regex_t regexp;1939 regmatch_t match[1];19401941/* Allow "-L <something>,+20" to mean starting at <something>1942 * for 20 lines, or "-L <something>,-5" for 5 lines ending at1943 * <something>.1944 */1945if(1< begin && (spec[0] =='+'|| spec[0] =='-')) {1946 num =strtol(spec +1, &term,10);1947if(term != spec +1) {1948if(spec[0] =='-')1949 num =0- num;1950if(0< num)1951*ret = begin + num -2;1952else if(!num)1953*ret = begin;1954else1955*ret = begin + num;1956return term;1957}1958return spec;1959}1960 num =strtol(spec, &term,10);1961if(term != spec) {1962*ret = num;1963return term;1964}1965if(spec[0] !='/')1966return spec;19671968/* it could be a regexp of form /.../ */1969for(term = (char*) spec +1; *term && *term !='/'; term++) {1970if(*term =='\\')1971 term++;1972}1973if(*term !='/')1974return spec;19751976/* try [spec+1 .. term-1] as regexp */1977*term =0;1978 begin--;/* input is in human terms */1979 line =nth_line(sb, begin);19801981if(!(reg_error =regcomp(®exp, spec +1, REG_NEWLINE)) &&1982!(reg_error =regexec(®exp, line,1, match,0))) {1983const char*cp = line + match[0].rm_so;1984const char*nline;19851986while(begin++ < lno) {1987 nline =nth_line(sb, begin);1988if(line <= cp && cp < nline)1989break;1990 line = nline;1991}1992*ret = begin;1993regfree(®exp);1994*term++ ='/';1995return term;1996}1997else{1998char errbuf[1024];1999regerror(reg_error, ®exp, errbuf,1024);2000die("-L parameter '%s':%s", spec +1, errbuf);2001}2002}20032004/*2005 * Parsing of -L option2006 */2007static voidprepare_blame_range(struct scoreboard *sb,2008const char*bottomtop,2009long lno,2010long*bottom,long*top)2011{2012const char*term;20132014 term =parse_loc(bottomtop, sb, lno,1, bottom);2015if(*term ==',') {2016 term =parse_loc(term +1, sb, lno, *bottom +1, top);2017if(*term)2018usage(blame_usage);2019}2020if(*term)2021usage(blame_usage);2022}20232024static intgit_blame_config(const char*var,const char*value)2025{2026if(!strcmp(var,"blame.showroot")) {2027 show_root =git_config_bool(var, value);2028return0;2029}2030if(!strcmp(var,"blame.blankboundary")) {2031 blank_boundary =git_config_bool(var, value);2032return0;2033}2034returngit_default_config(var, value);2035}20362037/*2038 * Prepare a dummy commit that represents the work tree (or staged) item.2039 * Note that annotating work tree item never works in the reverse.2040 */2041static struct commit *fake_working_tree_commit(const char*path,const char*contents_from)2042{2043struct commit *commit;2044struct origin *origin;2045unsigned char head_sha1[20];2046struct strbuf buf;2047const char*ident;2048time_t now;2049int size, len;2050struct cache_entry *ce;2051unsigned mode;20522053if(get_sha1("HEAD", head_sha1))2054die("No such ref: HEAD");20552056time(&now);2057 commit =xcalloc(1,sizeof(*commit));2058 commit->parents =xcalloc(1,sizeof(*commit->parents));2059 commit->parents->item =lookup_commit_reference(head_sha1);2060 commit->object.parsed =1;2061 commit->date = now;2062 commit->object.type = OBJ_COMMIT;20632064 origin =make_origin(commit, path);20652066strbuf_init(&buf,0);2067if(!contents_from ||strcmp("-", contents_from)) {2068struct stat st;2069const char*read_from;2070unsigned long fin_size;20712072if(contents_from) {2073if(stat(contents_from, &st) <0)2074die("Cannot stat%s", contents_from);2075 read_from = contents_from;2076}2077else{2078if(lstat(path, &st) <0)2079die("Cannot lstat%s", path);2080 read_from = path;2081}2082 fin_size =xsize_t(st.st_size);2083 mode =canon_mode(st.st_mode);2084switch(st.st_mode & S_IFMT) {2085case S_IFREG:2086if(strbuf_read_file(&buf, read_from, st.st_size) != st.st_size)2087die("cannot open or read%s", read_from);2088break;2089case S_IFLNK:2090if(readlink(read_from, buf.buf, buf.alloc) != fin_size)2091die("cannot readlink%s", read_from);2092 buf.len = fin_size;2093break;2094default:2095die("unsupported file type%s", read_from);2096}2097}2098else{2099/* Reading from stdin */2100 contents_from ="standard input";2101 mode =0;2102if(strbuf_read(&buf,0,0) <0)2103die("read error%sfrom stdin",strerror(errno));2104}2105convert_to_git(path, buf.buf, buf.len, &buf,0);2106 origin->file.ptr = buf.buf;2107 origin->file.size = buf.len;2108pretend_sha1_file(buf.buf, buf.len, OBJ_BLOB, origin->blob_sha1);2109 commit->util = origin;21102111/*2112 * Read the current index, replace the path entry with2113 * origin->blob_sha1 without mucking with its mode or type2114 * bits; we are not going to write this index out -- we just2115 * want to run "diff-index --cached".2116 */2117discard_cache();2118read_cache();21192120 len =strlen(path);2121if(!mode) {2122int pos =cache_name_pos(path, len);2123if(0<= pos)2124 mode = active_cache[pos]->ce_mode;2125else2126/* Let's not bother reading from HEAD tree */2127 mode = S_IFREG |0644;2128}2129 size =cache_entry_size(len);2130 ce =xcalloc(1, size);2131hashcpy(ce->sha1, origin->blob_sha1);2132memcpy(ce->name, path, len);2133 ce->ce_flags =create_ce_flags(len,0);2134 ce->ce_mode =create_ce_mode(mode);2135add_cache_entry(ce, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE);21362137/*2138 * We are not going to write this out, so this does not matter2139 * right now, but someday we might optimize diff-index --cached2140 * with cache-tree information.2141 */2142cache_tree_invalidate_path(active_cache_tree, path);21432144 commit->buffer =xmalloc(400);2145 ident =fmt_ident("Not Committed Yet","not.committed.yet", NULL,0);2146snprintf(commit->buffer,400,2147"tree 0000000000000000000000000000000000000000\n"2148"parent%s\n"2149"author%s\n"2150"committer%s\n\n"2151"Version of%sfrom%s\n",2152sha1_to_hex(head_sha1),2153 ident, ident, path, contents_from ? contents_from : path);2154return commit;2155}21562157static const char*prepare_final(struct scoreboard *sb,struct rev_info *revs)2158{2159int i;2160const char*final_commit_name = NULL;21612162/*2163 * There must be one and only one positive commit in the2164 * revs->pending array.2165 */2166for(i =0; i < revs->pending.nr; i++) {2167struct object *obj = revs->pending.objects[i].item;2168if(obj->flags & UNINTERESTING)2169continue;2170while(obj->type == OBJ_TAG)2171 obj =deref_tag(obj, NULL,0);2172if(obj->type != OBJ_COMMIT)2173die("Non commit%s?", revs->pending.objects[i].name);2174if(sb->final)2175die("More than one commit to dig from%sand%s?",2176 revs->pending.objects[i].name,2177 final_commit_name);2178 sb->final = (struct commit *) obj;2179 final_commit_name = revs->pending.objects[i].name;2180}2181return final_commit_name;2182}21832184intcmd_blame(int argc,const char**argv,const char*prefix)2185{2186struct rev_info revs;2187const char*path;2188struct scoreboard sb;2189struct origin *o;2190struct blame_entry *ent;2191int i, seen_dashdash, unk, opt;2192long bottom, top, lno;2193int output_option =0;2194int show_stats =0;2195const char*revs_file = NULL;2196const char*final_commit_name = NULL;2197enum object_type type;2198const char*bottomtop = NULL;2199const char*contents_from = NULL;22002201 cmd_is_annotate = !strcmp(argv[0],"annotate");22022203git_config(git_blame_config);2204 save_commit_buffer =0;22052206 opt =0;2207 seen_dashdash =0;2208for(unk = i =1; i < argc; i++) {2209const char*arg = argv[i];2210if(*arg !='-')2211break;2212else if(!strcmp("-b", arg))2213 blank_boundary =1;2214else if(!strcmp("--root", arg))2215 show_root =1;2216else if(!strcmp(arg,"--show-stats"))2217 show_stats =1;2218else if(!strcmp("-c", arg))2219 output_option |= OUTPUT_ANNOTATE_COMPAT;2220else if(!strcmp("-t", arg))2221 output_option |= OUTPUT_RAW_TIMESTAMP;2222else if(!strcmp("-l", arg))2223 output_option |= OUTPUT_LONG_OBJECT_NAME;2224else if(!strcmp("-s", arg))2225 output_option |= OUTPUT_NO_AUTHOR;2226else if(!strcmp("-w", arg))2227 xdl_opts |= XDF_IGNORE_WHITESPACE;2228else if(!strcmp("-S", arg) && ++i < argc)2229 revs_file = argv[i];2230else if(!prefixcmp(arg,"-M")) {2231 opt |= PICKAXE_BLAME_MOVE;2232 blame_move_score =parse_score(arg+2);2233}2234else if(!prefixcmp(arg,"-C")) {2235/*2236 * -C enables copy from removed files;2237 * -C -C enables copy from existing files, but only2238 * when blaming a new file;2239 * -C -C -C enables copy from existing files for2240 * everybody2241 */2242if(opt & PICKAXE_BLAME_COPY_HARDER)2243 opt |= PICKAXE_BLAME_COPY_HARDEST;2244if(opt & PICKAXE_BLAME_COPY)2245 opt |= PICKAXE_BLAME_COPY_HARDER;2246 opt |= PICKAXE_BLAME_COPY | PICKAXE_BLAME_MOVE;2247 blame_copy_score =parse_score(arg+2);2248}2249else if(!prefixcmp(arg,"-L")) {2250if(!arg[2]) {2251if(++i >= argc)2252usage(blame_usage);2253 arg = argv[i];2254}2255else2256 arg +=2;2257if(bottomtop)2258die("More than one '-L n,m' option given");2259 bottomtop = arg;2260}2261else if(!strcmp("--contents", arg)) {2262if(++i >= argc)2263usage(blame_usage);2264 contents_from = argv[i];2265}2266else if(!strcmp("--incremental", arg))2267 incremental =1;2268else if(!strcmp("--score-debug", arg))2269 output_option |= OUTPUT_SHOW_SCORE;2270else if(!strcmp("-f", arg) ||2271!strcmp("--show-name", arg))2272 output_option |= OUTPUT_SHOW_NAME;2273else if(!strcmp("-n", arg) ||2274!strcmp("--show-number", arg))2275 output_option |= OUTPUT_SHOW_NUMBER;2276else if(!strcmp("-p", arg) ||2277!strcmp("--porcelain", arg))2278 output_option |= OUTPUT_PORCELAIN;2279else if(!strcmp("--", arg)) {2280 seen_dashdash =1;2281 i++;2282break;2283}2284else2285 argv[unk++] = arg;2286}22872288if(!blame_move_score)2289 blame_move_score = BLAME_DEFAULT_MOVE_SCORE;2290if(!blame_copy_score)2291 blame_copy_score = BLAME_DEFAULT_COPY_SCORE;22922293/*2294 * We have collected options unknown to us in argv[1..unk]2295 * which are to be passed to revision machinery if we are2296 * going to do the "bottom" processing.2297 *2298 * The remaining are:2299 *2300 * (1) if seen_dashdash, its either2301 * "-options -- <path>" or2302 * "-options -- <path> <rev>".2303 * but the latter is allowed only if there is no2304 * options that we passed to revision machinery.2305 *2306 * (2) otherwise, we may have "--" somewhere later and2307 * might be looking at the first one of multiple 'rev'2308 * parameters (e.g. " master ^next ^maint -- path").2309 * See if there is a dashdash first, and give the2310 * arguments before that to revision machinery.2311 * After that there must be one 'path'.2312 *2313 * (3) otherwise, its one of the three:2314 * "-options <path> <rev>"2315 * "-options <rev> <path>"2316 * "-options <path>"2317 * but again the first one is allowed only if2318 * there is no options that we passed to revision2319 * machinery.2320 */23212322if(seen_dashdash) {2323/* (1) */2324if(argc <= i)2325usage(blame_usage);2326 path =add_prefix(prefix, argv[i]);2327if(i +1== argc -1) {2328if(unk !=1)2329usage(blame_usage);2330 argv[unk++] = argv[i +1];2331}2332else if(i +1!= argc)2333/* garbage at end */2334usage(blame_usage);2335}2336else{2337int j;2338for(j = i; !seen_dashdash && j < argc; j++)2339if(!strcmp(argv[j],"--"))2340 seen_dashdash = j;2341if(seen_dashdash) {2342/* (2) */2343if(seen_dashdash +1!= argc -1)2344usage(blame_usage);2345 path =add_prefix(prefix, argv[seen_dashdash +1]);2346for(j = i; j < seen_dashdash; j++)2347 argv[unk++] = argv[j];2348}2349else{2350/* (3) */2351if(argc <= i)2352usage(blame_usage);2353 path =add_prefix(prefix, argv[i]);2354if(i +1== argc -1) {2355 final_commit_name = argv[i +1];23562357/* if (unk == 1) we could be getting2358 * old-style2359 */2360if(unk ==1&& !has_path_in_work_tree(path)) {2361 path =add_prefix(prefix, argv[i +1]);2362 final_commit_name = argv[i];2363}2364}2365else if(i != argc -1)2366usage(blame_usage);/* garbage at end */23672368setup_work_tree();2369if(!has_path_in_work_tree(path))2370die("cannot stat path%s:%s",2371 path,strerror(errno));2372}2373}23742375if(final_commit_name)2376 argv[unk++] = final_commit_name;23772378/*2379 * Now we got rev and path. We do not want the path pruning2380 * but we may want "bottom" processing.2381 */2382 argv[unk++] ="--";/* terminate the rev name */2383 argv[unk] = NULL;23842385init_revisions(&revs, NULL);2386setup_revisions(unk, argv, &revs, NULL);2387memset(&sb,0,sizeof(sb));23882389 final_commit_name =prepare_final(&sb, &revs);2390if(!sb.final) {2391/*2392 * "--not A B -- path" without anything positive;2393 * do not default to HEAD, but use the working tree2394 * or "--contents".2395 */2396setup_work_tree();2397 sb.final =fake_working_tree_commit(path, contents_from);2398add_pending_object(&revs, &(sb.final->object),":");2399}2400else if(contents_from)2401die("Cannot use --contents with final commit object name");24022403/*2404 * If we have bottom, this will mark the ancestors of the2405 * bottom commits we would reach while traversing as2406 * uninteresting.2407 */2408if(prepare_revision_walk(&revs))2409die("revision walk setup failed");24102411if(is_null_sha1(sb.final->object.sha1)) {2412char*buf;2413 o = sb.final->util;2414 buf =xmalloc(o->file.size +1);2415memcpy(buf, o->file.ptr, o->file.size +1);2416 sb.final_buf = buf;2417 sb.final_buf_size = o->file.size;2418}2419else{2420 o =get_origin(&sb, sb.final, path);2421if(fill_blob_sha1(o))2422die("no such path%sin%s", path, final_commit_name);24232424 sb.final_buf =read_sha1_file(o->blob_sha1, &type,2425&sb.final_buf_size);2426if(!sb.final_buf)2427die("Cannot read blob%sfor path%s",2428sha1_to_hex(o->blob_sha1),2429 path);2430}2431 num_read_blob++;2432 lno =prepare_lines(&sb);24332434 bottom = top =0;2435if(bottomtop)2436prepare_blame_range(&sb, bottomtop, lno, &bottom, &top);2437if(bottom && top && top < bottom) {2438long tmp;2439 tmp = top; top = bottom; bottom = tmp;2440}2441if(bottom <1)2442 bottom =1;2443if(top <1)2444 top = lno;2445 bottom--;2446if(lno < top)2447die("file%shas only%lu lines", path, lno);24482449 ent =xcalloc(1,sizeof(*ent));2450 ent->lno = bottom;2451 ent->num_lines = top - bottom;2452 ent->suspect = o;2453 ent->s_lno = bottom;24542455 sb.ent = ent;2456 sb.path = path;24572458if(revs_file &&read_ancestry(revs_file))2459die("reading graft file%sfailed:%s",2460 revs_file,strerror(errno));24612462read_mailmap(&mailmap,".mailmap", NULL);24632464if(!incremental)2465setup_pager();24662467assign_blame(&sb, &revs, opt);24682469if(incremental)2470return0;24712472coalesce(&sb);24732474if(!(output_option & OUTPUT_PORCELAIN))2475find_alignment(&sb, &output_option);24762477output(&sb, output_option);2478free((void*)sb.final_buf);2479for(ent = sb.ent; ent; ) {2480struct blame_entry *e = ent->next;2481free(ent);2482 ent = e;2483}24842485if(show_stats) {2486printf("num read blob:%d\n", num_read_blob);2487printf("num get patch:%d\n", num_get_patch);2488printf("num commits:%d\n", num_commits);2489}2490return0;2491}