Merge branch 'jn/gitweb-grep'
[git/git.git] / builtin-log.c
1 /*
2 * Builtin "git log" and related commands (show, whatchanged)
3 *
4 * (C) Copyright 2006 Linus Torvalds
5 * 2006 Junio Hamano
6 */
7 #include "cache.h"
8 #include "color.h"
9 #include "commit.h"
10 #include "diff.h"
11 #include "revision.h"
12 #include "log-tree.h"
13 #include "builtin.h"
14 #include "tag.h"
15 #include "reflog-walk.h"
16 #include "patch-ids.h"
17 #include "refs.h"
18 #include "run-command.h"
19 #include "shortlog.h"
20
21 static int default_show_root = 1;
22 static const char *fmt_patch_subject_prefix = "PATCH";
23
24 static void add_name_decoration(const char *prefix, const char *name, struct object *obj)
25 {
26 int plen = strlen(prefix);
27 int nlen = strlen(name);
28 struct name_decoration *res = xmalloc(sizeof(struct name_decoration) + plen + nlen);
29 memcpy(res->name, prefix, plen);
30 memcpy(res->name + plen, name, nlen + 1);
31 res->next = add_decoration(&name_decoration, obj, res);
32 }
33
34 static int add_ref_decoration(const char *refname, const unsigned char *sha1, int flags, void *cb_data)
35 {
36 struct object *obj = parse_object(sha1);
37 if (!obj)
38 return 0;
39 add_name_decoration("", refname, obj);
40 while (obj->type == OBJ_TAG) {
41 obj = ((struct tag *)obj)->tagged;
42 if (!obj)
43 break;
44 add_name_decoration("tag: ", refname, obj);
45 }
46 return 0;
47 }
48
49 static void cmd_log_init(int argc, const char **argv, const char *prefix,
50 struct rev_info *rev)
51 {
52 int i;
53 int decorate = 0;
54
55 rev->abbrev = DEFAULT_ABBREV;
56 rev->commit_format = CMIT_FMT_DEFAULT;
57 rev->verbose_header = 1;
58 DIFF_OPT_SET(&rev->diffopt, RECURSIVE);
59 rev->show_root_diff = default_show_root;
60 rev->subject_prefix = fmt_patch_subject_prefix;
61 argc = setup_revisions(argc, argv, rev, "HEAD");
62 if (rev->diffopt.pickaxe || rev->diffopt.filter)
63 rev->always_show_header = 0;
64 if (DIFF_OPT_TST(&rev->diffopt, FOLLOW_RENAMES)) {
65 rev->always_show_header = 0;
66 if (rev->diffopt.nr_paths != 1)
67 usage("git logs can only follow renames on one pathname at a time");
68 }
69 for (i = 1; i < argc; i++) {
70 const char *arg = argv[i];
71 if (!strcmp(arg, "--decorate")) {
72 if (!decorate)
73 for_each_ref(add_ref_decoration, NULL);
74 decorate = 1;
75 } else
76 die("unrecognized argument: %s", arg);
77 }
78 }
79
80 /*
81 * This gives a rough estimate for how many commits we
82 * will print out in the list.
83 */
84 static int estimate_commit_count(struct rev_info *rev, struct commit_list *list)
85 {
86 int n = 0;
87
88 while (list) {
89 struct commit *commit = list->item;
90 unsigned int flags = commit->object.flags;
91 list = list->next;
92 if (!(flags & (TREESAME | UNINTERESTING)))
93 n++;
94 }
95 return n;
96 }
97
98 static void show_early_header(struct rev_info *rev, const char *stage, int nr)
99 {
100 if (rev->shown_one) {
101 rev->shown_one = 0;
102 if (rev->commit_format != CMIT_FMT_ONELINE)
103 putchar(rev->diffopt.line_termination);
104 }
105 printf("Final output: %d %s\n", nr, stage);
106 }
107
108 struct itimerval early_output_timer;
109
110 static void log_show_early(struct rev_info *revs, struct commit_list *list)
111 {
112 int i = revs->early_output;
113 int show_header = 1;
114
115 sort_in_topological_order(&list, revs->lifo);
116 while (list && i) {
117 struct commit *commit = list->item;
118 switch (simplify_commit(revs, commit)) {
119 case commit_show:
120 if (show_header) {
121 int n = estimate_commit_count(revs, list);
122 show_early_header(revs, "incomplete", n);
123 show_header = 0;
124 }
125 log_tree_commit(revs, commit);
126 i--;
127 break;
128 case commit_ignore:
129 break;
130 case commit_error:
131 return;
132 }
133 list = list->next;
134 }
135
136 /* Did we already get enough commits for the early output? */
137 if (!i)
138 return;
139
140 /*
141 * ..if no, then repeat it twice a second until we
142 * do.
143 *
144 * NOTE! We don't use "it_interval", because if the
145 * reader isn't listening, we want our output to be
146 * throttled by the writing, and not have the timer
147 * trigger every second even if we're blocked on a
148 * reader!
149 */
150 early_output_timer.it_value.tv_sec = 0;
151 early_output_timer.it_value.tv_usec = 500000;
152 setitimer(ITIMER_REAL, &early_output_timer, NULL);
153 }
154
155 static void early_output(int signal)
156 {
157 show_early_output = log_show_early;
158 }
159
160 static void setup_early_output(struct rev_info *rev)
161 {
162 struct sigaction sa;
163
164 /*
165 * Set up the signal handler, minimally intrusively:
166 * we only set a single volatile integer word (not
167 * using sigatomic_t - trying to avoid unnecessary
168 * system dependencies and headers), and using
169 * SA_RESTART.
170 */
171 memset(&sa, 0, sizeof(sa));
172 sa.sa_handler = early_output;
173 sigemptyset(&sa.sa_mask);
174 sa.sa_flags = SA_RESTART;
175 sigaction(SIGALRM, &sa, NULL);
176
177 /*
178 * If we can get the whole output in less than a
179 * tenth of a second, don't even bother doing the
180 * early-output thing..
181 *
182 * This is a one-time-only trigger.
183 */
184 early_output_timer.it_value.tv_sec = 0;
185 early_output_timer.it_value.tv_usec = 100000;
186 setitimer(ITIMER_REAL, &early_output_timer, NULL);
187 }
188
189 static void finish_early_output(struct rev_info *rev)
190 {
191 int n = estimate_commit_count(rev, rev->commits);
192 signal(SIGALRM, SIG_IGN);
193 show_early_header(rev, "done", n);
194 }
195
196 static int cmd_log_walk(struct rev_info *rev)
197 {
198 struct commit *commit;
199
200 if (rev->early_output)
201 setup_early_output(rev);
202
203 if (prepare_revision_walk(rev))
204 die("revision walk setup failed");
205
206 if (rev->early_output)
207 finish_early_output(rev);
208
209 while ((commit = get_revision(rev)) != NULL) {
210 log_tree_commit(rev, commit);
211 if (!rev->reflog_info) {
212 /* we allow cycles in reflog ancestry */
213 free(commit->buffer);
214 commit->buffer = NULL;
215 }
216 free_commit_list(commit->parents);
217 commit->parents = NULL;
218 }
219 return 0;
220 }
221
222 static int git_log_config(const char *var, const char *value)
223 {
224 if (!strcmp(var, "format.subjectprefix")) {
225 if (!value)
226 config_error_nonbool(var);
227 fmt_patch_subject_prefix = xstrdup(value);
228 return 0;
229 }
230 if (!strcmp(var, "log.showroot")) {
231 default_show_root = git_config_bool(var, value);
232 return 0;
233 }
234 return git_diff_ui_config(var, value);
235 }
236
237 int cmd_whatchanged(int argc, const char **argv, const char *prefix)
238 {
239 struct rev_info rev;
240
241 git_config(git_log_config);
242
243 if (diff_use_color_default == -1)
244 diff_use_color_default = git_use_color_default;
245
246 init_revisions(&rev, prefix);
247 rev.diff = 1;
248 rev.simplify_history = 0;
249 cmd_log_init(argc, argv, prefix, &rev);
250 if (!rev.diffopt.output_format)
251 rev.diffopt.output_format = DIFF_FORMAT_RAW;
252 return cmd_log_walk(&rev);
253 }
254
255 static void show_tagger(char *buf, int len, struct rev_info *rev)
256 {
257 char *email_end, *p;
258 unsigned long date;
259 int tz;
260
261 email_end = memchr(buf, '>', len);
262 if (!email_end)
263 return;
264 p = ++email_end;
265 while (isspace(*p))
266 p++;
267 date = strtoul(p, &p, 10);
268 while (isspace(*p))
269 p++;
270 tz = (int)strtol(p, NULL, 10);
271 printf("Tagger: %.*s\nDate: %s\n", (int)(email_end - buf), buf,
272 show_date(date, tz, rev->date_mode));
273 }
274
275 static int show_object(const unsigned char *sha1, int show_tag_object,
276 struct rev_info *rev)
277 {
278 unsigned long size;
279 enum object_type type;
280 char *buf = read_sha1_file(sha1, &type, &size);
281 int offset = 0;
282
283 if (!buf)
284 return error("Could not read object %s", sha1_to_hex(sha1));
285
286 if (show_tag_object)
287 while (offset < size && buf[offset] != '\n') {
288 int new_offset = offset + 1;
289 while (new_offset < size && buf[new_offset++] != '\n')
290 ; /* do nothing */
291 if (!prefixcmp(buf + offset, "tagger "))
292 show_tagger(buf + offset + 7,
293 new_offset - offset - 7, rev);
294 offset = new_offset;
295 }
296
297 if (offset < size)
298 fwrite(buf + offset, size - offset, 1, stdout);
299 free(buf);
300 return 0;
301 }
302
303 static int show_tree_object(const unsigned char *sha1,
304 const char *base, int baselen,
305 const char *pathname, unsigned mode, int stage)
306 {
307 printf("%s%s\n", pathname, S_ISDIR(mode) ? "/" : "");
308 return 0;
309 }
310
311 int cmd_show(int argc, const char **argv, const char *prefix)
312 {
313 struct rev_info rev;
314 struct object_array_entry *objects;
315 int i, count, ret = 0;
316
317 git_config(git_log_config);
318
319 if (diff_use_color_default == -1)
320 diff_use_color_default = git_use_color_default;
321
322 init_revisions(&rev, prefix);
323 rev.diff = 1;
324 rev.combine_merges = 1;
325 rev.dense_combined_merges = 1;
326 rev.always_show_header = 1;
327 rev.ignore_merges = 0;
328 rev.no_walk = 1;
329 cmd_log_init(argc, argv, prefix, &rev);
330
331 count = rev.pending.nr;
332 objects = rev.pending.objects;
333 for (i = 0; i < count && !ret; i++) {
334 struct object *o = objects[i].item;
335 const char *name = objects[i].name;
336 switch (o->type) {
337 case OBJ_BLOB:
338 ret = show_object(o->sha1, 0, NULL);
339 break;
340 case OBJ_TAG: {
341 struct tag *t = (struct tag *)o;
342
343 printf("%stag %s%s\n",
344 diff_get_color_opt(&rev.diffopt, DIFF_COMMIT),
345 t->tag,
346 diff_get_color_opt(&rev.diffopt, DIFF_RESET));
347 ret = show_object(o->sha1, 1, &rev);
348 objects[i].item = (struct object *)t->tagged;
349 i--;
350 break;
351 }
352 case OBJ_TREE:
353 printf("%stree %s%s\n\n",
354 diff_get_color_opt(&rev.diffopt, DIFF_COMMIT),
355 name,
356 diff_get_color_opt(&rev.diffopt, DIFF_RESET));
357 read_tree_recursive((struct tree *)o, "", 0, 0, NULL,
358 show_tree_object);
359 break;
360 case OBJ_COMMIT:
361 rev.pending.nr = rev.pending.alloc = 0;
362 rev.pending.objects = NULL;
363 add_object_array(o, name, &rev.pending);
364 ret = cmd_log_walk(&rev);
365 break;
366 default:
367 ret = error("Unknown type: %d", o->type);
368 }
369 }
370 free(objects);
371 return ret;
372 }
373
374 /*
375 * This is equivalent to "git log -g --abbrev-commit --pretty=oneline"
376 */
377 int cmd_log_reflog(int argc, const char **argv, const char *prefix)
378 {
379 struct rev_info rev;
380
381 git_config(git_log_config);
382
383 if (diff_use_color_default == -1)
384 diff_use_color_default = git_use_color_default;
385
386 init_revisions(&rev, prefix);
387 init_reflog_walk(&rev.reflog_info);
388 rev.abbrev_commit = 1;
389 rev.verbose_header = 1;
390 cmd_log_init(argc, argv, prefix, &rev);
391
392 /*
393 * This means that we override whatever commit format the user gave
394 * on the cmd line. Sad, but cmd_log_init() currently doesn't
395 * allow us to set a different default.
396 */
397 rev.commit_format = CMIT_FMT_ONELINE;
398 rev.always_show_header = 1;
399
400 /*
401 * We get called through "git reflog", so unlike the other log
402 * routines, we need to set up our pager manually..
403 */
404 setup_pager();
405
406 return cmd_log_walk(&rev);
407 }
408
409 int cmd_log(int argc, const char **argv, const char *prefix)
410 {
411 struct rev_info rev;
412
413 git_config(git_log_config);
414
415 if (diff_use_color_default == -1)
416 diff_use_color_default = git_use_color_default;
417
418 init_revisions(&rev, prefix);
419 rev.always_show_header = 1;
420 cmd_log_init(argc, argv, prefix, &rev);
421 return cmd_log_walk(&rev);
422 }
423
424 /* format-patch */
425 #define FORMAT_PATCH_NAME_MAX 64
426
427 static int istitlechar(char c)
428 {
429 return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
430 (c >= '0' && c <= '9') || c == '.' || c == '_';
431 }
432
433 static const char *fmt_patch_suffix = ".patch";
434 static int numbered = 0;
435 static int auto_number = 0;
436
437 static char **extra_hdr;
438 static int extra_hdr_nr;
439 static int extra_hdr_alloc;
440
441 static char **extra_to;
442 static int extra_to_nr;
443 static int extra_to_alloc;
444
445 static char **extra_cc;
446 static int extra_cc_nr;
447 static int extra_cc_alloc;
448
449 static void add_header(const char *value)
450 {
451 int len = strlen(value);
452 while (value[len - 1] == '\n')
453 len--;
454 if (!strncasecmp(value, "to: ", 4)) {
455 ALLOC_GROW(extra_to, extra_to_nr + 1, extra_to_alloc);
456 extra_to[extra_to_nr++] = xstrndup(value + 4, len - 4);
457 return;
458 }
459 if (!strncasecmp(value, "cc: ", 4)) {
460 ALLOC_GROW(extra_cc, extra_cc_nr + 1, extra_cc_alloc);
461 extra_cc[extra_cc_nr++] = xstrndup(value + 4, len - 4);
462 return;
463 }
464 ALLOC_GROW(extra_hdr, extra_hdr_nr + 1, extra_hdr_alloc);
465 extra_hdr[extra_hdr_nr++] = xstrndup(value, len);
466 }
467
468 static int git_format_config(const char *var, const char *value)
469 {
470 if (!strcmp(var, "format.headers")) {
471 if (!value)
472 die("format.headers without value");
473 add_header(value);
474 return 0;
475 }
476 if (!strcmp(var, "format.suffix")) {
477 if (!value)
478 return config_error_nonbool(var);
479 fmt_patch_suffix = xstrdup(value);
480 return 0;
481 }
482 if (!strcmp(var, "diff.color") || !strcmp(var, "color.diff")) {
483 return 0;
484 }
485 if (!strcmp(var, "format.numbered")) {
486 if (value && !strcasecmp(value, "auto")) {
487 auto_number = 1;
488 return 0;
489 }
490 numbered = git_config_bool(var, value);
491 return 0;
492 }
493
494 return git_log_config(var, value);
495 }
496
497
498 static const char *get_oneline_for_filename(struct commit *commit,
499 int keep_subject)
500 {
501 static char filename[PATH_MAX];
502 char *sol;
503 int len = 0;
504 int suffix_len = strlen(fmt_patch_suffix) + 1;
505
506 sol = strstr(commit->buffer, "\n\n");
507 if (!sol)
508 filename[0] = '\0';
509 else {
510 int j, space = 0;
511
512 sol += 2;
513 /* strip [PATCH] or [PATCH blabla] */
514 if (!keep_subject && !prefixcmp(sol, "[PATCH")) {
515 char *eos = strchr(sol + 6, ']');
516 if (eos) {
517 while (isspace(*eos))
518 eos++;
519 sol = eos;
520 }
521 }
522
523 for (j = 0;
524 j < FORMAT_PATCH_NAME_MAX - suffix_len - 5 &&
525 len < sizeof(filename) - suffix_len &&
526 sol[j] && sol[j] != '\n';
527 j++) {
528 if (istitlechar(sol[j])) {
529 if (space) {
530 filename[len++] = '-';
531 space = 0;
532 }
533 filename[len++] = sol[j];
534 if (sol[j] == '.')
535 while (sol[j + 1] == '.')
536 j++;
537 } else
538 space = 1;
539 }
540 while (filename[len - 1] == '.'
541 || filename[len - 1] == '-')
542 len--;
543 filename[len] = '\0';
544 }
545 return filename;
546 }
547
548 static FILE *realstdout = NULL;
549 static const char *output_directory = NULL;
550
551 static int reopen_stdout(const char *oneline, int nr, int total)
552 {
553 char filename[PATH_MAX];
554 int len = 0;
555 int suffix_len = strlen(fmt_patch_suffix) + 1;
556
557 if (output_directory) {
558 len = snprintf(filename, sizeof(filename), "%s",
559 output_directory);
560 if (len >=
561 sizeof(filename) - FORMAT_PATCH_NAME_MAX - suffix_len)
562 return error("name of output directory is too long");
563 if (filename[len - 1] != '/')
564 filename[len++] = '/';
565 }
566
567 if (!oneline)
568 len += sprintf(filename + len, "%d", nr);
569 else {
570 len += sprintf(filename + len, "%04d-", nr);
571 len += snprintf(filename + len, sizeof(filename) - len - 1
572 - suffix_len, "%s", oneline);
573 strcpy(filename + len, fmt_patch_suffix);
574 }
575
576 fprintf(realstdout, "%s\n", filename);
577 if (freopen(filename, "w", stdout) == NULL)
578 return error("Cannot open patch file %s",filename);
579
580 return 0;
581 }
582
583 static void get_patch_ids(struct rev_info *rev, struct patch_ids *ids, const char *prefix)
584 {
585 struct rev_info check_rev;
586 struct commit *commit;
587 struct object *o1, *o2;
588 unsigned flags1, flags2;
589
590 if (rev->pending.nr != 2)
591 die("Need exactly one range.");
592
593 o1 = rev->pending.objects[0].item;
594 flags1 = o1->flags;
595 o2 = rev->pending.objects[1].item;
596 flags2 = o2->flags;
597
598 if ((flags1 & UNINTERESTING) == (flags2 & UNINTERESTING))
599 die("Not a range.");
600
601 init_patch_ids(ids);
602
603 /* given a range a..b get all patch ids for b..a */
604 init_revisions(&check_rev, prefix);
605 o1->flags ^= UNINTERESTING;
606 o2->flags ^= UNINTERESTING;
607 add_pending_object(&check_rev, o1, "o1");
608 add_pending_object(&check_rev, o2, "o2");
609 if (prepare_revision_walk(&check_rev))
610 die("revision walk setup failed");
611
612 while ((commit = get_revision(&check_rev)) != NULL) {
613 /* ignore merges */
614 if (commit->parents && commit->parents->next)
615 continue;
616
617 add_commit_patch_id(commit, ids);
618 }
619
620 /* reset for next revision walk */
621 clear_commit_marks((struct commit *)o1,
622 SEEN | UNINTERESTING | SHOWN | ADDED);
623 clear_commit_marks((struct commit *)o2,
624 SEEN | UNINTERESTING | SHOWN | ADDED);
625 o1->flags = flags1;
626 o2->flags = flags2;
627 }
628
629 static void gen_message_id(struct rev_info *info, char *base)
630 {
631 const char *committer = git_committer_info(IDENT_WARN_ON_NO_NAME);
632 const char *email_start = strrchr(committer, '<');
633 const char *email_end = strrchr(committer, '>');
634 struct strbuf buf;
635 if (!email_start || !email_end || email_start > email_end - 1)
636 die("Could not extract email from committer identity.");
637 strbuf_init(&buf, 0);
638 strbuf_addf(&buf, "%s.%lu.git.%.*s", base,
639 (unsigned long) time(NULL),
640 (int)(email_end - email_start - 1), email_start + 1);
641 info->message_id = strbuf_detach(&buf, NULL);
642 }
643
644 static void make_cover_letter(struct rev_info *rev, int use_stdout,
645 int numbered, int numbered_files,
646 struct commit *origin,
647 int nr, struct commit **list, struct commit *head)
648 {
649 const char *committer;
650 char *head_sha1;
651 const char *subject_start = NULL;
652 const char *body = "*** SUBJECT HERE ***\n\n*** BLURB HERE ***\n";
653 const char *msg;
654 const char *extra_headers = rev->extra_headers;
655 struct shortlog log;
656 struct strbuf sb;
657 int i;
658 const char *encoding = "utf-8";
659 struct diff_options opts;
660
661 if (rev->commit_format != CMIT_FMT_EMAIL)
662 die("Cover letter needs email format");
663
664 if (!use_stdout && reopen_stdout(numbered_files ?
665 NULL : "cover-letter", 0, rev->total))
666 return;
667
668 head_sha1 = sha1_to_hex(head->object.sha1);
669
670 log_write_email_headers(rev, head_sha1, &subject_start, &extra_headers);
671
672 committer = git_committer_info(0);
673
674 msg = body;
675 strbuf_init(&sb, 0);
676 pp_user_info(NULL, CMIT_FMT_EMAIL, &sb, committer, DATE_RFC2822,
677 encoding);
678 pp_title_line(CMIT_FMT_EMAIL, &msg, &sb, subject_start, extra_headers,
679 encoding, 0);
680 pp_remainder(CMIT_FMT_EMAIL, &msg, &sb, 0);
681 printf("%s\n", sb.buf);
682
683 strbuf_release(&sb);
684
685 shortlog_init(&log);
686 for (i = 0; i < nr; i++)
687 shortlog_add_commit(&log, list[i]);
688
689 shortlog_output(&log);
690
691 /*
692 * We can only do diffstat with a unique reference point
693 */
694 if (!origin)
695 return;
696
697 diff_setup(&opts);
698 opts.output_format |= DIFF_FORMAT_SUMMARY | DIFF_FORMAT_DIFFSTAT;
699
700 diff_setup_done(&opts);
701
702 diff_tree_sha1(origin->tree->object.sha1,
703 head->tree->object.sha1,
704 "", &opts);
705 diffcore_std(&opts);
706 diff_flush(&opts);
707
708 printf("\n");
709 }
710
711 static const char *clean_message_id(const char *msg_id)
712 {
713 char ch;
714 const char *a, *z, *m;
715
716 m = msg_id;
717 while ((ch = *m) && (isspace(ch) || (ch == '<')))
718 m++;
719 a = m;
720 z = NULL;
721 while ((ch = *m)) {
722 if (!isspace(ch) && (ch != '>'))
723 z = m;
724 m++;
725 }
726 if (!z)
727 die("insane in-reply-to: %s", msg_id);
728 if (++z == m)
729 return a;
730 return xmemdupz(a, z - a);
731 }
732
733 int cmd_format_patch(int argc, const char **argv, const char *prefix)
734 {
735 struct commit *commit;
736 struct commit **list = NULL;
737 struct rev_info rev;
738 int nr = 0, total, i, j;
739 int use_stdout = 0;
740 int start_number = -1;
741 int keep_subject = 0;
742 int numbered_files = 0; /* _just_ numbers */
743 int subject_prefix = 0;
744 int ignore_if_in_upstream = 0;
745 int thread = 0;
746 int cover_letter = 0;
747 int boundary_count = 0;
748 struct commit *origin = NULL, *head = NULL;
749 const char *in_reply_to = NULL;
750 struct patch_ids ids;
751 char *add_signoff = NULL;
752 struct strbuf buf;
753
754 git_config(git_format_config);
755 init_revisions(&rev, prefix);
756 rev.commit_format = CMIT_FMT_EMAIL;
757 rev.verbose_header = 1;
758 rev.diff = 1;
759 rev.combine_merges = 0;
760 rev.ignore_merges = 1;
761 rev.diffopt.msg_sep = "";
762 DIFF_OPT_SET(&rev.diffopt, RECURSIVE);
763
764 rev.subject_prefix = fmt_patch_subject_prefix;
765
766 /*
767 * Parse the arguments before setup_revisions(), or something
768 * like "git format-patch -o a123 HEAD^.." may fail; a123 is
769 * possibly a valid SHA1.
770 */
771 for (i = 1, j = 1; i < argc; i++) {
772 if (!strcmp(argv[i], "--stdout"))
773 use_stdout = 1;
774 else if (!strcmp(argv[i], "-n") ||
775 !strcmp(argv[i], "--numbered"))
776 numbered = 1;
777 else if (!strcmp(argv[i], "-N") ||
778 !strcmp(argv[i], "--no-numbered")) {
779 numbered = 0;
780 auto_number = 0;
781 }
782 else if (!prefixcmp(argv[i], "--start-number="))
783 start_number = strtol(argv[i] + 15, NULL, 10);
784 else if (!strcmp(argv[i], "--numbered-files"))
785 numbered_files = 1;
786 else if (!strcmp(argv[i], "--start-number")) {
787 i++;
788 if (i == argc)
789 die("Need a number for --start-number");
790 start_number = strtol(argv[i], NULL, 10);
791 }
792 else if (!prefixcmp(argv[i], "--cc=")) {
793 ALLOC_GROW(extra_cc, extra_cc_nr + 1, extra_cc_alloc);
794 extra_cc[extra_cc_nr++] = xstrdup(argv[i] + 5);
795 }
796 else if (!strcmp(argv[i], "-k") ||
797 !strcmp(argv[i], "--keep-subject")) {
798 keep_subject = 1;
799 rev.total = -1;
800 }
801 else if (!strcmp(argv[i], "--output-directory") ||
802 !strcmp(argv[i], "-o")) {
803 i++;
804 if (argc <= i)
805 die("Which directory?");
806 if (output_directory)
807 die("Two output directories?");
808 output_directory = argv[i];
809 }
810 else if (!strcmp(argv[i], "--signoff") ||
811 !strcmp(argv[i], "-s")) {
812 const char *committer;
813 const char *endpos;
814 committer = git_committer_info(IDENT_ERROR_ON_NO_NAME);
815 endpos = strchr(committer, '>');
816 if (!endpos)
817 die("bogos committer info %s\n", committer);
818 add_signoff = xmemdupz(committer, endpos - committer + 1);
819 }
820 else if (!strcmp(argv[i], "--attach")) {
821 rev.mime_boundary = git_version_string;
822 rev.no_inline = 1;
823 }
824 else if (!prefixcmp(argv[i], "--attach=")) {
825 rev.mime_boundary = argv[i] + 9;
826 rev.no_inline = 1;
827 }
828 else if (!strcmp(argv[i], "--inline")) {
829 rev.mime_boundary = git_version_string;
830 rev.no_inline = 0;
831 }
832 else if (!prefixcmp(argv[i], "--inline=")) {
833 rev.mime_boundary = argv[i] + 9;
834 rev.no_inline = 0;
835 }
836 else if (!strcmp(argv[i], "--ignore-if-in-upstream"))
837 ignore_if_in_upstream = 1;
838 else if (!strcmp(argv[i], "--thread"))
839 thread = 1;
840 else if (!prefixcmp(argv[i], "--in-reply-to="))
841 in_reply_to = argv[i] + 14;
842 else if (!strcmp(argv[i], "--in-reply-to")) {
843 i++;
844 if (i == argc)
845 die("Need a Message-Id for --in-reply-to");
846 in_reply_to = argv[i];
847 } else if (!prefixcmp(argv[i], "--subject-prefix=")) {
848 subject_prefix = 1;
849 rev.subject_prefix = argv[i] + 17;
850 } else if (!prefixcmp(argv[i], "--suffix="))
851 fmt_patch_suffix = argv[i] + 9;
852 else if (!strcmp(argv[i], "--cover-letter"))
853 cover_letter = 1;
854 else
855 argv[j++] = argv[i];
856 }
857 argc = j;
858
859 strbuf_init(&buf, 0);
860
861 for (i = 0; i < extra_hdr_nr; i++) {
862 strbuf_addstr(&buf, extra_hdr[i]);
863 strbuf_addch(&buf, '\n');
864 }
865
866 if (extra_to_nr)
867 strbuf_addstr(&buf, "To: ");
868 for (i = 0; i < extra_to_nr; i++) {
869 if (i)
870 strbuf_addstr(&buf, " ");
871 strbuf_addstr(&buf, extra_to[i]);
872 if (i + 1 < extra_to_nr)
873 strbuf_addch(&buf, ',');
874 strbuf_addch(&buf, '\n');
875 }
876
877 if (extra_cc_nr)
878 strbuf_addstr(&buf, "Cc: ");
879 for (i = 0; i < extra_cc_nr; i++) {
880 if (i)
881 strbuf_addstr(&buf, " ");
882 strbuf_addstr(&buf, extra_cc[i]);
883 if (i + 1 < extra_cc_nr)
884 strbuf_addch(&buf, ',');
885 strbuf_addch(&buf, '\n');
886 }
887
888 rev.extra_headers = strbuf_detach(&buf, 0);
889
890 if (start_number < 0)
891 start_number = 1;
892 if (numbered && keep_subject)
893 die ("-n and -k are mutually exclusive.");
894 if (keep_subject && subject_prefix)
895 die ("--subject-prefix and -k are mutually exclusive.");
896 if (numbered_files && use_stdout)
897 die ("--numbered-files and --stdout are mutually exclusive.");
898
899 argc = setup_revisions(argc, argv, &rev, "HEAD");
900 if (argc > 1)
901 die ("unrecognized argument: %s", argv[1]);
902
903 if (!rev.diffopt.output_format)
904 rev.diffopt.output_format = DIFF_FORMAT_DIFFSTAT | DIFF_FORMAT_SUMMARY | DIFF_FORMAT_PATCH;
905
906 if (!DIFF_OPT_TST(&rev.diffopt, TEXT))
907 DIFF_OPT_SET(&rev.diffopt, BINARY);
908
909 if (!output_directory && !use_stdout)
910 output_directory = prefix;
911
912 if (output_directory) {
913 if (use_stdout)
914 die("standard output, or directory, which one?");
915 if (mkdir(output_directory, 0777) < 0 && errno != EEXIST)
916 die("Could not create directory %s",
917 output_directory);
918 }
919
920 if (rev.pending.nr == 1) {
921 if (rev.max_count < 0 && !rev.show_root_diff) {
922 /*
923 * This is traditional behaviour of "git format-patch
924 * origin" that prepares what the origin side still
925 * does not have.
926 */
927 rev.pending.objects[0].item->flags |= UNINTERESTING;
928 add_head_to_pending(&rev);
929 }
930 /*
931 * Otherwise, it is "format-patch -22 HEAD", and/or
932 * "format-patch --root HEAD". The user wants
933 * get_revision() to do the usual traversal.
934 */
935 }
936 if (cover_letter) {
937 /* remember the range */
938 int i;
939 for (i = 0; i < rev.pending.nr; i++) {
940 struct object *o = rev.pending.objects[i].item;
941 if (!(o->flags & UNINTERESTING))
942 head = (struct commit *)o;
943 }
944 /* We can't generate a cover letter without any patches */
945 if (!head)
946 return 0;
947 }
948
949 if (ignore_if_in_upstream)
950 get_patch_ids(&rev, &ids, prefix);
951
952 if (!use_stdout)
953 realstdout = xfdopen(xdup(1), "w");
954
955 if (prepare_revision_walk(&rev))
956 die("revision walk setup failed");
957 rev.boundary = 1;
958 while ((commit = get_revision(&rev)) != NULL) {
959 if (commit->object.flags & BOUNDARY) {
960 boundary_count++;
961 origin = (boundary_count == 1) ? commit : NULL;
962 continue;
963 }
964
965 /* ignore merges */
966 if (commit->parents && commit->parents->next)
967 continue;
968
969 if (ignore_if_in_upstream &&
970 has_commit_patch_id(commit, &ids))
971 continue;
972
973 nr++;
974 list = xrealloc(list, nr * sizeof(list[0]));
975 list[nr - 1] = commit;
976 }
977 total = nr;
978 if (!keep_subject && auto_number && total > 1)
979 numbered = 1;
980 if (numbered)
981 rev.total = total + start_number - 1;
982 if (in_reply_to)
983 rev.ref_message_id = clean_message_id(in_reply_to);
984 if (cover_letter) {
985 if (thread)
986 gen_message_id(&rev, "cover");
987 make_cover_letter(&rev, use_stdout, numbered, numbered_files,
988 origin, nr, list, head);
989 total++;
990 start_number--;
991 }
992 rev.add_signoff = add_signoff;
993 while (0 <= --nr) {
994 int shown;
995 commit = list[nr];
996 rev.nr = total - nr + (start_number - 1);
997 /* Make the second and subsequent mails replies to the first */
998 if (thread) {
999 /* Have we already had a message ID? */
1000 if (rev.message_id) {
1001 /*
1002 * If we've got the ID to be a reply
1003 * to, discard the current ID;
1004 * otherwise, make everything a reply
1005 * to that.
1006 */
1007 if (rev.ref_message_id)
1008 free(rev.message_id);
1009 else
1010 rev.ref_message_id = rev.message_id;
1011 }
1012 gen_message_id(&rev, sha1_to_hex(commit->object.sha1));
1013 }
1014 if (!use_stdout && reopen_stdout(numbered_files ? NULL :
1015 get_oneline_for_filename(commit, keep_subject),
1016 rev.nr, rev.total))
1017 die("Failed to create output files");
1018 shown = log_tree_commit(&rev, commit);
1019 free(commit->buffer);
1020 commit->buffer = NULL;
1021
1022 /* We put one extra blank line between formatted
1023 * patches and this flag is used by log-tree code
1024 * to see if it needs to emit a LF before showing
1025 * the log; when using one file per patch, we do
1026 * not want the extra blank line.
1027 */
1028 if (!use_stdout)
1029 rev.shown_one = 0;
1030 if (shown) {
1031 if (rev.mime_boundary)
1032 printf("\n--%s%s--\n\n\n",
1033 mime_boundary_leader,
1034 rev.mime_boundary);
1035 else
1036 printf("-- \n%s\n\n", git_version_string);
1037 }
1038 if (!use_stdout)
1039 fclose(stdout);
1040 }
1041 free(list);
1042 if (ignore_if_in_upstream)
1043 free_patch_ids(&ids);
1044 return 0;
1045 }
1046
1047 static int add_pending_commit(const char *arg, struct rev_info *revs, int flags)
1048 {
1049 unsigned char sha1[20];
1050 if (get_sha1(arg, sha1) == 0) {
1051 struct commit *commit = lookup_commit_reference(sha1);
1052 if (commit) {
1053 commit->object.flags |= flags;
1054 add_pending_object(revs, &commit->object, arg);
1055 return 0;
1056 }
1057 }
1058 return -1;
1059 }
1060
1061 static const char cherry_usage[] =
1062 "git-cherry [-v] <upstream> [<head>] [<limit>]";
1063 int cmd_cherry(int argc, const char **argv, const char *prefix)
1064 {
1065 struct rev_info revs;
1066 struct patch_ids ids;
1067 struct commit *commit;
1068 struct commit_list *list = NULL;
1069 const char *upstream;
1070 const char *head = "HEAD";
1071 const char *limit = NULL;
1072 int verbose = 0;
1073
1074 if (argc > 1 && !strcmp(argv[1], "-v")) {
1075 verbose = 1;
1076 argc--;
1077 argv++;
1078 }
1079
1080 switch (argc) {
1081 case 4:
1082 limit = argv[3];
1083 /* FALLTHROUGH */
1084 case 3:
1085 head = argv[2];
1086 /* FALLTHROUGH */
1087 case 2:
1088 upstream = argv[1];
1089 break;
1090 default:
1091 usage(cherry_usage);
1092 }
1093
1094 init_revisions(&revs, prefix);
1095 revs.diff = 1;
1096 revs.combine_merges = 0;
1097 revs.ignore_merges = 1;
1098 DIFF_OPT_SET(&revs.diffopt, RECURSIVE);
1099
1100 if (add_pending_commit(head, &revs, 0))
1101 die("Unknown commit %s", head);
1102 if (add_pending_commit(upstream, &revs, UNINTERESTING))
1103 die("Unknown commit %s", upstream);
1104
1105 /* Don't say anything if head and upstream are the same. */
1106 if (revs.pending.nr == 2) {
1107 struct object_array_entry *o = revs.pending.objects;
1108 if (hashcmp(o[0].item->sha1, o[1].item->sha1) == 0)
1109 return 0;
1110 }
1111
1112 get_patch_ids(&revs, &ids, prefix);
1113
1114 if (limit && add_pending_commit(limit, &revs, UNINTERESTING))
1115 die("Unknown commit %s", limit);
1116
1117 /* reverse the list of commits */
1118 if (prepare_revision_walk(&revs))
1119 die("revision walk setup failed");
1120 while ((commit = get_revision(&revs)) != NULL) {
1121 /* ignore merges */
1122 if (commit->parents && commit->parents->next)
1123 continue;
1124
1125 commit_list_insert(commit, &list);
1126 }
1127
1128 while (list) {
1129 char sign = '+';
1130
1131 commit = list->item;
1132 if (has_commit_patch_id(commit, &ids))
1133 sign = '-';
1134
1135 if (verbose) {
1136 struct strbuf buf;
1137 strbuf_init(&buf, 0);
1138 pretty_print_commit(CMIT_FMT_ONELINE, commit,
1139 &buf, 0, NULL, NULL, 0, 0);
1140 printf("%c %s %s\n", sign,
1141 sha1_to_hex(commit->object.sha1), buf.buf);
1142 strbuf_release(&buf);
1143 }
1144 else {
1145 printf("%c %s\n", sign,
1146 sha1_to_hex(commit->object.sha1));
1147 }
1148
1149 list = list->next;
1150 }
1151
1152 free_patch_ids(&ids);
1153 return 0;
1154 }