Merge branch 'cb/filter-branch-prune-empty-degenerate-merges'
[git] / log-tree.c
1 #include "cache.h"
2 #include "diff.h"
3 #include "commit.h"
4 #include "tag.h"
5 #include "graph.h"
6 #include "log-tree.h"
7 #include "reflog-walk.h"
8 #include "refs.h"
9 #include "string-list.h"
10 #include "color.h"
11 #include "gpg-interface.h"
12 #include "sequencer.h"
13 #include "line-log.h"
14
15 struct decoration name_decoration = { "object names" };
16
17 enum decoration_type {
18         DECORATION_NONE = 0,
19         DECORATION_REF_LOCAL,
20         DECORATION_REF_REMOTE,
21         DECORATION_REF_TAG,
22         DECORATION_REF_STASH,
23         DECORATION_REF_HEAD,
24         DECORATION_GRAFTED,
25 };
26
27 static char decoration_colors[][COLOR_MAXLEN] = {
28         GIT_COLOR_RESET,
29         GIT_COLOR_BOLD_GREEN,   /* REF_LOCAL */
30         GIT_COLOR_BOLD_RED,     /* REF_REMOTE */
31         GIT_COLOR_BOLD_YELLOW,  /* REF_TAG */
32         GIT_COLOR_BOLD_MAGENTA, /* REF_STASH */
33         GIT_COLOR_BOLD_CYAN,    /* REF_HEAD */
34         GIT_COLOR_BOLD_BLUE,    /* GRAFTED */
35 };
36
37 static const char *decorate_get_color(int decorate_use_color, enum decoration_type ix)
38 {
39         if (want_color(decorate_use_color))
40                 return decoration_colors[ix];
41         return "";
42 }
43
44 static int parse_decorate_color_slot(const char *slot)
45 {
46         /*
47          * We're comparing with 'ignore-case' on
48          * (because config.c sets them all tolower),
49          * but let's match the letters in the literal
50          * string values here with how they are
51          * documented in Documentation/config.txt, for
52          * consistency.
53          *
54          * We love being consistent, don't we?
55          */
56         if (!strcasecmp(slot, "branch"))
57                 return DECORATION_REF_LOCAL;
58         if (!strcasecmp(slot, "remoteBranch"))
59                 return DECORATION_REF_REMOTE;
60         if (!strcasecmp(slot, "tag"))
61                 return DECORATION_REF_TAG;
62         if (!strcasecmp(slot, "stash"))
63                 return DECORATION_REF_STASH;
64         if (!strcasecmp(slot, "HEAD"))
65                 return DECORATION_REF_HEAD;
66         return -1;
67 }
68
69 int parse_decorate_color_config(const char *var, const int ofs, const char *value)
70 {
71         int slot = parse_decorate_color_slot(var + ofs);
72         if (slot < 0)
73                 return 0;
74         if (!value)
75                 return config_error_nonbool(var);
76         color_parse(value, var, decoration_colors[slot]);
77         return 0;
78 }
79
80 /*
81  * log-tree.c uses DIFF_OPT_TST for determining whether to use color
82  * for showing the commit sha1, use the same check for --decorate
83  */
84 #define decorate_get_color_opt(o, ix) \
85         decorate_get_color((o)->use_color, ix)
86
87 static void add_name_decoration(enum decoration_type type, const char *name, struct object *obj)
88 {
89         int nlen = strlen(name);
90         struct name_decoration *res = xmalloc(sizeof(struct name_decoration) + nlen);
91         memcpy(res->name, name, nlen + 1);
92         res->type = type;
93         res->next = add_decoration(&name_decoration, obj, res);
94 }
95
96 static int add_ref_decoration(const char *refname, const unsigned char *sha1, int flags, void *cb_data)
97 {
98         struct object *obj;
99         enum decoration_type type = DECORATION_NONE;
100
101         if (starts_with(refname, "refs/replace/")) {
102                 unsigned char original_sha1[20];
103                 if (!check_replace_refs)
104                         return 0;
105                 if (get_sha1_hex(refname + 13, original_sha1)) {
106                         warning("invalid replace ref %s", refname);
107                         return 0;
108                 }
109                 obj = parse_object(original_sha1);
110                 if (obj)
111                         add_name_decoration(DECORATION_GRAFTED, "replaced", obj);
112                 return 0;
113         }
114
115         obj = parse_object(sha1);
116         if (!obj)
117                 return 0;
118
119         if (starts_with(refname, "refs/heads/"))
120                 type = DECORATION_REF_LOCAL;
121         else if (starts_with(refname, "refs/remotes/"))
122                 type = DECORATION_REF_REMOTE;
123         else if (starts_with(refname, "refs/tags/"))
124                 type = DECORATION_REF_TAG;
125         else if (!strcmp(refname, "refs/stash"))
126                 type = DECORATION_REF_STASH;
127         else if (!strcmp(refname, "HEAD"))
128                 type = DECORATION_REF_HEAD;
129
130         if (!cb_data || *(int *)cb_data == DECORATE_SHORT_REFS)
131                 refname = prettify_refname(refname);
132         add_name_decoration(type, refname, obj);
133         while (obj->type == OBJ_TAG) {
134                 obj = ((struct tag *)obj)->tagged;
135                 if (!obj)
136                         break;
137                 if (!obj->parsed)
138                         parse_object(obj->sha1);
139                 add_name_decoration(DECORATION_REF_TAG, refname, obj);
140         }
141         return 0;
142 }
143
144 static int add_graft_decoration(const struct commit_graft *graft, void *cb_data)
145 {
146         struct commit *commit = lookup_commit(graft->sha1);
147         if (!commit)
148                 return 0;
149         add_name_decoration(DECORATION_GRAFTED, "grafted", &commit->object);
150         return 0;
151 }
152
153 void load_ref_decorations(int flags)
154 {
155         static int loaded;
156         if (!loaded) {
157                 loaded = 1;
158                 for_each_ref(add_ref_decoration, &flags);
159                 head_ref(add_ref_decoration, &flags);
160                 for_each_commit_graft(add_graft_decoration, NULL);
161         }
162 }
163
164 static void show_parents(struct commit *commit, int abbrev)
165 {
166         struct commit_list *p;
167         for (p = commit->parents; p ; p = p->next) {
168                 struct commit *parent = p->item;
169                 printf(" %s", find_unique_abbrev(parent->object.sha1, abbrev));
170         }
171 }
172
173 static void show_children(struct rev_info *opt, struct commit *commit, int abbrev)
174 {
175         struct commit_list *p = lookup_decoration(&opt->children, &commit->object);
176         for ( ; p; p = p->next) {
177                 printf(" %s", find_unique_abbrev(p->item->object.sha1, abbrev));
178         }
179 }
180
181 /*
182  * The caller makes sure there is no funny color before
183  * calling. format_decorations makes sure the same after return.
184  */
185 void format_decorations(struct strbuf *sb,
186                         const struct commit *commit,
187                         int use_color)
188 {
189         const char *prefix;
190         struct name_decoration *decoration;
191         const char *color_commit =
192                 diff_get_color(use_color, DIFF_COMMIT);
193         const char *color_reset =
194                 decorate_get_color(use_color, DECORATION_NONE);
195
196         decoration = lookup_decoration(&name_decoration, &commit->object);
197         if (!decoration)
198                 return;
199         prefix = " (";
200         while (decoration) {
201                 strbuf_addstr(sb, color_commit);
202                 strbuf_addstr(sb, prefix);
203                 strbuf_addstr(sb, decorate_get_color(use_color, decoration->type));
204                 if (decoration->type == DECORATION_REF_TAG)
205                         strbuf_addstr(sb, "tag: ");
206                 strbuf_addstr(sb, decoration->name);
207                 strbuf_addstr(sb, color_reset);
208                 prefix = ", ";
209                 decoration = decoration->next;
210         }
211         strbuf_addstr(sb, color_commit);
212         strbuf_addch(sb, ')');
213         strbuf_addstr(sb, color_reset);
214 }
215
216 void show_decorations(struct rev_info *opt, struct commit *commit)
217 {
218         struct strbuf sb = STRBUF_INIT;
219
220         if (opt->show_source && commit->util)
221                 printf("\t%s", (char *) commit->util);
222         if (!opt->show_decorations)
223                 return;
224         format_decorations(&sb, commit, opt->diffopt.use_color);
225         fputs(sb.buf, stdout);
226         strbuf_release(&sb);
227 }
228
229 static unsigned int digits_in_number(unsigned int number)
230 {
231         unsigned int i = 10, result = 1;
232         while (i <= number) {
233                 i *= 10;
234                 result++;
235         }
236         return result;
237 }
238
239 void fmt_output_subject(struct strbuf *filename,
240                         const char *subject,
241                         struct rev_info *info)
242 {
243         const char *suffix = info->patch_suffix;
244         int nr = info->nr;
245         int start_len = filename->len;
246         int max_len = start_len + FORMAT_PATCH_NAME_MAX - (strlen(suffix) + 1);
247
248         if (0 < info->reroll_count)
249                 strbuf_addf(filename, "v%d-", info->reroll_count);
250         strbuf_addf(filename, "%04d-%s", nr, subject);
251
252         if (max_len < filename->len)
253                 strbuf_setlen(filename, max_len);
254         strbuf_addstr(filename, suffix);
255 }
256
257 void fmt_output_commit(struct strbuf *filename,
258                        struct commit *commit,
259                        struct rev_info *info)
260 {
261         struct pretty_print_context ctx = {0};
262         struct strbuf subject = STRBUF_INIT;
263
264         format_commit_message(commit, "%f", &subject, &ctx);
265         fmt_output_subject(filename, subject.buf, info);
266         strbuf_release(&subject);
267 }
268
269 void log_write_email_headers(struct rev_info *opt, struct commit *commit,
270                              const char **subject_p,
271                              const char **extra_headers_p,
272                              int *need_8bit_cte_p)
273 {
274         const char *subject = NULL;
275         const char *extra_headers = opt->extra_headers;
276         const char *name = sha1_to_hex(commit->object.sha1);
277
278         *need_8bit_cte_p = 0; /* unknown */
279         if (opt->total > 0) {
280                 static char buffer[64];
281                 snprintf(buffer, sizeof(buffer),
282                          "Subject: [%s%s%0*d/%d] ",
283                          opt->subject_prefix,
284                          *opt->subject_prefix ? " " : "",
285                          digits_in_number(opt->total),
286                          opt->nr, opt->total);
287                 subject = buffer;
288         } else if (opt->total == 0 && opt->subject_prefix && *opt->subject_prefix) {
289                 static char buffer[256];
290                 snprintf(buffer, sizeof(buffer),
291                          "Subject: [%s] ",
292                          opt->subject_prefix);
293                 subject = buffer;
294         } else {
295                 subject = "Subject: ";
296         }
297
298         printf("From %s Mon Sep 17 00:00:00 2001\n", name);
299         graph_show_oneline(opt->graph);
300         if (opt->message_id) {
301                 printf("Message-Id: <%s>\n", opt->message_id);
302                 graph_show_oneline(opt->graph);
303         }
304         if (opt->ref_message_ids && opt->ref_message_ids->nr > 0) {
305                 int i, n;
306                 n = opt->ref_message_ids->nr;
307                 printf("In-Reply-To: <%s>\n", opt->ref_message_ids->items[n-1].string);
308                 for (i = 0; i < n; i++)
309                         printf("%s<%s>\n", (i > 0 ? "\t" : "References: "),
310                                opt->ref_message_ids->items[i].string);
311                 graph_show_oneline(opt->graph);
312         }
313         if (opt->mime_boundary) {
314                 static char subject_buffer[1024];
315                 static char buffer[1024];
316                 struct strbuf filename =  STRBUF_INIT;
317                 *need_8bit_cte_p = -1; /* NEVER */
318                 snprintf(subject_buffer, sizeof(subject_buffer) - 1,
319                          "%s"
320                          "MIME-Version: 1.0\n"
321                          "Content-Type: multipart/mixed;"
322                          " boundary=\"%s%s\"\n"
323                          "\n"
324                          "This is a multi-part message in MIME "
325                          "format.\n"
326                          "--%s%s\n"
327                          "Content-Type: text/plain; "
328                          "charset=UTF-8; format=fixed\n"
329                          "Content-Transfer-Encoding: 8bit\n\n",
330                          extra_headers ? extra_headers : "",
331                          mime_boundary_leader, opt->mime_boundary,
332                          mime_boundary_leader, opt->mime_boundary);
333                 extra_headers = subject_buffer;
334
335                 if (opt->numbered_files)
336                         strbuf_addf(&filename, "%d", opt->nr);
337                 else
338                         fmt_output_commit(&filename, commit, opt);
339                 snprintf(buffer, sizeof(buffer) - 1,
340                          "\n--%s%s\n"
341                          "Content-Type: text/x-patch;"
342                          " name=\"%s\"\n"
343                          "Content-Transfer-Encoding: 8bit\n"
344                          "Content-Disposition: %s;"
345                          " filename=\"%s\"\n\n",
346                          mime_boundary_leader, opt->mime_boundary,
347                          filename.buf,
348                          opt->no_inline ? "attachment" : "inline",
349                          filename.buf);
350                 opt->diffopt.stat_sep = buffer;
351                 strbuf_release(&filename);
352         }
353         *subject_p = subject;
354         *extra_headers_p = extra_headers;
355 }
356
357 static void show_sig_lines(struct rev_info *opt, int status, const char *bol)
358 {
359         const char *color, *reset, *eol;
360
361         color = diff_get_color_opt(&opt->diffopt,
362                                    status ? DIFF_WHITESPACE : DIFF_FRAGINFO);
363         reset = diff_get_color_opt(&opt->diffopt, DIFF_RESET);
364         while (*bol) {
365                 eol = strchrnul(bol, '\n');
366                 printf("%s%.*s%s%s", color, (int)(eol - bol), bol, reset,
367                        *eol ? "\n" : "");
368                 bol = (*eol) ? (eol + 1) : eol;
369         }
370 }
371
372 static void show_signature(struct rev_info *opt, struct commit *commit)
373 {
374         struct strbuf payload = STRBUF_INIT;
375         struct strbuf signature = STRBUF_INIT;
376         struct strbuf gpg_output = STRBUF_INIT;
377         int status;
378
379         if (parse_signed_commit(commit, &payload, &signature) <= 0)
380                 goto out;
381
382         status = verify_signed_buffer(payload.buf, payload.len,
383                                       signature.buf, signature.len,
384                                       &gpg_output, NULL);
385         if (status && !gpg_output.len)
386                 strbuf_addstr(&gpg_output, "No signature\n");
387
388         show_sig_lines(opt, status, gpg_output.buf);
389
390  out:
391         strbuf_release(&gpg_output);
392         strbuf_release(&payload);
393         strbuf_release(&signature);
394 }
395
396 static int which_parent(const unsigned char *sha1, const struct commit *commit)
397 {
398         int nth;
399         const struct commit_list *parent;
400
401         for (nth = 0, parent = commit->parents; parent; parent = parent->next) {
402                 if (!hashcmp(parent->item->object.sha1, sha1))
403                         return nth;
404                 nth++;
405         }
406         return -1;
407 }
408
409 static int is_common_merge(const struct commit *commit)
410 {
411         return (commit->parents
412                 && commit->parents->next
413                 && !commit->parents->next->next);
414 }
415
416 static void show_one_mergetag(struct rev_info *opt,
417                               struct commit_extra_header *extra,
418                               struct commit *commit)
419 {
420         unsigned char sha1[20];
421         struct tag *tag;
422         struct strbuf verify_message;
423         int status, nth;
424         size_t payload_size, gpg_message_offset;
425
426         hash_sha1_file(extra->value, extra->len, typename(OBJ_TAG), sha1);
427         tag = lookup_tag(sha1);
428         if (!tag)
429                 return; /* error message already given */
430
431         strbuf_init(&verify_message, 256);
432         if (parse_tag_buffer(tag, extra->value, extra->len))
433                 strbuf_addstr(&verify_message, "malformed mergetag\n");
434         else if (is_common_merge(commit) &&
435                  !hashcmp(tag->tagged->sha1,
436                           commit->parents->next->item->object.sha1))
437                 strbuf_addf(&verify_message,
438                             "merged tag '%s'\n", tag->tag);
439         else if ((nth = which_parent(tag->tagged->sha1, commit)) < 0)
440                 strbuf_addf(&verify_message, "tag %s names a non-parent %s\n",
441                                     tag->tag, tag->tagged->sha1);
442         else
443                 strbuf_addf(&verify_message,
444                             "parent #%d, tagged '%s'\n", nth + 1, tag->tag);
445         gpg_message_offset = verify_message.len;
446
447         payload_size = parse_signature(extra->value, extra->len);
448         status = -1;
449         if (extra->len > payload_size)
450                 if (verify_signed_buffer(extra->value, payload_size,
451                                          extra->value + payload_size,
452                                          extra->len - payload_size,
453                                          &verify_message, NULL)) {
454                         if (verify_message.len <= gpg_message_offset)
455                                 strbuf_addstr(&verify_message, "No signature\n");
456                         else
457                                 status = 0;
458                 }
459
460         show_sig_lines(opt, status, verify_message.buf);
461         strbuf_release(&verify_message);
462 }
463
464 static void show_mergetag(struct rev_info *opt, struct commit *commit)
465 {
466         struct commit_extra_header *extra, *to_free;
467
468         to_free = read_commit_extra_headers(commit, NULL);
469         for (extra = to_free; extra; extra = extra->next) {
470                 if (strcmp(extra->key, "mergetag"))
471                         continue; /* not a merge tag */
472                 show_one_mergetag(opt, extra, commit);
473         }
474         free_commit_extra_headers(to_free);
475 }
476
477 void show_log(struct rev_info *opt)
478 {
479         struct strbuf msgbuf = STRBUF_INIT;
480         struct log_info *log = opt->loginfo;
481         struct commit *commit = log->commit, *parent = log->parent;
482         int abbrev_commit = opt->abbrev_commit ? opt->abbrev : 40;
483         const char *extra_headers = opt->extra_headers;
484         struct pretty_print_context ctx = {0};
485
486         opt->loginfo = NULL;
487         if (!opt->verbose_header) {
488                 graph_show_commit(opt->graph);
489
490                 if (!opt->graph)
491                         put_revision_mark(opt, commit);
492                 fputs(find_unique_abbrev(commit->object.sha1, abbrev_commit), stdout);
493                 if (opt->print_parents)
494                         show_parents(commit, abbrev_commit);
495                 if (opt->children.name)
496                         show_children(opt, commit, abbrev_commit);
497                 show_decorations(opt, commit);
498                 if (opt->graph && !graph_is_commit_finished(opt->graph)) {
499                         putchar('\n');
500                         graph_show_remainder(opt->graph);
501                 }
502                 putchar(opt->diffopt.line_termination);
503                 return;
504         }
505
506         /*
507          * If use_terminator is set, we already handled any record termination
508          * at the end of the last record.
509          * Otherwise, add a diffopt.line_termination character before all
510          * entries but the first.  (IOW, as a separator between entries)
511          */
512         if (opt->shown_one && !opt->use_terminator) {
513                 /*
514                  * If entries are separated by a newline, the output
515                  * should look human-readable.  If the last entry ended
516                  * with a newline, print the graph output before this
517                  * newline.  Otherwise it will end up as a completely blank
518                  * line and will look like a gap in the graph.
519                  *
520                  * If the entry separator is not a newline, the output is
521                  * primarily intended for programmatic consumption, and we
522                  * never want the extra graph output before the entry
523                  * separator.
524                  */
525                 if (opt->diffopt.line_termination == '\n' &&
526                     !opt->missing_newline)
527                         graph_show_padding(opt->graph);
528                 putchar(opt->diffopt.line_termination);
529         }
530         opt->shown_one = 1;
531
532         /*
533          * If the history graph was requested,
534          * print the graph, up to this commit's line
535          */
536         graph_show_commit(opt->graph);
537
538         /*
539          * Print header line of header..
540          */
541
542         if (opt->commit_format == CMIT_FMT_EMAIL) {
543                 log_write_email_headers(opt, commit, &ctx.subject, &extra_headers,
544                                         &ctx.need_8bit_cte);
545         } else if (opt->commit_format != CMIT_FMT_USERFORMAT) {
546                 fputs(diff_get_color_opt(&opt->diffopt, DIFF_COMMIT), stdout);
547                 if (opt->commit_format != CMIT_FMT_ONELINE)
548                         fputs("commit ", stdout);
549
550                 if (!opt->graph)
551                         put_revision_mark(opt, commit);
552                 fputs(find_unique_abbrev(commit->object.sha1, abbrev_commit),
553                       stdout);
554                 if (opt->print_parents)
555                         show_parents(commit, abbrev_commit);
556                 if (opt->children.name)
557                         show_children(opt, commit, abbrev_commit);
558                 if (parent)
559                         printf(" (from %s)",
560                                find_unique_abbrev(parent->object.sha1,
561                                                   abbrev_commit));
562                 fputs(diff_get_color_opt(&opt->diffopt, DIFF_RESET), stdout);
563                 show_decorations(opt, commit);
564                 if (opt->commit_format == CMIT_FMT_ONELINE) {
565                         putchar(' ');
566                 } else {
567                         putchar('\n');
568                         graph_show_oneline(opt->graph);
569                 }
570                 if (opt->reflog_info) {
571                         /*
572                          * setup_revisions() ensures that opt->reflog_info
573                          * and opt->graph cannot both be set,
574                          * so we don't need to worry about printing the
575                          * graph info here.
576                          */
577                         show_reflog_message(opt->reflog_info,
578                                             opt->commit_format == CMIT_FMT_ONELINE,
579                                             opt->date_mode,
580                                             opt->date_mode_explicit);
581                         if (opt->commit_format == CMIT_FMT_ONELINE)
582                                 return;
583                 }
584         }
585
586         if (opt->show_signature) {
587                 show_signature(opt, commit);
588                 show_mergetag(opt, commit);
589         }
590
591         if (!get_cached_commit_buffer(commit, NULL))
592                 return;
593
594         if (opt->show_notes) {
595                 int raw;
596                 struct strbuf notebuf = STRBUF_INIT;
597
598                 raw = (opt->commit_format == CMIT_FMT_USERFORMAT);
599                 format_display_notes(commit->object.sha1, &notebuf,
600                                      get_log_output_encoding(), raw);
601                 ctx.notes_message = notebuf.len
602                         ? strbuf_detach(&notebuf, NULL)
603                         : xcalloc(1, 1);
604         }
605
606         /*
607          * And then the pretty-printed message itself
608          */
609         if (ctx.need_8bit_cte >= 0 && opt->add_signoff)
610                 ctx.need_8bit_cte =
611                         has_non_ascii(fmt_name(getenv("GIT_COMMITTER_NAME"),
612                                                getenv("GIT_COMMITTER_EMAIL")));
613         ctx.date_mode = opt->date_mode;
614         ctx.date_mode_explicit = opt->date_mode_explicit;
615         ctx.abbrev = opt->diffopt.abbrev;
616         ctx.after_subject = extra_headers;
617         ctx.preserve_subject = opt->preserve_subject;
618         ctx.reflog_info = opt->reflog_info;
619         ctx.fmt = opt->commit_format;
620         ctx.mailmap = opt->mailmap;
621         ctx.color = opt->diffopt.use_color;
622         ctx.output_encoding = get_log_output_encoding();
623         if (opt->from_ident.mail_begin && opt->from_ident.name_begin)
624                 ctx.from_ident = &opt->from_ident;
625         pretty_print_commit(&ctx, commit, &msgbuf);
626
627         if (opt->add_signoff)
628                 append_signoff(&msgbuf, 0, APPEND_SIGNOFF_DEDUP);
629
630         if ((ctx.fmt != CMIT_FMT_USERFORMAT) &&
631             ctx.notes_message && *ctx.notes_message) {
632                 if (ctx.fmt == CMIT_FMT_EMAIL) {
633                         strbuf_addstr(&msgbuf, "---\n");
634                         opt->shown_dashes = 1;
635                 }
636                 strbuf_addstr(&msgbuf, ctx.notes_message);
637         }
638
639         if (opt->show_log_size) {
640                 printf("log size %i\n", (int)msgbuf.len);
641                 graph_show_oneline(opt->graph);
642         }
643
644         /*
645          * Set opt->missing_newline if msgbuf doesn't
646          * end in a newline (including if it is empty)
647          */
648         if (!msgbuf.len || msgbuf.buf[msgbuf.len - 1] != '\n')
649                 opt->missing_newline = 1;
650         else
651                 opt->missing_newline = 0;
652
653         if (opt->graph)
654                 graph_show_commit_msg(opt->graph, &msgbuf);
655         else
656                 fwrite(msgbuf.buf, sizeof(char), msgbuf.len, stdout);
657         if (opt->use_terminator) {
658                 if (!opt->missing_newline)
659                         graph_show_padding(opt->graph);
660                 putchar(opt->diffopt.line_termination);
661         }
662
663         strbuf_release(&msgbuf);
664         free(ctx.notes_message);
665 }
666
667 int log_tree_diff_flush(struct rev_info *opt)
668 {
669         opt->shown_dashes = 0;
670         diffcore_std(&opt->diffopt);
671
672         if (diff_queue_is_empty()) {
673                 int saved_fmt = opt->diffopt.output_format;
674                 opt->diffopt.output_format = DIFF_FORMAT_NO_OUTPUT;
675                 diff_flush(&opt->diffopt);
676                 opt->diffopt.output_format = saved_fmt;
677                 return 0;
678         }
679
680         if (opt->loginfo && !opt->no_commit_id) {
681                 show_log(opt);
682                 if ((opt->diffopt.output_format & ~DIFF_FORMAT_NO_OUTPUT) &&
683                     opt->verbose_header &&
684                     opt->commit_format != CMIT_FMT_ONELINE) {
685                         /*
686                          * When showing a verbose header (i.e. log message),
687                          * and not in --pretty=oneline format, we would want
688                          * an extra newline between the end of log and the
689                          * diff/diffstat output for readability.
690                          */
691                         int pch = DIFF_FORMAT_DIFFSTAT | DIFF_FORMAT_PATCH;
692                         if (opt->diffopt.output_prefix) {
693                                 struct strbuf *msg = NULL;
694                                 msg = opt->diffopt.output_prefix(&opt->diffopt,
695                                         opt->diffopt.output_prefix_data);
696                                 fwrite(msg->buf, msg->len, 1, stdout);
697                         }
698
699                         /*
700                          * We may have shown three-dashes line early
701                          * between notes and the log message, in which
702                          * case we only want a blank line after the
703                          * notes without (an extra) three-dashes line.
704                          * Otherwise, we show the three-dashes line if
705                          * we are showing the patch with diffstat, but
706                          * in that case, there is no extra blank line
707                          * after the three-dashes line.
708                          */
709                         if (!opt->shown_dashes &&
710                             (pch & opt->diffopt.output_format) == pch)
711                                 printf("---");
712                         putchar('\n');
713                 }
714         }
715         diff_flush(&opt->diffopt);
716         return 1;
717 }
718
719 static int do_diff_combined(struct rev_info *opt, struct commit *commit)
720 {
721         diff_tree_combined_merge(commit, opt->dense_combined_merges, opt);
722         return !opt->loginfo;
723 }
724
725 /*
726  * Show the diff of a commit.
727  *
728  * Return true if we printed any log info messages
729  */
730 static int log_tree_diff(struct rev_info *opt, struct commit *commit, struct log_info *log)
731 {
732         int showed_log;
733         struct commit_list *parents;
734         unsigned const char *sha1;
735
736         if (!opt->diff && !DIFF_OPT_TST(&opt->diffopt, EXIT_WITH_STATUS))
737                 return 0;
738
739         parse_commit_or_die(commit);
740         sha1 = commit->tree->object.sha1;
741
742         /* Root commit? */
743         parents = get_saved_parents(opt, commit);
744         if (!parents) {
745                 if (opt->show_root_diff) {
746                         diff_root_tree_sha1(sha1, "", &opt->diffopt);
747                         log_tree_diff_flush(opt);
748                 }
749                 return !opt->loginfo;
750         }
751
752         /* More than one parent? */
753         if (parents && parents->next) {
754                 if (opt->ignore_merges)
755                         return 0;
756                 else if (opt->combine_merges)
757                         return do_diff_combined(opt, commit);
758                 else if (opt->first_parent_only) {
759                         /*
760                          * Generate merge log entry only for the first
761                          * parent, showing summary diff of the others
762                          * we merged _in_.
763                          */
764                         parse_commit_or_die(parents->item);
765                         diff_tree_sha1(parents->item->tree->object.sha1,
766                                        sha1, "", &opt->diffopt);
767                         log_tree_diff_flush(opt);
768                         return !opt->loginfo;
769                 }
770
771                 /* If we show individual diffs, show the parent info */
772                 log->parent = parents->item;
773         }
774
775         showed_log = 0;
776         for (;;) {
777                 struct commit *parent = parents->item;
778
779                 parse_commit_or_die(parent);
780                 diff_tree_sha1(parent->tree->object.sha1,
781                                sha1, "", &opt->diffopt);
782                 log_tree_diff_flush(opt);
783
784                 showed_log |= !opt->loginfo;
785
786                 /* Set up the log info for the next parent, if any.. */
787                 parents = parents->next;
788                 if (!parents)
789                         break;
790                 log->parent = parents->item;
791                 opt->loginfo = log;
792         }
793         return showed_log;
794 }
795
796 int log_tree_commit(struct rev_info *opt, struct commit *commit)
797 {
798         struct log_info log;
799         int shown;
800
801         log.commit = commit;
802         log.parent = NULL;
803         opt->loginfo = &log;
804
805         if (opt->line_level_traverse)
806                 return line_log_print(opt, commit);
807
808         if (opt->track_linear && !opt->linear && !opt->reverse_output_stage)
809                 printf("\n%s\n", opt->break_bar);
810         shown = log_tree_diff(opt, commit, &log);
811         if (!shown && opt->loginfo && opt->always_show_header) {
812                 log.parent = NULL;
813                 show_log(opt);
814                 shown = 1;
815         }
816         if (opt->track_linear && !opt->linear && opt->reverse_output_stage)
817                 printf("\n%s\n", opt->break_bar);
818         opt->loginfo = NULL;
819         maybe_flush_or_die(stdout, "stdout");
820         return shown;
821 }