1/* 2 * Blame 3 * 4 * Copyright (c) 2006, 2014 by its authors 5 * See COPYING for licensing conditions 6 */ 7 8#include"cache.h" 9#include"refs.h" 10#include"builtin.h" 11#include"blob.h" 12#include"commit.h" 13#include"tag.h" 14#include"tree-walk.h" 15#include"diff.h" 16#include"diffcore.h" 17#include"revision.h" 18#include"quote.h" 19#include"xdiff-interface.h" 20#include"cache-tree.h" 21#include"string-list.h" 22#include"mailmap.h" 23#include"mergesort.h" 24#include"parse-options.h" 25#include"prio-queue.h" 26#include"utf8.h" 27#include"userdiff.h" 28#include"line-range.h" 29#include"line-log.h" 30#include"dir.h" 31#include"progress.h" 32 33static char blame_usage[] =N_("git blame [<options>] [<rev-opts>] [<rev>] [--] <file>"); 34 35static const char*blame_opt_usage[] = { 36 blame_usage, 37"", 38N_("<rev-opts> are documented in git-rev-list(1)"), 39 NULL 40}; 41 42static int longest_file; 43static int longest_author; 44static int max_orig_digits; 45static int max_digits; 46static int max_score_digits; 47static int show_root; 48static int reverse; 49static int blank_boundary; 50static int incremental; 51static int xdl_opts; 52static int abbrev = -1; 53static int no_whole_file_rename; 54static int show_progress; 55 56static struct date_mode blame_date_mode = { DATE_ISO8601 }; 57static size_t blame_date_width; 58 59static struct string_list mailmap = STRING_LIST_INIT_NODUP; 60 61#ifndef DEBUG 62#define DEBUG 0 63#endif 64 65/* stats */ 66static int num_read_blob; 67static int num_get_patch; 68static int num_commits; 69 70#define PICKAXE_BLAME_MOVE 01 71#define PICKAXE_BLAME_COPY 02 72#define PICKAXE_BLAME_COPY_HARDER 04 73#define PICKAXE_BLAME_COPY_HARDEST 010 74 75/* 76 * blame for a blame_entry with score lower than these thresholds 77 * is not passed to the parent using move/copy logic. 78 */ 79static unsigned blame_move_score; 80static unsigned blame_copy_score; 81#define BLAME_DEFAULT_MOVE_SCORE 20 82#define BLAME_DEFAULT_COPY_SCORE 40 83 84/* Remember to update object flag allocation in object.h */ 85#define METAINFO_SHOWN (1u<<12) 86#define MORE_THAN_ONE_PATH (1u<<13) 87 88/* 89 * One blob in a commit that is being suspected 90 */ 91struct origin { 92int refcnt; 93/* Record preceding blame record for this blob */ 94struct origin *previous; 95/* origins are put in a list linked via `next' hanging off the 96 * corresponding commit's util field in order to make finding 97 * them fast. The presence in this chain does not count 98 * towards the origin's reference count. It is tempting to 99 * let it count as long as the commit is pending examination, 100 * but even under circumstances where the commit will be 101 * present multiple times in the priority queue of unexamined 102 * commits, processing the first instance will not leave any 103 * work requiring the origin data for the second instance. An 104 * interspersed commit changing that would have to be 105 * preexisting with a different ancestry and with the same 106 * commit date in order to wedge itself between two instances 107 * of the same commit in the priority queue _and_ produce 108 * blame entries relevant for it. While we don't want to let 109 * us get tripped up by this case, it certainly does not seem 110 * worth optimizing for. 111 */ 112struct origin *next; 113struct commit *commit; 114/* `suspects' contains blame entries that may be attributed to 115 * this origin's commit or to parent commits. When a commit 116 * is being processed, all suspects will be moved, either by 117 * assigning them to an origin in a different commit, or by 118 * shipping them to the scoreboard's ent list because they 119 * cannot be attributed to a different commit. 120 */ 121struct blame_entry *suspects; 122 mmfile_t file; 123struct object_id blob_oid; 124unsigned mode; 125/* guilty gets set when shipping any suspects to the final 126 * blame list instead of other commits 127 */ 128char guilty; 129char path[FLEX_ARRAY]; 130}; 131 132struct progress_info { 133struct progress *progress; 134int blamed_lines; 135}; 136 137static intdiff_hunks(mmfile_t *file_a, mmfile_t *file_b, 138 xdl_emit_hunk_consume_func_t hunk_func,void*cb_data) 139{ 140 xpparam_t xpp = {0}; 141 xdemitconf_t xecfg = {0}; 142 xdemitcb_t ecb = {NULL}; 143 144 xpp.flags = xdl_opts; 145 xecfg.hunk_func = hunk_func; 146 ecb.priv = cb_data; 147returnxdi_diff(file_a, file_b, &xpp, &xecfg, &ecb); 148} 149 150/* 151 * Prepare diff_filespec and convert it using diff textconv API 152 * if the textconv driver exists. 153 * Return 1 if the conversion succeeds, 0 otherwise. 154 */ 155inttextconv_object(const char*path, 156unsigned mode, 157const struct object_id *oid, 158int oid_valid, 159char**buf, 160unsigned long*buf_size) 161{ 162struct diff_filespec *df; 163struct userdiff_driver *textconv; 164 165 df =alloc_filespec(path); 166fill_filespec(df, oid->hash, oid_valid, mode); 167 textconv =get_textconv(df); 168if(!textconv) { 169free_filespec(df); 170return0; 171} 172 173*buf_size =fill_textconv(textconv, df, buf); 174free_filespec(df); 175return1; 176} 177 178/* 179 * Given an origin, prepare mmfile_t structure to be used by the 180 * diff machinery 181 */ 182static voidfill_origin_blob(struct diff_options *opt, 183struct origin *o, mmfile_t *file) 184{ 185if(!o->file.ptr) { 186enum object_type type; 187unsigned long file_size; 188 189 num_read_blob++; 190if(DIFF_OPT_TST(opt, ALLOW_TEXTCONV) && 191textconv_object(o->path, o->mode, &o->blob_oid,1, &file->ptr, &file_size)) 192; 193else 194 file->ptr =read_sha1_file(o->blob_oid.hash, &type, 195&file_size); 196 file->size = file_size; 197 198if(!file->ptr) 199die("Cannot read blob%sfor path%s", 200oid_to_hex(&o->blob_oid), 201 o->path); 202 o->file = *file; 203} 204else 205*file = o->file; 206} 207 208/* 209 * Origin is refcounted and usually we keep the blob contents to be 210 * reused. 211 */ 212staticinlinestruct origin *origin_incref(struct origin *o) 213{ 214if(o) 215 o->refcnt++; 216return o; 217} 218 219static voidorigin_decref(struct origin *o) 220{ 221if(o && --o->refcnt <=0) { 222struct origin *p, *l = NULL; 223if(o->previous) 224origin_decref(o->previous); 225free(o->file.ptr); 226/* Should be present exactly once in commit chain */ 227for(p = o->commit->util; p; l = p, p = p->next) { 228if(p == o) { 229if(l) 230 l->next = p->next; 231else 232 o->commit->util = p->next; 233free(o); 234return; 235} 236} 237die("internal error in blame::origin_decref"); 238} 239} 240 241static voiddrop_origin_blob(struct origin *o) 242{ 243if(o->file.ptr) { 244free(o->file.ptr); 245 o->file.ptr = NULL; 246} 247} 248 249/* 250 * Each group of lines is described by a blame_entry; it can be split 251 * as we pass blame to the parents. They are arranged in linked lists 252 * kept as `suspects' of some unprocessed origin, or entered (when the 253 * blame origin has been finalized) into the scoreboard structure. 254 * While the scoreboard structure is only sorted at the end of 255 * processing (according to final image line number), the lists 256 * attached to an origin are sorted by the target line number. 257 */ 258struct blame_entry { 259struct blame_entry *next; 260 261/* the first line of this group in the final image; 262 * internally all line numbers are 0 based. 263 */ 264int lno; 265 266/* how many lines this group has */ 267int num_lines; 268 269/* the commit that introduced this group into the final image */ 270struct origin *suspect; 271 272/* the line number of the first line of this group in the 273 * suspect's file; internally all line numbers are 0 based. 274 */ 275int s_lno; 276 277/* how significant this entry is -- cached to avoid 278 * scanning the lines over and over. 279 */ 280unsigned score; 281}; 282 283/* 284 * Any merge of blames happens on lists of blames that arrived via 285 * different parents in a single suspect. In this case, we want to 286 * sort according to the suspect line numbers as opposed to the final 287 * image line numbers. The function body is somewhat longish because 288 * it avoids unnecessary writes. 289 */ 290 291static struct blame_entry *blame_merge(struct blame_entry *list1, 292struct blame_entry *list2) 293{ 294struct blame_entry *p1 = list1, *p2 = list2, 295**tail = &list1; 296 297if(!p1) 298return p2; 299if(!p2) 300return p1; 301 302if(p1->s_lno <= p2->s_lno) { 303do{ 304 tail = &p1->next; 305if((p1 = *tail) == NULL) { 306*tail = p2; 307return list1; 308} 309}while(p1->s_lno <= p2->s_lno); 310} 311for(;;) { 312*tail = p2; 313do{ 314 tail = &p2->next; 315if((p2 = *tail) == NULL) { 316*tail = p1; 317return list1; 318} 319}while(p1->s_lno > p2->s_lno); 320*tail = p1; 321do{ 322 tail = &p1->next; 323if((p1 = *tail) == NULL) { 324*tail = p2; 325return list1; 326} 327}while(p1->s_lno <= p2->s_lno); 328} 329} 330 331static void*get_next_blame(const void*p) 332{ 333return((struct blame_entry *)p)->next; 334} 335 336static voidset_next_blame(void*p1,void*p2) 337{ 338((struct blame_entry *)p1)->next = p2; 339} 340 341/* 342 * Final image line numbers are all different, so we don't need a 343 * three-way comparison here. 344 */ 345 346static intcompare_blame_final(const void*p1,const void*p2) 347{ 348return((struct blame_entry *)p1)->lno > ((struct blame_entry *)p2)->lno 349?1: -1; 350} 351 352static intcompare_blame_suspect(const void*p1,const void*p2) 353{ 354const struct blame_entry *s1 = p1, *s2 = p2; 355/* 356 * to allow for collating suspects, we sort according to the 357 * respective pointer value as the primary sorting criterion. 358 * The actual relation is pretty unimportant as long as it 359 * establishes a total order. Comparing as integers gives us 360 * that. 361 */ 362if(s1->suspect != s2->suspect) 363return(intptr_t)s1->suspect > (intptr_t)s2->suspect ?1: -1; 364if(s1->s_lno == s2->s_lno) 365return0; 366return s1->s_lno > s2->s_lno ?1: -1; 367} 368 369static struct blame_entry *blame_sort(struct blame_entry *head, 370int(*compare_fn)(const void*,const void*)) 371{ 372returnllist_mergesort(head, get_next_blame, set_next_blame, compare_fn); 373} 374 375static intcompare_commits_by_reverse_commit_date(const void*a, 376const void*b, 377void*c) 378{ 379return-compare_commits_by_commit_date(a, b, c); 380} 381 382/* 383 * The current state of the blame assignment. 384 */ 385struct scoreboard { 386/* the final commit (i.e. where we started digging from) */ 387struct commit *final; 388/* Priority queue for commits with unassigned blame records */ 389struct prio_queue commits; 390struct rev_info *revs; 391const char*path; 392 393/* 394 * The contents in the final image. 395 * Used by many functions to obtain contents of the nth line, 396 * indexed with scoreboard.lineno[blame_entry.lno]. 397 */ 398const char*final_buf; 399unsigned long final_buf_size; 400 401/* linked list of blames */ 402struct blame_entry *ent; 403 404/* look-up a line in the final buffer */ 405int num_lines; 406int*lineno; 407}; 408 409static voidsanity_check_refcnt(struct scoreboard *); 410 411/* 412 * If two blame entries that are next to each other came from 413 * contiguous lines in the same origin (i.e. <commit, path> pair), 414 * merge them together. 415 */ 416static voidcoalesce(struct scoreboard *sb) 417{ 418struct blame_entry *ent, *next; 419 420for(ent = sb->ent; ent && (next = ent->next); ent = next) { 421if(ent->suspect == next->suspect && 422 ent->s_lno + ent->num_lines == next->s_lno) { 423 ent->num_lines += next->num_lines; 424 ent->next = next->next; 425origin_decref(next->suspect); 426free(next); 427 ent->score =0; 428 next = ent;/* again */ 429} 430} 431 432if(DEBUG)/* sanity */ 433sanity_check_refcnt(sb); 434} 435 436/* 437 * Merge the given sorted list of blames into a preexisting origin. 438 * If there were no previous blames to that commit, it is entered into 439 * the commit priority queue of the score board. 440 */ 441 442static voidqueue_blames(struct scoreboard *sb,struct origin *porigin, 443struct blame_entry *sorted) 444{ 445if(porigin->suspects) 446 porigin->suspects =blame_merge(porigin->suspects, sorted); 447else{ 448struct origin *o; 449for(o = porigin->commit->util; o; o = o->next) { 450if(o->suspects) { 451 porigin->suspects = sorted; 452return; 453} 454} 455 porigin->suspects = sorted; 456prio_queue_put(&sb->commits, porigin->commit); 457} 458} 459 460/* 461 * Given a commit and a path in it, create a new origin structure. 462 * The callers that add blame to the scoreboard should use 463 * get_origin() to obtain shared, refcounted copy instead of calling 464 * this function directly. 465 */ 466static struct origin *make_origin(struct commit *commit,const char*path) 467{ 468struct origin *o; 469FLEX_ALLOC_STR(o, path, path); 470 o->commit = commit; 471 o->refcnt =1; 472 o->next = commit->util; 473 commit->util = o; 474return o; 475} 476 477/* 478 * Locate an existing origin or create a new one. 479 * This moves the origin to front position in the commit util list. 480 */ 481static struct origin *get_origin(struct scoreboard *sb, 482struct commit *commit, 483const char*path) 484{ 485struct origin *o, *l; 486 487for(o = commit->util, l = NULL; o; l = o, o = o->next) { 488if(!strcmp(o->path, path)) { 489/* bump to front */ 490if(l) { 491 l->next = o->next; 492 o->next = commit->util; 493 commit->util = o; 494} 495returnorigin_incref(o); 496} 497} 498returnmake_origin(commit, path); 499} 500 501/* 502 * Fill the blob_sha1 field of an origin if it hasn't, so that later 503 * call to fill_origin_blob() can use it to locate the data. blob_sha1 504 * for an origin is also used to pass the blame for the entire file to 505 * the parent to detect the case where a child's blob is identical to 506 * that of its parent's. 507 * 508 * This also fills origin->mode for corresponding tree path. 509 */ 510static intfill_blob_sha1_and_mode(struct origin *origin) 511{ 512if(!is_null_oid(&origin->blob_oid)) 513return0; 514if(get_tree_entry(origin->commit->object.oid.hash, 515 origin->path, 516 origin->blob_oid.hash, &origin->mode)) 517goto error_out; 518if(sha1_object_info(origin->blob_oid.hash, NULL) != OBJ_BLOB) 519goto error_out; 520return0; 521 error_out: 522oidclr(&origin->blob_oid); 523 origin->mode = S_IFINVALID; 524return-1; 525} 526 527/* 528 * We have an origin -- check if the same path exists in the 529 * parent and return an origin structure to represent it. 530 */ 531static struct origin *find_origin(struct scoreboard *sb, 532struct commit *parent, 533struct origin *origin) 534{ 535struct origin *porigin; 536struct diff_options diff_opts; 537const char*paths[2]; 538 539/* First check any existing origins */ 540for(porigin = parent->util; porigin; porigin = porigin->next) 541if(!strcmp(porigin->path, origin->path)) { 542/* 543 * The same path between origin and its parent 544 * without renaming -- the most common case. 545 */ 546returnorigin_incref(porigin); 547} 548 549/* See if the origin->path is different between parent 550 * and origin first. Most of the time they are the 551 * same and diff-tree is fairly efficient about this. 552 */ 553diff_setup(&diff_opts); 554DIFF_OPT_SET(&diff_opts, RECURSIVE); 555 diff_opts.detect_rename =0; 556 diff_opts.output_format = DIFF_FORMAT_NO_OUTPUT; 557 paths[0] = origin->path; 558 paths[1] = NULL; 559 560parse_pathspec(&diff_opts.pathspec, 561 PATHSPEC_ALL_MAGIC & ~PATHSPEC_LITERAL, 562 PATHSPEC_LITERAL_PATH,"", paths); 563diff_setup_done(&diff_opts); 564 565if(is_null_oid(&origin->commit->object.oid)) 566do_diff_cache(parent->tree->object.oid.hash, &diff_opts); 567else 568diff_tree_sha1(parent->tree->object.oid.hash, 569 origin->commit->tree->object.oid.hash, 570"", &diff_opts); 571diffcore_std(&diff_opts); 572 573if(!diff_queued_diff.nr) { 574/* The path is the same as parent */ 575 porigin =get_origin(sb, parent, origin->path); 576oidcpy(&porigin->blob_oid, &origin->blob_oid); 577 porigin->mode = origin->mode; 578}else{ 579/* 580 * Since origin->path is a pathspec, if the parent 581 * commit had it as a directory, we will see a whole 582 * bunch of deletion of files in the directory that we 583 * do not care about. 584 */ 585int i; 586struct diff_filepair *p = NULL; 587for(i =0; i < diff_queued_diff.nr; i++) { 588const char*name; 589 p = diff_queued_diff.queue[i]; 590 name = p->one->path ? p->one->path : p->two->path; 591if(!strcmp(name, origin->path)) 592break; 593} 594if(!p) 595die("internal error in blame::find_origin"); 596switch(p->status) { 597default: 598die("internal error in blame::find_origin (%c)", 599 p->status); 600case'M': 601 porigin =get_origin(sb, parent, origin->path); 602oidcpy(&porigin->blob_oid, &p->one->oid); 603 porigin->mode = p->one->mode; 604break; 605case'A': 606case'T': 607/* Did not exist in parent, or type changed */ 608break; 609} 610} 611diff_flush(&diff_opts); 612clear_pathspec(&diff_opts.pathspec); 613return porigin; 614} 615 616/* 617 * We have an origin -- find the path that corresponds to it in its 618 * parent and return an origin structure to represent it. 619 */ 620static struct origin *find_rename(struct scoreboard *sb, 621struct commit *parent, 622struct origin *origin) 623{ 624struct origin *porigin = NULL; 625struct diff_options diff_opts; 626int i; 627 628diff_setup(&diff_opts); 629DIFF_OPT_SET(&diff_opts, RECURSIVE); 630 diff_opts.detect_rename = DIFF_DETECT_RENAME; 631 diff_opts.output_format = DIFF_FORMAT_NO_OUTPUT; 632 diff_opts.single_follow = origin->path; 633diff_setup_done(&diff_opts); 634 635if(is_null_oid(&origin->commit->object.oid)) 636do_diff_cache(parent->tree->object.oid.hash, &diff_opts); 637else 638diff_tree_sha1(parent->tree->object.oid.hash, 639 origin->commit->tree->object.oid.hash, 640"", &diff_opts); 641diffcore_std(&diff_opts); 642 643for(i =0; i < diff_queued_diff.nr; i++) { 644struct diff_filepair *p = diff_queued_diff.queue[i]; 645if((p->status =='R'|| p->status =='C') && 646!strcmp(p->two->path, origin->path)) { 647 porigin =get_origin(sb, parent, p->one->path); 648oidcpy(&porigin->blob_oid, &p->one->oid); 649 porigin->mode = p->one->mode; 650break; 651} 652} 653diff_flush(&diff_opts); 654clear_pathspec(&diff_opts.pathspec); 655return porigin; 656} 657 658/* 659 * Append a new blame entry to a given output queue. 660 */ 661static voidadd_blame_entry(struct blame_entry ***queue,struct blame_entry *e) 662{ 663origin_incref(e->suspect); 664 665 e->next = **queue; 666**queue = e; 667*queue = &e->next; 668} 669 670/* 671 * src typically is on-stack; we want to copy the information in it to 672 * a malloced blame_entry that gets added to the given queue. The 673 * origin of dst loses a refcnt. 674 */ 675static voiddup_entry(struct blame_entry ***queue, 676struct blame_entry *dst,struct blame_entry *src) 677{ 678origin_incref(src->suspect); 679origin_decref(dst->suspect); 680memcpy(dst, src,sizeof(*src)); 681 dst->next = **queue; 682**queue = dst; 683*queue = &dst->next; 684} 685 686static const char*nth_line(struct scoreboard *sb,long lno) 687{ 688return sb->final_buf + sb->lineno[lno]; 689} 690 691static const char*nth_line_cb(void*data,long lno) 692{ 693returnnth_line((struct scoreboard *)data, lno); 694} 695 696/* 697 * It is known that lines between tlno to same came from parent, and e 698 * has an overlap with that range. it also is known that parent's 699 * line plno corresponds to e's line tlno. 700 * 701 * <---- e -----> 702 * <------> 703 * <------------> 704 * <------------> 705 * <------------------> 706 * 707 * Split e into potentially three parts; before this chunk, the chunk 708 * to be blamed for the parent, and after that portion. 709 */ 710static voidsplit_overlap(struct blame_entry *split, 711struct blame_entry *e, 712int tlno,int plno,int same, 713struct origin *parent) 714{ 715int chunk_end_lno; 716memset(split,0,sizeof(struct blame_entry [3])); 717 718if(e->s_lno < tlno) { 719/* there is a pre-chunk part not blamed on parent */ 720 split[0].suspect =origin_incref(e->suspect); 721 split[0].lno = e->lno; 722 split[0].s_lno = e->s_lno; 723 split[0].num_lines = tlno - e->s_lno; 724 split[1].lno = e->lno + tlno - e->s_lno; 725 split[1].s_lno = plno; 726} 727else{ 728 split[1].lno = e->lno; 729 split[1].s_lno = plno + (e->s_lno - tlno); 730} 731 732if(same < e->s_lno + e->num_lines) { 733/* there is a post-chunk part not blamed on parent */ 734 split[2].suspect =origin_incref(e->suspect); 735 split[2].lno = e->lno + (same - e->s_lno); 736 split[2].s_lno = e->s_lno + (same - e->s_lno); 737 split[2].num_lines = e->s_lno + e->num_lines - same; 738 chunk_end_lno = split[2].lno; 739} 740else 741 chunk_end_lno = e->lno + e->num_lines; 742 split[1].num_lines = chunk_end_lno - split[1].lno; 743 744/* 745 * if it turns out there is nothing to blame the parent for, 746 * forget about the splitting. !split[1].suspect signals this. 747 */ 748if(split[1].num_lines <1) 749return; 750 split[1].suspect =origin_incref(parent); 751} 752 753/* 754 * split_overlap() divided an existing blame e into up to three parts 755 * in split. Any assigned blame is moved to queue to 756 * reflect the split. 757 */ 758static voidsplit_blame(struct blame_entry ***blamed, 759struct blame_entry ***unblamed, 760struct blame_entry *split, 761struct blame_entry *e) 762{ 763struct blame_entry *new_entry; 764 765if(split[0].suspect && split[2].suspect) { 766/* The first part (reuse storage for the existing entry e) */ 767dup_entry(unblamed, e, &split[0]); 768 769/* The last part -- me */ 770 new_entry =xmalloc(sizeof(*new_entry)); 771memcpy(new_entry, &(split[2]),sizeof(struct blame_entry)); 772add_blame_entry(unblamed, new_entry); 773 774/* ... and the middle part -- parent */ 775 new_entry =xmalloc(sizeof(*new_entry)); 776memcpy(new_entry, &(split[1]),sizeof(struct blame_entry)); 777add_blame_entry(blamed, new_entry); 778} 779else if(!split[0].suspect && !split[2].suspect) 780/* 781 * The parent covers the entire area; reuse storage for 782 * e and replace it with the parent. 783 */ 784dup_entry(blamed, e, &split[1]); 785else if(split[0].suspect) { 786/* me and then parent */ 787dup_entry(unblamed, e, &split[0]); 788 789 new_entry =xmalloc(sizeof(*new_entry)); 790memcpy(new_entry, &(split[1]),sizeof(struct blame_entry)); 791add_blame_entry(blamed, new_entry); 792} 793else{ 794/* parent and then me */ 795dup_entry(blamed, e, &split[1]); 796 797 new_entry =xmalloc(sizeof(*new_entry)); 798memcpy(new_entry, &(split[2]),sizeof(struct blame_entry)); 799add_blame_entry(unblamed, new_entry); 800} 801} 802 803/* 804 * After splitting the blame, the origins used by the 805 * on-stack blame_entry should lose one refcnt each. 806 */ 807static voiddecref_split(struct blame_entry *split) 808{ 809int i; 810 811for(i =0; i <3; i++) 812origin_decref(split[i].suspect); 813} 814 815/* 816 * reverse_blame reverses the list given in head, appending tail. 817 * That allows us to build lists in reverse order, then reverse them 818 * afterwards. This can be faster than building the list in proper 819 * order right away. The reason is that building in proper order 820 * requires writing a link in the _previous_ element, while building 821 * in reverse order just requires placing the list head into the 822 * _current_ element. 823 */ 824 825static struct blame_entry *reverse_blame(struct blame_entry *head, 826struct blame_entry *tail) 827{ 828while(head) { 829struct blame_entry *next = head->next; 830 head->next = tail; 831 tail = head; 832 head = next; 833} 834return tail; 835} 836 837/* 838 * Process one hunk from the patch between the current suspect for 839 * blame_entry e and its parent. This first blames any unfinished 840 * entries before the chunk (which is where target and parent start 841 * differing) on the parent, and then splits blame entries at the 842 * start and at the end of the difference region. Since use of -M and 843 * -C options may lead to overlapping/duplicate source line number 844 * ranges, all we can rely on from sorting/merging is the order of the 845 * first suspect line number. 846 */ 847static voidblame_chunk(struct blame_entry ***dstq,struct blame_entry ***srcq, 848int tlno,int offset,int same, 849struct origin *parent) 850{ 851struct blame_entry *e = **srcq; 852struct blame_entry *samep = NULL, *diffp = NULL; 853 854while(e && e->s_lno < tlno) { 855struct blame_entry *next = e->next; 856/* 857 * current record starts before differing portion. If 858 * it reaches into it, we need to split it up and 859 * examine the second part separately. 860 */ 861if(e->s_lno + e->num_lines > tlno) { 862/* Move second half to a new record */ 863int len = tlno - e->s_lno; 864struct blame_entry *n =xcalloc(1,sizeof(struct blame_entry)); 865 n->suspect = e->suspect; 866 n->lno = e->lno + len; 867 n->s_lno = e->s_lno + len; 868 n->num_lines = e->num_lines - len; 869 e->num_lines = len; 870 e->score =0; 871/* Push new record to diffp */ 872 n->next = diffp; 873 diffp = n; 874}else 875origin_decref(e->suspect); 876/* Pass blame for everything before the differing 877 * chunk to the parent */ 878 e->suspect =origin_incref(parent); 879 e->s_lno += offset; 880 e->next = samep; 881 samep = e; 882 e = next; 883} 884/* 885 * As we don't know how much of a common stretch after this 886 * diff will occur, the currently blamed parts are all that we 887 * can assign to the parent for now. 888 */ 889 890if(samep) { 891**dstq =reverse_blame(samep, **dstq); 892*dstq = &samep->next; 893} 894/* 895 * Prepend the split off portions: everything after e starts 896 * after the blameable portion. 897 */ 898 e =reverse_blame(diffp, e); 899 900/* 901 * Now retain records on the target while parts are different 902 * from the parent. 903 */ 904 samep = NULL; 905 diffp = NULL; 906while(e && e->s_lno < same) { 907struct blame_entry *next = e->next; 908 909/* 910 * If current record extends into sameness, need to split. 911 */ 912if(e->s_lno + e->num_lines > same) { 913/* 914 * Move second half to a new record to be 915 * processed by later chunks 916 */ 917int len = same - e->s_lno; 918struct blame_entry *n =xcalloc(1,sizeof(struct blame_entry)); 919 n->suspect =origin_incref(e->suspect); 920 n->lno = e->lno + len; 921 n->s_lno = e->s_lno + len; 922 n->num_lines = e->num_lines - len; 923 e->num_lines = len; 924 e->score =0; 925/* Push new record to samep */ 926 n->next = samep; 927 samep = n; 928} 929 e->next = diffp; 930 diffp = e; 931 e = next; 932} 933**srcq =reverse_blame(diffp,reverse_blame(samep, e)); 934/* Move across elements that are in the unblamable portion */ 935if(diffp) 936*srcq = &diffp->next; 937} 938 939struct blame_chunk_cb_data { 940struct origin *parent; 941long offset; 942struct blame_entry **dstq; 943struct blame_entry **srcq; 944}; 945 946/* diff chunks are from parent to target */ 947static intblame_chunk_cb(long start_a,long count_a, 948long start_b,long count_b,void*data) 949{ 950struct blame_chunk_cb_data *d = data; 951if(start_a - start_b != d->offset) 952die("internal error in blame::blame_chunk_cb"); 953blame_chunk(&d->dstq, &d->srcq, start_b, start_a - start_b, 954 start_b + count_b, d->parent); 955 d->offset = start_a + count_a - (start_b + count_b); 956return0; 957} 958 959/* 960 * We are looking at the origin 'target' and aiming to pass blame 961 * for the lines it is suspected to its parent. Run diff to find 962 * which lines came from parent and pass blame for them. 963 */ 964static voidpass_blame_to_parent(struct scoreboard *sb, 965struct origin *target, 966struct origin *parent) 967{ 968 mmfile_t file_p, file_o; 969struct blame_chunk_cb_data d; 970struct blame_entry *newdest = NULL; 971 972if(!target->suspects) 973return;/* nothing remains for this target */ 974 975 d.parent = parent; 976 d.offset =0; 977 d.dstq = &newdest; d.srcq = &target->suspects; 978 979fill_origin_blob(&sb->revs->diffopt, parent, &file_p); 980fill_origin_blob(&sb->revs->diffopt, target, &file_o); 981 num_get_patch++; 982 983if(diff_hunks(&file_p, &file_o, blame_chunk_cb, &d)) 984die("unable to generate diff (%s->%s)", 985oid_to_hex(&parent->commit->object.oid), 986oid_to_hex(&target->commit->object.oid)); 987/* The rest are the same as the parent */ 988blame_chunk(&d.dstq, &d.srcq, INT_MAX, d.offset, INT_MAX, parent); 989*d.dstq = NULL; 990queue_blames(sb, parent, newdest); 991 992return; 993} 994 995/* 996 * The lines in blame_entry after splitting blames many times can become 997 * very small and trivial, and at some point it becomes pointless to 998 * blame the parents. E.g. "\t\t}\n\t}\n\n" appears everywhere in any 999 * ordinary C program, and it is not worth to say it was copied from1000 * totally unrelated file in the parent.1001 *1002 * Compute how trivial the lines in the blame_entry are.1003 */1004static unsignedent_score(struct scoreboard *sb,struct blame_entry *e)1005{1006unsigned score;1007const char*cp, *ep;10081009if(e->score)1010return e->score;10111012 score =1;1013 cp =nth_line(sb, e->lno);1014 ep =nth_line(sb, e->lno + e->num_lines);1015while(cp < ep) {1016unsigned ch = *((unsigned char*)cp);1017if(isalnum(ch))1018 score++;1019 cp++;1020}1021 e->score = score;1022return score;1023}10241025/*1026 * best_so_far[] and this[] are both a split of an existing blame_entry1027 * that passes blame to the parent. Maintain best_so_far the best split1028 * so far, by comparing this and best_so_far and copying this into1029 * bst_so_far as needed.1030 */1031static voidcopy_split_if_better(struct scoreboard *sb,1032struct blame_entry *best_so_far,1033struct blame_entry *this)1034{1035int i;10361037if(!this[1].suspect)1038return;1039if(best_so_far[1].suspect) {1040if(ent_score(sb, &this[1]) <ent_score(sb, &best_so_far[1]))1041return;1042}10431044for(i =0; i <3; i++)1045origin_incref(this[i].suspect);1046decref_split(best_so_far);1047memcpy(best_so_far,this,sizeof(struct blame_entry [3]));1048}10491050/*1051 * We are looking at a part of the final image represented by1052 * ent (tlno and same are offset by ent->s_lno).1053 * tlno is where we are looking at in the final image.1054 * up to (but not including) same match preimage.1055 * plno is where we are looking at in the preimage.1056 *1057 * <-------------- final image ---------------------->1058 * <------ent------>1059 * ^tlno ^same1060 * <---------preimage----->1061 * ^plno1062 *1063 * All line numbers are 0-based.1064 */1065static voidhandle_split(struct scoreboard *sb,1066struct blame_entry *ent,1067int tlno,int plno,int same,1068struct origin *parent,1069struct blame_entry *split)1070{1071if(ent->num_lines <= tlno)1072return;1073if(tlno < same) {1074struct blame_entry this[3];1075 tlno += ent->s_lno;1076 same += ent->s_lno;1077split_overlap(this, ent, tlno, plno, same, parent);1078copy_split_if_better(sb, split,this);1079decref_split(this);1080}1081}10821083struct handle_split_cb_data {1084struct scoreboard *sb;1085struct blame_entry *ent;1086struct origin *parent;1087struct blame_entry *split;1088long plno;1089long tlno;1090};10911092static inthandle_split_cb(long start_a,long count_a,1093long start_b,long count_b,void*data)1094{1095struct handle_split_cb_data *d = data;1096handle_split(d->sb, d->ent, d->tlno, d->plno, start_b, d->parent,1097 d->split);1098 d->plno = start_a + count_a;1099 d->tlno = start_b + count_b;1100return0;1101}11021103/*1104 * Find the lines from parent that are the same as ent so that1105 * we can pass blames to it. file_p has the blob contents for1106 * the parent.1107 */1108static voidfind_copy_in_blob(struct scoreboard *sb,1109struct blame_entry *ent,1110struct origin *parent,1111struct blame_entry *split,1112 mmfile_t *file_p)1113{1114const char*cp;1115 mmfile_t file_o;1116struct handle_split_cb_data d;11171118memset(&d,0,sizeof(d));1119 d.sb = sb; d.ent = ent; d.parent = parent; d.split = split;1120/*1121 * Prepare mmfile that contains only the lines in ent.1122 */1123 cp =nth_line(sb, ent->lno);1124 file_o.ptr = (char*) cp;1125 file_o.size =nth_line(sb, ent->lno + ent->num_lines) - cp;11261127/*1128 * file_o is a part of final image we are annotating.1129 * file_p partially may match that image.1130 */1131memset(split,0,sizeof(struct blame_entry [3]));1132if(diff_hunks(file_p, &file_o, handle_split_cb, &d))1133die("unable to generate diff (%s)",1134oid_to_hex(&parent->commit->object.oid));1135/* remainder, if any, all match the preimage */1136handle_split(sb, ent, d.tlno, d.plno, ent->num_lines, parent, split);1137}11381139/* Move all blame entries from list *source that have a score smaller1140 * than score_min to the front of list *small.1141 * Returns a pointer to the link pointing to the old head of the small list.1142 */11431144static struct blame_entry **filter_small(struct scoreboard *sb,1145struct blame_entry **small,1146struct blame_entry **source,1147unsigned score_min)1148{1149struct blame_entry *p = *source;1150struct blame_entry *oldsmall = *small;1151while(p) {1152if(ent_score(sb, p) <= score_min) {1153*small = p;1154 small = &p->next;1155 p = *small;1156}else{1157*source = p;1158 source = &p->next;1159 p = *source;1160}1161}1162*small = oldsmall;1163*source = NULL;1164return small;1165}11661167/*1168 * See if lines currently target is suspected for can be attributed to1169 * parent.1170 */1171static voidfind_move_in_parent(struct scoreboard *sb,1172struct blame_entry ***blamed,1173struct blame_entry **toosmall,1174struct origin *target,1175struct origin *parent)1176{1177struct blame_entry *e, split[3];1178struct blame_entry *unblamed = target->suspects;1179struct blame_entry *leftover = NULL;1180 mmfile_t file_p;11811182if(!unblamed)1183return;/* nothing remains for this target */11841185fill_origin_blob(&sb->revs->diffopt, parent, &file_p);1186if(!file_p.ptr)1187return;11881189/* At each iteration, unblamed has a NULL-terminated list of1190 * entries that have not yet been tested for blame. leftover1191 * contains the reversed list of entries that have been tested1192 * without being assignable to the parent.1193 */1194do{1195struct blame_entry **unblamedtail = &unblamed;1196struct blame_entry *next;1197for(e = unblamed; e; e = next) {1198 next = e->next;1199find_copy_in_blob(sb, e, parent, split, &file_p);1200if(split[1].suspect &&1201 blame_move_score <ent_score(sb, &split[1])) {1202split_blame(blamed, &unblamedtail, split, e);1203}else{1204 e->next = leftover;1205 leftover = e;1206}1207decref_split(split);1208}1209*unblamedtail = NULL;1210 toosmall =filter_small(sb, toosmall, &unblamed, blame_move_score);1211}while(unblamed);1212 target->suspects =reverse_blame(leftover, NULL);1213}12141215struct blame_list {1216struct blame_entry *ent;1217struct blame_entry split[3];1218};12191220/*1221 * Count the number of entries the target is suspected for,1222 * and prepare a list of entry and the best split.1223 */1224static struct blame_list *setup_blame_list(struct blame_entry *unblamed,1225int*num_ents_p)1226{1227struct blame_entry *e;1228int num_ents, i;1229struct blame_list *blame_list = NULL;12301231for(e = unblamed, num_ents =0; e; e = e->next)1232 num_ents++;1233if(num_ents) {1234 blame_list =xcalloc(num_ents,sizeof(struct blame_list));1235for(e = unblamed, i =0; e; e = e->next)1236 blame_list[i++].ent = e;1237}1238*num_ents_p = num_ents;1239return blame_list;1240}12411242/*1243 * For lines target is suspected for, see if we can find code movement1244 * across file boundary from the parent commit. porigin is the path1245 * in the parent we already tried.1246 */1247static voidfind_copy_in_parent(struct scoreboard *sb,1248struct blame_entry ***blamed,1249struct blame_entry **toosmall,1250struct origin *target,1251struct commit *parent,1252struct origin *porigin,1253int opt)1254{1255struct diff_options diff_opts;1256int i, j;1257struct blame_list *blame_list;1258int num_ents;1259struct blame_entry *unblamed = target->suspects;1260struct blame_entry *leftover = NULL;12611262if(!unblamed)1263return;/* nothing remains for this target */12641265diff_setup(&diff_opts);1266DIFF_OPT_SET(&diff_opts, RECURSIVE);1267 diff_opts.output_format = DIFF_FORMAT_NO_OUTPUT;12681269diff_setup_done(&diff_opts);12701271/* Try "find copies harder" on new path if requested;1272 * we do not want to use diffcore_rename() actually to1273 * match things up; find_copies_harder is set only to1274 * force diff_tree_sha1() to feed all filepairs to diff_queue,1275 * and this code needs to be after diff_setup_done(), which1276 * usually makes find-copies-harder imply copy detection.1277 */1278if((opt & PICKAXE_BLAME_COPY_HARDEST)1279|| ((opt & PICKAXE_BLAME_COPY_HARDER)1280&& (!porigin ||strcmp(target->path, porigin->path))))1281DIFF_OPT_SET(&diff_opts, FIND_COPIES_HARDER);12821283if(is_null_oid(&target->commit->object.oid))1284do_diff_cache(parent->tree->object.oid.hash, &diff_opts);1285else1286diff_tree_sha1(parent->tree->object.oid.hash,1287 target->commit->tree->object.oid.hash,1288"", &diff_opts);12891290if(!DIFF_OPT_TST(&diff_opts, FIND_COPIES_HARDER))1291diffcore_std(&diff_opts);12921293do{1294struct blame_entry **unblamedtail = &unblamed;1295 blame_list =setup_blame_list(unblamed, &num_ents);12961297for(i =0; i < diff_queued_diff.nr; i++) {1298struct diff_filepair *p = diff_queued_diff.queue[i];1299struct origin *norigin;1300 mmfile_t file_p;1301struct blame_entry this[3];13021303if(!DIFF_FILE_VALID(p->one))1304continue;/* does not exist in parent */1305if(S_ISGITLINK(p->one->mode))1306continue;/* ignore git links */1307if(porigin && !strcmp(p->one->path, porigin->path))1308/* find_move already dealt with this path */1309continue;13101311 norigin =get_origin(sb, parent, p->one->path);1312oidcpy(&norigin->blob_oid, &p->one->oid);1313 norigin->mode = p->one->mode;1314fill_origin_blob(&sb->revs->diffopt, norigin, &file_p);1315if(!file_p.ptr)1316continue;13171318for(j =0; j < num_ents; j++) {1319find_copy_in_blob(sb, blame_list[j].ent,1320 norigin,this, &file_p);1321copy_split_if_better(sb, blame_list[j].split,1322this);1323decref_split(this);1324}1325origin_decref(norigin);1326}13271328for(j =0; j < num_ents; j++) {1329struct blame_entry *split = blame_list[j].split;1330if(split[1].suspect &&1331 blame_copy_score <ent_score(sb, &split[1])) {1332split_blame(blamed, &unblamedtail, split,1333 blame_list[j].ent);1334}else{1335 blame_list[j].ent->next = leftover;1336 leftover = blame_list[j].ent;1337}1338decref_split(split);1339}1340free(blame_list);1341*unblamedtail = NULL;1342 toosmall =filter_small(sb, toosmall, &unblamed, blame_copy_score);1343}while(unblamed);1344 target->suspects =reverse_blame(leftover, NULL);1345diff_flush(&diff_opts);1346clear_pathspec(&diff_opts.pathspec);1347}13481349/*1350 * The blobs of origin and porigin exactly match, so everything1351 * origin is suspected for can be blamed on the parent.1352 */1353static voidpass_whole_blame(struct scoreboard *sb,1354struct origin *origin,struct origin *porigin)1355{1356struct blame_entry *e, *suspects;13571358if(!porigin->file.ptr && origin->file.ptr) {1359/* Steal its file */1360 porigin->file = origin->file;1361 origin->file.ptr = NULL;1362}1363 suspects = origin->suspects;1364 origin->suspects = NULL;1365for(e = suspects; e; e = e->next) {1366origin_incref(porigin);1367origin_decref(e->suspect);1368 e->suspect = porigin;1369}1370queue_blames(sb, porigin, suspects);1371}13721373/*1374 * We pass blame from the current commit to its parents. We keep saying1375 * "parent" (and "porigin"), but what we mean is to find scapegoat to1376 * exonerate ourselves.1377 */1378static struct commit_list *first_scapegoat(struct rev_info *revs,struct commit *commit)1379{1380if(!reverse) {1381if(revs->first_parent_only &&1382 commit->parents &&1383 commit->parents->next) {1384free_commit_list(commit->parents->next);1385 commit->parents->next = NULL;1386}1387return commit->parents;1388}1389returnlookup_decoration(&revs->children, &commit->object);1390}13911392static intnum_scapegoats(struct rev_info *revs,struct commit *commit)1393{1394struct commit_list *l =first_scapegoat(revs, commit);1395returncommit_list_count(l);1396}13971398/* Distribute collected unsorted blames to the respected sorted lists1399 * in the various origins.1400 */1401static voiddistribute_blame(struct scoreboard *sb,struct blame_entry *blamed)1402{1403 blamed =blame_sort(blamed, compare_blame_suspect);1404while(blamed)1405{1406struct origin *porigin = blamed->suspect;1407struct blame_entry *suspects = NULL;1408do{1409struct blame_entry *next = blamed->next;1410 blamed->next = suspects;1411 suspects = blamed;1412 blamed = next;1413}while(blamed && blamed->suspect == porigin);1414 suspects =reverse_blame(suspects, NULL);1415queue_blames(sb, porigin, suspects);1416}1417}14181419#define MAXSG 1614201421static voidpass_blame(struct scoreboard *sb,struct origin *origin,int opt)1422{1423struct rev_info *revs = sb->revs;1424int i, pass, num_sg;1425struct commit *commit = origin->commit;1426struct commit_list *sg;1427struct origin *sg_buf[MAXSG];1428struct origin *porigin, **sg_origin = sg_buf;1429struct blame_entry *toosmall = NULL;1430struct blame_entry *blames, **blametail = &blames;14311432 num_sg =num_scapegoats(revs, commit);1433if(!num_sg)1434goto finish;1435else if(num_sg <ARRAY_SIZE(sg_buf))1436memset(sg_buf,0,sizeof(sg_buf));1437else1438 sg_origin =xcalloc(num_sg,sizeof(*sg_origin));14391440/*1441 * The first pass looks for unrenamed path to optimize for1442 * common cases, then we look for renames in the second pass.1443 */1444for(pass =0; pass <2- no_whole_file_rename; pass++) {1445struct origin *(*find)(struct scoreboard *,1446struct commit *,struct origin *);1447 find = pass ? find_rename : find_origin;14481449for(i =0, sg =first_scapegoat(revs, commit);1450 i < num_sg && sg;1451 sg = sg->next, i++) {1452struct commit *p = sg->item;1453int j, same;14541455if(sg_origin[i])1456continue;1457if(parse_commit(p))1458continue;1459 porigin =find(sb, p, origin);1460if(!porigin)1461continue;1462if(!oidcmp(&porigin->blob_oid, &origin->blob_oid)) {1463pass_whole_blame(sb, origin, porigin);1464origin_decref(porigin);1465goto finish;1466}1467for(j = same =0; j < i; j++)1468if(sg_origin[j] &&1469!oidcmp(&sg_origin[j]->blob_oid, &porigin->blob_oid)) {1470 same =1;1471break;1472}1473if(!same)1474 sg_origin[i] = porigin;1475else1476origin_decref(porigin);1477}1478}14791480 num_commits++;1481for(i =0, sg =first_scapegoat(revs, commit);1482 i < num_sg && sg;1483 sg = sg->next, i++) {1484struct origin *porigin = sg_origin[i];1485if(!porigin)1486continue;1487if(!origin->previous) {1488origin_incref(porigin);1489 origin->previous = porigin;1490}1491pass_blame_to_parent(sb, origin, porigin);1492if(!origin->suspects)1493goto finish;1494}14951496/*1497 * Optionally find moves in parents' files.1498 */1499if(opt & PICKAXE_BLAME_MOVE) {1500filter_small(sb, &toosmall, &origin->suspects, blame_move_score);1501if(origin->suspects) {1502for(i =0, sg =first_scapegoat(revs, commit);1503 i < num_sg && sg;1504 sg = sg->next, i++) {1505struct origin *porigin = sg_origin[i];1506if(!porigin)1507continue;1508find_move_in_parent(sb, &blametail, &toosmall, origin, porigin);1509if(!origin->suspects)1510break;1511}1512}1513}15141515/*1516 * Optionally find copies from parents' files.1517 */1518if(opt & PICKAXE_BLAME_COPY) {1519if(blame_copy_score > blame_move_score)1520filter_small(sb, &toosmall, &origin->suspects, blame_copy_score);1521else if(blame_copy_score < blame_move_score) {1522 origin->suspects =blame_merge(origin->suspects, toosmall);1523 toosmall = NULL;1524filter_small(sb, &toosmall, &origin->suspects, blame_copy_score);1525}1526if(!origin->suspects)1527goto finish;15281529for(i =0, sg =first_scapegoat(revs, commit);1530 i < num_sg && sg;1531 sg = sg->next, i++) {1532struct origin *porigin = sg_origin[i];1533find_copy_in_parent(sb, &blametail, &toosmall,1534 origin, sg->item, porigin, opt);1535if(!origin->suspects)1536goto finish;1537}1538}15391540finish:1541*blametail = NULL;1542distribute_blame(sb, blames);1543/*1544 * prepend toosmall to origin->suspects1545 *1546 * There is no point in sorting: this ends up on a big1547 * unsorted list in the caller anyway.1548 */1549if(toosmall) {1550struct blame_entry **tail = &toosmall;1551while(*tail)1552 tail = &(*tail)->next;1553*tail = origin->suspects;1554 origin->suspects = toosmall;1555}1556for(i =0; i < num_sg; i++) {1557if(sg_origin[i]) {1558drop_origin_blob(sg_origin[i]);1559origin_decref(sg_origin[i]);1560}1561}1562drop_origin_blob(origin);1563if(sg_buf != sg_origin)1564free(sg_origin);1565}15661567/*1568 * Information on commits, used for output.1569 */1570struct commit_info {1571struct strbuf author;1572struct strbuf author_mail;1573unsigned long author_time;1574struct strbuf author_tz;15751576/* filled only when asked for details */1577struct strbuf committer;1578struct strbuf committer_mail;1579unsigned long committer_time;1580struct strbuf committer_tz;15811582struct strbuf summary;1583};15841585/*1586 * Parse author/committer line in the commit object buffer1587 */1588static voidget_ac_line(const char*inbuf,const char*what,1589struct strbuf *name,struct strbuf *mail,1590unsigned long*time,struct strbuf *tz)1591{1592struct ident_split ident;1593size_t len, maillen, namelen;1594char*tmp, *endp;1595const char*namebuf, *mailbuf;15961597 tmp =strstr(inbuf, what);1598if(!tmp)1599goto error_out;1600 tmp +=strlen(what);1601 endp =strchr(tmp,'\n');1602if(!endp)1603 len =strlen(tmp);1604else1605 len = endp - tmp;16061607if(split_ident_line(&ident, tmp, len)) {1608 error_out:1609/* Ugh */1610 tmp ="(unknown)";1611strbuf_addstr(name, tmp);1612strbuf_addstr(mail, tmp);1613strbuf_addstr(tz, tmp);1614*time =0;1615return;1616}16171618 namelen = ident.name_end - ident.name_begin;1619 namebuf = ident.name_begin;16201621 maillen = ident.mail_end - ident.mail_begin;1622 mailbuf = ident.mail_begin;16231624if(ident.date_begin && ident.date_end)1625*time =strtoul(ident.date_begin, NULL,10);1626else1627*time =0;16281629if(ident.tz_begin && ident.tz_end)1630strbuf_add(tz, ident.tz_begin, ident.tz_end - ident.tz_begin);1631else1632strbuf_addstr(tz,"(unknown)");16331634/*1635 * Now, convert both name and e-mail using mailmap1636 */1637map_user(&mailmap, &mailbuf, &maillen,1638&namebuf, &namelen);16391640strbuf_addf(mail,"<%.*s>", (int)maillen, mailbuf);1641strbuf_add(name, namebuf, namelen);1642}16431644static voidcommit_info_init(struct commit_info *ci)1645{16461647strbuf_init(&ci->author,0);1648strbuf_init(&ci->author_mail,0);1649strbuf_init(&ci->author_tz,0);1650strbuf_init(&ci->committer,0);1651strbuf_init(&ci->committer_mail,0);1652strbuf_init(&ci->committer_tz,0);1653strbuf_init(&ci->summary,0);1654}16551656static voidcommit_info_destroy(struct commit_info *ci)1657{16581659strbuf_release(&ci->author);1660strbuf_release(&ci->author_mail);1661strbuf_release(&ci->author_tz);1662strbuf_release(&ci->committer);1663strbuf_release(&ci->committer_mail);1664strbuf_release(&ci->committer_tz);1665strbuf_release(&ci->summary);1666}16671668static voidget_commit_info(struct commit *commit,1669struct commit_info *ret,1670int detailed)1671{1672int len;1673const char*subject, *encoding;1674const char*message;16751676commit_info_init(ret);16771678 encoding =get_log_output_encoding();1679 message =logmsg_reencode(commit, NULL, encoding);1680get_ac_line(message,"\nauthor ",1681&ret->author, &ret->author_mail,1682&ret->author_time, &ret->author_tz);16831684if(!detailed) {1685unuse_commit_buffer(commit, message);1686return;1687}16881689get_ac_line(message,"\ncommitter ",1690&ret->committer, &ret->committer_mail,1691&ret->committer_time, &ret->committer_tz);16921693 len =find_commit_subject(message, &subject);1694if(len)1695strbuf_add(&ret->summary, subject, len);1696else1697strbuf_addf(&ret->summary,"(%s)",oid_to_hex(&commit->object.oid));16981699unuse_commit_buffer(commit, message);1700}17011702/*1703 * Write out any suspect information which depends on the path. This must be1704 * handled separately from emit_one_suspect_detail(), because a given commit1705 * may have changes in multiple paths. So this needs to appear each time1706 * we mention a new group.1707 *1708 * To allow LF and other nonportable characters in pathnames,1709 * they are c-style quoted as needed.1710 */1711static voidwrite_filename_info(struct origin *suspect)1712{1713if(suspect->previous) {1714struct origin *prev = suspect->previous;1715printf("previous%s",oid_to_hex(&prev->commit->object.oid));1716write_name_quoted(prev->path, stdout,'\n');1717}1718printf("filename ");1719write_name_quoted(suspect->path, stdout,'\n');1720}17211722/*1723 * Porcelain/Incremental format wants to show a lot of details per1724 * commit. Instead of repeating this every line, emit it only once,1725 * the first time each commit appears in the output (unless the1726 * user has specifically asked for us to repeat).1727 */1728static intemit_one_suspect_detail(struct origin *suspect,int repeat)1729{1730struct commit_info ci;17311732if(!repeat && (suspect->commit->object.flags & METAINFO_SHOWN))1733return0;17341735 suspect->commit->object.flags |= METAINFO_SHOWN;1736get_commit_info(suspect->commit, &ci,1);1737printf("author%s\n", ci.author.buf);1738printf("author-mail%s\n", ci.author_mail.buf);1739printf("author-time%lu\n", ci.author_time);1740printf("author-tz%s\n", ci.author_tz.buf);1741printf("committer%s\n", ci.committer.buf);1742printf("committer-mail%s\n", ci.committer_mail.buf);1743printf("committer-time%lu\n", ci.committer_time);1744printf("committer-tz%s\n", ci.committer_tz.buf);1745printf("summary%s\n", ci.summary.buf);1746if(suspect->commit->object.flags & UNINTERESTING)1747printf("boundary\n");17481749commit_info_destroy(&ci);17501751return1;1752}17531754/*1755 * The blame_entry is found to be guilty for the range.1756 * Show it in incremental output.1757 */1758static voidfound_guilty_entry(struct blame_entry *ent,1759struct progress_info *pi)1760{1761if(incremental) {1762struct origin *suspect = ent->suspect;17631764printf("%s %d %d %d\n",1765oid_to_hex(&suspect->commit->object.oid),1766 ent->s_lno +1, ent->lno +1, ent->num_lines);1767emit_one_suspect_detail(suspect,0);1768write_filename_info(suspect);1769maybe_flush_or_die(stdout,"stdout");1770}1771 pi->blamed_lines += ent->num_lines;1772display_progress(pi->progress, pi->blamed_lines);1773}17741775/*1776 * The main loop -- while we have blobs with lines whose true origin1777 * is still unknown, pick one blob, and allow its lines to pass blames1778 * to its parents. */1779static voidassign_blame(struct scoreboard *sb,int opt)1780{1781struct rev_info *revs = sb->revs;1782struct commit *commit =prio_queue_get(&sb->commits);1783struct progress_info pi = { NULL,0};17841785if(show_progress)1786 pi.progress =start_progress_delay(_("Blaming lines"),1787 sb->num_lines,50,1);17881789while(commit) {1790struct blame_entry *ent;1791struct origin *suspect = commit->util;17921793/* find one suspect to break down */1794while(suspect && !suspect->suspects)1795 suspect = suspect->next;17961797if(!suspect) {1798 commit =prio_queue_get(&sb->commits);1799continue;1800}18011802assert(commit == suspect->commit);18031804/*1805 * We will use this suspect later in the loop,1806 * so hold onto it in the meantime.1807 */1808origin_incref(suspect);1809parse_commit(commit);1810if(reverse ||1811(!(commit->object.flags & UNINTERESTING) &&1812!(revs->max_age != -1&& commit->date < revs->max_age)))1813pass_blame(sb, suspect, opt);1814else{1815 commit->object.flags |= UNINTERESTING;1816if(commit->object.parsed)1817mark_parents_uninteresting(commit);1818}1819/* treat root commit as boundary */1820if(!commit->parents && !show_root)1821 commit->object.flags |= UNINTERESTING;18221823/* Take responsibility for the remaining entries */1824 ent = suspect->suspects;1825if(ent) {1826 suspect->guilty =1;1827for(;;) {1828struct blame_entry *next = ent->next;1829found_guilty_entry(ent, &pi);1830if(next) {1831 ent = next;1832continue;1833}1834 ent->next = sb->ent;1835 sb->ent = suspect->suspects;1836 suspect->suspects = NULL;1837break;1838}1839}1840origin_decref(suspect);18411842if(DEBUG)/* sanity */1843sanity_check_refcnt(sb);1844}18451846stop_progress(&pi.progress);1847}18481849static const char*format_time(unsigned long time,const char*tz_str,1850int show_raw_time)1851{1852static struct strbuf time_buf = STRBUF_INIT;18531854strbuf_reset(&time_buf);1855if(show_raw_time) {1856strbuf_addf(&time_buf,"%lu%s", time, tz_str);1857}1858else{1859const char*time_str;1860size_t time_width;1861int tz;1862 tz =atoi(tz_str);1863 time_str =show_date(time, tz, &blame_date_mode);1864strbuf_addstr(&time_buf, time_str);1865/*1866 * Add space paddings to time_buf to display a fixed width1867 * string, and use time_width for display width calibration.1868 */1869for(time_width =utf8_strwidth(time_str);1870 time_width < blame_date_width;1871 time_width++)1872strbuf_addch(&time_buf,' ');1873}1874return time_buf.buf;1875}18761877#define OUTPUT_ANNOTATE_COMPAT 0011878#define OUTPUT_LONG_OBJECT_NAME 0021879#define OUTPUT_RAW_TIMESTAMP 0041880#define OUTPUT_PORCELAIN 0101881#define OUTPUT_SHOW_NAME 0201882#define OUTPUT_SHOW_NUMBER 0401883#define OUTPUT_SHOW_SCORE 01001884#define OUTPUT_NO_AUTHOR 02001885#define OUTPUT_SHOW_EMAIL 04001886#define OUTPUT_LINE_PORCELAIN 0100018871888static voidemit_porcelain_details(struct origin *suspect,int repeat)1889{1890if(emit_one_suspect_detail(suspect, repeat) ||1891(suspect->commit->object.flags & MORE_THAN_ONE_PATH))1892write_filename_info(suspect);1893}18941895static voidemit_porcelain(struct scoreboard *sb,struct blame_entry *ent,1896int opt)1897{1898int repeat = opt & OUTPUT_LINE_PORCELAIN;1899int cnt;1900const char*cp;1901struct origin *suspect = ent->suspect;1902char hex[GIT_SHA1_HEXSZ +1];19031904sha1_to_hex_r(hex, suspect->commit->object.oid.hash);1905printf("%s %d %d %d\n",1906 hex,1907 ent->s_lno +1,1908 ent->lno +1,1909 ent->num_lines);1910emit_porcelain_details(suspect, repeat);19111912 cp =nth_line(sb, ent->lno);1913for(cnt =0; cnt < ent->num_lines; cnt++) {1914char ch;1915if(cnt) {1916printf("%s %d %d\n", hex,1917 ent->s_lno +1+ cnt,1918 ent->lno +1+ cnt);1919if(repeat)1920emit_porcelain_details(suspect,1);1921}1922putchar('\t');1923do{1924 ch = *cp++;1925putchar(ch);1926}while(ch !='\n'&&1927 cp < sb->final_buf + sb->final_buf_size);1928}19291930if(sb->final_buf_size && cp[-1] !='\n')1931putchar('\n');1932}19331934static voidemit_other(struct scoreboard *sb,struct blame_entry *ent,int opt)1935{1936int cnt;1937const char*cp;1938struct origin *suspect = ent->suspect;1939struct commit_info ci;1940char hex[GIT_SHA1_HEXSZ +1];1941int show_raw_time = !!(opt & OUTPUT_RAW_TIMESTAMP);19421943get_commit_info(suspect->commit, &ci,1);1944sha1_to_hex_r(hex, suspect->commit->object.oid.hash);19451946 cp =nth_line(sb, ent->lno);1947for(cnt =0; cnt < ent->num_lines; cnt++) {1948char ch;1949int length = (opt & OUTPUT_LONG_OBJECT_NAME) ? GIT_SHA1_HEXSZ : abbrev;19501951if(suspect->commit->object.flags & UNINTERESTING) {1952if(blank_boundary)1953memset(hex,' ', length);1954else if(!(opt & OUTPUT_ANNOTATE_COMPAT)) {1955 length--;1956putchar('^');1957}1958}19591960printf("%.*s", length, hex);1961if(opt & OUTPUT_ANNOTATE_COMPAT) {1962const char*name;1963if(opt & OUTPUT_SHOW_EMAIL)1964 name = ci.author_mail.buf;1965else1966 name = ci.author.buf;1967printf("\t(%10s\t%10s\t%d)", name,1968format_time(ci.author_time, ci.author_tz.buf,1969 show_raw_time),1970 ent->lno +1+ cnt);1971}else{1972if(opt & OUTPUT_SHOW_SCORE)1973printf(" %*d%02d",1974 max_score_digits, ent->score,1975 ent->suspect->refcnt);1976if(opt & OUTPUT_SHOW_NAME)1977printf(" %-*.*s", longest_file, longest_file,1978 suspect->path);1979if(opt & OUTPUT_SHOW_NUMBER)1980printf(" %*d", max_orig_digits,1981 ent->s_lno +1+ cnt);19821983if(!(opt & OUTPUT_NO_AUTHOR)) {1984const char*name;1985int pad;1986if(opt & OUTPUT_SHOW_EMAIL)1987 name = ci.author_mail.buf;1988else1989 name = ci.author.buf;1990 pad = longest_author -utf8_strwidth(name);1991printf(" (%s%*s%10s",1992 name, pad,"",1993format_time(ci.author_time,1994 ci.author_tz.buf,1995 show_raw_time));1996}1997printf(" %*d) ",1998 max_digits, ent->lno +1+ cnt);1999}2000do{2001 ch = *cp++;2002putchar(ch);2003}while(ch !='\n'&&2004 cp < sb->final_buf + sb->final_buf_size);2005}20062007if(sb->final_buf_size && cp[-1] !='\n')2008putchar('\n');20092010commit_info_destroy(&ci);2011}20122013static voidoutput(struct scoreboard *sb,int option)2014{2015struct blame_entry *ent;20162017if(option & OUTPUT_PORCELAIN) {2018for(ent = sb->ent; ent; ent = ent->next) {2019int count =0;2020struct origin *suspect;2021struct commit *commit = ent->suspect->commit;2022if(commit->object.flags & MORE_THAN_ONE_PATH)2023continue;2024for(suspect = commit->util; suspect; suspect = suspect->next) {2025if(suspect->guilty && count++) {2026 commit->object.flags |= MORE_THAN_ONE_PATH;2027break;2028}2029}2030}2031}20322033for(ent = sb->ent; ent; ent = ent->next) {2034if(option & OUTPUT_PORCELAIN)2035emit_porcelain(sb, ent, option);2036else{2037emit_other(sb, ent, option);2038}2039}2040}20412042static const char*get_next_line(const char*start,const char*end)2043{2044const char*nl =memchr(start,'\n', end - start);2045return nl ? nl +1: end;2046}20472048/*2049 * To allow quick access to the contents of nth line in the2050 * final image, prepare an index in the scoreboard.2051 */2052static intprepare_lines(struct scoreboard *sb)2053{2054const char*buf = sb->final_buf;2055unsigned long len = sb->final_buf_size;2056const char*end = buf + len;2057const char*p;2058int*lineno;2059int num =0;20602061for(p = buf; p < end; p =get_next_line(p, end))2062 num++;20632064ALLOC_ARRAY(sb->lineno, num +1);2065 lineno = sb->lineno;20662067for(p = buf; p < end; p =get_next_line(p, end))2068*lineno++ = p - buf;20692070*lineno = len;20712072 sb->num_lines = num;2073return sb->num_lines;2074}20752076/*2077 * Add phony grafts for use with -S; this is primarily to2078 * support git's cvsserver that wants to give a linear history2079 * to its clients.2080 */2081static intread_ancestry(const char*graft_file)2082{2083FILE*fp =fopen(graft_file,"r");2084struct strbuf buf = STRBUF_INIT;2085if(!fp)2086return-1;2087while(!strbuf_getwholeline(&buf, fp,'\n')) {2088/* The format is just "Commit Parent1 Parent2 ...\n" */2089struct commit_graft *graft =read_graft_line(buf.buf, buf.len);2090if(graft)2091register_commit_graft(graft,0);2092}2093fclose(fp);2094strbuf_release(&buf);2095return0;2096}20972098static intupdate_auto_abbrev(int auto_abbrev,struct origin *suspect)2099{2100const char*uniq =find_unique_abbrev(suspect->commit->object.oid.hash,2101 auto_abbrev);2102int len =strlen(uniq);2103if(auto_abbrev < len)2104return len;2105return auto_abbrev;2106}21072108/*2109 * How many columns do we need to show line numbers, authors,2110 * and filenames?2111 */2112static voidfind_alignment(struct scoreboard *sb,int*option)2113{2114int longest_src_lines =0;2115int longest_dst_lines =0;2116unsigned largest_score =0;2117struct blame_entry *e;2118int compute_auto_abbrev = (abbrev <0);2119int auto_abbrev = DEFAULT_ABBREV;21202121for(e = sb->ent; e; e = e->next) {2122struct origin *suspect = e->suspect;2123int num;21242125if(compute_auto_abbrev)2126 auto_abbrev =update_auto_abbrev(auto_abbrev, suspect);2127if(strcmp(suspect->path, sb->path))2128*option |= OUTPUT_SHOW_NAME;2129 num =strlen(suspect->path);2130if(longest_file < num)2131 longest_file = num;2132if(!(suspect->commit->object.flags & METAINFO_SHOWN)) {2133struct commit_info ci;2134 suspect->commit->object.flags |= METAINFO_SHOWN;2135get_commit_info(suspect->commit, &ci,1);2136if(*option & OUTPUT_SHOW_EMAIL)2137 num =utf8_strwidth(ci.author_mail.buf);2138else2139 num =utf8_strwidth(ci.author.buf);2140if(longest_author < num)2141 longest_author = num;2142commit_info_destroy(&ci);2143}2144 num = e->s_lno + e->num_lines;2145if(longest_src_lines < num)2146 longest_src_lines = num;2147 num = e->lno + e->num_lines;2148if(longest_dst_lines < num)2149 longest_dst_lines = num;2150if(largest_score <ent_score(sb, e))2151 largest_score =ent_score(sb, e);2152}2153 max_orig_digits =decimal_width(longest_src_lines);2154 max_digits =decimal_width(longest_dst_lines);2155 max_score_digits =decimal_width(largest_score);21562157if(compute_auto_abbrev)2158/* one more abbrev length is needed for the boundary commit */2159 abbrev = auto_abbrev +1;2160}21612162/*2163 * For debugging -- origin is refcounted, and this asserts that2164 * we do not underflow.2165 */2166static voidsanity_check_refcnt(struct scoreboard *sb)2167{2168int baa =0;2169struct blame_entry *ent;21702171for(ent = sb->ent; ent; ent = ent->next) {2172/* Nobody should have zero or negative refcnt */2173if(ent->suspect->refcnt <=0) {2174fprintf(stderr,"%sin%shas negative refcnt%d\n",2175 ent->suspect->path,2176oid_to_hex(&ent->suspect->commit->object.oid),2177 ent->suspect->refcnt);2178 baa =1;2179}2180}2181if(baa) {2182int opt =0160;2183find_alignment(sb, &opt);2184output(sb, opt);2185die("Baa%d!", baa);2186}2187}21882189static unsignedparse_score(const char*arg)2190{2191char*end;2192unsigned long score =strtoul(arg, &end,10);2193if(*end)2194return0;2195return score;2196}21972198static const char*add_prefix(const char*prefix,const char*path)2199{2200returnprefix_path(prefix, prefix ?strlen(prefix) :0, path);2201}22022203static intgit_blame_config(const char*var,const char*value,void*cb)2204{2205if(!strcmp(var,"blame.showroot")) {2206 show_root =git_config_bool(var, value);2207return0;2208}2209if(!strcmp(var,"blame.blankboundary")) {2210 blank_boundary =git_config_bool(var, value);2211return0;2212}2213if(!strcmp(var,"blame.showemail")) {2214int*output_option = cb;2215if(git_config_bool(var, value))2216*output_option |= OUTPUT_SHOW_EMAIL;2217else2218*output_option &= ~OUTPUT_SHOW_EMAIL;2219return0;2220}2221if(!strcmp(var,"blame.date")) {2222if(!value)2223returnconfig_error_nonbool(var);2224parse_date_format(value, &blame_date_mode);2225return0;2226}22272228if(git_diff_heuristic_config(var, value, cb) <0)2229return-1;2230if(userdiff_config(var, value) <0)2231return-1;22322233returngit_default_config(var, value, cb);2234}22352236static voidverify_working_tree_path(struct commit *work_tree,const char*path)2237{2238struct commit_list *parents;2239int pos;22402241for(parents = work_tree->parents; parents; parents = parents->next) {2242const struct object_id *commit_oid = &parents->item->object.oid;2243struct object_id blob_oid;2244unsigned mode;22452246if(!get_tree_entry(commit_oid->hash, path, blob_oid.hash, &mode) &&2247sha1_object_info(blob_oid.hash, NULL) == OBJ_BLOB)2248return;2249}22502251 pos =cache_name_pos(path,strlen(path));2252if(pos >=0)2253;/* path is in the index */2254else if(-1- pos < active_nr &&2255!strcmp(active_cache[-1- pos]->name, path))2256;/* path is in the index, unmerged */2257else2258die("no such path '%s' in HEAD", path);2259}22602261static struct commit_list **append_parent(struct commit_list **tail,const struct object_id *oid)2262{2263struct commit *parent;22642265 parent =lookup_commit_reference(oid->hash);2266if(!parent)2267die("no such commit%s",oid_to_hex(oid));2268return&commit_list_insert(parent, tail)->next;2269}22702271static voidappend_merge_parents(struct commit_list **tail)2272{2273int merge_head;2274struct strbuf line = STRBUF_INIT;22752276 merge_head =open(git_path_merge_head(), O_RDONLY);2277if(merge_head <0) {2278if(errno == ENOENT)2279return;2280die("cannot open '%s' for reading",git_path_merge_head());2281}22822283while(!strbuf_getwholeline_fd(&line, merge_head,'\n')) {2284struct object_id oid;2285if(line.len < GIT_SHA1_HEXSZ ||get_oid_hex(line.buf, &oid))2286die("unknown line in '%s':%s",git_path_merge_head(), line.buf);2287 tail =append_parent(tail, &oid);2288}2289close(merge_head);2290strbuf_release(&line);2291}22922293/*2294 * This isn't as simple as passing sb->buf and sb->len, because we2295 * want to transfer ownership of the buffer to the commit (so we2296 * must use detach).2297 */2298static voidset_commit_buffer_from_strbuf(struct commit *c,struct strbuf *sb)2299{2300size_t len;2301void*buf =strbuf_detach(sb, &len);2302set_commit_buffer(c, buf, len);2303}23042305/*2306 * Prepare a dummy commit that represents the work tree (or staged) item.2307 * Note that annotating work tree item never works in the reverse.2308 */2309static struct commit *fake_working_tree_commit(struct diff_options *opt,2310const char*path,2311const char*contents_from)2312{2313struct commit *commit;2314struct origin *origin;2315struct commit_list **parent_tail, *parent;2316struct object_id head_oid;2317struct strbuf buf = STRBUF_INIT;2318const char*ident;2319time_t now;2320int size, len;2321struct cache_entry *ce;2322unsigned mode;2323struct strbuf msg = STRBUF_INIT;23242325read_cache();2326time(&now);2327 commit =alloc_commit_node();2328 commit->object.parsed =1;2329 commit->date = now;2330 parent_tail = &commit->parents;23312332if(!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, head_oid.hash, NULL))2333die("no such ref: HEAD");23342335 parent_tail =append_parent(parent_tail, &head_oid);2336append_merge_parents(parent_tail);2337verify_working_tree_path(commit, path);23382339 origin =make_origin(commit, path);23402341 ident =fmt_ident("Not Committed Yet","not.committed.yet", NULL,0);2342strbuf_addstr(&msg,"tree 0000000000000000000000000000000000000000\n");2343for(parent = commit->parents; parent; parent = parent->next)2344strbuf_addf(&msg,"parent%s\n",2345oid_to_hex(&parent->item->object.oid));2346strbuf_addf(&msg,2347"author%s\n"2348"committer%s\n\n"2349"Version of%sfrom%s\n",2350 ident, ident, path,2351(!contents_from ? path :2352(!strcmp(contents_from,"-") ?"standard input": contents_from)));2353set_commit_buffer_from_strbuf(commit, &msg);23542355if(!contents_from ||strcmp("-", contents_from)) {2356struct stat st;2357const char*read_from;2358char*buf_ptr;2359unsigned long buf_len;23602361if(contents_from) {2362if(stat(contents_from, &st) <0)2363die_errno("Cannot stat '%s'", contents_from);2364 read_from = contents_from;2365}2366else{2367if(lstat(path, &st) <0)2368die_errno("Cannot lstat '%s'", path);2369 read_from = path;2370}2371 mode =canon_mode(st.st_mode);23722373switch(st.st_mode & S_IFMT) {2374case S_IFREG:2375if(DIFF_OPT_TST(opt, ALLOW_TEXTCONV) &&2376textconv_object(read_from, mode, &null_oid,0, &buf_ptr, &buf_len))2377strbuf_attach(&buf, buf_ptr, buf_len, buf_len +1);2378else if(strbuf_read_file(&buf, read_from, st.st_size) != st.st_size)2379die_errno("cannot open or read '%s'", read_from);2380break;2381case S_IFLNK:2382if(strbuf_readlink(&buf, read_from, st.st_size) <0)2383die_errno("cannot readlink '%s'", read_from);2384break;2385default:2386die("unsupported file type%s", read_from);2387}2388}2389else{2390/* Reading from stdin */2391 mode =0;2392if(strbuf_read(&buf,0,0) <0)2393die_errno("failed to read from stdin");2394}2395convert_to_git(path, buf.buf, buf.len, &buf,0);2396 origin->file.ptr = buf.buf;2397 origin->file.size = buf.len;2398pretend_sha1_file(buf.buf, buf.len, OBJ_BLOB, origin->blob_oid.hash);23992400/*2401 * Read the current index, replace the path entry with2402 * origin->blob_sha1 without mucking with its mode or type2403 * bits; we are not going to write this index out -- we just2404 * want to run "diff-index --cached".2405 */2406discard_cache();2407read_cache();24082409 len =strlen(path);2410if(!mode) {2411int pos =cache_name_pos(path, len);2412if(0<= pos)2413 mode = active_cache[pos]->ce_mode;2414else2415/* Let's not bother reading from HEAD tree */2416 mode = S_IFREG |0644;2417}2418 size =cache_entry_size(len);2419 ce =xcalloc(1, size);2420oidcpy(&ce->oid, &origin->blob_oid);2421memcpy(ce->name, path, len);2422 ce->ce_flags =create_ce_flags(0);2423 ce->ce_namelen = len;2424 ce->ce_mode =create_ce_mode(mode);2425add_cache_entry(ce, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE);24262427cache_tree_invalidate_path(&the_index, path);24282429return commit;2430}24312432static struct commit *find_single_final(struct rev_info *revs,2433const char**name_p)2434{2435int i;2436struct commit *found = NULL;2437const char*name = NULL;24382439for(i =0; i < revs->pending.nr; i++) {2440struct object *obj = revs->pending.objects[i].item;2441if(obj->flags & UNINTERESTING)2442continue;2443 obj =deref_tag(obj, NULL,0);2444if(obj->type != OBJ_COMMIT)2445die("Non commit%s?", revs->pending.objects[i].name);2446if(found)2447die("More than one commit to dig from%sand%s?",2448 revs->pending.objects[i].name, name);2449 found = (struct commit *)obj;2450 name = revs->pending.objects[i].name;2451}2452if(name_p)2453*name_p = name;2454return found;2455}24562457static char*prepare_final(struct scoreboard *sb)2458{2459const char*name;2460 sb->final =find_single_final(sb->revs, &name);2461returnxstrdup_or_null(name);2462}24632464static const char*dwim_reverse_initial(struct scoreboard *sb)2465{2466/*2467 * DWIM "git blame --reverse ONE -- PATH" as2468 * "git blame --reverse ONE..HEAD -- PATH" but only do so2469 * when it makes sense.2470 */2471struct object *obj;2472struct commit *head_commit;2473unsigned char head_sha1[20];24742475if(sb->revs->pending.nr !=1)2476return NULL;24772478/* Is that sole rev a committish? */2479 obj = sb->revs->pending.objects[0].item;2480 obj =deref_tag(obj, NULL,0);2481if(obj->type != OBJ_COMMIT)2482return NULL;24832484/* Do we have HEAD? */2485if(!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, head_sha1, NULL))2486return NULL;2487 head_commit =lookup_commit_reference_gently(head_sha1,1);2488if(!head_commit)2489return NULL;24902491/* Turn "ONE" into "ONE..HEAD" then */2492 obj->flags |= UNINTERESTING;2493add_pending_object(sb->revs, &head_commit->object,"HEAD");24942495 sb->final = (struct commit *)obj;2496return sb->revs->pending.objects[0].name;2497}24982499static char*prepare_initial(struct scoreboard *sb)2500{2501int i;2502const char*final_commit_name = NULL;2503struct rev_info *revs = sb->revs;25042505/*2506 * There must be one and only one negative commit, and it must be2507 * the boundary.2508 */2509for(i =0; i < revs->pending.nr; i++) {2510struct object *obj = revs->pending.objects[i].item;2511if(!(obj->flags & UNINTERESTING))2512continue;2513 obj =deref_tag(obj, NULL,0);2514if(obj->type != OBJ_COMMIT)2515die("Non commit%s?", revs->pending.objects[i].name);2516if(sb->final)2517die("More than one commit to dig up from,%sand%s?",2518 revs->pending.objects[i].name,2519 final_commit_name);2520 sb->final = (struct commit *) obj;2521 final_commit_name = revs->pending.objects[i].name;2522}25232524if(!final_commit_name)2525 final_commit_name =dwim_reverse_initial(sb);2526if(!final_commit_name)2527die("No commit to dig up from?");2528returnxstrdup(final_commit_name);2529}25302531static intblame_copy_callback(const struct option *option,const char*arg,int unset)2532{2533int*opt = option->value;25342535/*2536 * -C enables copy from removed files;2537 * -C -C enables copy from existing files, but only2538 * when blaming a new file;2539 * -C -C -C enables copy from existing files for2540 * everybody2541 */2542if(*opt & PICKAXE_BLAME_COPY_HARDER)2543*opt |= PICKAXE_BLAME_COPY_HARDEST;2544if(*opt & PICKAXE_BLAME_COPY)2545*opt |= PICKAXE_BLAME_COPY_HARDER;2546*opt |= PICKAXE_BLAME_COPY | PICKAXE_BLAME_MOVE;25472548if(arg)2549 blame_copy_score =parse_score(arg);2550return0;2551}25522553static intblame_move_callback(const struct option *option,const char*arg,int unset)2554{2555int*opt = option->value;25562557*opt |= PICKAXE_BLAME_MOVE;25582559if(arg)2560 blame_move_score =parse_score(arg);2561return0;2562}25632564intcmd_blame(int argc,const char**argv,const char*prefix)2565{2566struct rev_info revs;2567const char*path;2568struct scoreboard sb;2569struct origin *o;2570struct blame_entry *ent = NULL;2571long dashdash_pos, lno;2572char*final_commit_name = NULL;2573enum object_type type;2574struct commit *final_commit = NULL;25752576struct string_list range_list = STRING_LIST_INIT_NODUP;2577int output_option =0, opt =0;2578int show_stats =0;2579const char*revs_file = NULL;2580const char*contents_from = NULL;2581const struct option options[] = {2582OPT_BOOL(0,"incremental", &incremental,N_("Show blame entries as we find them, incrementally")),2583OPT_BOOL('b', NULL, &blank_boundary,N_("Show blank SHA-1 for boundary commits (Default: off)")),2584OPT_BOOL(0,"root", &show_root,N_("Do not treat root commits as boundaries (Default: off)")),2585OPT_BOOL(0,"show-stats", &show_stats,N_("Show work cost statistics")),2586OPT_BOOL(0,"progress", &show_progress,N_("Force progress reporting")),2587OPT_BIT(0,"score-debug", &output_option,N_("Show output score for blame entries"), OUTPUT_SHOW_SCORE),2588OPT_BIT('f',"show-name", &output_option,N_("Show original filename (Default: auto)"), OUTPUT_SHOW_NAME),2589OPT_BIT('n',"show-number", &output_option,N_("Show original linenumber (Default: off)"), OUTPUT_SHOW_NUMBER),2590OPT_BIT('p',"porcelain", &output_option,N_("Show in a format designed for machine consumption"), OUTPUT_PORCELAIN),2591OPT_BIT(0,"line-porcelain", &output_option,N_("Show porcelain format with per-line commit information"), OUTPUT_PORCELAIN|OUTPUT_LINE_PORCELAIN),2592OPT_BIT('c', NULL, &output_option,N_("Use the same output mode as git-annotate (Default: off)"), OUTPUT_ANNOTATE_COMPAT),2593OPT_BIT('t', NULL, &output_option,N_("Show raw timestamp (Default: off)"), OUTPUT_RAW_TIMESTAMP),2594OPT_BIT('l', NULL, &output_option,N_("Show long commit SHA1 (Default: off)"), OUTPUT_LONG_OBJECT_NAME),2595OPT_BIT('s', NULL, &output_option,N_("Suppress author name and timestamp (Default: off)"), OUTPUT_NO_AUTHOR),2596OPT_BIT('e',"show-email", &output_option,N_("Show author email instead of name (Default: off)"), OUTPUT_SHOW_EMAIL),2597OPT_BIT('w', NULL, &xdl_opts,N_("Ignore whitespace differences"), XDF_IGNORE_WHITESPACE),25982599/*2600 * The following two options are parsed by parse_revision_opt()2601 * and are only included here to get included in the "-h"2602 * output:2603 */2604{ OPTION_LOWLEVEL_CALLBACK,0,"indent-heuristic", NULL, NULL,N_("Use an experimental indent-based heuristic to improve diffs"), PARSE_OPT_NOARG, parse_opt_unknown_cb },2605{ OPTION_LOWLEVEL_CALLBACK,0,"compaction-heuristic", NULL, NULL,N_("Use an experimental blank-line-based heuristic to improve diffs"), PARSE_OPT_NOARG, parse_opt_unknown_cb },26062607OPT_BIT(0,"minimal", &xdl_opts,N_("Spend extra cycles to find better match"), XDF_NEED_MINIMAL),2608OPT_STRING('S', NULL, &revs_file,N_("file"),N_("Use revisions from <file> instead of calling git-rev-list")),2609OPT_STRING(0,"contents", &contents_from,N_("file"),N_("Use <file>'s contents as the final image")),2610{ OPTION_CALLBACK,'C', NULL, &opt,N_("score"),N_("Find line copies within and across files"), PARSE_OPT_OPTARG, blame_copy_callback },2611{ OPTION_CALLBACK,'M', NULL, &opt,N_("score"),N_("Find line movements within and across files"), PARSE_OPT_OPTARG, blame_move_callback },2612OPT_STRING_LIST('L', NULL, &range_list,N_("n,m"),N_("Process only line range n,m, counting from 1")),2613OPT__ABBREV(&abbrev),2614OPT_END()2615};26162617struct parse_opt_ctx_t ctx;2618int cmd_is_annotate = !strcmp(argv[0],"annotate");2619struct range_set ranges;2620unsigned int range_i;2621long anchor;26222623git_config(git_blame_config, &output_option);2624init_revisions(&revs, NULL);2625 revs.date_mode = blame_date_mode;2626DIFF_OPT_SET(&revs.diffopt, ALLOW_TEXTCONV);2627DIFF_OPT_SET(&revs.diffopt, FOLLOW_RENAMES);26282629 save_commit_buffer =0;2630 dashdash_pos =0;2631 show_progress = -1;26322633parse_options_start(&ctx, argc, argv, prefix, options,2634 PARSE_OPT_KEEP_DASHDASH | PARSE_OPT_KEEP_ARGV0);2635for(;;) {2636switch(parse_options_step(&ctx, options, blame_opt_usage)) {2637case PARSE_OPT_HELP:2638exit(129);2639case PARSE_OPT_DONE:2640if(ctx.argv[0])2641 dashdash_pos = ctx.cpidx;2642goto parse_done;2643}26442645if(!strcmp(ctx.argv[0],"--reverse")) {2646 ctx.argv[0] ="--children";2647 reverse =1;2648}2649parse_revision_opt(&revs, &ctx, options, blame_opt_usage);2650}2651parse_done:2652 no_whole_file_rename = !DIFF_OPT_TST(&revs.diffopt, FOLLOW_RENAMES);2653 xdl_opts |= revs.diffopt.xdl_opts & (XDF_COMPACTION_HEURISTIC | XDF_INDENT_HEURISTIC);2654DIFF_OPT_CLR(&revs.diffopt, FOLLOW_RENAMES);2655 argc =parse_options_end(&ctx);26562657if(incremental || (output_option & OUTPUT_PORCELAIN)) {2658if(show_progress >0)2659die(_("--progress can't be used with --incremental or porcelain formats"));2660 show_progress =0;2661}else if(show_progress <0)2662 show_progress =isatty(2);26632664if(0< abbrev && abbrev < GIT_SHA1_HEXSZ)2665/* one more abbrev length is needed for the boundary commit */2666 abbrev++;2667else if(!abbrev)2668 abbrev = GIT_SHA1_HEXSZ;26692670if(revs_file &&read_ancestry(revs_file))2671die_errno("reading graft file '%s' failed", revs_file);26722673if(cmd_is_annotate) {2674 output_option |= OUTPUT_ANNOTATE_COMPAT;2675 blame_date_mode.type = DATE_ISO8601;2676}else{2677 blame_date_mode = revs.date_mode;2678}26792680/* The maximum width used to show the dates */2681switch(blame_date_mode.type) {2682case DATE_RFC2822:2683 blame_date_width =sizeof("Thu, 19 Oct 2006 16:00:04 -0700");2684break;2685case DATE_ISO8601_STRICT:2686 blame_date_width =sizeof("2006-10-19T16:00:04-07:00");2687break;2688case DATE_ISO8601:2689 blame_date_width =sizeof("2006-10-19 16:00:04 -0700");2690break;2691case DATE_RAW:2692 blame_date_width =sizeof("1161298804 -0700");2693break;2694case DATE_UNIX:2695 blame_date_width =sizeof("1161298804");2696break;2697case DATE_SHORT:2698 blame_date_width =sizeof("2006-10-19");2699break;2700case DATE_RELATIVE:2701/* TRANSLATORS: This string is used to tell us the maximum2702 display width for a relative timestamp in "git blame"2703 output. For C locale, "4 years, 11 months ago", which2704 takes 22 places, is the longest among various forms of2705 relative timestamps, but your language may need more or2706 fewer display columns. */2707 blame_date_width =utf8_strwidth(_("4 years, 11 months ago")) +1;/* add the null */2708break;2709case DATE_NORMAL:2710 blame_date_width =sizeof("Thu Oct 19 16:00:04 2006 -0700");2711break;2712case DATE_STRFTIME:2713 blame_date_width =strlen(show_date(0,0, &blame_date_mode)) +1;/* add the null */2714break;2715}2716 blame_date_width -=1;/* strip the null */27172718if(DIFF_OPT_TST(&revs.diffopt, FIND_COPIES_HARDER))2719 opt |= (PICKAXE_BLAME_COPY | PICKAXE_BLAME_MOVE |2720 PICKAXE_BLAME_COPY_HARDER);27212722if(!blame_move_score)2723 blame_move_score = BLAME_DEFAULT_MOVE_SCORE;2724if(!blame_copy_score)2725 blame_copy_score = BLAME_DEFAULT_COPY_SCORE;27262727/*2728 * We have collected options unknown to us in argv[1..unk]2729 * which are to be passed to revision machinery if we are2730 * going to do the "bottom" processing.2731 *2732 * The remaining are:2733 *2734 * (1) if dashdash_pos != 0, it is either2735 * "blame [revisions] -- <path>" or2736 * "blame -- <path> <rev>"2737 *2738 * (2) otherwise, it is one of the two:2739 * "blame [revisions] <path>"2740 * "blame <path> <rev>"2741 *2742 * Note that we must strip out <path> from the arguments: we do not2743 * want the path pruning but we may want "bottom" processing.2744 */2745if(dashdash_pos) {2746switch(argc - dashdash_pos -1) {2747case2:/* (1b) */2748if(argc !=4)2749usage_with_options(blame_opt_usage, options);2750/* reorder for the new way: <rev> -- <path> */2751 argv[1] = argv[3];2752 argv[3] = argv[2];2753 argv[2] ="--";2754/* FALLTHROUGH */2755case1:/* (1a) */2756 path =add_prefix(prefix, argv[--argc]);2757 argv[argc] = NULL;2758break;2759default:2760usage_with_options(blame_opt_usage, options);2761}2762}else{2763if(argc <2)2764usage_with_options(blame_opt_usage, options);2765 path =add_prefix(prefix, argv[argc -1]);2766if(argc ==3&& !file_exists(path)) {/* (2b) */2767 path =add_prefix(prefix, argv[1]);2768 argv[1] = argv[2];2769}2770 argv[argc -1] ="--";27712772setup_work_tree();2773if(!file_exists(path))2774die_errno("cannot stat path '%s'", path);2775}27762777 revs.disable_stdin =1;2778setup_revisions(argc, argv, &revs, NULL);2779memset(&sb,0,sizeof(sb));27802781 sb.revs = &revs;2782if(!reverse) {2783 final_commit_name =prepare_final(&sb);2784 sb.commits.compare = compare_commits_by_commit_date;2785}2786else if(contents_from)2787die(_("--contents and --reverse do not blend well."));2788else{2789 final_commit_name =prepare_initial(&sb);2790 sb.commits.compare = compare_commits_by_reverse_commit_date;2791if(revs.first_parent_only)2792 revs.children.name = NULL;2793}27942795if(!sb.final) {2796/*2797 * "--not A B -- path" without anything positive;2798 * do not default to HEAD, but use the working tree2799 * or "--contents".2800 */2801setup_work_tree();2802 sb.final =fake_working_tree_commit(&sb.revs->diffopt,2803 path, contents_from);2804add_pending_object(&revs, &(sb.final->object),":");2805}2806else if(contents_from)2807die(_("cannot use --contents with final commit object name"));28082809if(reverse && revs.first_parent_only) {2810 final_commit =find_single_final(sb.revs, NULL);2811if(!final_commit)2812die(_("--reverse and --first-parent together require specified latest commit"));2813}28142815/*2816 * If we have bottom, this will mark the ancestors of the2817 * bottom commits we would reach while traversing as2818 * uninteresting.2819 */2820if(prepare_revision_walk(&revs))2821die(_("revision walk setup failed"));28222823if(reverse && revs.first_parent_only) {2824struct commit *c = final_commit;28252826 sb.revs->children.name ="children";2827while(c->parents &&2828oidcmp(&c->object.oid, &sb.final->object.oid)) {2829struct commit_list *l =xcalloc(1,sizeof(*l));28302831 l->item = c;2832if(add_decoration(&sb.revs->children,2833&c->parents->item->object, l))2834die("BUG: not unique item in first-parent chain");2835 c = c->parents->item;2836}28372838if(oidcmp(&c->object.oid, &sb.final->object.oid))2839die(_("--reverse --first-parent together require range along first-parent chain"));2840}28412842if(is_null_oid(&sb.final->object.oid)) {2843 o = sb.final->util;2844 sb.final_buf =xmemdupz(o->file.ptr, o->file.size);2845 sb.final_buf_size = o->file.size;2846}2847else{2848 o =get_origin(&sb, sb.final, path);2849if(fill_blob_sha1_and_mode(o))2850die(_("no such path%sin%s"), path, final_commit_name);28512852if(DIFF_OPT_TST(&sb.revs->diffopt, ALLOW_TEXTCONV) &&2853textconv_object(path, o->mode, &o->blob_oid,1, (char**) &sb.final_buf,2854&sb.final_buf_size))2855;2856else2857 sb.final_buf =read_sha1_file(o->blob_oid.hash, &type,2858&sb.final_buf_size);28592860if(!sb.final_buf)2861die(_("cannot read blob%sfor path%s"),2862oid_to_hex(&o->blob_oid),2863 path);2864}2865 num_read_blob++;2866 lno =prepare_lines(&sb);28672868if(lno && !range_list.nr)2869string_list_append(&range_list,"1");28702871 anchor =1;2872range_set_init(&ranges, range_list.nr);2873for(range_i =0; range_i < range_list.nr; ++range_i) {2874long bottom, top;2875if(parse_range_arg(range_list.items[range_i].string,2876 nth_line_cb, &sb, lno, anchor,2877&bottom, &top, sb.path))2878usage(blame_usage);2879if(lno < top || ((lno || bottom) && lno < bottom))2880die(Q_("file%shas only%lu line",2881"file%shas only%lu lines",2882 lno), path, lno);2883if(bottom <1)2884 bottom =1;2885if(top <1)2886 top = lno;2887 bottom--;2888range_set_append_unsafe(&ranges, bottom, top);2889 anchor = top +1;2890}2891sort_and_merge_range_set(&ranges);28922893for(range_i = ranges.nr; range_i >0; --range_i) {2894const struct range *r = &ranges.ranges[range_i -1];2895long bottom = r->start;2896long top = r->end;2897struct blame_entry *next = ent;2898 ent =xcalloc(1,sizeof(*ent));2899 ent->lno = bottom;2900 ent->num_lines = top - bottom;2901 ent->suspect = o;2902 ent->s_lno = bottom;2903 ent->next = next;2904origin_incref(o);2905}29062907 o->suspects = ent;2908prio_queue_put(&sb.commits, o->commit);29092910origin_decref(o);29112912range_set_release(&ranges);2913string_list_clear(&range_list,0);29142915 sb.ent = NULL;2916 sb.path = path;29172918read_mailmap(&mailmap, NULL);29192920assign_blame(&sb, opt);29212922if(!incremental)2923setup_pager();29242925free(final_commit_name);29262927if(incremental)2928return0;29292930 sb.ent =blame_sort(sb.ent, compare_blame_final);29312932coalesce(&sb);29332934if(!(output_option & OUTPUT_PORCELAIN))2935find_alignment(&sb, &output_option);29362937output(&sb, output_option);2938free((void*)sb.final_buf);2939for(ent = sb.ent; ent; ) {2940struct blame_entry *e = ent->next;2941free(ent);2942 ent = e;2943}29442945if(show_stats) {2946printf("num read blob:%d\n", num_read_blob);2947printf("num get patch:%d\n", num_get_patch);2948printf("num commits:%d\n", num_commits);2949}2950return0;2951}