branch: add read_branch_desc() helper function
[git/git.git] / builtin / log.c
CommitLineData
70827b15
LT
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"
6b2f2d98 8#include "color.h"
70827b15
LT
9#include "commit.h"
10#include "diff.h"
11#include "revision.h"
12#include "log-tree.h"
91efcf60 13#include "builtin.h"
5d7eeee2 14#include "tag.h"
cf39f54e 15#include "reflog-walk.h"
5d23e133 16#include "patch-ids.h"
a5a27c79 17#include "run-command.h"
2bda2cf4 18#include "shortlog.h"
f2968022 19#include "remote.h"
b079c50e 20#include "string-list.h"
fff02ee6 21#include "parse-options.h"
70827b15 22
dd0ffd5b
HO
23/* Set a default date-time format for git log ("log.date" config variable) */
24static const char *default_date_mode = NULL;
25
0c47695a 26static int default_abbrev_commit;
0f03ca94 27static int default_show_root = 1;
8a3d203b 28static int decoration_style;
1c40c36b 29static int decoration_given;
d54276f2 30static const char *fmt_patch_subject_prefix = "PATCH";
94c22a5e 31static const char *fmt_pretty;
0f03ca94 32
1c40c36b 33static const char * const builtin_log_usage[] = {
1c370ea4 34 "git log [<options>] [<since>..<until>] [[--] <path>...]\n"
1c40c36b
CMN
35 " or: git show [options] <object>...",
36 NULL
37};
1c370ea4 38
8a3d203b
JH
39static int parse_decoration_style(const char *var, const char *value)
40{
41 switch (git_config_maybe_bool(var, value)) {
42 case 1:
43 return DECORATE_SHORT_REFS;
44 case 0:
45 return 0;
46 default:
47 break;
48 }
49 if (!strcmp(value, "full"))
50 return DECORATE_FULL_REFS;
51 else if (!strcmp(value, "short"))
52 return DECORATE_SHORT_REFS;
53 return -1;
54}
55
1c40c36b
CMN
56static int decorate_callback(const struct option *opt, const char *arg, int unset)
57{
58 if (unset)
59 decoration_style = 0;
60 else if (arg)
61 decoration_style = parse_decoration_style("command line", arg);
62 else
63 decoration_style = DECORATE_SHORT_REFS;
64
65 if (decoration_style < 0)
66 die("invalid --decorate option: %s", arg);
67
68 decoration_given = 1;
69
70 return 0;
71}
72
ef803fd4 73static void cmd_log_init_defaults(struct rev_info *rev)
70827b15 74{
70827b15
LT
75 rev->abbrev = DEFAULT_ABBREV;
76 rev->commit_format = CMIT_FMT_DEFAULT;
94c22a5e 77 if (fmt_pretty)
4da45bef 78 get_commit_format(fmt_pretty, rev);
70827b15 79 rev->verbose_header = 1;
8f67f8ae 80 DIFF_OPT_SET(&rev->diffopt, RECURSIVE);
0c47695a 81 rev->abbrev_commit = default_abbrev_commit;
0f03ca94 82 rev->show_root_diff = default_show_root;
d54276f2 83 rev->subject_prefix = fmt_patch_subject_prefix;
5ec11af6 84 DIFF_OPT_SET(&rev->diffopt, ALLOW_TEXTCONV);
dd0ffd5b
HO
85
86 if (default_date_mode)
87 rev->date_mode = parse_date_format(default_date_mode);
ef803fd4 88}
dd0ffd5b 89
ef803fd4
MG
90static void cmd_log_init_finish(int argc, const char **argv, const char *prefix,
91 struct rev_info *rev, struct setup_revision_opt *opt)
92{
ef803fd4 93 struct userformat_want w;
1c40c36b
CMN
94 int quiet = 0, source = 0;
95
96 const struct option builtin_log_options[] = {
f0f90e34 97 OPT_BOOLEAN(0, "quiet", &quiet, "suppress diff output"),
1c40c36b
CMN
98 OPT_BOOLEAN(0, "source", &source, "show source"),
99 { OPTION_CALLBACK, 0, "decorate", NULL, NULL, "decorate options",
100 PARSE_OPT_OPTARG, decorate_callback},
101 OPT_END()
102 };
103
104 argc = parse_options(argc, argv, prefix,
105 builtin_log_options, builtin_log_usage,
106 PARSE_OPT_KEEP_ARGV0 | PARSE_OPT_KEEP_UNKNOWN |
107 PARSE_OPT_KEEP_DASHDASH);
52883fbd 108
32962c9b 109 argc = setup_revisions(argc, argv, rev, opt);
01771a8e
JH
110 if (quiet)
111 rev->diffopt.output_format |= DIFF_FORMAT_NO_OUTPUT;
dd0ffd5b 112
1c40c36b
CMN
113 /* Any arguments at this point are not recognized */
114 if (argc > 1)
115 die("unrecognized argument: %s", argv[1]);
116
5b163603
JG
117 memset(&w, 0, sizeof(w));
118 userformat_find_requirements(NULL, &w);
119
120 if (!rev->show_notes_given && (!rev->pretty_given || w.notes))
66b2ed09 121 rev->show_notes = 1;
894a9d33
TR
122 if (rev->show_notes)
123 init_display_notes(&rev->notes_opt);
66b2ed09 124
9dafea26
TH
125 if (rev->diffopt.pickaxe || rev->diffopt.filter)
126 rev->always_show_header = 0;
8f67f8ae 127 if (DIFF_OPT_TST(&rev->diffopt, FOLLOW_RENAMES)) {
750f7b66 128 rev->always_show_header = 0;
66f13625 129 if (rev->diffopt.pathspec.nr != 1)
750f7b66
LT
130 usage("git logs can only follow renames on one pathname at a time");
131 }
1c40c36b
CMN
132
133 if (source)
134 rev->show_source = 1;
635530a2 135
0c47695a
JS
136 if (rev->pretty_given && rev->commit_format == CMIT_FMT_RAW) {
137 /*
138 * "log --pretty=raw" is special; ignore UI oriented
139 * configuration variables such as decoration.
140 */
141 if (!decoration_given)
142 decoration_style = 0;
143 if (!rev->abbrev_commit_given)
144 rev->abbrev_commit = 0;
145 }
635530a2 146
33e7018c
LH
147 if (decoration_style) {
148 rev->show_decorations = 1;
149 load_ref_decorations(decoration_style);
150 }
1fda91b5 151 setup_pager();
9dafea26
TH
152}
153
ef803fd4
MG
154static void cmd_log_init(int argc, const char **argv, const char *prefix,
155 struct rev_info *rev, struct setup_revision_opt *opt)
156{
157 cmd_log_init_defaults(rev);
158 cmd_log_init_finish(argc, argv, prefix, rev, opt);
159}
160
252a7c02
LT
161/*
162 * This gives a rough estimate for how many commits we
163 * will print out in the list.
164 */
165static int estimate_commit_count(struct rev_info *rev, struct commit_list *list)
166{
167 int n = 0;
168
169 while (list) {
170 struct commit *commit = list->item;
171 unsigned int flags = commit->object.flags;
252a7c02 172 list = list->next;
7dc0fe3b 173 if (!(flags & (TREESAME | UNINTERESTING)))
53b2c823 174 n++;
252a7c02
LT
175 }
176 return n;
177}
178
179static void show_early_header(struct rev_info *rev, const char *stage, int nr)
180{
181 if (rev->shown_one) {
182 rev->shown_one = 0;
183 if (rev->commit_format != CMIT_FMT_ONELINE)
184 putchar(rev->diffopt.line_termination);
185 }
5c5f1d7c 186 printf(_("Final output: %d %s\n"), nr, stage);
252a7c02
LT
187}
188
2af202be 189static struct itimerval early_output_timer;
252a7c02 190
cdcefbc9
LT
191static void log_show_early(struct rev_info *revs, struct commit_list *list)
192{
193 int i = revs->early_output;
252a7c02 194 int show_header = 1;
cdcefbc9
LT
195
196 sort_in_topological_order(&list, revs->lifo);
197 while (list && i) {
198 struct commit *commit = list->item;
252a7c02
LT
199 switch (simplify_commit(revs, commit)) {
200 case commit_show:
201 if (show_header) {
202 int n = estimate_commit_count(revs, list);
203 show_early_header(revs, "incomplete", n);
204 show_header = 0;
205 }
206 log_tree_commit(revs, commit);
207 i--;
208 break;
209 case commit_ignore:
210 break;
211 case commit_error:
212 return;
213 }
cdcefbc9 214 list = list->next;
cdcefbc9 215 }
252a7c02
LT
216
217 /* Did we already get enough commits for the early output? */
218 if (!i)
219 return;
220
221 /*
222 * ..if no, then repeat it twice a second until we
223 * do.
224 *
225 * NOTE! We don't use "it_interval", because if the
226 * reader isn't listening, we want our output to be
227 * throttled by the writing, and not have the timer
228 * trigger every second even if we're blocked on a
229 * reader!
230 */
231 early_output_timer.it_value.tv_sec = 0;
232 early_output_timer.it_value.tv_usec = 500000;
233 setitimer(ITIMER_REAL, &early_output_timer, NULL);
cdcefbc9
LT
234}
235
236static void early_output(int signal)
237{
238 show_early_output = log_show_early;
239}
240
241static void setup_early_output(struct rev_info *rev)
242{
243 struct sigaction sa;
cdcefbc9
LT
244
245 /*
246 * Set up the signal handler, minimally intrusively:
247 * we only set a single volatile integer word (not
248 * using sigatomic_t - trying to avoid unnecessary
249 * system dependencies and headers), and using
250 * SA_RESTART.
251 */
252 memset(&sa, 0, sizeof(sa));
253 sa.sa_handler = early_output;
254 sigemptyset(&sa.sa_mask);
255 sa.sa_flags = SA_RESTART;
256 sigaction(SIGALRM, &sa, NULL);
257
258 /*
259 * If we can get the whole output in less than a
260 * tenth of a second, don't even bother doing the
261 * early-output thing..
262 *
263 * This is a one-time-only trigger.
264 */
252a7c02
LT
265 early_output_timer.it_value.tv_sec = 0;
266 early_output_timer.it_value.tv_usec = 100000;
267 setitimer(ITIMER_REAL, &early_output_timer, NULL);
cdcefbc9
LT
268}
269
270static void finish_early_output(struct rev_info *rev)
271{
252a7c02 272 int n = estimate_commit_count(rev, rev->commits);
cdcefbc9 273 signal(SIGALRM, SIG_IGN);
252a7c02 274 show_early_header(rev, "done", n);
cdcefbc9
LT
275}
276
9dafea26
TH
277static int cmd_log_walk(struct rev_info *rev)
278{
279 struct commit *commit;
f31027c9
JH
280 int saved_nrl = 0;
281 int saved_dcctc = 0;
70827b15 282
cdcefbc9
LT
283 if (rev->early_output)
284 setup_early_output(rev);
285
3d51e1b5 286 if (prepare_revision_walk(rev))
5c5f1d7c 287 die(_("revision walk setup failed"));
cdcefbc9
LT
288
289 if (rev->early_output)
290 finish_early_output(rev);
291
036d17fe 292 /*
84102a33
PVM
293 * For --check and --exit-code, the exit code is based on CHECK_FAILED
294 * and HAS_CHANGES being accumulated in rev->diffopt, so be careful to
295 * retain that state information if replacing rev->diffopt in this loop
036d17fe 296 */
70827b15 297 while ((commit = get_revision(rev)) != NULL) {
251df09b
MM
298 if (!log_tree_commit(rev, commit) &&
299 rev->max_count >= 0)
300 /*
301 * We decremented max_count in get_revision,
302 * but we didn't actually show the commit.
303 */
304 rev->max_count++;
a6c73064
JS
305 if (!rev->reflog_info) {
306 /* we allow cycles in reflog ancestry */
307 free(commit->buffer);
308 commit->buffer = NULL;
309 }
cb115748
LT
310 free_commit_list(commit->parents);
311 commit->parents = NULL;
f31027c9
JH
312 if (saved_nrl < rev->diffopt.needed_rename_limit)
313 saved_nrl = rev->diffopt.needed_rename_limit;
314 if (rev->diffopt.degraded_cc_to_c)
315 saved_dcctc = 1;
70827b15 316 }
f31027c9
JH
317 rev->diffopt.degraded_cc_to_c = saved_dcctc;
318 rev->diffopt.needed_rename_limit = saved_nrl;
319
036d17fe
PVM
320 if (rev->diffopt.output_format & DIFF_FORMAT_CHECKDIFF &&
321 DIFF_OPT_TST(&rev->diffopt, CHECK_FAILED)) {
322 return 02;
323 }
84102a33 324 return diff_result_code(&rev->diffopt, 0);
70827b15
LT
325}
326
ef90d6d4 327static int git_log_config(const char *var, const char *value, void *cb)
0f03ca94 328{
94c22a5e
CR
329 if (!strcmp(var, "format.pretty"))
330 return git_config_string(&fmt_pretty, var, value);
70cff3ac
BH
331 if (!strcmp(var, "format.subjectprefix"))
332 return git_config_string(&fmt_patch_subject_prefix, var, value);
0c47695a
JS
333 if (!strcmp(var, "log.abbrevcommit")) {
334 default_abbrev_commit = git_config_bool(var, value);
335 return 0;
336 }
dd0ffd5b
HO
337 if (!strcmp(var, "log.date"))
338 return git_config_string(&default_date_mode, var, value);
eb734454 339 if (!strcmp(var, "log.decorate")) {
8a3d203b
JH
340 decoration_style = parse_decoration_style(var, value);
341 if (decoration_style < 0)
342 decoration_style = 0; /* maybe warn? */
eb734454
SD
343 return 0;
344 }
0f03ca94
PB
345 if (!strcmp(var, "log.showroot")) {
346 default_show_root = git_config_bool(var, value);
347 return 0;
348 }
5e11bee6
NR
349 if (!prefixcmp(var, "color.decorate."))
350 return parse_decorate_color_config(var, 15, value);
351
ef90d6d4 352 return git_diff_ui_config(var, value, cb);
0f03ca94
PB
353}
354
a633fca0 355int cmd_whatchanged(int argc, const char **argv, const char *prefix)
70827b15
LT
356{
357 struct rev_info rev;
32962c9b 358 struct setup_revision_opt opt;
70827b15 359
ef90d6d4 360 git_config(git_log_config, NULL);
6b2f2d98 361
db6296a5 362 init_revisions(&rev, prefix);
70827b15 363 rev.diff = 1;
9202434c 364 rev.simplify_history = 0;
32962c9b
JH
365 memset(&opt, 0, sizeof(opt));
366 opt.def = "HEAD";
367 cmd_log_init(argc, argv, prefix, &rev, &opt);
9dafea26
TH
368 if (!rev.diffopt.output_format)
369 rev.diffopt.output_format = DIFF_FORMAT_RAW;
370 return cmd_log_walk(&rev);
70827b15
LT
371}
372
56122ed8
JS
373static void show_tagger(char *buf, int len, struct rev_info *rev)
374{
ea718e65 375 struct strbuf out = STRBUF_INIT;
6bf13944 376 struct pretty_print_context pp = {0};
56122ed8 377
6bf13944
JK
378 pp.fmt = rev->commit_format;
379 pp.date_mode = rev->date_mode;
380 pp_user_info(&pp, "Tagger", &out, buf, get_log_output_encoding());
ca4ca9ed 381 printf("%s", out.buf);
ea718e65 382 strbuf_release(&out);
56122ed8
JS
383}
384
385static int show_object(const unsigned char *sha1, int show_tag_object,
386 struct rev_info *rev)
5d7eeee2
JS
387{
388 unsigned long size;
21666f1a
NP
389 enum object_type type;
390 char *buf = read_sha1_file(sha1, &type, &size);
5d7eeee2
JS
391 int offset = 0;
392
393 if (!buf)
5c5f1d7c 394 return error(_("Could not read object %s"), sha1_to_hex(sha1));
5d7eeee2 395
56122ed8
JS
396 if (show_tag_object)
397 while (offset < size && buf[offset] != '\n') {
398 int new_offset = offset + 1;
5d7eeee2
JS
399 while (new_offset < size && buf[new_offset++] != '\n')
400 ; /* do nothing */
56122ed8
JS
401 if (!prefixcmp(buf + offset, "tagger "))
402 show_tagger(buf + offset + 7,
403 new_offset - offset - 7, rev);
5d7eeee2
JS
404 offset = new_offset;
405 }
406
407 if (offset < size)
408 fwrite(buf + offset, size - offset, 1, stdout);
409 free(buf);
410 return 0;
411}
412
413static int show_tree_object(const unsigned char *sha1,
414 const char *base, int baselen,
671f0707 415 const char *pathname, unsigned mode, int stage, void *context)
5d7eeee2
JS
416{
417 printf("%s%s\n", pathname, S_ISDIR(mode) ? "/" : "");
418 return 0;
419}
420
b4490059
JH
421static void show_rev_tweak_rev(struct rev_info *rev, struct setup_revision_opt *opt)
422{
2bf65873
JH
423 if (rev->ignore_merges) {
424 /* There was no "-m" on the command line */
425 rev->ignore_merges = 0;
426 if (!rev->first_parent_only && !rev->combine_merges) {
427 /* No "--first-parent", "-c", nor "--cc" */
428 rev->combine_merges = 1;
429 rev->dense_combined_merges = 1;
430 }
431 }
b4490059
JH
432 if (!rev->diffopt.output_format)
433 rev->diffopt.output_format = DIFF_FORMAT_PATCH;
434}
435
a633fca0 436int cmd_show(int argc, const char **argv, const char *prefix)
70827b15
LT
437{
438 struct rev_info rev;
5d7eeee2 439 struct object_array_entry *objects;
32962c9b 440 struct setup_revision_opt opt;
f0096c06 441 struct pathspec match_all;
5d7eeee2 442 int i, count, ret = 0;
70827b15 443
ef90d6d4 444 git_config(git_log_config, NULL);
6b2f2d98 445
f0096c06 446 init_pathspec(&match_all, NULL);
db6296a5 447 init_revisions(&rev, prefix);
70827b15 448 rev.diff = 1;
70827b15 449 rev.always_show_header = 1;
70827b15 450 rev.no_walk = 1;
32962c9b
JH
451 memset(&opt, 0, sizeof(opt));
452 opt.def = "HEAD";
b4490059 453 opt.tweak = show_rev_tweak_rev;
32962c9b 454 cmd_log_init(argc, argv, prefix, &rev, &opt);
5d7eeee2
JS
455
456 count = rev.pending.nr;
457 objects = rev.pending.objects;
458 for (i = 0; i < count && !ret; i++) {
459 struct object *o = objects[i].item;
460 const char *name = objects[i].name;
461 switch (o->type) {
462 case OBJ_BLOB:
56122ed8 463 ret = show_object(o->sha1, 0, NULL);
5d7eeee2
JS
464 break;
465 case OBJ_TAG: {
466 struct tag *t = (struct tag *)o;
467
ae03ee64
JK
468 if (rev.shown_one)
469 putchar('\n');
56122ed8 470 printf("%stag %s%s\n",
8f67f8ae 471 diff_get_color_opt(&rev.diffopt, DIFF_COMMIT),
5d7eeee2 472 t->tag,
8f67f8ae 473 diff_get_color_opt(&rev.diffopt, DIFF_RESET));
56122ed8 474 ret = show_object(o->sha1, 1, &rev);
ae03ee64 475 rev.shown_one = 1;
d2dadfe8
JH
476 if (ret)
477 break;
478 o = parse_object(t->tagged->sha1);
479 if (!o)
5c5f1d7c 480 ret = error(_("Could not read object %s"),
d2dadfe8
JH
481 sha1_to_hex(t->tagged->sha1));
482 objects[i].item = o;
5d7eeee2
JS
483 i--;
484 break;
485 }
486 case OBJ_TREE:
ae03ee64
JK
487 if (rev.shown_one)
488 putchar('\n');
5d7eeee2 489 printf("%stree %s%s\n\n",
8f67f8ae 490 diff_get_color_opt(&rev.diffopt, DIFF_COMMIT),
5d7eeee2 491 name,
8f67f8ae 492 diff_get_color_opt(&rev.diffopt, DIFF_RESET));
f0096c06 493 read_tree_recursive((struct tree *)o, "", 0, 0, &match_all,
671f0707 494 show_tree_object, NULL);
ae03ee64 495 rev.shown_one = 1;
5d7eeee2
JS
496 break;
497 case OBJ_COMMIT:
498 rev.pending.nr = rev.pending.alloc = 0;
499 rev.pending.objects = NULL;
500 add_object_array(o, name, &rev.pending);
501 ret = cmd_log_walk(&rev);
502 break;
503 default:
5c5f1d7c 504 ret = error(_("Unknown type: %d"), o->type);
5d7eeee2
JS
505 }
506 }
507 free(objects);
508 return ret;
70827b15
LT
509}
510
cf39f54e
LT
511/*
512 * This is equivalent to "git log -g --abbrev-commit --pretty=oneline"
513 */
514int cmd_log_reflog(int argc, const char **argv, const char *prefix)
515{
516 struct rev_info rev;
32962c9b 517 struct setup_revision_opt opt;
cf39f54e 518
ef90d6d4 519 git_config(git_log_config, NULL);
6b2f2d98 520
cf39f54e
LT
521 init_revisions(&rev, prefix);
522 init_reflog_walk(&rev.reflog_info);
cf39f54e 523 rev.verbose_header = 1;
32962c9b
JH
524 memset(&opt, 0, sizeof(opt));
525 opt.def = "HEAD";
4b56cf58 526 cmd_log_init_defaults(&rev);
0c47695a 527 rev.abbrev_commit = 1;
cf39f54e 528 rev.commit_format = CMIT_FMT_ONELINE;
4da45bef 529 rev.use_terminator = 1;
cf39f54e 530 rev.always_show_header = 1;
4b56cf58 531 cmd_log_init_finish(argc, argv, prefix, &rev, &opt);
cf39f54e 532
cf39f54e
LT
533 return cmd_log_walk(&rev);
534}
535
a633fca0 536int cmd_log(int argc, const char **argv, const char *prefix)
70827b15
LT
537{
538 struct rev_info rev;
32962c9b 539 struct setup_revision_opt opt;
70827b15 540
ef90d6d4 541 git_config(git_log_config, NULL);
6b2f2d98 542
db6296a5 543 init_revisions(&rev, prefix);
70827b15 544 rev.always_show_header = 1;
32962c9b
JH
545 memset(&opt, 0, sizeof(opt));
546 opt.def = "HEAD";
547 cmd_log_init(argc, argv, prefix, &rev, &opt);
9dafea26 548 return cmd_log_walk(&rev);
70827b15 549}
91efcf60 550
c06d2daa 551/* format-patch */
0377db77 552
917a8f89 553static const char *fmt_patch_suffix = ".patch";
49604a4d 554static int numbered = 0;
a567fdcb 555static int auto_number = 1;
20ff0680 556
0db5260b
JW
557static char *default_attach = NULL;
558
ca9e0a1b
SB
559static struct string_list extra_hdr;
560static struct string_list extra_to;
561static struct string_list extra_cc;
3ee79d9f
DB
562
563static void add_header(const char *value)
564{
ca9e0a1b 565 struct string_list_item *item;
3ee79d9f 566 int len = strlen(value);
c8c4450e 567 while (len && value[len - 1] == '\n')
3ee79d9f 568 len--;
ca9e0a1b 569
3ee79d9f 570 if (!strncasecmp(value, "to: ", 4)) {
1d2f80fa 571 item = string_list_append(&extra_to, value + 4);
ca9e0a1b
SB
572 len -= 4;
573 } else if (!strncasecmp(value, "cc: ", 4)) {
1d2f80fa 574 item = string_list_append(&extra_cc, value + 4);
ca9e0a1b
SB
575 len -= 4;
576 } else {
1d2f80fa 577 item = string_list_append(&extra_hdr, value);
3ee79d9f 578 }
ca9e0a1b
SB
579
580 item->string[len] = '\0';
3ee79d9f
DB
581}
582
30984ed2
TR
583#define THREAD_SHALLOW 1
584#define THREAD_DEEP 2
6622d9c7
SB
585static int thread;
586static int do_signoff;
587static const char *signature = git_version_string;
30984ed2 588
ef90d6d4 589static int git_format_config(const char *var, const char *value, void *cb)
20ff0680
JS
590{
591 if (!strcmp(var, "format.headers")) {
d7fb91c6 592 if (!value)
5c5f1d7c 593 die(_("format.headers without value"));
3ee79d9f 594 add_header(value);
20ff0680
JS
595 return 0;
596 }
70cff3ac
BH
597 if (!strcmp(var, "format.suffix"))
598 return git_config_string(&fmt_patch_suffix, var, value);
ae6c098f
SD
599 if (!strcmp(var, "format.to")) {
600 if (!value)
601 return config_error_nonbool(var);
1d2f80fa 602 string_list_append(&extra_to, value);
ae6c098f
SD
603 return 0;
604 }
fe8928e6
MV
605 if (!strcmp(var, "format.cc")) {
606 if (!value)
607 return config_error_nonbool(var);
1d2f80fa 608 string_list_append(&extra_cc, value);
fe8928e6
MV
609 return 0;
610 }
787570c7
PYH
611 if (!strcmp(var, "diff.color") || !strcmp(var, "color.diff") ||
612 !strcmp(var, "color.ui")) {
f3aafa4d
RA
613 return 0;
614 }
49604a4d 615 if (!strcmp(var, "format.numbered")) {
90f5c186 616 if (value && !strcasecmp(value, "auto")) {
49604a4d
BG
617 auto_number = 1;
618 return 0;
619 }
49604a4d 620 numbered = git_config_bool(var, value);
a567fdcb 621 auto_number = auto_number && numbered;
49604a4d
BG
622 return 0;
623 }
0db5260b
JW
624 if (!strcmp(var, "format.attach")) {
625 if (value && *value)
626 default_attach = xstrdup(value);
627 else
628 default_attach = xstrdup(git_version_string);
629 return 0;
630 }
30984ed2
TR
631 if (!strcmp(var, "format.thread")) {
632 if (value && !strcasecmp(value, "deep")) {
633 thread = THREAD_DEEP;
634 return 0;
635 }
636 if (value && !strcasecmp(value, "shallow")) {
637 thread = THREAD_SHALLOW;
638 return 0;
639 }
640 thread = git_config_bool(var, value) && THREAD_SHALLOW;
641 return 0;
642 }
1d1876e9
HV
643 if (!strcmp(var, "format.signoff")) {
644 do_signoff = git_config_bool(var, value);
645 return 0;
646 }
6622d9c7
SB
647 if (!strcmp(var, "format.signature"))
648 return git_config_string(&signature, var, value);
dbd21447 649
ef90d6d4 650 return git_log_config(var, value, cb);
20ff0680
JS
651}
652
81f3a188 653static FILE *realstdout = NULL;
efd02016 654static const char *output_directory = NULL;
9800a754 655static int outdir_offset;
81f3a188 656
250087f2 657static int reopen_stdout(struct commit *commit, struct rev_info *rev, int quiet)
0377db77 658{
cd2ef591 659 struct strbuf filename = STRBUF_INIT;
c06d2daa 660 int suffix_len = strlen(fmt_patch_suffix) + 1;
0377db77 661
2448482b 662 if (output_directory) {
cd2ef591
SB
663 strbuf_addstr(&filename, output_directory);
664 if (filename.len >=
665 PATH_MAX - FORMAT_PATCH_NAME_MAX - suffix_len)
5c5f1d7c 666 return error(_("name of output directory is too long"));
cd2ef591
SB
667 if (filename.buf[filename.len - 1] != '/')
668 strbuf_addch(&filename, '/');
2448482b 669 }
0377db77 670
cd2ef591 671 get_patch_filename(commit, rev->nr, fmt_patch_suffix, &filename);
e6ff0f42 672
250087f2 673 if (!quiet)
cd2ef591 674 fprintf(realstdout, "%s\n", filename.buf + outdir_offset);
ec2956df 675
cd2ef591 676 if (freopen(filename.buf, "w", stdout) == NULL)
5c5f1d7c 677 return error(_("Cannot open patch file %s"), filename.buf);
c06d2daa 678
cd2ef591 679 strbuf_release(&filename);
e6ff0f42 680 return 0;
0377db77
JS
681}
682
5d23e133 683static void get_patch_ids(struct rev_info *rev, struct patch_ids *ids, const char *prefix)
9c6efa36
JS
684{
685 struct rev_info check_rev;
686 struct commit *commit;
687 struct object *o1, *o2;
688 unsigned flags1, flags2;
9c6efa36
JS
689
690 if (rev->pending.nr != 2)
5c5f1d7c 691 die(_("Need exactly one range."));
9c6efa36
JS
692
693 o1 = rev->pending.objects[0].item;
694 flags1 = o1->flags;
695 o2 = rev->pending.objects[1].item;
696 flags2 = o2->flags;
697
698 if ((flags1 & UNINTERESTING) == (flags2 & UNINTERESTING))
5c5f1d7c 699 die(_("Not a range."));
9c6efa36 700
5d23e133 701 init_patch_ids(ids);
9c6efa36
JS
702
703 /* given a range a..b get all patch ids for b..a */
db6296a5 704 init_revisions(&check_rev, prefix);
9c6efa36
JS
705 o1->flags ^= UNINTERESTING;
706 o2->flags ^= UNINTERESTING;
707 add_pending_object(&check_rev, o1, "o1");
708 add_pending_object(&check_rev, o2, "o2");
3d51e1b5 709 if (prepare_revision_walk(&check_rev))
5c5f1d7c 710 die(_("revision walk setup failed"));
9c6efa36
JS
711
712 while ((commit = get_revision(&check_rev)) != NULL) {
713 /* ignore merges */
714 if (commit->parents && commit->parents->next)
715 continue;
716
5d23e133 717 add_commit_patch_id(commit, ids);
9c6efa36
JS
718 }
719
720 /* reset for next revision walk */
81db0941
JS
721 clear_commit_marks((struct commit *)o1,
722 SEEN | UNINTERESTING | SHOWN | ADDED);
723 clear_commit_marks((struct commit *)o2,
724 SEEN | UNINTERESTING | SHOWN | ADDED);
9c6efa36
JS
725 o1->flags = flags1;
726 o2->flags = flags2;
727}
728
e1a37346 729static void gen_message_id(struct rev_info *info, char *base)
d1566f78 730{
774751a8 731 const char *committer = git_committer_info(IDENT_WARN_ON_NO_NAME);
d1566f78
JT
732 const char *email_start = strrchr(committer, '<');
733 const char *email_end = strrchr(committer, '>');
f285a2d7 734 struct strbuf buf = STRBUF_INIT;
e1a37346 735 if (!email_start || !email_end || email_start > email_end - 1)
5c5f1d7c 736 die(_("Could not extract email from committer identity."));
e1a37346
DB
737 strbuf_addf(&buf, "%s.%lu.git.%.*s", base,
738 (unsigned long) time(NULL),
739 (int)(email_end - email_start - 1), email_start + 1);
740 info->message_id = strbuf_detach(&buf, NULL);
d1566f78
JT
741}
742
6622d9c7
SB
743static void print_signature(void)
744{
745 if (signature && *signature)
746 printf("-- \n%s\n\n", signature);
747}
748
2bda2cf4
DB
749static void make_cover_letter(struct rev_info *rev, int use_stdout,
750 int numbered, int numbered_files,
751 struct commit *origin,
250087f2
CMN
752 int nr, struct commit **list, struct commit *head,
753 int quiet)
a5a27c79
DB
754{
755 const char *committer;
a5a27c79
DB
756 const char *body = "*** SUBJECT HERE ***\n\n*** BLURB HERE ***\n";
757 const char *msg;
2bda2cf4 758 struct shortlog log;
f285a2d7 759 struct strbuf sb = STRBUF_INIT;
2bda2cf4 760 int i;
330db18c 761 const char *encoding = "UTF-8";
39fe578b 762 struct diff_options opts;
267123b4 763 int need_8bit_cte = 0;
cd2ef591 764 struct commit *commit = NULL;
6bf13944 765 struct pretty_print_context pp = {0};
a5a27c79
DB
766
767 if (rev->commit_format != CMIT_FMT_EMAIL)
5c5f1d7c 768 die(_("Cover letter needs email format"));
a5a27c79 769
cd2ef591 770 committer = git_committer_info(0);
6df514af 771
cd2ef591
SB
772 if (!numbered_files) {
773 /*
774 * We fake a commit for the cover letter so we get the filename
775 * desired.
776 */
777 commit = xcalloc(1, sizeof(*commit));
778 commit->buffer = xmalloc(400);
779 snprintf(commit->buffer, 400,
780 "tree 0000000000000000000000000000000000000000\n"
781 "parent %s\n"
782 "author %s\n"
783 "committer %s\n\n"
784 "cover letter\n",
108dab28 785 sha1_to_hex(head->object.sha1), committer, committer);
cd2ef591
SB
786 }
787
250087f2 788 if (!use_stdout && reopen_stdout(commit, rev, quiet))
a5a27c79
DB
789 return;
790
cd2ef591 791 if (commit) {
a5a27c79 792
cd2ef591
SB
793 free(commit->buffer);
794 free(commit);
795 }
a5a27c79 796
6bf13944 797 log_write_email_headers(rev, head, &pp.subject, &pp.after_subject,
267123b4 798 &need_8bit_cte);
a5a27c79 799
0a7f4483
JS
800 for (i = 0; !need_8bit_cte && i < nr; i++)
801 if (has_non_ascii(list[i]->buffer))
802 need_8bit_cte = 1;
803
a5a27c79 804 msg = body;
6bf13944
JK
805 pp.fmt = CMIT_FMT_EMAIL;
806 pp.date_mode = DATE_RFC2822;
807 pp_user_info(&pp, NULL, &sb, committer, encoding);
808 pp_title_line(&pp, &msg, &sb, encoding, need_8bit_cte);
809 pp_remainder(&pp, &msg, &sb, 0);
a5a27c79
DB
810 printf("%s\n", sb.buf);
811
812 strbuf_release(&sb);
813
2bda2cf4 814 shortlog_init(&log);
859c4fbe
JS
815 log.wrap_lines = 1;
816 log.wrap = 72;
817 log.in1 = 2;
818 log.in2 = 4;
2bda2cf4
DB
819 for (i = 0; i < nr; i++)
820 shortlog_add_commit(&log, list[i]);
821
822 shortlog_output(&log);
823
a5a27c79 824 /*
2bda2cf4 825 * We can only do diffstat with a unique reference point
a5a27c79
DB
826 */
827 if (!origin)
828 return;
829
5d02294c
JS
830 memcpy(&opts, &rev->diffopt, sizeof(opts));
831 opts.output_format = DIFF_FORMAT_SUMMARY | DIFF_FORMAT_DIFFSTAT;
a5a27c79 832
39fe578b
DB
833 diff_setup_done(&opts);
834
835 diff_tree_sha1(origin->tree->object.sha1,
836 head->tree->object.sha1,
837 "", &opts);
838 diffcore_std(&opts);
839 diff_flush(&opts);
a5a27c79 840
a5a27c79 841 printf("\n");
6622d9c7 842 print_signature();
d1566f78
JT
843}
844
8419d2ee
JH
845static const char *clean_message_id(const char *msg_id)
846{
847 char ch;
848 const char *a, *z, *m;
8419d2ee
JH
849
850 m = msg_id;
851 while ((ch = *m) && (isspace(ch) || (ch == '<')))
852 m++;
853 a = m;
854 z = NULL;
855 while ((ch = *m)) {
856 if (!isspace(ch) && (ch != '>'))
857 z = m;
858 m++;
859 }
860 if (!z)
5c5f1d7c 861 die(_("insane in-reply-to: %s"), msg_id);
8419d2ee
JH
862 if (++z == m)
863 return a;
182af834 864 return xmemdupz(a, z - a);
8419d2ee
JH
865}
866
9800a754
JH
867static const char *set_outdir(const char *prefix, const char *output_directory)
868{
869 if (output_directory && is_absolute_path(output_directory))
870 return output_directory;
871
872 if (!prefix || !*prefix) {
873 if (output_directory)
874 return output_directory;
875 /* The user did not explicitly ask for "./" */
876 outdir_offset = 2;
877 return "./";
878 }
879
880 outdir_offset = strlen(prefix);
881 if (!output_directory)
882 return prefix;
883
884 return xstrdup(prefix_filename(prefix, outdir_offset,
885 output_directory));
886}
887
fff02ee6
SB
888static const char * const builtin_format_patch_usage[] = {
889 "git format-patch [options] [<since> | <revision range>]",
890 NULL
891};
892
893static int keep_subject = 0;
894
895static int keep_callback(const struct option *opt, const char *arg, int unset)
896{
897 ((struct rev_info *)opt->value)->total = -1;
898 keep_subject = 1;
899 return 0;
900}
901
902static int subject_prefix = 0;
903
904static int subject_prefix_callback(const struct option *opt, const char *arg,
905 int unset)
906{
907 subject_prefix = 1;
908 ((struct rev_info *)opt->value)->subject_prefix = arg;
909 return 0;
910}
911
1af4731b
JH
912static int numbered_cmdline_opt = 0;
913
fff02ee6
SB
914static int numbered_callback(const struct option *opt, const char *arg,
915 int unset)
916{
1af4731b 917 *(int *)opt->value = numbered_cmdline_opt = unset ? 0 : 1;
fff02ee6
SB
918 if (unset)
919 auto_number = 0;
920 return 0;
921}
922
923static int no_numbered_callback(const struct option *opt, const char *arg,
924 int unset)
925{
926 return numbered_callback(opt, arg, 1);
927}
928
929static int output_directory_callback(const struct option *opt, const char *arg,
930 int unset)
931{
932 const char **dir = (const char **)opt->value;
933 if (*dir)
5c5f1d7c 934 die(_("Two output directories?"));
fff02ee6
SB
935 *dir = arg;
936 return 0;
937}
938
939static int thread_callback(const struct option *opt, const char *arg, int unset)
940{
941 int *thread = (int *)opt->value;
942 if (unset)
943 *thread = 0;
944 else if (!arg || !strcmp(arg, "shallow"))
945 *thread = THREAD_SHALLOW;
946 else if (!strcmp(arg, "deep"))
947 *thread = THREAD_DEEP;
948 else
949 return 1;
950 return 0;
951}
952
953static int attach_callback(const struct option *opt, const char *arg, int unset)
954{
955 struct rev_info *rev = (struct rev_info *)opt->value;
956 if (unset)
957 rev->mime_boundary = NULL;
958 else if (arg)
959 rev->mime_boundary = arg;
960 else
961 rev->mime_boundary = git_version_string;
962 rev->no_inline = unset ? 0 : 1;
963 return 0;
964}
965
966static int inline_callback(const struct option *opt, const char *arg, int unset)
967{
968 struct rev_info *rev = (struct rev_info *)opt->value;
969 if (unset)
970 rev->mime_boundary = NULL;
971 else if (arg)
972 rev->mime_boundary = arg;
973 else
974 rev->mime_boundary = git_version_string;
975 rev->no_inline = 0;
976 return 0;
977}
978
979static int header_callback(const struct option *opt, const char *arg, int unset)
980{
c4260034
SB
981 if (unset) {
982 string_list_clear(&extra_hdr, 0);
983 string_list_clear(&extra_to, 0);
984 string_list_clear(&extra_cc, 0);
985 } else {
986 add_header(arg);
987 }
fff02ee6
SB
988 return 0;
989}
990
ae6c098f
SD
991static int to_callback(const struct option *opt, const char *arg, int unset)
992{
c4260034
SB
993 if (unset)
994 string_list_clear(&extra_to, 0);
995 else
1d2f80fa 996 string_list_append(&extra_to, arg);
fff02ee6
SB
997 return 0;
998}
999
1000static int cc_callback(const struct option *opt, const char *arg, int unset)
1001{
c4260034
SB
1002 if (unset)
1003 string_list_clear(&extra_cc, 0);
1004 else
1d2f80fa 1005 string_list_append(&extra_cc, arg);
fff02ee6
SB
1006 return 0;
1007}
1008
a633fca0 1009int cmd_format_patch(int argc, const char **argv, const char *prefix)
91efcf60
JH
1010{
1011 struct commit *commit;
1012 struct commit **list = NULL;
1013 struct rev_info rev;
32962c9b 1014 struct setup_revision_opt s_r_opt;
fff02ee6 1015 int nr = 0, total, i;
0377db77 1016 int use_stdout = 0;
fa0f02df 1017 int start_number = -1;
e6ff0f42 1018 int numbered_files = 0; /* _just_ numbers */
9c6efa36 1019 int ignore_if_in_upstream = 0;
a5a27c79 1020 int cover_letter = 0;
2bda2cf4 1021 int boundary_count = 0;
37c22a4b 1022 int no_binary_diff = 0;
a5a27c79 1023 struct commit *origin = NULL, *head = NULL;
76af0734 1024 const char *in_reply_to = NULL;
5d23e133 1025 struct patch_ids ids;
cf2251b6 1026 char *add_signoff = NULL;
f285a2d7 1027 struct strbuf buf = STRBUF_INIT;
1d46f2ea 1028 int use_patch_format = 0;
250087f2 1029 int quiet = 0;
fff02ee6
SB
1030 const struct option builtin_format_patch_options[] = {
1031 { OPTION_CALLBACK, 'n', "numbered", &numbered, NULL,
1032 "use [PATCH n/m] even with a single patch",
1033 PARSE_OPT_NOARG, numbered_callback },
1034 { OPTION_CALLBACK, 'N', "no-numbered", &numbered, NULL,
1035 "use [PATCH] even with multiple patches",
1036 PARSE_OPT_NOARG, no_numbered_callback },
1037 OPT_BOOLEAN('s', "signoff", &do_signoff, "add Signed-off-by:"),
1038 OPT_BOOLEAN(0, "stdout", &use_stdout,
1039 "print patches to standard out"),
1040 OPT_BOOLEAN(0, "cover-letter", &cover_letter,
1041 "generate a cover letter"),
1042 OPT_BOOLEAN(0, "numbered-files", &numbered_files,
1043 "use simple number sequence for output file names"),
1044 OPT_STRING(0, "suffix", &fmt_patch_suffix, "sfx",
1045 "use <sfx> instead of '.patch'"),
1046 OPT_INTEGER(0, "start-number", &start_number,
1047 "start numbering patches at <n> instead of 1"),
1048 { OPTION_CALLBACK, 0, "subject-prefix", &rev, "prefix",
1049 "Use [<prefix>] instead of [PATCH]",
1050 PARSE_OPT_NONEG, subject_prefix_callback },
1051 { OPTION_CALLBACK, 'o', "output-directory", &output_directory,
1052 "dir", "store resulting files in <dir>",
1053 PARSE_OPT_NONEG, output_directory_callback },
1054 { OPTION_CALLBACK, 'k', "keep-subject", &rev, NULL,
1055 "don't strip/add [PATCH]",
1056 PARSE_OPT_NOARG | PARSE_OPT_NONEG, keep_callback },
1057 OPT_BOOLEAN(0, "no-binary", &no_binary_diff,
1058 "don't output binary diffs"),
1059 OPT_BOOLEAN(0, "ignore-if-in-upstream", &ignore_if_in_upstream,
1060 "don't include a patch matching a commit upstream"),
2cfa8330
BG
1061 { OPTION_BOOLEAN, 'p', "no-stat", &use_patch_format, NULL,
1062 "show patch format instead of default (patch + stat)",
1063 PARSE_OPT_NONEG | PARSE_OPT_NOARG },
fff02ee6
SB
1064 OPT_GROUP("Messaging"),
1065 { OPTION_CALLBACK, 0, "add-header", NULL, "header",
c4260034 1066 "add email header", 0, header_callback },
ae6c098f 1067 { OPTION_CALLBACK, 0, "to", NULL, "email", "add To: header",
c4260034 1068 0, to_callback },
fff02ee6 1069 { OPTION_CALLBACK, 0, "cc", NULL, "email", "add Cc: header",
c4260034 1070 0, cc_callback },
fff02ee6
SB
1071 OPT_STRING(0, "in-reply-to", &in_reply_to, "message-id",
1072 "make first mail a reply to <message-id>"),
1073 { OPTION_CALLBACK, 0, "attach", &rev, "boundary",
1074 "attach the patch", PARSE_OPT_OPTARG,
1075 attach_callback },
1076 { OPTION_CALLBACK, 0, "inline", &rev, "boundary",
1077 "inline the patch",
1078 PARSE_OPT_OPTARG | PARSE_OPT_NONEG,
1079 inline_callback },
1080 { OPTION_CALLBACK, 0, "thread", &thread, "style",
1081 "enable message threading, styles: shallow, deep",
1082 PARSE_OPT_OPTARG, thread_callback },
6622d9c7
SB
1083 OPT_STRING(0, "signature", &signature, "signature",
1084 "add a signature"),
250087f2
CMN
1085 OPT_BOOLEAN(0, "quiet", &quiet,
1086 "don't print the patch filenames"),
fff02ee6
SB
1087 OPT_END()
1088 };
91efcf60 1089
ca9e0a1b
SB
1090 extra_hdr.strdup_strings = 1;
1091 extra_to.strdup_strings = 1;
1092 extra_cc.strdup_strings = 1;
ef90d6d4 1093 git_config(git_format_config, NULL);
db6296a5 1094 init_revisions(&rev, prefix);
91efcf60
JH
1095 rev.commit_format = CMIT_FMT_EMAIL;
1096 rev.verbose_header = 1;
1097 rev.diff = 1;
ad5aeede 1098 rev.max_parents = 1;
8f67f8ae 1099 DIFF_OPT_SET(&rev.diffopt, RECURSIVE);
dbd21447 1100 rev.subject_prefix = fmt_patch_subject_prefix;
32962c9b
JH
1101 memset(&s_r_opt, 0, sizeof(s_r_opt));
1102 s_r_opt.def = "HEAD";
20ff0680 1103
0db5260b
JW
1104 if (default_attach) {
1105 rev.mime_boundary = default_attach;
1106 rev.no_inline = 1;
1107 }
1108
2448482b
JS
1109 /*
1110 * Parse the arguments before setup_revisions(), or something
2dc189a3 1111 * like "git format-patch -o a123 HEAD^.." may fail; a123 is
2448482b
JS
1112 * possibly a valid SHA1.
1113 */
37782920 1114 argc = parse_options(argc, argv, prefix, builtin_format_patch_options,
fff02ee6 1115 builtin_format_patch_usage,
382da402
FC
1116 PARSE_OPT_KEEP_ARGV0 | PARSE_OPT_KEEP_UNKNOWN |
1117 PARSE_OPT_KEEP_DASHDASH);
2448482b 1118
1d1876e9
HV
1119 if (do_signoff) {
1120 const char *committer;
1121 const char *endpos;
1122 committer = git_committer_info(IDENT_ERROR_ON_NO_NAME);
1123 endpos = strchr(committer, '>');
1124 if (!endpos)
5c5f1d7c 1125 die(_("bogus committer info %s"), committer);
1d1876e9
HV
1126 add_signoff = xmemdupz(committer, endpos - committer + 1);
1127 }
1128
ca9e0a1b
SB
1129 for (i = 0; i < extra_hdr.nr; i++) {
1130 strbuf_addstr(&buf, extra_hdr.items[i].string);
3ee79d9f
DB
1131 strbuf_addch(&buf, '\n');
1132 }
1133
ca9e0a1b 1134 if (extra_to.nr)
3ee79d9f 1135 strbuf_addstr(&buf, "To: ");
ca9e0a1b 1136 for (i = 0; i < extra_to.nr; i++) {
3ee79d9f
DB
1137 if (i)
1138 strbuf_addstr(&buf, " ");
ca9e0a1b
SB
1139 strbuf_addstr(&buf, extra_to.items[i].string);
1140 if (i + 1 < extra_to.nr)
3ee79d9f
DB
1141 strbuf_addch(&buf, ',');
1142 strbuf_addch(&buf, '\n');
1143 }
1144
ca9e0a1b 1145 if (extra_cc.nr)
3ee79d9f 1146 strbuf_addstr(&buf, "Cc: ");
ca9e0a1b 1147 for (i = 0; i < extra_cc.nr; i++) {
3ee79d9f
DB
1148 if (i)
1149 strbuf_addstr(&buf, " ");
ca9e0a1b
SB
1150 strbuf_addstr(&buf, extra_cc.items[i].string);
1151 if (i + 1 < extra_cc.nr)
3ee79d9f
DB
1152 strbuf_addch(&buf, ',');
1153 strbuf_addch(&buf, '\n');
1154 }
1155
2af202be 1156 rev.extra_headers = strbuf_detach(&buf, NULL);
3ee79d9f 1157
add5c8a5 1158 if (start_number < 0)
fa0f02df 1159 start_number = 1;
ca6b91d2
JM
1160
1161 /*
1162 * If numbered is set solely due to format.numbered in config,
1163 * and it would conflict with --keep-subject (-k) from the
1164 * command line, reset "numbered".
1165 */
1166 if (numbered && keep_subject && !numbered_cmdline_opt)
1167 numbered = 0;
1168
63b398a4 1169 if (numbered && keep_subject)
5c5f1d7c 1170 die (_("-n and -k are mutually exclusive."));
2d9e4a47 1171 if (keep_subject && subject_prefix)
5c5f1d7c 1172 die (_("--subject-prefix and -k are mutually exclusive."));
9553d2b2 1173 rev.preserve_subject = keep_subject;
8ac80a57 1174
32962c9b 1175 argc = setup_revisions(argc, argv, &rev, &s_r_opt);
2448482b 1176 if (argc > 1)
5c5f1d7c 1177 die (_("unrecognized argument: %s"), argv[1]);
0377db77 1178
02bc5b03 1179 if (rev.diffopt.output_format & DIFF_FORMAT_NAME)
f338cb83 1180 die(_("--name-only does not make sense"));
02bc5b03 1181 if (rev.diffopt.output_format & DIFF_FORMAT_NAME_STATUS)
f338cb83 1182 die(_("--name-status does not make sense"));
02bc5b03 1183 if (rev.diffopt.output_format & DIFF_FORMAT_CHECKDIFF)
f338cb83 1184 die(_("--check does not make sense"));
02bc5b03
BG
1185
1186 if (!use_patch_format &&
1187 (!rev.diffopt.output_format ||
1188 rev.diffopt.output_format == DIFF_FORMAT_PATCH))
1189 rev.diffopt.output_format = DIFF_FORMAT_DIFFSTAT | DIFF_FORMAT_SUMMARY;
1190
1191 /* Always generate a patch */
1192 rev.diffopt.output_format |= DIFF_FORMAT_PATCH;
c9b5ef99 1193
37c22a4b 1194 if (!DIFF_OPT_TST(&rev.diffopt, TEXT) && !no_binary_diff)
8f67f8ae 1195 DIFF_OPT_SET(&rev.diffopt, BINARY);
e47f306d 1196
894a9d33
TR
1197 if (rev.show_notes)
1198 init_display_notes(&rev.notes_opt);
1199
9800a754
JH
1200 if (!use_stdout)
1201 output_directory = set_outdir(prefix, output_directory);
38a94bb6
TRC
1202 else
1203 setup_pager();
77e565d8 1204
efd02016
JH
1205 if (output_directory) {
1206 if (use_stdout)
5c5f1d7c 1207 die(_("standard output, or directory, which one?"));
efd02016 1208 if (mkdir(output_directory, 0777) < 0 && errno != EEXIST)
5c5f1d7c 1209 die_errno(_("Could not create directory '%s'"),
0721c314 1210 output_directory);
efd02016
JH
1211 }
1212
1f1e895f 1213 if (rev.pending.nr == 1) {
8a1d076e
JH
1214 if (rev.max_count < 0 && !rev.show_root_diff) {
1215 /*
1216 * This is traditional behaviour of "git format-patch
1217 * origin" that prepares what the origin side still
1218 * does not have.
1219 */
7c496280 1220 rev.pending.objects[0].item->flags |= UNINTERESTING;
3384a2df 1221 add_head_to_pending(&rev);
7c496280 1222 }
8a1d076e
JH
1223 /*
1224 * Otherwise, it is "format-patch -22 HEAD", and/or
1225 * "format-patch --root HEAD". The user wants
1226 * get_revision() to do the usual traversal.
7c496280 1227 */
e686eb98 1228 }
68c2ec7f
JH
1229
1230 /*
1231 * We cannot move this anywhere earlier because we do want to
9517e6b8 1232 * know if --root was given explicitly from the command line.
68c2ec7f
JH
1233 */
1234 rev.show_root_diff = 1;
1235
a5a27c79
DB
1236 if (cover_letter) {
1237 /* remember the range */
a5a27c79
DB
1238 int i;
1239 for (i = 0; i < rev.pending.nr; i++) {
1240 struct object *o = rev.pending.objects[i].item;
2bda2cf4 1241 if (!(o->flags & UNINTERESTING))
a5a27c79
DB
1242 head = (struct commit *)o;
1243 }
a5a27c79
DB
1244 /* We can't generate a cover letter without any patches */
1245 if (!head)
1246 return 0;
1247 }
e686eb98 1248
657ab61e
KB
1249 if (ignore_if_in_upstream) {
1250 /* Don't say anything if head and upstream are the same. */
1251 if (rev.pending.nr == 2) {
1252 struct object_array_entry *o = rev.pending.objects;
1253 if (hashcmp(o[0].item->sha1, o[1].item->sha1) == 0)
1254 return 0;
1255 }
5d23e133 1256 get_patch_ids(&rev, &ids, prefix);
657ab61e 1257 }
9c6efa36 1258
81f3a188 1259 if (!use_stdout)
f5788250 1260 realstdout = xfdopen(xdup(1), "w");
81f3a188 1261
3d51e1b5 1262 if (prepare_revision_walk(&rev))
5c5f1d7c 1263 die(_("revision walk setup failed"));
2bda2cf4 1264 rev.boundary = 1;
91efcf60 1265 while ((commit = get_revision(&rev)) != NULL) {
2bda2cf4 1266 if (commit->object.flags & BOUNDARY) {
2bda2cf4
DB
1267 boundary_count++;
1268 origin = (boundary_count == 1) ? commit : NULL;
1269 continue;
1270 }
1271
9c6efa36 1272 if (ignore_if_in_upstream &&
5d23e133 1273 has_commit_patch_id(commit, &ids))
9c6efa36
JS
1274 continue;
1275
91efcf60 1276 nr++;
83572c1a 1277 list = xrealloc(list, nr * sizeof(list[0]));
91efcf60
JH
1278 list[nr - 1] = commit;
1279 }
0377db77 1280 total = nr;
49604a4d
BG
1281 if (!keep_subject && auto_number && total > 1)
1282 numbered = 1;
596524b3 1283 if (numbered)
fa0f02df 1284 rev.total = total + start_number - 1;
b079c50e
TR
1285 if (in_reply_to || thread || cover_letter)
1286 rev.ref_message_ids = xcalloc(1, sizeof(struct string_list));
1287 if (in_reply_to) {
1288 const char *msgid = clean_message_id(in_reply_to);
1d2f80fa 1289 string_list_append(rev.ref_message_ids, msgid);
b079c50e 1290 }
108dab28
SB
1291 rev.numbered_files = numbered_files;
1292 rev.patch_suffix = fmt_patch_suffix;
a5a27c79
DB
1293 if (cover_letter) {
1294 if (thread)
1295 gen_message_id(&rev, "cover");
1296 make_cover_letter(&rev, use_stdout, numbered, numbered_files,
250087f2 1297 origin, nr, list, head, quiet);
a5a27c79
DB
1298 total++;
1299 start_number--;
1300 }
1301 rev.add_signoff = add_signoff;
91efcf60
JH
1302 while (0 <= --nr) {
1303 int shown;
1304 commit = list[nr];
add5c8a5 1305 rev.nr = total - nr + (start_number - 1);
d1566f78 1306 /* Make the second and subsequent mails replies to the first */
cc35de84 1307 if (thread) {
a5a27c79 1308 /* Have we already had a message ID? */
e1a37346 1309 if (rev.message_id) {
a5a27c79 1310 /*
30984ed2
TR
1311 * For deep threading: make every mail
1312 * a reply to the previous one, no
1313 * matter what other options are set.
1314 *
1315 * For shallow threading:
1316 *
2175c10d
TR
1317 * Without --cover-letter and
1318 * --in-reply-to, make every mail a
1319 * reply to the one before.
1320 *
1321 * With --in-reply-to but no
1322 * --cover-letter, make every mail a
1323 * reply to the <reply-to>.
1324 *
1325 * With --cover-letter, make every
1326 * mail but the cover letter a reply
1327 * to the cover letter. The cover
1328 * letter is a reply to the
1329 * --in-reply-to, if specified.
a5a27c79 1330 */
30984ed2
TR
1331 if (thread == THREAD_SHALLOW
1332 && rev.ref_message_ids->nr > 0
2175c10d 1333 && (!cover_letter || rev.nr > 1))
e1a37346
DB
1334 free(rev.message_id);
1335 else
1d2f80fa
JP
1336 string_list_append(rev.ref_message_ids,
1337 rev.message_id);
cc35de84 1338 }
e1a37346 1339 gen_message_id(&rev, sha1_to_hex(commit->object.sha1));
d1566f78 1340 }
6df514af 1341
cd2ef591 1342 if (!use_stdout && reopen_stdout(numbered_files ? NULL : commit,
250087f2 1343 &rev, quiet))
5c5f1d7c 1344 die(_("Failed to create output files"));
91efcf60
JH
1345 shown = log_tree_commit(&rev, commit);
1346 free(commit->buffer);
1347 commit->buffer = NULL;
add5c8a5
JH
1348
1349 /* We put one extra blank line between formatted
1350 * patches and this flag is used by log-tree code
1351 * to see if it needs to emit a LF before showing
1352 * the log; when using one file per patch, we do
1353 * not want the extra blank line.
1354 */
1355 if (!use_stdout)
1356 rev.shown_one = 0;
698ce6f8
JS
1357 if (shown) {
1358 if (rev.mime_boundary)
1359 printf("\n--%s%s--\n\n\n",
1360 mime_boundary_leader,
1361 rev.mime_boundary);
1362 else
6622d9c7 1363 print_signature();
698ce6f8 1364 }
0377db77
JS
1365 if (!use_stdout)
1366 fclose(stdout);
91efcf60
JH
1367 }
1368 free(list);
ca9e0a1b
SB
1369 string_list_clear(&extra_to, 0);
1370 string_list_clear(&extra_cc, 0);
1371 string_list_clear(&extra_hdr, 0);
5d23e133
JH
1372 if (ignore_if_in_upstream)
1373 free_patch_ids(&ids);
91efcf60
JH
1374 return 0;
1375}
1376
e827633a
RS
1377static int add_pending_commit(const char *arg, struct rev_info *revs, int flags)
1378{
1379 unsigned char sha1[20];
1380 if (get_sha1(arg, sha1) == 0) {
1381 struct commit *commit = lookup_commit_reference(sha1);
1382 if (commit) {
1383 commit->object.flags |= flags;
1384 add_pending_object(revs, &commit->object, arg);
1385 return 0;
1386 }
1387 }
1388 return -1;
1389}
1390
28a53178
EFL
1391static const char * const cherry_usage[] = {
1392 "git cherry [-v] [<upstream> [<head> [<limit>]]]",
1393 NULL
1394};
1395
a3a32e7f
JN
1396static void print_commit(char sign, struct commit *commit, int verbose,
1397 int abbrev)
1398{
1399 if (!verbose) {
1400 printf("%c %s\n", sign,
1401 find_unique_abbrev(commit->object.sha1, abbrev));
1402 } else {
1403 struct strbuf buf = STRBUF_INIT;
f67d2e82 1404 pp_commit_easy(CMIT_FMT_ONELINE, commit, &buf);
a3a32e7f
JN
1405 printf("%c %s %s\n", sign,
1406 find_unique_abbrev(commit->object.sha1, abbrev),
1407 buf.buf);
1408 strbuf_release(&buf);
1409 }
1410}
1411
e827633a
RS
1412int cmd_cherry(int argc, const char **argv, const char *prefix)
1413{
1414 struct rev_info revs;
5d23e133 1415 struct patch_ids ids;
e827633a
RS
1416 struct commit *commit;
1417 struct commit_list *list = NULL;
f2968022 1418 struct branch *current_branch;
e827633a
RS
1419 const char *upstream;
1420 const char *head = "HEAD";
1421 const char *limit = NULL;
28a53178 1422 int verbose = 0, abbrev = 0;
e827633a 1423
28a53178
EFL
1424 struct option options[] = {
1425 OPT__ABBREV(&abbrev),
fd03881a 1426 OPT__VERBOSE(&verbose, "be verbose"),
28a53178
EFL
1427 OPT_END()
1428 };
e827633a 1429
28a53178 1430 argc = parse_options(argc, argv, prefix, options, cherry_usage, 0);
fef34270 1431
e827633a 1432 switch (argc) {
e827633a 1433 case 3:
28a53178 1434 limit = argv[2];
e827633a
RS
1435 /* FALLTHROUGH */
1436 case 2:
28a53178
EFL
1437 head = argv[1];
1438 /* FALLTHROUGH */
1439 case 1:
1440 upstream = argv[0];
e827633a
RS
1441 break;
1442 default:
f2968022
MH
1443 current_branch = branch_get(NULL);
1444 if (!current_branch || !current_branch->merge
1445 || !current_branch->merge[0]
1446 || !current_branch->merge[0]->dst) {
5c5f1d7c 1447 fprintf(stderr, _("Could not find a tracked"
f2968022 1448 " remote branch, please"
5c5f1d7c 1449 " specify <upstream> manually.\n"));
28a53178 1450 usage_with_options(cherry_usage, options);
f2968022
MH
1451 }
1452
1453 upstream = current_branch->merge[0]->dst;
e827633a
RS
1454 }
1455
1456 init_revisions(&revs, prefix);
1457 revs.diff = 1;
1458 revs.combine_merges = 0;
1459 revs.ignore_merges = 1;
8f67f8ae 1460 DIFF_OPT_SET(&revs.diffopt, RECURSIVE);
e827633a
RS
1461
1462 if (add_pending_commit(head, &revs, 0))
5c5f1d7c 1463 die(_("Unknown commit %s"), head);
e827633a 1464 if (add_pending_commit(upstream, &revs, UNINTERESTING))
5c5f1d7c 1465 die(_("Unknown commit %s"), upstream);
e827633a
RS
1466
1467 /* Don't say anything if head and upstream are the same. */
1468 if (revs.pending.nr == 2) {
1469 struct object_array_entry *o = revs.pending.objects;
1470 if (hashcmp(o[0].item->sha1, o[1].item->sha1) == 0)
1471 return 0;
1472 }
1473
5d23e133 1474 get_patch_ids(&revs, &ids, prefix);
e827633a
RS
1475
1476 if (limit && add_pending_commit(limit, &revs, UNINTERESTING))
5c5f1d7c 1477 die(_("Unknown commit %s"), limit);
e827633a
RS
1478
1479 /* reverse the list of commits */
3d51e1b5 1480 if (prepare_revision_walk(&revs))
5c5f1d7c 1481 die(_("revision walk setup failed"));
e827633a
RS
1482 while ((commit = get_revision(&revs)) != NULL) {
1483 /* ignore merges */
1484 if (commit->parents && commit->parents->next)
1485 continue;
1486
1487 commit_list_insert(commit, &list);
1488 }
1489
1490 while (list) {
e827633a
RS
1491 char sign = '+';
1492
1493 commit = list->item;
5d23e133 1494 if (has_commit_patch_id(commit, &ids))
e827633a 1495 sign = '-';
a3a32e7f 1496 print_commit(sign, commit, verbose, abbrev);
e827633a
RS
1497 list = list->next;
1498 }
1499
5d23e133 1500 free_patch_ids(&ids);
e827633a
RS
1501 return 0;
1502}