1/* 2 * Blame 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"string-list.h" 20#include"mailmap.h" 21#include"parse-options.h" 22#include"utf8.h" 23 24static char blame_usage[] ="git blame [options] [rev-opts] [rev] [--] file"; 25 26static const char*blame_opt_usage[] = { 27 blame_usage, 28"", 29"[rev-opts] are documented in git-rev-list(1)", 30 NULL 31}; 32 33static int longest_file; 34static int longest_author; 35static int max_orig_digits; 36static int max_digits; 37static int max_score_digits; 38static int show_root; 39static int reverse; 40static int blank_boundary; 41static int incremental; 42static int xdl_opts; 43 44static enum date_mode blame_date_mode = DATE_ISO8601; 45static size_t blame_date_width; 46 47static struct string_list mailmap; 48 49#ifndef DEBUG 50#define DEBUG 0 51#endif 52 53/* stats */ 54static int num_read_blob; 55static int num_get_patch; 56static int num_commits; 57 58#define PICKAXE_BLAME_MOVE 01 59#define PICKAXE_BLAME_COPY 02 60#define PICKAXE_BLAME_COPY_HARDER 04 61#define PICKAXE_BLAME_COPY_HARDEST 010 62 63/* 64 * blame for a blame_entry with score lower than these thresholds 65 * is not passed to the parent using move/copy logic. 66 */ 67static unsigned blame_move_score; 68static unsigned blame_copy_score; 69#define BLAME_DEFAULT_MOVE_SCORE 20 70#define BLAME_DEFAULT_COPY_SCORE 40 71 72/* bits #0..7 in revision.h, #8..11 used for merge_bases() in commit.c */ 73#define METAINFO_SHOWN (1u<<12) 74#define MORE_THAN_ONE_PATH (1u<<13) 75 76/* 77 * One blob in a commit that is being suspected 78 */ 79struct origin { 80int refcnt; 81struct origin *previous; 82struct commit *commit; 83 mmfile_t file; 84unsigned char blob_sha1[20]; 85char path[FLEX_ARRAY]; 86}; 87 88/* 89 * Given an origin, prepare mmfile_t structure to be used by the 90 * diff machinery 91 */ 92static voidfill_origin_blob(struct origin *o, mmfile_t *file) 93{ 94if(!o->file.ptr) { 95enum object_type type; 96 num_read_blob++; 97 file->ptr =read_sha1_file(o->blob_sha1, &type, 98(unsigned long*)(&(file->size))); 99if(!file->ptr) 100die("Cannot read blob%sfor path%s", 101sha1_to_hex(o->blob_sha1), 102 o->path); 103 o->file = *file; 104} 105else 106*file = o->file; 107} 108 109/* 110 * Origin is refcounted and usually we keep the blob contents to be 111 * reused. 112 */ 113staticinlinestruct origin *origin_incref(struct origin *o) 114{ 115if(o) 116 o->refcnt++; 117return o; 118} 119 120static voidorigin_decref(struct origin *o) 121{ 122if(o && --o->refcnt <=0) { 123if(o->previous) 124origin_decref(o->previous); 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/* true if the entry has been scanned for copies in the current parent 164 */ 165char scanned; 166 167/* the line number of the first line of this group in the 168 * suspect's file; internally all line numbers are 0 based. 169 */ 170int s_lno; 171 172/* how significant this entry is -- cached to avoid 173 * scanning the lines over and over. 174 */ 175unsigned score; 176}; 177 178/* 179 * The current state of the blame assignment. 180 */ 181struct scoreboard { 182/* the final commit (i.e. where we started digging from) */ 183struct commit *final; 184struct rev_info *revs; 185const char*path; 186 187/* 188 * The contents in the final image. 189 * Used by many functions to obtain contents of the nth line, 190 * indexed with scoreboard.lineno[blame_entry.lno]. 191 */ 192const char*final_buf; 193unsigned long final_buf_size; 194 195/* linked list of blames */ 196struct blame_entry *ent; 197 198/* look-up a line in the final buffer */ 199int num_lines; 200int*lineno; 201}; 202 203staticinlineintsame_suspect(struct origin *a,struct origin *b) 204{ 205if(a == b) 206return1; 207if(a->commit != b->commit) 208return0; 209return!strcmp(a->path, b->path); 210} 211 212static voidsanity_check_refcnt(struct scoreboard *); 213 214/* 215 * If two blame entries that are next to each other came from 216 * contiguous lines in the same origin (i.e. <commit, path> pair), 217 * merge them together. 218 */ 219static voidcoalesce(struct scoreboard *sb) 220{ 221struct blame_entry *ent, *next; 222 223for(ent = sb->ent; ent && (next = ent->next); ent = next) { 224if(same_suspect(ent->suspect, next->suspect) && 225 ent->guilty == next->guilty && 226 ent->s_lno + ent->num_lines == next->s_lno) { 227 ent->num_lines += next->num_lines; 228 ent->next = next->next; 229if(ent->next) 230 ent->next->prev = ent; 231origin_decref(next->suspect); 232free(next); 233 ent->score =0; 234 next = ent;/* again */ 235} 236} 237 238if(DEBUG)/* sanity */ 239sanity_check_refcnt(sb); 240} 241 242/* 243 * Given a commit and a path in it, create a new origin structure. 244 * The callers that add blame to the scoreboard should use 245 * get_origin() to obtain shared, refcounted copy instead of calling 246 * this function directly. 247 */ 248static struct origin *make_origin(struct commit *commit,const char*path) 249{ 250struct origin *o; 251 o =xcalloc(1,sizeof(*o) +strlen(path) +1); 252 o->commit = commit; 253 o->refcnt =1; 254strcpy(o->path, path); 255return o; 256} 257 258/* 259 * Locate an existing origin or create a new one. 260 */ 261static struct origin *get_origin(struct scoreboard *sb, 262struct commit *commit, 263const char*path) 264{ 265struct blame_entry *e; 266 267for(e = sb->ent; e; e = e->next) { 268if(e->suspect->commit == commit && 269!strcmp(e->suspect->path, path)) 270returnorigin_incref(e->suspect); 271} 272returnmake_origin(commit, path); 273} 274 275/* 276 * Fill the blob_sha1 field of an origin if it hasn't, so that later 277 * call to fill_origin_blob() can use it to locate the data. blob_sha1 278 * for an origin is also used to pass the blame for the entire file to 279 * the parent to detect the case where a child's blob is identical to 280 * that of its parent's. 281 */ 282static intfill_blob_sha1(struct origin *origin) 283{ 284unsigned mode; 285 286if(!is_null_sha1(origin->blob_sha1)) 287return0; 288if(get_tree_entry(origin->commit->object.sha1, 289 origin->path, 290 origin->blob_sha1, &mode)) 291goto error_out; 292if(sha1_object_info(origin->blob_sha1, NULL) != OBJ_BLOB) 293goto error_out; 294return0; 295 error_out: 296hashclr(origin->blob_sha1); 297return-1; 298} 299 300/* 301 * We have an origin -- check if the same path exists in the 302 * parent and return an origin structure to represent it. 303 */ 304static struct origin *find_origin(struct scoreboard *sb, 305struct commit *parent, 306struct origin *origin) 307{ 308struct origin *porigin = NULL; 309struct diff_options diff_opts; 310const char*paths[2]; 311 312if(parent->util) { 313/* 314 * Each commit object can cache one origin in that 315 * commit. This is a freestanding copy of origin and 316 * not refcounted. 317 */ 318struct origin *cached = parent->util; 319if(!strcmp(cached->path, origin->path)) { 320/* 321 * The same path between origin and its parent 322 * without renaming -- the most common case. 323 */ 324 porigin =get_origin(sb, parent, cached->path); 325 326/* 327 * If the origin was newly created (i.e. get_origin 328 * would call make_origin if none is found in the 329 * scoreboard), it does not know the blob_sha1, 330 * so copy it. Otherwise porigin was in the 331 * scoreboard and already knows blob_sha1. 332 */ 333if(porigin->refcnt ==1) 334hashcpy(porigin->blob_sha1, cached->blob_sha1); 335return porigin; 336} 337/* otherwise it was not very useful; free it */ 338free(parent->util); 339 parent->util = NULL; 340} 341 342/* See if the origin->path is different between parent 343 * and origin first. Most of the time they are the 344 * same and diff-tree is fairly efficient about this. 345 */ 346diff_setup(&diff_opts); 347DIFF_OPT_SET(&diff_opts, RECURSIVE); 348 diff_opts.detect_rename =0; 349 diff_opts.output_format = DIFF_FORMAT_NO_OUTPUT; 350 paths[0] = origin->path; 351 paths[1] = NULL; 352 353diff_tree_setup_paths(paths, &diff_opts); 354if(diff_setup_done(&diff_opts) <0) 355die("diff-setup"); 356 357if(is_null_sha1(origin->commit->object.sha1)) 358do_diff_cache(parent->tree->object.sha1, &diff_opts); 359else 360diff_tree_sha1(parent->tree->object.sha1, 361 origin->commit->tree->object.sha1, 362"", &diff_opts); 363diffcore_std(&diff_opts); 364 365if(!diff_queued_diff.nr) { 366/* The path is the same as parent */ 367 porigin =get_origin(sb, parent, origin->path); 368hashcpy(porigin->blob_sha1, origin->blob_sha1); 369}else{ 370/* 371 * Since origin->path is a pathspec, if the parent 372 * commit had it as a directory, we will see a whole 373 * bunch of deletion of files in the directory that we 374 * do not care about. 375 */ 376int i; 377struct diff_filepair *p = NULL; 378for(i =0; i < diff_queued_diff.nr; i++) { 379const char*name; 380 p = diff_queued_diff.queue[i]; 381 name = p->one->path ? p->one->path : p->two->path; 382if(!strcmp(name, origin->path)) 383break; 384} 385if(!p) 386die("internal error in blame::find_origin"); 387switch(p->status) { 388default: 389die("internal error in blame::find_origin (%c)", 390 p->status); 391case'M': 392 porigin =get_origin(sb, parent, origin->path); 393hashcpy(porigin->blob_sha1, p->one->sha1); 394break; 395case'A': 396case'T': 397/* Did not exist in parent, or type changed */ 398break; 399} 400} 401diff_flush(&diff_opts); 402diff_tree_release_paths(&diff_opts); 403if(porigin) { 404/* 405 * Create a freestanding copy that is not part of 406 * the refcounted origin found in the scoreboard, and 407 * cache it in the commit. 408 */ 409struct origin *cached; 410 411 cached =make_origin(porigin->commit, porigin->path); 412hashcpy(cached->blob_sha1, porigin->blob_sha1); 413 parent->util = cached; 414} 415return porigin; 416} 417 418/* 419 * We have an origin -- find the path that corresponds to it in its 420 * parent and return an origin structure to represent it. 421 */ 422static struct origin *find_rename(struct scoreboard *sb, 423struct commit *parent, 424struct origin *origin) 425{ 426struct origin *porigin = NULL; 427struct diff_options diff_opts; 428int i; 429const char*paths[2]; 430 431diff_setup(&diff_opts); 432DIFF_OPT_SET(&diff_opts, RECURSIVE); 433 diff_opts.detect_rename = DIFF_DETECT_RENAME; 434 diff_opts.output_format = DIFF_FORMAT_NO_OUTPUT; 435 diff_opts.single_follow = origin->path; 436 paths[0] = NULL; 437diff_tree_setup_paths(paths, &diff_opts); 438if(diff_setup_done(&diff_opts) <0) 439die("diff-setup"); 440 441if(is_null_sha1(origin->commit->object.sha1)) 442do_diff_cache(parent->tree->object.sha1, &diff_opts); 443else 444diff_tree_sha1(parent->tree->object.sha1, 445 origin->commit->tree->object.sha1, 446"", &diff_opts); 447diffcore_std(&diff_opts); 448 449for(i =0; i < diff_queued_diff.nr; i++) { 450struct diff_filepair *p = diff_queued_diff.queue[i]; 451if((p->status =='R'|| p->status =='C') && 452!strcmp(p->two->path, origin->path)) { 453 porigin =get_origin(sb, parent, p->one->path); 454hashcpy(porigin->blob_sha1, p->one->sha1); 455break; 456} 457} 458diff_flush(&diff_opts); 459diff_tree_release_paths(&diff_opts); 460return porigin; 461} 462 463/* 464 * Link in a new blame entry to the scoreboard. Entries that cover the 465 * same line range have been removed from the scoreboard previously. 466 */ 467static voidadd_blame_entry(struct scoreboard *sb,struct blame_entry *e) 468{ 469struct blame_entry *ent, *prev = NULL; 470 471origin_incref(e->suspect); 472 473for(ent = sb->ent; ent && ent->lno < e->lno; ent = ent->next) 474 prev = ent; 475 476/* prev, if not NULL, is the last one that is below e */ 477 e->prev = prev; 478if(prev) { 479 e->next = prev->next; 480 prev->next = e; 481} 482else{ 483 e->next = sb->ent; 484 sb->ent = e; 485} 486if(e->next) 487 e->next->prev = e; 488} 489 490/* 491 * src typically is on-stack; we want to copy the information in it to 492 * a malloced blame_entry that is already on the linked list of the 493 * scoreboard. The origin of dst loses a refcnt while the origin of src 494 * gains one. 495 */ 496static voiddup_entry(struct blame_entry *dst,struct blame_entry *src) 497{ 498struct blame_entry *p, *n; 499 500 p = dst->prev; 501 n = dst->next; 502origin_incref(src->suspect); 503origin_decref(dst->suspect); 504memcpy(dst, src,sizeof(*src)); 505 dst->prev = p; 506 dst->next = n; 507 dst->score =0; 508} 509 510static const char*nth_line(struct scoreboard *sb,int lno) 511{ 512return sb->final_buf + sb->lineno[lno]; 513} 514 515/* 516 * It is known that lines between tlno to same came from parent, and e 517 * has an overlap with that range. it also is known that parent's 518 * line plno corresponds to e's line tlno. 519 * 520 * <---- e -----> 521 * <------> 522 * <------------> 523 * <------------> 524 * <------------------> 525 * 526 * Split e into potentially three parts; before this chunk, the chunk 527 * to be blamed for the parent, and after that portion. 528 */ 529static voidsplit_overlap(struct blame_entry *split, 530struct blame_entry *e, 531int tlno,int plno,int same, 532struct origin *parent) 533{ 534int chunk_end_lno; 535memset(split,0,sizeof(struct blame_entry [3])); 536 537if(e->s_lno < tlno) { 538/* there is a pre-chunk part not blamed on parent */ 539 split[0].suspect =origin_incref(e->suspect); 540 split[0].lno = e->lno; 541 split[0].s_lno = e->s_lno; 542 split[0].num_lines = tlno - e->s_lno; 543 split[1].lno = e->lno + tlno - e->s_lno; 544 split[1].s_lno = plno; 545} 546else{ 547 split[1].lno = e->lno; 548 split[1].s_lno = plno + (e->s_lno - tlno); 549} 550 551if(same < e->s_lno + e->num_lines) { 552/* there is a post-chunk part not blamed on parent */ 553 split[2].suspect =origin_incref(e->suspect); 554 split[2].lno = e->lno + (same - e->s_lno); 555 split[2].s_lno = e->s_lno + (same - e->s_lno); 556 split[2].num_lines = e->s_lno + e->num_lines - same; 557 chunk_end_lno = split[2].lno; 558} 559else 560 chunk_end_lno = e->lno + e->num_lines; 561 split[1].num_lines = chunk_end_lno - split[1].lno; 562 563/* 564 * if it turns out there is nothing to blame the parent for, 565 * forget about the splitting. !split[1].suspect signals this. 566 */ 567if(split[1].num_lines <1) 568return; 569 split[1].suspect =origin_incref(parent); 570} 571 572/* 573 * split_overlap() divided an existing blame e into up to three parts 574 * in split. Adjust the linked list of blames in the scoreboard to 575 * reflect the split. 576 */ 577static voidsplit_blame(struct scoreboard *sb, 578struct blame_entry *split, 579struct blame_entry *e) 580{ 581struct blame_entry *new_entry; 582 583if(split[0].suspect && split[2].suspect) { 584/* The first part (reuse storage for the existing entry e) */ 585dup_entry(e, &split[0]); 586 587/* The last part -- me */ 588 new_entry =xmalloc(sizeof(*new_entry)); 589memcpy(new_entry, &(split[2]),sizeof(struct blame_entry)); 590add_blame_entry(sb, new_entry); 591 592/* ... and the middle part -- parent */ 593 new_entry =xmalloc(sizeof(*new_entry)); 594memcpy(new_entry, &(split[1]),sizeof(struct blame_entry)); 595add_blame_entry(sb, new_entry); 596} 597else if(!split[0].suspect && !split[2].suspect) 598/* 599 * The parent covers the entire area; reuse storage for 600 * e and replace it with the parent. 601 */ 602dup_entry(e, &split[1]); 603else if(split[0].suspect) { 604/* me and then parent */ 605dup_entry(e, &split[0]); 606 607 new_entry =xmalloc(sizeof(*new_entry)); 608memcpy(new_entry, &(split[1]),sizeof(struct blame_entry)); 609add_blame_entry(sb, new_entry); 610} 611else{ 612/* parent and then me */ 613dup_entry(e, &split[1]); 614 615 new_entry =xmalloc(sizeof(*new_entry)); 616memcpy(new_entry, &(split[2]),sizeof(struct blame_entry)); 617add_blame_entry(sb, new_entry); 618} 619 620if(DEBUG) {/* sanity */ 621struct blame_entry *ent; 622int lno = sb->ent->lno, corrupt =0; 623 624for(ent = sb->ent; ent; ent = ent->next) { 625if(lno != ent->lno) 626 corrupt =1; 627if(ent->s_lno <0) 628 corrupt =1; 629 lno += ent->num_lines; 630} 631if(corrupt) { 632 lno = sb->ent->lno; 633for(ent = sb->ent; ent; ent = ent->next) { 634printf("L%8d l%8d n%8d\n", 635 lno, ent->lno, ent->num_lines); 636 lno = ent->lno + ent->num_lines; 637} 638die("oops"); 639} 640} 641} 642 643/* 644 * After splitting the blame, the origins used by the 645 * on-stack blame_entry should lose one refcnt each. 646 */ 647static voiddecref_split(struct blame_entry *split) 648{ 649int i; 650 651for(i =0; i <3; i++) 652origin_decref(split[i].suspect); 653} 654 655/* 656 * Helper for blame_chunk(). blame_entry e is known to overlap with 657 * the patch hunk; split it and pass blame to the parent. 658 */ 659static voidblame_overlap(struct scoreboard *sb,struct blame_entry *e, 660int tlno,int plno,int same, 661struct origin *parent) 662{ 663struct blame_entry split[3]; 664 665split_overlap(split, e, tlno, plno, same, parent); 666if(split[1].suspect) 667split_blame(sb, split, e); 668decref_split(split); 669} 670 671/* 672 * Find the line number of the last line the target is suspected for. 673 */ 674static intfind_last_in_target(struct scoreboard *sb,struct origin *target) 675{ 676struct blame_entry *e; 677int last_in_target = -1; 678 679for(e = sb->ent; e; e = e->next) { 680if(e->guilty || !same_suspect(e->suspect, target)) 681continue; 682if(last_in_target < e->s_lno + e->num_lines) 683 last_in_target = e->s_lno + e->num_lines; 684} 685return last_in_target; 686} 687 688/* 689 * Process one hunk from the patch between the current suspect for 690 * blame_entry e and its parent. Find and split the overlap, and 691 * pass blame to the overlapping part to the parent. 692 */ 693static voidblame_chunk(struct scoreboard *sb, 694int tlno,int plno,int same, 695struct origin *target,struct origin *parent) 696{ 697struct blame_entry *e; 698 699for(e = sb->ent; e; e = e->next) { 700if(e->guilty || !same_suspect(e->suspect, target)) 701continue; 702if(same <= e->s_lno) 703continue; 704if(tlno < e->s_lno + e->num_lines) 705blame_overlap(sb, e, tlno, plno, same, parent); 706} 707} 708 709struct blame_chunk_cb_data { 710struct scoreboard *sb; 711struct origin *target; 712struct origin *parent; 713long plno; 714long tlno; 715}; 716 717static voidblame_chunk_cb(void*data,long same,long p_next,long t_next) 718{ 719struct blame_chunk_cb_data *d = data; 720blame_chunk(d->sb, d->tlno, d->plno, same, d->target, d->parent); 721 d->plno = p_next; 722 d->tlno = t_next; 723} 724 725/* 726 * We are looking at the origin 'target' and aiming to pass blame 727 * for the lines it is suspected to its parent. Run diff to find 728 * which lines came from parent and pass blame for them. 729 */ 730static intpass_blame_to_parent(struct scoreboard *sb, 731struct origin *target, 732struct origin *parent) 733{ 734int last_in_target; 735 mmfile_t file_p, file_o; 736struct blame_chunk_cb_data d; 737 xpparam_t xpp; 738 xdemitconf_t xecfg; 739memset(&d,0,sizeof(d)); 740 d.sb = sb; d.target = target; d.parent = parent; 741 last_in_target =find_last_in_target(sb, target); 742if(last_in_target <0) 743return1;/* nothing remains for this target */ 744 745fill_origin_blob(parent, &file_p); 746fill_origin_blob(target, &file_o); 747 num_get_patch++; 748 749memset(&xpp,0,sizeof(xpp)); 750 xpp.flags = xdl_opts; 751memset(&xecfg,0,sizeof(xecfg)); 752 xecfg.ctxlen =0; 753xdi_diff_hunks(&file_p, &file_o, blame_chunk_cb, &d, &xpp, &xecfg); 754/* The rest (i.e. anything after tlno) are the same as the parent */ 755blame_chunk(sb, d.tlno, d.plno, last_in_target, target, parent); 756 757return0; 758} 759 760/* 761 * The lines in blame_entry after splitting blames many times can become 762 * very small and trivial, and at some point it becomes pointless to 763 * blame the parents. E.g. "\t\t}\n\t}\n\n" appears everywhere in any 764 * ordinary C program, and it is not worth to say it was copied from 765 * totally unrelated file in the parent. 766 * 767 * Compute how trivial the lines in the blame_entry are. 768 */ 769static unsignedent_score(struct scoreboard *sb,struct blame_entry *e) 770{ 771unsigned score; 772const char*cp, *ep; 773 774if(e->score) 775return e->score; 776 777 score =1; 778 cp =nth_line(sb, e->lno); 779 ep =nth_line(sb, e->lno + e->num_lines); 780while(cp < ep) { 781unsigned ch = *((unsigned char*)cp); 782if(isalnum(ch)) 783 score++; 784 cp++; 785} 786 e->score = score; 787return score; 788} 789 790/* 791 * best_so_far[] and this[] are both a split of an existing blame_entry 792 * that passes blame to the parent. Maintain best_so_far the best split 793 * so far, by comparing this and best_so_far and copying this into 794 * bst_so_far as needed. 795 */ 796static voidcopy_split_if_better(struct scoreboard *sb, 797struct blame_entry *best_so_far, 798struct blame_entry *this) 799{ 800int i; 801 802if(!this[1].suspect) 803return; 804if(best_so_far[1].suspect) { 805if(ent_score(sb, &this[1]) <ent_score(sb, &best_so_far[1])) 806return; 807} 808 809for(i =0; i <3; i++) 810origin_incref(this[i].suspect); 811decref_split(best_so_far); 812memcpy(best_so_far,this,sizeof(struct blame_entry [3])); 813} 814 815/* 816 * We are looking at a part of the final image represented by 817 * ent (tlno and same are offset by ent->s_lno). 818 * tlno is where we are looking at in the final image. 819 * up to (but not including) same match preimage. 820 * plno is where we are looking at in the preimage. 821 * 822 * <-------------- final image ----------------------> 823 * <------ent------> 824 * ^tlno ^same 825 * <---------preimage-----> 826 * ^plno 827 * 828 * All line numbers are 0-based. 829 */ 830static voidhandle_split(struct scoreboard *sb, 831struct blame_entry *ent, 832int tlno,int plno,int same, 833struct origin *parent, 834struct blame_entry *split) 835{ 836if(ent->num_lines <= tlno) 837return; 838if(tlno < same) { 839struct blame_entry this[3]; 840 tlno += ent->s_lno; 841 same += ent->s_lno; 842split_overlap(this, ent, tlno, plno, same, parent); 843copy_split_if_better(sb, split,this); 844decref_split(this); 845} 846} 847 848struct handle_split_cb_data { 849struct scoreboard *sb; 850struct blame_entry *ent; 851struct origin *parent; 852struct blame_entry *split; 853long plno; 854long tlno; 855}; 856 857static voidhandle_split_cb(void*data,long same,long p_next,long t_next) 858{ 859struct handle_split_cb_data *d = data; 860handle_split(d->sb, d->ent, d->tlno, d->plno, same, d->parent, d->split); 861 d->plno = p_next; 862 d->tlno = t_next; 863} 864 865/* 866 * Find the lines from parent that are the same as ent so that 867 * we can pass blames to it. file_p has the blob contents for 868 * the parent. 869 */ 870static voidfind_copy_in_blob(struct scoreboard *sb, 871struct blame_entry *ent, 872struct origin *parent, 873struct blame_entry *split, 874 mmfile_t *file_p) 875{ 876const char*cp; 877int cnt; 878 mmfile_t file_o; 879struct handle_split_cb_data d; 880 xpparam_t xpp; 881 xdemitconf_t xecfg; 882memset(&d,0,sizeof(d)); 883 d.sb = sb; d.ent = ent; d.parent = parent; d.split = split; 884/* 885 * Prepare mmfile that contains only the lines in ent. 886 */ 887 cp =nth_line(sb, ent->lno); 888 file_o.ptr = (char*) cp; 889 cnt = ent->num_lines; 890 891while(cnt && cp < sb->final_buf + sb->final_buf_size) { 892if(*cp++ =='\n') 893 cnt--; 894} 895 file_o.size = cp - file_o.ptr; 896 897/* 898 * file_o is a part of final image we are annotating. 899 * file_p partially may match that image. 900 */ 901memset(&xpp,0,sizeof(xpp)); 902 xpp.flags = xdl_opts; 903memset(&xecfg,0,sizeof(xecfg)); 904 xecfg.ctxlen =1; 905memset(split,0,sizeof(struct blame_entry [3])); 906xdi_diff_hunks(file_p, &file_o, handle_split_cb, &d, &xpp, &xecfg); 907/* remainder, if any, all match the preimage */ 908handle_split(sb, ent, d.tlno, d.plno, ent->num_lines, parent, split); 909} 910 911/* 912 * See if lines currently target is suspected for can be attributed to 913 * parent. 914 */ 915static intfind_move_in_parent(struct scoreboard *sb, 916struct origin *target, 917struct origin *parent) 918{ 919int last_in_target, made_progress; 920struct blame_entry *e, split[3]; 921 mmfile_t file_p; 922 923 last_in_target =find_last_in_target(sb, target); 924if(last_in_target <0) 925return1;/* nothing remains for this target */ 926 927fill_origin_blob(parent, &file_p); 928if(!file_p.ptr) 929return0; 930 931 made_progress =1; 932while(made_progress) { 933 made_progress =0; 934for(e = sb->ent; e; e = e->next) { 935if(e->guilty || !same_suspect(e->suspect, target) || 936ent_score(sb, e) < blame_move_score) 937continue; 938find_copy_in_blob(sb, e, parent, split, &file_p); 939if(split[1].suspect && 940 blame_move_score <ent_score(sb, &split[1])) { 941split_blame(sb, split, e); 942 made_progress =1; 943} 944decref_split(split); 945} 946} 947return0; 948} 949 950struct blame_list { 951struct blame_entry *ent; 952struct blame_entry split[3]; 953}; 954 955/* 956 * Count the number of entries the target is suspected for, 957 * and prepare a list of entry and the best split. 958 */ 959static struct blame_list *setup_blame_list(struct scoreboard *sb, 960struct origin *target, 961int min_score, 962int*num_ents_p) 963{ 964struct blame_entry *e; 965int num_ents, i; 966struct blame_list *blame_list = NULL; 967 968for(e = sb->ent, num_ents =0; e; e = e->next) 969if(!e->scanned && !e->guilty && 970same_suspect(e->suspect, target) && 971 min_score <ent_score(sb, e)) 972 num_ents++; 973if(num_ents) { 974 blame_list =xcalloc(num_ents,sizeof(struct blame_list)); 975for(e = sb->ent, i =0; e; e = e->next) 976if(!e->scanned && !e->guilty && 977same_suspect(e->suspect, target) && 978 min_score <ent_score(sb, e)) 979 blame_list[i++].ent = e; 980} 981*num_ents_p = num_ents; 982return blame_list; 983} 984 985/* 986 * Reset the scanned status on all entries. 987 */ 988static voidreset_scanned_flag(struct scoreboard *sb) 989{ 990struct blame_entry *e; 991for(e = sb->ent; e; e = e->next) 992 e->scanned =0; 993} 994 995/* 996 * For lines target is suspected for, see if we can find code movement 997 * across file boundary from the parent commit. porigin is the path 998 * in the parent we already tried. 999 */1000static intfind_copy_in_parent(struct scoreboard *sb,1001struct origin *target,1002struct commit *parent,1003struct origin *porigin,1004int opt)1005{1006struct diff_options diff_opts;1007const char*paths[1];1008int i, j;1009int retval;1010struct blame_list *blame_list;1011int num_ents;10121013 blame_list =setup_blame_list(sb, target, blame_copy_score, &num_ents);1014if(!blame_list)1015return1;/* nothing remains for this target */10161017diff_setup(&diff_opts);1018DIFF_OPT_SET(&diff_opts, RECURSIVE);1019 diff_opts.output_format = DIFF_FORMAT_NO_OUTPUT;10201021 paths[0] = NULL;1022diff_tree_setup_paths(paths, &diff_opts);1023if(diff_setup_done(&diff_opts) <0)1024die("diff-setup");10251026/* Try "find copies harder" on new path if requested;1027 * we do not want to use diffcore_rename() actually to1028 * match things up; find_copies_harder is set only to1029 * force diff_tree_sha1() to feed all filepairs to diff_queue,1030 * and this code needs to be after diff_setup_done(), which1031 * usually makes find-copies-harder imply copy detection.1032 */1033if((opt & PICKAXE_BLAME_COPY_HARDEST)1034|| ((opt & PICKAXE_BLAME_COPY_HARDER)1035&& (!porigin ||strcmp(target->path, porigin->path))))1036DIFF_OPT_SET(&diff_opts, FIND_COPIES_HARDER);10371038if(is_null_sha1(target->commit->object.sha1))1039do_diff_cache(parent->tree->object.sha1, &diff_opts);1040else1041diff_tree_sha1(parent->tree->object.sha1,1042 target->commit->tree->object.sha1,1043"", &diff_opts);10441045if(!DIFF_OPT_TST(&diff_opts, FIND_COPIES_HARDER))1046diffcore_std(&diff_opts);10471048 retval =0;1049while(1) {1050int made_progress =0;10511052for(i =0; i < diff_queued_diff.nr; i++) {1053struct diff_filepair *p = diff_queued_diff.queue[i];1054struct origin *norigin;1055 mmfile_t file_p;1056struct blame_entry this[3];10571058if(!DIFF_FILE_VALID(p->one))1059continue;/* does not exist in parent */1060if(S_ISGITLINK(p->one->mode))1061continue;/* ignore git links */1062if(porigin && !strcmp(p->one->path, porigin->path))1063/* find_move already dealt with this path */1064continue;10651066 norigin =get_origin(sb, parent, p->one->path);1067hashcpy(norigin->blob_sha1, p->one->sha1);1068fill_origin_blob(norigin, &file_p);1069if(!file_p.ptr)1070continue;10711072for(j =0; j < num_ents; j++) {1073find_copy_in_blob(sb, blame_list[j].ent,1074 norigin,this, &file_p);1075copy_split_if_better(sb, blame_list[j].split,1076this);1077decref_split(this);1078}1079origin_decref(norigin);1080}10811082for(j =0; j < num_ents; j++) {1083struct blame_entry *split = blame_list[j].split;1084if(split[1].suspect &&1085 blame_copy_score <ent_score(sb, &split[1])) {1086split_blame(sb, split, blame_list[j].ent);1087 made_progress =1;1088}1089else1090 blame_list[j].ent->scanned =1;1091decref_split(split);1092}1093free(blame_list);10941095if(!made_progress)1096break;1097 blame_list =setup_blame_list(sb, target, blame_copy_score, &num_ents);1098if(!blame_list) {1099 retval =1;1100break;1101}1102}1103reset_scanned_flag(sb);1104diff_flush(&diff_opts);1105diff_tree_release_paths(&diff_opts);1106return retval;1107}11081109/*1110 * The blobs of origin and porigin exactly match, so everything1111 * origin is suspected for can be blamed on the parent.1112 */1113static voidpass_whole_blame(struct scoreboard *sb,1114struct origin *origin,struct origin *porigin)1115{1116struct blame_entry *e;11171118if(!porigin->file.ptr && origin->file.ptr) {1119/* Steal its file */1120 porigin->file = origin->file;1121 origin->file.ptr = NULL;1122}1123for(e = sb->ent; e; e = e->next) {1124if(!same_suspect(e->suspect, origin))1125continue;1126origin_incref(porigin);1127origin_decref(e->suspect);1128 e->suspect = porigin;1129}1130}11311132/*1133 * We pass blame from the current commit to its parents. We keep saying1134 * "parent" (and "porigin"), but what we mean is to find scapegoat to1135 * exonerate ourselves.1136 */1137static struct commit_list *first_scapegoat(struct rev_info *revs,struct commit *commit)1138{1139if(!reverse)1140return commit->parents;1141returnlookup_decoration(&revs->children, &commit->object);1142}11431144static intnum_scapegoats(struct rev_info *revs,struct commit *commit)1145{1146int cnt;1147struct commit_list *l =first_scapegoat(revs, commit);1148for(cnt =0; l; l = l->next)1149 cnt++;1150return cnt;1151}11521153#define MAXSG 1611541155static voidpass_blame(struct scoreboard *sb,struct origin *origin,int opt)1156{1157struct rev_info *revs = sb->revs;1158int i, pass, num_sg;1159struct commit *commit = origin->commit;1160struct commit_list *sg;1161struct origin *sg_buf[MAXSG];1162struct origin *porigin, **sg_origin = sg_buf;11631164 num_sg =num_scapegoats(revs, commit);1165if(!num_sg)1166goto finish;1167else if(num_sg <ARRAY_SIZE(sg_buf))1168memset(sg_buf,0,sizeof(sg_buf));1169else1170 sg_origin =xcalloc(num_sg,sizeof(*sg_origin));11711172/*1173 * The first pass looks for unrenamed path to optimize for1174 * common cases, then we look for renames in the second pass.1175 */1176for(pass =0; pass <2; pass++) {1177struct origin *(*find)(struct scoreboard *,1178struct commit *,struct origin *);1179 find = pass ? find_rename : find_origin;11801181for(i =0, sg =first_scapegoat(revs, commit);1182 i < num_sg && sg;1183 sg = sg->next, i++) {1184struct commit *p = sg->item;1185int j, same;11861187if(sg_origin[i])1188continue;1189if(parse_commit(p))1190continue;1191 porigin =find(sb, p, origin);1192if(!porigin)1193continue;1194if(!hashcmp(porigin->blob_sha1, origin->blob_sha1)) {1195pass_whole_blame(sb, origin, porigin);1196origin_decref(porigin);1197goto finish;1198}1199for(j = same =0; j < i; j++)1200if(sg_origin[j] &&1201!hashcmp(sg_origin[j]->blob_sha1,1202 porigin->blob_sha1)) {1203 same =1;1204break;1205}1206if(!same)1207 sg_origin[i] = porigin;1208else1209origin_decref(porigin);1210}1211}12121213 num_commits++;1214for(i =0, sg =first_scapegoat(revs, commit);1215 i < num_sg && sg;1216 sg = sg->next, i++) {1217struct origin *porigin = sg_origin[i];1218if(!porigin)1219continue;1220if(!origin->previous) {1221origin_incref(porigin);1222 origin->previous = porigin;1223}1224if(pass_blame_to_parent(sb, origin, porigin))1225goto finish;1226}12271228/*1229 * Optionally find moves in parents' files.1230 */1231if(opt & PICKAXE_BLAME_MOVE)1232for(i =0, sg =first_scapegoat(revs, commit);1233 i < num_sg && sg;1234 sg = sg->next, i++) {1235struct origin *porigin = sg_origin[i];1236if(!porigin)1237continue;1238if(find_move_in_parent(sb, origin, porigin))1239goto finish;1240}12411242/*1243 * Optionally find copies from parents' files.1244 */1245if(opt & PICKAXE_BLAME_COPY)1246for(i =0, sg =first_scapegoat(revs, commit);1247 i < num_sg && sg;1248 sg = sg->next, i++) {1249struct origin *porigin = sg_origin[i];1250if(find_copy_in_parent(sb, origin, sg->item,1251 porigin, opt))1252goto finish;1253}12541255 finish:1256for(i =0; i < num_sg; i++) {1257if(sg_origin[i]) {1258drop_origin_blob(sg_origin[i]);1259origin_decref(sg_origin[i]);1260}1261}1262drop_origin_blob(origin);1263if(sg_buf != sg_origin)1264free(sg_origin);1265}12661267/*1268 * Information on commits, used for output.1269 */1270struct commit_info1271{1272const char*author;1273const char*author_mail;1274unsigned long author_time;1275const char*author_tz;12761277/* filled only when asked for details */1278const char*committer;1279const char*committer_mail;1280unsigned long committer_time;1281const char*committer_tz;12821283const char*summary;1284};12851286/*1287 * Parse author/committer line in the commit object buffer1288 */1289static voidget_ac_line(const char*inbuf,const char*what,1290int person_len,char*person,1291int mail_len,char*mail,1292unsigned long*time,const char**tz)1293{1294int len, tzlen, maillen;1295char*tmp, *endp, *timepos, *mailpos;12961297 tmp =strstr(inbuf, what);1298if(!tmp)1299goto error_out;1300 tmp +=strlen(what);1301 endp =strchr(tmp,'\n');1302if(!endp)1303 len =strlen(tmp);1304else1305 len = endp - tmp;1306if(person_len <= len) {1307 error_out:1308/* Ugh */1309*tz ="(unknown)";1310strcpy(person, *tz);1311strcpy(mail, *tz);1312*time =0;1313return;1314}1315memcpy(person, tmp, len);13161317 tmp = person;1318 tmp += len;1319*tmp =0;1320while(person < tmp && *tmp !=' ')1321 tmp--;1322if(tmp <= person)1323goto error_out;1324*tz = tmp+1;1325 tzlen = (person+len)-(tmp+1);13261327*tmp =0;1328while(person < tmp && *tmp !=' ')1329 tmp--;1330if(tmp <= person)1331goto error_out;1332*time =strtoul(tmp, NULL,10);1333 timepos = tmp;13341335*tmp =0;1336while(person < tmp && *tmp !=' ')1337 tmp--;1338if(tmp <= person)1339return;1340 mailpos = tmp +1;1341*tmp =0;1342 maillen = timepos - tmp;1343memcpy(mail, mailpos, maillen);13441345if(!mailmap.nr)1346return;13471348/*1349 * mailmap expansion may make the name longer.1350 * make room by pushing stuff down.1351 */1352 tmp = person + person_len - (tzlen +1);1353memmove(tmp, *tz, tzlen);1354 tmp[tzlen] =0;1355*tz = tmp;13561357/*1358 * Now, convert both name and e-mail using mailmap1359 */1360if(map_user(&mailmap, mail+1, mail_len-1, person, tmp-person-1)) {1361/* Add a trailing '>' to email, since map_user returns plain emails1362 Note: It already has '<', since we replace from mail+1 */1363 mailpos =memchr(mail,'\0', mail_len);1364if(mailpos && mailpos-mail < mail_len -1) {1365*mailpos ='>';1366*(mailpos+1) ='\0';1367}1368}1369}13701371static voidget_commit_info(struct commit *commit,1372struct commit_info *ret,1373int detailed)1374{1375int len;1376char*tmp, *endp, *reencoded, *message;1377static char author_name[1024];1378static char author_mail[1024];1379static char committer_name[1024];1380static char committer_mail[1024];1381static char summary_buf[1024];13821383/*1384 * We've operated without save_commit_buffer, so1385 * we now need to populate them for output.1386 */1387if(!commit->buffer) {1388enum object_type type;1389unsigned long size;1390 commit->buffer =1391read_sha1_file(commit->object.sha1, &type, &size);1392if(!commit->buffer)1393die("Cannot read commit%s",1394sha1_to_hex(commit->object.sha1));1395}1396 reencoded =reencode_commit_message(commit, NULL);1397 message = reencoded ? reencoded : commit->buffer;1398 ret->author = author_name;1399 ret->author_mail = author_mail;1400get_ac_line(message,"\nauthor ",1401sizeof(author_name), author_name,1402sizeof(author_mail), author_mail,1403&ret->author_time, &ret->author_tz);14041405if(!detailed) {1406free(reencoded);1407return;1408}14091410 ret->committer = committer_name;1411 ret->committer_mail = committer_mail;1412get_ac_line(message,"\ncommitter ",1413sizeof(committer_name), committer_name,1414sizeof(committer_mail), committer_mail,1415&ret->committer_time, &ret->committer_tz);14161417 ret->summary = summary_buf;1418 tmp =strstr(message,"\n\n");1419if(!tmp) {1420 error_out:1421sprintf(summary_buf,"(%s)",sha1_to_hex(commit->object.sha1));1422free(reencoded);1423return;1424}1425 tmp +=2;1426 endp =strchr(tmp,'\n');1427if(!endp)1428 endp = tmp +strlen(tmp);1429 len = endp - tmp;1430if(len >=sizeof(summary_buf) || len ==0)1431goto error_out;1432memcpy(summary_buf, tmp, len);1433 summary_buf[len] =0;1434free(reencoded);1435}14361437/*1438 * To allow LF and other nonportable characters in pathnames,1439 * they are c-style quoted as needed.1440 */1441static voidwrite_filename_info(const char*path)1442{1443printf("filename ");1444write_name_quoted(path, stdout,'\n');1445}14461447/*1448 * Porcelain/Incremental format wants to show a lot of details per1449 * commit. Instead of repeating this every line, emit it only once,1450 * the first time each commit appears in the output.1451 */1452static intemit_one_suspect_detail(struct origin *suspect)1453{1454struct commit_info ci;14551456if(suspect->commit->object.flags & METAINFO_SHOWN)1457return0;14581459 suspect->commit->object.flags |= METAINFO_SHOWN;1460get_commit_info(suspect->commit, &ci,1);1461printf("author%s\n", ci.author);1462printf("author-mail%s\n", ci.author_mail);1463printf("author-time%lu\n", ci.author_time);1464printf("author-tz%s\n", ci.author_tz);1465printf("committer%s\n", ci.committer);1466printf("committer-mail%s\n", ci.committer_mail);1467printf("committer-time%lu\n", ci.committer_time);1468printf("committer-tz%s\n", ci.committer_tz);1469printf("summary%s\n", ci.summary);1470if(suspect->commit->object.flags & UNINTERESTING)1471printf("boundary\n");1472if(suspect->previous) {1473struct origin *prev = suspect->previous;1474printf("previous%s",sha1_to_hex(prev->commit->object.sha1));1475write_name_quoted(prev->path, stdout,'\n');1476}1477return1;1478}14791480/*1481 * The blame_entry is found to be guilty for the range. Mark it1482 * as such, and show it in incremental output.1483 */1484static voidfound_guilty_entry(struct blame_entry *ent)1485{1486if(ent->guilty)1487return;1488 ent->guilty =1;1489if(incremental) {1490struct origin *suspect = ent->suspect;14911492printf("%s %d %d %d\n",1493sha1_to_hex(suspect->commit->object.sha1),1494 ent->s_lno +1, ent->lno +1, ent->num_lines);1495emit_one_suspect_detail(suspect);1496write_filename_info(suspect->path);1497maybe_flush_or_die(stdout,"stdout");1498}1499}15001501/*1502 * The main loop -- while the scoreboard has lines whose true origin1503 * is still unknown, pick one blame_entry, and allow its current1504 * suspect to pass blames to its parents.1505 */1506static voidassign_blame(struct scoreboard *sb,int opt)1507{1508struct rev_info *revs = sb->revs;15091510while(1) {1511struct blame_entry *ent;1512struct commit *commit;1513struct origin *suspect = NULL;15141515/* find one suspect to break down */1516for(ent = sb->ent; !suspect && ent; ent = ent->next)1517if(!ent->guilty)1518 suspect = ent->suspect;1519if(!suspect)1520return;/* all done */15211522/*1523 * We will use this suspect later in the loop,1524 * so hold onto it in the meantime.1525 */1526origin_incref(suspect);1527 commit = suspect->commit;1528if(!commit->object.parsed)1529parse_commit(commit);1530if(reverse ||1531(!(commit->object.flags & UNINTERESTING) &&1532!(revs->max_age != -1&& commit->date < revs->max_age)))1533pass_blame(sb, suspect, opt);1534else{1535 commit->object.flags |= UNINTERESTING;1536if(commit->object.parsed)1537mark_parents_uninteresting(commit);1538}1539/* treat root commit as boundary */1540if(!commit->parents && !show_root)1541 commit->object.flags |= UNINTERESTING;15421543/* Take responsibility for the remaining entries */1544for(ent = sb->ent; ent; ent = ent->next)1545if(same_suspect(ent->suspect, suspect))1546found_guilty_entry(ent);1547origin_decref(suspect);15481549if(DEBUG)/* sanity */1550sanity_check_refcnt(sb);1551}1552}15531554static const char*format_time(unsigned long time,const char*tz_str,1555int show_raw_time)1556{1557static char time_buf[128];1558const char*time_str;1559int time_len;1560int tz;15611562if(show_raw_time) {1563sprintf(time_buf,"%lu%s", time, tz_str);1564}1565else{1566 tz =atoi(tz_str);1567 time_str =show_date(time, tz, blame_date_mode);1568 time_len =strlen(time_str);1569memcpy(time_buf, time_str, time_len);1570memset(time_buf + time_len,' ', blame_date_width - time_len);1571}1572return time_buf;1573}15741575#define OUTPUT_ANNOTATE_COMPAT 0011576#define OUTPUT_LONG_OBJECT_NAME 0021577#define OUTPUT_RAW_TIMESTAMP 0041578#define OUTPUT_PORCELAIN 0101579#define OUTPUT_SHOW_NAME 0201580#define OUTPUT_SHOW_NUMBER 0401581#define OUTPUT_SHOW_SCORE 01001582#define OUTPUT_NO_AUTHOR 020015831584static voidemit_porcelain(struct scoreboard *sb,struct blame_entry *ent)1585{1586int cnt;1587const char*cp;1588struct origin *suspect = ent->suspect;1589char hex[41];15901591strcpy(hex,sha1_to_hex(suspect->commit->object.sha1));1592printf("%s%c%d %d %d\n",1593 hex,1594 ent->guilty ?' ':'*',/* purely for debugging */1595 ent->s_lno +1,1596 ent->lno +1,1597 ent->num_lines);1598if(emit_one_suspect_detail(suspect) ||1599(suspect->commit->object.flags & MORE_THAN_ONE_PATH))1600write_filename_info(suspect->path);16011602 cp =nth_line(sb, ent->lno);1603for(cnt =0; cnt < ent->num_lines; cnt++) {1604char ch;1605if(cnt)1606printf("%s %d %d\n", hex,1607 ent->s_lno +1+ cnt,1608 ent->lno +1+ cnt);1609putchar('\t');1610do{1611 ch = *cp++;1612putchar(ch);1613}while(ch !='\n'&&1614 cp < sb->final_buf + sb->final_buf_size);1615}16161617if(sb->final_buf_size && cp[-1] !='\n')1618putchar('\n');1619}16201621static voidemit_other(struct scoreboard *sb,struct blame_entry *ent,int opt)1622{1623int cnt;1624const char*cp;1625struct origin *suspect = ent->suspect;1626struct commit_info ci;1627char hex[41];1628int show_raw_time = !!(opt & OUTPUT_RAW_TIMESTAMP);16291630get_commit_info(suspect->commit, &ci,1);1631strcpy(hex,sha1_to_hex(suspect->commit->object.sha1));16321633 cp =nth_line(sb, ent->lno);1634for(cnt =0; cnt < ent->num_lines; cnt++) {1635char ch;1636int length = (opt & OUTPUT_LONG_OBJECT_NAME) ?40:8;16371638if(suspect->commit->object.flags & UNINTERESTING) {1639if(blank_boundary)1640memset(hex,' ', length);1641else if(!(opt & OUTPUT_ANNOTATE_COMPAT)) {1642 length--;1643putchar('^');1644}1645}16461647printf("%.*s", length, hex);1648if(opt & OUTPUT_ANNOTATE_COMPAT)1649printf("\t(%10s\t%10s\t%d)", ci.author,1650format_time(ci.author_time, ci.author_tz,1651 show_raw_time),1652 ent->lno +1+ cnt);1653else{1654if(opt & OUTPUT_SHOW_SCORE)1655printf(" %*d%02d",1656 max_score_digits, ent->score,1657 ent->suspect->refcnt);1658if(opt & OUTPUT_SHOW_NAME)1659printf(" %-*.*s", longest_file, longest_file,1660 suspect->path);1661if(opt & OUTPUT_SHOW_NUMBER)1662printf(" %*d", max_orig_digits,1663 ent->s_lno +1+ cnt);16641665if(!(opt & OUTPUT_NO_AUTHOR)) {1666int pad = longest_author -utf8_strwidth(ci.author);1667printf(" (%s%*s%10s",1668 ci.author, pad,"",1669format_time(ci.author_time,1670 ci.author_tz,1671 show_raw_time));1672}1673printf(" %*d) ",1674 max_digits, ent->lno +1+ cnt);1675}1676do{1677 ch = *cp++;1678putchar(ch);1679}while(ch !='\n'&&1680 cp < sb->final_buf + sb->final_buf_size);1681}16821683if(sb->final_buf_size && cp[-1] !='\n')1684putchar('\n');1685}16861687static voidoutput(struct scoreboard *sb,int option)1688{1689struct blame_entry *ent;16901691if(option & OUTPUT_PORCELAIN) {1692for(ent = sb->ent; ent; ent = ent->next) {1693struct blame_entry *oth;1694struct origin *suspect = ent->suspect;1695struct commit *commit = suspect->commit;1696if(commit->object.flags & MORE_THAN_ONE_PATH)1697continue;1698for(oth = ent->next; oth; oth = oth->next) {1699if((oth->suspect->commit != commit) ||1700!strcmp(oth->suspect->path, suspect->path))1701continue;1702 commit->object.flags |= MORE_THAN_ONE_PATH;1703break;1704}1705}1706}17071708for(ent = sb->ent; ent; ent = ent->next) {1709if(option & OUTPUT_PORCELAIN)1710emit_porcelain(sb, ent);1711else{1712emit_other(sb, ent, option);1713}1714}1715}17161717/*1718 * To allow quick access to the contents of nth line in the1719 * final image, prepare an index in the scoreboard.1720 */1721static intprepare_lines(struct scoreboard *sb)1722{1723const char*buf = sb->final_buf;1724unsigned long len = sb->final_buf_size;1725int num =0, incomplete =0, bol =1;17261727if(len && buf[len-1] !='\n')1728 incomplete++;/* incomplete line at the end */1729while(len--) {1730if(bol) {1731 sb->lineno =xrealloc(sb->lineno,1732sizeof(int*) * (num +1));1733 sb->lineno[num] = buf - sb->final_buf;1734 bol =0;1735}1736if(*buf++ =='\n') {1737 num++;1738 bol =1;1739}1740}1741 sb->lineno =xrealloc(sb->lineno,1742sizeof(int*) * (num + incomplete +1));1743 sb->lineno[num + incomplete] = buf - sb->final_buf;1744 sb->num_lines = num + incomplete;1745return sb->num_lines;1746}17471748/*1749 * Add phony grafts for use with -S; this is primarily to1750 * support git's cvsserver that wants to give a linear history1751 * to its clients.1752 */1753static intread_ancestry(const char*graft_file)1754{1755FILE*fp =fopen(graft_file,"r");1756char buf[1024];1757if(!fp)1758return-1;1759while(fgets(buf,sizeof(buf), fp)) {1760/* The format is just "Commit Parent1 Parent2 ...\n" */1761int len =strlen(buf);1762struct commit_graft *graft =read_graft_line(buf, len);1763if(graft)1764register_commit_graft(graft,0);1765}1766fclose(fp);1767return0;1768}17691770/*1771 * How many columns do we need to show line numbers in decimal?1772 */1773static intlineno_width(int lines)1774{1775int i, width;17761777for(width =1, i =10; i <= lines; width++)1778 i *=10;1779return width;1780}17811782/*1783 * How many columns do we need to show line numbers, authors,1784 * and filenames?1785 */1786static voidfind_alignment(struct scoreboard *sb,int*option)1787{1788int longest_src_lines =0;1789int longest_dst_lines =0;1790unsigned largest_score =0;1791struct blame_entry *e;17921793for(e = sb->ent; e; e = e->next) {1794struct origin *suspect = e->suspect;1795struct commit_info ci;1796int num;17971798if(strcmp(suspect->path, sb->path))1799*option |= OUTPUT_SHOW_NAME;1800 num =strlen(suspect->path);1801if(longest_file < num)1802 longest_file = num;1803if(!(suspect->commit->object.flags & METAINFO_SHOWN)) {1804 suspect->commit->object.flags |= METAINFO_SHOWN;1805get_commit_info(suspect->commit, &ci,1);1806 num =utf8_strwidth(ci.author);1807if(longest_author < num)1808 longest_author = num;1809}1810 num = e->s_lno + e->num_lines;1811if(longest_src_lines < num)1812 longest_src_lines = num;1813 num = e->lno + e->num_lines;1814if(longest_dst_lines < num)1815 longest_dst_lines = num;1816if(largest_score <ent_score(sb, e))1817 largest_score =ent_score(sb, e);1818}1819 max_orig_digits =lineno_width(longest_src_lines);1820 max_digits =lineno_width(longest_dst_lines);1821 max_score_digits =lineno_width(largest_score);1822}18231824/*1825 * For debugging -- origin is refcounted, and this asserts that1826 * we do not underflow.1827 */1828static voidsanity_check_refcnt(struct scoreboard *sb)1829{1830int baa =0;1831struct blame_entry *ent;18321833for(ent = sb->ent; ent; ent = ent->next) {1834/* Nobody should have zero or negative refcnt */1835if(ent->suspect->refcnt <=0) {1836fprintf(stderr,"%sin%shas negative refcnt%d\n",1837 ent->suspect->path,1838sha1_to_hex(ent->suspect->commit->object.sha1),1839 ent->suspect->refcnt);1840 baa =1;1841}1842}1843if(baa) {1844int opt =0160;1845find_alignment(sb, &opt);1846output(sb, opt);1847die("Baa%d!", baa);1848}1849}18501851/*1852 * Used for the command line parsing; check if the path exists1853 * in the working tree.1854 */1855static inthas_string_in_work_tree(const char*path)1856{1857struct stat st;1858return!lstat(path, &st);1859}18601861static unsignedparse_score(const char*arg)1862{1863char*end;1864unsigned long score =strtoul(arg, &end,10);1865if(*end)1866return0;1867return score;1868}18691870static const char*add_prefix(const char*prefix,const char*path)1871{1872returnprefix_path(prefix, prefix ?strlen(prefix) :0, path);1873}18741875/*1876 * Parsing of (comma separated) one item in the -L option1877 */1878static const char*parse_loc(const char*spec,1879struct scoreboard *sb,long lno,1880long begin,long*ret)1881{1882char*term;1883const char*line;1884long num;1885int reg_error;1886 regex_t regexp;1887 regmatch_t match[1];18881889/* Allow "-L <something>,+20" to mean starting at <something>1890 * for 20 lines, or "-L <something>,-5" for 5 lines ending at1891 * <something>.1892 */1893if(1< begin && (spec[0] =='+'|| spec[0] =='-')) {1894 num =strtol(spec +1, &term,10);1895if(term != spec +1) {1896if(spec[0] =='-')1897 num =0- num;1898if(0< num)1899*ret = begin + num -2;1900else if(!num)1901*ret = begin;1902else1903*ret = begin + num;1904return term;1905}1906return spec;1907}1908 num =strtol(spec, &term,10);1909if(term != spec) {1910*ret = num;1911return term;1912}1913if(spec[0] !='/')1914return spec;19151916/* it could be a regexp of form /.../ */1917for(term = (char*) spec +1; *term && *term !='/'; term++) {1918if(*term =='\\')1919 term++;1920}1921if(*term !='/')1922return spec;19231924/* try [spec+1 .. term-1] as regexp */1925*term =0;1926 begin--;/* input is in human terms */1927 line =nth_line(sb, begin);19281929if(!(reg_error =regcomp(®exp, spec +1, REG_NEWLINE)) &&1930!(reg_error =regexec(®exp, line,1, match,0))) {1931const char*cp = line + match[0].rm_so;1932const char*nline;19331934while(begin++ < lno) {1935 nline =nth_line(sb, begin);1936if(line <= cp && cp < nline)1937break;1938 line = nline;1939}1940*ret = begin;1941regfree(®exp);1942*term++ ='/';1943return term;1944}1945else{1946char errbuf[1024];1947regerror(reg_error, ®exp, errbuf,1024);1948die("-L parameter '%s':%s", spec +1, errbuf);1949}1950}19511952/*1953 * Parsing of -L option1954 */1955static voidprepare_blame_range(struct scoreboard *sb,1956const char*bottomtop,1957long lno,1958long*bottom,long*top)1959{1960const char*term;19611962 term =parse_loc(bottomtop, sb, lno,1, bottom);1963if(*term ==',') {1964 term =parse_loc(term +1, sb, lno, *bottom +1, top);1965if(*term)1966usage(blame_usage);1967}1968if(*term)1969usage(blame_usage);1970}19711972static intgit_blame_config(const char*var,const char*value,void*cb)1973{1974if(!strcmp(var,"blame.showroot")) {1975 show_root =git_config_bool(var, value);1976return0;1977}1978if(!strcmp(var,"blame.blankboundary")) {1979 blank_boundary =git_config_bool(var, value);1980return0;1981}1982if(!strcmp(var,"blame.date")) {1983if(!value)1984returnconfig_error_nonbool(var);1985 blame_date_mode =parse_date_format(value);1986return0;1987}1988returngit_default_config(var, value, cb);1989}19901991/*1992 * Prepare a dummy commit that represents the work tree (or staged) item.1993 * Note that annotating work tree item never works in the reverse.1994 */1995static struct commit *fake_working_tree_commit(const char*path,const char*contents_from)1996{1997struct commit *commit;1998struct origin *origin;1999unsigned char head_sha1[20];2000struct strbuf buf = STRBUF_INIT;2001const char*ident;2002time_t now;2003int size, len;2004struct cache_entry *ce;2005unsigned mode;20062007if(get_sha1("HEAD", head_sha1))2008die("No such ref: HEAD");20092010time(&now);2011 commit =xcalloc(1,sizeof(*commit));2012 commit->parents =xcalloc(1,sizeof(*commit->parents));2013 commit->parents->item =lookup_commit_reference(head_sha1);2014 commit->object.parsed =1;2015 commit->date = now;2016 commit->object.type = OBJ_COMMIT;20172018 origin =make_origin(commit, path);20192020if(!contents_from ||strcmp("-", contents_from)) {2021struct stat st;2022const char*read_from;20232024if(contents_from) {2025if(stat(contents_from, &st) <0)2026die_errno("Cannot stat '%s'", contents_from);2027 read_from = contents_from;2028}2029else{2030if(lstat(path, &st) <0)2031die_errno("Cannot lstat '%s'", path);2032 read_from = path;2033}2034 mode =canon_mode(st.st_mode);2035switch(st.st_mode & S_IFMT) {2036case S_IFREG:2037if(strbuf_read_file(&buf, read_from, st.st_size) != st.st_size)2038die_errno("cannot open or read '%s'", read_from);2039break;2040case S_IFLNK:2041if(strbuf_readlink(&buf, read_from, st.st_size) <0)2042die_errno("cannot readlink '%s'", read_from);2043break;2044default:2045die("unsupported file type%s", read_from);2046}2047}2048else{2049/* Reading from stdin */2050 contents_from ="standard input";2051 mode =0;2052if(strbuf_read(&buf,0,0) <0)2053die_errno("failed to read from stdin");2054}2055convert_to_git(path, buf.buf, buf.len, &buf,0);2056 origin->file.ptr = buf.buf;2057 origin->file.size = buf.len;2058pretend_sha1_file(buf.buf, buf.len, OBJ_BLOB, origin->blob_sha1);2059 commit->util = origin;20602061/*2062 * Read the current index, replace the path entry with2063 * origin->blob_sha1 without mucking with its mode or type2064 * bits; we are not going to write this index out -- we just2065 * want to run "diff-index --cached".2066 */2067discard_cache();2068read_cache();20692070 len =strlen(path);2071if(!mode) {2072int pos =cache_name_pos(path, len);2073if(0<= pos)2074 mode = active_cache[pos]->ce_mode;2075else2076/* Let's not bother reading from HEAD tree */2077 mode = S_IFREG |0644;2078}2079 size =cache_entry_size(len);2080 ce =xcalloc(1, size);2081hashcpy(ce->sha1, origin->blob_sha1);2082memcpy(ce->name, path, len);2083 ce->ce_flags =create_ce_flags(len,0);2084 ce->ce_mode =create_ce_mode(mode);2085add_cache_entry(ce, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE);20862087/*2088 * We are not going to write this out, so this does not matter2089 * right now, but someday we might optimize diff-index --cached2090 * with cache-tree information.2091 */2092cache_tree_invalidate_path(active_cache_tree, path);20932094 commit->buffer =xmalloc(400);2095 ident =fmt_ident("Not Committed Yet","not.committed.yet", NULL,0);2096snprintf(commit->buffer,400,2097"tree 0000000000000000000000000000000000000000\n"2098"parent%s\n"2099"author%s\n"2100"committer%s\n\n"2101"Version of%sfrom%s\n",2102sha1_to_hex(head_sha1),2103 ident, ident, path, contents_from ? contents_from : path);2104return commit;2105}21062107static const char*prepare_final(struct scoreboard *sb)2108{2109int i;2110const char*final_commit_name = NULL;2111struct rev_info *revs = sb->revs;21122113/*2114 * There must be one and only one positive commit in the2115 * revs->pending array.2116 */2117for(i =0; i < revs->pending.nr; i++) {2118struct object *obj = revs->pending.objects[i].item;2119if(obj->flags & UNINTERESTING)2120continue;2121while(obj->type == OBJ_TAG)2122 obj =deref_tag(obj, NULL,0);2123if(obj->type != OBJ_COMMIT)2124die("Non commit%s?", revs->pending.objects[i].name);2125if(sb->final)2126die("More than one commit to dig from%sand%s?",2127 revs->pending.objects[i].name,2128 final_commit_name);2129 sb->final = (struct commit *) obj;2130 final_commit_name = revs->pending.objects[i].name;2131}2132return final_commit_name;2133}21342135static const char*prepare_initial(struct scoreboard *sb)2136{2137int i;2138const char*final_commit_name = NULL;2139struct rev_info *revs = sb->revs;21402141/*2142 * There must be one and only one negative commit, and it must be2143 * the boundary.2144 */2145for(i =0; i < revs->pending.nr; i++) {2146struct object *obj = revs->pending.objects[i].item;2147if(!(obj->flags & UNINTERESTING))2148continue;2149while(obj->type == OBJ_TAG)2150 obj =deref_tag(obj, NULL,0);2151if(obj->type != OBJ_COMMIT)2152die("Non commit%s?", revs->pending.objects[i].name);2153if(sb->final)2154die("More than one commit to dig down to%sand%s?",2155 revs->pending.objects[i].name,2156 final_commit_name);2157 sb->final = (struct commit *) obj;2158 final_commit_name = revs->pending.objects[i].name;2159}2160if(!final_commit_name)2161die("No commit to dig down to?");2162return final_commit_name;2163}21642165static intblame_copy_callback(const struct option *option,const char*arg,int unset)2166{2167int*opt = option->value;21682169/*2170 * -C enables copy from removed files;2171 * -C -C enables copy from existing files, but only2172 * when blaming a new file;2173 * -C -C -C enables copy from existing files for2174 * everybody2175 */2176if(*opt & PICKAXE_BLAME_COPY_HARDER)2177*opt |= PICKAXE_BLAME_COPY_HARDEST;2178if(*opt & PICKAXE_BLAME_COPY)2179*opt |= PICKAXE_BLAME_COPY_HARDER;2180*opt |= PICKAXE_BLAME_COPY | PICKAXE_BLAME_MOVE;21812182if(arg)2183 blame_copy_score =parse_score(arg);2184return0;2185}21862187static intblame_move_callback(const struct option *option,const char*arg,int unset)2188{2189int*opt = option->value;21902191*opt |= PICKAXE_BLAME_MOVE;21922193if(arg)2194 blame_move_score =parse_score(arg);2195return0;2196}21972198static intblame_bottomtop_callback(const struct option *option,const char*arg,int unset)2199{2200const char**bottomtop = option->value;2201if(!arg)2202return-1;2203if(*bottomtop)2204die("More than one '-L n,m' option given");2205*bottomtop = arg;2206return0;2207}22082209intcmd_blame(int argc,const char**argv,const char*prefix)2210{2211struct rev_info revs;2212const char*path;2213struct scoreboard sb;2214struct origin *o;2215struct blame_entry *ent;2216long dashdash_pos, bottom, top, lno;2217const char*final_commit_name = NULL;2218enum object_type type;22192220static const char*bottomtop = NULL;2221static int output_option =0, opt =0;2222static int show_stats =0;2223static const char*revs_file = NULL;2224static const char*contents_from = NULL;2225static const struct option options[] = {2226OPT_BOOLEAN(0,"incremental", &incremental,"Show blame entries as we find them, incrementally"),2227OPT_BOOLEAN('b', NULL, &blank_boundary,"Show blank SHA-1 for boundary commits (Default: off)"),2228OPT_BOOLEAN(0,"root", &show_root,"Do not treat root commits as boundaries (Default: off)"),2229OPT_BOOLEAN(0,"show-stats", &show_stats,"Show work cost statistics"),2230OPT_BIT(0,"score-debug", &output_option,"Show output score for blame entries", OUTPUT_SHOW_SCORE),2231OPT_BIT('f',"show-name", &output_option,"Show original filename (Default: auto)", OUTPUT_SHOW_NAME),2232OPT_BIT('n',"show-number", &output_option,"Show original linenumber (Default: off)", OUTPUT_SHOW_NUMBER),2233OPT_BIT('p',"porcelain", &output_option,"Show in a format designed for machine consumption", OUTPUT_PORCELAIN),2234OPT_BIT('c', NULL, &output_option,"Use the same output mode as git-annotate (Default: off)", OUTPUT_ANNOTATE_COMPAT),2235OPT_BIT('t', NULL, &output_option,"Show raw timestamp (Default: off)", OUTPUT_RAW_TIMESTAMP),2236OPT_BIT('l', NULL, &output_option,"Show long commit SHA1 (Default: off)", OUTPUT_LONG_OBJECT_NAME),2237OPT_BIT('s', NULL, &output_option,"Suppress author name and timestamp (Default: off)", OUTPUT_NO_AUTHOR),2238OPT_BIT('w', NULL, &xdl_opts,"Ignore whitespace differences", XDF_IGNORE_WHITESPACE),2239OPT_STRING('S', NULL, &revs_file,"file","Use revisions from <file> instead of calling git-rev-list"),2240OPT_STRING(0,"contents", &contents_from,"file","Use <file>'s contents as the final image"),2241{ OPTION_CALLBACK,'C', NULL, &opt,"score","Find line copies within and across files", PARSE_OPT_OPTARG, blame_copy_callback },2242{ OPTION_CALLBACK,'M', NULL, &opt,"score","Find line movements within and across files", PARSE_OPT_OPTARG, blame_move_callback },2243OPT_CALLBACK('L', NULL, &bottomtop,"n,m","Process only line range n,m, counting from 1", blame_bottomtop_callback),2244OPT_END()2245};22462247struct parse_opt_ctx_t ctx;2248int cmd_is_annotate = !strcmp(argv[0],"annotate");22492250git_config(git_blame_config, NULL);2251init_revisions(&revs, NULL);2252 revs.date_mode = blame_date_mode;22532254 save_commit_buffer =0;2255 dashdash_pos =0;22562257parse_options_start(&ctx, argc, argv, prefix, PARSE_OPT_KEEP_DASHDASH |2258 PARSE_OPT_KEEP_ARGV0);2259for(;;) {2260switch(parse_options_step(&ctx, options, blame_opt_usage)) {2261case PARSE_OPT_HELP:2262exit(129);2263case PARSE_OPT_DONE:2264if(ctx.argv[0])2265 dashdash_pos = ctx.cpidx;2266goto parse_done;2267}22682269if(!strcmp(ctx.argv[0],"--reverse")) {2270 ctx.argv[0] ="--children";2271 reverse =1;2272}2273parse_revision_opt(&revs, &ctx, options, blame_opt_usage);2274}2275parse_done:2276 argc =parse_options_end(&ctx);22772278if(revs_file &&read_ancestry(revs_file))2279die_errno("reading graft file '%s' failed", revs_file);22802281if(cmd_is_annotate) {2282 output_option |= OUTPUT_ANNOTATE_COMPAT;2283 blame_date_mode = DATE_ISO8601;2284}else{2285 blame_date_mode = revs.date_mode;2286}22872288/* The maximum width used to show the dates */2289switch(blame_date_mode) {2290case DATE_RFC2822:2291 blame_date_width =sizeof("Thu, 19 Oct 2006 16:00:04 -0700");2292break;2293case DATE_ISO8601:2294 blame_date_width =sizeof("2006-10-19 16:00:04 -0700");2295break;2296case DATE_RAW:2297 blame_date_width =sizeof("1161298804 -0700");2298break;2299case DATE_SHORT:2300 blame_date_width =sizeof("2006-10-19");2301break;2302case DATE_RELATIVE:2303/* "normal" is used as the fallback for "relative" */2304case DATE_LOCAL:2305case DATE_NORMAL:2306 blame_date_width =sizeof("Thu Oct 19 16:00:04 2006 -0700");2307break;2308}2309 blame_date_width -=1;/* strip the null */23102311if(DIFF_OPT_TST(&revs.diffopt, FIND_COPIES_HARDER))2312 opt |= (PICKAXE_BLAME_COPY | PICKAXE_BLAME_MOVE |2313 PICKAXE_BLAME_COPY_HARDER);23142315if(!blame_move_score)2316 blame_move_score = BLAME_DEFAULT_MOVE_SCORE;2317if(!blame_copy_score)2318 blame_copy_score = BLAME_DEFAULT_COPY_SCORE;23192320/*2321 * We have collected options unknown to us in argv[1..unk]2322 * which are to be passed to revision machinery if we are2323 * going to do the "bottom" processing.2324 *2325 * The remaining are:2326 *2327 * (1) if dashdash_pos != 0, its either2328 * "blame [revisions] -- <path>" or2329 * "blame -- <path> <rev>"2330 *2331 * (2) otherwise, its one of the two:2332 * "blame [revisions] <path>"2333 * "blame <path> <rev>"2334 *2335 * Note that we must strip out <path> from the arguments: we do not2336 * want the path pruning but we may want "bottom" processing.2337 */2338if(dashdash_pos) {2339switch(argc - dashdash_pos -1) {2340case2:/* (1b) */2341if(argc !=4)2342usage_with_options(blame_opt_usage, options);2343/* reorder for the new way: <rev> -- <path> */2344 argv[1] = argv[3];2345 argv[3] = argv[2];2346 argv[2] ="--";2347/* FALLTHROUGH */2348case1:/* (1a) */2349 path =add_prefix(prefix, argv[--argc]);2350 argv[argc] = NULL;2351break;2352default:2353usage_with_options(blame_opt_usage, options);2354}2355}else{2356if(argc <2)2357usage_with_options(blame_opt_usage, options);2358 path =add_prefix(prefix, argv[argc -1]);2359if(argc ==3&& !has_string_in_work_tree(path)) {/* (2b) */2360 path =add_prefix(prefix, argv[1]);2361 argv[1] = argv[2];2362}2363 argv[argc -1] ="--";23642365setup_work_tree();2366if(!has_string_in_work_tree(path))2367die_errno("cannot stat path '%s'", path);2368}23692370 revs.disable_stdin =1;2371setup_revisions(argc, argv, &revs, NULL);2372memset(&sb,0,sizeof(sb));23732374 sb.revs = &revs;2375if(!reverse)2376 final_commit_name =prepare_final(&sb);2377else if(contents_from)2378die("--contents and --children do not blend well.");2379else2380 final_commit_name =prepare_initial(&sb);23812382if(!sb.final) {2383/*2384 * "--not A B -- path" without anything positive;2385 * do not default to HEAD, but use the working tree2386 * or "--contents".2387 */2388setup_work_tree();2389 sb.final =fake_working_tree_commit(path, contents_from);2390add_pending_object(&revs, &(sb.final->object),":");2391}2392else if(contents_from)2393die("Cannot use --contents with final commit object name");23942395/*2396 * If we have bottom, this will mark the ancestors of the2397 * bottom commits we would reach while traversing as2398 * uninteresting.2399 */2400if(prepare_revision_walk(&revs))2401die("revision walk setup failed");24022403if(is_null_sha1(sb.final->object.sha1)) {2404char*buf;2405 o = sb.final->util;2406 buf =xmalloc(o->file.size +1);2407memcpy(buf, o->file.ptr, o->file.size +1);2408 sb.final_buf = buf;2409 sb.final_buf_size = o->file.size;2410}2411else{2412 o =get_origin(&sb, sb.final, path);2413if(fill_blob_sha1(o))2414die("no such path%sin%s", path, final_commit_name);24152416 sb.final_buf =read_sha1_file(o->blob_sha1, &type,2417&sb.final_buf_size);2418if(!sb.final_buf)2419die("Cannot read blob%sfor path%s",2420sha1_to_hex(o->blob_sha1),2421 path);2422}2423 num_read_blob++;2424 lno =prepare_lines(&sb);24252426 bottom = top =0;2427if(bottomtop)2428prepare_blame_range(&sb, bottomtop, lno, &bottom, &top);2429if(bottom && top && top < bottom) {2430long tmp;2431 tmp = top; top = bottom; bottom = tmp;2432}2433if(bottom <1)2434 bottom =1;2435if(top <1)2436 top = lno;2437 bottom--;2438if(lno < top || lno < bottom)2439die("file%shas only%lu lines", path, lno);24402441 ent =xcalloc(1,sizeof(*ent));2442 ent->lno = bottom;2443 ent->num_lines = top - bottom;2444 ent->suspect = o;2445 ent->s_lno = bottom;24462447 sb.ent = ent;2448 sb.path = path;24492450read_mailmap(&mailmap, NULL);24512452if(!incremental)2453setup_pager();24542455assign_blame(&sb, opt);24562457if(incremental)2458return0;24592460coalesce(&sb);24612462if(!(output_option & OUTPUT_PORCELAIN))2463find_alignment(&sb, &output_option);24642465output(&sb, output_option);2466free((void*)sb.final_buf);2467for(ent = sb.ent; ent; ) {2468struct blame_entry *e = ent->next;2469free(ent);2470 ent = e;2471}24722473if(show_stats) {2474printf("num read blob:%d\n", num_read_blob);2475printf("num get patch:%d\n", num_get_patch);2476printf("num commits:%d\n", num_commits);2477}2478return0;2479}