Code

Merge branch 'jc/pull-signed-tag'
[git.git] / diff.c
1 /*
2  * Copyright (C) 2005 Junio C Hamano
3  */
4 #include "cache.h"
5 #include "quote.h"
6 #include "diff.h"
7 #include "diffcore.h"
8 #include "delta.h"
9 #include "xdiff-interface.h"
10 #include "color.h"
11 #include "attr.h"
12 #include "run-command.h"
13 #include "utf8.h"
14 #include "userdiff.h"
15 #include "sigchain.h"
16 #include "submodule.h"
17 #include "ll-merge.h"
19 #ifdef NO_FAST_WORKING_DIRECTORY
20 #define FAST_WORKING_DIRECTORY 0
21 #else
22 #define FAST_WORKING_DIRECTORY 1
23 #endif
25 static int diff_detect_rename_default;
26 static int diff_rename_limit_default = 400;
27 static int diff_suppress_blank_empty;
28 int diff_use_color_default = -1;
29 static const char *diff_word_regex_cfg;
30 static const char *external_diff_cmd_cfg;
31 int diff_auto_refresh_index = 1;
32 static int diff_mnemonic_prefix;
33 static int diff_no_prefix;
34 static int diff_dirstat_permille_default = 30;
35 static struct diff_options default_diff_options;
37 static char diff_colors[][COLOR_MAXLEN] = {
38         GIT_COLOR_RESET,
39         GIT_COLOR_NORMAL,       /* PLAIN */
40         GIT_COLOR_BOLD,         /* METAINFO */
41         GIT_COLOR_CYAN,         /* FRAGINFO */
42         GIT_COLOR_RED,          /* OLD */
43         GIT_COLOR_GREEN,        /* NEW */
44         GIT_COLOR_YELLOW,       /* COMMIT */
45         GIT_COLOR_BG_RED,       /* WHITESPACE */
46         GIT_COLOR_NORMAL,       /* FUNCINFO */
47 };
49 static int parse_diff_color_slot(const char *var, int ofs)
50 {
51         if (!strcasecmp(var+ofs, "plain"))
52                 return DIFF_PLAIN;
53         if (!strcasecmp(var+ofs, "meta"))
54                 return DIFF_METAINFO;
55         if (!strcasecmp(var+ofs, "frag"))
56                 return DIFF_FRAGINFO;
57         if (!strcasecmp(var+ofs, "old"))
58                 return DIFF_FILE_OLD;
59         if (!strcasecmp(var+ofs, "new"))
60                 return DIFF_FILE_NEW;
61         if (!strcasecmp(var+ofs, "commit"))
62                 return DIFF_COMMIT;
63         if (!strcasecmp(var+ofs, "whitespace"))
64                 return DIFF_WHITESPACE;
65         if (!strcasecmp(var+ofs, "func"))
66                 return DIFF_FUNCINFO;
67         return -1;
68 }
70 static int parse_dirstat_params(struct diff_options *options, const char *params,
71                                 struct strbuf *errmsg)
72 {
73         const char *p = params;
74         int p_len, ret = 0;
76         while (*p) {
77                 p_len = strchrnul(p, ',') - p;
78                 if (!memcmp(p, "changes", p_len)) {
79                         DIFF_OPT_CLR(options, DIRSTAT_BY_LINE);
80                         DIFF_OPT_CLR(options, DIRSTAT_BY_FILE);
81                 } else if (!memcmp(p, "lines", p_len)) {
82                         DIFF_OPT_SET(options, DIRSTAT_BY_LINE);
83                         DIFF_OPT_CLR(options, DIRSTAT_BY_FILE);
84                 } else if (!memcmp(p, "files", p_len)) {
85                         DIFF_OPT_CLR(options, DIRSTAT_BY_LINE);
86                         DIFF_OPT_SET(options, DIRSTAT_BY_FILE);
87                 } else if (!memcmp(p, "noncumulative", p_len)) {
88                         DIFF_OPT_CLR(options, DIRSTAT_CUMULATIVE);
89                 } else if (!memcmp(p, "cumulative", p_len)) {
90                         DIFF_OPT_SET(options, DIRSTAT_CUMULATIVE);
91                 } else if (isdigit(*p)) {
92                         char *end;
93                         int permille = strtoul(p, &end, 10) * 10;
94                         if (*end == '.' && isdigit(*++end)) {
95                                 /* only use first digit */
96                                 permille += *end - '0';
97                                 /* .. and ignore any further digits */
98                                 while (isdigit(*++end))
99                                         ; /* nothing */
100                         }
101                         if (end - p == p_len)
102                                 options->dirstat_permille = permille;
103                         else {
104                                 strbuf_addf(errmsg, _("  Failed to parse dirstat cut-off percentage '%.*s'\n"),
105                                             p_len, p);
106                                 ret++;
107                         }
108                 } else {
109                         strbuf_addf(errmsg, _("  Unknown dirstat parameter '%.*s'\n"),
110                                     p_len, p);
111                         ret++;
112                 }
114                 p += p_len;
116                 if (*p)
117                         p++; /* more parameters, swallow separator */
118         }
119         return ret;
122 static int git_config_rename(const char *var, const char *value)
124         if (!value)
125                 return DIFF_DETECT_RENAME;
126         if (!strcasecmp(value, "copies") || !strcasecmp(value, "copy"))
127                 return  DIFF_DETECT_COPY;
128         return git_config_bool(var,value) ? DIFF_DETECT_RENAME : 0;
131 /*
132  * These are to give UI layer defaults.
133  * The core-level commands such as git-diff-files should
134  * never be affected by the setting of diff.renames
135  * the user happens to have in the configuration file.
136  */
137 int git_diff_ui_config(const char *var, const char *value, void *cb)
139         if (!strcmp(var, "diff.color") || !strcmp(var, "color.diff")) {
140                 diff_use_color_default = git_config_colorbool(var, value);
141                 return 0;
142         }
143         if (!strcmp(var, "diff.renames")) {
144                 diff_detect_rename_default = git_config_rename(var, value);
145                 return 0;
146         }
147         if (!strcmp(var, "diff.autorefreshindex")) {
148                 diff_auto_refresh_index = git_config_bool(var, value);
149                 return 0;
150         }
151         if (!strcmp(var, "diff.mnemonicprefix")) {
152                 diff_mnemonic_prefix = git_config_bool(var, value);
153                 return 0;
154         }
155         if (!strcmp(var, "diff.noprefix")) {
156                 diff_no_prefix = git_config_bool(var, value);
157                 return 0;
158         }
159         if (!strcmp(var, "diff.external"))
160                 return git_config_string(&external_diff_cmd_cfg, var, value);
161         if (!strcmp(var, "diff.wordregex"))
162                 return git_config_string(&diff_word_regex_cfg, var, value);
164         if (!strcmp(var, "diff.ignoresubmodules"))
165                 handle_ignore_submodules_arg(&default_diff_options, value);
167         if (git_color_config(var, value, cb) < 0)
168                 return -1;
170         return git_diff_basic_config(var, value, cb);
173 int git_diff_basic_config(const char *var, const char *value, void *cb)
175         if (!strcmp(var, "diff.renamelimit")) {
176                 diff_rename_limit_default = git_config_int(var, value);
177                 return 0;
178         }
180         switch (userdiff_config(var, value)) {
181                 case 0: break;
182                 case -1: return -1;
183                 default: return 0;
184         }
186         if (!prefixcmp(var, "diff.color.") || !prefixcmp(var, "color.diff.")) {
187                 int slot = parse_diff_color_slot(var, 11);
188                 if (slot < 0)
189                         return 0;
190                 if (!value)
191                         return config_error_nonbool(var);
192                 color_parse(value, var, diff_colors[slot]);
193                 return 0;
194         }
196         /* like GNU diff's --suppress-blank-empty option  */
197         if (!strcmp(var, "diff.suppressblankempty") ||
198                         /* for backwards compatibility */
199                         !strcmp(var, "diff.suppress-blank-empty")) {
200                 diff_suppress_blank_empty = git_config_bool(var, value);
201                 return 0;
202         }
204         if (!strcmp(var, "diff.dirstat")) {
205                 struct strbuf errmsg = STRBUF_INIT;
206                 default_diff_options.dirstat_permille = diff_dirstat_permille_default;
207                 if (parse_dirstat_params(&default_diff_options, value, &errmsg))
208                         warning(_("Found errors in 'diff.dirstat' config variable:\n%s"),
209                                 errmsg.buf);
210                 strbuf_release(&errmsg);
211                 diff_dirstat_permille_default = default_diff_options.dirstat_permille;
212                 return 0;
213         }
215         if (!prefixcmp(var, "submodule."))
216                 return parse_submodule_config_option(var, value);
218         return git_default_config(var, value, cb);
221 static char *quote_two(const char *one, const char *two)
223         int need_one = quote_c_style(one, NULL, NULL, 1);
224         int need_two = quote_c_style(two, NULL, NULL, 1);
225         struct strbuf res = STRBUF_INIT;
227         if (need_one + need_two) {
228                 strbuf_addch(&res, '"');
229                 quote_c_style(one, &res, NULL, 1);
230                 quote_c_style(two, &res, NULL, 1);
231                 strbuf_addch(&res, '"');
232         } else {
233                 strbuf_addstr(&res, one);
234                 strbuf_addstr(&res, two);
235         }
236         return strbuf_detach(&res, NULL);
239 static const char *external_diff(void)
241         static const char *external_diff_cmd = NULL;
242         static int done_preparing = 0;
244         if (done_preparing)
245                 return external_diff_cmd;
246         external_diff_cmd = getenv("GIT_EXTERNAL_DIFF");
247         if (!external_diff_cmd)
248                 external_diff_cmd = external_diff_cmd_cfg;
249         done_preparing = 1;
250         return external_diff_cmd;
253 static struct diff_tempfile {
254         const char *name; /* filename external diff should read from */
255         char hex[41];
256         char mode[10];
257         char tmp_path[PATH_MAX];
258 } diff_temp[2];
260 typedef unsigned long (*sane_truncate_fn)(char *line, unsigned long len);
262 struct emit_callback {
263         int color_diff;
264         unsigned ws_rule;
265         int blank_at_eof_in_preimage;
266         int blank_at_eof_in_postimage;
267         int lno_in_preimage;
268         int lno_in_postimage;
269         sane_truncate_fn truncate;
270         const char **label_path;
271         struct diff_words_data *diff_words;
272         struct diff_options *opt;
273         int *found_changesp;
274         struct strbuf *header;
275 };
277 static int count_lines(const char *data, int size)
279         int count, ch, completely_empty = 1, nl_just_seen = 0;
280         count = 0;
281         while (0 < size--) {
282                 ch = *data++;
283                 if (ch == '\n') {
284                         count++;
285                         nl_just_seen = 1;
286                         completely_empty = 0;
287                 }
288                 else {
289                         nl_just_seen = 0;
290                         completely_empty = 0;
291                 }
292         }
293         if (completely_empty)
294                 return 0;
295         if (!nl_just_seen)
296                 count++; /* no trailing newline */
297         return count;
300 static int fill_mmfile(mmfile_t *mf, struct diff_filespec *one)
302         if (!DIFF_FILE_VALID(one)) {
303                 mf->ptr = (char *)""; /* does not matter */
304                 mf->size = 0;
305                 return 0;
306         }
307         else if (diff_populate_filespec(one, 0))
308                 return -1;
310         mf->ptr = one->data;
311         mf->size = one->size;
312         return 0;
315 /* like fill_mmfile, but only for size, so we can avoid retrieving blob */
316 static unsigned long diff_filespec_size(struct diff_filespec *one)
318         if (!DIFF_FILE_VALID(one))
319                 return 0;
320         diff_populate_filespec(one, 1);
321         return one->size;
324 static int count_trailing_blank(mmfile_t *mf, unsigned ws_rule)
326         char *ptr = mf->ptr;
327         long size = mf->size;
328         int cnt = 0;
330         if (!size)
331                 return cnt;
332         ptr += size - 1; /* pointing at the very end */
333         if (*ptr != '\n')
334                 ; /* incomplete line */
335         else
336                 ptr--; /* skip the last LF */
337         while (mf->ptr < ptr) {
338                 char *prev_eol;
339                 for (prev_eol = ptr; mf->ptr <= prev_eol; prev_eol--)
340                         if (*prev_eol == '\n')
341                                 break;
342                 if (!ws_blank_line(prev_eol + 1, ptr - prev_eol, ws_rule))
343                         break;
344                 cnt++;
345                 ptr = prev_eol - 1;
346         }
347         return cnt;
350 static void check_blank_at_eof(mmfile_t *mf1, mmfile_t *mf2,
351                                struct emit_callback *ecbdata)
353         int l1, l2, at;
354         unsigned ws_rule = ecbdata->ws_rule;
355         l1 = count_trailing_blank(mf1, ws_rule);
356         l2 = count_trailing_blank(mf2, ws_rule);
357         if (l2 <= l1) {
358                 ecbdata->blank_at_eof_in_preimage = 0;
359                 ecbdata->blank_at_eof_in_postimage = 0;
360                 return;
361         }
362         at = count_lines(mf1->ptr, mf1->size);
363         ecbdata->blank_at_eof_in_preimage = (at - l1) + 1;
365         at = count_lines(mf2->ptr, mf2->size);
366         ecbdata->blank_at_eof_in_postimage = (at - l2) + 1;
369 static void emit_line_0(struct diff_options *o, const char *set, const char *reset,
370                         int first, const char *line, int len)
372         int has_trailing_newline, has_trailing_carriage_return;
373         int nofirst;
374         FILE *file = o->file;
376         if (o->output_prefix) {
377                 struct strbuf *msg = NULL;
378                 msg = o->output_prefix(o, o->output_prefix_data);
379                 assert(msg);
380                 fwrite(msg->buf, msg->len, 1, file);
381         }
383         if (len == 0) {
384                 has_trailing_newline = (first == '\n');
385                 has_trailing_carriage_return = (!has_trailing_newline &&
386                                                 (first == '\r'));
387                 nofirst = has_trailing_newline || has_trailing_carriage_return;
388         } else {
389                 has_trailing_newline = (len > 0 && line[len-1] == '\n');
390                 if (has_trailing_newline)
391                         len--;
392                 has_trailing_carriage_return = (len > 0 && line[len-1] == '\r');
393                 if (has_trailing_carriage_return)
394                         len--;
395                 nofirst = 0;
396         }
398         if (len || !nofirst) {
399                 fputs(set, file);
400                 if (!nofirst)
401                         fputc(first, file);
402                 fwrite(line, len, 1, file);
403                 fputs(reset, file);
404         }
405         if (has_trailing_carriage_return)
406                 fputc('\r', file);
407         if (has_trailing_newline)
408                 fputc('\n', file);
411 static void emit_line(struct diff_options *o, const char *set, const char *reset,
412                       const char *line, int len)
414         emit_line_0(o, set, reset, line[0], line+1, len-1);
417 static int new_blank_line_at_eof(struct emit_callback *ecbdata, const char *line, int len)
419         if (!((ecbdata->ws_rule & WS_BLANK_AT_EOF) &&
420               ecbdata->blank_at_eof_in_preimage &&
421               ecbdata->blank_at_eof_in_postimage &&
422               ecbdata->blank_at_eof_in_preimage <= ecbdata->lno_in_preimage &&
423               ecbdata->blank_at_eof_in_postimage <= ecbdata->lno_in_postimage))
424                 return 0;
425         return ws_blank_line(line, len, ecbdata->ws_rule);
428 static void emit_add_line(const char *reset,
429                           struct emit_callback *ecbdata,
430                           const char *line, int len)
432         const char *ws = diff_get_color(ecbdata->color_diff, DIFF_WHITESPACE);
433         const char *set = diff_get_color(ecbdata->color_diff, DIFF_FILE_NEW);
435         if (!*ws)
436                 emit_line_0(ecbdata->opt, set, reset, '+', line, len);
437         else if (new_blank_line_at_eof(ecbdata, line, len))
438                 /* Blank line at EOF - paint '+' as well */
439                 emit_line_0(ecbdata->opt, ws, reset, '+', line, len);
440         else {
441                 /* Emit just the prefix, then the rest. */
442                 emit_line_0(ecbdata->opt, set, reset, '+', "", 0);
443                 ws_check_emit(line, len, ecbdata->ws_rule,
444                               ecbdata->opt->file, set, reset, ws);
445         }
448 static void emit_hunk_header(struct emit_callback *ecbdata,
449                              const char *line, int len)
451         const char *plain = diff_get_color(ecbdata->color_diff, DIFF_PLAIN);
452         const char *frag = diff_get_color(ecbdata->color_diff, DIFF_FRAGINFO);
453         const char *func = diff_get_color(ecbdata->color_diff, DIFF_FUNCINFO);
454         const char *reset = diff_get_color(ecbdata->color_diff, DIFF_RESET);
455         static const char atat[2] = { '@', '@' };
456         const char *cp, *ep;
457         struct strbuf msgbuf = STRBUF_INIT;
458         int org_len = len;
459         int i = 1;
461         /*
462          * As a hunk header must begin with "@@ -<old>, +<new> @@",
463          * it always is at least 10 bytes long.
464          */
465         if (len < 10 ||
466             memcmp(line, atat, 2) ||
467             !(ep = memmem(line + 2, len - 2, atat, 2))) {
468                 emit_line(ecbdata->opt, plain, reset, line, len);
469                 return;
470         }
471         ep += 2; /* skip over @@ */
473         /* The hunk header in fraginfo color */
474         strbuf_add(&msgbuf, frag, strlen(frag));
475         strbuf_add(&msgbuf, line, ep - line);
476         strbuf_add(&msgbuf, reset, strlen(reset));
478         /*
479          * trailing "\r\n"
480          */
481         for ( ; i < 3; i++)
482                 if (line[len - i] == '\r' || line[len - i] == '\n')
483                         len--;
485         /* blank before the func header */
486         for (cp = ep; ep - line < len; ep++)
487                 if (*ep != ' ' && *ep != '\t')
488                         break;
489         if (ep != cp) {
490                 strbuf_add(&msgbuf, plain, strlen(plain));
491                 strbuf_add(&msgbuf, cp, ep - cp);
492                 strbuf_add(&msgbuf, reset, strlen(reset));
493         }
495         if (ep < line + len) {
496                 strbuf_add(&msgbuf, func, strlen(func));
497                 strbuf_add(&msgbuf, ep, line + len - ep);
498                 strbuf_add(&msgbuf, reset, strlen(reset));
499         }
501         strbuf_add(&msgbuf, line + len, org_len - len);
502         emit_line(ecbdata->opt, "", "", msgbuf.buf, msgbuf.len);
503         strbuf_release(&msgbuf);
506 static struct diff_tempfile *claim_diff_tempfile(void) {
507         int i;
508         for (i = 0; i < ARRAY_SIZE(diff_temp); i++)
509                 if (!diff_temp[i].name)
510                         return diff_temp + i;
511         die("BUG: diff is failing to clean up its tempfiles");
514 static int remove_tempfile_installed;
516 static void remove_tempfile(void)
518         int i;
519         for (i = 0; i < ARRAY_SIZE(diff_temp); i++) {
520                 if (diff_temp[i].name == diff_temp[i].tmp_path)
521                         unlink_or_warn(diff_temp[i].name);
522                 diff_temp[i].name = NULL;
523         }
526 static void remove_tempfile_on_signal(int signo)
528         remove_tempfile();
529         sigchain_pop(signo);
530         raise(signo);
533 static void print_line_count(FILE *file, int count)
535         switch (count) {
536         case 0:
537                 fprintf(file, "0,0");
538                 break;
539         case 1:
540                 fprintf(file, "1");
541                 break;
542         default:
543                 fprintf(file, "1,%d", count);
544                 break;
545         }
548 static void emit_rewrite_lines(struct emit_callback *ecb,
549                                int prefix, const char *data, int size)
551         const char *endp = NULL;
552         static const char *nneof = " No newline at end of file\n";
553         const char *old = diff_get_color(ecb->color_diff, DIFF_FILE_OLD);
554         const char *reset = diff_get_color(ecb->color_diff, DIFF_RESET);
556         while (0 < size) {
557                 int len;
559                 endp = memchr(data, '\n', size);
560                 len = endp ? (endp - data + 1) : size;
561                 if (prefix != '+') {
562                         ecb->lno_in_preimage++;
563                         emit_line_0(ecb->opt, old, reset, '-',
564                                     data, len);
565                 } else {
566                         ecb->lno_in_postimage++;
567                         emit_add_line(reset, ecb, data, len);
568                 }
569                 size -= len;
570                 data += len;
571         }
572         if (!endp) {
573                 const char *plain = diff_get_color(ecb->color_diff,
574                                                    DIFF_PLAIN);
575                 emit_line_0(ecb->opt, plain, reset, '\\',
576                             nneof, strlen(nneof));
577         }
580 static void emit_rewrite_diff(const char *name_a,
581                               const char *name_b,
582                               struct diff_filespec *one,
583                               struct diff_filespec *two,
584                               struct userdiff_driver *textconv_one,
585                               struct userdiff_driver *textconv_two,
586                               struct diff_options *o)
588         int lc_a, lc_b;
589         const char *name_a_tab, *name_b_tab;
590         const char *metainfo = diff_get_color(o->use_color, DIFF_METAINFO);
591         const char *fraginfo = diff_get_color(o->use_color, DIFF_FRAGINFO);
592         const char *reset = diff_get_color(o->use_color, DIFF_RESET);
593         static struct strbuf a_name = STRBUF_INIT, b_name = STRBUF_INIT;
594         const char *a_prefix, *b_prefix;
595         char *data_one, *data_two;
596         size_t size_one, size_two;
597         struct emit_callback ecbdata;
598         char *line_prefix = "";
599         struct strbuf *msgbuf;
601         if (o && o->output_prefix) {
602                 msgbuf = o->output_prefix(o, o->output_prefix_data);
603                 line_prefix = msgbuf->buf;
604         }
606         if (diff_mnemonic_prefix && DIFF_OPT_TST(o, REVERSE_DIFF)) {
607                 a_prefix = o->b_prefix;
608                 b_prefix = o->a_prefix;
609         } else {
610                 a_prefix = o->a_prefix;
611                 b_prefix = o->b_prefix;
612         }
614         name_a += (*name_a == '/');
615         name_b += (*name_b == '/');
616         name_a_tab = strchr(name_a, ' ') ? "\t" : "";
617         name_b_tab = strchr(name_b, ' ') ? "\t" : "";
619         strbuf_reset(&a_name);
620         strbuf_reset(&b_name);
621         quote_two_c_style(&a_name, a_prefix, name_a, 0);
622         quote_two_c_style(&b_name, b_prefix, name_b, 0);
624         size_one = fill_textconv(textconv_one, one, &data_one);
625         size_two = fill_textconv(textconv_two, two, &data_two);
627         memset(&ecbdata, 0, sizeof(ecbdata));
628         ecbdata.color_diff = want_color(o->use_color);
629         ecbdata.found_changesp = &o->found_changes;
630         ecbdata.ws_rule = whitespace_rule(name_b ? name_b : name_a);
631         ecbdata.opt = o;
632         if (ecbdata.ws_rule & WS_BLANK_AT_EOF) {
633                 mmfile_t mf1, mf2;
634                 mf1.ptr = (char *)data_one;
635                 mf2.ptr = (char *)data_two;
636                 mf1.size = size_one;
637                 mf2.size = size_two;
638                 check_blank_at_eof(&mf1, &mf2, &ecbdata);
639         }
640         ecbdata.lno_in_preimage = 1;
641         ecbdata.lno_in_postimage = 1;
643         lc_a = count_lines(data_one, size_one);
644         lc_b = count_lines(data_two, size_two);
645         fprintf(o->file,
646                 "%s%s--- %s%s%s\n%s%s+++ %s%s%s\n%s%s@@ -",
647                 line_prefix, metainfo, a_name.buf, name_a_tab, reset,
648                 line_prefix, metainfo, b_name.buf, name_b_tab, reset,
649                 line_prefix, fraginfo);
650         if (!o->irreversible_delete)
651                 print_line_count(o->file, lc_a);
652         else
653                 fprintf(o->file, "?,?");
654         fprintf(o->file, " +");
655         print_line_count(o->file, lc_b);
656         fprintf(o->file, " @@%s\n", reset);
657         if (lc_a && !o->irreversible_delete)
658                 emit_rewrite_lines(&ecbdata, '-', data_one, size_one);
659         if (lc_b)
660                 emit_rewrite_lines(&ecbdata, '+', data_two, size_two);
661         if (textconv_one)
662                 free((char *)data_one);
663         if (textconv_two)
664                 free((char *)data_two);
667 struct diff_words_buffer {
668         mmfile_t text;
669         long alloc;
670         struct diff_words_orig {
671                 const char *begin, *end;
672         } *orig;
673         int orig_nr, orig_alloc;
674 };
676 static void diff_words_append(char *line, unsigned long len,
677                 struct diff_words_buffer *buffer)
679         ALLOC_GROW(buffer->text.ptr, buffer->text.size + len, buffer->alloc);
680         line++;
681         len--;
682         memcpy(buffer->text.ptr + buffer->text.size, line, len);
683         buffer->text.size += len;
684         buffer->text.ptr[buffer->text.size] = '\0';
687 struct diff_words_style_elem {
688         const char *prefix;
689         const char *suffix;
690         const char *color; /* NULL; filled in by the setup code if
691                             * color is enabled */
692 };
694 struct diff_words_style {
695         enum diff_words_type type;
696         struct diff_words_style_elem new, old, ctx;
697         const char *newline;
698 };
700 static struct diff_words_style diff_words_styles[] = {
701         { DIFF_WORDS_PORCELAIN, {"+", "\n"}, {"-", "\n"}, {" ", "\n"}, "~\n" },
702         { DIFF_WORDS_PLAIN, {"{+", "+}"}, {"[-", "-]"}, {"", ""}, "\n" },
703         { DIFF_WORDS_COLOR, {"", ""}, {"", ""}, {"", ""}, "\n" }
704 };
706 struct diff_words_data {
707         struct diff_words_buffer minus, plus;
708         const char *current_plus;
709         int last_minus;
710         struct diff_options *opt;
711         regex_t *word_regex;
712         enum diff_words_type type;
713         struct diff_words_style *style;
714 };
716 static int fn_out_diff_words_write_helper(FILE *fp,
717                                           struct diff_words_style_elem *st_el,
718                                           const char *newline,
719                                           size_t count, const char *buf,
720                                           const char *line_prefix)
722         int print = 0;
724         while (count) {
725                 char *p = memchr(buf, '\n', count);
726                 if (print)
727                         fputs(line_prefix, fp);
728                 if (p != buf) {
729                         if (st_el->color && fputs(st_el->color, fp) < 0)
730                                 return -1;
731                         if (fputs(st_el->prefix, fp) < 0 ||
732                             fwrite(buf, p ? p - buf : count, 1, fp) != 1 ||
733                             fputs(st_el->suffix, fp) < 0)
734                                 return -1;
735                         if (st_el->color && *st_el->color
736                             && fputs(GIT_COLOR_RESET, fp) < 0)
737                                 return -1;
738                 }
739                 if (!p)
740                         return 0;
741                 if (fputs(newline, fp) < 0)
742                         return -1;
743                 count -= p + 1 - buf;
744                 buf = p + 1;
745                 print = 1;
746         }
747         return 0;
750 /*
751  * '--color-words' algorithm can be described as:
752  *
753  *   1. collect a the minus/plus lines of a diff hunk, divided into
754  *      minus-lines and plus-lines;
755  *
756  *   2. break both minus-lines and plus-lines into words and
757  *      place them into two mmfile_t with one word for each line;
758  *
759  *   3. use xdiff to run diff on the two mmfile_t to get the words level diff;
760  *
761  * And for the common parts of the both file, we output the plus side text.
762  * diff_words->current_plus is used to trace the current position of the plus file
763  * which printed. diff_words->last_minus is used to trace the last minus word
764  * printed.
765  *
766  * For '--graph' to work with '--color-words', we need to output the graph prefix
767  * on each line of color words output. Generally, there are two conditions on
768  * which we should output the prefix.
769  *
770  *   1. diff_words->last_minus == 0 &&
771  *      diff_words->current_plus == diff_words->plus.text.ptr
772  *
773  *      that is: the plus text must start as a new line, and if there is no minus
774  *      word printed, a graph prefix must be printed.
775  *
776  *   2. diff_words->current_plus > diff_words->plus.text.ptr &&
777  *      *(diff_words->current_plus - 1) == '\n'
778  *
779  *      that is: a graph prefix must be printed following a '\n'
780  */
781 static int color_words_output_graph_prefix(struct diff_words_data *diff_words)
783         if ((diff_words->last_minus == 0 &&
784                 diff_words->current_plus == diff_words->plus.text.ptr) ||
785                 (diff_words->current_plus > diff_words->plus.text.ptr &&
786                 *(diff_words->current_plus - 1) == '\n')) {
787                 return 1;
788         } else {
789                 return 0;
790         }
793 static void fn_out_diff_words_aux(void *priv, char *line, unsigned long len)
795         struct diff_words_data *diff_words = priv;
796         struct diff_words_style *style = diff_words->style;
797         int minus_first, minus_len, plus_first, plus_len;
798         const char *minus_begin, *minus_end, *plus_begin, *plus_end;
799         struct diff_options *opt = diff_words->opt;
800         struct strbuf *msgbuf;
801         char *line_prefix = "";
803         if (line[0] != '@' || parse_hunk_header(line, len,
804                         &minus_first, &minus_len, &plus_first, &plus_len))
805                 return;
807         assert(opt);
808         if (opt->output_prefix) {
809                 msgbuf = opt->output_prefix(opt, opt->output_prefix_data);
810                 line_prefix = msgbuf->buf;
811         }
813         /* POSIX requires that first be decremented by one if len == 0... */
814         if (minus_len) {
815                 minus_begin = diff_words->minus.orig[minus_first].begin;
816                 minus_end =
817                         diff_words->minus.orig[minus_first + minus_len - 1].end;
818         } else
819                 minus_begin = minus_end =
820                         diff_words->minus.orig[minus_first].end;
822         if (plus_len) {
823                 plus_begin = diff_words->plus.orig[plus_first].begin;
824                 plus_end = diff_words->plus.orig[plus_first + plus_len - 1].end;
825         } else
826                 plus_begin = plus_end = diff_words->plus.orig[plus_first].end;
828         if (color_words_output_graph_prefix(diff_words)) {
829                 fputs(line_prefix, diff_words->opt->file);
830         }
831         if (diff_words->current_plus != plus_begin) {
832                 fn_out_diff_words_write_helper(diff_words->opt->file,
833                                 &style->ctx, style->newline,
834                                 plus_begin - diff_words->current_plus,
835                                 diff_words->current_plus, line_prefix);
836                 if (*(plus_begin - 1) == '\n')
837                         fputs(line_prefix, diff_words->opt->file);
838         }
839         if (minus_begin != minus_end) {
840                 fn_out_diff_words_write_helper(diff_words->opt->file,
841                                 &style->old, style->newline,
842                                 minus_end - minus_begin, minus_begin,
843                                 line_prefix);
844         }
845         if (plus_begin != plus_end) {
846                 fn_out_diff_words_write_helper(diff_words->opt->file,
847                                 &style->new, style->newline,
848                                 plus_end - plus_begin, plus_begin,
849                                 line_prefix);
850         }
852         diff_words->current_plus = plus_end;
853         diff_words->last_minus = minus_first;
856 /* This function starts looking at *begin, and returns 0 iff a word was found. */
857 static int find_word_boundaries(mmfile_t *buffer, regex_t *word_regex,
858                 int *begin, int *end)
860         if (word_regex && *begin < buffer->size) {
861                 regmatch_t match[1];
862                 if (!regexec(word_regex, buffer->ptr + *begin, 1, match, 0)) {
863                         char *p = memchr(buffer->ptr + *begin + match[0].rm_so,
864                                         '\n', match[0].rm_eo - match[0].rm_so);
865                         *end = p ? p - buffer->ptr : match[0].rm_eo + *begin;
866                         *begin += match[0].rm_so;
867                         return *begin >= *end;
868                 }
869                 return -1;
870         }
872         /* find the next word */
873         while (*begin < buffer->size && isspace(buffer->ptr[*begin]))
874                 (*begin)++;
875         if (*begin >= buffer->size)
876                 return -1;
878         /* find the end of the word */
879         *end = *begin + 1;
880         while (*end < buffer->size && !isspace(buffer->ptr[*end]))
881                 (*end)++;
883         return 0;
886 /*
887  * This function splits the words in buffer->text, stores the list with
888  * newline separator into out, and saves the offsets of the original words
889  * in buffer->orig.
890  */
891 static void diff_words_fill(struct diff_words_buffer *buffer, mmfile_t *out,
892                 regex_t *word_regex)
894         int i, j;
895         long alloc = 0;
897         out->size = 0;
898         out->ptr = NULL;
900         /* fake an empty "0th" word */
901         ALLOC_GROW(buffer->orig, 1, buffer->orig_alloc);
902         buffer->orig[0].begin = buffer->orig[0].end = buffer->text.ptr;
903         buffer->orig_nr = 1;
905         for (i = 0; i < buffer->text.size; i++) {
906                 if (find_word_boundaries(&buffer->text, word_regex, &i, &j))
907                         return;
909                 /* store original boundaries */
910                 ALLOC_GROW(buffer->orig, buffer->orig_nr + 1,
911                                 buffer->orig_alloc);
912                 buffer->orig[buffer->orig_nr].begin = buffer->text.ptr + i;
913                 buffer->orig[buffer->orig_nr].end = buffer->text.ptr + j;
914                 buffer->orig_nr++;
916                 /* store one word */
917                 ALLOC_GROW(out->ptr, out->size + j - i + 1, alloc);
918                 memcpy(out->ptr + out->size, buffer->text.ptr + i, j - i);
919                 out->ptr[out->size + j - i] = '\n';
920                 out->size += j - i + 1;
922                 i = j - 1;
923         }
926 /* this executes the word diff on the accumulated buffers */
927 static void diff_words_show(struct diff_words_data *diff_words)
929         xpparam_t xpp;
930         xdemitconf_t xecfg;
931         mmfile_t minus, plus;
932         struct diff_words_style *style = diff_words->style;
934         struct diff_options *opt = diff_words->opt;
935         struct strbuf *msgbuf;
936         char *line_prefix = "";
938         assert(opt);
939         if (opt->output_prefix) {
940                 msgbuf = opt->output_prefix(opt, opt->output_prefix_data);
941                 line_prefix = msgbuf->buf;
942         }
944         /* special case: only removal */
945         if (!diff_words->plus.text.size) {
946                 fputs(line_prefix, diff_words->opt->file);
947                 fn_out_diff_words_write_helper(diff_words->opt->file,
948                         &style->old, style->newline,
949                         diff_words->minus.text.size,
950                         diff_words->minus.text.ptr, line_prefix);
951                 diff_words->minus.text.size = 0;
952                 return;
953         }
955         diff_words->current_plus = diff_words->plus.text.ptr;
956         diff_words->last_minus = 0;
958         memset(&xpp, 0, sizeof(xpp));
959         memset(&xecfg, 0, sizeof(xecfg));
960         diff_words_fill(&diff_words->minus, &minus, diff_words->word_regex);
961         diff_words_fill(&diff_words->plus, &plus, diff_words->word_regex);
962         xpp.flags = 0;
963         /* as only the hunk header will be parsed, we need a 0-context */
964         xecfg.ctxlen = 0;
965         xdi_diff_outf(&minus, &plus, fn_out_diff_words_aux, diff_words,
966                       &xpp, &xecfg);
967         free(minus.ptr);
968         free(plus.ptr);
969         if (diff_words->current_plus != diff_words->plus.text.ptr +
970                         diff_words->plus.text.size) {
971                 if (color_words_output_graph_prefix(diff_words))
972                         fputs(line_prefix, diff_words->opt->file);
973                 fn_out_diff_words_write_helper(diff_words->opt->file,
974                         &style->ctx, style->newline,
975                         diff_words->plus.text.ptr + diff_words->plus.text.size
976                         - diff_words->current_plus, diff_words->current_plus,
977                         line_prefix);
978         }
979         diff_words->minus.text.size = diff_words->plus.text.size = 0;
982 /* In "color-words" mode, show word-diff of words accumulated in the buffer */
983 static void diff_words_flush(struct emit_callback *ecbdata)
985         if (ecbdata->diff_words->minus.text.size ||
986             ecbdata->diff_words->plus.text.size)
987                 diff_words_show(ecbdata->diff_words);
990 static void free_diff_words_data(struct emit_callback *ecbdata)
992         if (ecbdata->diff_words) {
993                 diff_words_flush(ecbdata);
994                 free (ecbdata->diff_words->minus.text.ptr);
995                 free (ecbdata->diff_words->minus.orig);
996                 free (ecbdata->diff_words->plus.text.ptr);
997                 free (ecbdata->diff_words->plus.orig);
998                 if (ecbdata->diff_words->word_regex) {
999                         regfree(ecbdata->diff_words->word_regex);
1000                         free(ecbdata->diff_words->word_regex);
1001                 }
1002                 free(ecbdata->diff_words);
1003                 ecbdata->diff_words = NULL;
1004         }
1007 const char *diff_get_color(int diff_use_color, enum color_diff ix)
1009         if (want_color(diff_use_color))
1010                 return diff_colors[ix];
1011         return "";
1014 static unsigned long sane_truncate_line(struct emit_callback *ecb, char *line, unsigned long len)
1016         const char *cp;
1017         unsigned long allot;
1018         size_t l = len;
1020         if (ecb->truncate)
1021                 return ecb->truncate(line, len);
1022         cp = line;
1023         allot = l;
1024         while (0 < l) {
1025                 (void) utf8_width(&cp, &l);
1026                 if (!cp)
1027                         break; /* truncated in the middle? */
1028         }
1029         return allot - l;
1032 static void find_lno(const char *line, struct emit_callback *ecbdata)
1034         const char *p;
1035         ecbdata->lno_in_preimage = 0;
1036         ecbdata->lno_in_postimage = 0;
1037         p = strchr(line, '-');
1038         if (!p)
1039                 return; /* cannot happen */
1040         ecbdata->lno_in_preimage = strtol(p + 1, NULL, 10);
1041         p = strchr(p, '+');
1042         if (!p)
1043                 return; /* cannot happen */
1044         ecbdata->lno_in_postimage = strtol(p + 1, NULL, 10);
1047 static void fn_out_consume(void *priv, char *line, unsigned long len)
1049         struct emit_callback *ecbdata = priv;
1050         const char *meta = diff_get_color(ecbdata->color_diff, DIFF_METAINFO);
1051         const char *plain = diff_get_color(ecbdata->color_diff, DIFF_PLAIN);
1052         const char *reset = diff_get_color(ecbdata->color_diff, DIFF_RESET);
1053         struct diff_options *o = ecbdata->opt;
1054         char *line_prefix = "";
1055         struct strbuf *msgbuf;
1057         if (o && o->output_prefix) {
1058                 msgbuf = o->output_prefix(o, o->output_prefix_data);
1059                 line_prefix = msgbuf->buf;
1060         }
1062         if (ecbdata->header) {
1063                 fprintf(ecbdata->opt->file, "%s", ecbdata->header->buf);
1064                 strbuf_reset(ecbdata->header);
1065                 ecbdata->header = NULL;
1066         }
1067         *(ecbdata->found_changesp) = 1;
1069         if (ecbdata->label_path[0]) {
1070                 const char *name_a_tab, *name_b_tab;
1072                 name_a_tab = strchr(ecbdata->label_path[0], ' ') ? "\t" : "";
1073                 name_b_tab = strchr(ecbdata->label_path[1], ' ') ? "\t" : "";
1075                 fprintf(ecbdata->opt->file, "%s%s--- %s%s%s\n",
1076                         line_prefix, meta, ecbdata->label_path[0], reset, name_a_tab);
1077                 fprintf(ecbdata->opt->file, "%s%s+++ %s%s%s\n",
1078                         line_prefix, meta, ecbdata->label_path[1], reset, name_b_tab);
1079                 ecbdata->label_path[0] = ecbdata->label_path[1] = NULL;
1080         }
1082         if (diff_suppress_blank_empty
1083             && len == 2 && line[0] == ' ' && line[1] == '\n') {
1084                 line[0] = '\n';
1085                 len = 1;
1086         }
1088         if (line[0] == '@') {
1089                 if (ecbdata->diff_words)
1090                         diff_words_flush(ecbdata);
1091                 len = sane_truncate_line(ecbdata, line, len);
1092                 find_lno(line, ecbdata);
1093                 emit_hunk_header(ecbdata, line, len);
1094                 if (line[len-1] != '\n')
1095                         putc('\n', ecbdata->opt->file);
1096                 return;
1097         }
1099         if (len < 1) {
1100                 emit_line(ecbdata->opt, reset, reset, line, len);
1101                 if (ecbdata->diff_words
1102                     && ecbdata->diff_words->type == DIFF_WORDS_PORCELAIN)
1103                         fputs("~\n", ecbdata->opt->file);
1104                 return;
1105         }
1107         if (ecbdata->diff_words) {
1108                 if (line[0] == '-') {
1109                         diff_words_append(line, len,
1110                                           &ecbdata->diff_words->minus);
1111                         return;
1112                 } else if (line[0] == '+') {
1113                         diff_words_append(line, len,
1114                                           &ecbdata->diff_words->plus);
1115                         return;
1116                 } else if (!prefixcmp(line, "\\ ")) {
1117                         /*
1118                          * Eat the "no newline at eof" marker as if we
1119                          * saw a "+" or "-" line with nothing on it,
1120                          * and return without diff_words_flush() to
1121                          * defer processing. If this is the end of
1122                          * preimage, more "+" lines may come after it.
1123                          */
1124                         return;
1125                 }
1126                 diff_words_flush(ecbdata);
1127                 if (ecbdata->diff_words->type == DIFF_WORDS_PORCELAIN) {
1128                         emit_line(ecbdata->opt, plain, reset, line, len);
1129                         fputs("~\n", ecbdata->opt->file);
1130                 } else {
1131                         /*
1132                          * Skip the prefix character, if any.  With
1133                          * diff_suppress_blank_empty, there may be
1134                          * none.
1135                          */
1136                         if (line[0] != '\n') {
1137                               line++;
1138                               len--;
1139                         }
1140                         emit_line(ecbdata->opt, plain, reset, line, len);
1141                 }
1142                 return;
1143         }
1145         if (line[0] != '+') {
1146                 const char *color =
1147                         diff_get_color(ecbdata->color_diff,
1148                                        line[0] == '-' ? DIFF_FILE_OLD : DIFF_PLAIN);
1149                 ecbdata->lno_in_preimage++;
1150                 if (line[0] == ' ')
1151                         ecbdata->lno_in_postimage++;
1152                 emit_line(ecbdata->opt, color, reset, line, len);
1153         } else {
1154                 ecbdata->lno_in_postimage++;
1155                 emit_add_line(reset, ecbdata, line + 1, len - 1);
1156         }
1159 static char *pprint_rename(const char *a, const char *b)
1161         const char *old = a;
1162         const char *new = b;
1163         struct strbuf name = STRBUF_INIT;
1164         int pfx_length, sfx_length;
1165         int len_a = strlen(a);
1166         int len_b = strlen(b);
1167         int a_midlen, b_midlen;
1168         int qlen_a = quote_c_style(a, NULL, NULL, 0);
1169         int qlen_b = quote_c_style(b, NULL, NULL, 0);
1171         if (qlen_a || qlen_b) {
1172                 quote_c_style(a, &name, NULL, 0);
1173                 strbuf_addstr(&name, " => ");
1174                 quote_c_style(b, &name, NULL, 0);
1175                 return strbuf_detach(&name, NULL);
1176         }
1178         /* Find common prefix */
1179         pfx_length = 0;
1180         while (*old && *new && *old == *new) {
1181                 if (*old == '/')
1182                         pfx_length = old - a + 1;
1183                 old++;
1184                 new++;
1185         }
1187         /* Find common suffix */
1188         old = a + len_a;
1189         new = b + len_b;
1190         sfx_length = 0;
1191         while (a <= old && b <= new && *old == *new) {
1192                 if (*old == '/')
1193                         sfx_length = len_a - (old - a);
1194                 old--;
1195                 new--;
1196         }
1198         /*
1199          * pfx{mid-a => mid-b}sfx
1200          * {pfx-a => pfx-b}sfx
1201          * pfx{sfx-a => sfx-b}
1202          * name-a => name-b
1203          */
1204         a_midlen = len_a - pfx_length - sfx_length;
1205         b_midlen = len_b - pfx_length - sfx_length;
1206         if (a_midlen < 0)
1207                 a_midlen = 0;
1208         if (b_midlen < 0)
1209                 b_midlen = 0;
1211         strbuf_grow(&name, pfx_length + a_midlen + b_midlen + sfx_length + 7);
1212         if (pfx_length + sfx_length) {
1213                 strbuf_add(&name, a, pfx_length);
1214                 strbuf_addch(&name, '{');
1215         }
1216         strbuf_add(&name, a + pfx_length, a_midlen);
1217         strbuf_addstr(&name, " => ");
1218         strbuf_add(&name, b + pfx_length, b_midlen);
1219         if (pfx_length + sfx_length) {
1220                 strbuf_addch(&name, '}');
1221                 strbuf_add(&name, a + len_a - sfx_length, sfx_length);
1222         }
1223         return strbuf_detach(&name, NULL);
1226 struct diffstat_t {
1227         int nr;
1228         int alloc;
1229         struct diffstat_file {
1230                 char *from_name;
1231                 char *name;
1232                 char *print_name;
1233                 unsigned is_unmerged:1;
1234                 unsigned is_binary:1;
1235                 unsigned is_renamed:1;
1236                 uintmax_t added, deleted;
1237         } **files;
1238 };
1240 static struct diffstat_file *diffstat_add(struct diffstat_t *diffstat,
1241                                           const char *name_a,
1242                                           const char *name_b)
1244         struct diffstat_file *x;
1245         x = xcalloc(sizeof (*x), 1);
1246         if (diffstat->nr == diffstat->alloc) {
1247                 diffstat->alloc = alloc_nr(diffstat->alloc);
1248                 diffstat->files = xrealloc(diffstat->files,
1249                                 diffstat->alloc * sizeof(x));
1250         }
1251         diffstat->files[diffstat->nr++] = x;
1252         if (name_b) {
1253                 x->from_name = xstrdup(name_a);
1254                 x->name = xstrdup(name_b);
1255                 x->is_renamed = 1;
1256         }
1257         else {
1258                 x->from_name = NULL;
1259                 x->name = xstrdup(name_a);
1260         }
1261         return x;
1264 static void diffstat_consume(void *priv, char *line, unsigned long len)
1266         struct diffstat_t *diffstat = priv;
1267         struct diffstat_file *x = diffstat->files[diffstat->nr - 1];
1269         if (line[0] == '+')
1270                 x->added++;
1271         else if (line[0] == '-')
1272                 x->deleted++;
1275 const char mime_boundary_leader[] = "------------";
1277 static int scale_linear(int it, int width, int max_change)
1279         /*
1280          * make sure that at least one '-' is printed if there were deletions,
1281          * and likewise for '+'.
1282          */
1283         if (max_change < 2)
1284                 return it;
1285         return ((it - 1) * (width - 1) + max_change - 1) / (max_change - 1);
1288 static void show_name(FILE *file,
1289                       const char *prefix, const char *name, int len)
1291         fprintf(file, " %s%-*s |", prefix, len, name);
1294 static void show_graph(FILE *file, char ch, int cnt, const char *set, const char *reset)
1296         if (cnt <= 0)
1297                 return;
1298         fprintf(file, "%s", set);
1299         while (cnt--)
1300                 putc(ch, file);
1301         fprintf(file, "%s", reset);
1304 static void fill_print_name(struct diffstat_file *file)
1306         char *pname;
1308         if (file->print_name)
1309                 return;
1311         if (!file->is_renamed) {
1312                 struct strbuf buf = STRBUF_INIT;
1313                 if (quote_c_style(file->name, &buf, NULL, 0)) {
1314                         pname = strbuf_detach(&buf, NULL);
1315                 } else {
1316                         pname = file->name;
1317                         strbuf_release(&buf);
1318                 }
1319         } else {
1320                 pname = pprint_rename(file->from_name, file->name);
1321         }
1322         file->print_name = pname;
1325 static void show_stats(struct diffstat_t *data, struct diff_options *options)
1327         int i, len, add, del, adds = 0, dels = 0;
1328         uintmax_t max_change = 0, max_len = 0;
1329         int total_files = data->nr;
1330         int width, name_width, count;
1331         const char *reset, *add_c, *del_c;
1332         const char *line_prefix = "";
1333         int extra_shown = 0;
1334         struct strbuf *msg = NULL;
1336         if (data->nr == 0)
1337                 return;
1339         if (options->output_prefix) {
1340                 msg = options->output_prefix(options, options->output_prefix_data);
1341                 line_prefix = msg->buf;
1342         }
1344         width = options->stat_width ? options->stat_width : 80;
1345         name_width = options->stat_name_width ? options->stat_name_width : 50;
1346         count = options->stat_count ? options->stat_count : data->nr;
1348         /* Sanity: give at least 5 columns to the graph,
1349          * but leave at least 10 columns for the name.
1350          */
1351         if (width < 25)
1352                 width = 25;
1353         if (name_width < 10)
1354                 name_width = 10;
1355         else if (width < name_width + 15)
1356                 name_width = width - 15;
1358         /* Find the longest filename and max number of changes */
1359         reset = diff_get_color_opt(options, DIFF_RESET);
1360         add_c = diff_get_color_opt(options, DIFF_FILE_NEW);
1361         del_c = diff_get_color_opt(options, DIFF_FILE_OLD);
1363         for (i = 0; (i < count) && (i < data->nr); i++) {
1364                 struct diffstat_file *file = data->files[i];
1365                 uintmax_t change = file->added + file->deleted;
1366                 if (!data->files[i]->is_renamed &&
1367                          (change == 0)) {
1368                         count++; /* not shown == room for one more */
1369                         continue;
1370                 }
1371                 fill_print_name(file);
1372                 len = strlen(file->print_name);
1373                 if (max_len < len)
1374                         max_len = len;
1376                 if (file->is_binary || file->is_unmerged)
1377                         continue;
1378                 if (max_change < change)
1379                         max_change = change;
1380         }
1381         count = i; /* min(count, data->nr) */
1383         /* Compute the width of the graph part;
1384          * 10 is for one blank at the beginning of the line plus
1385          * " | count " between the name and the graph.
1386          *
1387          * From here on, name_width is the width of the name area,
1388          * and width is the width of the graph area.
1389          */
1390         name_width = (name_width < max_len) ? name_width : max_len;
1391         if (width < (name_width + 10) + max_change)
1392                 width = width - (name_width + 10);
1393         else
1394                 width = max_change;
1396         for (i = 0; i < count; i++) {
1397                 const char *prefix = "";
1398                 char *name = data->files[i]->print_name;
1399                 uintmax_t added = data->files[i]->added;
1400                 uintmax_t deleted = data->files[i]->deleted;
1401                 int name_len;
1403                 if (!data->files[i]->is_renamed &&
1404                          (added + deleted == 0)) {
1405                         total_files--;
1406                         continue;
1407                 }
1408                 /*
1409                  * "scale" the filename
1410                  */
1411                 len = name_width;
1412                 name_len = strlen(name);
1413                 if (name_width < name_len) {
1414                         char *slash;
1415                         prefix = "...";
1416                         len -= 3;
1417                         name += name_len - len;
1418                         slash = strchr(name, '/');
1419                         if (slash)
1420                                 name = slash;
1421                 }
1423                 if (data->files[i]->is_binary) {
1424                         fprintf(options->file, "%s", line_prefix);
1425                         show_name(options->file, prefix, name, len);
1426                         fprintf(options->file, "  Bin ");
1427                         fprintf(options->file, "%s%"PRIuMAX"%s",
1428                                 del_c, deleted, reset);
1429                         fprintf(options->file, " -> ");
1430                         fprintf(options->file, "%s%"PRIuMAX"%s",
1431                                 add_c, added, reset);
1432                         fprintf(options->file, " bytes");
1433                         fprintf(options->file, "\n");
1434                         continue;
1435                 }
1436                 else if (data->files[i]->is_unmerged) {
1437                         fprintf(options->file, "%s", line_prefix);
1438                         show_name(options->file, prefix, name, len);
1439                         fprintf(options->file, "  Unmerged\n");
1440                         continue;
1441                 }
1443                 /*
1444                  * scale the add/delete
1445                  */
1446                 add = added;
1447                 del = deleted;
1448                 adds += add;
1449                 dels += del;
1451                 if (width <= max_change) {
1452                         add = scale_linear(add, width, max_change);
1453                         del = scale_linear(del, width, max_change);
1454                 }
1455                 fprintf(options->file, "%s", line_prefix);
1456                 show_name(options->file, prefix, name, len);
1457                 fprintf(options->file, "%5"PRIuMAX"%s", added + deleted,
1458                                 added + deleted ? " " : "");
1459                 show_graph(options->file, '+', add, add_c, reset);
1460                 show_graph(options->file, '-', del, del_c, reset);
1461                 fprintf(options->file, "\n");
1462         }
1463         for (i = count; i < data->nr; i++) {
1464                 uintmax_t added = data->files[i]->added;
1465                 uintmax_t deleted = data->files[i]->deleted;
1466                 if (!data->files[i]->is_renamed &&
1467                          (added + deleted == 0)) {
1468                         total_files--;
1469                         continue;
1470                 }
1471                 adds += added;
1472                 dels += deleted;
1473                 if (!extra_shown)
1474                         fprintf(options->file, "%s ...\n", line_prefix);
1475                 extra_shown = 1;
1476         }
1477         fprintf(options->file, "%s", line_prefix);
1478         fprintf(options->file,
1479                " %d files changed, %d insertions(+), %d deletions(-)\n",
1480                total_files, adds, dels);
1483 static void show_shortstats(struct diffstat_t *data, struct diff_options *options)
1485         int i, adds = 0, dels = 0, total_files = data->nr;
1487         if (data->nr == 0)
1488                 return;
1490         for (i = 0; i < data->nr; i++) {
1491                 if (!data->files[i]->is_binary &&
1492                     !data->files[i]->is_unmerged) {
1493                         int added = data->files[i]->added;
1494                         int deleted= data->files[i]->deleted;
1495                         if (!data->files[i]->is_renamed &&
1496                             (added + deleted == 0)) {
1497                                 total_files--;
1498                         } else {
1499                                 adds += added;
1500                                 dels += deleted;
1501                         }
1502                 }
1503         }
1504         if (options->output_prefix) {
1505                 struct strbuf *msg = NULL;
1506                 msg = options->output_prefix(options,
1507                                 options->output_prefix_data);
1508                 fprintf(options->file, "%s", msg->buf);
1509         }
1510         fprintf(options->file, " %d files changed, %d insertions(+), %d deletions(-)\n",
1511                total_files, adds, dels);
1514 static void show_numstat(struct diffstat_t *data, struct diff_options *options)
1516         int i;
1518         if (data->nr == 0)
1519                 return;
1521         for (i = 0; i < data->nr; i++) {
1522                 struct diffstat_file *file = data->files[i];
1524                 if (options->output_prefix) {
1525                         struct strbuf *msg = NULL;
1526                         msg = options->output_prefix(options,
1527                                         options->output_prefix_data);
1528                         fprintf(options->file, "%s", msg->buf);
1529                 }
1531                 if (file->is_binary)
1532                         fprintf(options->file, "-\t-\t");
1533                 else
1534                         fprintf(options->file,
1535                                 "%"PRIuMAX"\t%"PRIuMAX"\t",
1536                                 file->added, file->deleted);
1537                 if (options->line_termination) {
1538                         fill_print_name(file);
1539                         if (!file->is_renamed)
1540                                 write_name_quoted(file->name, options->file,
1541                                                   options->line_termination);
1542                         else {
1543                                 fputs(file->print_name, options->file);
1544                                 putc(options->line_termination, options->file);
1545                         }
1546                 } else {
1547                         if (file->is_renamed) {
1548                                 putc('\0', options->file);
1549                                 write_name_quoted(file->from_name, options->file, '\0');
1550                         }
1551                         write_name_quoted(file->name, options->file, '\0');
1552                 }
1553         }
1556 struct dirstat_file {
1557         const char *name;
1558         unsigned long changed;
1559 };
1561 struct dirstat_dir {
1562         struct dirstat_file *files;
1563         int alloc, nr, permille, cumulative;
1564 };
1566 static long gather_dirstat(struct diff_options *opt, struct dirstat_dir *dir,
1567                 unsigned long changed, const char *base, int baselen)
1569         unsigned long this_dir = 0;
1570         unsigned int sources = 0;
1571         const char *line_prefix = "";
1572         struct strbuf *msg = NULL;
1574         if (opt->output_prefix) {
1575                 msg = opt->output_prefix(opt, opt->output_prefix_data);
1576                 line_prefix = msg->buf;
1577         }
1579         while (dir->nr) {
1580                 struct dirstat_file *f = dir->files;
1581                 int namelen = strlen(f->name);
1582                 unsigned long this;
1583                 char *slash;
1585                 if (namelen < baselen)
1586                         break;
1587                 if (memcmp(f->name, base, baselen))
1588                         break;
1589                 slash = strchr(f->name + baselen, '/');
1590                 if (slash) {
1591                         int newbaselen = slash + 1 - f->name;
1592                         this = gather_dirstat(opt, dir, changed, f->name, newbaselen);
1593                         sources++;
1594                 } else {
1595                         this = f->changed;
1596                         dir->files++;
1597                         dir->nr--;
1598                         sources += 2;
1599                 }
1600                 this_dir += this;
1601         }
1603         /*
1604          * We don't report dirstat's for
1605          *  - the top level
1606          *  - or cases where everything came from a single directory
1607          *    under this directory (sources == 1).
1608          */
1609         if (baselen && sources != 1) {
1610                 if (this_dir) {
1611                         int permille = this_dir * 1000 / changed;
1612                         if (permille >= dir->permille) {
1613                                 fprintf(opt->file, "%s%4d.%01d%% %.*s\n", line_prefix,
1614                                         permille / 10, permille % 10, baselen, base);
1615                                 if (!dir->cumulative)
1616                                         return 0;
1617                         }
1618                 }
1619         }
1620         return this_dir;
1623 static int dirstat_compare(const void *_a, const void *_b)
1625         const struct dirstat_file *a = _a;
1626         const struct dirstat_file *b = _b;
1627         return strcmp(a->name, b->name);
1630 static void show_dirstat(struct diff_options *options)
1632         int i;
1633         unsigned long changed;
1634         struct dirstat_dir dir;
1635         struct diff_queue_struct *q = &diff_queued_diff;
1637         dir.files = NULL;
1638         dir.alloc = 0;
1639         dir.nr = 0;
1640         dir.permille = options->dirstat_permille;
1641         dir.cumulative = DIFF_OPT_TST(options, DIRSTAT_CUMULATIVE);
1643         changed = 0;
1644         for (i = 0; i < q->nr; i++) {
1645                 struct diff_filepair *p = q->queue[i];
1646                 const char *name;
1647                 unsigned long copied, added, damage;
1648                 int content_changed;
1650                 name = p->two->path ? p->two->path : p->one->path;
1652                 if (p->one->sha1_valid && p->two->sha1_valid)
1653                         content_changed = hashcmp(p->one->sha1, p->two->sha1);
1654                 else
1655                         content_changed = 1;
1657                 if (!content_changed) {
1658                         /*
1659                          * The SHA1 has not changed, so pre-/post-content is
1660                          * identical. We can therefore skip looking at the
1661                          * file contents altogether.
1662                          */
1663                         damage = 0;
1664                         goto found_damage;
1665                 }
1667                 if (DIFF_OPT_TST(options, DIRSTAT_BY_FILE)) {
1668                         /*
1669                          * In --dirstat-by-file mode, we don't really need to
1670                          * look at the actual file contents at all.
1671                          * The fact that the SHA1 changed is enough for us to
1672                          * add this file to the list of results
1673                          * (with each file contributing equal damage).
1674                          */
1675                         damage = 1;
1676                         goto found_damage;
1677                 }
1679                 if (DIFF_FILE_VALID(p->one) && DIFF_FILE_VALID(p->two)) {
1680                         diff_populate_filespec(p->one, 0);
1681                         diff_populate_filespec(p->two, 0);
1682                         diffcore_count_changes(p->one, p->two, NULL, NULL, 0,
1683                                                &copied, &added);
1684                         diff_free_filespec_data(p->one);
1685                         diff_free_filespec_data(p->two);
1686                 } else if (DIFF_FILE_VALID(p->one)) {
1687                         diff_populate_filespec(p->one, 1);
1688                         copied = added = 0;
1689                         diff_free_filespec_data(p->one);
1690                 } else if (DIFF_FILE_VALID(p->two)) {
1691                         diff_populate_filespec(p->two, 1);
1692                         copied = 0;
1693                         added = p->two->size;
1694                         diff_free_filespec_data(p->two);
1695                 } else
1696                         continue;
1698                 /*
1699                  * Original minus copied is the removed material,
1700                  * added is the new material.  They are both damages
1701                  * made to the preimage.
1702                  * If the resulting damage is zero, we know that
1703                  * diffcore_count_changes() considers the two entries to
1704                  * be identical, but since content_changed is true, we
1705                  * know that there must have been _some_ kind of change,
1706                  * so we force all entries to have damage > 0.
1707                  */
1708                 damage = (p->one->size - copied) + added;
1709                 if (!damage)
1710                         damage = 1;
1712 found_damage:
1713                 ALLOC_GROW(dir.files, dir.nr + 1, dir.alloc);
1714                 dir.files[dir.nr].name = name;
1715                 dir.files[dir.nr].changed = damage;
1716                 changed += damage;
1717                 dir.nr++;
1718         }
1720         /* This can happen even with many files, if everything was renames */
1721         if (!changed)
1722                 return;
1724         /* Show all directories with more than x% of the changes */
1725         qsort(dir.files, dir.nr, sizeof(dir.files[0]), dirstat_compare);
1726         gather_dirstat(options, &dir, changed, "", 0);
1729 static void show_dirstat_by_line(struct diffstat_t *data, struct diff_options *options)
1731         int i;
1732         unsigned long changed;
1733         struct dirstat_dir dir;
1735         if (data->nr == 0)
1736                 return;
1738         dir.files = NULL;
1739         dir.alloc = 0;
1740         dir.nr = 0;
1741         dir.permille = options->dirstat_permille;
1742         dir.cumulative = DIFF_OPT_TST(options, DIRSTAT_CUMULATIVE);
1744         changed = 0;
1745         for (i = 0; i < data->nr; i++) {
1746                 struct diffstat_file *file = data->files[i];
1747                 unsigned long damage = file->added + file->deleted;
1748                 if (file->is_binary)
1749                         /*
1750                          * binary files counts bytes, not lines. Must find some
1751                          * way to normalize binary bytes vs. textual lines.
1752                          * The following heuristic assumes that there are 64
1753                          * bytes per "line".
1754                          * This is stupid and ugly, but very cheap...
1755                          */
1756                         damage = (damage + 63) / 64;
1757                 ALLOC_GROW(dir.files, dir.nr + 1, dir.alloc);
1758                 dir.files[dir.nr].name = file->name;
1759                 dir.files[dir.nr].changed = damage;
1760                 changed += damage;
1761                 dir.nr++;
1762         }
1764         /* This can happen even with many files, if everything was renames */
1765         if (!changed)
1766                 return;
1768         /* Show all directories with more than x% of the changes */
1769         qsort(dir.files, dir.nr, sizeof(dir.files[0]), dirstat_compare);
1770         gather_dirstat(options, &dir, changed, "", 0);
1773 static void free_diffstat_info(struct diffstat_t *diffstat)
1775         int i;
1776         for (i = 0; i < diffstat->nr; i++) {
1777                 struct diffstat_file *f = diffstat->files[i];
1778                 if (f->name != f->print_name)
1779                         free(f->print_name);
1780                 free(f->name);
1781                 free(f->from_name);
1782                 free(f);
1783         }
1784         free(diffstat->files);
1787 struct checkdiff_t {
1788         const char *filename;
1789         int lineno;
1790         int conflict_marker_size;
1791         struct diff_options *o;
1792         unsigned ws_rule;
1793         unsigned status;
1794 };
1796 static int is_conflict_marker(const char *line, int marker_size, unsigned long len)
1798         char firstchar;
1799         int cnt;
1801         if (len < marker_size + 1)
1802                 return 0;
1803         firstchar = line[0];
1804         switch (firstchar) {
1805         case '=': case '>': case '<': case '|':
1806                 break;
1807         default:
1808                 return 0;
1809         }
1810         for (cnt = 1; cnt < marker_size; cnt++)
1811                 if (line[cnt] != firstchar)
1812                         return 0;
1813         /* line[1] thru line[marker_size-1] are same as firstchar */
1814         if (len < marker_size + 1 || !isspace(line[marker_size]))
1815                 return 0;
1816         return 1;
1819 static void checkdiff_consume(void *priv, char *line, unsigned long len)
1821         struct checkdiff_t *data = priv;
1822         int marker_size = data->conflict_marker_size;
1823         const char *ws = diff_get_color(data->o->use_color, DIFF_WHITESPACE);
1824         const char *reset = diff_get_color(data->o->use_color, DIFF_RESET);
1825         const char *set = diff_get_color(data->o->use_color, DIFF_FILE_NEW);
1826         char *err;
1827         char *line_prefix = "";
1828         struct strbuf *msgbuf;
1830         assert(data->o);
1831         if (data->o->output_prefix) {
1832                 msgbuf = data->o->output_prefix(data->o,
1833                         data->o->output_prefix_data);
1834                 line_prefix = msgbuf->buf;
1835         }
1837         if (line[0] == '+') {
1838                 unsigned bad;
1839                 data->lineno++;
1840                 if (is_conflict_marker(line + 1, marker_size, len - 1)) {
1841                         data->status |= 1;
1842                         fprintf(data->o->file,
1843                                 "%s%s:%d: leftover conflict marker\n",
1844                                 line_prefix, data->filename, data->lineno);
1845                 }
1846                 bad = ws_check(line + 1, len - 1, data->ws_rule);
1847                 if (!bad)
1848                         return;
1849                 data->status |= bad;
1850                 err = whitespace_error_string(bad);
1851                 fprintf(data->o->file, "%s%s:%d: %s.\n",
1852                         line_prefix, data->filename, data->lineno, err);
1853                 free(err);
1854                 emit_line(data->o, set, reset, line, 1);
1855                 ws_check_emit(line + 1, len - 1, data->ws_rule,
1856                               data->o->file, set, reset, ws);
1857         } else if (line[0] == ' ') {
1858                 data->lineno++;
1859         } else if (line[0] == '@') {
1860                 char *plus = strchr(line, '+');
1861                 if (plus)
1862                         data->lineno = strtol(plus, NULL, 10) - 1;
1863                 else
1864                         die("invalid diff");
1865         }
1868 static unsigned char *deflate_it(char *data,
1869                                  unsigned long size,
1870                                  unsigned long *result_size)
1872         int bound;
1873         unsigned char *deflated;
1874         git_zstream stream;
1876         memset(&stream, 0, sizeof(stream));
1877         git_deflate_init(&stream, zlib_compression_level);
1878         bound = git_deflate_bound(&stream, size);
1879         deflated = xmalloc(bound);
1880         stream.next_out = deflated;
1881         stream.avail_out = bound;
1883         stream.next_in = (unsigned char *)data;
1884         stream.avail_in = size;
1885         while (git_deflate(&stream, Z_FINISH) == Z_OK)
1886                 ; /* nothing */
1887         git_deflate_end(&stream);
1888         *result_size = stream.total_out;
1889         return deflated;
1892 static void emit_binary_diff_body(FILE *file, mmfile_t *one, mmfile_t *two, char *prefix)
1894         void *cp;
1895         void *delta;
1896         void *deflated;
1897         void *data;
1898         unsigned long orig_size;
1899         unsigned long delta_size;
1900         unsigned long deflate_size;
1901         unsigned long data_size;
1903         /* We could do deflated delta, or we could do just deflated two,
1904          * whichever is smaller.
1905          */
1906         delta = NULL;
1907         deflated = deflate_it(two->ptr, two->size, &deflate_size);
1908         if (one->size && two->size) {
1909                 delta = diff_delta(one->ptr, one->size,
1910                                    two->ptr, two->size,
1911                                    &delta_size, deflate_size);
1912                 if (delta) {
1913                         void *to_free = delta;
1914                         orig_size = delta_size;
1915                         delta = deflate_it(delta, delta_size, &delta_size);
1916                         free(to_free);
1917                 }
1918         }
1920         if (delta && delta_size < deflate_size) {
1921                 fprintf(file, "%sdelta %lu\n", prefix, orig_size);
1922                 free(deflated);
1923                 data = delta;
1924                 data_size = delta_size;
1925         }
1926         else {
1927                 fprintf(file, "%sliteral %lu\n", prefix, two->size);
1928                 free(delta);
1929                 data = deflated;
1930                 data_size = deflate_size;
1931         }
1933         /* emit data encoded in base85 */
1934         cp = data;
1935         while (data_size) {
1936                 int bytes = (52 < data_size) ? 52 : data_size;
1937                 char line[70];
1938                 data_size -= bytes;
1939                 if (bytes <= 26)
1940                         line[0] = bytes + 'A' - 1;
1941                 else
1942                         line[0] = bytes - 26 + 'a' - 1;
1943                 encode_85(line + 1, cp, bytes);
1944                 cp = (char *) cp + bytes;
1945                 fprintf(file, "%s", prefix);
1946                 fputs(line, file);
1947                 fputc('\n', file);
1948         }
1949         fprintf(file, "%s\n", prefix);
1950         free(data);
1953 static void emit_binary_diff(FILE *file, mmfile_t *one, mmfile_t *two, char *prefix)
1955         fprintf(file, "%sGIT binary patch\n", prefix);
1956         emit_binary_diff_body(file, one, two, prefix);
1957         emit_binary_diff_body(file, two, one, prefix);
1960 static void diff_filespec_load_driver(struct diff_filespec *one)
1962         /* Use already-loaded driver */
1963         if (one->driver)
1964                 return;
1966         if (S_ISREG(one->mode))
1967                 one->driver = userdiff_find_by_path(one->path);
1969         /* Fallback to default settings */
1970         if (!one->driver)
1971                 one->driver = userdiff_find_by_name("default");
1974 int diff_filespec_is_binary(struct diff_filespec *one)
1976         if (one->is_binary == -1) {
1977                 diff_filespec_load_driver(one);
1978                 if (one->driver->binary != -1)
1979                         one->is_binary = one->driver->binary;
1980                 else {
1981                         if (!one->data && DIFF_FILE_VALID(one))
1982                                 diff_populate_filespec(one, 0);
1983                         if (one->data)
1984                                 one->is_binary = buffer_is_binary(one->data,
1985                                                 one->size);
1986                         if (one->is_binary == -1)
1987                                 one->is_binary = 0;
1988                 }
1989         }
1990         return one->is_binary;
1993 static const struct userdiff_funcname *diff_funcname_pattern(struct diff_filespec *one)
1995         diff_filespec_load_driver(one);
1996         return one->driver->funcname.pattern ? &one->driver->funcname : NULL;
1999 static const char *userdiff_word_regex(struct diff_filespec *one)
2001         diff_filespec_load_driver(one);
2002         return one->driver->word_regex;
2005 void diff_set_mnemonic_prefix(struct diff_options *options, const char *a, const char *b)
2007         if (!options->a_prefix)
2008                 options->a_prefix = a;
2009         if (!options->b_prefix)
2010                 options->b_prefix = b;
2013 struct userdiff_driver *get_textconv(struct diff_filespec *one)
2015         if (!DIFF_FILE_VALID(one))
2016                 return NULL;
2018         diff_filespec_load_driver(one);
2019         return userdiff_get_textconv(one->driver);
2022 static void builtin_diff(const char *name_a,
2023                          const char *name_b,
2024                          struct diff_filespec *one,
2025                          struct diff_filespec *two,
2026                          const char *xfrm_msg,
2027                          int must_show_header,
2028                          struct diff_options *o,
2029                          int complete_rewrite)
2031         mmfile_t mf1, mf2;
2032         const char *lbl[2];
2033         char *a_one, *b_two;
2034         const char *set = diff_get_color_opt(o, DIFF_METAINFO);
2035         const char *reset = diff_get_color_opt(o, DIFF_RESET);
2036         const char *a_prefix, *b_prefix;
2037         struct userdiff_driver *textconv_one = NULL;
2038         struct userdiff_driver *textconv_two = NULL;
2039         struct strbuf header = STRBUF_INIT;
2040         struct strbuf *msgbuf;
2041         char *line_prefix = "";
2043         if (o->output_prefix) {
2044                 msgbuf = o->output_prefix(o, o->output_prefix_data);
2045                 line_prefix = msgbuf->buf;
2046         }
2048         if (DIFF_OPT_TST(o, SUBMODULE_LOG) &&
2049                         (!one->mode || S_ISGITLINK(one->mode)) &&
2050                         (!two->mode || S_ISGITLINK(two->mode))) {
2051                 const char *del = diff_get_color_opt(o, DIFF_FILE_OLD);
2052                 const char *add = diff_get_color_opt(o, DIFF_FILE_NEW);
2053                 show_submodule_summary(o->file, one ? one->path : two->path,
2054                                 one->sha1, two->sha1, two->dirty_submodule,
2055                                 del, add, reset);
2056                 return;
2057         }
2059         if (DIFF_OPT_TST(o, ALLOW_TEXTCONV)) {
2060                 textconv_one = get_textconv(one);
2061                 textconv_two = get_textconv(two);
2062         }
2064         diff_set_mnemonic_prefix(o, "a/", "b/");
2065         if (DIFF_OPT_TST(o, REVERSE_DIFF)) {
2066                 a_prefix = o->b_prefix;
2067                 b_prefix = o->a_prefix;
2068         } else {
2069                 a_prefix = o->a_prefix;
2070                 b_prefix = o->b_prefix;
2071         }
2073         /* Never use a non-valid filename anywhere if at all possible */
2074         name_a = DIFF_FILE_VALID(one) ? name_a : name_b;
2075         name_b = DIFF_FILE_VALID(two) ? name_b : name_a;
2077         a_one = quote_two(a_prefix, name_a + (*name_a == '/'));
2078         b_two = quote_two(b_prefix, name_b + (*name_b == '/'));
2079         lbl[0] = DIFF_FILE_VALID(one) ? a_one : "/dev/null";
2080         lbl[1] = DIFF_FILE_VALID(two) ? b_two : "/dev/null";
2081         strbuf_addf(&header, "%s%sdiff --git %s %s%s\n", line_prefix, set, a_one, b_two, reset);
2082         if (lbl[0][0] == '/') {
2083                 /* /dev/null */
2084                 strbuf_addf(&header, "%s%snew file mode %06o%s\n", line_prefix, set, two->mode, reset);
2085                 if (xfrm_msg)
2086                         strbuf_addstr(&header, xfrm_msg);
2087                 must_show_header = 1;
2088         }
2089         else if (lbl[1][0] == '/') {
2090                 strbuf_addf(&header, "%s%sdeleted file mode %06o%s\n", line_prefix, set, one->mode, reset);
2091                 if (xfrm_msg)
2092                         strbuf_addstr(&header, xfrm_msg);
2093                 must_show_header = 1;
2094         }
2095         else {
2096                 if (one->mode != two->mode) {
2097                         strbuf_addf(&header, "%s%sold mode %06o%s\n", line_prefix, set, one->mode, reset);
2098                         strbuf_addf(&header, "%s%snew mode %06o%s\n", line_prefix, set, two->mode, reset);
2099                         must_show_header = 1;
2100                 }
2101                 if (xfrm_msg)
2102                         strbuf_addstr(&header, xfrm_msg);
2104                 /*
2105                  * we do not run diff between different kind
2106                  * of objects.
2107                  */
2108                 if ((one->mode ^ two->mode) & S_IFMT)
2109                         goto free_ab_and_return;
2110                 if (complete_rewrite &&
2111                     (textconv_one || !diff_filespec_is_binary(one)) &&
2112                     (textconv_two || !diff_filespec_is_binary(two))) {
2113                         fprintf(o->file, "%s", header.buf);
2114                         strbuf_reset(&header);
2115                         emit_rewrite_diff(name_a, name_b, one, two,
2116                                                 textconv_one, textconv_two, o);
2117                         o->found_changes = 1;
2118                         goto free_ab_and_return;
2119                 }
2120         }
2122         if (o->irreversible_delete && lbl[1][0] == '/') {
2123                 fprintf(o->file, "%s", header.buf);
2124                 strbuf_reset(&header);
2125                 goto free_ab_and_return;
2126         } else if (!DIFF_OPT_TST(o, TEXT) &&
2127             ( (!textconv_one && diff_filespec_is_binary(one)) ||
2128               (!textconv_two && diff_filespec_is_binary(two)) )) {
2129                 if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
2130                         die("unable to read files to diff");
2131                 /* Quite common confusing case */
2132                 if (mf1.size == mf2.size &&
2133                     !memcmp(mf1.ptr, mf2.ptr, mf1.size)) {
2134                         if (must_show_header)
2135                                 fprintf(o->file, "%s", header.buf);
2136                         goto free_ab_and_return;
2137                 }
2138                 fprintf(o->file, "%s", header.buf);
2139                 strbuf_reset(&header);
2140                 if (DIFF_OPT_TST(o, BINARY))
2141                         emit_binary_diff(o->file, &mf1, &mf2, line_prefix);
2142                 else
2143                         fprintf(o->file, "%sBinary files %s and %s differ\n",
2144                                 line_prefix, lbl[0], lbl[1]);
2145                 o->found_changes = 1;
2146         } else {
2147                 /* Crazy xdl interfaces.. */
2148                 const char *diffopts = getenv("GIT_DIFF_OPTS");
2149                 xpparam_t xpp;
2150                 xdemitconf_t xecfg;
2151                 struct emit_callback ecbdata;
2152                 const struct userdiff_funcname *pe;
2154                 if (!DIFF_XDL_TST(o, WHITESPACE_FLAGS) || must_show_header) {
2155                         fprintf(o->file, "%s", header.buf);
2156                         strbuf_reset(&header);
2157                 }
2159                 mf1.size = fill_textconv(textconv_one, one, &mf1.ptr);
2160                 mf2.size = fill_textconv(textconv_two, two, &mf2.ptr);
2162                 pe = diff_funcname_pattern(one);
2163                 if (!pe)
2164                         pe = diff_funcname_pattern(two);
2166                 memset(&xpp, 0, sizeof(xpp));
2167                 memset(&xecfg, 0, sizeof(xecfg));
2168                 memset(&ecbdata, 0, sizeof(ecbdata));
2169                 ecbdata.label_path = lbl;
2170                 ecbdata.color_diff = want_color(o->use_color);
2171                 ecbdata.found_changesp = &o->found_changes;
2172                 ecbdata.ws_rule = whitespace_rule(name_b ? name_b : name_a);
2173                 if (ecbdata.ws_rule & WS_BLANK_AT_EOF)
2174                         check_blank_at_eof(&mf1, &mf2, &ecbdata);
2175                 ecbdata.opt = o;
2176                 ecbdata.header = header.len ? &header : NULL;
2177                 xpp.flags = o->xdl_opts;
2178                 xecfg.ctxlen = o->context;
2179                 xecfg.interhunkctxlen = o->interhunkcontext;
2180                 xecfg.flags = XDL_EMIT_FUNCNAMES;
2181                 if (DIFF_OPT_TST(o, FUNCCONTEXT))
2182                         xecfg.flags |= XDL_EMIT_FUNCCONTEXT;
2183                 if (pe)
2184                         xdiff_set_find_func(&xecfg, pe->pattern, pe->cflags);
2185                 if (!diffopts)
2186                         ;
2187                 else if (!prefixcmp(diffopts, "--unified="))
2188                         xecfg.ctxlen = strtoul(diffopts + 10, NULL, 10);
2189                 else if (!prefixcmp(diffopts, "-u"))
2190                         xecfg.ctxlen = strtoul(diffopts + 2, NULL, 10);
2191                 if (o->word_diff) {
2192                         int i;
2194                         ecbdata.diff_words =
2195                                 xcalloc(1, sizeof(struct diff_words_data));
2196                         ecbdata.diff_words->type = o->word_diff;
2197                         ecbdata.diff_words->opt = o;
2198                         if (!o->word_regex)
2199                                 o->word_regex = userdiff_word_regex(one);
2200                         if (!o->word_regex)
2201                                 o->word_regex = userdiff_word_regex(two);
2202                         if (!o->word_regex)
2203                                 o->word_regex = diff_word_regex_cfg;
2204                         if (o->word_regex) {
2205                                 ecbdata.diff_words->word_regex = (regex_t *)
2206                                         xmalloc(sizeof(regex_t));
2207                                 if (regcomp(ecbdata.diff_words->word_regex,
2208                                                 o->word_regex,
2209                                                 REG_EXTENDED | REG_NEWLINE))
2210                                         die ("Invalid regular expression: %s",
2211                                                         o->word_regex);
2212                         }
2213                         for (i = 0; i < ARRAY_SIZE(diff_words_styles); i++) {
2214                                 if (o->word_diff == diff_words_styles[i].type) {
2215                                         ecbdata.diff_words->style =
2216                                                 &diff_words_styles[i];
2217                                         break;
2218                                 }
2219                         }
2220                         if (want_color(o->use_color)) {
2221                                 struct diff_words_style *st = ecbdata.diff_words->style;
2222                                 st->old.color = diff_get_color_opt(o, DIFF_FILE_OLD);
2223                                 st->new.color = diff_get_color_opt(o, DIFF_FILE_NEW);
2224                                 st->ctx.color = diff_get_color_opt(o, DIFF_PLAIN);
2225                         }
2226                 }
2227                 xdi_diff_outf(&mf1, &mf2, fn_out_consume, &ecbdata,
2228                               &xpp, &xecfg);
2229                 if (o->word_diff)
2230                         free_diff_words_data(&ecbdata);
2231                 if (textconv_one)
2232                         free(mf1.ptr);
2233                 if (textconv_two)
2234                         free(mf2.ptr);
2235                 xdiff_clear_find_func(&xecfg);
2236         }
2238  free_ab_and_return:
2239         strbuf_release(&header);
2240         diff_free_filespec_data(one);
2241         diff_free_filespec_data(two);
2242         free(a_one);
2243         free(b_two);
2244         return;
2247 static void builtin_diffstat(const char *name_a, const char *name_b,
2248                              struct diff_filespec *one,
2249                              struct diff_filespec *two,
2250                              struct diffstat_t *diffstat,
2251                              struct diff_options *o,
2252                              int complete_rewrite)
2254         mmfile_t mf1, mf2;
2255         struct diffstat_file *data;
2257         data = diffstat_add(diffstat, name_a, name_b);
2259         if (!one || !two) {
2260                 data->is_unmerged = 1;
2261                 return;
2262         }
2264         if (diff_filespec_is_binary(one) || diff_filespec_is_binary(two)) {
2265                 data->is_binary = 1;
2266                 data->added = diff_filespec_size(two);
2267                 data->deleted = diff_filespec_size(one);
2268         }
2270         else if (complete_rewrite) {
2271                 diff_populate_filespec(one, 0);
2272                 diff_populate_filespec(two, 0);
2273                 data->deleted = count_lines(one->data, one->size);
2274                 data->added = count_lines(two->data, two->size);
2275         }
2277         else {
2278                 /* Crazy xdl interfaces.. */
2279                 xpparam_t xpp;
2280                 xdemitconf_t xecfg;
2282                 if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
2283                         die("unable to read files to diff");
2285                 memset(&xpp, 0, sizeof(xpp));
2286                 memset(&xecfg, 0, sizeof(xecfg));
2287                 xpp.flags = o->xdl_opts;
2288                 xecfg.ctxlen = o->context;
2289                 xecfg.interhunkctxlen = o->interhunkcontext;
2290                 xdi_diff_outf(&mf1, &mf2, diffstat_consume, diffstat,
2291                               &xpp, &xecfg);
2292         }
2294         diff_free_filespec_data(one);
2295         diff_free_filespec_data(two);
2298 static void builtin_checkdiff(const char *name_a, const char *name_b,
2299                               const char *attr_path,
2300                               struct diff_filespec *one,
2301                               struct diff_filespec *two,
2302                               struct diff_options *o)
2304         mmfile_t mf1, mf2;
2305         struct checkdiff_t data;
2307         if (!two)
2308                 return;
2310         memset(&data, 0, sizeof(data));
2311         data.filename = name_b ? name_b : name_a;
2312         data.lineno = 0;
2313         data.o = o;
2314         data.ws_rule = whitespace_rule(attr_path);
2315         data.conflict_marker_size = ll_merge_marker_size(attr_path);
2317         if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
2318                 die("unable to read files to diff");
2320         /*
2321          * All the other codepaths check both sides, but not checking
2322          * the "old" side here is deliberate.  We are checking the newly
2323          * introduced changes, and as long as the "new" side is text, we
2324          * can and should check what it introduces.
2325          */
2326         if (diff_filespec_is_binary(two))
2327                 goto free_and_return;
2328         else {
2329                 /* Crazy xdl interfaces.. */
2330                 xpparam_t xpp;
2331                 xdemitconf_t xecfg;
2333                 memset(&xpp, 0, sizeof(xpp));
2334                 memset(&xecfg, 0, sizeof(xecfg));
2335                 xecfg.ctxlen = 1; /* at least one context line */
2336                 xpp.flags = 0;
2337                 xdi_diff_outf(&mf1, &mf2, checkdiff_consume, &data,
2338                               &xpp, &xecfg);
2340                 if (data.ws_rule & WS_BLANK_AT_EOF) {
2341                         struct emit_callback ecbdata;
2342                         int blank_at_eof;
2344                         ecbdata.ws_rule = data.ws_rule;
2345                         check_blank_at_eof(&mf1, &mf2, &ecbdata);
2346                         blank_at_eof = ecbdata.blank_at_eof_in_postimage;
2348                         if (blank_at_eof) {
2349                                 static char *err;
2350                                 if (!err)
2351                                         err = whitespace_error_string(WS_BLANK_AT_EOF);
2352                                 fprintf(o->file, "%s:%d: %s.\n",
2353                                         data.filename, blank_at_eof, err);
2354                                 data.status = 1; /* report errors */
2355                         }
2356                 }
2357         }
2358  free_and_return:
2359         diff_free_filespec_data(one);
2360         diff_free_filespec_data(two);
2361         if (data.status)
2362                 DIFF_OPT_SET(o, CHECK_FAILED);
2365 struct diff_filespec *alloc_filespec(const char *path)
2367         int namelen = strlen(path);
2368         struct diff_filespec *spec = xmalloc(sizeof(*spec) + namelen + 1);
2370         memset(spec, 0, sizeof(*spec));
2371         spec->path = (char *)(spec + 1);
2372         memcpy(spec->path, path, namelen+1);
2373         spec->count = 1;
2374         spec->is_binary = -1;
2375         return spec;
2378 void free_filespec(struct diff_filespec *spec)
2380         if (!--spec->count) {
2381                 diff_free_filespec_data(spec);
2382                 free(spec);
2383         }
2386 void fill_filespec(struct diff_filespec *spec, const unsigned char *sha1,
2387                    unsigned short mode)
2389         if (mode) {
2390                 spec->mode = canon_mode(mode);
2391                 hashcpy(spec->sha1, sha1);
2392                 spec->sha1_valid = !is_null_sha1(sha1);
2393         }
2396 /*
2397  * Given a name and sha1 pair, if the index tells us the file in
2398  * the work tree has that object contents, return true, so that
2399  * prepare_temp_file() does not have to inflate and extract.
2400  */
2401 static int reuse_worktree_file(const char *name, const unsigned char *sha1, int want_file)
2403         struct cache_entry *ce;
2404         struct stat st;
2405         int pos, len;
2407         /*
2408          * We do not read the cache ourselves here, because the
2409          * benchmark with my previous version that always reads cache
2410          * shows that it makes things worse for diff-tree comparing
2411          * two linux-2.6 kernel trees in an already checked out work
2412          * tree.  This is because most diff-tree comparisons deal with
2413          * only a small number of files, while reading the cache is
2414          * expensive for a large project, and its cost outweighs the
2415          * savings we get by not inflating the object to a temporary
2416          * file.  Practically, this code only helps when we are used
2417          * by diff-cache --cached, which does read the cache before
2418          * calling us.
2419          */
2420         if (!active_cache)
2421                 return 0;
2423         /* We want to avoid the working directory if our caller
2424          * doesn't need the data in a normal file, this system
2425          * is rather slow with its stat/open/mmap/close syscalls,
2426          * and the object is contained in a pack file.  The pack
2427          * is probably already open and will be faster to obtain
2428          * the data through than the working directory.  Loose
2429          * objects however would tend to be slower as they need
2430          * to be individually opened and inflated.
2431          */
2432         if (!FAST_WORKING_DIRECTORY && !want_file && has_sha1_pack(sha1))
2433                 return 0;
2435         len = strlen(name);
2436         pos = cache_name_pos(name, len);
2437         if (pos < 0)
2438                 return 0;
2439         ce = active_cache[pos];
2441         /*
2442          * This is not the sha1 we are looking for, or
2443          * unreusable because it is not a regular file.
2444          */
2445         if (hashcmp(sha1, ce->sha1) || !S_ISREG(ce->ce_mode))
2446                 return 0;
2448         /*
2449          * If ce is marked as "assume unchanged", there is no
2450          * guarantee that work tree matches what we are looking for.
2451          */
2452         if ((ce->ce_flags & CE_VALID) || ce_skip_worktree(ce))
2453                 return 0;
2455         /*
2456          * If ce matches the file in the work tree, we can reuse it.
2457          */
2458         if (ce_uptodate(ce) ||
2459             (!lstat(name, &st) && !ce_match_stat(ce, &st, 0)))
2460                 return 1;
2462         return 0;
2465 static int populate_from_stdin(struct diff_filespec *s)
2467         struct strbuf buf = STRBUF_INIT;
2468         size_t size = 0;
2470         if (strbuf_read(&buf, 0, 0) < 0)
2471                 return error("error while reading from stdin %s",
2472                                      strerror(errno));
2474         s->should_munmap = 0;
2475         s->data = strbuf_detach(&buf, &size);
2476         s->size = size;
2477         s->should_free = 1;
2478         return 0;
2481 static int diff_populate_gitlink(struct diff_filespec *s, int size_only)
2483         int len;
2484         char *data = xmalloc(100), *dirty = "";
2486         /* Are we looking at the work tree? */
2487         if (s->dirty_submodule)
2488                 dirty = "-dirty";
2490         len = snprintf(data, 100,
2491                        "Subproject commit %s%s\n", sha1_to_hex(s->sha1), dirty);
2492         s->data = data;
2493         s->size = len;
2494         s->should_free = 1;
2495         if (size_only) {
2496                 s->data = NULL;
2497                 free(data);
2498         }
2499         return 0;
2502 /*
2503  * While doing rename detection and pickaxe operation, we may need to
2504  * grab the data for the blob (or file) for our own in-core comparison.
2505  * diff_filespec has data and size fields for this purpose.
2506  */
2507 int diff_populate_filespec(struct diff_filespec *s, int size_only)
2509         int err = 0;
2510         if (!DIFF_FILE_VALID(s))
2511                 die("internal error: asking to populate invalid file.");
2512         if (S_ISDIR(s->mode))
2513                 return -1;
2515         if (s->data)
2516                 return 0;
2518         if (size_only && 0 < s->size)
2519                 return 0;
2521         if (S_ISGITLINK(s->mode))
2522                 return diff_populate_gitlink(s, size_only);
2524         if (!s->sha1_valid ||
2525             reuse_worktree_file(s->path, s->sha1, 0)) {
2526                 struct strbuf buf = STRBUF_INIT;
2527                 struct stat st;
2528                 int fd;
2530                 if (!strcmp(s->path, "-"))
2531                         return populate_from_stdin(s);
2533                 if (lstat(s->path, &st) < 0) {
2534                         if (errno == ENOENT) {
2535                         err_empty:
2536                                 err = -1;
2537                         empty:
2538                                 s->data = (char *)"";
2539                                 s->size = 0;
2540                                 return err;
2541                         }
2542                 }
2543                 s->size = xsize_t(st.st_size);
2544                 if (!s->size)
2545                         goto empty;
2546                 if (S_ISLNK(st.st_mode)) {
2547                         struct strbuf sb = STRBUF_INIT;
2549                         if (strbuf_readlink(&sb, s->path, s->size))
2550                                 goto err_empty;
2551                         s->size = sb.len;
2552                         s->data = strbuf_detach(&sb, NULL);
2553                         s->should_free = 1;
2554                         return 0;
2555                 }
2556                 if (size_only)
2557                         return 0;
2558                 fd = open(s->path, O_RDONLY);
2559                 if (fd < 0)
2560                         goto err_empty;
2561                 s->data = xmmap(NULL, s->size, PROT_READ, MAP_PRIVATE, fd, 0);
2562                 close(fd);
2563                 s->should_munmap = 1;
2565                 /*
2566                  * Convert from working tree format to canonical git format
2567                  */
2568                 if (convert_to_git(s->path, s->data, s->size, &buf, safe_crlf)) {
2569                         size_t size = 0;
2570                         munmap(s->data, s->size);
2571                         s->should_munmap = 0;
2572                         s->data = strbuf_detach(&buf, &size);
2573                         s->size = size;
2574                         s->should_free = 1;
2575                 }
2576         }
2577         else {
2578                 enum object_type type;
2579                 if (size_only) {
2580                         type = sha1_object_info(s->sha1, &s->size);
2581                         if (type < 0)
2582                                 die("unable to read %s", sha1_to_hex(s->sha1));
2583                 } else {
2584                         s->data = read_sha1_file(s->sha1, &type, &s->size);
2585                         if (!s->data)
2586                                 die("unable to read %s", sha1_to_hex(s->sha1));
2587                         s->should_free = 1;
2588                 }
2589         }
2590         return 0;
2593 void diff_free_filespec_blob(struct diff_filespec *s)
2595         if (s->should_free)
2596                 free(s->data);
2597         else if (s->should_munmap)
2598                 munmap(s->data, s->size);
2600         if (s->should_free || s->should_munmap) {
2601                 s->should_free = s->should_munmap = 0;
2602                 s->data = NULL;
2603         }
2606 void diff_free_filespec_data(struct diff_filespec *s)
2608         diff_free_filespec_blob(s);
2609         free(s->cnt_data);
2610         s->cnt_data = NULL;
2613 static void prep_temp_blob(const char *path, struct diff_tempfile *temp,
2614                            void *blob,
2615                            unsigned long size,
2616                            const unsigned char *sha1,
2617                            int mode)
2619         int fd;
2620         struct strbuf buf = STRBUF_INIT;
2621         struct strbuf template = STRBUF_INIT;
2622         char *path_dup = xstrdup(path);
2623         const char *base = basename(path_dup);
2625         /* Generate "XXXXXX_basename.ext" */
2626         strbuf_addstr(&template, "XXXXXX_");
2627         strbuf_addstr(&template, base);
2629         fd = git_mkstemps(temp->tmp_path, PATH_MAX, template.buf,
2630                         strlen(base) + 1);
2631         if (fd < 0)
2632                 die_errno("unable to create temp-file");
2633         if (convert_to_working_tree(path,
2634                         (const char *)blob, (size_t)size, &buf)) {
2635                 blob = buf.buf;
2636                 size = buf.len;
2637         }
2638         if (write_in_full(fd, blob, size) != size)
2639                 die_errno("unable to write temp-file");
2640         close(fd);
2641         temp->name = temp->tmp_path;
2642         strcpy(temp->hex, sha1_to_hex(sha1));
2643         temp->hex[40] = 0;
2644         sprintf(temp->mode, "%06o", mode);
2645         strbuf_release(&buf);
2646         strbuf_release(&template);
2647         free(path_dup);
2650 static struct diff_tempfile *prepare_temp_file(const char *name,
2651                 struct diff_filespec *one)
2653         struct diff_tempfile *temp = claim_diff_tempfile();
2655         if (!DIFF_FILE_VALID(one)) {
2656         not_a_valid_file:
2657                 /* A '-' entry produces this for file-2, and
2658                  * a '+' entry produces this for file-1.
2659                  */
2660                 temp->name = "/dev/null";
2661                 strcpy(temp->hex, ".");
2662                 strcpy(temp->mode, ".");
2663                 return temp;
2664         }
2666         if (!remove_tempfile_installed) {
2667                 atexit(remove_tempfile);
2668                 sigchain_push_common(remove_tempfile_on_signal);
2669                 remove_tempfile_installed = 1;
2670         }
2672         if (!one->sha1_valid ||
2673             reuse_worktree_file(name, one->sha1, 1)) {
2674                 struct stat st;
2675                 if (lstat(name, &st) < 0) {
2676                         if (errno == ENOENT)
2677                                 goto not_a_valid_file;
2678                         die_errno("stat(%s)", name);
2679                 }
2680                 if (S_ISLNK(st.st_mode)) {
2681                         struct strbuf sb = STRBUF_INIT;
2682                         if (strbuf_readlink(&sb, name, st.st_size) < 0)
2683                                 die_errno("readlink(%s)", name);
2684                         prep_temp_blob(name, temp, sb.buf, sb.len,
2685                                        (one->sha1_valid ?
2686                                         one->sha1 : null_sha1),
2687                                        (one->sha1_valid ?
2688                                         one->mode : S_IFLNK));
2689                         strbuf_release(&sb);
2690                 }
2691                 else {
2692                         /* we can borrow from the file in the work tree */
2693                         temp->name = name;
2694                         if (!one->sha1_valid)
2695                                 strcpy(temp->hex, sha1_to_hex(null_sha1));
2696                         else
2697                                 strcpy(temp->hex, sha1_to_hex(one->sha1));
2698                         /* Even though we may sometimes borrow the
2699                          * contents from the work tree, we always want
2700                          * one->mode.  mode is trustworthy even when
2701                          * !(one->sha1_valid), as long as
2702                          * DIFF_FILE_VALID(one).
2703                          */
2704                         sprintf(temp->mode, "%06o", one->mode);
2705                 }
2706                 return temp;
2707         }
2708         else {
2709                 if (diff_populate_filespec(one, 0))
2710                         die("cannot read data blob for %s", one->path);
2711                 prep_temp_blob(name, temp, one->data, one->size,
2712                                one->sha1, one->mode);
2713         }
2714         return temp;
2717 /* An external diff command takes:
2718  *
2719  * diff-cmd name infile1 infile1-sha1 infile1-mode \
2720  *               infile2 infile2-sha1 infile2-mode [ rename-to ]
2721  *
2722  */
2723 static void run_external_diff(const char *pgm,
2724                               const char *name,
2725                               const char *other,
2726                               struct diff_filespec *one,
2727                               struct diff_filespec *two,
2728                               const char *xfrm_msg,
2729                               int complete_rewrite)
2731         const char *spawn_arg[10];
2732         int retval;
2733         const char **arg = &spawn_arg[0];
2735         if (one && two) {
2736                 struct diff_tempfile *temp_one, *temp_two;
2737                 const char *othername = (other ? other : name);
2738                 temp_one = prepare_temp_file(name, one);
2739                 temp_two = prepare_temp_file(othername, two);
2740                 *arg++ = pgm;
2741                 *arg++ = name;
2742                 *arg++ = temp_one->name;
2743                 *arg++ = temp_one->hex;
2744                 *arg++ = temp_one->mode;
2745                 *arg++ = temp_two->name;
2746                 *arg++ = temp_two->hex;
2747                 *arg++ = temp_two->mode;
2748                 if (other) {
2749                         *arg++ = other;
2750                         *arg++ = xfrm_msg;
2751                 }
2752         } else {
2753                 *arg++ = pgm;
2754                 *arg++ = name;
2755         }
2756         *arg = NULL;
2757         fflush(NULL);
2758         retval = run_command_v_opt(spawn_arg, RUN_USING_SHELL);
2759         remove_tempfile();
2760         if (retval) {
2761                 fprintf(stderr, "external diff died, stopping at %s.\n", name);
2762                 exit(1);
2763         }
2766 static int similarity_index(struct diff_filepair *p)
2768         return p->score * 100 / MAX_SCORE;
2771 static void fill_metainfo(struct strbuf *msg,
2772                           const char *name,
2773                           const char *other,
2774                           struct diff_filespec *one,
2775                           struct diff_filespec *two,
2776                           struct diff_options *o,
2777                           struct diff_filepair *p,
2778                           int *must_show_header,
2779                           int use_color)
2781         const char *set = diff_get_color(use_color, DIFF_METAINFO);
2782         const char *reset = diff_get_color(use_color, DIFF_RESET);
2783         struct strbuf *msgbuf;
2784         char *line_prefix = "";
2786         *must_show_header = 1;
2787         if (o->output_prefix) {
2788                 msgbuf = o->output_prefix(o, o->output_prefix_data);
2789                 line_prefix = msgbuf->buf;
2790         }
2791         strbuf_init(msg, PATH_MAX * 2 + 300);
2792         switch (p->status) {
2793         case DIFF_STATUS_COPIED:
2794                 strbuf_addf(msg, "%s%ssimilarity index %d%%",
2795                             line_prefix, set, similarity_index(p));
2796                 strbuf_addf(msg, "%s\n%s%scopy from ",
2797                             reset,  line_prefix, set);
2798                 quote_c_style(name, msg, NULL, 0);
2799                 strbuf_addf(msg, "%s\n%s%scopy to ", reset, line_prefix, set);
2800                 quote_c_style(other, msg, NULL, 0);
2801                 strbuf_addf(msg, "%s\n", reset);
2802                 break;
2803         case DIFF_STATUS_RENAMED:
2804                 strbuf_addf(msg, "%s%ssimilarity index %d%%",
2805                             line_prefix, set, similarity_index(p));
2806                 strbuf_addf(msg, "%s\n%s%srename from ",
2807                             reset, line_prefix, set);
2808                 quote_c_style(name, msg, NULL, 0);
2809                 strbuf_addf(msg, "%s\n%s%srename to ",
2810                             reset, line_prefix, set);
2811                 quote_c_style(other, msg, NULL, 0);
2812                 strbuf_addf(msg, "%s\n", reset);
2813                 break;
2814         case DIFF_STATUS_MODIFIED:
2815                 if (p->score) {
2816                         strbuf_addf(msg, "%s%sdissimilarity index %d%%%s\n",
2817                                     line_prefix,
2818                                     set, similarity_index(p), reset);
2819                         break;
2820                 }
2821                 /* fallthru */
2822         default:
2823                 *must_show_header = 0;
2824         }
2825         if (one && two && hashcmp(one->sha1, two->sha1)) {
2826                 int abbrev = DIFF_OPT_TST(o, FULL_INDEX) ? 40 : DEFAULT_ABBREV;
2828                 if (DIFF_OPT_TST(o, BINARY)) {
2829                         mmfile_t mf;
2830                         if ((!fill_mmfile(&mf, one) && diff_filespec_is_binary(one)) ||
2831                             (!fill_mmfile(&mf, two) && diff_filespec_is_binary(two)))
2832                                 abbrev = 40;
2833                 }
2834                 strbuf_addf(msg, "%s%sindex %s..", line_prefix, set,
2835                             find_unique_abbrev(one->sha1, abbrev));
2836                 strbuf_addstr(msg, find_unique_abbrev(two->sha1, abbrev));
2837                 if (one->mode == two->mode)
2838                         strbuf_addf(msg, " %06o", one->mode);
2839                 strbuf_addf(msg, "%s\n", reset);
2840         }
2843 static void run_diff_cmd(const char *pgm,
2844                          const char *name,
2845                          const char *other,
2846                          const char *attr_path,
2847                          struct diff_filespec *one,
2848                          struct diff_filespec *two,
2849                          struct strbuf *msg,
2850                          struct diff_options *o,
2851                          struct diff_filepair *p)
2853         const char *xfrm_msg = NULL;
2854         int complete_rewrite = (p->status == DIFF_STATUS_MODIFIED) && p->score;
2855         int must_show_header = 0;
2857         if (!DIFF_OPT_TST(o, ALLOW_EXTERNAL))
2858                 pgm = NULL;
2859         else {
2860                 struct userdiff_driver *drv = userdiff_find_by_path(attr_path);
2861                 if (drv && drv->external)
2862                         pgm = drv->external;
2863         }
2865         if (msg) {
2866                 /*
2867                  * don't use colors when the header is intended for an
2868                  * external diff driver
2869                  */
2870                 fill_metainfo(msg, name, other, one, two, o, p,
2871                               &must_show_header,
2872                               want_color(o->use_color) && !pgm);
2873                 xfrm_msg = msg->len ? msg->buf : NULL;
2874         }
2876         if (pgm) {
2877                 run_external_diff(pgm, name, other, one, two, xfrm_msg,
2878                                   complete_rewrite);
2879                 return;
2880         }
2881         if (one && two)
2882                 builtin_diff(name, other ? other : name,
2883                              one, two, xfrm_msg, must_show_header,
2884                              o, complete_rewrite);
2885         else
2886                 fprintf(o->file, "* Unmerged path %s\n", name);
2889 static void diff_fill_sha1_info(struct diff_filespec *one)
2891         if (DIFF_FILE_VALID(one)) {
2892                 if (!one->sha1_valid) {
2893                         struct stat st;
2894                         if (!strcmp(one->path, "-")) {
2895                                 hashcpy(one->sha1, null_sha1);
2896                                 return;
2897                         }
2898                         if (lstat(one->path, &st) < 0)
2899                                 die_errno("stat '%s'", one->path);
2900                         if (index_path(one->sha1, one->path, &st, 0))
2901                                 die("cannot hash %s", one->path);
2902                 }
2903         }
2904         else
2905                 hashclr(one->sha1);
2908 static void strip_prefix(int prefix_length, const char **namep, const char **otherp)
2910         /* Strip the prefix but do not molest /dev/null and absolute paths */
2911         if (*namep && **namep != '/') {
2912                 *namep += prefix_length;
2913                 if (**namep == '/')
2914                         ++*namep;
2915         }
2916         if (*otherp && **otherp != '/') {
2917                 *otherp += prefix_length;
2918                 if (**otherp == '/')
2919                         ++*otherp;
2920         }
2923 static void run_diff(struct diff_filepair *p, struct diff_options *o)
2925         const char *pgm = external_diff();
2926         struct strbuf msg;
2927         struct diff_filespec *one = p->one;
2928         struct diff_filespec *two = p->two;
2929         const char *name;
2930         const char *other;
2931         const char *attr_path;
2933         name  = p->one->path;
2934         other = (strcmp(name, p->two->path) ? p->two->path : NULL);
2935         attr_path = name;
2936         if (o->prefix_length)
2937                 strip_prefix(o->prefix_length, &name, &other);
2939         if (DIFF_PAIR_UNMERGED(p)) {
2940                 run_diff_cmd(pgm, name, NULL, attr_path,
2941                              NULL, NULL, NULL, o, p);
2942                 return;
2943         }
2945         diff_fill_sha1_info(one);
2946         diff_fill_sha1_info(two);
2948         if (!pgm &&
2949             DIFF_FILE_VALID(one) && DIFF_FILE_VALID(two) &&
2950             (S_IFMT & one->mode) != (S_IFMT & two->mode)) {
2951                 /*
2952                  * a filepair that changes between file and symlink
2953                  * needs to be split into deletion and creation.
2954                  */
2955                 struct diff_filespec *null = alloc_filespec(two->path);
2956                 run_diff_cmd(NULL, name, other, attr_path,
2957                              one, null, &msg, o, p);
2958                 free(null);
2959                 strbuf_release(&msg);
2961                 null = alloc_filespec(one->path);
2962                 run_diff_cmd(NULL, name, other, attr_path,
2963                              null, two, &msg, o, p);
2964                 free(null);
2965         }
2966         else
2967                 run_diff_cmd(pgm, name, other, attr_path,
2968                              one, two, &msg, o, p);
2970         strbuf_release(&msg);
2973 static void run_diffstat(struct diff_filepair *p, struct diff_options *o,
2974                          struct diffstat_t *diffstat)
2976         const char *name;
2977         const char *other;
2978         int complete_rewrite = 0;
2980         if (DIFF_PAIR_UNMERGED(p)) {
2981                 /* unmerged */
2982                 builtin_diffstat(p->one->path, NULL, NULL, NULL, diffstat, o, 0);
2983                 return;
2984         }
2986         name = p->one->path;
2987         other = (strcmp(name, p->two->path) ? p->two->path : NULL);
2989         if (o->prefix_length)
2990                 strip_prefix(o->prefix_length, &name, &other);
2992         diff_fill_sha1_info(p->one);
2993         diff_fill_sha1_info(p->two);
2995         if (p->status == DIFF_STATUS_MODIFIED && p->score)
2996                 complete_rewrite = 1;
2997         builtin_diffstat(name, other, p->one, p->two, diffstat, o, complete_rewrite);
3000 static void run_checkdiff(struct diff_filepair *p, struct diff_options *o)
3002         const char *name;
3003         const char *other;
3004         const char *attr_path;
3006         if (DIFF_PAIR_UNMERGED(p)) {
3007                 /* unmerged */
3008                 return;
3009         }
3011         name = p->one->path;
3012         other = (strcmp(name, p->two->path) ? p->two->path : NULL);
3013         attr_path = other ? other : name;
3015         if (o->prefix_length)
3016                 strip_prefix(o->prefix_length, &name, &other);
3018         diff_fill_sha1_info(p->one);
3019         diff_fill_sha1_info(p->two);
3021         builtin_checkdiff(name, other, attr_path, p->one, p->two, o);
3024 void diff_setup(struct diff_options *options)
3026         memcpy(options, &default_diff_options, sizeof(*options));
3028         options->file = stdout;
3030         options->line_termination = '\n';
3031         options->break_opt = -1;
3032         options->rename_limit = -1;
3033         options->dirstat_permille = diff_dirstat_permille_default;
3034         options->context = 3;
3036         options->change = diff_change;
3037         options->add_remove = diff_addremove;
3038         options->use_color = diff_use_color_default;
3039         options->detect_rename = diff_detect_rename_default;
3041         if (diff_no_prefix) {
3042                 options->a_prefix = options->b_prefix = "";
3043         } else if (!diff_mnemonic_prefix) {
3044                 options->a_prefix = "a/";
3045                 options->b_prefix = "b/";
3046         }
3049 int diff_setup_done(struct diff_options *options)
3051         int count = 0;
3053         if (options->output_format & DIFF_FORMAT_NAME)
3054                 count++;
3055         if (options->output_format & DIFF_FORMAT_NAME_STATUS)
3056                 count++;
3057         if (options->output_format & DIFF_FORMAT_CHECKDIFF)
3058                 count++;
3059         if (options->output_format & DIFF_FORMAT_NO_OUTPUT)
3060                 count++;
3061         if (count > 1)
3062                 die("--name-only, --name-status, --check and -s are mutually exclusive");
3064         /*
3065          * Most of the time we can say "there are changes"
3066          * only by checking if there are changed paths, but
3067          * --ignore-whitespace* options force us to look
3068          * inside contents.
3069          */
3071         if (DIFF_XDL_TST(options, IGNORE_WHITESPACE) ||
3072             DIFF_XDL_TST(options, IGNORE_WHITESPACE_CHANGE) ||
3073             DIFF_XDL_TST(options, IGNORE_WHITESPACE_AT_EOL))
3074                 DIFF_OPT_SET(options, DIFF_FROM_CONTENTS);
3075         else
3076                 DIFF_OPT_CLR(options, DIFF_FROM_CONTENTS);
3078         if (DIFF_OPT_TST(options, FIND_COPIES_HARDER))
3079                 options->detect_rename = DIFF_DETECT_COPY;
3081         if (!DIFF_OPT_TST(options, RELATIVE_NAME))
3082                 options->prefix = NULL;
3083         if (options->prefix)
3084                 options->prefix_length = strlen(options->prefix);
3085         else
3086                 options->prefix_length = 0;
3088         if (options->output_format & (DIFF_FORMAT_NAME |
3089                                       DIFF_FORMAT_NAME_STATUS |
3090                                       DIFF_FORMAT_CHECKDIFF |
3091                                       DIFF_FORMAT_NO_OUTPUT))
3092                 options->output_format &= ~(DIFF_FORMAT_RAW |
3093                                             DIFF_FORMAT_NUMSTAT |
3094                                             DIFF_FORMAT_DIFFSTAT |
3095                                             DIFF_FORMAT_SHORTSTAT |
3096                                             DIFF_FORMAT_DIRSTAT |
3097                                             DIFF_FORMAT_SUMMARY |
3098                                             DIFF_FORMAT_PATCH);
3100         /*
3101          * These cases always need recursive; we do not drop caller-supplied
3102          * recursive bits for other formats here.
3103          */
3104         if (options->output_format & (DIFF_FORMAT_PATCH |
3105                                       DIFF_FORMAT_NUMSTAT |
3106                                       DIFF_FORMAT_DIFFSTAT |
3107                                       DIFF_FORMAT_SHORTSTAT |
3108                                       DIFF_FORMAT_DIRSTAT |
3109                                       DIFF_FORMAT_SUMMARY |
3110                                       DIFF_FORMAT_CHECKDIFF))
3111                 DIFF_OPT_SET(options, RECURSIVE);
3112         /*
3113          * Also pickaxe would not work very well if you do not say recursive
3114          */
3115         if (options->pickaxe)
3116                 DIFF_OPT_SET(options, RECURSIVE);
3117         /*
3118          * When patches are generated, submodules diffed against the work tree
3119          * must be checked for dirtiness too so it can be shown in the output
3120          */
3121         if (options->output_format & DIFF_FORMAT_PATCH)
3122                 DIFF_OPT_SET(options, DIRTY_SUBMODULES);
3124         if (options->detect_rename && options->rename_limit < 0)
3125                 options->rename_limit = diff_rename_limit_default;
3126         if (options->setup & DIFF_SETUP_USE_CACHE) {
3127                 if (!active_cache)
3128                         /* read-cache does not die even when it fails
3129                          * so it is safe for us to do this here.  Also
3130                          * it does not smudge active_cache or active_nr
3131                          * when it fails, so we do not have to worry about
3132                          * cleaning it up ourselves either.
3133                          */
3134                         read_cache();
3135         }
3136         if (options->abbrev <= 0 || 40 < options->abbrev)
3137                 options->abbrev = 40; /* full */
3139         /*
3140          * It does not make sense to show the first hit we happened
3141          * to have found.  It does not make sense not to return with
3142          * exit code in such a case either.
3143          */
3144         if (DIFF_OPT_TST(options, QUICK)) {
3145                 options->output_format = DIFF_FORMAT_NO_OUTPUT;
3146                 DIFF_OPT_SET(options, EXIT_WITH_STATUS);
3147         }
3149         return 0;
3152 static int opt_arg(const char *arg, int arg_short, const char *arg_long, int *val)
3154         char c, *eq;
3155         int len;
3157         if (*arg != '-')
3158                 return 0;
3159         c = *++arg;
3160         if (!c)
3161                 return 0;
3162         if (c == arg_short) {
3163                 c = *++arg;
3164                 if (!c)
3165                         return 1;
3166                 if (val && isdigit(c)) {
3167                         char *end;
3168                         int n = strtoul(arg, &end, 10);
3169                         if (*end)
3170                                 return 0;
3171                         *val = n;
3172                         return 1;
3173                 }
3174                 return 0;
3175         }
3176         if (c != '-')
3177                 return 0;
3178         arg++;
3179         eq = strchr(arg, '=');
3180         if (eq)
3181                 len = eq - arg;
3182         else
3183                 len = strlen(arg);
3184         if (!len || strncmp(arg, arg_long, len))
3185                 return 0;
3186         if (eq) {
3187                 int n;
3188                 char *end;
3189                 if (!isdigit(*++eq))
3190                         return 0;
3191                 n = strtoul(eq, &end, 10);
3192                 if (*end)
3193                         return 0;
3194                 *val = n;
3195         }
3196         return 1;
3199 static int diff_scoreopt_parse(const char *opt);
3201 static inline int short_opt(char opt, const char **argv,
3202                             const char **optarg)
3204         const char *arg = argv[0];
3205         if (arg[0] != '-' || arg[1] != opt)
3206                 return 0;
3207         if (arg[2] != '\0') {
3208                 *optarg = arg + 2;
3209                 return 1;
3210         }
3211         if (!argv[1])
3212                 die("Option '%c' requires a value", opt);
3213         *optarg = argv[1];
3214         return 2;
3217 int parse_long_opt(const char *opt, const char **argv,
3218                    const char **optarg)
3220         const char *arg = argv[0];
3221         if (arg[0] != '-' || arg[1] != '-')
3222                 return 0;
3223         arg += strlen("--");
3224         if (prefixcmp(arg, opt))
3225                 return 0;
3226         arg += strlen(opt);
3227         if (*arg == '=') { /* sticked form: --option=value */
3228                 *optarg = arg + 1;
3229                 return 1;
3230         }
3231         if (*arg != '\0')
3232                 return 0;
3233         /* separate form: --option value */
3234         if (!argv[1])
3235                 die("Option '--%s' requires a value", opt);
3236         *optarg = argv[1];
3237         return 2;
3240 static int stat_opt(struct diff_options *options, const char **av)
3242         const char *arg = av[0];
3243         char *end;
3244         int width = options->stat_width;
3245         int name_width = options->stat_name_width;
3246         int count = options->stat_count;
3247         int argcount = 1;
3249         arg += strlen("--stat");
3250         end = (char *)arg;
3252         switch (*arg) {
3253         case '-':
3254                 if (!prefixcmp(arg, "-width")) {
3255                         arg += strlen("-width");
3256                         if (*arg == '=')
3257                                 width = strtoul(arg + 1, &end, 10);
3258                         else if (!*arg && !av[1])
3259                                 die("Option '--stat-width' requires a value");
3260                         else if (!*arg) {
3261                                 width = strtoul(av[1], &end, 10);
3262                                 argcount = 2;
3263                         }
3264                 } else if (!prefixcmp(arg, "-name-width")) {
3265                         arg += strlen("-name-width");
3266                         if (*arg == '=')
3267                                 name_width = strtoul(arg + 1, &end, 10);
3268                         else if (!*arg && !av[1])
3269                                 die("Option '--stat-name-width' requires a value");
3270                         else if (!*arg) {
3271                                 name_width = strtoul(av[1], &end, 10);
3272                                 argcount = 2;
3273                         }
3274                 } else if (!prefixcmp(arg, "-count")) {
3275                         arg += strlen("-count");
3276                         if (*arg == '=')
3277                                 count = strtoul(arg + 1, &end, 10);
3278                         else if (!*arg && !av[1])
3279                                 die("Option '--stat-count' requires a value");
3280                         else if (!*arg) {
3281                                 count = strtoul(av[1], &end, 10);
3282                                 argcount = 2;
3283                         }
3284                 }
3285                 break;
3286         case '=':
3287                 width = strtoul(arg+1, &end, 10);
3288                 if (*end == ',')
3289                         name_width = strtoul(end+1, &end, 10);
3290                 if (*end == ',')
3291                         count = strtoul(end+1, &end, 10);
3292         }
3294         /* Important! This checks all the error cases! */
3295         if (*end)
3296                 return 0;
3297         options->output_format |= DIFF_FORMAT_DIFFSTAT;
3298         options->stat_name_width = name_width;
3299         options->stat_width = width;
3300         options->stat_count = count;
3301         return argcount;
3304 static int parse_dirstat_opt(struct diff_options *options, const char *params)
3306         struct strbuf errmsg = STRBUF_INIT;
3307         if (parse_dirstat_params(options, params, &errmsg))
3308                 die(_("Failed to parse --dirstat/-X option parameter:\n%s"),
3309                     errmsg.buf);
3310         strbuf_release(&errmsg);
3311         /*
3312          * The caller knows a dirstat-related option is given from the command
3313          * line; allow it to say "return this_function();"
3314          */
3315         options->output_format |= DIFF_FORMAT_DIRSTAT;
3316         return 1;
3319 int diff_opt_parse(struct diff_options *options, const char **av, int ac)
3321         const char *arg = av[0];
3322         const char *optarg;
3323         int argcount;
3325         /* Output format options */
3326         if (!strcmp(arg, "-p") || !strcmp(arg, "-u") || !strcmp(arg, "--patch"))
3327                 options->output_format |= DIFF_FORMAT_PATCH;
3328         else if (opt_arg(arg, 'U', "unified", &options->context))
3329                 options->output_format |= DIFF_FORMAT_PATCH;
3330         else if (!strcmp(arg, "--raw"))
3331                 options->output_format |= DIFF_FORMAT_RAW;
3332         else if (!strcmp(arg, "--patch-with-raw"))
3333                 options->output_format |= DIFF_FORMAT_PATCH | DIFF_FORMAT_RAW;
3334         else if (!strcmp(arg, "--numstat"))
3335                 options->output_format |= DIFF_FORMAT_NUMSTAT;
3336         else if (!strcmp(arg, "--shortstat"))
3337                 options->output_format |= DIFF_FORMAT_SHORTSTAT;
3338         else if (!strcmp(arg, "-X") || !strcmp(arg, "--dirstat"))
3339                 return parse_dirstat_opt(options, "");
3340         else if (!prefixcmp(arg, "-X"))
3341                 return parse_dirstat_opt(options, arg + 2);
3342         else if (!prefixcmp(arg, "--dirstat="))
3343                 return parse_dirstat_opt(options, arg + 10);
3344         else if (!strcmp(arg, "--cumulative"))
3345                 return parse_dirstat_opt(options, "cumulative");
3346         else if (!strcmp(arg, "--dirstat-by-file"))
3347                 return parse_dirstat_opt(options, "files");
3348         else if (!prefixcmp(arg, "--dirstat-by-file=")) {
3349                 parse_dirstat_opt(options, "files");
3350                 return parse_dirstat_opt(options, arg + 18);
3351         }
3352         else if (!strcmp(arg, "--check"))
3353                 options->output_format |= DIFF_FORMAT_CHECKDIFF;
3354         else if (!strcmp(arg, "--summary"))
3355                 options->output_format |= DIFF_FORMAT_SUMMARY;
3356         else if (!strcmp(arg, "--patch-with-stat"))
3357                 options->output_format |= DIFF_FORMAT_PATCH | DIFF_FORMAT_DIFFSTAT;
3358         else if (!strcmp(arg, "--name-only"))
3359                 options->output_format |= DIFF_FORMAT_NAME;
3360         else if (!strcmp(arg, "--name-status"))
3361                 options->output_format |= DIFF_FORMAT_NAME_STATUS;
3362         else if (!strcmp(arg, "-s"))
3363                 options->output_format |= DIFF_FORMAT_NO_OUTPUT;
3364         else if (!prefixcmp(arg, "--stat"))
3365                 /* --stat, --stat-width, --stat-name-width, or --stat-count */
3366                 return stat_opt(options, av);
3368         /* renames options */
3369         else if (!prefixcmp(arg, "-B") || !prefixcmp(arg, "--break-rewrites=") ||
3370                  !strcmp(arg, "--break-rewrites")) {
3371                 if ((options->break_opt = diff_scoreopt_parse(arg)) == -1)
3372                         return error("invalid argument to -B: %s", arg+2);
3373         }
3374         else if (!prefixcmp(arg, "-M") || !prefixcmp(arg, "--find-renames=") ||
3375                  !strcmp(arg, "--find-renames")) {
3376                 if ((options->rename_score = diff_scoreopt_parse(arg)) == -1)
3377                         return error("invalid argument to -M: %s", arg+2);
3378                 options->detect_rename = DIFF_DETECT_RENAME;
3379         }
3380         else if (!strcmp(arg, "-D") || !strcmp(arg, "--irreversible-delete")) {
3381                 options->irreversible_delete = 1;
3382         }
3383         else if (!prefixcmp(arg, "-C") || !prefixcmp(arg, "--find-copies=") ||
3384                  !strcmp(arg, "--find-copies")) {
3385                 if (options->detect_rename == DIFF_DETECT_COPY)
3386                         DIFF_OPT_SET(options, FIND_COPIES_HARDER);
3387                 if ((options->rename_score = diff_scoreopt_parse(arg)) == -1)
3388                         return error("invalid argument to -C: %s", arg+2);
3389                 options->detect_rename = DIFF_DETECT_COPY;
3390         }
3391         else if (!strcmp(arg, "--no-renames"))
3392                 options->detect_rename = 0;
3393         else if (!strcmp(arg, "--relative"))
3394                 DIFF_OPT_SET(options, RELATIVE_NAME);
3395         else if (!prefixcmp(arg, "--relative=")) {
3396                 DIFF_OPT_SET(options, RELATIVE_NAME);
3397                 options->prefix = arg + 11;
3398         }
3400         /* xdiff options */
3401         else if (!strcmp(arg, "--minimal"))
3402                 DIFF_XDL_SET(options, NEED_MINIMAL);
3403         else if (!strcmp(arg, "--no-minimal"))
3404                 DIFF_XDL_CLR(options, NEED_MINIMAL);
3405         else if (!strcmp(arg, "-w") || !strcmp(arg, "--ignore-all-space"))
3406                 DIFF_XDL_SET(options, IGNORE_WHITESPACE);
3407         else if (!strcmp(arg, "-b") || !strcmp(arg, "--ignore-space-change"))
3408                 DIFF_XDL_SET(options, IGNORE_WHITESPACE_CHANGE);
3409         else if (!strcmp(arg, "--ignore-space-at-eol"))
3410                 DIFF_XDL_SET(options, IGNORE_WHITESPACE_AT_EOL);
3411         else if (!strcmp(arg, "--patience"))
3412                 DIFF_XDL_SET(options, PATIENCE_DIFF);
3413         else if (!strcmp(arg, "--histogram"))
3414                 DIFF_XDL_SET(options, HISTOGRAM_DIFF);
3416         /* flags options */
3417         else if (!strcmp(arg, "--binary")) {
3418                 options->output_format |= DIFF_FORMAT_PATCH;
3419                 DIFF_OPT_SET(options, BINARY);
3420         }
3421         else if (!strcmp(arg, "--full-index"))
3422                 DIFF_OPT_SET(options, FULL_INDEX);
3423         else if (!strcmp(arg, "-a") || !strcmp(arg, "--text"))
3424                 DIFF_OPT_SET(options, TEXT);
3425         else if (!strcmp(arg, "-R"))
3426                 DIFF_OPT_SET(options, REVERSE_DIFF);
3427         else if (!strcmp(arg, "--find-copies-harder"))
3428                 DIFF_OPT_SET(options, FIND_COPIES_HARDER);
3429         else if (!strcmp(arg, "--follow"))
3430                 DIFF_OPT_SET(options, FOLLOW_RENAMES);
3431         else if (!strcmp(arg, "--color"))
3432                 options->use_color = 1;
3433         else if (!prefixcmp(arg, "--color=")) {
3434                 int value = git_config_colorbool(NULL, arg+8);
3435                 if (value < 0)
3436                         return error("option `color' expects \"always\", \"auto\", or \"never\"");
3437                 options->use_color = value;
3438         }
3439         else if (!strcmp(arg, "--no-color"))
3440                 options->use_color = 0;
3441         else if (!strcmp(arg, "--color-words")) {
3442                 options->use_color = 1;
3443                 options->word_diff = DIFF_WORDS_COLOR;
3444         }
3445         else if (!prefixcmp(arg, "--color-words=")) {
3446                 options->use_color = 1;
3447                 options->word_diff = DIFF_WORDS_COLOR;
3448                 options->word_regex = arg + 14;
3449         }
3450         else if (!strcmp(arg, "--word-diff")) {
3451                 if (options->word_diff == DIFF_WORDS_NONE)
3452                         options->word_diff = DIFF_WORDS_PLAIN;
3453         }
3454         else if (!prefixcmp(arg, "--word-diff=")) {
3455                 const char *type = arg + 12;
3456                 if (!strcmp(type, "plain"))
3457                         options->word_diff = DIFF_WORDS_PLAIN;
3458                 else if (!strcmp(type, "color")) {
3459                         options->use_color = 1;
3460                         options->word_diff = DIFF_WORDS_COLOR;
3461                 }
3462                 else if (!strcmp(type, "porcelain"))
3463                         options->word_diff = DIFF_WORDS_PORCELAIN;
3464                 else if (!strcmp(type, "none"))
3465                         options->word_diff = DIFF_WORDS_NONE;
3466                 else
3467                         die("bad --word-diff argument: %s", type);
3468         }
3469         else if ((argcount = parse_long_opt("word-diff-regex", av, &optarg))) {
3470                 if (options->word_diff == DIFF_WORDS_NONE)
3471                         options->word_diff = DIFF_WORDS_PLAIN;
3472                 options->word_regex = optarg;
3473                 return argcount;
3474         }
3475         else if (!strcmp(arg, "--exit-code"))
3476                 DIFF_OPT_SET(options, EXIT_WITH_STATUS);
3477         else if (!strcmp(arg, "--quiet"))
3478                 DIFF_OPT_SET(options, QUICK);
3479         else if (!strcmp(arg, "--ext-diff"))
3480                 DIFF_OPT_SET(options, ALLOW_EXTERNAL);
3481         else if (!strcmp(arg, "--no-ext-diff"))
3482                 DIFF_OPT_CLR(options, ALLOW_EXTERNAL);
3483         else if (!strcmp(arg, "--textconv"))
3484                 DIFF_OPT_SET(options, ALLOW_TEXTCONV);
3485         else if (!strcmp(arg, "--no-textconv"))
3486                 DIFF_OPT_CLR(options, ALLOW_TEXTCONV);
3487         else if (!strcmp(arg, "--ignore-submodules")) {
3488                 DIFF_OPT_SET(options, OVERRIDE_SUBMODULE_CONFIG);
3489                 handle_ignore_submodules_arg(options, "all");
3490         } else if (!prefixcmp(arg, "--ignore-submodules=")) {
3491                 DIFF_OPT_SET(options, OVERRIDE_SUBMODULE_CONFIG);
3492                 handle_ignore_submodules_arg(options, arg + 20);
3493         } else if (!strcmp(arg, "--submodule"))
3494                 DIFF_OPT_SET(options, SUBMODULE_LOG);
3495         else if (!prefixcmp(arg, "--submodule=")) {
3496                 if (!strcmp(arg + 12, "log"))
3497                         DIFF_OPT_SET(options, SUBMODULE_LOG);
3498         }
3500         /* misc options */
3501         else if (!strcmp(arg, "-z"))
3502                 options->line_termination = 0;
3503         else if ((argcount = short_opt('l', av, &optarg))) {
3504                 options->rename_limit = strtoul(optarg, NULL, 10);
3505                 return argcount;
3506         }
3507         else if ((argcount = short_opt('S', av, &optarg))) {
3508                 options->pickaxe = optarg;
3509                 options->pickaxe_opts |= DIFF_PICKAXE_KIND_S;
3510                 return argcount;
3511         } else if ((argcount = short_opt('G', av, &optarg))) {
3512                 options->pickaxe = optarg;
3513                 options->pickaxe_opts |= DIFF_PICKAXE_KIND_G;
3514                 return argcount;
3515         }
3516         else if (!strcmp(arg, "--pickaxe-all"))
3517                 options->pickaxe_opts |= DIFF_PICKAXE_ALL;
3518         else if (!strcmp(arg, "--pickaxe-regex"))
3519                 options->pickaxe_opts |= DIFF_PICKAXE_REGEX;
3520         else if ((argcount = short_opt('O', av, &optarg))) {
3521                 options->orderfile = optarg;
3522                 return argcount;
3523         }
3524         else if ((argcount = parse_long_opt("diff-filter", av, &optarg))) {
3525                 options->filter = optarg;
3526                 return argcount;
3527         }
3528         else if (!strcmp(arg, "--abbrev"))
3529                 options->abbrev = DEFAULT_ABBREV;
3530         else if (!prefixcmp(arg, "--abbrev=")) {
3531                 options->abbrev = strtoul(arg + 9, NULL, 10);
3532                 if (options->abbrev < MINIMUM_ABBREV)
3533                         options->abbrev = MINIMUM_ABBREV;
3534                 else if (40 < options->abbrev)
3535                         options->abbrev = 40;
3536         }
3537         else if ((argcount = parse_long_opt("src-prefix", av, &optarg))) {
3538                 options->a_prefix = optarg;
3539                 return argcount;
3540         }
3541         else if ((argcount = parse_long_opt("dst-prefix", av, &optarg))) {
3542                 options->b_prefix = optarg;
3543                 return argcount;
3544         }
3545         else if (!strcmp(arg, "--no-prefix"))
3546                 options->a_prefix = options->b_prefix = "";
3547         else if (opt_arg(arg, '\0', "inter-hunk-context",
3548                          &options->interhunkcontext))
3549                 ;
3550         else if (!strcmp(arg, "-W"))
3551                 DIFF_OPT_SET(options, FUNCCONTEXT);
3552         else if (!strcmp(arg, "--function-context"))
3553                 DIFF_OPT_SET(options, FUNCCONTEXT);
3554         else if (!strcmp(arg, "--no-function-context"))
3555                 DIFF_OPT_CLR(options, FUNCCONTEXT);
3556         else if ((argcount = parse_long_opt("output", av, &optarg))) {
3557                 options->file = fopen(optarg, "w");
3558                 if (!options->file)
3559                         die_errno("Could not open '%s'", optarg);
3560                 options->close_file = 1;
3561                 return argcount;
3562         } else
3563                 return 0;
3564         return 1;
3567 int parse_rename_score(const char **cp_p)
3569         unsigned long num, scale;
3570         int ch, dot;
3571         const char *cp = *cp_p;
3573         num = 0;
3574         scale = 1;
3575         dot = 0;
3576         for (;;) {
3577                 ch = *cp;
3578                 if ( !dot && ch == '.' ) {
3579                         scale = 1;
3580                         dot = 1;
3581                 } else if ( ch == '%' ) {
3582                         scale = dot ? scale*100 : 100;
3583                         cp++;   /* % is always at the end */
3584                         break;
3585                 } else if ( ch >= '0' && ch <= '9' ) {
3586                         if ( scale < 100000 ) {
3587                                 scale *= 10;
3588                                 num = (num*10) + (ch-'0');
3589                         }
3590                 } else {
3591                         break;
3592                 }
3593                 cp++;
3594         }
3595         *cp_p = cp;
3597         /* user says num divided by scale and we say internally that
3598          * is MAX_SCORE * num / scale.
3599          */
3600         return (int)((num >= scale) ? MAX_SCORE : (MAX_SCORE * num / scale));
3603 static int diff_scoreopt_parse(const char *opt)
3605         int opt1, opt2, cmd;
3607         if (*opt++ != '-')
3608                 return -1;
3609         cmd = *opt++;
3610         if (cmd == '-') {
3611                 /* convert the long-form arguments into short-form versions */
3612                 if (!prefixcmp(opt, "break-rewrites")) {
3613                         opt += strlen("break-rewrites");
3614                         if (*opt == 0 || *opt++ == '=')
3615                                 cmd = 'B';
3616                 } else if (!prefixcmp(opt, "find-copies")) {
3617                         opt += strlen("find-copies");
3618                         if (*opt == 0 || *opt++ == '=')
3619                                 cmd = 'C';
3620                 } else if (!prefixcmp(opt, "find-renames")) {
3621                         opt += strlen("find-renames");
3622                         if (*opt == 0 || *opt++ == '=')
3623                                 cmd = 'M';
3624                 }
3625         }
3626         if (cmd != 'M' && cmd != 'C' && cmd != 'B')
3627                 return -1; /* that is not a -M, -C nor -B option */
3629         opt1 = parse_rename_score(&opt);
3630         if (cmd != 'B')
3631                 opt2 = 0;
3632         else {
3633                 if (*opt == 0)
3634                         opt2 = 0;
3635                 else if (*opt != '/')
3636                         return -1; /* we expect -B80/99 or -B80 */
3637                 else {
3638                         opt++;
3639                         opt2 = parse_rename_score(&opt);
3640                 }
3641         }
3642         if (*opt != 0)
3643                 return -1;
3644         return opt1 | (opt2 << 16);
3647 struct diff_queue_struct diff_queued_diff;
3649 void diff_q(struct diff_queue_struct *queue, struct diff_filepair *dp)
3651         if (queue->alloc <= queue->nr) {
3652                 queue->alloc = alloc_nr(queue->alloc);
3653                 queue->queue = xrealloc(queue->queue,
3654                                         sizeof(dp) * queue->alloc);
3655         }
3656         queue->queue[queue->nr++] = dp;
3659 struct diff_filepair *diff_queue(struct diff_queue_struct *queue,
3660                                  struct diff_filespec *one,
3661                                  struct diff_filespec *two)
3663         struct diff_filepair *dp = xcalloc(1, sizeof(*dp));
3664         dp->one = one;
3665         dp->two = two;
3666         if (queue)
3667                 diff_q(queue, dp);
3668         return dp;
3671 void diff_free_filepair(struct diff_filepair *p)
3673         free_filespec(p->one);
3674         free_filespec(p->two);
3675         free(p);
3678 /* This is different from find_unique_abbrev() in that
3679  * it stuffs the result with dots for alignment.
3680  */
3681 const char *diff_unique_abbrev(const unsigned char *sha1, int len)
3683         int abblen;
3684         const char *abbrev;
3685         if (len == 40)
3686                 return sha1_to_hex(sha1);
3688         abbrev = find_unique_abbrev(sha1, len);
3689         abblen = strlen(abbrev);
3690         if (abblen < 37) {
3691                 static char hex[41];
3692                 if (len < abblen && abblen <= len + 2)
3693                         sprintf(hex, "%s%.*s", abbrev, len+3-abblen, "..");
3694                 else
3695                         sprintf(hex, "%s...", abbrev);
3696                 return hex;
3697         }
3698         return sha1_to_hex(sha1);
3701 static void diff_flush_raw(struct diff_filepair *p, struct diff_options *opt)
3703         int line_termination = opt->line_termination;
3704         int inter_name_termination = line_termination ? '\t' : '\0';
3705         if (opt->output_prefix) {
3706                 struct strbuf *msg = NULL;
3707                 msg = opt->output_prefix(opt, opt->output_prefix_data);
3708                 fprintf(opt->file, "%s", msg->buf);
3709         }
3711         if (!(opt->output_format & DIFF_FORMAT_NAME_STATUS)) {
3712                 fprintf(opt->file, ":%06o %06o %s ", p->one->mode, p->two->mode,
3713                         diff_unique_abbrev(p->one->sha1, opt->abbrev));
3714                 fprintf(opt->file, "%s ", diff_unique_abbrev(p->two->sha1, opt->abbrev));
3715         }
3716         if (p->score) {
3717                 fprintf(opt->file, "%c%03d%c", p->status, similarity_index(p),
3718                         inter_name_termination);
3719         } else {
3720                 fprintf(opt->file, "%c%c", p->status, inter_name_termination);
3721         }
3723         if (p->status == DIFF_STATUS_COPIED ||
3724             p->status == DIFF_STATUS_RENAMED) {
3725                 const char *name_a, *name_b;
3726                 name_a = p->one->path;
3727                 name_b = p->two->path;
3728                 strip_prefix(opt->prefix_length, &name_a, &name_b);
3729                 write_name_quoted(name_a, opt->file, inter_name_termination);
3730                 write_name_quoted(name_b, opt->file, line_termination);
3731         } else {
3732                 const char *name_a, *name_b;
3733                 name_a = p->one->mode ? p->one->path : p->two->path;
3734                 name_b = NULL;
3735                 strip_prefix(opt->prefix_length, &name_a, &name_b);
3736                 write_name_quoted(name_a, opt->file, line_termination);
3737         }
3740 int diff_unmodified_pair(struct diff_filepair *p)
3742         /* This function is written stricter than necessary to support
3743          * the currently implemented transformers, but the idea is to
3744          * let transformers to produce diff_filepairs any way they want,
3745          * and filter and clean them up here before producing the output.
3746          */
3747         struct diff_filespec *one = p->one, *two = p->two;
3749         if (DIFF_PAIR_UNMERGED(p))
3750                 return 0; /* unmerged is interesting */
3752         /* deletion, addition, mode or type change
3753          * and rename are all interesting.
3754          */
3755         if (DIFF_FILE_VALID(one) != DIFF_FILE_VALID(two) ||
3756             DIFF_PAIR_MODE_CHANGED(p) ||
3757             strcmp(one->path, two->path))
3758                 return 0;
3760         /* both are valid and point at the same path.  that is, we are
3761          * dealing with a change.
3762          */
3763         if (one->sha1_valid && two->sha1_valid &&
3764             !hashcmp(one->sha1, two->sha1) &&
3765             !one->dirty_submodule && !two->dirty_submodule)
3766                 return 1; /* no change */
3767         if (!one->sha1_valid && !two->sha1_valid)
3768                 return 1; /* both look at the same file on the filesystem. */
3769         return 0;
3772 static void diff_flush_patch(struct diff_filepair *p, struct diff_options *o)
3774         if (diff_unmodified_pair(p))
3775                 return;
3777         if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) ||
3778             (DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
3779                 return; /* no tree diffs in patch format */
3781         run_diff(p, o);
3784 static void diff_flush_stat(struct diff_filepair *p, struct diff_options *o,
3785                             struct diffstat_t *diffstat)
3787         if (diff_unmodified_pair(p))
3788                 return;
3790         if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) ||
3791             (DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
3792                 return; /* no useful stat for tree diffs */
3794         run_diffstat(p, o, diffstat);
3797 static void diff_flush_checkdiff(struct diff_filepair *p,
3798                 struct diff_options *o)
3800         if (diff_unmodified_pair(p))
3801                 return;
3803         if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) ||
3804             (DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
3805                 return; /* nothing to check in tree diffs */
3807         run_checkdiff(p, o);
3810 int diff_queue_is_empty(void)
3812         struct diff_queue_struct *q = &diff_queued_diff;
3813         int i;
3814         for (i = 0; i < q->nr; i++)
3815                 if (!diff_unmodified_pair(q->queue[i]))
3816                         return 0;
3817         return 1;
3820 #if DIFF_DEBUG
3821 void diff_debug_filespec(struct diff_filespec *s, int x, const char *one)
3823         fprintf(stderr, "queue[%d] %s (%s) %s %06o %s\n",
3824                 x, one ? one : "",
3825                 s->path,
3826                 DIFF_FILE_VALID(s) ? "valid" : "invalid",
3827                 s->mode,
3828                 s->sha1_valid ? sha1_to_hex(s->sha1) : "");
3829         fprintf(stderr, "queue[%d] %s size %lu flags %d\n",
3830                 x, one ? one : "",
3831                 s->size, s->xfrm_flags);
3834 void diff_debug_filepair(const struct diff_filepair *p, int i)
3836         diff_debug_filespec(p->one, i, "one");
3837         diff_debug_filespec(p->two, i, "two");
3838         fprintf(stderr, "score %d, status %c rename_used %d broken %d\n",
3839                 p->score, p->status ? p->status : '?',
3840                 p->one->rename_used, p->broken_pair);
3843 void diff_debug_queue(const char *msg, struct diff_queue_struct *q)
3845         int i;
3846         if (msg)
3847                 fprintf(stderr, "%s\n", msg);
3848         fprintf(stderr, "q->nr = %d\n", q->nr);
3849         for (i = 0; i < q->nr; i++) {
3850                 struct diff_filepair *p = q->queue[i];
3851                 diff_debug_filepair(p, i);
3852         }
3854 #endif
3856 static void diff_resolve_rename_copy(void)
3858         int i;
3859         struct diff_filepair *p;
3860         struct diff_queue_struct *q = &diff_queued_diff;
3862         diff_debug_queue("resolve-rename-copy", q);
3864         for (i = 0; i < q->nr; i++) {
3865                 p = q->queue[i];
3866                 p->status = 0; /* undecided */
3867                 if (DIFF_PAIR_UNMERGED(p))
3868                         p->status = DIFF_STATUS_UNMERGED;
3869                 else if (!DIFF_FILE_VALID(p->one))
3870                         p->status = DIFF_STATUS_ADDED;
3871                 else if (!DIFF_FILE_VALID(p->two))
3872                         p->status = DIFF_STATUS_DELETED;
3873                 else if (DIFF_PAIR_TYPE_CHANGED(p))
3874                         p->status = DIFF_STATUS_TYPE_CHANGED;
3876                 /* from this point on, we are dealing with a pair
3877                  * whose both sides are valid and of the same type, i.e.
3878                  * either in-place edit or rename/copy edit.
3879                  */
3880                 else if (DIFF_PAIR_RENAME(p)) {
3881                         /*
3882                          * A rename might have re-connected a broken
3883                          * pair up, causing the pathnames to be the
3884                          * same again. If so, that's not a rename at
3885                          * all, just a modification..
3886                          *
3887                          * Otherwise, see if this source was used for
3888                          * multiple renames, in which case we decrement
3889                          * the count, and call it a copy.
3890                          */
3891                         if (!strcmp(p->one->path, p->two->path))
3892                                 p->status = DIFF_STATUS_MODIFIED;
3893                         else if (--p->one->rename_used > 0)
3894                                 p->status = DIFF_STATUS_COPIED;
3895                         else
3896                                 p->status = DIFF_STATUS_RENAMED;
3897                 }
3898                 else if (hashcmp(p->one->sha1, p->two->sha1) ||
3899                          p->one->mode != p->two->mode ||
3900                          p->one->dirty_submodule ||
3901                          p->two->dirty_submodule ||
3902                          is_null_sha1(p->one->sha1))
3903                         p->status = DIFF_STATUS_MODIFIED;
3904                 else {
3905                         /* This is a "no-change" entry and should not
3906                          * happen anymore, but prepare for broken callers.
3907                          */
3908                         error("feeding unmodified %s to diffcore",
3909                               p->one->path);
3910                         p->status = DIFF_STATUS_UNKNOWN;
3911                 }
3912         }
3913         diff_debug_queue("resolve-rename-copy done", q);
3916 static int check_pair_status(struct diff_filepair *p)
3918         switch (p->status) {
3919         case DIFF_STATUS_UNKNOWN:
3920                 return 0;
3921         case 0:
3922                 die("internal error in diff-resolve-rename-copy");
3923         default:
3924                 return 1;
3925         }
3928 static void flush_one_pair(struct diff_filepair *p, struct diff_options *opt)
3930         int fmt = opt->output_format;
3932         if (fmt & DIFF_FORMAT_CHECKDIFF)
3933                 diff_flush_checkdiff(p, opt);
3934         else if (fmt & (DIFF_FORMAT_RAW | DIFF_FORMAT_NAME_STATUS))
3935                 diff_flush_raw(p, opt);
3936         else if (fmt & DIFF_FORMAT_NAME) {
3937                 const char *name_a, *name_b;
3938                 name_a = p->two->path;
3939                 name_b = NULL;
3940                 strip_prefix(opt->prefix_length, &name_a, &name_b);
3941                 write_name_quoted(name_a, opt->file, opt->line_termination);
3942         }
3945 static void show_file_mode_name(FILE *file, const char *newdelete, struct diff_filespec *fs)
3947         if (fs->mode)
3948                 fprintf(file, " %s mode %06o ", newdelete, fs->mode);
3949         else
3950                 fprintf(file, " %s ", newdelete);
3951         write_name_quoted(fs->path, file, '\n');
3955 static void show_mode_change(FILE *file, struct diff_filepair *p, int show_name,
3956                 const char *line_prefix)
3958         if (p->one->mode && p->two->mode && p->one->mode != p->two->mode) {
3959                 fprintf(file, "%s mode change %06o => %06o%c", line_prefix, p->one->mode,
3960                         p->two->mode, show_name ? ' ' : '\n');
3961                 if (show_name) {
3962                         write_name_quoted(p->two->path, file, '\n');
3963                 }
3964         }
3967 static void show_rename_copy(FILE *file, const char *renamecopy, struct diff_filepair *p,
3968                         const char *line_prefix)
3970         char *names = pprint_rename(p->one->path, p->two->path);
3972         fprintf(file, " %s %s (%d%%)\n", renamecopy, names, similarity_index(p));
3973         free(names);
3974         show_mode_change(file, p, 0, line_prefix);
3977 static void diff_summary(struct diff_options *opt, struct diff_filepair *p)
3979         FILE *file = opt->file;
3980         char *line_prefix = "";
3982         if (opt->output_prefix) {
3983                 struct strbuf *buf = opt->output_prefix(opt, opt->output_prefix_data);
3984                 line_prefix = buf->buf;
3985         }
3987         switch(p->status) {
3988         case DIFF_STATUS_DELETED:
3989                 fputs(line_prefix, file);
3990                 show_file_mode_name(file, "delete", p->one);
3991                 break;
3992         case DIFF_STATUS_ADDED:
3993                 fputs(line_prefix, file);
3994                 show_file_mode_name(file, "create", p->two);
3995                 break;
3996         case DIFF_STATUS_COPIED:
3997                 fputs(line_prefix, file);
3998                 show_rename_copy(file, "copy", p, line_prefix);
3999                 break;
4000         case DIFF_STATUS_RENAMED:
4001                 fputs(line_prefix, file);
4002                 show_rename_copy(file, "rename", p, line_prefix);
4003                 break;
4004         default:
4005                 if (p->score) {
4006                         fprintf(file, "%s rewrite ", line_prefix);
4007                         write_name_quoted(p->two->path, file, ' ');
4008                         fprintf(file, "(%d%%)\n", similarity_index(p));
4009                 }
4010                 show_mode_change(file, p, !p->score, line_prefix);
4011                 break;
4012         }
4015 struct patch_id_t {
4016         git_SHA_CTX *ctx;
4017         int patchlen;
4018 };
4020 static int remove_space(char *line, int len)
4022         int i;
4023         char *dst = line;
4024         unsigned char c;
4026         for (i = 0; i < len; i++)
4027                 if (!isspace((c = line[i])))
4028                         *dst++ = c;
4030         return dst - line;
4033 static void patch_id_consume(void *priv, char *line, unsigned long len)
4035         struct patch_id_t *data = priv;
4036         int new_len;
4038         /* Ignore line numbers when computing the SHA1 of the patch */
4039         if (!prefixcmp(line, "@@ -"))
4040                 return;
4042         new_len = remove_space(line, len);
4044         git_SHA1_Update(data->ctx, line, new_len);
4045         data->patchlen += new_len;
4048 /* returns 0 upon success, and writes result into sha1 */
4049 static int diff_get_patch_id(struct diff_options *options, unsigned char *sha1)
4051         struct diff_queue_struct *q = &diff_queued_diff;
4052         int i;
4053         git_SHA_CTX ctx;
4054         struct patch_id_t data;
4055         char buffer[PATH_MAX * 4 + 20];
4057         git_SHA1_Init(&ctx);
4058         memset(&data, 0, sizeof(struct patch_id_t));
4059         data.ctx = &ctx;
4061         for (i = 0; i < q->nr; i++) {
4062                 xpparam_t xpp;
4063                 xdemitconf_t xecfg;
4064                 mmfile_t mf1, mf2;
4065                 struct diff_filepair *p = q->queue[i];
4066                 int len1, len2;
4068                 memset(&xpp, 0, sizeof(xpp));
4069                 memset(&xecfg, 0, sizeof(xecfg));
4070                 if (p->status == 0)
4071                         return error("internal diff status error");
4072                 if (p->status == DIFF_STATUS_UNKNOWN)
4073                         continue;
4074                 if (diff_unmodified_pair(p))
4075                         continue;
4076                 if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) ||
4077                     (DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
4078                         continue;
4079                 if (DIFF_PAIR_UNMERGED(p))
4080                         continue;
4082                 diff_fill_sha1_info(p->one);
4083                 diff_fill_sha1_info(p->two);
4084                 if (fill_mmfile(&mf1, p->one) < 0 ||
4085                                 fill_mmfile(&mf2, p->two) < 0)
4086                         return error("unable to read files to diff");
4088                 len1 = remove_space(p->one->path, strlen(p->one->path));
4089                 len2 = remove_space(p->two->path, strlen(p->two->path));
4090                 if (p->one->mode == 0)
4091                         len1 = snprintf(buffer, sizeof(buffer),
4092                                         "diff--gita/%.*sb/%.*s"
4093                                         "newfilemode%06o"
4094                                         "---/dev/null"
4095                                         "+++b/%.*s",
4096                                         len1, p->one->path,
4097                                         len2, p->two->path,
4098                                         p->two->mode,
4099                                         len2, p->two->path);
4100                 else if (p->two->mode == 0)
4101                         len1 = snprintf(buffer, sizeof(buffer),
4102                                         "diff--gita/%.*sb/%.*s"
4103                                         "deletedfilemode%06o"
4104                                         "---a/%.*s"
4105                                         "+++/dev/null",
4106                                         len1, p->one->path,
4107                                         len2, p->two->path,
4108                                         p->one->mode,
4109                                         len1, p->one->path);
4110                 else
4111                         len1 = snprintf(buffer, sizeof(buffer),
4112                                         "diff--gita/%.*sb/%.*s"
4113                                         "---a/%.*s"
4114                                         "+++b/%.*s",
4115                                         len1, p->one->path,
4116                                         len2, p->two->path,
4117                                         len1, p->one->path,
4118                                         len2, p->two->path);
4119                 git_SHA1_Update(&ctx, buffer, len1);
4121                 if (diff_filespec_is_binary(p->one) ||
4122                     diff_filespec_is_binary(p->two)) {
4123                         git_SHA1_Update(&ctx, sha1_to_hex(p->one->sha1), 40);
4124                         git_SHA1_Update(&ctx, sha1_to_hex(p->two->sha1), 40);
4125                         continue;
4126                 }
4128                 xpp.flags = 0;
4129                 xecfg.ctxlen = 3;
4130                 xecfg.flags = 0;
4131                 xdi_diff_outf(&mf1, &mf2, patch_id_consume, &data,
4132                               &xpp, &xecfg);
4133         }
4135         git_SHA1_Final(sha1, &ctx);
4136         return 0;
4139 int diff_flush_patch_id(struct diff_options *options, unsigned char *sha1)
4141         struct diff_queue_struct *q = &diff_queued_diff;
4142         int i;
4143         int result = diff_get_patch_id(options, sha1);
4145         for (i = 0; i < q->nr; i++)
4146                 diff_free_filepair(q->queue[i]);
4148         free(q->queue);
4149         DIFF_QUEUE_CLEAR(q);
4151         return result;
4154 static int is_summary_empty(const struct diff_queue_struct *q)
4156         int i;
4158         for (i = 0; i < q->nr; i++) {
4159                 const struct diff_filepair *p = q->queue[i];
4161                 switch (p->status) {
4162                 case DIFF_STATUS_DELETED:
4163                 case DIFF_STATUS_ADDED:
4164                 case DIFF_STATUS_COPIED:
4165                 case DIFF_STATUS_RENAMED:
4166                         return 0;
4167                 default:
4168                         if (p->score)
4169                                 return 0;
4170                         if (p->one->mode && p->two->mode &&
4171                             p->one->mode != p->two->mode)
4172                                 return 0;
4173                         break;
4174                 }
4175         }
4176         return 1;
4179 static const char rename_limit_warning[] =
4180 "inexact rename detection was skipped due to too many files.";
4182 static const char degrade_cc_to_c_warning[] =
4183 "only found copies from modified paths due to too many files.";
4185 static const char rename_limit_advice[] =
4186 "you may want to set your %s variable to at least "
4187 "%d and retry the command.";
4189 void diff_warn_rename_limit(const char *varname, int needed, int degraded_cc)
4191         if (degraded_cc)
4192                 warning(degrade_cc_to_c_warning);
4193         else if (needed)
4194                 warning(rename_limit_warning);
4195         else
4196                 return;
4197         if (0 < needed && needed < 32767)
4198                 warning(rename_limit_advice, varname, needed);
4201 void diff_flush(struct diff_options *options)
4203         struct diff_queue_struct *q = &diff_queued_diff;
4204         int i, output_format = options->output_format;
4205         int separator = 0;
4206         int dirstat_by_line = 0;
4208         /*
4209          * Order: raw, stat, summary, patch
4210          * or:    name/name-status/checkdiff (other bits clear)
4211          */
4212         if (!q->nr)
4213                 goto free_queue;
4215         if (output_format & (DIFF_FORMAT_RAW |
4216                              DIFF_FORMAT_NAME |
4217                              DIFF_FORMAT_NAME_STATUS |
4218                              DIFF_FORMAT_CHECKDIFF)) {
4219                 for (i = 0; i < q->nr; i++) {
4220                         struct diff_filepair *p = q->queue[i];
4221                         if (check_pair_status(p))
4222                                 flush_one_pair(p, options);
4223                 }
4224                 separator++;
4225         }
4227         if (output_format & DIFF_FORMAT_DIRSTAT && DIFF_OPT_TST(options, DIRSTAT_BY_LINE))
4228                 dirstat_by_line = 1;
4230         if (output_format & (DIFF_FORMAT_DIFFSTAT|DIFF_FORMAT_SHORTSTAT|DIFF_FORMAT_NUMSTAT) ||
4231             dirstat_by_line) {
4232                 struct diffstat_t diffstat;
4234                 memset(&diffstat, 0, sizeof(struct diffstat_t));
4235                 for (i = 0; i < q->nr; i++) {
4236                         struct diff_filepair *p = q->queue[i];
4237                         if (check_pair_status(p))
4238                                 diff_flush_stat(p, options, &diffstat);
4239                 }
4240                 if (output_format & DIFF_FORMAT_NUMSTAT)
4241                         show_numstat(&diffstat, options);
4242                 if (output_format & DIFF_FORMAT_DIFFSTAT)
4243                         show_stats(&diffstat, options);
4244                 if (output_format & DIFF_FORMAT_SHORTSTAT)
4245                         show_shortstats(&diffstat, options);
4246                 if (output_format & DIFF_FORMAT_DIRSTAT)
4247                         show_dirstat_by_line(&diffstat, options);
4248                 free_diffstat_info(&diffstat);
4249                 separator++;
4250         }
4251         if ((output_format & DIFF_FORMAT_DIRSTAT) && !dirstat_by_line)
4252                 show_dirstat(options);
4254         if (output_format & DIFF_FORMAT_SUMMARY && !is_summary_empty(q)) {
4255                 for (i = 0; i < q->nr; i++) {
4256                         diff_summary(options, q->queue[i]);
4257                 }
4258                 separator++;
4259         }
4261         if (output_format & DIFF_FORMAT_NO_OUTPUT &&
4262             DIFF_OPT_TST(options, EXIT_WITH_STATUS) &&
4263             DIFF_OPT_TST(options, DIFF_FROM_CONTENTS)) {
4264                 /*
4265                  * run diff_flush_patch for the exit status. setting
4266                  * options->file to /dev/null should be safe, becaue we
4267                  * aren't supposed to produce any output anyway.
4268                  */
4269                 if (options->close_file)
4270                         fclose(options->file);
4271                 options->file = fopen("/dev/null", "w");
4272                 if (!options->file)
4273                         die_errno("Could not open /dev/null");
4274                 options->close_file = 1;
4275                 for (i = 0; i < q->nr; i++) {
4276                         struct diff_filepair *p = q->queue[i];
4277                         if (check_pair_status(p))
4278                                 diff_flush_patch(p, options);
4279                         if (options->found_changes)
4280                                 break;
4281                 }
4282         }
4284         if (output_format & DIFF_FORMAT_PATCH) {
4285                 if (separator) {
4286                         putc(options->line_termination, options->file);
4287                         if (options->stat_sep) {
4288                                 /* attach patch instead of inline */
4289                                 fputs(options->stat_sep, options->file);
4290                         }
4291                 }
4293                 for (i = 0; i < q->nr; i++) {
4294                         struct diff_filepair *p = q->queue[i];
4295                         if (check_pair_status(p))
4296                                 diff_flush_patch(p, options);
4297                 }
4298         }
4300         if (output_format & DIFF_FORMAT_CALLBACK)
4301                 options->format_callback(q, options, options->format_callback_data);
4303         for (i = 0; i < q->nr; i++)
4304                 diff_free_filepair(q->queue[i]);
4305 free_queue:
4306         free(q->queue);
4307         DIFF_QUEUE_CLEAR(q);
4308         if (options->close_file)
4309                 fclose(options->file);
4311         /*
4312          * Report the content-level differences with HAS_CHANGES;
4313          * diff_addremove/diff_change does not set the bit when
4314          * DIFF_FROM_CONTENTS is in effect (e.g. with -w).
4315          */
4316         if (DIFF_OPT_TST(options, DIFF_FROM_CONTENTS)) {
4317                 if (options->found_changes)
4318                         DIFF_OPT_SET(options, HAS_CHANGES);
4319                 else
4320                         DIFF_OPT_CLR(options, HAS_CHANGES);
4321         }
4324 static void diffcore_apply_filter(const char *filter)
4326         int i;
4327         struct diff_queue_struct *q = &diff_queued_diff;
4328         struct diff_queue_struct outq;
4329         DIFF_QUEUE_CLEAR(&outq);
4331         if (!filter)
4332                 return;
4334         if (strchr(filter, DIFF_STATUS_FILTER_AON)) {
4335                 int found;
4336                 for (i = found = 0; !found && i < q->nr; i++) {
4337                         struct diff_filepair *p = q->queue[i];
4338                         if (((p->status == DIFF_STATUS_MODIFIED) &&
4339                              ((p->score &&
4340                                strchr(filter, DIFF_STATUS_FILTER_BROKEN)) ||
4341                               (!p->score &&
4342                                strchr(filter, DIFF_STATUS_MODIFIED)))) ||
4343                             ((p->status != DIFF_STATUS_MODIFIED) &&
4344                              strchr(filter, p->status)))
4345                                 found++;
4346                 }
4347                 if (found)
4348                         return;
4350                 /* otherwise we will clear the whole queue
4351                  * by copying the empty outq at the end of this
4352                  * function, but first clear the current entries
4353                  * in the queue.
4354                  */
4355                 for (i = 0; i < q->nr; i++)
4356                         diff_free_filepair(q->queue[i]);
4357         }
4358         else {
4359                 /* Only the matching ones */
4360                 for (i = 0; i < q->nr; i++) {
4361                         struct diff_filepair *p = q->queue[i];
4363                         if (((p->status == DIFF_STATUS_MODIFIED) &&
4364                              ((p->score &&
4365                                strchr(filter, DIFF_STATUS_FILTER_BROKEN)) ||
4366                               (!p->score &&
4367                                strchr(filter, DIFF_STATUS_MODIFIED)))) ||
4368                             ((p->status != DIFF_STATUS_MODIFIED) &&
4369                              strchr(filter, p->status)))
4370                                 diff_q(&outq, p);
4371                         else
4372                                 diff_free_filepair(p);
4373                 }
4374         }
4375         free(q->queue);
4376         *q = outq;
4379 /* Check whether two filespecs with the same mode and size are identical */
4380 static int diff_filespec_is_identical(struct diff_filespec *one,
4381                                       struct diff_filespec *two)
4383         if (S_ISGITLINK(one->mode))
4384                 return 0;
4385         if (diff_populate_filespec(one, 0))
4386                 return 0;
4387         if (diff_populate_filespec(two, 0))
4388                 return 0;
4389         return !memcmp(one->data, two->data, one->size);
4392 static void diffcore_skip_stat_unmatch(struct diff_options *diffopt)
4394         int i;
4395         struct diff_queue_struct *q = &diff_queued_diff;
4396         struct diff_queue_struct outq;
4397         DIFF_QUEUE_CLEAR(&outq);
4399         for (i = 0; i < q->nr; i++) {
4400                 struct diff_filepair *p = q->queue[i];
4402                 /*
4403                  * 1. Entries that come from stat info dirtiness
4404                  *    always have both sides (iow, not create/delete),
4405                  *    one side of the object name is unknown, with
4406                  *    the same mode and size.  Keep the ones that
4407                  *    do not match these criteria.  They have real
4408                  *    differences.
4409                  *
4410                  * 2. At this point, the file is known to be modified,
4411                  *    with the same mode and size, and the object
4412                  *    name of one side is unknown.  Need to inspect
4413                  *    the identical contents.
4414                  */
4415                 if (!DIFF_FILE_VALID(p->one) || /* (1) */
4416                     !DIFF_FILE_VALID(p->two) ||
4417                     (p->one->sha1_valid && p->two->sha1_valid) ||
4418                     (p->one->mode != p->two->mode) ||
4419                     diff_populate_filespec(p->one, 1) ||
4420                     diff_populate_filespec(p->two, 1) ||
4421                     (p->one->size != p->two->size) ||
4422                     !diff_filespec_is_identical(p->one, p->two)) /* (2) */
4423                         diff_q(&outq, p);
4424                 else {
4425                         /*
4426                          * The caller can subtract 1 from skip_stat_unmatch
4427                          * to determine how many paths were dirty only
4428                          * due to stat info mismatch.
4429                          */
4430                         if (!DIFF_OPT_TST(diffopt, NO_INDEX))
4431                                 diffopt->skip_stat_unmatch++;
4432                         diff_free_filepair(p);
4433                 }
4434         }
4435         free(q->queue);
4436         *q = outq;
4439 static int diffnamecmp(const void *a_, const void *b_)
4441         const struct diff_filepair *a = *((const struct diff_filepair **)a_);
4442         const struct diff_filepair *b = *((const struct diff_filepair **)b_);
4443         const char *name_a, *name_b;
4445         name_a = a->one ? a->one->path : a->two->path;
4446         name_b = b->one ? b->one->path : b->two->path;
4447         return strcmp(name_a, name_b);
4450 void diffcore_fix_diff_index(struct diff_options *options)
4452         struct diff_queue_struct *q = &diff_queued_diff;
4453         qsort(q->queue, q->nr, sizeof(q->queue[0]), diffnamecmp);
4456 void diffcore_std(struct diff_options *options)
4458         if (options->skip_stat_unmatch)
4459                 diffcore_skip_stat_unmatch(options);
4460         if (!options->found_follow) {
4461                 /* See try_to_follow_renames() in tree-diff.c */
4462                 if (options->break_opt != -1)
4463                         diffcore_break(options->break_opt);
4464                 if (options->detect_rename)
4465                         diffcore_rename(options);
4466                 if (options->break_opt != -1)
4467                         diffcore_merge_broken();
4468         }
4469         if (options->pickaxe)
4470                 diffcore_pickaxe(options);
4471         if (options->orderfile)
4472                 diffcore_order(options->orderfile);
4473         if (!options->found_follow)
4474                 /* See try_to_follow_renames() in tree-diff.c */
4475                 diff_resolve_rename_copy();
4476         diffcore_apply_filter(options->filter);
4478         if (diff_queued_diff.nr && !DIFF_OPT_TST(options, DIFF_FROM_CONTENTS))
4479                 DIFF_OPT_SET(options, HAS_CHANGES);
4480         else
4481                 DIFF_OPT_CLR(options, HAS_CHANGES);
4483         options->found_follow = 0;
4486 int diff_result_code(struct diff_options *opt, int status)
4488         int result = 0;
4490         diff_warn_rename_limit("diff.renamelimit",
4491                                opt->needed_rename_limit,
4492                                opt->degraded_cc_to_c);
4493         if (!DIFF_OPT_TST(opt, EXIT_WITH_STATUS) &&
4494             !(opt->output_format & DIFF_FORMAT_CHECKDIFF))
4495                 return status;
4496         if (DIFF_OPT_TST(opt, EXIT_WITH_STATUS) &&
4497             DIFF_OPT_TST(opt, HAS_CHANGES))
4498                 result |= 01;
4499         if ((opt->output_format & DIFF_FORMAT_CHECKDIFF) &&
4500             DIFF_OPT_TST(opt, CHECK_FAILED))
4501                 result |= 02;
4502         return result;
4505 int diff_can_quit_early(struct diff_options *opt)
4507         return (DIFF_OPT_TST(opt, QUICK) &&
4508                 !opt->filter &&
4509                 DIFF_OPT_TST(opt, HAS_CHANGES));
4512 /*
4513  * Shall changes to this submodule be ignored?
4514  *
4515  * Submodule changes can be configured to be ignored separately for each path,
4516  * but that configuration can be overridden from the command line.
4517  */
4518 static int is_submodule_ignored(const char *path, struct diff_options *options)
4520         int ignored = 0;
4521         unsigned orig_flags = options->flags;
4522         if (!DIFF_OPT_TST(options, OVERRIDE_SUBMODULE_CONFIG))
4523                 set_diffopt_flags_from_submodule_config(options, path);
4524         if (DIFF_OPT_TST(options, IGNORE_SUBMODULES))
4525                 ignored = 1;
4526         options->flags = orig_flags;
4527         return ignored;
4530 void diff_addremove(struct diff_options *options,
4531                     int addremove, unsigned mode,
4532                     const unsigned char *sha1,
4533                     const char *concatpath, unsigned dirty_submodule)
4535         struct diff_filespec *one, *two;
4537         if (S_ISGITLINK(mode) && is_submodule_ignored(concatpath, options))
4538                 return;
4540         /* This may look odd, but it is a preparation for
4541          * feeding "there are unchanged files which should
4542          * not produce diffs, but when you are doing copy
4543          * detection you would need them, so here they are"
4544          * entries to the diff-core.  They will be prefixed
4545          * with something like '=' or '*' (I haven't decided
4546          * which but should not make any difference).
4547          * Feeding the same new and old to diff_change()
4548          * also has the same effect.
4549          * Before the final output happens, they are pruned after
4550          * merged into rename/copy pairs as appropriate.
4551          */
4552         if (DIFF_OPT_TST(options, REVERSE_DIFF))
4553                 addremove = (addremove == '+' ? '-' :
4554                              addremove == '-' ? '+' : addremove);
4556         if (options->prefix &&
4557             strncmp(concatpath, options->prefix, options->prefix_length))
4558                 return;
4560         one = alloc_filespec(concatpath);
4561         two = alloc_filespec(concatpath);
4563         if (addremove != '+')
4564                 fill_filespec(one, sha1, mode);
4565         if (addremove != '-') {
4566                 fill_filespec(two, sha1, mode);
4567                 two->dirty_submodule = dirty_submodule;
4568         }
4570         diff_queue(&diff_queued_diff, one, two);
4571         if (!DIFF_OPT_TST(options, DIFF_FROM_CONTENTS))
4572                 DIFF_OPT_SET(options, HAS_CHANGES);
4575 void diff_change(struct diff_options *options,
4576                  unsigned old_mode, unsigned new_mode,
4577                  const unsigned char *old_sha1,
4578                  const unsigned char *new_sha1,
4579                  const char *concatpath,
4580                  unsigned old_dirty_submodule, unsigned new_dirty_submodule)
4582         struct diff_filespec *one, *two;
4584         if (S_ISGITLINK(old_mode) && S_ISGITLINK(new_mode) &&
4585             is_submodule_ignored(concatpath, options))
4586                 return;
4588         if (DIFF_OPT_TST(options, REVERSE_DIFF)) {
4589                 unsigned tmp;
4590                 const unsigned char *tmp_c;
4591                 tmp = old_mode; old_mode = new_mode; new_mode = tmp;
4592                 tmp_c = old_sha1; old_sha1 = new_sha1; new_sha1 = tmp_c;
4593                 tmp = old_dirty_submodule; old_dirty_submodule = new_dirty_submodule;
4594                         new_dirty_submodule = tmp;
4595         }
4597         if (options->prefix &&
4598             strncmp(concatpath, options->prefix, options->prefix_length))
4599                 return;
4601         one = alloc_filespec(concatpath);
4602         two = alloc_filespec(concatpath);
4603         fill_filespec(one, old_sha1, old_mode);
4604         fill_filespec(two, new_sha1, new_mode);
4605         one->dirty_submodule = old_dirty_submodule;
4606         two->dirty_submodule = new_dirty_submodule;
4608         diff_queue(&diff_queued_diff, one, two);
4609         if (!DIFF_OPT_TST(options, DIFF_FROM_CONTENTS))
4610                 DIFF_OPT_SET(options, HAS_CHANGES);
4613 struct diff_filepair *diff_unmerge(struct diff_options *options, const char *path)
4615         struct diff_filepair *pair;
4616         struct diff_filespec *one, *two;
4618         if (options->prefix &&
4619             strncmp(path, options->prefix, options->prefix_length))
4620                 return NULL;
4622         one = alloc_filespec(path);
4623         two = alloc_filespec(path);
4624         pair = diff_queue(&diff_queued_diff, one, two);
4625         pair->is_unmerged = 1;
4626         return pair;
4629 static char *run_textconv(const char *pgm, struct diff_filespec *spec,
4630                 size_t *outsize)
4632         struct diff_tempfile *temp;
4633         const char *argv[3];
4634         const char **arg = argv;
4635         struct child_process child;
4636         struct strbuf buf = STRBUF_INIT;
4637         int err = 0;
4639         temp = prepare_temp_file(spec->path, spec);
4640         *arg++ = pgm;
4641         *arg++ = temp->name;
4642         *arg = NULL;
4644         memset(&child, 0, sizeof(child));
4645         child.use_shell = 1;
4646         child.argv = argv;
4647         child.out = -1;
4648         if (start_command(&child)) {
4649                 remove_tempfile();
4650                 return NULL;
4651         }
4653         if (strbuf_read(&buf, child.out, 0) < 0)
4654                 err = error("error reading from textconv command '%s'", pgm);
4655         close(child.out);
4657         if (finish_command(&child) || err) {
4658                 strbuf_release(&buf);
4659                 remove_tempfile();
4660                 return NULL;
4661         }
4662         remove_tempfile();
4664         return strbuf_detach(&buf, outsize);
4667 size_t fill_textconv(struct userdiff_driver *driver,
4668                      struct diff_filespec *df,
4669                      char **outbuf)
4671         size_t size;
4673         if (!driver || !driver->textconv) {
4674                 if (!DIFF_FILE_VALID(df)) {
4675                         *outbuf = "";
4676                         return 0;
4677                 }
4678                 if (diff_populate_filespec(df, 0))
4679                         die("unable to read files to diff");
4680                 *outbuf = df->data;
4681                 return df->size;
4682         }
4684         if (driver->textconv_cache && df->sha1_valid) {
4685                 *outbuf = notes_cache_get(driver->textconv_cache, df->sha1,
4686                                           &size);
4687                 if (*outbuf)
4688                         return size;
4689         }
4691         *outbuf = run_textconv(driver->textconv, df, &size);
4692         if (!*outbuf)
4693                 die("unable to read files to diff");
4695         if (driver->textconv_cache && df->sha1_valid) {
4696                 /* ignore errors, as we might be in a readonly repository */
4697                 notes_cache_put(driver->textconv_cache, df->sha1, *outbuf,
4698                                 size);
4699                 /*
4700                  * we could save up changes and flush them all at the end,
4701                  * but we would need an extra call after all diffing is done.
4702                  * Since generating a cache entry is the slow path anyway,
4703                  * this extra overhead probably isn't a big deal.
4704                  */
4705                 notes_cache_write(driver->textconv_cache);
4706         }
4708         return size;