Merge branch 'js/branch-track'
[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 const char *origin_sha1, *head_sha1;
651 const char *argv[7];
652 const char *subject_start = NULL;
653 const char *body = "*** SUBJECT HERE ***\n\n*** BLURB HERE ***\n";
654 const char *msg;
655 const char *extra_headers = rev->extra_headers;
656 struct shortlog log;
657 struct strbuf sb;
658 int i;
659 const char *encoding = "utf-8";
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 origin_sha1 = sha1_to_hex(origin->object.sha1);
698
699 argv[0] = "diff";
700 argv[1] = "--stat";
701 argv[2] = "--summary";
702 argv[3] = head_sha1;
703 argv[4] = "--not";
704 argv[5] = origin_sha1;
705 argv[6] = "--";
706 argv[7] = NULL;
707 fflush(stdout);
708 run_command_v_opt(argv, RUN_GIT_CMD);
709
710 fflush(stdout);
711 printf("\n");
712 }
713
714 static const char *clean_message_id(const char *msg_id)
715 {
716 char ch;
717 const char *a, *z, *m;
718
719 m = msg_id;
720 while ((ch = *m) && (isspace(ch) || (ch == '<')))
721 m++;
722 a = m;
723 z = NULL;
724 while ((ch = *m)) {
725 if (!isspace(ch) && (ch != '>'))
726 z = m;
727 m++;
728 }
729 if (!z)
730 die("insane in-reply-to: %s", msg_id);
731 if (++z == m)
732 return a;
733 return xmemdupz(a, z - a);
734 }
735
736 int cmd_format_patch(int argc, const char **argv, const char *prefix)
737 {
738 struct commit *commit;
739 struct commit **list = NULL;
740 struct rev_info rev;
741 int nr = 0, total, i, j;
742 int use_stdout = 0;
743 int start_number = -1;
744 int keep_subject = 0;
745 int numbered_files = 0; /* _just_ numbers */
746 int subject_prefix = 0;
747 int ignore_if_in_upstream = 0;
748 int thread = 0;
749 int cover_letter = 0;
750 int boundary_count = 0;
751 struct commit *origin = NULL, *head = NULL;
752 const char *in_reply_to = NULL;
753 struct patch_ids ids;
754 char *add_signoff = NULL;
755 struct strbuf buf;
756
757 git_config(git_format_config);
758 init_revisions(&rev, prefix);
759 rev.commit_format = CMIT_FMT_EMAIL;
760 rev.verbose_header = 1;
761 rev.diff = 1;
762 rev.combine_merges = 0;
763 rev.ignore_merges = 1;
764 rev.diffopt.msg_sep = "";
765 DIFF_OPT_SET(&rev.diffopt, RECURSIVE);
766
767 rev.subject_prefix = fmt_patch_subject_prefix;
768
769 /*
770 * Parse the arguments before setup_revisions(), or something
771 * like "git format-patch -o a123 HEAD^.." may fail; a123 is
772 * possibly a valid SHA1.
773 */
774 for (i = 1, j = 1; i < argc; i++) {
775 if (!strcmp(argv[i], "--stdout"))
776 use_stdout = 1;
777 else if (!strcmp(argv[i], "-n") ||
778 !strcmp(argv[i], "--numbered"))
779 numbered = 1;
780 else if (!strcmp(argv[i], "-N") ||
781 !strcmp(argv[i], "--no-numbered")) {
782 numbered = 0;
783 auto_number = 0;
784 }
785 else if (!prefixcmp(argv[i], "--start-number="))
786 start_number = strtol(argv[i] + 15, NULL, 10);
787 else if (!strcmp(argv[i], "--numbered-files"))
788 numbered_files = 1;
789 else if (!strcmp(argv[i], "--start-number")) {
790 i++;
791 if (i == argc)
792 die("Need a number for --start-number");
793 start_number = strtol(argv[i], NULL, 10);
794 }
795 else if (!prefixcmp(argv[i], "--cc=")) {
796 ALLOC_GROW(extra_cc, extra_cc_nr + 1, extra_cc_alloc);
797 extra_cc[extra_cc_nr++] = xstrdup(argv[i] + 5);
798 }
799 else if (!strcmp(argv[i], "-k") ||
800 !strcmp(argv[i], "--keep-subject")) {
801 keep_subject = 1;
802 rev.total = -1;
803 }
804 else if (!strcmp(argv[i], "--output-directory") ||
805 !strcmp(argv[i], "-o")) {
806 i++;
807 if (argc <= i)
808 die("Which directory?");
809 if (output_directory)
810 die("Two output directories?");
811 output_directory = argv[i];
812 }
813 else if (!strcmp(argv[i], "--signoff") ||
814 !strcmp(argv[i], "-s")) {
815 const char *committer;
816 const char *endpos;
817 committer = git_committer_info(IDENT_ERROR_ON_NO_NAME);
818 endpos = strchr(committer, '>');
819 if (!endpos)
820 die("bogos committer info %s\n", committer);
821 add_signoff = xmemdupz(committer, endpos - committer + 1);
822 }
823 else if (!strcmp(argv[i], "--attach")) {
824 rev.mime_boundary = git_version_string;
825 rev.no_inline = 1;
826 }
827 else if (!prefixcmp(argv[i], "--attach=")) {
828 rev.mime_boundary = argv[i] + 9;
829 rev.no_inline = 1;
830 }
831 else if (!strcmp(argv[i], "--inline")) {
832 rev.mime_boundary = git_version_string;
833 rev.no_inline = 0;
834 }
835 else if (!prefixcmp(argv[i], "--inline=")) {
836 rev.mime_boundary = argv[i] + 9;
837 rev.no_inline = 0;
838 }
839 else if (!strcmp(argv[i], "--ignore-if-in-upstream"))
840 ignore_if_in_upstream = 1;
841 else if (!strcmp(argv[i], "--thread"))
842 thread = 1;
843 else if (!prefixcmp(argv[i], "--in-reply-to="))
844 in_reply_to = argv[i] + 14;
845 else if (!strcmp(argv[i], "--in-reply-to")) {
846 i++;
847 if (i == argc)
848 die("Need a Message-Id for --in-reply-to");
849 in_reply_to = argv[i];
850 } else if (!prefixcmp(argv[i], "--subject-prefix=")) {
851 subject_prefix = 1;
852 rev.subject_prefix = argv[i] + 17;
853 } else if (!prefixcmp(argv[i], "--suffix="))
854 fmt_patch_suffix = argv[i] + 9;
855 else if (!strcmp(argv[i], "--cover-letter"))
856 cover_letter = 1;
857 else
858 argv[j++] = argv[i];
859 }
860 argc = j;
861
862 strbuf_init(&buf, 0);
863
864 for (i = 0; i < extra_hdr_nr; i++) {
865 strbuf_addstr(&buf, extra_hdr[i]);
866 strbuf_addch(&buf, '\n');
867 }
868
869 if (extra_to_nr)
870 strbuf_addstr(&buf, "To: ");
871 for (i = 0; i < extra_to_nr; i++) {
872 if (i)
873 strbuf_addstr(&buf, " ");
874 strbuf_addstr(&buf, extra_to[i]);
875 if (i + 1 < extra_to_nr)
876 strbuf_addch(&buf, ',');
877 strbuf_addch(&buf, '\n');
878 }
879
880 if (extra_cc_nr)
881 strbuf_addstr(&buf, "Cc: ");
882 for (i = 0; i < extra_cc_nr; i++) {
883 if (i)
884 strbuf_addstr(&buf, " ");
885 strbuf_addstr(&buf, extra_cc[i]);
886 if (i + 1 < extra_cc_nr)
887 strbuf_addch(&buf, ',');
888 strbuf_addch(&buf, '\n');
889 }
890
891 rev.extra_headers = strbuf_detach(&buf, 0);
892
893 if (start_number < 0)
894 start_number = 1;
895 if (numbered && keep_subject)
896 die ("-n and -k are mutually exclusive.");
897 if (keep_subject && subject_prefix)
898 die ("--subject-prefix and -k are mutually exclusive.");
899 if (numbered_files && use_stdout)
900 die ("--numbered-files and --stdout are mutually exclusive.");
901
902 argc = setup_revisions(argc, argv, &rev, "HEAD");
903 if (argc > 1)
904 die ("unrecognized argument: %s", argv[1]);
905
906 if (!rev.diffopt.output_format)
907 rev.diffopt.output_format = DIFF_FORMAT_DIFFSTAT | DIFF_FORMAT_SUMMARY | DIFF_FORMAT_PATCH;
908
909 if (!DIFF_OPT_TST(&rev.diffopt, TEXT))
910 DIFF_OPT_SET(&rev.diffopt, BINARY);
911
912 if (!output_directory && !use_stdout)
913 output_directory = prefix;
914
915 if (output_directory) {
916 if (use_stdout)
917 die("standard output, or directory, which one?");
918 if (mkdir(output_directory, 0777) < 0 && errno != EEXIST)
919 die("Could not create directory %s",
920 output_directory);
921 }
922
923 if (rev.pending.nr == 1) {
924 if (rev.max_count < 0 && !rev.show_root_diff) {
925 /*
926 * This is traditional behaviour of "git format-patch
927 * origin" that prepares what the origin side still
928 * does not have.
929 */
930 rev.pending.objects[0].item->flags |= UNINTERESTING;
931 add_head_to_pending(&rev);
932 }
933 /*
934 * Otherwise, it is "format-patch -22 HEAD", and/or
935 * "format-patch --root HEAD". The user wants
936 * get_revision() to do the usual traversal.
937 */
938 }
939 if (cover_letter) {
940 /* remember the range */
941 int i;
942 for (i = 0; i < rev.pending.nr; i++) {
943 struct object *o = rev.pending.objects[i].item;
944 if (!(o->flags & UNINTERESTING))
945 head = (struct commit *)o;
946 }
947 /* We can't generate a cover letter without any patches */
948 if (!head)
949 return 0;
950 }
951
952 if (ignore_if_in_upstream)
953 get_patch_ids(&rev, &ids, prefix);
954
955 if (!use_stdout)
956 realstdout = xfdopen(xdup(1), "w");
957
958 if (prepare_revision_walk(&rev))
959 die("revision walk setup failed");
960 rev.boundary = 1;
961 while ((commit = get_revision(&rev)) != NULL) {
962 if (commit->object.flags & BOUNDARY) {
963 fprintf(stderr, "Boundary %s\n", sha1_to_hex(commit->object.sha1));
964 boundary_count++;
965 origin = (boundary_count == 1) ? commit : NULL;
966 continue;
967 }
968
969 /* ignore merges */
970 if (commit->parents && commit->parents->next)
971 continue;
972
973 if (ignore_if_in_upstream &&
974 has_commit_patch_id(commit, &ids))
975 continue;
976
977 nr++;
978 list = xrealloc(list, nr * sizeof(list[0]));
979 list[nr - 1] = commit;
980 }
981 total = nr;
982 if (!keep_subject && auto_number && total > 1)
983 numbered = 1;
984 if (numbered)
985 rev.total = total + start_number - 1;
986 if (in_reply_to)
987 rev.ref_message_id = clean_message_id(in_reply_to);
988 if (cover_letter) {
989 if (thread)
990 gen_message_id(&rev, "cover");
991 make_cover_letter(&rev, use_stdout, numbered, numbered_files,
992 origin, nr, list, head);
993 total++;
994 start_number--;
995 }
996 rev.add_signoff = add_signoff;
997 while (0 <= --nr) {
998 int shown;
999 commit = list[nr];
1000 rev.nr = total - nr + (start_number - 1);
1001 /* Make the second and subsequent mails replies to the first */
1002 if (thread) {
1003 /* Have we already had a message ID? */
1004 if (rev.message_id) {
1005 /*
1006 * If we've got the ID to be a reply
1007 * to, discard the current ID;
1008 * otherwise, make everything a reply
1009 * to that.
1010 */
1011 if (rev.ref_message_id)
1012 free(rev.message_id);
1013 else
1014 rev.ref_message_id = rev.message_id;
1015 }
1016 gen_message_id(&rev, sha1_to_hex(commit->object.sha1));
1017 }
1018 if (!use_stdout && reopen_stdout(numbered_files ? NULL :
1019 get_oneline_for_filename(commit, keep_subject),
1020 rev.nr, rev.total))
1021 die("Failed to create output files");
1022 shown = log_tree_commit(&rev, commit);
1023 free(commit->buffer);
1024 commit->buffer = NULL;
1025
1026 /* We put one extra blank line between formatted
1027 * patches and this flag is used by log-tree code
1028 * to see if it needs to emit a LF before showing
1029 * the log; when using one file per patch, we do
1030 * not want the extra blank line.
1031 */
1032 if (!use_stdout)
1033 rev.shown_one = 0;
1034 if (shown) {
1035 if (rev.mime_boundary)
1036 printf("\n--%s%s--\n\n\n",
1037 mime_boundary_leader,
1038 rev.mime_boundary);
1039 else
1040 printf("-- \n%s\n\n", git_version_string);
1041 }
1042 if (!use_stdout)
1043 fclose(stdout);
1044 }
1045 free(list);
1046 if (ignore_if_in_upstream)
1047 free_patch_ids(&ids);
1048 return 0;
1049 }
1050
1051 static int add_pending_commit(const char *arg, struct rev_info *revs, int flags)
1052 {
1053 unsigned char sha1[20];
1054 if (get_sha1(arg, sha1) == 0) {
1055 struct commit *commit = lookup_commit_reference(sha1);
1056 if (commit) {
1057 commit->object.flags |= flags;
1058 add_pending_object(revs, &commit->object, arg);
1059 return 0;
1060 }
1061 }
1062 return -1;
1063 }
1064
1065 static const char cherry_usage[] =
1066 "git-cherry [-v] <upstream> [<head>] [<limit>]";
1067 int cmd_cherry(int argc, const char **argv, const char *prefix)
1068 {
1069 struct rev_info revs;
1070 struct patch_ids ids;
1071 struct commit *commit;
1072 struct commit_list *list = NULL;
1073 const char *upstream;
1074 const char *head = "HEAD";
1075 const char *limit = NULL;
1076 int verbose = 0;
1077
1078 if (argc > 1 && !strcmp(argv[1], "-v")) {
1079 verbose = 1;
1080 argc--;
1081 argv++;
1082 }
1083
1084 switch (argc) {
1085 case 4:
1086 limit = argv[3];
1087 /* FALLTHROUGH */
1088 case 3:
1089 head = argv[2];
1090 /* FALLTHROUGH */
1091 case 2:
1092 upstream = argv[1];
1093 break;
1094 default:
1095 usage(cherry_usage);
1096 }
1097
1098 init_revisions(&revs, prefix);
1099 revs.diff = 1;
1100 revs.combine_merges = 0;
1101 revs.ignore_merges = 1;
1102 DIFF_OPT_SET(&revs.diffopt, RECURSIVE);
1103
1104 if (add_pending_commit(head, &revs, 0))
1105 die("Unknown commit %s", head);
1106 if (add_pending_commit(upstream, &revs, UNINTERESTING))
1107 die("Unknown commit %s", upstream);
1108
1109 /* Don't say anything if head and upstream are the same. */
1110 if (revs.pending.nr == 2) {
1111 struct object_array_entry *o = revs.pending.objects;
1112 if (hashcmp(o[0].item->sha1, o[1].item->sha1) == 0)
1113 return 0;
1114 }
1115
1116 get_patch_ids(&revs, &ids, prefix);
1117
1118 if (limit && add_pending_commit(limit, &revs, UNINTERESTING))
1119 die("Unknown commit %s", limit);
1120
1121 /* reverse the list of commits */
1122 if (prepare_revision_walk(&revs))
1123 die("revision walk setup failed");
1124 while ((commit = get_revision(&revs)) != NULL) {
1125 /* ignore merges */
1126 if (commit->parents && commit->parents->next)
1127 continue;
1128
1129 commit_list_insert(commit, &list);
1130 }
1131
1132 while (list) {
1133 char sign = '+';
1134
1135 commit = list->item;
1136 if (has_commit_patch_id(commit, &ids))
1137 sign = '-';
1138
1139 if (verbose) {
1140 struct strbuf buf;
1141 strbuf_init(&buf, 0);
1142 pretty_print_commit(CMIT_FMT_ONELINE, commit,
1143 &buf, 0, NULL, NULL, 0, 0);
1144 printf("%c %s %s\n", sign,
1145 sha1_to_hex(commit->object.sha1), buf.buf);
1146 strbuf_release(&buf);
1147 }
1148 else {
1149 printf("%c %s\n", sign,
1150 sha1_to_hex(commit->object.sha1));
1151 }
1152
1153 list = list->next;
1154 }
1155
1156 free_patch_ids(&ids);
1157 return 0;
1158 }