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 reverse; 47static int blank_boundary; 48static int incremental; 49static int cmd_is_annotate; 50static int xdl_opts = XDF_NEED_MINIMAL; 51static struct path_list mailmap; 52 53#ifndef DEBUG 54#define DEBUG 0 55#endif 56 57/* stats */ 58static int num_read_blob; 59static int num_get_patch; 60static int num_commits; 61 62#define PICKAXE_BLAME_MOVE 01 63#define PICKAXE_BLAME_COPY 02 64#define PICKAXE_BLAME_COPY_HARDER 04 65#define PICKAXE_BLAME_COPY_HARDEST 010 66 67/* 68 * blame for a blame_entry with score lower than these thresholds 69 * is not passed to the parent using move/copy logic. 70 */ 71static unsigned blame_move_score; 72static unsigned blame_copy_score; 73#define BLAME_DEFAULT_MOVE_SCORE 20 74#define BLAME_DEFAULT_COPY_SCORE 40 75 76/* bits #0..7 in revision.h, #8..11 used for merge_bases() in commit.c */ 77#define METAINFO_SHOWN (1u<<12) 78#define MORE_THAN_ONE_PATH (1u<<13) 79 80/* 81 * One blob in a commit that is being suspected 82 */ 83struct origin { 84int refcnt; 85struct commit *commit; 86 mmfile_t file; 87unsigned char blob_sha1[20]; 88char path[FLEX_ARRAY]; 89}; 90 91/* 92 * Given an origin, prepare mmfile_t structure to be used by the 93 * diff machinery 94 */ 95static voidfill_origin_blob(struct origin *o, mmfile_t *file) 96{ 97if(!o->file.ptr) { 98enum object_type type; 99 num_read_blob++; 100 file->ptr =read_sha1_file(o->blob_sha1, &type, 101(unsigned long*)(&(file->size))); 102if(!file->ptr) 103die("Cannot read blob%sfor path%s", 104sha1_to_hex(o->blob_sha1), 105 o->path); 106 o->file = *file; 107} 108else 109*file = o->file; 110} 111 112/* 113 * Origin is refcounted and usually we keep the blob contents to be 114 * reused. 115 */ 116staticinlinestruct origin *origin_incref(struct origin *o) 117{ 118if(o) 119 o->refcnt++; 120return o; 121} 122 123static voidorigin_decref(struct origin *o) 124{ 125if(o && --o->refcnt <=0) { 126free(o->file.ptr); 127free(o); 128} 129} 130 131static voiddrop_origin_blob(struct origin *o) 132{ 133if(o->file.ptr) { 134free(o->file.ptr); 135 o->file.ptr = NULL; 136} 137} 138 139/* 140 * Each group of lines is described by a blame_entry; it can be split 141 * as we pass blame to the parents. They form a linked list in the 142 * scoreboard structure, sorted by the target line number. 143 */ 144struct blame_entry { 145struct blame_entry *prev; 146struct blame_entry *next; 147 148/* the first line of this group in the final image; 149 * internally all line numbers are 0 based. 150 */ 151int lno; 152 153/* how many lines this group has */ 154int num_lines; 155 156/* the commit that introduced this group into the final image */ 157struct origin *suspect; 158 159/* true if the suspect is truly guilty; false while we have not 160 * checked if the group came from one of its parents. 161 */ 162char guilty; 163 164/* the line number of the first line of this group in the 165 * suspect's file; internally all line numbers are 0 based. 166 */ 167int s_lno; 168 169/* how significant this entry is -- cached to avoid 170 * scanning the lines over and over. 171 */ 172unsigned score; 173}; 174 175/* 176 * The current state of the blame assignment. 177 */ 178struct scoreboard { 179/* the final commit (i.e. where we started digging from) */ 180struct commit *final; 181struct rev_info *revs; 182const char*path; 183 184/* 185 * The contents in the final image. 186 * Used by many functions to obtain contents of the nth line, 187 * indexed with scoreboard.lineno[blame_entry.lno]. 188 */ 189const char*final_buf; 190unsigned long final_buf_size; 191 192/* linked list of blames */ 193struct blame_entry *ent; 194 195/* look-up a line in the final buffer */ 196int num_lines; 197int*lineno; 198}; 199 200staticinlineintsame_suspect(struct origin *a,struct origin *b) 201{ 202if(a == b) 203return1; 204if(a->commit != b->commit) 205return0; 206return!strcmp(a->path, b->path); 207} 208 209static voidsanity_check_refcnt(struct scoreboard *); 210 211/* 212 * If two blame entries that are next to each other came from 213 * contiguous lines in the same origin (i.e. <commit, path> pair), 214 * merge them together. 215 */ 216static voidcoalesce(struct scoreboard *sb) 217{ 218struct blame_entry *ent, *next; 219 220for(ent = sb->ent; ent && (next = ent->next); ent = next) { 221if(same_suspect(ent->suspect, next->suspect) && 222 ent->guilty == next->guilty && 223 ent->s_lno + ent->num_lines == next->s_lno) { 224 ent->num_lines += next->num_lines; 225 ent->next = next->next; 226if(ent->next) 227 ent->next->prev = ent; 228origin_decref(next->suspect); 229free(next); 230 ent->score =0; 231 next = ent;/* again */ 232} 233} 234 235if(DEBUG)/* sanity */ 236sanity_check_refcnt(sb); 237} 238 239/* 240 * Given a commit and a path in it, create a new origin structure. 241 * The callers that add blame to the scoreboard should use 242 * get_origin() to obtain shared, refcounted copy instead of calling 243 * this function directly. 244 */ 245static struct origin *make_origin(struct commit *commit,const char*path) 246{ 247struct origin *o; 248 o =xcalloc(1,sizeof(*o) +strlen(path) +1); 249 o->commit = commit; 250 o->refcnt =1; 251strcpy(o->path, path); 252return o; 253} 254 255/* 256 * Locate an existing origin or create a new one. 257 */ 258static struct origin *get_origin(struct scoreboard *sb, 259struct commit *commit, 260const char*path) 261{ 262struct blame_entry *e; 263 264for(e = sb->ent; e; e = e->next) { 265if(e->suspect->commit == commit && 266!strcmp(e->suspect->path, path)) 267returnorigin_incref(e->suspect); 268} 269returnmake_origin(commit, path); 270} 271 272/* 273 * Fill the blob_sha1 field of an origin if it hasn't, so that later 274 * call to fill_origin_blob() can use it to locate the data. blob_sha1 275 * for an origin is also used to pass the blame for the entire file to 276 * the parent to detect the case where a child's blob is identical to 277 * that of its parent's. 278 */ 279static intfill_blob_sha1(struct origin *origin) 280{ 281unsigned mode; 282 283if(!is_null_sha1(origin->blob_sha1)) 284return0; 285if(get_tree_entry(origin->commit->object.sha1, 286 origin->path, 287 origin->blob_sha1, &mode)) 288goto error_out; 289if(sha1_object_info(origin->blob_sha1, NULL) != OBJ_BLOB) 290goto error_out; 291return0; 292 error_out: 293hashclr(origin->blob_sha1); 294return-1; 295} 296 297/* 298 * We have an origin -- check if the same path exists in the 299 * parent and return an origin structure to represent it. 300 */ 301static struct origin *find_origin(struct scoreboard *sb, 302struct commit *parent, 303struct origin *origin) 304{ 305struct origin *porigin = NULL; 306struct diff_options diff_opts; 307const char*paths[2]; 308 309if(parent->util) { 310/* 311 * Each commit object can cache one origin in that 312 * commit. This is a freestanding copy of origin and 313 * not refcounted. 314 */ 315struct origin *cached = parent->util; 316if(!strcmp(cached->path, origin->path)) { 317/* 318 * The same path between origin and its parent 319 * without renaming -- the most common case. 320 */ 321 porigin =get_origin(sb, parent, cached->path); 322 323/* 324 * If the origin was newly created (i.e. get_origin 325 * would call make_origin if none is found in the 326 * scoreboard), it does not know the blob_sha1, 327 * so copy it. Otherwise porigin was in the 328 * scoreboard and already knows blob_sha1. 329 */ 330if(porigin->refcnt ==1) 331hashcpy(porigin->blob_sha1, cached->blob_sha1); 332return porigin; 333} 334/* otherwise it was not very useful; free it */ 335free(parent->util); 336 parent->util = NULL; 337} 338 339/* See if the origin->path is different between parent 340 * and origin first. Most of the time they are the 341 * same and diff-tree is fairly efficient about this. 342 */ 343diff_setup(&diff_opts); 344DIFF_OPT_SET(&diff_opts, RECURSIVE); 345 diff_opts.detect_rename =0; 346 diff_opts.output_format = DIFF_FORMAT_NO_OUTPUT; 347 paths[0] = origin->path; 348 paths[1] = NULL; 349 350diff_tree_setup_paths(paths, &diff_opts); 351if(diff_setup_done(&diff_opts) <0) 352die("diff-setup"); 353 354if(is_null_sha1(origin->commit->object.sha1)) 355do_diff_cache(parent->tree->object.sha1, &diff_opts); 356else 357diff_tree_sha1(parent->tree->object.sha1, 358 origin->commit->tree->object.sha1, 359"", &diff_opts); 360diffcore_std(&diff_opts); 361 362/* It is either one entry that says "modified", or "created", 363 * or nothing. 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} 370else if(diff_queued_diff.nr !=1) 371die("internal error in blame::find_origin"); 372else{ 373struct diff_filepair *p = diff_queued_diff.queue[0]; 374switch(p->status) { 375default: 376die("internal error in blame::find_origin (%c)", 377 p->status); 378case'M': 379 porigin =get_origin(sb, parent, origin->path); 380hashcpy(porigin->blob_sha1, p->one->sha1); 381break; 382case'A': 383case'T': 384/* Did not exist in parent, or type changed */ 385break; 386} 387} 388diff_flush(&diff_opts); 389diff_tree_release_paths(&diff_opts); 390if(porigin) { 391/* 392 * Create a freestanding copy that is not part of 393 * the refcounted origin found in the scoreboard, and 394 * cache it in the commit. 395 */ 396struct origin *cached; 397 398 cached =make_origin(porigin->commit, porigin->path); 399hashcpy(cached->blob_sha1, porigin->blob_sha1); 400 parent->util = cached; 401} 402return porigin; 403} 404 405/* 406 * We have an origin -- find the path that corresponds to it in its 407 * parent and return an origin structure to represent it. 408 */ 409static struct origin *find_rename(struct scoreboard *sb, 410struct commit *parent, 411struct origin *origin) 412{ 413struct origin *porigin = NULL; 414struct diff_options diff_opts; 415int i; 416const char*paths[2]; 417 418diff_setup(&diff_opts); 419DIFF_OPT_SET(&diff_opts, RECURSIVE); 420 diff_opts.detect_rename = DIFF_DETECT_RENAME; 421 diff_opts.output_format = DIFF_FORMAT_NO_OUTPUT; 422 diff_opts.single_follow = origin->path; 423 paths[0] = NULL; 424diff_tree_setup_paths(paths, &diff_opts); 425if(diff_setup_done(&diff_opts) <0) 426die("diff-setup"); 427 428if(is_null_sha1(origin->commit->object.sha1)) 429do_diff_cache(parent->tree->object.sha1, &diff_opts); 430else 431diff_tree_sha1(parent->tree->object.sha1, 432 origin->commit->tree->object.sha1, 433"", &diff_opts); 434diffcore_std(&diff_opts); 435 436for(i =0; i < diff_queued_diff.nr; i++) { 437struct diff_filepair *p = diff_queued_diff.queue[i]; 438if((p->status =='R'|| p->status =='C') && 439!strcmp(p->two->path, origin->path)) { 440 porigin =get_origin(sb, parent, p->one->path); 441hashcpy(porigin->blob_sha1, p->one->sha1); 442break; 443} 444} 445diff_flush(&diff_opts); 446diff_tree_release_paths(&diff_opts); 447return porigin; 448} 449 450/* 451 * Parsing of patch chunks... 452 */ 453struct chunk { 454/* line number in postimage; up to but not including this 455 * line is the same as preimage 456 */ 457int same; 458 459/* preimage line number after this chunk */ 460int p_next; 461 462/* postimage line number after this chunk */ 463int t_next; 464}; 465 466struct patch { 467struct chunk *chunks; 468int num; 469}; 470 471struct blame_diff_state { 472struct xdiff_emit_state xm; 473struct patch *ret; 474unsigned hunk_post_context; 475unsigned hunk_in_pre_context :1; 476}; 477 478static voidprocess_u_diff(void*state_,char*line,unsigned long len) 479{ 480struct blame_diff_state *state = state_; 481struct chunk *chunk; 482int off1, off2, len1, len2, num; 483 484 num = state->ret->num; 485if(len <4|| line[0] !='@'|| line[1] !='@') { 486if(state->hunk_in_pre_context && line[0] ==' ') 487 state->ret->chunks[num -1].same++; 488else{ 489 state->hunk_in_pre_context =0; 490if(line[0] ==' ') 491 state->hunk_post_context++; 492else 493 state->hunk_post_context =0; 494} 495return; 496} 497 498if(num && state->hunk_post_context) { 499 chunk = &state->ret->chunks[num -1]; 500 chunk->p_next -= state->hunk_post_context; 501 chunk->t_next -= state->hunk_post_context; 502} 503 state->ret->num = ++num; 504 state->ret->chunks =xrealloc(state->ret->chunks, 505sizeof(struct chunk) * num); 506 chunk = &state->ret->chunks[num -1]; 507if(parse_hunk_header(line, len, &off1, &len1, &off2, &len2)) { 508 state->ret->num--; 509return; 510} 511 512/* Line numbers in patch output are one based. */ 513 off1--; 514 off2--; 515 516 chunk->same = len2 ? off2 : (off2 +1); 517 518 chunk->p_next = off1 + (len1 ? len1 :1); 519 chunk->t_next = chunk->same + len2; 520 state->hunk_in_pre_context =1; 521 state->hunk_post_context =0; 522} 523 524static struct patch *compare_buffer(mmfile_t *file_p, mmfile_t *file_o, 525int context) 526{ 527struct blame_diff_state state; 528 xpparam_t xpp; 529 xdemitconf_t xecfg; 530 xdemitcb_t ecb; 531 532 xpp.flags = xdl_opts; 533memset(&xecfg,0,sizeof(xecfg)); 534 xecfg.ctxlen = context; 535 ecb.outf = xdiff_outf; 536 ecb.priv = &state; 537memset(&state,0,sizeof(state)); 538 state.xm.consume = process_u_diff; 539 state.ret =xmalloc(sizeof(struct patch)); 540 state.ret->chunks = NULL; 541 state.ret->num =0; 542 543xdi_diff(file_p, file_o, &xpp, &xecfg, &ecb); 544 545if(state.ret->num) { 546struct chunk *chunk; 547 chunk = &state.ret->chunks[state.ret->num -1]; 548 chunk->p_next -= state.hunk_post_context; 549 chunk->t_next -= state.hunk_post_context; 550} 551return state.ret; 552} 553 554/* 555 * Run diff between two origins and grab the patch output, so that 556 * we can pass blame for lines origin is currently suspected for 557 * to its parent. 558 */ 559static struct patch *get_patch(struct origin *parent,struct origin *origin) 560{ 561 mmfile_t file_p, file_o; 562struct patch *patch; 563 564fill_origin_blob(parent, &file_p); 565fill_origin_blob(origin, &file_o); 566if(!file_p.ptr || !file_o.ptr) 567return NULL; 568 patch =compare_buffer(&file_p, &file_o,0); 569 num_get_patch++; 570return patch; 571} 572 573static voidfree_patch(struct patch *p) 574{ 575free(p->chunks); 576free(p); 577} 578 579/* 580 * Link in a new blame entry to the scoreboard. Entries that cover the 581 * same line range have been removed from the scoreboard previously. 582 */ 583static voidadd_blame_entry(struct scoreboard *sb,struct blame_entry *e) 584{ 585struct blame_entry *ent, *prev = NULL; 586 587origin_incref(e->suspect); 588 589for(ent = sb->ent; ent && ent->lno < e->lno; ent = ent->next) 590 prev = ent; 591 592/* prev, if not NULL, is the last one that is below e */ 593 e->prev = prev; 594if(prev) { 595 e->next = prev->next; 596 prev->next = e; 597} 598else{ 599 e->next = sb->ent; 600 sb->ent = e; 601} 602if(e->next) 603 e->next->prev = e; 604} 605 606/* 607 * src typically is on-stack; we want to copy the information in it to 608 * a malloced blame_entry that is already on the linked list of the 609 * scoreboard. The origin of dst loses a refcnt while the origin of src 610 * gains one. 611 */ 612static voiddup_entry(struct blame_entry *dst,struct blame_entry *src) 613{ 614struct blame_entry *p, *n; 615 616 p = dst->prev; 617 n = dst->next; 618origin_incref(src->suspect); 619origin_decref(dst->suspect); 620memcpy(dst, src,sizeof(*src)); 621 dst->prev = p; 622 dst->next = n; 623 dst->score =0; 624} 625 626static const char*nth_line(struct scoreboard *sb,int lno) 627{ 628return sb->final_buf + sb->lineno[lno]; 629} 630 631/* 632 * It is known that lines between tlno to same came from parent, and e 633 * has an overlap with that range. it also is known that parent's 634 * line plno corresponds to e's line tlno. 635 * 636 * <---- e -----> 637 * <------> 638 * <------------> 639 * <------------> 640 * <------------------> 641 * 642 * Split e into potentially three parts; before this chunk, the chunk 643 * to be blamed for the parent, and after that portion. 644 */ 645static voidsplit_overlap(struct blame_entry *split, 646struct blame_entry *e, 647int tlno,int plno,int same, 648struct origin *parent) 649{ 650int chunk_end_lno; 651memset(split,0,sizeof(struct blame_entry [3])); 652 653if(e->s_lno < tlno) { 654/* there is a pre-chunk part not blamed on parent */ 655 split[0].suspect =origin_incref(e->suspect); 656 split[0].lno = e->lno; 657 split[0].s_lno = e->s_lno; 658 split[0].num_lines = tlno - e->s_lno; 659 split[1].lno = e->lno + tlno - e->s_lno; 660 split[1].s_lno = plno; 661} 662else{ 663 split[1].lno = e->lno; 664 split[1].s_lno = plno + (e->s_lno - tlno); 665} 666 667if(same < e->s_lno + e->num_lines) { 668/* there is a post-chunk part not blamed on parent */ 669 split[2].suspect =origin_incref(e->suspect); 670 split[2].lno = e->lno + (same - e->s_lno); 671 split[2].s_lno = e->s_lno + (same - e->s_lno); 672 split[2].num_lines = e->s_lno + e->num_lines - same; 673 chunk_end_lno = split[2].lno; 674} 675else 676 chunk_end_lno = e->lno + e->num_lines; 677 split[1].num_lines = chunk_end_lno - split[1].lno; 678 679/* 680 * if it turns out there is nothing to blame the parent for, 681 * forget about the splitting. !split[1].suspect signals this. 682 */ 683if(split[1].num_lines <1) 684return; 685 split[1].suspect =origin_incref(parent); 686} 687 688/* 689 * split_overlap() divided an existing blame e into up to three parts 690 * in split. Adjust the linked list of blames in the scoreboard to 691 * reflect the split. 692 */ 693static voidsplit_blame(struct scoreboard *sb, 694struct blame_entry *split, 695struct blame_entry *e) 696{ 697struct blame_entry *new_entry; 698 699if(split[0].suspect && split[2].suspect) { 700/* The first part (reuse storage for the existing entry e) */ 701dup_entry(e, &split[0]); 702 703/* The last part -- me */ 704 new_entry =xmalloc(sizeof(*new_entry)); 705memcpy(new_entry, &(split[2]),sizeof(struct blame_entry)); 706add_blame_entry(sb, new_entry); 707 708/* ... and the middle part -- parent */ 709 new_entry =xmalloc(sizeof(*new_entry)); 710memcpy(new_entry, &(split[1]),sizeof(struct blame_entry)); 711add_blame_entry(sb, new_entry); 712} 713else if(!split[0].suspect && !split[2].suspect) 714/* 715 * The parent covers the entire area; reuse storage for 716 * e and replace it with the parent. 717 */ 718dup_entry(e, &split[1]); 719else if(split[0].suspect) { 720/* me and then parent */ 721dup_entry(e, &split[0]); 722 723 new_entry =xmalloc(sizeof(*new_entry)); 724memcpy(new_entry, &(split[1]),sizeof(struct blame_entry)); 725add_blame_entry(sb, new_entry); 726} 727else{ 728/* parent and then me */ 729dup_entry(e, &split[1]); 730 731 new_entry =xmalloc(sizeof(*new_entry)); 732memcpy(new_entry, &(split[2]),sizeof(struct blame_entry)); 733add_blame_entry(sb, new_entry); 734} 735 736if(DEBUG) {/* sanity */ 737struct blame_entry *ent; 738int lno = sb->ent->lno, corrupt =0; 739 740for(ent = sb->ent; ent; ent = ent->next) { 741if(lno != ent->lno) 742 corrupt =1; 743if(ent->s_lno <0) 744 corrupt =1; 745 lno += ent->num_lines; 746} 747if(corrupt) { 748 lno = sb->ent->lno; 749for(ent = sb->ent; ent; ent = ent->next) { 750printf("L%8d l%8d n%8d\n", 751 lno, ent->lno, ent->num_lines); 752 lno = ent->lno + ent->num_lines; 753} 754die("oops"); 755} 756} 757} 758 759/* 760 * After splitting the blame, the origins used by the 761 * on-stack blame_entry should lose one refcnt each. 762 */ 763static voiddecref_split(struct blame_entry *split) 764{ 765int i; 766 767for(i =0; i <3; i++) 768origin_decref(split[i].suspect); 769} 770 771/* 772 * Helper for blame_chunk(). blame_entry e is known to overlap with 773 * the patch hunk; split it and pass blame to the parent. 774 */ 775static voidblame_overlap(struct scoreboard *sb,struct blame_entry *e, 776int tlno,int plno,int same, 777struct origin *parent) 778{ 779struct blame_entry split[3]; 780 781split_overlap(split, e, tlno, plno, same, parent); 782if(split[1].suspect) 783split_blame(sb, split, e); 784decref_split(split); 785} 786 787/* 788 * Find the line number of the last line the target is suspected for. 789 */ 790static intfind_last_in_target(struct scoreboard *sb,struct origin *target) 791{ 792struct blame_entry *e; 793int last_in_target = -1; 794 795for(e = sb->ent; e; e = e->next) { 796if(e->guilty || !same_suspect(e->suspect, target)) 797continue; 798if(last_in_target < e->s_lno + e->num_lines) 799 last_in_target = e->s_lno + e->num_lines; 800} 801return last_in_target; 802} 803 804/* 805 * Process one hunk from the patch between the current suspect for 806 * blame_entry e and its parent. Find and split the overlap, and 807 * pass blame to the overlapping part to the parent. 808 */ 809static voidblame_chunk(struct scoreboard *sb, 810int tlno,int plno,int same, 811struct origin *target,struct origin *parent) 812{ 813struct blame_entry *e; 814 815for(e = sb->ent; e; e = e->next) { 816if(e->guilty || !same_suspect(e->suspect, target)) 817continue; 818if(same <= e->s_lno) 819continue; 820if(tlno < e->s_lno + e->num_lines) 821blame_overlap(sb, e, tlno, plno, same, parent); 822} 823} 824 825/* 826 * We are looking at the origin 'target' and aiming to pass blame 827 * for the lines it is suspected to its parent. Run diff to find 828 * which lines came from parent and pass blame for them. 829 */ 830static intpass_blame_to_parent(struct scoreboard *sb, 831struct origin *target, 832struct origin *parent) 833{ 834int i, last_in_target, plno, tlno; 835struct patch *patch; 836 837 last_in_target =find_last_in_target(sb, target); 838if(last_in_target <0) 839return1;/* nothing remains for this target */ 840 841 patch =get_patch(parent, target); 842 plno = tlno =0; 843for(i =0; i < patch->num; i++) { 844struct chunk *chunk = &patch->chunks[i]; 845 846blame_chunk(sb, tlno, plno, chunk->same, target, parent); 847 plno = chunk->p_next; 848 tlno = chunk->t_next; 849} 850/* The rest (i.e. anything after tlno) are the same as the parent */ 851blame_chunk(sb, tlno, plno, last_in_target, target, parent); 852 853free_patch(patch); 854return0; 855} 856 857/* 858 * The lines in blame_entry after splitting blames many times can become 859 * very small and trivial, and at some point it becomes pointless to 860 * blame the parents. E.g. "\t\t}\n\t}\n\n" appears everywhere in any 861 * ordinary C program, and it is not worth to say it was copied from 862 * totally unrelated file in the parent. 863 * 864 * Compute how trivial the lines in the blame_entry are. 865 */ 866static unsignedent_score(struct scoreboard *sb,struct blame_entry *e) 867{ 868unsigned score; 869const char*cp, *ep; 870 871if(e->score) 872return e->score; 873 874 score =1; 875 cp =nth_line(sb, e->lno); 876 ep =nth_line(sb, e->lno + e->num_lines); 877while(cp < ep) { 878unsigned ch = *((unsigned char*)cp); 879if(isalnum(ch)) 880 score++; 881 cp++; 882} 883 e->score = score; 884return score; 885} 886 887/* 888 * best_so_far[] and this[] are both a split of an existing blame_entry 889 * that passes blame to the parent. Maintain best_so_far the best split 890 * so far, by comparing this and best_so_far and copying this into 891 * bst_so_far as needed. 892 */ 893static voidcopy_split_if_better(struct scoreboard *sb, 894struct blame_entry *best_so_far, 895struct blame_entry *this) 896{ 897int i; 898 899if(!this[1].suspect) 900return; 901if(best_so_far[1].suspect) { 902if(ent_score(sb, &this[1]) <ent_score(sb, &best_so_far[1])) 903return; 904} 905 906for(i =0; i <3; i++) 907origin_incref(this[i].suspect); 908decref_split(best_so_far); 909memcpy(best_so_far,this,sizeof(struct blame_entry [3])); 910} 911 912/* 913 * We are looking at a part of the final image represented by 914 * ent (tlno and same are offset by ent->s_lno). 915 * tlno is where we are looking at in the final image. 916 * up to (but not including) same match preimage. 917 * plno is where we are looking at in the preimage. 918 * 919 * <-------------- final image ----------------------> 920 * <------ent------> 921 * ^tlno ^same 922 * <---------preimage-----> 923 * ^plno 924 * 925 * All line numbers are 0-based. 926 */ 927static voidhandle_split(struct scoreboard *sb, 928struct blame_entry *ent, 929int tlno,int plno,int same, 930struct origin *parent, 931struct blame_entry *split) 932{ 933if(ent->num_lines <= tlno) 934return; 935if(tlno < same) { 936struct blame_entry this[3]; 937 tlno += ent->s_lno; 938 same += ent->s_lno; 939split_overlap(this, ent, tlno, plno, same, parent); 940copy_split_if_better(sb, split,this); 941decref_split(this); 942} 943} 944 945/* 946 * Find the lines from parent that are the same as ent so that 947 * we can pass blames to it. file_p has the blob contents for 948 * the parent. 949 */ 950static voidfind_copy_in_blob(struct scoreboard *sb, 951struct blame_entry *ent, 952struct origin *parent, 953struct blame_entry *split, 954 mmfile_t *file_p) 955{ 956const char*cp; 957int cnt; 958 mmfile_t file_o; 959struct patch *patch; 960int i, plno, tlno; 961 962/* 963 * Prepare mmfile that contains only the lines in ent. 964 */ 965 cp =nth_line(sb, ent->lno); 966 file_o.ptr = (char*) cp; 967 cnt = ent->num_lines; 968 969while(cnt && cp < sb->final_buf + sb->final_buf_size) { 970if(*cp++ =='\n') 971 cnt--; 972} 973 file_o.size = cp - file_o.ptr; 974 975 patch =compare_buffer(file_p, &file_o,1); 976 977/* 978 * file_o is a part of final image we are annotating. 979 * file_p partially may match that image. 980 */ 981memset(split,0,sizeof(struct blame_entry [3])); 982 plno = tlno =0; 983for(i =0; i < patch->num; i++) { 984struct chunk *chunk = &patch->chunks[i]; 985 986handle_split(sb, ent, tlno, plno, chunk->same, parent, split); 987 plno = chunk->p_next; 988 tlno = chunk->t_next; 989} 990/* remainder, if any, all match the preimage */ 991handle_split(sb, ent, tlno, plno, ent->num_lines, parent, split); 992free_patch(patch); 993} 994 995/* 996 * See if lines currently target is suspected for can be attributed to 997 * parent. 998 */ 999static intfind_move_in_parent(struct scoreboard *sb,1000struct origin *target,1001struct origin *parent)1002{1003int last_in_target, made_progress;1004struct blame_entry *e, split[3];1005 mmfile_t file_p;10061007 last_in_target =find_last_in_target(sb, target);1008if(last_in_target <0)1009return1;/* nothing remains for this target */10101011fill_origin_blob(parent, &file_p);1012if(!file_p.ptr)1013return0;10141015 made_progress =1;1016while(made_progress) {1017 made_progress =0;1018for(e = sb->ent; e; e = e->next) {1019if(e->guilty || !same_suspect(e->suspect, target))1020continue;1021find_copy_in_blob(sb, e, parent, split, &file_p);1022if(split[1].suspect &&1023 blame_move_score <ent_score(sb, &split[1])) {1024split_blame(sb, split, e);1025 made_progress =1;1026}1027decref_split(split);1028}1029}1030return0;1031}10321033struct blame_list {1034struct blame_entry *ent;1035struct blame_entry split[3];1036};10371038/*1039 * Count the number of entries the target is suspected for,1040 * and prepare a list of entry and the best split.1041 */1042static struct blame_list *setup_blame_list(struct scoreboard *sb,1043struct origin *target,1044int*num_ents_p)1045{1046struct blame_entry *e;1047int num_ents, i;1048struct blame_list *blame_list = NULL;10491050for(e = sb->ent, num_ents =0; e; e = e->next)1051if(!e->guilty &&same_suspect(e->suspect, target))1052 num_ents++;1053if(num_ents) {1054 blame_list =xcalloc(num_ents,sizeof(struct blame_list));1055for(e = sb->ent, i =0; e; e = e->next)1056if(!e->guilty &&same_suspect(e->suspect, target))1057 blame_list[i++].ent = e;1058}1059*num_ents_p = num_ents;1060return blame_list;1061}10621063/*1064 * For lines target is suspected for, see if we can find code movement1065 * across file boundary from the parent commit. porigin is the path1066 * in the parent we already tried.1067 */1068static intfind_copy_in_parent(struct scoreboard *sb,1069struct origin *target,1070struct commit *parent,1071struct origin *porigin,1072int opt)1073{1074struct diff_options diff_opts;1075const char*paths[1];1076int i, j;1077int retval;1078struct blame_list *blame_list;1079int num_ents;10801081 blame_list =setup_blame_list(sb, target, &num_ents);1082if(!blame_list)1083return1;/* nothing remains for this target */10841085diff_setup(&diff_opts);1086DIFF_OPT_SET(&diff_opts, RECURSIVE);1087 diff_opts.output_format = DIFF_FORMAT_NO_OUTPUT;10881089 paths[0] = NULL;1090diff_tree_setup_paths(paths, &diff_opts);1091if(diff_setup_done(&diff_opts) <0)1092die("diff-setup");10931094/* Try "find copies harder" on new path if requested;1095 * we do not want to use diffcore_rename() actually to1096 * match things up; find_copies_harder is set only to1097 * force diff_tree_sha1() to feed all filepairs to diff_queue,1098 * and this code needs to be after diff_setup_done(), which1099 * usually makes find-copies-harder imply copy detection.1100 */1101if((opt & PICKAXE_BLAME_COPY_HARDEST)1102|| ((opt & PICKAXE_BLAME_COPY_HARDER)1103&& (!porigin ||strcmp(target->path, porigin->path))))1104DIFF_OPT_SET(&diff_opts, FIND_COPIES_HARDER);11051106if(is_null_sha1(target->commit->object.sha1))1107do_diff_cache(parent->tree->object.sha1, &diff_opts);1108else1109diff_tree_sha1(parent->tree->object.sha1,1110 target->commit->tree->object.sha1,1111"", &diff_opts);11121113if(!DIFF_OPT_TST(&diff_opts, FIND_COPIES_HARDER))1114diffcore_std(&diff_opts);11151116 retval =0;1117while(1) {1118int made_progress =0;11191120for(i =0; i < diff_queued_diff.nr; i++) {1121struct diff_filepair *p = diff_queued_diff.queue[i];1122struct origin *norigin;1123 mmfile_t file_p;1124struct blame_entry this[3];11251126if(!DIFF_FILE_VALID(p->one))1127continue;/* does not exist in parent */1128if(porigin && !strcmp(p->one->path, porigin->path))1129/* find_move already dealt with this path */1130continue;11311132 norigin =get_origin(sb, parent, p->one->path);1133hashcpy(norigin->blob_sha1, p->one->sha1);1134fill_origin_blob(norigin, &file_p);1135if(!file_p.ptr)1136continue;11371138for(j =0; j < num_ents; j++) {1139find_copy_in_blob(sb, blame_list[j].ent,1140 norigin,this, &file_p);1141copy_split_if_better(sb, blame_list[j].split,1142this);1143decref_split(this);1144}1145origin_decref(norigin);1146}11471148for(j =0; j < num_ents; j++) {1149struct blame_entry *split = blame_list[j].split;1150if(split[1].suspect &&1151 blame_copy_score <ent_score(sb, &split[1])) {1152split_blame(sb, split, blame_list[j].ent);1153 made_progress =1;1154}1155decref_split(split);1156}1157free(blame_list);11581159if(!made_progress)1160break;1161 blame_list =setup_blame_list(sb, target, &num_ents);1162if(!blame_list) {1163 retval =1;1164break;1165}1166}1167diff_flush(&diff_opts);1168diff_tree_release_paths(&diff_opts);1169return retval;1170}11711172/*1173 * The blobs of origin and porigin exactly match, so everything1174 * origin is suspected for can be blamed on the parent.1175 */1176static voidpass_whole_blame(struct scoreboard *sb,1177struct origin *origin,struct origin *porigin)1178{1179struct blame_entry *e;11801181if(!porigin->file.ptr && origin->file.ptr) {1182/* Steal its file */1183 porigin->file = origin->file;1184 origin->file.ptr = NULL;1185}1186for(e = sb->ent; e; e = e->next) {1187if(!same_suspect(e->suspect, origin))1188continue;1189origin_incref(porigin);1190origin_decref(e->suspect);1191 e->suspect = porigin;1192}1193}11941195/*1196 * We pass blame from the current commit to its parents. We keep saying1197 * "parent" (and "porigin"), but what we mean is to find scapegoat to1198 * exonerate ourselves.1199 */1200static struct commit_list *first_scapegoat(struct rev_info *revs,struct commit *commit)1201{1202if(!reverse)1203return commit->parents;1204returnlookup_decoration(&revs->children, &commit->object);1205}12061207static intnum_scapegoats(struct rev_info *revs,struct commit *commit)1208{1209int cnt;1210struct commit_list *l =first_scapegoat(revs, commit);1211for(cnt =0; l; l = l->next)1212 cnt++;1213return cnt;1214}12151216#define MAXSG 1612171218static voidpass_blame(struct scoreboard *sb,struct origin *origin,int opt)1219{1220struct rev_info *revs = sb->revs;1221int i, pass, num_sg;1222struct commit *commit = origin->commit;1223struct commit_list *sg;1224struct origin *sg_buf[MAXSG];1225struct origin *porigin, **sg_origin = sg_buf;12261227 num_sg =num_scapegoats(revs, commit);1228if(!num_sg)1229goto finish;1230else if(num_sg <ARRAY_SIZE(sg_buf))1231memset(sg_buf,0,sizeof(sg_buf));1232else1233 sg_origin =xcalloc(num_sg,sizeof(*sg_origin));12341235/*1236 * The first pass looks for unrenamed path to optimize for1237 * common cases, then we look for renames in the second pass.1238 */1239for(pass =0; pass <2; pass++) {1240struct origin *(*find)(struct scoreboard *,1241struct commit *,struct origin *);1242 find = pass ? find_rename : find_origin;12431244for(i =0, sg =first_scapegoat(revs, commit);1245 i < num_sg && sg;1246 sg = sg->next, i++) {1247struct commit *p = sg->item;1248int j, same;12491250if(sg_origin[i])1251continue;1252if(parse_commit(p))1253continue;1254 porigin =find(sb, p, origin);1255if(!porigin)1256continue;1257if(!hashcmp(porigin->blob_sha1, origin->blob_sha1)) {1258pass_whole_blame(sb, origin, porigin);1259origin_decref(porigin);1260goto finish;1261}1262for(j = same =0; j < i; j++)1263if(sg_origin[j] &&1264!hashcmp(sg_origin[j]->blob_sha1,1265 porigin->blob_sha1)) {1266 same =1;1267break;1268}1269if(!same)1270 sg_origin[i] = porigin;1271else1272origin_decref(porigin);1273}1274}12751276 num_commits++;1277for(i =0, sg =first_scapegoat(revs, commit);1278 i < num_sg && sg;1279 sg = sg->next, i++) {1280struct origin *porigin = sg_origin[i];1281if(!porigin)1282continue;1283if(pass_blame_to_parent(sb, origin, porigin))1284goto finish;1285}12861287/*1288 * Optionally find moves in parents' files.1289 */1290if(opt & PICKAXE_BLAME_MOVE)1291for(i =0, sg =first_scapegoat(revs, commit);1292 i < num_sg && sg;1293 sg = sg->next, i++) {1294struct origin *porigin = sg_origin[i];1295if(!porigin)1296continue;1297if(find_move_in_parent(sb, origin, porigin))1298goto finish;1299}13001301/*1302 * Optionally find copies from parents' files.1303 */1304if(opt & PICKAXE_BLAME_COPY)1305for(i =0, sg =first_scapegoat(revs, commit);1306 i < num_sg && sg;1307 sg = sg->next, i++) {1308struct origin *porigin = sg_origin[i];1309if(find_copy_in_parent(sb, origin, sg->item,1310 porigin, opt))1311goto finish;1312}13131314 finish:1315for(i =0; i < num_sg; i++) {1316if(sg_origin[i]) {1317drop_origin_blob(sg_origin[i]);1318origin_decref(sg_origin[i]);1319}1320}1321drop_origin_blob(origin);1322if(sg_buf != sg_origin)1323free(sg_origin);1324}13251326/*1327 * Information on commits, used for output.1328 */1329struct commit_info1330{1331const char*author;1332const char*author_mail;1333unsigned long author_time;1334const char*author_tz;13351336/* filled only when asked for details */1337const char*committer;1338const char*committer_mail;1339unsigned long committer_time;1340const char*committer_tz;13411342const char*summary;1343};13441345/*1346 * Parse author/committer line in the commit object buffer1347 */1348static voidget_ac_line(const char*inbuf,const char*what,1349int bufsz,char*person,const char**mail,1350unsigned long*time,const char**tz)1351{1352int len, tzlen, maillen;1353char*tmp, *endp, *timepos;13541355 tmp =strstr(inbuf, what);1356if(!tmp)1357goto error_out;1358 tmp +=strlen(what);1359 endp =strchr(tmp,'\n');1360if(!endp)1361 len =strlen(tmp);1362else1363 len = endp - tmp;1364if(bufsz <= len) {1365 error_out:1366/* Ugh */1367*mail = *tz ="(unknown)";1368*time =0;1369return;1370}1371memcpy(person, tmp, len);13721373 tmp = person;1374 tmp += len;1375*tmp =0;1376while(*tmp !=' ')1377 tmp--;1378*tz = tmp+1;1379 tzlen = (person+len)-(tmp+1);13801381*tmp =0;1382while(*tmp !=' ')1383 tmp--;1384*time =strtoul(tmp, NULL,10);1385 timepos = tmp;13861387*tmp =0;1388while(*tmp !=' ')1389 tmp--;1390*mail = tmp +1;1391*tmp =0;1392 maillen = timepos - tmp;13931394if(!mailmap.nr)1395return;13961397/*1398 * mailmap expansion may make the name longer.1399 * make room by pushing stuff down.1400 */1401 tmp = person + bufsz - (tzlen +1);1402memmove(tmp, *tz, tzlen);1403 tmp[tzlen] =0;1404*tz = tmp;14051406 tmp = tmp - (maillen +1);1407memmove(tmp, *mail, maillen);1408 tmp[maillen] =0;1409*mail = tmp;14101411/*1412 * Now, convert e-mail using mailmap1413 */1414map_email(&mailmap, tmp +1, person, tmp-person-1);1415}14161417static voidget_commit_info(struct commit *commit,1418struct commit_info *ret,1419int detailed)1420{1421int len;1422char*tmp, *endp;1423static char author_buf[1024];1424static char committer_buf[1024];1425static char summary_buf[1024];14261427/*1428 * We've operated without save_commit_buffer, so1429 * we now need to populate them for output.1430 */1431if(!commit->buffer) {1432enum object_type type;1433unsigned long size;1434 commit->buffer =1435read_sha1_file(commit->object.sha1, &type, &size);1436if(!commit->buffer)1437die("Cannot read commit%s",1438sha1_to_hex(commit->object.sha1));1439}1440 ret->author = author_buf;1441get_ac_line(commit->buffer,"\nauthor ",1442sizeof(author_buf), author_buf, &ret->author_mail,1443&ret->author_time, &ret->author_tz);14441445if(!detailed)1446return;14471448 ret->committer = committer_buf;1449get_ac_line(commit->buffer,"\ncommitter ",1450sizeof(committer_buf), committer_buf, &ret->committer_mail,1451&ret->committer_time, &ret->committer_tz);14521453 ret->summary = summary_buf;1454 tmp =strstr(commit->buffer,"\n\n");1455if(!tmp) {1456 error_out:1457sprintf(summary_buf,"(%s)",sha1_to_hex(commit->object.sha1));1458return;1459}1460 tmp +=2;1461 endp =strchr(tmp,'\n');1462if(!endp)1463 endp = tmp +strlen(tmp);1464 len = endp - tmp;1465if(len >=sizeof(summary_buf) || len ==0)1466goto error_out;1467memcpy(summary_buf, tmp, len);1468 summary_buf[len] =0;1469}14701471/*1472 * To allow LF and other nonportable characters in pathnames,1473 * they are c-style quoted as needed.1474 */1475static voidwrite_filename_info(const char*path)1476{1477printf("filename ");1478write_name_quoted(path, stdout,'\n');1479}14801481/*1482 * The blame_entry is found to be guilty for the range. Mark it1483 * as such, and show it in incremental output.1484 */1485static voidfound_guilty_entry(struct blame_entry *ent)1486{1487if(ent->guilty)1488return;1489 ent->guilty =1;1490if(incremental) {1491struct origin *suspect = ent->suspect;14921493printf("%s %d %d %d\n",1494sha1_to_hex(suspect->commit->object.sha1),1495 ent->s_lno +1, ent->lno +1, ent->num_lines);1496if(!(suspect->commit->object.flags & METAINFO_SHOWN)) {1497struct commit_info ci;1498 suspect->commit->object.flags |= METAINFO_SHOWN;1499get_commit_info(suspect->commit, &ci,1);1500printf("author%s\n", ci.author);1501printf("author-mail%s\n", ci.author_mail);1502printf("author-time%lu\n", ci.author_time);1503printf("author-tz%s\n", ci.author_tz);1504printf("committer%s\n", ci.committer);1505printf("committer-mail%s\n", ci.committer_mail);1506printf("committer-time%lu\n", ci.committer_time);1507printf("committer-tz%s\n", ci.committer_tz);1508printf("summary%s\n", ci.summary);1509if(suspect->commit->object.flags & UNINTERESTING)1510printf("boundary\n");1511}1512write_filename_info(suspect->path);1513maybe_flush_or_die(stdout,"stdout");1514}1515}15161517/*1518 * The main loop -- while the scoreboard has lines whose true origin1519 * is still unknown, pick one blame_entry, and allow its current1520 * suspect to pass blames to its parents.1521 */1522static voidassign_blame(struct scoreboard *sb,int opt)1523{1524struct rev_info *revs = sb->revs;15251526while(1) {1527struct blame_entry *ent;1528struct commit *commit;1529struct origin *suspect = NULL;15301531/* find one suspect to break down */1532for(ent = sb->ent; !suspect && ent; ent = ent->next)1533if(!ent->guilty)1534 suspect = ent->suspect;1535if(!suspect)1536return;/* all done */15371538/*1539 * We will use this suspect later in the loop,1540 * so hold onto it in the meantime.1541 */1542origin_incref(suspect);1543 commit = suspect->commit;1544if(!commit->object.parsed)1545parse_commit(commit);1546if(reverse ||1547(!(commit->object.flags & UNINTERESTING) &&1548!(revs->max_age != -1&& commit->date < revs->max_age)))1549pass_blame(sb, suspect, opt);1550else{1551 commit->object.flags |= UNINTERESTING;1552if(commit->object.parsed)1553mark_parents_uninteresting(commit);1554}1555/* treat root commit as boundary */1556if(!commit->parents && !show_root)1557 commit->object.flags |= UNINTERESTING;15581559/* Take responsibility for the remaining entries */1560for(ent = sb->ent; ent; ent = ent->next)1561if(same_suspect(ent->suspect, suspect))1562found_guilty_entry(ent);1563origin_decref(suspect);15641565if(DEBUG)/* sanity */1566sanity_check_refcnt(sb);1567}1568}15691570static const char*format_time(unsigned long time,const char*tz_str,1571int show_raw_time)1572{1573static char time_buf[128];1574time_t t = time;1575int minutes, tz;1576struct tm *tm;15771578if(show_raw_time) {1579sprintf(time_buf,"%lu%s", time, tz_str);1580return time_buf;1581}15821583 tz =atoi(tz_str);1584 minutes = tz <0? -tz : tz;1585 minutes = (minutes /100)*60+ (minutes %100);1586 minutes = tz <0? -minutes : minutes;1587 t = time + minutes *60;1588 tm =gmtime(&t);15891590strftime(time_buf,sizeof(time_buf),"%Y-%m-%d %H:%M:%S", tm);1591strcat(time_buf, tz_str);1592return time_buf;1593}15941595#define OUTPUT_ANNOTATE_COMPAT 0011596#define OUTPUT_LONG_OBJECT_NAME 0021597#define OUTPUT_RAW_TIMESTAMP 0041598#define OUTPUT_PORCELAIN 0101599#define OUTPUT_SHOW_NAME 0201600#define OUTPUT_SHOW_NUMBER 0401601#define OUTPUT_SHOW_SCORE 01001602#define OUTPUT_NO_AUTHOR 020016031604static voidemit_porcelain(struct scoreboard *sb,struct blame_entry *ent)1605{1606int cnt;1607const char*cp;1608struct origin *suspect = ent->suspect;1609char hex[41];16101611strcpy(hex,sha1_to_hex(suspect->commit->object.sha1));1612printf("%s%c%d %d %d\n",1613 hex,1614 ent->guilty ?' ':'*',// purely for debugging1615 ent->s_lno +1,1616 ent->lno +1,1617 ent->num_lines);1618if(!(suspect->commit->object.flags & METAINFO_SHOWN)) {1619struct commit_info ci;1620 suspect->commit->object.flags |= METAINFO_SHOWN;1621get_commit_info(suspect->commit, &ci,1);1622printf("author%s\n", ci.author);1623printf("author-mail%s\n", ci.author_mail);1624printf("author-time%lu\n", ci.author_time);1625printf("author-tz%s\n", ci.author_tz);1626printf("committer%s\n", ci.committer);1627printf("committer-mail%s\n", ci.committer_mail);1628printf("committer-time%lu\n", ci.committer_time);1629printf("committer-tz%s\n", ci.committer_tz);1630write_filename_info(suspect->path);1631printf("summary%s\n", ci.summary);1632if(suspect->commit->object.flags & UNINTERESTING)1633printf("boundary\n");1634}1635else if(suspect->commit->object.flags & MORE_THAN_ONE_PATH)1636write_filename_info(suspect->path);16371638 cp =nth_line(sb, ent->lno);1639for(cnt =0; cnt < ent->num_lines; cnt++) {1640char ch;1641if(cnt)1642printf("%s %d %d\n", hex,1643 ent->s_lno +1+ cnt,1644 ent->lno +1+ cnt);1645putchar('\t');1646do{1647 ch = *cp++;1648putchar(ch);1649}while(ch !='\n'&&1650 cp < sb->final_buf + sb->final_buf_size);1651}1652}16531654static voidemit_other(struct scoreboard *sb,struct blame_entry *ent,int opt)1655{1656int cnt;1657const char*cp;1658struct origin *suspect = ent->suspect;1659struct commit_info ci;1660char hex[41];1661int show_raw_time = !!(opt & OUTPUT_RAW_TIMESTAMP);16621663get_commit_info(suspect->commit, &ci,1);1664strcpy(hex,sha1_to_hex(suspect->commit->object.sha1));16651666 cp =nth_line(sb, ent->lno);1667for(cnt =0; cnt < ent->num_lines; cnt++) {1668char ch;1669int length = (opt & OUTPUT_LONG_OBJECT_NAME) ?40:8;16701671if(suspect->commit->object.flags & UNINTERESTING) {1672if(blank_boundary)1673memset(hex,' ', length);1674else if(!cmd_is_annotate) {1675 length--;1676putchar('^');1677}1678}16791680printf("%.*s", length, hex);1681if(opt & OUTPUT_ANNOTATE_COMPAT)1682printf("\t(%10s\t%10s\t%d)", ci.author,1683format_time(ci.author_time, ci.author_tz,1684 show_raw_time),1685 ent->lno +1+ cnt);1686else{1687if(opt & OUTPUT_SHOW_SCORE)1688printf(" %*d%02d",1689 max_score_digits, ent->score,1690 ent->suspect->refcnt);1691if(opt & OUTPUT_SHOW_NAME)1692printf(" %-*.*s", longest_file, longest_file,1693 suspect->path);1694if(opt & OUTPUT_SHOW_NUMBER)1695printf(" %*d", max_orig_digits,1696 ent->s_lno +1+ cnt);16971698if(!(opt & OUTPUT_NO_AUTHOR))1699printf(" (%-*.*s%10s",1700 longest_author, longest_author,1701 ci.author,1702format_time(ci.author_time,1703 ci.author_tz,1704 show_raw_time));1705printf(" %*d) ",1706 max_digits, ent->lno +1+ cnt);1707}1708do{1709 ch = *cp++;1710putchar(ch);1711}while(ch !='\n'&&1712 cp < sb->final_buf + sb->final_buf_size);1713}1714}17151716static voidoutput(struct scoreboard *sb,int option)1717{1718struct blame_entry *ent;17191720if(option & OUTPUT_PORCELAIN) {1721for(ent = sb->ent; ent; ent = ent->next) {1722struct blame_entry *oth;1723struct origin *suspect = ent->suspect;1724struct commit *commit = suspect->commit;1725if(commit->object.flags & MORE_THAN_ONE_PATH)1726continue;1727for(oth = ent->next; oth; oth = oth->next) {1728if((oth->suspect->commit != commit) ||1729!strcmp(oth->suspect->path, suspect->path))1730continue;1731 commit->object.flags |= MORE_THAN_ONE_PATH;1732break;1733}1734}1735}17361737for(ent = sb->ent; ent; ent = ent->next) {1738if(option & OUTPUT_PORCELAIN)1739emit_porcelain(sb, ent);1740else{1741emit_other(sb, ent, option);1742}1743}1744}17451746/*1747 * To allow quick access to the contents of nth line in the1748 * final image, prepare an index in the scoreboard.1749 */1750static intprepare_lines(struct scoreboard *sb)1751{1752const char*buf = sb->final_buf;1753unsigned long len = sb->final_buf_size;1754int num =0, incomplete =0, bol =1;17551756if(len && buf[len-1] !='\n')1757 incomplete++;/* incomplete line at the end */1758while(len--) {1759if(bol) {1760 sb->lineno =xrealloc(sb->lineno,1761sizeof(int* ) * (num +1));1762 sb->lineno[num] = buf - sb->final_buf;1763 bol =0;1764}1765if(*buf++ =='\n') {1766 num++;1767 bol =1;1768}1769}1770 sb->lineno =xrealloc(sb->lineno,1771sizeof(int* ) * (num + incomplete +1));1772 sb->lineno[num + incomplete] = buf - sb->final_buf;1773 sb->num_lines = num + incomplete;1774return sb->num_lines;1775}17761777/*1778 * Add phony grafts for use with -S; this is primarily to1779 * support git-cvsserver that wants to give a linear history1780 * to its clients.1781 */1782static intread_ancestry(const char*graft_file)1783{1784FILE*fp =fopen(graft_file,"r");1785char buf[1024];1786if(!fp)1787return-1;1788while(fgets(buf,sizeof(buf), fp)) {1789/* The format is just "Commit Parent1 Parent2 ...\n" */1790int len =strlen(buf);1791struct commit_graft *graft =read_graft_line(buf, len);1792if(graft)1793register_commit_graft(graft,0);1794}1795fclose(fp);1796return0;1797}17981799/*1800 * How many columns do we need to show line numbers in decimal?1801 */1802static intlineno_width(int lines)1803{1804int i, width;18051806for(width =1, i =10; i <= lines +1; width++)1807 i *=10;1808return width;1809}18101811/*1812 * How many columns do we need to show line numbers, authors,1813 * and filenames?1814 */1815static voidfind_alignment(struct scoreboard *sb,int*option)1816{1817int longest_src_lines =0;1818int longest_dst_lines =0;1819unsigned largest_score =0;1820struct blame_entry *e;18211822for(e = sb->ent; e; e = e->next) {1823struct origin *suspect = e->suspect;1824struct commit_info ci;1825int num;18261827if(strcmp(suspect->path, sb->path))1828*option |= OUTPUT_SHOW_NAME;1829 num =strlen(suspect->path);1830if(longest_file < num)1831 longest_file = num;1832if(!(suspect->commit->object.flags & METAINFO_SHOWN)) {1833 suspect->commit->object.flags |= METAINFO_SHOWN;1834get_commit_info(suspect->commit, &ci,1);1835 num =strlen(ci.author);1836if(longest_author < num)1837 longest_author = num;1838}1839 num = e->s_lno + e->num_lines;1840if(longest_src_lines < num)1841 longest_src_lines = num;1842 num = e->lno + e->num_lines;1843if(longest_dst_lines < num)1844 longest_dst_lines = num;1845if(largest_score <ent_score(sb, e))1846 largest_score =ent_score(sb, e);1847}1848 max_orig_digits =lineno_width(longest_src_lines);1849 max_digits =lineno_width(longest_dst_lines);1850 max_score_digits =lineno_width(largest_score);1851}18521853/*1854 * For debugging -- origin is refcounted, and this asserts that1855 * we do not underflow.1856 */1857static voidsanity_check_refcnt(struct scoreboard *sb)1858{1859int baa =0;1860struct blame_entry *ent;18611862for(ent = sb->ent; ent; ent = ent->next) {1863/* Nobody should have zero or negative refcnt */1864if(ent->suspect->refcnt <=0) {1865fprintf(stderr,"%sin%shas negative refcnt%d\n",1866 ent->suspect->path,1867sha1_to_hex(ent->suspect->commit->object.sha1),1868 ent->suspect->refcnt);1869 baa =1;1870}1871}1872for(ent = sb->ent; ent; ent = ent->next) {1873/* Mark the ones that haven't been checked */1874if(0< ent->suspect->refcnt)1875 ent->suspect->refcnt = -ent->suspect->refcnt;1876}1877for(ent = sb->ent; ent; ent = ent->next) {1878/*1879 * ... then pick each and see if they have the the1880 * correct refcnt.1881 */1882int found;1883struct blame_entry *e;1884struct origin *suspect = ent->suspect;18851886if(0< suspect->refcnt)1887continue;1888 suspect->refcnt = -suspect->refcnt;/* Unmark */1889for(found =0, e = sb->ent; e; e = e->next) {1890if(e->suspect != suspect)1891continue;1892 found++;1893}1894if(suspect->refcnt != found) {1895fprintf(stderr,"%sin%shas refcnt%d, not%d\n",1896 ent->suspect->path,1897sha1_to_hex(ent->suspect->commit->object.sha1),1898 ent->suspect->refcnt, found);1899 baa =2;1900}1901}1902if(baa) {1903int opt =0160;1904find_alignment(sb, &opt);1905output(sb, opt);1906die("Baa%d!", baa);1907}1908}19091910/*1911 * Used for the command line parsing; check if the path exists1912 * in the working tree.1913 */1914static inthas_path_in_work_tree(const char*path)1915{1916struct stat st;1917return!lstat(path, &st);1918}19191920static unsignedparse_score(const char*arg)1921{1922char*end;1923unsigned long score =strtoul(arg, &end,10);1924if(*end)1925return0;1926return score;1927}19281929static const char*add_prefix(const char*prefix,const char*path)1930{1931returnprefix_path(prefix, prefix ?strlen(prefix) :0, path);1932}19331934/*1935 * Parsing of (comma separated) one item in the -L option1936 */1937static const char*parse_loc(const char*spec,1938struct scoreboard *sb,long lno,1939long begin,long*ret)1940{1941char*term;1942const char*line;1943long num;1944int reg_error;1945 regex_t regexp;1946 regmatch_t match[1];19471948/* Allow "-L <something>,+20" to mean starting at <something>1949 * for 20 lines, or "-L <something>,-5" for 5 lines ending at1950 * <something>.1951 */1952if(1< begin && (spec[0] =='+'|| spec[0] =='-')) {1953 num =strtol(spec +1, &term,10);1954if(term != spec +1) {1955if(spec[0] =='-')1956 num =0- num;1957if(0< num)1958*ret = begin + num -2;1959else if(!num)1960*ret = begin;1961else1962*ret = begin + num;1963return term;1964}1965return spec;1966}1967 num =strtol(spec, &term,10);1968if(term != spec) {1969*ret = num;1970return term;1971}1972if(spec[0] !='/')1973return spec;19741975/* it could be a regexp of form /.../ */1976for(term = (char*) spec +1; *term && *term !='/'; term++) {1977if(*term =='\\')1978 term++;1979}1980if(*term !='/')1981return spec;19821983/* try [spec+1 .. term-1] as regexp */1984*term =0;1985 begin--;/* input is in human terms */1986 line =nth_line(sb, begin);19871988if(!(reg_error =regcomp(®exp, spec +1, REG_NEWLINE)) &&1989!(reg_error =regexec(®exp, line,1, match,0))) {1990const char*cp = line + match[0].rm_so;1991const char*nline;19921993while(begin++ < lno) {1994 nline =nth_line(sb, begin);1995if(line <= cp && cp < nline)1996break;1997 line = nline;1998}1999*ret = begin;2000regfree(®exp);2001*term++ ='/';2002return term;2003}2004else{2005char errbuf[1024];2006regerror(reg_error, ®exp, errbuf,1024);2007die("-L parameter '%s':%s", spec +1, errbuf);2008}2009}20102011/*2012 * Parsing of -L option2013 */2014static voidprepare_blame_range(struct scoreboard *sb,2015const char*bottomtop,2016long lno,2017long*bottom,long*top)2018{2019const char*term;20202021 term =parse_loc(bottomtop, sb, lno,1, bottom);2022if(*term ==',') {2023 term =parse_loc(term +1, sb, lno, *bottom +1, top);2024if(*term)2025usage(blame_usage);2026}2027if(*term)2028usage(blame_usage);2029}20302031static intgit_blame_config(const char*var,const char*value)2032{2033if(!strcmp(var,"blame.showroot")) {2034 show_root =git_config_bool(var, value);2035return0;2036}2037if(!strcmp(var,"blame.blankboundary")) {2038 blank_boundary =git_config_bool(var, value);2039return0;2040}2041returngit_default_config(var, value);2042}20432044/*2045 * Prepare a dummy commit that represents the work tree (or staged) item.2046 * Note that annotating work tree item never works in the reverse.2047 */2048static struct commit *fake_working_tree_commit(const char*path,const char*contents_from)2049{2050struct commit *commit;2051struct origin *origin;2052unsigned char head_sha1[20];2053struct strbuf buf;2054const char*ident;2055time_t now;2056int size, len;2057struct cache_entry *ce;2058unsigned mode;20592060if(get_sha1("HEAD", head_sha1))2061die("No such ref: HEAD");20622063time(&now);2064 commit =xcalloc(1,sizeof(*commit));2065 commit->parents =xcalloc(1,sizeof(*commit->parents));2066 commit->parents->item =lookup_commit_reference(head_sha1);2067 commit->object.parsed =1;2068 commit->date = now;2069 commit->object.type = OBJ_COMMIT;20702071 origin =make_origin(commit, path);20722073strbuf_init(&buf,0);2074if(!contents_from ||strcmp("-", contents_from)) {2075struct stat st;2076const char*read_from;2077unsigned long fin_size;20782079if(contents_from) {2080if(stat(contents_from, &st) <0)2081die("Cannot stat%s", contents_from);2082 read_from = contents_from;2083}2084else{2085if(lstat(path, &st) <0)2086die("Cannot lstat%s", path);2087 read_from = path;2088}2089 fin_size =xsize_t(st.st_size);2090 mode =canon_mode(st.st_mode);2091switch(st.st_mode & S_IFMT) {2092case S_IFREG:2093if(strbuf_read_file(&buf, read_from, st.st_size) != st.st_size)2094die("cannot open or read%s", read_from);2095break;2096case S_IFLNK:2097if(readlink(read_from, buf.buf, buf.alloc) != fin_size)2098die("cannot readlink%s", read_from);2099 buf.len = fin_size;2100break;2101default:2102die("unsupported file type%s", read_from);2103}2104}2105else{2106/* Reading from stdin */2107 contents_from ="standard input";2108 mode =0;2109if(strbuf_read(&buf,0,0) <0)2110die("read error%sfrom stdin",strerror(errno));2111}2112convert_to_git(path, buf.buf, buf.len, &buf,0);2113 origin->file.ptr = buf.buf;2114 origin->file.size = buf.len;2115pretend_sha1_file(buf.buf, buf.len, OBJ_BLOB, origin->blob_sha1);2116 commit->util = origin;21172118/*2119 * Read the current index, replace the path entry with2120 * origin->blob_sha1 without mucking with its mode or type2121 * bits; we are not going to write this index out -- we just2122 * want to run "diff-index --cached".2123 */2124discard_cache();2125read_cache();21262127 len =strlen(path);2128if(!mode) {2129int pos =cache_name_pos(path, len);2130if(0<= pos)2131 mode = active_cache[pos]->ce_mode;2132else2133/* Let's not bother reading from HEAD tree */2134 mode = S_IFREG |0644;2135}2136 size =cache_entry_size(len);2137 ce =xcalloc(1, size);2138hashcpy(ce->sha1, origin->blob_sha1);2139memcpy(ce->name, path, len);2140 ce->ce_flags =create_ce_flags(len,0);2141 ce->ce_mode =create_ce_mode(mode);2142add_cache_entry(ce, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE);21432144/*2145 * We are not going to write this out, so this does not matter2146 * right now, but someday we might optimize diff-index --cached2147 * with cache-tree information.2148 */2149cache_tree_invalidate_path(active_cache_tree, path);21502151 commit->buffer =xmalloc(400);2152 ident =fmt_ident("Not Committed Yet","not.committed.yet", NULL,0);2153snprintf(commit->buffer,400,2154"tree 0000000000000000000000000000000000000000\n"2155"parent%s\n"2156"author%s\n"2157"committer%s\n\n"2158"Version of%sfrom%s\n",2159sha1_to_hex(head_sha1),2160 ident, ident, path, contents_from ? contents_from : path);2161return commit;2162}21632164static const char*prepare_final(struct scoreboard *sb)2165{2166int i;2167const char*final_commit_name = NULL;2168struct rev_info *revs = sb->revs;21692170/*2171 * There must be one and only one positive commit in the2172 * revs->pending array.2173 */2174for(i =0; i < revs->pending.nr; i++) {2175struct object *obj = revs->pending.objects[i].item;2176if(obj->flags & UNINTERESTING)2177continue;2178while(obj->type == OBJ_TAG)2179 obj =deref_tag(obj, NULL,0);2180if(obj->type != OBJ_COMMIT)2181die("Non commit%s?", revs->pending.objects[i].name);2182if(sb->final)2183die("More than one commit to dig from%sand%s?",2184 revs->pending.objects[i].name,2185 final_commit_name);2186 sb->final = (struct commit *) obj;2187 final_commit_name = revs->pending.objects[i].name;2188}2189return final_commit_name;2190}21912192static const char*prepare_initial(struct scoreboard *sb)2193{2194int i;2195const char*final_commit_name = NULL;2196struct rev_info *revs = sb->revs;21972198/*2199 * There must be one and only one negative commit, and it must be2200 * the boundary.2201 */2202for(i =0; i < revs->pending.nr; i++) {2203struct object *obj = revs->pending.objects[i].item;2204if(!(obj->flags & UNINTERESTING))2205continue;2206while(obj->type == OBJ_TAG)2207 obj =deref_tag(obj, NULL,0);2208if(obj->type != OBJ_COMMIT)2209die("Non commit%s?", revs->pending.objects[i].name);2210if(sb->final)2211die("More than one commit to dig down to%sand%s?",2212 revs->pending.objects[i].name,2213 final_commit_name);2214 sb->final = (struct commit *) obj;2215 final_commit_name = revs->pending.objects[i].name;2216}2217if(!final_commit_name)2218die("No commit to dig down to?");2219return final_commit_name;2220}22212222intcmd_blame(int argc,const char**argv,const char*prefix)2223{2224struct rev_info revs;2225const char*path;2226struct scoreboard sb;2227struct origin *o;2228struct blame_entry *ent;2229int i, seen_dashdash, unk, opt;2230long bottom, top, lno;2231int output_option =0;2232int show_stats =0;2233const char*revs_file = NULL;2234const char*final_commit_name = NULL;2235enum object_type type;2236const char*bottomtop = NULL;2237const char*contents_from = NULL;22382239 cmd_is_annotate = !strcmp(argv[0],"annotate");22402241git_config(git_blame_config);2242 save_commit_buffer =0;22432244 opt =0;2245 seen_dashdash =0;2246for(unk = i =1; i < argc; i++) {2247const char*arg = argv[i];2248if(*arg !='-')2249break;2250else if(!strcmp("-b", arg))2251 blank_boundary =1;2252else if(!strcmp("--root", arg))2253 show_root =1;2254else if(!strcmp("--reverse", arg)) {2255 argv[unk++] ="--children";2256 reverse =1;2257}2258else if(!strcmp(arg,"--show-stats"))2259 show_stats =1;2260else if(!strcmp("-c", arg))2261 output_option |= OUTPUT_ANNOTATE_COMPAT;2262else if(!strcmp("-t", arg))2263 output_option |= OUTPUT_RAW_TIMESTAMP;2264else if(!strcmp("-l", arg))2265 output_option |= OUTPUT_LONG_OBJECT_NAME;2266else if(!strcmp("-s", arg))2267 output_option |= OUTPUT_NO_AUTHOR;2268else if(!strcmp("-w", arg))2269 xdl_opts |= XDF_IGNORE_WHITESPACE;2270else if(!strcmp("-S", arg) && ++i < argc)2271 revs_file = argv[i];2272else if(!prefixcmp(arg,"-M")) {2273 opt |= PICKAXE_BLAME_MOVE;2274 blame_move_score =parse_score(arg+2);2275}2276else if(!prefixcmp(arg,"-C")) {2277/*2278 * -C enables copy from removed files;2279 * -C -C enables copy from existing files, but only2280 * when blaming a new file;2281 * -C -C -C enables copy from existing files for2282 * everybody2283 */2284if(opt & PICKAXE_BLAME_COPY_HARDER)2285 opt |= PICKAXE_BLAME_COPY_HARDEST;2286if(opt & PICKAXE_BLAME_COPY)2287 opt |= PICKAXE_BLAME_COPY_HARDER;2288 opt |= PICKAXE_BLAME_COPY | PICKAXE_BLAME_MOVE;2289 blame_copy_score =parse_score(arg+2);2290}2291else if(!prefixcmp(arg,"-L")) {2292if(!arg[2]) {2293if(++i >= argc)2294usage(blame_usage);2295 arg = argv[i];2296}2297else2298 arg +=2;2299if(bottomtop)2300die("More than one '-L n,m' option given");2301 bottomtop = arg;2302}2303else if(!strcmp("--contents", arg)) {2304if(++i >= argc)2305usage(blame_usage);2306 contents_from = argv[i];2307}2308else if(!strcmp("--incremental", arg))2309 incremental =1;2310else if(!strcmp("--score-debug", arg))2311 output_option |= OUTPUT_SHOW_SCORE;2312else if(!strcmp("-f", arg) ||2313!strcmp("--show-name", arg))2314 output_option |= OUTPUT_SHOW_NAME;2315else if(!strcmp("-n", arg) ||2316!strcmp("--show-number", arg))2317 output_option |= OUTPUT_SHOW_NUMBER;2318else if(!strcmp("-p", arg) ||2319!strcmp("--porcelain", arg))2320 output_option |= OUTPUT_PORCELAIN;2321else if(!strcmp("--", arg)) {2322 seen_dashdash =1;2323 i++;2324break;2325}2326else2327 argv[unk++] = arg;2328}23292330if(!blame_move_score)2331 blame_move_score = BLAME_DEFAULT_MOVE_SCORE;2332if(!blame_copy_score)2333 blame_copy_score = BLAME_DEFAULT_COPY_SCORE;23342335/*2336 * We have collected options unknown to us in argv[1..unk]2337 * which are to be passed to revision machinery if we are2338 * going to do the "bottom" processing.2339 *2340 * The remaining are:2341 *2342 * (1) if seen_dashdash, its either2343 * "-options -- <path>" or2344 * "-options -- <path> <rev>".2345 * but the latter is allowed only if there is no2346 * options that we passed to revision machinery.2347 *2348 * (2) otherwise, we may have "--" somewhere later and2349 * might be looking at the first one of multiple 'rev'2350 * parameters (e.g. " master ^next ^maint -- path").2351 * See if there is a dashdash first, and give the2352 * arguments before that to revision machinery.2353 * After that there must be one 'path'.2354 *2355 * (3) otherwise, its one of the three:2356 * "-options <path> <rev>"2357 * "-options <rev> <path>"2358 * "-options <path>"2359 * but again the first one is allowed only if2360 * there is no options that we passed to revision2361 * machinery.2362 */23632364if(seen_dashdash) {2365/* (1) */2366if(argc <= i)2367usage(blame_usage);2368 path =add_prefix(prefix, argv[i]);2369if(i +1== argc -1) {2370if(unk !=1)2371usage(blame_usage);2372 argv[unk++] = argv[i +1];2373}2374else if(i +1!= argc)2375/* garbage at end */2376usage(blame_usage);2377}2378else{2379int j;2380for(j = i; !seen_dashdash && j < argc; j++)2381if(!strcmp(argv[j],"--"))2382 seen_dashdash = j;2383if(seen_dashdash) {2384/* (2) */2385if(seen_dashdash +1!= argc -1)2386usage(blame_usage);2387 path =add_prefix(prefix, argv[seen_dashdash +1]);2388for(j = i; j < seen_dashdash; j++)2389 argv[unk++] = argv[j];2390}2391else{2392/* (3) */2393if(argc <= i)2394usage(blame_usage);2395 path =add_prefix(prefix, argv[i]);2396if(i +1== argc -1) {2397 final_commit_name = argv[i +1];23982399/* if (unk == 1) we could be getting2400 * old-style2401 */2402if(unk ==1&& !has_path_in_work_tree(path)) {2403 path =add_prefix(prefix, argv[i +1]);2404 final_commit_name = argv[i];2405}2406}2407else if(i != argc -1)2408usage(blame_usage);/* garbage at end */24092410setup_work_tree();2411if(!has_path_in_work_tree(path))2412die("cannot stat path%s:%s",2413 path,strerror(errno));2414}2415}24162417if(final_commit_name)2418 argv[unk++] = final_commit_name;24192420/*2421 * Now we got rev and path. We do not want the path pruning2422 * but we may want "bottom" processing.2423 */2424 argv[unk++] ="--";/* terminate the rev name */2425 argv[unk] = NULL;24262427init_revisions(&revs, NULL);2428setup_revisions(unk, argv, &revs, NULL);2429memset(&sb,0,sizeof(sb));24302431 sb.revs = &revs;2432if(!reverse)2433 final_commit_name =prepare_final(&sb);2434else if(contents_from)2435die("--contents and --children do not blend well.");2436else2437 final_commit_name =prepare_initial(&sb);24382439if(!sb.final) {2440/*2441 * "--not A B -- path" without anything positive;2442 * do not default to HEAD, but use the working tree2443 * or "--contents".2444 */2445setup_work_tree();2446 sb.final =fake_working_tree_commit(path, contents_from);2447add_pending_object(&revs, &(sb.final->object),":");2448}2449else if(contents_from)2450die("Cannot use --contents with final commit object name");24512452/*2453 * If we have bottom, this will mark the ancestors of the2454 * bottom commits we would reach while traversing as2455 * uninteresting.2456 */2457if(prepare_revision_walk(&revs))2458die("revision walk setup failed");24592460if(is_null_sha1(sb.final->object.sha1)) {2461char*buf;2462 o = sb.final->util;2463 buf =xmalloc(o->file.size +1);2464memcpy(buf, o->file.ptr, o->file.size +1);2465 sb.final_buf = buf;2466 sb.final_buf_size = o->file.size;2467}2468else{2469 o =get_origin(&sb, sb.final, path);2470if(fill_blob_sha1(o))2471die("no such path%sin%s", path, final_commit_name);24722473 sb.final_buf =read_sha1_file(o->blob_sha1, &type,2474&sb.final_buf_size);2475if(!sb.final_buf)2476die("Cannot read blob%sfor path%s",2477sha1_to_hex(o->blob_sha1),2478 path);2479}2480 num_read_blob++;2481 lno =prepare_lines(&sb);24822483 bottom = top =0;2484if(bottomtop)2485prepare_blame_range(&sb, bottomtop, lno, &bottom, &top);2486if(bottom && top && top < bottom) {2487long tmp;2488 tmp = top; top = bottom; bottom = tmp;2489}2490if(bottom <1)2491 bottom =1;2492if(top <1)2493 top = lno;2494 bottom--;2495if(lno < top)2496die("file%shas only%lu lines", path, lno);24972498 ent =xcalloc(1,sizeof(*ent));2499 ent->lno = bottom;2500 ent->num_lines = top - bottom;2501 ent->suspect = o;2502 ent->s_lno = bottom;25032504 sb.ent = ent;2505 sb.path = path;25062507if(revs_file &&read_ancestry(revs_file))2508die("reading graft file%sfailed:%s",2509 revs_file,strerror(errno));25102511read_mailmap(&mailmap,".mailmap", NULL);25122513if(!incremental)2514setup_pager();25152516assign_blame(&sb, opt);25172518if(incremental)2519return0;25202521coalesce(&sb);25222523if(!(output_option & OUTPUT_PORCELAIN))2524find_alignment(&sb, &output_option);25252526output(&sb, output_option);2527free((void*)sb.final_buf);2528for(ent = sb.ent; ent; ) {2529struct blame_entry *e = ent->next;2530free(ent);2531 ent = e;2532}25332534if(show_stats) {2535printf("num read blob:%d\n", num_read_blob);2536printf("num get patch:%d\n", num_get_patch);2537printf("num commits:%d\n", num_commits);2538}2539return0;2540}