?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Allow '-' in config variable names
[git/kirr.git] / blame.c
blob3ec1c8f1b287654cccb0f2427810d0afead5c44b
1 /*
2 * Copyright (C) 2006, Fredrik Kuivinen <freku045@student.liu.se>
3 */
4
5 #include <assert.h>
6 #include <time.h>
7 #include <sys/time.h>
8 #include <math.h>
9
10 #include "cache.h"
11 #include "refs.h"
12 #include "tag.h"
13 #include "commit.h"
14 #include "tree.h"
15 #include "blob.h"
16 #include "diff.h"
17 #include "diffcore.h"
18 #include "revision.h"
19 #include "xdiff-interface.h"
20 #include "quote.h"
21
22 #ifndef DEBUG
23 #define DEBUG 0
24 #endif
25
26 static const char blame_usage[] =
27 "git-blame [-c] [-l] [-t] [-f] [-n] [-p] [-S <revs-file>] [--] file [commit]\n"
28 " -c, --compatibility Use the same output mode as git-annotate (Default: off)\n"
29 " -l, --long Show long commit SHA1 (Default: off)\n"
30 " -t, --time Show raw timestamp (Default: off)\n"
31 " -f, --show-name Show original filename (Default: auto)\n"
32 " -n, --show-number Show original linenumber (Default: off)\n"
33 " -p, --porcelain Show in a format designed for machine consumption\n"
34 " -S revs-file Use revisions from revs-file instead of calling git-rev-list\n"
35 " -h, --help This message";
36
37 static struct commit **blame_lines;
38 static int num_blame_lines;
39 static char *blame_contents;
40 static int blame_len;
41
42 struct util_info {
43 int *line_map;
44 unsigned char sha1[20]; /* blob sha, not commit! */
45 char *buf;
46 unsigned long size;
47 int num_lines;
48 const char *pathname;
49 unsigned meta_given:1;
50
51 void *topo_data;
52 };
53
54 struct chunk {
55 int off1, len1; /* --- */
56 int off2, len2; /* +++ */
57 };
58
59 struct patch {
60 struct chunk *chunks;
61 int num;
62 };
63
64 static void get_blob(struct commit *commit);
65
66 /* Only used for statistics */
67 static int num_get_patch;
68 static int num_commits;
69 static int patch_time;
70
71 struct blame_diff_state {
72 struct xdiff_emit_state xm;
73 struct patch *ret;
74 };
75
76 static void process_u0_diff(void *state_, char *line, unsigned long len)
77 {
78 struct blame_diff_state *state = state_;
79 struct chunk *chunk;
80
81 if (len < 4 || line[0] != '@' || line[1] != '@')
82 return;
83
84 if (DEBUG)
85 printf("chunk line: %.*s", (int)len, line);
86 state->ret->num++;
87 state->ret->chunks = xrealloc(state->ret->chunks,
88 sizeof(struct chunk) * state->ret->num);
89 chunk = &state->ret->chunks[state->ret->num - 1];
90
91 assert(!strncmp(line, "@@ -", 4));
92
93 if (parse_hunk_header(line, len,
94 &chunk->off1, &chunk->len1,
95 &chunk->off2, &chunk->len2)) {
96 state->ret->num--;
97 return;
98 }
99
100 if (chunk->len1 == 0)
101 chunk->off1++;
102 if (chunk->len2 == 0)
103 chunk->off2++;
104
105 if (chunk->off1 > 0)
106 chunk->off1--;
107 if (chunk->off2 > 0)
108 chunk->off2--;
109
110 assert(chunk->off1 >= 0);
111 assert(chunk->off2 >= 0);
112 }
113
114 static struct patch *get_patch(struct commit *commit, struct commit *other)
115 {
116 struct blame_diff_state state;
117 xpparam_t xpp;
118 xdemitconf_t xecfg;
119 mmfile_t file_c, file_o;
120 xdemitcb_t ecb;
121 struct util_info *info_c = (struct util_info *)commit->util;
122 struct util_info *info_o = (struct util_info *)other->util;
123 struct timeval tv_start, tv_end;
124
125 get_blob(commit);
126 file_c.ptr = info_c->buf;
127 file_c.size = info_c->size;
128
129 get_blob(other);
130 file_o.ptr = info_o->buf;
131 file_o.size = info_o->size;
132
133 gettimeofday(&tv_start, NULL);
134
135 xpp.flags = XDF_NEED_MINIMAL;
136 xecfg.ctxlen = 0;
137 xecfg.flags = 0;
138 ecb.outf = xdiff_outf;
139 ecb.priv = &state;
140 memset(&state, 0, sizeof(state));
141 state.xm.consume = process_u0_diff;
142 state.ret = xmalloc(sizeof(struct patch));
143 state.ret->chunks = NULL;
144 state.ret->num = 0;
145
146 xdl_diff(&file_c, &file_o, &xpp, &xecfg, &ecb);
147
148 gettimeofday(&tv_end, NULL);
149 patch_time += 1000000 * (tv_end.tv_sec - tv_start.tv_sec) +
150 tv_end.tv_usec - tv_start.tv_usec;
151
152 num_get_patch++;
153 return state.ret;
154 }
155
156 static void free_patch(struct patch *p)
157 {
158 free(p->chunks);
159 free(p);
160 }
161
162 static int get_blob_sha1_internal(const unsigned char *sha1, const char *base,
163 int baselen, const char *pathname,
164 unsigned mode, int stage);
165
166 static unsigned char blob_sha1[20];
167 static const char *blame_file;
168 static int get_blob_sha1(struct tree *t, const char *pathname,
169 unsigned char *sha1)
170 {
171 const char *pathspec[2];
172 blame_file = pathname;
173 pathspec[0] = pathname;
174 pathspec[1] = NULL;
175 hashclr(blob_sha1);
176 read_tree_recursive(t, "", 0, 0, pathspec, get_blob_sha1_internal);
177
178 if (is_null_sha1(blob_sha1))
179 return -1;
180
181 hashcpy(sha1, blob_sha1);
182 return 0;
183 }
184
185 static int get_blob_sha1_internal(const unsigned char *sha1, const char *base,
186 int baselen, const char *pathname,
187 unsigned mode, int stage)
188 {
189 if (S_ISDIR(mode))
190 return READ_TREE_RECURSIVE;
191
192 if (strncmp(blame_file, base, baselen) ||
193 strcmp(blame_file + baselen, pathname))
194 return -1;
195
196 hashcpy(blob_sha1, sha1);
197 return -1;
198 }
199
200 static void get_blob(struct commit *commit)
201 {
202 struct util_info *info = commit->util;
203 char type[20];
204
205 if (info->buf)
206 return;
207
208 info->buf = read_sha1_file(info->sha1, type, &info->size);
209
210 assert(!strcmp(type, blob_type));
211 }
212
213 /* For debugging only */
214 static void print_patch(struct patch *p)
215 {
216 int i;
217 printf("Num chunks: %d\n", p->num);
218 for (i = 0; i < p->num; i++) {
219 printf("%d,%d %d,%d\n", p->chunks[i].off1, p->chunks[i].len1,
220 p->chunks[i].off2, p->chunks[i].len2);
221 }
222 }
223
224 #if DEBUG
225 /* For debugging only */
226 static void print_map(struct commit *cmit, struct commit *other)
227 {
228 struct util_info *util = cmit->util;
229 struct util_info *util2 = other->util;
230
231 int i;
232 int max =
233 util->num_lines >
234 util2->num_lines ? util->num_lines : util2->num_lines;
235 int num;
236
237 if (print_map == NULL)
238 ; /* to avoid "unused function" warning */
239
240 for (i = 0; i < max; i++) {
241 printf("i: %d ", i);
242 num = -1;
243
244 if (i < util->num_lines) {
245 num = util->line_map[i];
246 printf("%d\t", num);
247 }
248 else
249 printf("\t");
250
251 if (i < util2->num_lines) {
252 int num2 = util2->line_map[i];
253 printf("%d\t", num2);
254 if (num != -1 && num2 != num)
255 printf("---");
256 }
257 else
258 printf("\t");
259
260 printf("\n");
261 }
262 }
263 #endif
264
265 /* p is a patch from commit to other. */
266 static void fill_line_map(struct commit *commit, struct commit *other,
267 struct patch *p)
268 {
269 struct util_info *util = commit->util;
270 struct util_info *util2 = other->util;
271 int *map = util->line_map;
272 int *map2 = util2->line_map;
273 int cur_chunk = 0;
274 int i1, i2;
275
276 if (DEBUG) {
277 if (p->num)
278 print_patch(p);
279 printf("num lines 1: %d num lines 2: %d\n", util->num_lines,
280 util2->num_lines);
281 }
282
283 for (i1 = 0, i2 = 0; i1 < util->num_lines; i1++, i2++) {
284 struct chunk *chunk = NULL;
285 if (cur_chunk < p->num)
286 chunk = &p->chunks[cur_chunk];
287
288 if (chunk && chunk->off1 == i1) {
289 if (DEBUG && i2 != chunk->off2)
290 printf("i2: %d off2: %d\n", i2, chunk->off2);
291
292 assert(i2 == chunk->off2);
293
294 i1--;
295 i2--;
296 if (chunk->len1 > 0)
297 i1 += chunk->len1;
298
299 if (chunk->len2 > 0)
300 i2 += chunk->len2;
301
302 cur_chunk++;
303 }
304 else {
305 if (i2 >= util2->num_lines)
306 break;
307
308 if (map[i1] != map2[i2] && map[i1] != -1) {
309 if (DEBUG)
310 printf("map: i1: %d %d %p i2: %d %d %p\n",
311 i1, map[i1],
312 (void *) (i1 != -1 ? blame_lines[map[i1]] : NULL),
313 i2, map2[i2],
314 (void *) (i2 != -1 ? blame_lines[map2[i2]] : NULL));
315 if (map2[i2] != -1 &&
316 blame_lines[map[i1]] &&
317 !blame_lines[map2[i2]])
318 map[i1] = map2[i2];
319 }
320
321 if (map[i1] == -1 && map2[i2] != -1)
322 map[i1] = map2[i2];
323 }
324
325 if (DEBUG > 1)
326 printf("l1: %d l2: %d i1: %d i2: %d\n",
327 map[i1], map2[i2], i1, i2);
328 }
329 }
330
331 static int map_line(struct commit *commit, int line)
332 {
333 struct util_info *info = commit->util;
334 assert(line >= 0 && line < info->num_lines);
335 return info->line_map[line];
336 }
337
338 static struct util_info *get_util(struct commit *commit)
339 {
340 struct util_info *util = commit->util;
341
342 if (util)
343 return util;
344
345 util = xcalloc(1, sizeof(struct util_info));
346 util->num_lines = -1;
347 commit->util = util;
348 return util;
349 }
350
351 static int fill_util_info(struct commit *commit)
352 {
353 struct util_info *util = commit->util;
354
355 assert(util);
356 assert(util->pathname);
357
358 return !!get_blob_sha1(commit->tree, util->pathname, util->sha1);
359 }
360
361 static void alloc_line_map(struct commit *commit)
362 {
363 struct util_info *util = commit->util;
364 int i;
365
366 if (util->line_map)
367 return;
368
369 get_blob(commit);
370
371 util->num_lines = 0;
372 for (i = 0; i < util->size; i++) {
373 if (util->buf[i] == '\n')
374 util->num_lines++;
375 }
376 if (util->buf[util->size - 1] != '\n')
377 util->num_lines++;
378
379 util->line_map = xmalloc(sizeof(int) * util->num_lines);
380
381 for (i = 0; i < util->num_lines; i++)
382 util->line_map[i] = -1;
383 }
384
385 static void init_first_commit(struct commit *commit, const char *filename)
386 {
387 struct util_info *util = commit->util;
388 int i;
389
390 util->pathname = filename;
391 if (fill_util_info(commit))
392 die("fill_util_info failed");
393
394 alloc_line_map(commit);
395
396 util = commit->util;
397
398 for (i = 0; i < util->num_lines; i++)
399 util->line_map[i] = i;
400 }
401
402 static void process_commits(struct rev_info *rev, const char *path,
403 struct commit **initial)
404 {
405 int i;
406 struct util_info *util;
407 int lines_left;
408 int *blame_p;
409 int *new_lines;
410 int new_lines_len;
411
412 struct commit *commit = get_revision(rev);
413 assert(commit);
414 init_first_commit(commit, path);
415
416 util = commit->util;
417 num_blame_lines = util->num_lines;
418 blame_lines = xmalloc(sizeof(struct commit *) * num_blame_lines);
419 blame_contents = util->buf;
420 blame_len = util->size;
421
422 for (i = 0; i < num_blame_lines; i++)
423 blame_lines[i] = NULL;
424
425 lines_left = num_blame_lines;
426 blame_p = xmalloc(sizeof(int) * num_blame_lines);
427 new_lines = xmalloc(sizeof(int) * num_blame_lines);
428 do {
429 struct commit_list *parents;
430 int num_parents;
431 struct util_info *util;
432
433 if (DEBUG)
434 printf("\nProcessing commit: %d %s\n", num_commits,
435 sha1_to_hex(commit->object.sha1));
436
437 if (lines_left == 0)
438 return;
439
440 num_commits++;
441 memset(blame_p, 0, sizeof(int) * num_blame_lines);
442 new_lines_len = 0;
443 num_parents = 0;
444 for (parents = commit->parents;
445 parents != NULL; parents = parents->next)
446 num_parents++;
447
448 if (num_parents == 0)
449 *initial = commit;
450
451 if (fill_util_info(commit))
452 continue;
453
454 alloc_line_map(commit);
455 util = commit->util;
456
457 for (parents = commit->parents;
458 parents != NULL; parents = parents->next) {
459 struct commit *parent = parents->item;
460 struct patch *patch;
461
462 if (parse_commit(parent) < 0)
463 die("parse_commit error");
464
465 if (DEBUG)
466 printf("parent: %s\n",
467 sha1_to_hex(parent->object.sha1));
468
469 if (fill_util_info(parent)) {
470 num_parents--;
471 continue;
472 }
473
474 patch = get_patch(parent, commit);
475 alloc_line_map(parent);
476 fill_line_map(parent, commit, patch);
477
478 for (i = 0; i < patch->num; i++) {
479 int l;
480 for (l = 0; l < patch->chunks[i].len2; l++) {
481 int mapped_line =
482 map_line(commit, patch->chunks[i].off2 + l);
483 if (mapped_line != -1) {
484 blame_p[mapped_line]++;
485 if (blame_p[mapped_line] == num_parents)
486 new_lines[new_lines_len++] = mapped_line;
487 }
488 }
489 }
490 free_patch(patch);
491 }
492
493 if (DEBUG)
494 printf("parents: %d\n", num_parents);
495
496 for (i = 0; i < new_lines_len; i++) {
497 int mapped_line = new_lines[i];
498 if (blame_lines[mapped_line] == NULL) {
499 blame_lines[mapped_line] = commit;
500 lines_left--;
501 if (DEBUG)
502 printf("blame: mapped: %d i: %d\n",
503 mapped_line, i);
504 }
505 }
506 } while ((commit = get_revision(rev)) != NULL);
507 }
508
509 static int compare_tree_path(struct rev_info *revs,
510 struct commit *c1, struct commit *c2)
511 {
512 int ret;
513 const char *paths[2];
514 struct util_info *util = c2->util;
515 paths[0] = util->pathname;
516 paths[1] = NULL;
517
518 diff_tree_setup_paths(get_pathspec(revs->prefix, paths),
519 &revs->pruning);
520 ret = rev_compare_tree(revs, c1->tree, c2->tree);
521 diff_tree_release_paths(&revs->pruning);
522 return ret;
523 }
524
525 static int same_tree_as_empty_path(struct rev_info *revs, struct tree *t1,
526 const char *path)
527 {
528 int ret;
529 const char *paths[2];
530 paths[0] = path;
531 paths[1] = NULL;
532
533 diff_tree_setup_paths(get_pathspec(revs->prefix, paths),
534 &revs->pruning);
535 ret = rev_same_tree_as_empty(revs, t1);
536 diff_tree_release_paths(&revs->pruning);
537 return ret;
538 }
539
540 static const char *find_rename(struct commit *commit, struct commit *parent)
541 {
542 struct util_info *cutil = commit->util;
543 struct diff_options diff_opts;
544 const char *paths[1];
545 int i;
546
547 if (DEBUG) {
548 printf("find_rename commit: %s ",
549 sha1_to_hex(commit->object.sha1));
550 puts(sha1_to_hex(parent->object.sha1));
551 }
552
553 diff_setup(&diff_opts);
554 diff_opts.recursive = 1;
555 diff_opts.detect_rename = DIFF_DETECT_RENAME;
556 paths[0] = NULL;
557 diff_tree_setup_paths(paths, &diff_opts);
558 if (diff_setup_done(&diff_opts) < 0)
559 die("diff_setup_done failed");
560
561 diff_tree_sha1(commit->tree->object.sha1, parent->tree->object.sha1,
562 "", &diff_opts);
563 diffcore_std(&diff_opts);
564
565 for (i = 0; i < diff_queued_diff.nr; i++) {
566 struct diff_filepair *p = diff_queued_diff.queue[i];
567
568 if (p->status == 'R' &&
569 !strcmp(p->one->path, cutil->pathname)) {
570 if (DEBUG)
571 printf("rename %s -> %s\n",
572 p->one->path, p->two->path);
573 return p->two->path;
574 }
575 }
576
577 return 0;
578 }
579
580 static void simplify_commit(struct rev_info *revs, struct commit *commit)
581 {
582 struct commit_list **pp, *parent;
583
584 if (!commit->tree)
585 return;
586
587 if (!commit->parents) {
588 struct util_info *util = commit->util;
589 if (!same_tree_as_empty_path(revs, commit->tree,
590 util->pathname))
591 commit->object.flags |= TREECHANGE;
592 return;
593 }
594
595 pp = &commit->parents;
596 while ((parent = *pp) != NULL) {
597 struct commit *p = parent->item;
598
599 if (p->object.flags & UNINTERESTING) {
600 pp = &parent->next;
601 continue;
602 }
603
604 parse_commit(p);
605 switch (compare_tree_path(revs, p, commit)) {
606 case REV_TREE_SAME:
607 parent->next = NULL;
608 commit->parents = parent;
609 get_util(p)->pathname = get_util(commit)->pathname;
610 return;
611
612 case REV_TREE_NEW:
613 {
614 struct util_info *util = commit->util;
615 if (revs->remove_empty_trees &&
616 same_tree_as_empty_path(revs, p->tree,
617 util->pathname)) {
618 const char *new_name = find_rename(commit, p);
619 if (new_name) {
620 struct util_info *putil = get_util(p);
621 if (!putil->pathname)
622 putil->pathname = xstrdup(new_name);
623 }
624 else {
625 *pp = parent->next;
626 continue;
627 }
628 }
629 }
630
631 /* fallthrough */
632 case REV_TREE_DIFFERENT:
633 pp = &parent->next;
634 if (!get_util(p)->pathname)
635 get_util(p)->pathname =
636 get_util(commit)->pathname;
637 continue;
638 }
639 die("bad tree compare for commit %s",
640 sha1_to_hex(commit->object.sha1));
641 }
642 commit->object.flags |= TREECHANGE;
643 }
644
645 struct commit_info
646 {
647 char *author;
648 char *author_mail;
649 unsigned long author_time;
650 char *author_tz;
651
652 /* filled only when asked for details */
653 char *committer;
654 char *committer_mail;
655 unsigned long committer_time;
656 char *committer_tz;
657
658 char *summary;
659 };
660
661 static void get_ac_line(const char *inbuf, const char *what,
662 int bufsz, char *person, char **mail,
663 unsigned long *time, char **tz)
664 {
665 int len;
666 char *tmp, *endp;
667
668 tmp = strstr(inbuf, what);
669 if (!tmp)
670 goto error_out;
671 tmp += strlen(what);
672 endp = strchr(tmp, '\n');
673 if (!endp)
674 len = strlen(tmp);
675 else
676 len = endp - tmp;
677 if (bufsz <= len) {
678 error_out:
679 /* Ugh */
680 person = *mail = *tz = "(unknown)";
681 *time = 0;
682 return;
683 }
684 memcpy(person, tmp, len);
685
686 tmp = person;
687 tmp += len;
688 *tmp = 0;
689 while (*tmp != ' ')
690 tmp--;
691 *tz = tmp+1;
692
693 *tmp = 0;
694 while (*tmp != ' ')
695 tmp--;
696 *time = strtoul(tmp, NULL, 10);
697
698 *tmp = 0;
699 while (*tmp != ' ')
700 tmp--;
701 *mail = tmp + 1;
702 *tmp = 0;
703 }
704
705 static void get_commit_info(struct commit *commit, struct commit_info *ret, int detailed)
706 {
707 int len;
708 char *tmp, *endp;
709 static char author_buf[1024];
710 static char committer_buf[1024];
711 static char summary_buf[1024];
712
713 ret->author = author_buf;
714 get_ac_line(commit->buffer, "\nauthor ",
715 sizeof(author_buf), author_buf, &ret->author_mail,
716 &ret->author_time, &ret->author_tz);
717
718 if (!detailed)
719 return;
720
721 ret->committer = committer_buf;
722 get_ac_line(commit->buffer, "\ncommitter ",
723 sizeof(committer_buf), committer_buf, &ret->committer_mail,
724 &ret->committer_time, &ret->committer_tz);
725
726 ret->summary = summary_buf;
727 tmp = strstr(commit->buffer, "\n\n");
728 if (!tmp) {
729 error_out:
730 sprintf(summary_buf, "(%s)", sha1_to_hex(commit->object.sha1));
731 return;
732 }
733 tmp += 2;
734 endp = strchr(tmp, '\n');
735 if (!endp)
736 goto error_out;
737 len = endp - tmp;
738 if (len >= sizeof(summary_buf))
739 goto error_out;
740 memcpy(summary_buf, tmp, len);
741 summary_buf[len] = 0;
742 }
743
744 static const char *format_time(unsigned long time, const char *tz_str,
745 int show_raw_time)
746 {
747 static char time_buf[128];
748 time_t t = time;
749 int minutes, tz;
750 struct tm *tm;
751
752 if (show_raw_time) {
753 sprintf(time_buf, "%lu %s", time, tz_str);
754 return time_buf;
755 }
756
757 tz = atoi(tz_str);
758 minutes = tz < 0 ? -tz : tz;
759 minutes = (minutes / 100)*60 + (minutes % 100);
760 minutes = tz < 0 ? -minutes : minutes;
761 t = time + minutes * 60;
762 tm = gmtime(&t);
763
764 strftime(time_buf, sizeof(time_buf), "%Y-%m-%d %H:%M:%S ", tm);
765 strcat(time_buf, tz_str);
766 return time_buf;
767 }
768
769 static void topo_setter(struct commit *c, void *data)
770 {
771 struct util_info *util = c->util;
772 util->topo_data = data;
773 }
774
775 static void *topo_getter(struct commit *c)
776 {
777 struct util_info *util = c->util;
778 return util->topo_data;
779 }
780
781 static int read_ancestry(const char *graft_file,
782 unsigned char **start_sha1)
783 {
784 FILE *fp = fopen(graft_file, "r");
785 char buf[1024];
786 if (!fp)
787 return -1;
788 while (fgets(buf, sizeof(buf), fp)) {
789 /* The format is just "Commit Parent1 Parent2 ...\n" */
790 int len = strlen(buf);
791 struct commit_graft *graft = read_graft_line(buf, len);
792 register_commit_graft(graft, 0);
793 if (!*start_sha1)
794 *start_sha1 = graft->sha1;
795 }
796 fclose(fp);
797 return 0;
798 }
799
800 static int lineno_width(int lines)
801 {
802 int i, width;
803
804 for (width = 1, i = 10; i <= lines + 1; width++)
805 i *= 10;
806 return width;
807 }
808
809 static int find_orig_linenum(struct util_info *u, int lineno)
810 {
811 int i;
812
813 for (i = 0; i < u->num_lines; i++)
814 if (lineno == u->line_map[i])
815 return i + 1;
816 return 0;
817 }
818
819 static void emit_meta(struct commit *c, int lno,
820 int sha1_len, int compatibility, int porcelain,
821 int show_name, int show_number, int show_raw_time,
822 int longest_file, int longest_author,
823 int max_digits, int max_orig_digits)
824 {
825 struct util_info *u;
826 int lineno;
827 struct commit_info ci;
828
829 u = c->util;
830 lineno = find_orig_linenum(u, lno);
831
832 if (porcelain) {
833 int group_size = -1;
834 struct commit *cc = (lno == 0) ? NULL : blame_lines[lno-1];
835 if (cc != c) {
836 /* This is the beginning of this group */
837 int i;
838 for (i = lno + 1; i < num_blame_lines; i++)
839 if (blame_lines[i] != c)
840 break;
841 group_size = i - lno;
842 }
843 if (0 < group_size)
844 printf("%s %d %d %d\n", sha1_to_hex(c->object.sha1),
845 lineno, lno + 1, group_size);
846 else
847 printf("%s %d %d\n", sha1_to_hex(c->object.sha1),
848 lineno, lno + 1);
849 if (!u->meta_given) {
850 get_commit_info(c, &ci, 1);
851 printf("author %s\n", ci.author);
852 printf("author-mail %s\n", ci.author_mail);
853 printf("author-time %lu\n", ci.author_time);
854 printf("author-tz %s\n", ci.author_tz);
855 printf("committer %s\n", ci.committer);
856 printf("committer-mail %s\n", ci.committer_mail);
857 printf("committer-time %lu\n", ci.committer_time);
858 printf("committer-tz %s\n", ci.committer_tz);
859 printf("filename ");
860 if (quote_c_style(u->pathname, NULL, NULL, 0))
861 quote_c_style(u->pathname, NULL, stdout, 0);
862 else
863 fputs(u->pathname, stdout);
864 printf("\nsummary %s\n", ci.summary);
865
866 u->meta_given = 1;
867 }
868 putchar('\t');
869 return;
870 }
871
872 get_commit_info(c, &ci, 0);
873 fwrite(sha1_to_hex(c->object.sha1), sha1_len, 1, stdout);
874 if (compatibility) {
875 printf("\t(%10s\t%10s\t%d)", ci.author,
876 format_time(ci.author_time, ci.author_tz,
877 show_raw_time),
878 lno + 1);
879 }
880 else {
881 if (show_name)
882 printf(" %-*.*s", longest_file, longest_file,
883 u->pathname);
884 if (show_number)
885 printf(" %*d", max_orig_digits,
886 lineno);
887 printf(" (%-*.*s %10s %*d) ",
888 longest_author, longest_author, ci.author,
889 format_time(ci.author_time, ci.author_tz,
890 show_raw_time),
891 max_digits, lno + 1);
892 }
893 }
894
895 int main(int argc, const char **argv)
896 {
897 int i;
898 struct commit *initial = NULL;
899 unsigned char sha1[20], *sha1_p = NULL;
900
901 const char *filename = NULL, *commit = NULL;
902 char filename_buf[256];
903 int sha1_len = 8;
904 int compatibility = 0;
905 int show_raw_time = 0;
906 int options = 1;
907 struct commit *start_commit;
908
909 const char *args[10];
910 struct rev_info rev;
911
912 struct commit_info ci;
913 const char *buf;
914 int max_digits, max_orig_digits;
915 int longest_file, longest_author, longest_file_lines;
916 int show_name = 0;
917 int show_number = 0;
918 int porcelain = 0;
919
920 const char *prefix = setup_git_directory();
921 git_config(git_default_config);
922
923 for (i = 1; i < argc; i++) {
924 if (options) {
925 if (!strcmp(argv[i], "-h") ||
926 !strcmp(argv[i], "--help"))
927 usage(blame_usage);
928 if (!strcmp(argv[i], "-l") ||
929 !strcmp(argv[i], "--long")) {
930 sha1_len = 40;
931 continue;
932 }
933 if (!strcmp(argv[i], "-c") ||
934 !strcmp(argv[i], "--compatibility")) {
935 compatibility = 1;
936 continue;
937 }
938 if (!strcmp(argv[i], "-t") ||
939 !strcmp(argv[i], "--time")) {
940 show_raw_time = 1;
941 continue;
942 }
943 if (!strcmp(argv[i], "-S")) {
944 if (i + 1 < argc &&
945 !read_ancestry(argv[i + 1], &sha1_p)) {
946 compatibility = 1;
947 i++;
948 continue;
949 }
950 usage(blame_usage);
951 }
952 if (!strcmp(argv[i], "-f") ||
953 !strcmp(argv[i], "--show-name")) {
954 show_name = 1;
955 continue;
956 }
957 if (!strcmp(argv[i], "-n") ||
958 !strcmp(argv[i], "--show-number")) {
959 show_number = 1;
960 continue;
961 }
962 if (!strcmp(argv[i], "-p") ||
963 !strcmp(argv[i], "--porcelain")) {
964 porcelain = 1;
965 sha1_len = 40;
966 show_raw_time = 1;
967 continue;
968 }
969 if (!strcmp(argv[i], "--")) {
970 options = 0;
971 continue;
972 }
973 if (argv[i][0] == '-')
974 usage(blame_usage);
975 options = 0;
976 }
977
978 if (!options) {
979 if (!filename)
980 filename = argv[i];
981 else if (!commit)
982 commit = argv[i];
983 else
984 usage(blame_usage);
985 }
986 }
987
988 if (!filename)
989 usage(blame_usage);
990 if (commit && sha1_p)
991 usage(blame_usage);
992 else if (!commit)
993 commit = "HEAD";
994
995 if (prefix)
996 sprintf(filename_buf, "%s%s", prefix, filename);
997 else
998 strcpy(filename_buf, filename);
999 filename = filename_buf;
1000
1001 if (!sha1_p) {
1002 if (get_sha1(commit, sha1))
1003 die("get_sha1 failed, commit '%s' not found", commit);
1004 sha1_p = sha1;
1005 }
1006 start_commit = lookup_commit_reference(sha1_p);
1007 get_util(start_commit)->pathname = filename;
1008 if (fill_util_info(start_commit)) {
1009 printf("%s not found in %s\n", filename, commit);
1010 return 1;
1011 }
1012
1013 init_revisions(&rev, setup_git_directory());
1014 rev.remove_empty_trees = 1;
1015 rev.topo_order = 1;
1016 rev.prune_fn = simplify_commit;
1017 rev.topo_setter = topo_setter;
1018 rev.topo_getter = topo_getter;
1019 rev.parents = 1;
1020 rev.limited = 1;
1021
1022 commit_list_insert(start_commit, &rev.commits);
1023
1024 args[0] = filename;
1025 args[1] = NULL;
1026 diff_tree_setup_paths(args, &rev.pruning);
1027 prepare_revision_walk(&rev);
1028 process_commits(&rev, filename, &initial);
1029
1030 for (i = 0; i < num_blame_lines; i++)
1031 if (!blame_lines[i])
1032 blame_lines[i] = initial;
1033
1034 buf = blame_contents;
1035 max_digits = lineno_width(num_blame_lines);
1036
1037 longest_file = 0;
1038 longest_author = 0;
1039 longest_file_lines = 0;
1040 for (i = 0; i < num_blame_lines; i++) {
1041 struct commit *c = blame_lines[i];
1042 struct util_info *u;
1043 u = c->util;
1044
1045 if (!show_name && strcmp(filename, u->pathname))
1046 show_name = 1;
1047 if (longest_file < strlen(u->pathname))
1048 longest_file = strlen(u->pathname);
1049 if (longest_file_lines < u->num_lines)
1050 longest_file_lines = u->num_lines;
1051 get_commit_info(c, &ci, 0);
1052 if (longest_author < strlen(ci.author))
1053 longest_author = strlen(ci.author);
1054 }
1055
1056 max_orig_digits = lineno_width(longest_file_lines);
1057
1058 for (i = 0; i < num_blame_lines; i++) {
1059 emit_meta(blame_lines[i], i,
1060 sha1_len, compatibility, porcelain,
1061 show_name, show_number, show_raw_time,
1062 longest_file, longest_author,
1063 max_digits, max_orig_digits);
1064
1065 if (i == num_blame_lines - 1) {
1066 fwrite(buf, blame_len - (buf - blame_contents),
1067 1, stdout);
1068 if (blame_contents[blame_len-1] != '\n')
1069 putc('\n', stdout);
1070 }
1071 else {
1072 char *next_buf = strchr(buf, '\n') + 1;
1073 fwrite(buf, next_buf - buf, 1, stdout);
1074 buf = next_buf;
1075 }
1076 }
1077
1078 if (DEBUG) {
1079 printf("num get patch: %d\n", num_get_patch);
1080 printf("num commits: %d\n", num_commits);
1081 printf("patch time: %f\n", patch_time / 1000000.0);
1082 printf("initial: %s\n", sha1_to_hex(initial->object.sha1));
1083 }
1084
1085 return 0;
1086 }
kirr's git tree