?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
git-pickaxe: refcount origin correctly in find_copy_in_parent()
[git/git-svn.git] / builtin-pickaxe.c
blob3e7277da21cdf4c94a0056e1e9a404c383a5f6b8
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 "xdiff-interface.h"
17
18 #include <time.h>
19 #include <sys/time.h>
20
21 static char pickaxe_usage[] =
22 "git-pickaxe [-c] [-l] [-t] [-f] [-n] [-p] [-L n,m] [-S <revs-file>] [-M] [-C] [-C] [commit] [--] file\n"
23 " -c, --compatibility Use the same output mode as git-annotate (Default: off)\n"
24 " -l, --long Show long commit SHA1 (Default: off)\n"
25 " -t, --time Show raw timestamp (Default: off)\n"
26 " -f, --show-name Show original filename (Default: auto)\n"
27 " -n, --show-number Show original linenumber (Default: off)\n"
28 " -p, --porcelain Show in a format designed for machine consumption\n"
29 " -L n,m Process only line range n,m, counting from 1\n"
30 " -M, -C Find line movements within and across files\n"
31 " -S revs-file Use revisions from revs-file instead of calling git-rev-list\n";
32
33 static int longest_file;
34 static int longest_author;
35 static int max_orig_digits;
36 static int max_digits;
37 static int max_score_digits;
38
39 #ifndef DEBUG
40 #define DEBUG 0
41 #endif
42
43 #define PICKAXE_BLAME_MOVE 01
44 #define PICKAXE_BLAME_COPY 02
45 #define PICKAXE_BLAME_COPY_HARDER 04
46
47 /*
48 * blame for a blame_entry with score lower than these thresholds
49 * is not passed to the parent using move/copy logic.
50 */
51 static unsigned blame_move_score;
52 static unsigned blame_copy_score;
53 #define BLAME_DEFAULT_MOVE_SCORE 20
54 #define BLAME_DEFAULT_COPY_SCORE 40
55
56 /* bits #0..7 in revision.h, #8..11 used for merge_bases() in commit.c */
57 #define METAINFO_SHOWN (1u<<12)
58 #define MORE_THAN_ONE_PATH (1u<<13)
59
60 /*
61 * One blob in a commit that is being suspected
62 */
63 struct origin {
64 int refcnt;
65 struct commit *commit;
66 unsigned char blob_sha1[20];
67 char path[FLEX_ARRAY];
68 };
69
70 static inline struct origin *origin_incref(struct origin *o)
71 {
72 if (o)
73 o->refcnt++;
74 return o;
75 }
76
77 static void origin_decref(struct origin *o)
78 {
79 if (o && --o->refcnt <= 0) {
80 memset(o, 0, sizeof(*o));
81 free(o);
82 }
83 }
84
85 struct blame_entry {
86 struct blame_entry *prev;
87 struct blame_entry *next;
88
89 /* the first line of this group in the final image;
90 * internally all line numbers are 0 based.
91 */
92 int lno;
93
94 /* how many lines this group has */
95 int num_lines;
96
97 /* the commit that introduced this group into the final image */
98 struct origin *suspect;
99
100 /* true if the suspect is truly guilty; false while we have not
101 * checked if the group came from one of its parents.
102 */
103 char guilty;
104
105 /* the line number of the first line of this group in the
106 * suspect's file; internally all line numbers are 0 based.
107 */
108 int s_lno;
109
110 /* how significant this entry is -- cached to avoid
111 * scanning the lines over and over
112 */
113 unsigned score;
114 };
115
116 struct scoreboard {
117 /* the final commit (i.e. where we started digging from) */
118 struct commit *final;
119
120 const char *path;
121
122 /* the contents in the final; pointed into by buf pointers of
123 * blame_entries
124 */
125 const char *final_buf;
126 unsigned long final_buf_size;
127
128 /* linked list of blames */
129 struct blame_entry *ent;
130
131 /* look-up a line in the final buffer */
132 int num_lines;
133 int *lineno;
134 };
135
136 static int cmp_suspect(struct origin *a, struct origin *b)
137 {
138 int cmp = hashcmp(a->commit->object.sha1, b->commit->object.sha1);
139 if (cmp)
140 return cmp;
141 return strcmp(a->path, b->path);
142 }
143
144 static void sanity_check_refcnt(struct scoreboard *);
145
146 static void coalesce(struct scoreboard *sb)
147 {
148 struct blame_entry *ent, *next;
149
150 for (ent = sb->ent; ent && (next = ent->next); ent = next) {
151 if (!cmp_suspect(ent->suspect, next->suspect) &&
152 ent->guilty == next->guilty &&
153 ent->s_lno + ent->num_lines == next->s_lno) {
154 ent->num_lines += next->num_lines;
155 ent->next = next->next;
156 if (ent->next)
157 ent->next->prev = ent;
158 origin_decref(next->suspect);
159 free(next);
160 ent->score = 0;
161 next = ent; /* again */
162 }
163 }
164
165 if (DEBUG) /* sanity */
166 sanity_check_refcnt(sb);
167 }
168
169 static struct origin *get_origin(struct scoreboard *sb,
170 struct commit *commit,
171 const char *path)
172 {
173 struct blame_entry *e;
174 struct origin *o;
175
176 for (e = sb->ent; e; e = e->next) {
177 if (e->suspect->commit == commit &&
178 !strcmp(e->suspect->path, path))
179 return origin_incref(e->suspect);
180 }
181 o = xcalloc(1, sizeof(*o) + strlen(path) + 1);
182 o->commit = commit;
183 o->refcnt = 1;
184 strcpy(o->path, path);
185 return o;
186 }
187
188 static int fill_blob_sha1(struct origin *origin)
189 {
190 unsigned mode;
191 char type[10];
192
193 if (!is_null_sha1(origin->blob_sha1))
194 return 0;
195 if (get_tree_entry(origin->commit->object.sha1,
196 origin->path,
197 origin->blob_sha1, &mode))
198 goto error_out;
199 if (sha1_object_info(origin->blob_sha1, type, NULL) ||
200 strcmp(type, blob_type))
201 goto error_out;
202 return 0;
203 error_out:
204 hashclr(origin->blob_sha1);
205 return -1;
206 }
207
208 static struct origin *find_origin(struct scoreboard *sb,
209 struct commit *parent,
210 struct origin *origin)
211 {
212 struct origin *porigin = NULL;
213 struct diff_options diff_opts;
214 int i;
215 const char *paths[2];
216
217 /* See if the origin->path is different between parent
218 * and origin first. Most of the time they are the
219 * same and diff-tree is fairly efficient about this.
220 */
221 diff_setup(&diff_opts);
222 diff_opts.recursive = 1;
223 diff_opts.detect_rename = 0;
224 diff_opts.output_format = DIFF_FORMAT_NO_OUTPUT;
225 paths[0] = origin->path;
226 paths[1] = NULL;
227
228 diff_tree_setup_paths(paths, &diff_opts);
229 if (diff_setup_done(&diff_opts) < 0)
230 die("diff-setup");
231 diff_tree_sha1(parent->tree->object.sha1,
232 origin->commit->tree->object.sha1,
233 "", &diff_opts);
234 diffcore_std(&diff_opts);
235
236 /* It is either one entry that says "modified", or "created",
237 * or nothing.
238 */
239 if (!diff_queued_diff.nr) {
240 /* The path is the same as parent */
241 porigin = get_origin(sb, parent, origin->path);
242 hashcpy(porigin->blob_sha1, origin->blob_sha1);
243 }
244 else if (diff_queued_diff.nr != 1)
245 die("internal error in pickaxe::find_origin");
246 else {
247 struct diff_filepair *p = diff_queued_diff.queue[0];
248 switch (p->status) {
249 default:
250 die("internal error in pickaxe::find_origin (%c)",
251 p->status);
252 case 'M':
253 porigin = get_origin(sb, parent, origin->path);
254 hashcpy(porigin->blob_sha1, p->one->sha1);
255 break;
256 case 'A':
257 case 'T':
258 /* Did not exist in parent, or type changed */
259 break;
260 }
261 }
262 diff_flush(&diff_opts);
263 if (porigin)
264 return porigin;
265
266 /* Otherwise we would look for a rename */
267
268 diff_setup(&diff_opts);
269 diff_opts.recursive = 1;
270 diff_opts.detect_rename = DIFF_DETECT_RENAME;
271 diff_opts.output_format = DIFF_FORMAT_NO_OUTPUT;
272 paths[0] = NULL;
273 diff_tree_setup_paths(paths, &diff_opts);
274 if (diff_setup_done(&diff_opts) < 0)
275 die("diff-setup");
276 diff_tree_sha1(parent->tree->object.sha1,
277 origin->commit->tree->object.sha1,
278 "", &diff_opts);
279 diffcore_std(&diff_opts);
280
281 for (i = 0; i < diff_queued_diff.nr; i++) {
282 struct diff_filepair *p = diff_queued_diff.queue[i];
283 if ((p->status == 'R' || p->status == 'C') &&
284 !strcmp(p->two->path, origin->path)) {
285 porigin = get_origin(sb, parent, p->one->path);
286 hashcpy(porigin->blob_sha1, p->one->sha1);
287 break;
288 }
289 }
290 diff_flush(&diff_opts);
291 return porigin;
292 }
293
294 struct chunk {
295 /* line number in postimage; up to but not including this
296 * line is the same as preimage
297 */
298 int same;
299
300 /* preimage line number after this chunk */
301 int p_next;
302
303 /* postimage line number after this chunk */
304 int t_next;
305 };
306
307 struct patch {
308 struct chunk *chunks;
309 int num;
310 };
311
312 struct blame_diff_state {
313 struct xdiff_emit_state xm;
314 struct patch *ret;
315 unsigned hunk_post_context;
316 unsigned hunk_in_pre_context : 1;
317 };
318
319 static void process_u_diff(void *state_, char *line, unsigned long len)
320 {
321 struct blame_diff_state *state = state_;
322 struct chunk *chunk;
323 int off1, off2, len1, len2, num;
324
325 num = state->ret->num;
326 if (len < 4 || line[0] != '@' || line[1] != '@') {
327 if (state->hunk_in_pre_context && line[0] == ' ')
328 state->ret->chunks[num - 1].same++;
329 else {
330 state->hunk_in_pre_context = 0;
331 if (line[0] == ' ')
332 state->hunk_post_context++;
333 else
334 state->hunk_post_context = 0;
335 }
336 return;
337 }
338
339 if (num && state->hunk_post_context) {
340 chunk = &state->ret->chunks[num - 1];
341 chunk->p_next -= state->hunk_post_context;
342 chunk->t_next -= state->hunk_post_context;
343 }
344 state->ret->num = ++num;
345 state->ret->chunks = xrealloc(state->ret->chunks,
346 sizeof(struct chunk) * num);
347 chunk = &state->ret->chunks[num - 1];
348 if (parse_hunk_header(line, len, &off1, &len1, &off2, &len2)) {
349 state->ret->num--;
350 return;
351 }
352
353 /* Line numbers in patch output are one based. */
354 off1--;
355 off2--;
356
357 chunk->same = len2 ? off2 : (off2 + 1);
358
359 chunk->p_next = off1 + (len1 ? len1 : 1);
360 chunk->t_next = chunk->same + len2;
361 state->hunk_in_pre_context = 1;
362 state->hunk_post_context = 0;
363 }
364
365 static struct patch *compare_buffer(mmfile_t *file_p, mmfile_t *file_o,
366 int context)
367 {
368 struct blame_diff_state state;
369 xpparam_t xpp;
370 xdemitconf_t xecfg;
371 xdemitcb_t ecb;
372
373 xpp.flags = XDF_NEED_MINIMAL;
374 xecfg.ctxlen = context;
375 xecfg.flags = 0;
376 ecb.outf = xdiff_outf;
377 ecb.priv = &state;
378 memset(&state, 0, sizeof(state));
379 state.xm.consume = process_u_diff;
380 state.ret = xmalloc(sizeof(struct patch));
381 state.ret->chunks = NULL;
382 state.ret->num = 0;
383
384 xdl_diff(file_p, file_o, &xpp, &xecfg, &ecb);
385
386 if (state.ret->num) {
387 struct chunk *chunk;
388 chunk = &state.ret->chunks[state.ret->num - 1];
389 chunk->p_next -= state.hunk_post_context;
390 chunk->t_next -= state.hunk_post_context;
391 }
392 return state.ret;
393 }
394
395 static struct patch *get_patch(struct origin *parent, struct origin *origin)
396 {
397 mmfile_t file_p, file_o;
398 char type[10];
399 char *blob_p, *blob_o;
400 struct patch *patch;
401
402 blob_p = read_sha1_file(parent->blob_sha1, type,
403 (unsigned long *) &file_p.size);
404 blob_o = read_sha1_file(origin->blob_sha1, type,
405 (unsigned long *) &file_o.size);
406 file_p.ptr = blob_p;
407 file_o.ptr = blob_o;
408 if (!file_p.ptr || !file_o.ptr) {
409 free(blob_p);
410 free(blob_o);
411 return NULL;
412 }
413
414 patch = compare_buffer(&file_p, &file_o, 0);
415 free(blob_p);
416 free(blob_o);
417 return patch;
418 }
419
420 static void free_patch(struct patch *p)
421 {
422 free(p->chunks);
423 free(p);
424 }
425
426 static void add_blame_entry(struct scoreboard *sb, struct blame_entry *e)
427 {
428 struct blame_entry *ent, *prev = NULL;
429
430 origin_incref(e->suspect);
431
432 for (ent = sb->ent; ent && ent->lno < e->lno; ent = ent->next)
433 prev = ent;
434
435 /* prev, if not NULL, is the last one that is below e */
436 e->prev = prev;
437 if (prev) {
438 e->next = prev->next;
439 prev->next = e;
440 }
441 else {
442 e->next = sb->ent;
443 sb->ent = e;
444 }
445 if (e->next)
446 e->next->prev = e;
447 }
448
449 static void dup_entry(struct blame_entry *dst, struct blame_entry *src)
450 {
451 struct blame_entry *p, *n;
452
453 p = dst->prev;
454 n = dst->next;
455 origin_incref(src->suspect);
456 origin_decref(dst->suspect);
457 memcpy(dst, src, sizeof(*src));
458 dst->prev = p;
459 dst->next = n;
460 dst->score = 0;
461 }
462
463 static const char *nth_line(struct scoreboard *sb, int lno)
464 {
465 return sb->final_buf + sb->lineno[lno];
466 }
467
468 static void split_overlap(struct blame_entry *split,
469 struct blame_entry *e,
470 int tlno, int plno, int same,
471 struct origin *parent)
472 {
473 /* it is known that lines between tlno to same came from
474 * parent, and e has an overlap with that range. it also is
475 * known that parent's line plno corresponds to e's line tlno.
476 *
477 * <---- e ----->
478 * <------>
479 * <------------>
480 * <------------>
481 * <------------------>
482 *
483 * Potentially we need to split e into three parts; before
484 * this chunk, the chunk to be blamed for parent, and after
485 * that portion.
486 */
487 int chunk_end_lno;
488 memset(split, 0, sizeof(struct blame_entry [3]));
489
490 if (e->s_lno < tlno) {
491 /* there is a pre-chunk part not blamed on parent */
492 split[0].suspect = origin_incref(e->suspect);
493 split[0].lno = e->lno;
494 split[0].s_lno = e->s_lno;
495 split[0].num_lines = tlno - e->s_lno;
496 split[1].lno = e->lno + tlno - e->s_lno;
497 split[1].s_lno = plno;
498 }
499 else {
500 split[1].lno = e->lno;
501 split[1].s_lno = plno + (e->s_lno - tlno);
502 }
503
504 if (same < e->s_lno + e->num_lines) {
505 /* there is a post-chunk part not blamed on parent */
506 split[2].suspect = origin_incref(e->suspect);
507 split[2].lno = e->lno + (same - e->s_lno);
508 split[2].s_lno = e->s_lno + (same - e->s_lno);
509 split[2].num_lines = e->s_lno + e->num_lines - same;
510 chunk_end_lno = split[2].lno;
511 }
512 else
513 chunk_end_lno = e->lno + e->num_lines;
514 split[1].num_lines = chunk_end_lno - split[1].lno;
515
516 if (split[1].num_lines < 1)
517 return;
518 split[1].suspect = origin_incref(parent);
519 }
520
521 static void split_blame(struct scoreboard *sb,
522 struct blame_entry *split,
523 struct blame_entry *e)
524 {
525 struct blame_entry *new_entry;
526
527 if (split[0].suspect && split[2].suspect) {
528 /* we need to split e into two and add another for parent */
529 dup_entry(e, &split[0]);
530
531 new_entry = xmalloc(sizeof(*new_entry));
532 memcpy(new_entry, &(split[2]), sizeof(struct blame_entry));
533 add_blame_entry(sb, new_entry);
534
535 new_entry = xmalloc(sizeof(*new_entry));
536 memcpy(new_entry, &(split[1]), sizeof(struct blame_entry));
537 add_blame_entry(sb, new_entry);
538 }
539 else if (!split[0].suspect && !split[2].suspect)
540 /* parent covers the entire area */
541 dup_entry(e, &split[1]);
542 else if (split[0].suspect) {
543 dup_entry(e, &split[0]);
544
545 new_entry = xmalloc(sizeof(*new_entry));
546 memcpy(new_entry, &(split[1]), sizeof(struct blame_entry));
547 add_blame_entry(sb, new_entry);
548 }
549 else {
550 dup_entry(e, &split[1]);
551
552 new_entry = xmalloc(sizeof(*new_entry));
553 memcpy(new_entry, &(split[2]), sizeof(struct blame_entry));
554 add_blame_entry(sb, new_entry);
555 }
556
557 if (DEBUG) { /* sanity */
558 struct blame_entry *ent;
559 int lno = sb->ent->lno, corrupt = 0;
560
561 for (ent = sb->ent; ent; ent = ent->next) {
562 if (lno != ent->lno)
563 corrupt = 1;
564 if (ent->s_lno < 0)
565 corrupt = 1;
566 lno += ent->num_lines;
567 }
568 if (corrupt) {
569 lno = sb->ent->lno;
570 for (ent = sb->ent; ent; ent = ent->next) {
571 printf("L %8d l %8d n %8d\n",
572 lno, ent->lno, ent->num_lines);
573 lno = ent->lno + ent->num_lines;
574 }
575 die("oops");
576 }
577 }
578 }
579
580 static void decref_split(struct blame_entry *split)
581 {
582 int i;
583
584 for (i = 0; i < 3; i++)
585 origin_decref(split[i].suspect);
586 }
587
588 static void blame_overlap(struct scoreboard *sb, struct blame_entry *e,
589 int tlno, int plno, int same,
590 struct origin *parent)
591 {
592 struct blame_entry split[3];
593
594 split_overlap(split, e, tlno, plno, same, parent);
595 if (split[1].suspect)
596 split_blame(sb, split, e);
597 decref_split(split);
598 }
599
600 static int find_last_in_target(struct scoreboard *sb, struct origin *target)
601 {
602 struct blame_entry *e;
603 int last_in_target = -1;
604
605 for (e = sb->ent; e; e = e->next) {
606 if (e->guilty || cmp_suspect(e->suspect, target))
607 continue;
608 if (last_in_target < e->s_lno + e->num_lines)
609 last_in_target = e->s_lno + e->num_lines;
610 }
611 return last_in_target;
612 }
613
614 static void blame_chunk(struct scoreboard *sb,
615 int tlno, int plno, int same,
616 struct origin *target, struct origin *parent)
617 {
618 struct blame_entry *e;
619
620 for (e = sb->ent; e; e = e->next) {
621 if (e->guilty || cmp_suspect(e->suspect, target))
622 continue;
623 if (same <= e->s_lno)
624 continue;
625 if (tlno < e->s_lno + e->num_lines)
626 blame_overlap(sb, e, tlno, plno, same, parent);
627 }
628 }
629
630 static int pass_blame_to_parent(struct scoreboard *sb,
631 struct origin *target,
632 struct origin *parent)
633 {
634 int i, last_in_target, plno, tlno;
635 struct patch *patch;
636
637 last_in_target = find_last_in_target(sb, target);
638 if (last_in_target < 0)
639 return 1; /* nothing remains for this target */
640
641 patch = get_patch(parent, target);
642 plno = tlno = 0;
643 for (i = 0; i < patch->num; i++) {
644 struct chunk *chunk = &patch->chunks[i];
645
646 blame_chunk(sb, tlno, plno, chunk->same, target, parent);
647 plno = chunk->p_next;
648 tlno = chunk->t_next;
649 }
650 /* rest (i.e. anything above tlno) are the same as parent */
651 blame_chunk(sb, tlno, plno, last_in_target, target, parent);
652
653 free_patch(patch);
654 return 0;
655 }
656
657 static unsigned ent_score(struct scoreboard *sb, struct blame_entry *e)
658 {
659 unsigned score;
660 const char *cp, *ep;
661
662 if (e->score)
663 return e->score;
664
665 score = 1;
666 cp = nth_line(sb, e->lno);
667 ep = nth_line(sb, e->lno + e->num_lines);
668 while (cp < ep) {
669 unsigned ch = *((unsigned char *)cp);
670 if (isalnum(ch))
671 score++;
672 cp++;
673 }
674 e->score = score;
675 return score;
676 }
677
678 static void copy_split_if_better(struct scoreboard *sb,
679 struct blame_entry *best_so_far,
680 struct blame_entry *this)
681 {
682 int i;
683
684 if (!this[1].suspect)
685 return;
686 if (best_so_far[1].suspect) {
687 if (ent_score(sb, &this[1]) < ent_score(sb, &best_so_far[1]))
688 return;
689 }
690
691 for (i = 0; i < 3; i++)
692 origin_incref(this[i].suspect);
693 decref_split(best_so_far);
694 memcpy(best_so_far, this, sizeof(struct blame_entry [3]));
695 }
696
697 static void find_copy_in_blob(struct scoreboard *sb,
698 struct blame_entry *ent,
699 struct origin *parent,
700 struct blame_entry *split,
701 mmfile_t *file_p)
702 {
703 const char *cp;
704 int cnt;
705 mmfile_t file_o;
706 struct patch *patch;
707 int i, plno, tlno;
708
709 cp = nth_line(sb, ent->lno);
710 file_o.ptr = (char*) cp;
711 cnt = ent->num_lines;
712
713 while (cnt && cp < sb->final_buf + sb->final_buf_size) {
714 if (*cp++ == '\n')
715 cnt--;
716 }
717 file_o.size = cp - file_o.ptr;
718
719 patch = compare_buffer(file_p, &file_o, 1);
720
721 memset(split, 0, sizeof(struct blame_entry [3]));
722 plno = tlno = 0;
723 for (i = 0; i < patch->num; i++) {
724 struct chunk *chunk = &patch->chunks[i];
725
726 /* tlno to chunk->same are the same as ent */
727 if (ent->num_lines <= tlno)
728 break;
729 if (tlno < chunk->same) {
730 struct blame_entry this[3];
731 split_overlap(this, ent,
732 tlno + ent->s_lno, plno,
733 chunk->same + ent->s_lno,
734 parent);
735 copy_split_if_better(sb, split, this);
736 decref_split(this);
737 }
738 plno = chunk->p_next;
739 tlno = chunk->t_next;
740 }
741 free_patch(patch);
742 }
743
744 static int find_move_in_parent(struct scoreboard *sb,
745 struct origin *target,
746 struct origin *parent)
747 {
748 int last_in_target;
749 struct blame_entry *e, split[3];
750 mmfile_t file_p;
751 char type[10];
752 char *blob_p;
753
754 last_in_target = find_last_in_target(sb, target);
755 if (last_in_target < 0)
756 return 1; /* nothing remains for this target */
757
758 blob_p = read_sha1_file(parent->blob_sha1, type,
759 (unsigned long *) &file_p.size);
760 file_p.ptr = blob_p;
761 if (!file_p.ptr) {
762 free(blob_p);
763 return 0;
764 }
765
766 for (e = sb->ent; e; e = e->next) {
767 if (e->guilty || cmp_suspect(e->suspect, target))
768 continue;
769 find_copy_in_blob(sb, e, parent, split, &file_p);
770 if (split[1].suspect &&
771 blame_move_score < ent_score(sb, &split[1]))
772 split_blame(sb, split, e);
773 decref_split(split);
774 }
775 free(blob_p);
776 return 0;
777 }
778
779 static int find_copy_in_parent(struct scoreboard *sb,
780 struct origin *target,
781 struct commit *parent,
782 struct origin *porigin,
783 int opt)
784 {
785 struct diff_options diff_opts;
786 const char *paths[1];
787 struct blame_entry *e;
788 int i, j;
789 struct blame_list {
790 struct blame_entry *ent;
791 struct blame_entry split[3];
792 } *blame_list;
793 int num_ents;
794
795 /* Count the number of entries the target is suspected for,
796 * and prepare a list of entry and the best split.
797 */
798 for (e = sb->ent, num_ents = 0; e; e = e->next)
799 if (!e->guilty && !cmp_suspect(e->suspect, target))
800 num_ents++;
801 if (!num_ents)
802 return 1; /* nothing remains for this target */
803
804 blame_list = xcalloc(num_ents, sizeof(struct blame_list));
805 for (e = sb->ent, i = 0; e; e = e->next)
806 if (!e->guilty && !cmp_suspect(e->suspect, target))
807 blame_list[i++].ent = e;
808
809 diff_setup(&diff_opts);
810 diff_opts.recursive = 1;
811 diff_opts.output_format = DIFF_FORMAT_NO_OUTPUT;
812
813 /* Try "find copies harder" on new path */
814 if ((opt & PICKAXE_BLAME_COPY_HARDER) &&
815 (!porigin || strcmp(target->path, porigin->path))) {
816 diff_opts.detect_rename = DIFF_DETECT_COPY;
817 diff_opts.find_copies_harder = 1;
818 }
819 paths[0] = NULL;
820 diff_tree_setup_paths(paths, &diff_opts);
821 if (diff_setup_done(&diff_opts) < 0)
822 die("diff-setup");
823 diff_tree_sha1(parent->tree->object.sha1,
824 target->commit->tree->object.sha1,
825 "", &diff_opts);
826 diffcore_std(&diff_opts);
827
828 for (i = 0; i < diff_queued_diff.nr; i++) {
829 struct diff_filepair *p = diff_queued_diff.queue[i];
830 struct origin *norigin;
831 mmfile_t file_p;
832 char type[10];
833 char *blob;
834 struct blame_entry this[3];
835
836 if (!DIFF_FILE_VALID(p->one))
837 continue; /* does not exist in parent */
838 if (porigin && !strcmp(p->one->path, porigin->path))
839 /* find_move already dealt with this path */
840 continue;
841
842 norigin = get_origin(sb, parent, p->one->path);
843 hashcpy(norigin->blob_sha1, p->one->sha1);
844 blob = read_sha1_file(norigin->blob_sha1, type,
845 (unsigned long *) &file_p.size);
846 file_p.ptr = blob;
847 if (!file_p.ptr)
848 continue;
849
850 for (j = 0; j < num_ents; j++) {
851 find_copy_in_blob(sb, blame_list[j].ent, norigin,
852 this, &file_p);
853 copy_split_if_better(sb, blame_list[j].split,
854 this);
855 decref_split(this);
856 }
857 free(blob);
858 origin_decref(norigin);
859 }
860 diff_flush(&diff_opts);
861
862 for (j = 0; j < num_ents; j++) {
863 struct blame_entry *split = blame_list[j].split;
864 if (split[1].suspect &&
865 blame_copy_score < ent_score(sb, &split[1]))
866 split_blame(sb, split, blame_list[j].ent);
867 decref_split(split);
868 }
869 free(blame_list);
870
871 return 0;
872 }
873
874 #define MAXPARENT 16
875
876 static void pass_blame(struct scoreboard *sb, struct origin *origin, int opt)
877 {
878 int i;
879 struct commit *commit = origin->commit;
880 struct commit_list *parent;
881 struct origin *parent_origin[MAXPARENT], *porigin;
882
883 memset(parent_origin, 0, sizeof(parent_origin));
884 for (i = 0, parent = commit->parents;
885 i < MAXPARENT && parent;
886 parent = parent->next, i++) {
887 struct commit *p = parent->item;
888
889 if (parse_commit(p))
890 continue;
891 porigin = find_origin(sb, parent->item, origin);
892 if (!porigin)
893 continue;
894 if (!hashcmp(porigin->blob_sha1, origin->blob_sha1)) {
895 struct blame_entry *e;
896 for (e = sb->ent; e; e = e->next)
897 if (e->suspect == origin) {
898 origin_incref(porigin);
899 origin_decref(e->suspect);
900 e->suspect = porigin;
901 }
902 origin_decref(porigin);
903 goto finish;
904 }
905 parent_origin[i] = porigin;
906 }
907
908 for (i = 0, parent = commit->parents;
909 i < MAXPARENT && parent;
910 parent = parent->next, i++) {
911 struct origin *porigin = parent_origin[i];
912 if (!porigin)
913 continue;
914 if (pass_blame_to_parent(sb, origin, porigin))
915 goto finish;
916 }
917
918 /*
919 * Optionally run "miff" to find moves in parents' files here.
920 */
921 if (opt & PICKAXE_BLAME_MOVE)
922 for (i = 0, parent = commit->parents;
923 i < MAXPARENT && parent;
924 parent = parent->next, i++) {
925 struct origin *porigin = parent_origin[i];
926 if (!porigin)
927 continue;
928 if (find_move_in_parent(sb, origin, porigin))
929 goto finish;
930 }
931
932 /*
933 * Optionally run "ciff" to find copies from parents' files here.
934 */
935 if (opt & PICKAXE_BLAME_COPY)
936 for (i = 0, parent = commit->parents;
937 i < MAXPARENT && parent;
938 parent = parent->next, i++) {
939 struct origin *porigin = parent_origin[i];
940 if (find_copy_in_parent(sb, origin, parent->item,
941 porigin, opt))
942 goto finish;
943 }
944
945 finish:
946 for (i = 0; i < MAXPARENT; i++)
947 origin_decref(parent_origin[i]);
948 }
949
950 static void assign_blame(struct scoreboard *sb, struct rev_info *revs, int opt)
951 {
952 while (1) {
953 struct blame_entry *ent;
954 struct commit *commit;
955 struct origin *suspect = NULL;
956
957 /* find one suspect to break down */
958 for (ent = sb->ent; !suspect && ent; ent = ent->next)
959 if (!ent->guilty)
960 suspect = ent->suspect;
961 if (!suspect)
962 return; /* all done */
963
964 origin_incref(suspect);
965 commit = suspect->commit;
966 parse_commit(commit);
967 if (!(commit->object.flags & UNINTERESTING) &&
968 !(revs->max_age != -1 && commit->date < revs->max_age))
969 pass_blame(sb, suspect, opt);
970
971 /* Take responsibility for the remaining entries */
972 for (ent = sb->ent; ent; ent = ent->next)
973 if (!cmp_suspect(ent->suspect, suspect))
974 ent->guilty = 1;
975 origin_decref(suspect);
976 coalesce(sb);
977 }
978 }
979
980 static const char *format_time(unsigned long time, const char *tz_str,
981 int show_raw_time)
982 {
983 static char time_buf[128];
984 time_t t = time;
985 int minutes, tz;
986 struct tm *tm;
987
988 if (show_raw_time) {
989 sprintf(time_buf, "%lu %s", time, tz_str);
990 return time_buf;
991 }
992
993 tz = atoi(tz_str);
994 minutes = tz < 0 ? -tz : tz;
995 minutes = (minutes / 100)*60 + (minutes % 100);
996 minutes = tz < 0 ? -minutes : minutes;
997 t = time + minutes * 60;
998 tm = gmtime(&t);
999
1000 strftime(time_buf, sizeof(time_buf), "%Y-%m-%d %H:%M:%S ", tm);
1001 strcat(time_buf, tz_str);
1002 return time_buf;
1003 }
1004
1005 struct commit_info
1006 {
1007 char *author;
1008 char *author_mail;
1009 unsigned long author_time;
1010 char *author_tz;
1011
1012 /* filled only when asked for details */
1013 char *committer;
1014 char *committer_mail;
1015 unsigned long committer_time;
1016 char *committer_tz;
1017
1018 char *summary;
1019 };
1020
1021 static void get_ac_line(const char *inbuf, const char *what,
1022 int bufsz, char *person, char **mail,
1023 unsigned long *time, char **tz)
1024 {
1025 int len;
1026 char *tmp, *endp;
1027
1028 tmp = strstr(inbuf, what);
1029 if (!tmp)
1030 goto error_out;
1031 tmp += strlen(what);
1032 endp = strchr(tmp, '\n');
1033 if (!endp)
1034 len = strlen(tmp);
1035 else
1036 len = endp - tmp;
1037 if (bufsz <= len) {
1038 error_out:
1039 /* Ugh */
1040 person = *mail = *tz = "(unknown)";
1041 *time = 0;
1042 return;
1043 }
1044 memcpy(person, tmp, len);
1045
1046 tmp = person;
1047 tmp += len;
1048 *tmp = 0;
1049 while (*tmp != ' ')
1050 tmp--;
1051 *tz = tmp+1;
1052
1053 *tmp = 0;
1054 while (*tmp != ' ')
1055 tmp--;
1056 *time = strtoul(tmp, NULL, 10);
1057
1058 *tmp = 0;
1059 while (*tmp != ' ')
1060 tmp--;
1061 *mail = tmp + 1;
1062 *tmp = 0;
1063 }
1064
1065 static void get_commit_info(struct commit *commit,
1066 struct commit_info *ret,
1067 int detailed)
1068 {
1069 int len;
1070 char *tmp, *endp;
1071 static char author_buf[1024];
1072 static char committer_buf[1024];
1073 static char summary_buf[1024];
1074
1075 /* We've operated without save_commit_buffer, so
1076 * we now need to populate them for output.
1077 */
1078 if (!commit->buffer) {
1079 char type[20];
1080 unsigned long size;
1081 commit->buffer =
1082 read_sha1_file(commit->object.sha1, type, &size);
1083 }
1084 ret->author = author_buf;
1085 get_ac_line(commit->buffer, "\nauthor ",
1086 sizeof(author_buf), author_buf, &ret->author_mail,
1087 &ret->author_time, &ret->author_tz);
1088
1089 if (!detailed)
1090 return;
1091
1092 ret->committer = committer_buf;
1093 get_ac_line(commit->buffer, "\ncommitter ",
1094 sizeof(committer_buf), committer_buf, &ret->committer_mail,
1095 &ret->committer_time, &ret->committer_tz);
1096
1097 ret->summary = summary_buf;
1098 tmp = strstr(commit->buffer, "\n\n");
1099 if (!tmp) {
1100 error_out:
1101 sprintf(summary_buf, "(%s)", sha1_to_hex(commit->object.sha1));
1102 return;
1103 }
1104 tmp += 2;
1105 endp = strchr(tmp, '\n');
1106 if (!endp)
1107 goto error_out;
1108 len = endp - tmp;
1109 if (len >= sizeof(summary_buf))
1110 goto error_out;
1111 memcpy(summary_buf, tmp, len);
1112 summary_buf[len] = 0;
1113 }
1114
1115 #define OUTPUT_ANNOTATE_COMPAT 001
1116 #define OUTPUT_LONG_OBJECT_NAME 002
1117 #define OUTPUT_RAW_TIMESTAMP 004
1118 #define OUTPUT_PORCELAIN 010
1119 #define OUTPUT_SHOW_NAME 020
1120 #define OUTPUT_SHOW_NUMBER 040
1121 #define OUTPUT_SHOW_SCORE 0100
1122
1123 static void emit_porcelain(struct scoreboard *sb, struct blame_entry *ent)
1124 {
1125 int cnt;
1126 const char *cp;
1127 struct origin *suspect = ent->suspect;
1128 char hex[41];
1129
1130 strcpy(hex, sha1_to_hex(suspect->commit->object.sha1));
1131 printf("%s%c%d %d %d\n",
1132 hex,
1133 ent->guilty ? ' ' : '*', // purely for debugging
1134 ent->s_lno + 1,
1135 ent->lno + 1,
1136 ent->num_lines);
1137 if (!(suspect->commit->object.flags & METAINFO_SHOWN)) {
1138 struct commit_info ci;
1139 suspect->commit->object.flags |= METAINFO_SHOWN;
1140 get_commit_info(suspect->commit, &ci, 1);
1141 printf("author %s\n", ci.author);
1142 printf("author-mail %s\n", ci.author_mail);
1143 printf("author-time %lu\n", ci.author_time);
1144 printf("author-tz %s\n", ci.author_tz);
1145 printf("committer %s\n", ci.committer);
1146 printf("committer-mail %s\n", ci.committer_mail);
1147 printf("committer-time %lu\n", ci.committer_time);
1148 printf("committer-tz %s\n", ci.committer_tz);
1149 printf("filename %s\n", suspect->path);
1150 printf("summary %s\n", ci.summary);
1151 }
1152 else if (suspect->commit->object.flags & MORE_THAN_ONE_PATH)
1153 printf("filename %s\n", suspect->path);
1154
1155 cp = nth_line(sb, ent->lno);
1156 for (cnt = 0; cnt < ent->num_lines; cnt++) {
1157 char ch;
1158 if (cnt)
1159 printf("%s %d %d\n", hex,
1160 ent->s_lno + 1 + cnt,
1161 ent->lno + 1 + cnt);
1162 putchar('\t');
1163 do {
1164 ch = *cp++;
1165 putchar(ch);
1166 } while (ch != '\n' &&
1167 cp < sb->final_buf + sb->final_buf_size);
1168 }
1169 }
1170
1171 static void emit_other(struct scoreboard *sb, struct blame_entry *ent, int opt)
1172 {
1173 int cnt;
1174 const char *cp;
1175 struct origin *suspect = ent->suspect;
1176 struct commit_info ci;
1177 char hex[41];
1178 int show_raw_time = !!(opt & OUTPUT_RAW_TIMESTAMP);
1179
1180 get_commit_info(suspect->commit, &ci, 1);
1181 strcpy(hex, sha1_to_hex(suspect->commit->object.sha1));
1182
1183 cp = nth_line(sb, ent->lno);
1184 for (cnt = 0; cnt < ent->num_lines; cnt++) {
1185 char ch;
1186
1187 printf("%.*s", (opt & OUTPUT_LONG_OBJECT_NAME) ? 40 : 8, hex);
1188 if (opt & OUTPUT_ANNOTATE_COMPAT)
1189 printf("\t(%10s\t%10s\t%d)", ci.author,
1190 format_time(ci.author_time, ci.author_tz,
1191 show_raw_time),
1192 ent->lno + 1 + cnt);
1193 else {
1194 if (opt & OUTPUT_SHOW_SCORE)
1195 printf(" %*d %02d",
1196 max_score_digits, ent->score,
1197 ent->suspect->refcnt);
1198 if (opt & OUTPUT_SHOW_NAME)
1199 printf(" %-*.*s", longest_file, longest_file,
1200 suspect->path);
1201 if (opt & OUTPUT_SHOW_NUMBER)
1202 printf(" %*d", max_orig_digits,
1203 ent->s_lno + 1 + cnt);
1204 printf(" (%-*.*s %10s %*d) ",
1205 longest_author, longest_author, ci.author,
1206 format_time(ci.author_time, ci.author_tz,
1207 show_raw_time),
1208 max_digits, ent->lno + 1 + cnt);
1209 }
1210 do {
1211 ch = *cp++;
1212 putchar(ch);
1213 } while (ch != '\n' &&
1214 cp < sb->final_buf + sb->final_buf_size);
1215 }
1216 }
1217
1218 static void output(struct scoreboard *sb, int option)
1219 {
1220 struct blame_entry *ent;
1221
1222 if (option & OUTPUT_PORCELAIN) {
1223 for (ent = sb->ent; ent; ent = ent->next) {
1224 struct blame_entry *oth;
1225 struct origin *suspect = ent->suspect;
1226 struct commit *commit = suspect->commit;
1227 if (commit->object.flags & MORE_THAN_ONE_PATH)
1228 continue;
1229 for (oth = ent->next; oth; oth = oth->next) {
1230 if ((oth->suspect->commit != commit) ||
1231 !strcmp(oth->suspect->path, suspect->path))
1232 continue;
1233 commit->object.flags |= MORE_THAN_ONE_PATH;
1234 break;
1235 }
1236 }
1237 }
1238
1239 for (ent = sb->ent; ent; ent = ent->next) {
1240 if (option & OUTPUT_PORCELAIN)
1241 emit_porcelain(sb, ent);
1242 else {
1243 emit_other(sb, ent, option);
1244 }
1245 }
1246 }
1247
1248 static int prepare_lines(struct scoreboard *sb)
1249 {
1250 const char *buf = sb->final_buf;
1251 unsigned long len = sb->final_buf_size;
1252 int num = 0, incomplete = 0, bol = 1;
1253
1254 if (len && buf[len-1] != '\n')
1255 incomplete++; /* incomplete line at the end */
1256 while (len--) {
1257 if (bol) {
1258 sb->lineno = xrealloc(sb->lineno,
1259 sizeof(int* ) * (num + 1));
1260 sb->lineno[num] = buf - sb->final_buf;
1261 bol = 0;
1262 }
1263 if (*buf++ == '\n') {
1264 num++;
1265 bol = 1;
1266 }
1267 }
1268 sb->lineno = xrealloc(sb->lineno,
1269 sizeof(int* ) * (num + incomplete + 1));
1270 sb->lineno[num + incomplete] = buf - sb->final_buf;
1271 sb->num_lines = num + incomplete;
1272 return sb->num_lines;
1273 }
1274
1275 static int read_ancestry(const char *graft_file)
1276 {
1277 FILE *fp = fopen(graft_file, "r");
1278 char buf[1024];
1279 if (!fp)
1280 return -1;
1281 while (fgets(buf, sizeof(buf), fp)) {
1282 /* The format is just "Commit Parent1 Parent2 ...\n" */
1283 int len = strlen(buf);
1284 struct commit_graft *graft = read_graft_line(buf, len);
1285 register_commit_graft(graft, 0);
1286 }
1287 fclose(fp);
1288 return 0;
1289 }
1290
1291 static int lineno_width(int lines)
1292 {
1293 int i, width;
1294
1295 for (width = 1, i = 10; i <= lines + 1; width++)
1296 i *= 10;
1297 return width;
1298 }
1299
1300 static void find_alignment(struct scoreboard *sb, int *option)
1301 {
1302 int longest_src_lines = 0;
1303 int longest_dst_lines = 0;
1304 unsigned largest_score = 0;
1305 struct blame_entry *e;
1306
1307 for (e = sb->ent; e; e = e->next) {
1308 struct origin *suspect = e->suspect;
1309 struct commit_info ci;
1310 int num;
1311
1312 if (!(suspect->commit->object.flags & METAINFO_SHOWN)) {
1313 suspect->commit->object.flags |= METAINFO_SHOWN;
1314 get_commit_info(suspect->commit, &ci, 1);
1315 if (strcmp(suspect->path, sb->path))
1316 *option |= OUTPUT_SHOW_NAME;
1317 num = strlen(suspect->path);
1318 if (longest_file < num)
1319 longest_file = num;
1320 num = strlen(ci.author);
1321 if (longest_author < num)
1322 longest_author = num;
1323 }
1324 num = e->s_lno + e->num_lines;
1325 if (longest_src_lines < num)
1326 longest_src_lines = num;
1327 num = e->lno + e->num_lines;
1328 if (longest_dst_lines < num)
1329 longest_dst_lines = num;
1330 if (largest_score < ent_score(sb, e))
1331 largest_score = ent_score(sb, e);
1332 }
1333 max_orig_digits = lineno_width(longest_src_lines);
1334 max_digits = lineno_width(longest_dst_lines);
1335 max_score_digits = lineno_width(largest_score);
1336 }
1337
1338 static void sanity_check_refcnt(struct scoreboard *sb)
1339 {
1340 int baa = 0;
1341 struct blame_entry *ent;
1342
1343 for (ent = sb->ent; ent; ent = ent->next) {
1344 /* first mark the ones that haven't been checked */
1345 if (0 < ent->suspect->refcnt)
1346 ent->suspect->refcnt = -ent->suspect->refcnt;
1347 else if (!ent->suspect->refcnt)
1348 baa = 1;
1349 }
1350 for (ent = sb->ent; ent; ent = ent->next) {
1351 /* then pick each and see if they have the the
1352 * correct refcnt
1353 */
1354 int found;
1355 struct blame_entry *e;
1356 struct origin *suspect = ent->suspect;
1357
1358 if (0 < suspect->refcnt)
1359 continue;
1360 suspect->refcnt = -suspect->refcnt;
1361 for (found = 0, e = sb->ent; e; e = e->next) {
1362 if (e->suspect != suspect)
1363 continue;
1364 found++;
1365 }
1366 if (suspect->refcnt != found)
1367 baa = 1;
1368 }
1369 if (baa) {
1370 int opt = 0160;
1371 find_alignment(sb, &opt);
1372 output(sb, opt);
1373 die("Baa!");
1374 }
1375 }
1376
1377 static int has_path_in_work_tree(const char *path)
1378 {
1379 struct stat st;
1380 return !lstat(path, &st);
1381 }
1382
1383 static unsigned parse_score(const char *arg)
1384 {
1385 char *end;
1386 unsigned long score = strtoul(arg, &end, 10);
1387 if (*end)
1388 return 0;
1389 return score;
1390 }
1391
1392 int cmd_pickaxe(int argc, const char **argv, const char *prefix)
1393 {
1394 struct rev_info revs;
1395 const char *path;
1396 struct scoreboard sb;
1397 struct origin *o;
1398 struct blame_entry *ent;
1399 int i, seen_dashdash, unk, opt;
1400 long bottom, top, lno;
1401 int output_option = 0;
1402 const char *revs_file = NULL;
1403 const char *final_commit_name = NULL;
1404 char type[10];
1405
1406 save_commit_buffer = 0;
1407
1408 opt = 0;
1409 bottom = top = 0;
1410 seen_dashdash = 0;
1411 for (unk = i = 1; i < argc; i++) {
1412 const char *arg = argv[i];
1413 if (*arg != '-')
1414 break;
1415 else if (!strcmp("-c", arg))
1416 output_option |= OUTPUT_ANNOTATE_COMPAT;
1417 else if (!strcmp("-t", arg))
1418 output_option |= OUTPUT_RAW_TIMESTAMP;
1419 else if (!strcmp("-l", arg))
1420 output_option |= OUTPUT_LONG_OBJECT_NAME;
1421 else if (!strcmp("-S", arg) && ++i < argc)
1422 revs_file = argv[i];
1423 else if (!strncmp("-M", arg, 2)) {
1424 opt |= PICKAXE_BLAME_MOVE;
1425 blame_move_score = parse_score(arg+2);
1426 }
1427 else if (!strncmp("-C", arg, 2)) {
1428 if (opt & PICKAXE_BLAME_COPY)
1429 opt |= PICKAXE_BLAME_COPY_HARDER;
1430 opt |= PICKAXE_BLAME_COPY | PICKAXE_BLAME_MOVE;
1431 blame_copy_score = parse_score(arg+2);
1432 }
1433 else if (!strncmp("-L", arg, 2)) {
1434 char *term;
1435 if (!arg[2]) {
1436 if (++i >= argc)
1437 usage(pickaxe_usage);
1438 arg = argv[i];
1439 }
1440 else
1441 arg += 2;
1442 if (bottom || top)
1443 die("More than one '-L n,m' option given");
1444 bottom = strtol(arg, &term, 10);
1445 if (*term == ',') {
1446 top = strtol(term + 1, &term, 10);
1447 if (*term)
1448 usage(pickaxe_usage);
1449 }
1450 if (bottom && top && top < bottom) {
1451 unsigned long tmp;
1452 tmp = top; top = bottom; bottom = tmp;
1453 }
1454 }
1455 else if (!strcmp("--score-debug", arg))
1456 output_option |= OUTPUT_SHOW_SCORE;
1457 else if (!strcmp("-f", arg) ||
1458 !strcmp("--show-name", arg))
1459 output_option |= OUTPUT_SHOW_NAME;
1460 else if (!strcmp("-n", arg) ||
1461 !strcmp("--show-number", arg))
1462 output_option |= OUTPUT_SHOW_NUMBER;
1463 else if (!strcmp("-p", arg) ||
1464 !strcmp("--porcelain", arg))
1465 output_option |= OUTPUT_PORCELAIN;
1466 else if (!strcmp("--", arg)) {
1467 seen_dashdash = 1;
1468 i++;
1469 break;
1470 }
1471 else
1472 argv[unk++] = arg;
1473 }
1474
1475 if (!blame_move_score)
1476 blame_move_score = BLAME_DEFAULT_MOVE_SCORE;
1477 if (!blame_copy_score)
1478 blame_copy_score = BLAME_DEFAULT_COPY_SCORE;
1479
1480 /* We have collected options unknown to us in argv[1..unk]
1481 * which are to be passed to revision machinery if we are
1482 * going to do the "bottom" procesing.
1483 *
1484 * The remaining are:
1485 *
1486 * (1) if seen_dashdash, its either
1487 * "-options -- <path>" or
1488 * "-options -- <path> <rev>".
1489 * but the latter is allowed only if there is no
1490 * options that we passed to revision machinery.
1491 *
1492 * (2) otherwise, we may have "--" somewhere later and
1493 * might be looking at the first one of multiple 'rev'
1494 * parameters (e.g. " master ^next ^maint -- path").
1495 * See if there is a dashdash first, and give the
1496 * arguments before that to revision machinery.
1497 * After that there must be one 'path'.
1498 *
1499 * (3) otherwise, its one of the three:
1500 * "-options <path> <rev>"
1501 * "-options <rev> <path>"
1502 * "-options <path>"
1503 * but again the first one is allowed only if
1504 * there is no options that we passed to revision
1505 * machinery.
1506 */
1507
1508 if (seen_dashdash) {
1509 /* (1) */
1510 if (argc <= i)
1511 usage(pickaxe_usage);
1512 path = argv[i];
1513 if (i + 1 == argc - 1) {
1514 if (unk != 1)
1515 usage(pickaxe_usage);
1516 argv[unk++] = argv[i + 1];
1517 }
1518 else if (i + 1 != argc)
1519 /* garbage at end */
1520 usage(pickaxe_usage);
1521 }
1522 else {
1523 int j;
1524 for (j = i; !seen_dashdash && j < argc; j++)
1525 if (!strcmp(argv[j], "--"))
1526 seen_dashdash = j;
1527 if (seen_dashdash) {
1528 if (seen_dashdash + 1 != argc - 1)
1529 usage(pickaxe_usage);
1530 path = argv[seen_dashdash + 1];
1531 for (j = i; j < seen_dashdash; j++)
1532 argv[unk++] = argv[j];
1533 }
1534 else {
1535 /* (3) */
1536 path = argv[i];
1537 if (i + 1 == argc - 1) {
1538 final_commit_name = argv[i + 1];
1539
1540 /* if (unk == 1) we could be getting
1541 * old-style
1542 */
1543 if (unk == 1 && !has_path_in_work_tree(path)) {
1544 path = argv[i + 1];
1545 final_commit_name = argv[i];
1546 }
1547 }
1548 else if (i != argc - 1)
1549 usage(pickaxe_usage); /* garbage at end */
1550
1551 if (!has_path_in_work_tree(path))
1552 die("cannot stat path %s: %s",
1553 path, strerror(errno));
1554 }
1555 }
1556
1557 if (final_commit_name)
1558 argv[unk++] = final_commit_name;
1559
1560 /* Now we got rev and path. We do not want the path pruning
1561 * but we may want "bottom" processing.
1562 */
1563 argv[unk] = NULL;
1564
1565 init_revisions(&revs, NULL);
1566 setup_revisions(unk, argv, &revs, "HEAD");
1567 memset(&sb, 0, sizeof(sb));
1568
1569 /* There must be one and only one positive commit in the
1570 * revs->pending array.
1571 */
1572 for (i = 0; i < revs.pending.nr; i++) {
1573 struct object *obj = revs.pending.objects[i].item;
1574 if (obj->flags & UNINTERESTING)
1575 continue;
1576 while (obj->type == OBJ_TAG)
1577 obj = deref_tag(obj, NULL, 0);
1578 if (obj->type != OBJ_COMMIT)
1579 die("Non commit %s?",
1580 revs.pending.objects[i].name);
1581 if (sb.final)
1582 die("More than one commit to dig from %s and %s?",
1583 revs.pending.objects[i].name,
1584 final_commit_name);
1585 sb.final = (struct commit *) obj;
1586 final_commit_name = revs.pending.objects[i].name;
1587 }
1588
1589 if (!sb.final) {
1590 /* "--not A B -- path" without anything positive */
1591 unsigned char head_sha1[20];
1592
1593 final_commit_name = "HEAD";
1594 if (get_sha1(final_commit_name, head_sha1))
1595 die("No such ref: HEAD");
1596 sb.final = lookup_commit_reference(head_sha1);
1597 add_pending_object(&revs, &(sb.final->object), "HEAD");
1598 }
1599
1600 /* If we have bottom, this will mark the ancestors of the
1601 * bottom commits we would reach while traversing as
1602 * uninteresting.
1603 */
1604 prepare_revision_walk(&revs);
1605
1606 o = get_origin(&sb, sb.final, path);
1607 if (fill_blob_sha1(o))
1608 die("no such path %s in %s", path, final_commit_name);
1609
1610 sb.final_buf = read_sha1_file(o->blob_sha1, type, &sb.final_buf_size);
1611 lno = prepare_lines(&sb);
1612
1613 if (bottom < 1)
1614 bottom = 1;
1615 if (top < 1)
1616 top = lno;
1617 bottom--;
1618 if (lno < top)
1619 die("file %s has only %lu lines", path, lno);
1620
1621 ent = xcalloc(1, sizeof(*ent));
1622 ent->lno = bottom;
1623 ent->num_lines = top - bottom;
1624 ent->suspect = o;
1625 ent->s_lno = bottom;
1626
1627 sb.ent = ent;
1628 sb.path = path;
1629
1630 if (revs_file && read_ancestry(revs_file))
1631 die("reading graft file %s failed: %s",
1632 revs_file, strerror(errno));
1633
1634 assign_blame(&sb, &revs, opt);
1635
1636 coalesce(&sb);
1637
1638 if (!(output_option & OUTPUT_PORCELAIN))
1639 find_alignment(&sb, &output_option);
1640
1641 output(&sb, output_option);
1642 free((void *)sb.final_buf);
1643 for (ent = sb.ent; ent; ) {
1644 struct blame_entry *e = ent->next;
1645 free(ent);
1646 ent = e;
1647 }
1648 return 0;
1649 }
Eric Wong's git-svn branch