b71cf9ba41b3311b47cbf75bf894f8aeca5ef078
   1#include "cache.h"
   2#include "diff.h"
   3#include "commit.h"
   4#include "log-tree.h"
   5
   6static void show_parents(struct commit *commit, int abbrev)
   7{
   8        struct commit_list *p;
   9        for (p = commit->parents; p ; p = p->next) {
  10                struct commit *parent = p->item;
  11                printf(" %s", diff_unique_abbrev(parent->object.sha1, abbrev));
  12        }
  13}
  14
  15static int append_signoff(char *buf, int buf_sz, int at, const char *signoff)
  16{
  17        int signoff_len = strlen(signoff);
  18        static const char signed_off_by[] = "Signed-off-by: ";
  19        char *cp = buf;
  20
  21        /* Do we have enough space to add it? */
  22        if (buf_sz - at <= strlen(signed_off_by) + signoff_len + 2)
  23                return at;
  24
  25        /* First see if we already have the sign-off by the signer */
  26        while (1) {
  27                cp = strstr(cp, signed_off_by);
  28                if (!cp)
  29                        break;
  30                cp += strlen(signed_off_by);
  31                if ((cp + signoff_len < buf + at) &&
  32                    !strncmp(cp, signoff, signoff_len) &&
  33                    isspace(cp[signoff_len]))
  34                        return at; /* we already have him */
  35        }
  36
  37        strcpy(buf + at, signed_off_by);
  38        at += strlen(signed_off_by);
  39        strcpy(buf + at, signoff);
  40        at += signoff_len;
  41        buf[at++] = '\n';
  42        buf[at] = 0;
  43        return at;
  44}
  45
  46void show_log(struct rev_info *opt, const char *sep)
  47{
  48        static char this_header[16384];
  49        struct log_info *log = opt->loginfo;
  50        struct commit *commit = log->commit, *parent = log->parent;
  51        int abbrev = opt->diffopt.abbrev;
  52        int abbrev_commit = opt->abbrev_commit ? opt->abbrev : 40;
  53        const char *extra;
  54        int len;
  55        const char *subject = NULL, *extra_headers = opt->extra_headers;
  56
  57        opt->loginfo = NULL;
  58        if (!opt->verbose_header) {
  59                fputs(diff_unique_abbrev(commit->object.sha1, abbrev_commit), stdout);
  60                if (opt->parents)
  61                        show_parents(commit, abbrev_commit);
  62                putchar('\n');
  63                return;
  64        }
  65
  66        /*
  67         * The "oneline" format has several special cases:
  68         *  - The pretty-printed commit lacks a newline at the end
  69         *    of the buffer, but we do want to make sure that we
  70         *    have a newline there. If the separator isn't already
  71         *    a newline, add an extra one.
  72         *  - unlike other log messages, the one-line format does
  73         *    not have an empty line between entries.
  74         */
  75        extra = "";
  76        if (*sep != '\n' && opt->commit_format == CMIT_FMT_ONELINE)
  77                extra = "\n";
  78        if (opt->shown_one && opt->commit_format != CMIT_FMT_ONELINE)
  79                putchar('\n');
  80        opt->shown_one = 1;
  81
  82        /*
  83         * Print header line of header..
  84         */
  85
  86        if (opt->commit_format == CMIT_FMT_EMAIL) {
  87                char *sha1 = sha1_to_hex(commit->object.sha1);
  88                if (opt->total > 0) {
  89                        static char buffer[64];
  90                        snprintf(buffer, sizeof(buffer),
  91                                        "Subject: [PATCH %d/%d] ",
  92                                        opt->nr, opt->total);
  93                        subject = buffer;
  94                } else if (opt->total == 0)
  95                        subject = "Subject: [PATCH] ";
  96                else
  97                        subject = "Subject: ";
  98
  99                printf("From %s Mon Sep 17 00:00:00 2001\n", sha1);
 100                if (opt->mime_boundary) {
 101                        static char subject_buffer[1024];
 102                        static char buffer[1024];
 103                        snprintf(subject_buffer, sizeof(subject_buffer) - 1,
 104                                 "%s"
 105                                 "MIME-Version: 1.0\n"
 106                                 "Content-Type: multipart/mixed;\n"
 107                                 " boundary=\"%s%s\"\n"
 108                                 "\n"
 109                                 "This is a multi-part message in MIME "
 110                                 "format.\n"
 111                                 "--%s%s\n"
 112                                 "Content-Type: text/plain; "
 113                                 "charset=UTF-8; format=fixed\n"
 114                                 "Content-Transfer-Encoding: 8bit\n\n",
 115                                 extra_headers ? extra_headers : "",
 116                                 mime_boundary_leader, opt->mime_boundary,
 117                                 mime_boundary_leader, opt->mime_boundary);
 118                        extra_headers = subject_buffer;
 119
 120                        snprintf(buffer, sizeof(buffer) - 1,
 121                                 "--%s%s\n"
 122                                 "Content-Type: text/x-patch;\n"
 123                                 " name=\"%s.diff\"\n"
 124                                 "Content-Transfer-Encoding: 8bit\n"
 125                                 "Content-Disposition: inline;\n"
 126                                 " filename=\"%s.diff\"\n\n",
 127                                 mime_boundary_leader, opt->mime_boundary,
 128                                 sha1, sha1);
 129                        opt->diffopt.stat_sep = buffer;
 130                }
 131        } else {
 132                printf("%s%s%s",
 133                       diff_get_color(opt->diffopt.color_diff, DIFF_COMMIT),
 134                       opt->commit_format == CMIT_FMT_ONELINE ? "" : "commit ",
 135                       diff_unique_abbrev(commit->object.sha1, abbrev_commit));
 136                if (opt->parents)
 137                        show_parents(commit, abbrev_commit);
 138                if (parent)
 139                        printf(" (from %s)",
 140                               diff_unique_abbrev(parent->object.sha1,
 141                                                  abbrev_commit));
 142                putchar(opt->commit_format == CMIT_FMT_ONELINE ? ' ' : '\n');
 143                printf("%s",
 144                       diff_get_color(opt->diffopt.color_diff, DIFF_RESET));
 145        }
 146
 147        /*
 148         * And then the pretty-printed message itself
 149         */
 150        len = pretty_print_commit(opt->commit_format, commit, ~0u, this_header, sizeof(this_header), abbrev, subject, extra_headers);
 151
 152        if (opt->add_signoff)
 153                len = append_signoff(this_header, sizeof(this_header), len,
 154                                     opt->add_signoff);
 155        printf("%s%s%s", this_header, extra, sep);
 156}
 157
 158int log_tree_diff_flush(struct rev_info *opt)
 159{
 160        diffcore_std(&opt->diffopt);
 161
 162        if (diff_queue_is_empty()) {
 163                int saved_fmt = opt->diffopt.output_format;
 164                opt->diffopt.output_format = DIFF_FORMAT_NO_OUTPUT;
 165                diff_flush(&opt->diffopt);
 166                opt->diffopt.output_format = saved_fmt;
 167                return 0;
 168        }
 169
 170        if (opt->loginfo && !opt->no_commit_id) {
 171                /* When showing a verbose header (i.e. log message),
 172                 * and not in --pretty=oneline format, we would want
 173                 * an extra newline between the end of log and the
 174                 * output for readability.
 175                 */
 176                show_log(opt, opt->diffopt.msg_sep);
 177                if (opt->verbose_header &&
 178                    opt->commit_format != CMIT_FMT_ONELINE) {
 179                        int pch = DIFF_FORMAT_DIFFSTAT | DIFF_FORMAT_PATCH;
 180                        if ((pch & opt->diffopt.output_format) == pch)
 181                                printf("---%c", opt->diffopt.line_termination);
 182                        else
 183                                putchar(opt->diffopt.line_termination);
 184                }
 185        }
 186        diff_flush(&opt->diffopt);
 187        return 1;
 188}
 189
 190static int diff_root_tree(struct rev_info *opt,
 191                          const unsigned char *new, const char *base)
 192{
 193        int retval;
 194        void *tree;
 195        struct tree_desc empty, real;
 196
 197        tree = read_object_with_reference(new, tree_type, &real.size, NULL);
 198        if (!tree)
 199                die("unable to read root tree (%s)", sha1_to_hex(new));
 200        real.buf = tree;
 201
 202        empty.buf = "";
 203        empty.size = 0;
 204        retval = diff_tree(&empty, &real, base, &opt->diffopt);
 205        free(tree);
 206        log_tree_diff_flush(opt);
 207        return retval;
 208}
 209
 210static int do_diff_combined(struct rev_info *opt, struct commit *commit)
 211{
 212        unsigned const char *sha1 = commit->object.sha1;
 213
 214        diff_tree_combined_merge(sha1, opt->dense_combined_merges, opt);
 215        return !opt->loginfo;
 216}
 217
 218/*
 219 * Show the diff of a commit.
 220 *
 221 * Return true if we printed any log info messages
 222 */
 223static int log_tree_diff(struct rev_info *opt, struct commit *commit, struct log_info *log)
 224{
 225        int showed_log;
 226        struct commit_list *parents;
 227        unsigned const char *sha1 = commit->object.sha1;
 228
 229        if (!opt->diff)
 230                return 0;
 231
 232        /* Root commit? */
 233        parents = commit->parents;
 234        if (!parents) {
 235                if (opt->show_root_diff)
 236                        diff_root_tree(opt, sha1, "");
 237                return !opt->loginfo;
 238        }
 239
 240        /* More than one parent? */
 241        if (parents && parents->next) {
 242                if (opt->ignore_merges)
 243                        return 0;
 244                else if (opt->combine_merges)
 245                        return do_diff_combined(opt, commit);
 246
 247                /* If we show individual diffs, show the parent info */
 248                log->parent = parents->item;
 249        }
 250
 251        showed_log = 0;
 252        for (;;) {
 253                struct commit *parent = parents->item;
 254
 255                diff_tree_sha1(parent->object.sha1, sha1, "", &opt->diffopt);
 256                log_tree_diff_flush(opt);
 257
 258                showed_log |= !opt->loginfo;
 259
 260                /* Set up the log info for the next parent, if any.. */
 261                parents = parents->next;
 262                if (!parents)
 263                        break;
 264                log->parent = parents->item;
 265                opt->loginfo = log;
 266        }
 267        return showed_log;
 268}
 269
 270int log_tree_commit(struct rev_info *opt, struct commit *commit)
 271{
 272        struct log_info log;
 273        int shown;
 274
 275        log.commit = commit;
 276        log.parent = NULL;
 277        opt->loginfo = &log;
 278
 279        shown = log_tree_diff(opt, commit, &log);
 280        if (!shown && opt->loginfo && opt->always_show_header) {
 281                log.parent = NULL;
 282                show_log(opt, "");
 283                shown = 1;
 284        }
 285        opt->loginfo = NULL;
 286        return shown;
 287}