/*

* Copyright (C) 2005 Junio C Hamano

*/

#include "cache.h"

#include "quote.h"

#include "diff.h"

#include "diffcore.h"

#include "delta.h"

#include "xdiff-interface.h"

#include "color.h"

#include "attr.h"

#include "run-command.h"

#include "utf8.h"

#include "userdiff.h"

#include "sigchain.h"

#include "submodule.h"

#include "ll-merge.h"

#ifdef NO_FAST_WORKING_DIRECTORY

#define FAST_WORKING_DIRECTORY 0

#else

#define FAST_WORKING_DIRECTORY 1

#endif

static int diff_detect_rename_default;

static int diff_rename_limit_default = 200;

static int diff_suppress_blank_empty;

int diff_use_color_default = -1;

static const char *diff_word_regex_cfg;

static const char *external_diff_cmd_cfg;

int diff_auto_refresh_index = 1;

static int diff_mnemonic_prefix;

static char diff_colors[][COLOR_MAXLEN] = {

GIT_COLOR_RESET,

GIT_COLOR_NORMAL, /* PLAIN */

GIT_COLOR_BOLD, /* METAINFO */

GIT_COLOR_CYAN, /* FRAGINFO */

GIT_COLOR_RED, /* OLD */

GIT_COLOR_GREEN, /* NEW */

GIT_COLOR_YELLOW, /* COMMIT */

GIT_COLOR_BG_RED, /* WHITESPACE */

GIT_COLOR_NORMAL, /* FUNCINFO */

};

static void diff_filespec_load_driver(struct diff_filespec *one);

static size_t fill_textconv(struct userdiff_driver *driver,

struct diff_filespec *df, char **outbuf);

static int parse_diff_color_slot(const char *var, int ofs)

{

if (!strcasecmp(var+ofs, "plain"))

return DIFF_PLAIN;

if (!strcasecmp(var+ofs, "meta"))

return DIFF_METAINFO;

if (!strcasecmp(var+ofs, "frag"))

return DIFF_FRAGINFO;

if (!strcasecmp(var+ofs, "old"))

return DIFF_FILE_OLD;

if (!strcasecmp(var+ofs, "new"))

return DIFF_FILE_NEW;

if (!strcasecmp(var+ofs, "commit"))

return DIFF_COMMIT;

if (!strcasecmp(var+ofs, "whitespace"))

return DIFF_WHITESPACE;

if (!strcasecmp(var+ofs, "func"))

return DIFF_FUNCINFO;

return -1;

}

static int git_config_rename(const char *var, const char *value)

{

if (!value)

return DIFF_DETECT_RENAME;

if (!strcasecmp(value, "copies") || !strcasecmp(value, "copy"))

return DIFF_DETECT_COPY;

return git_config_bool(var,value) ? DIFF_DETECT_RENAME : 0;

}

/*

* These are to give UI layer defaults.

* The core-level commands such as git-diff-files should

* never be affected by the setting of diff.renames

* the user happens to have in the configuration file.

*/

int git_diff_ui_config(const char *var, const char *value, void *cb)

{

if (!strcmp(var, "diff.color") || !strcmp(var, "color.diff")) {

diff_use_color_default = git_config_colorbool(var, value, -1);

return 0;

}

if (!strcmp(var, "diff.renames")) {

diff_detect_rename_default = git_config_rename(var, value);

return 0;

}

if (!strcmp(var, "diff.autorefreshindex")) {

diff_auto_refresh_index = git_config_bool(var, value);

return 0;

}

if (!strcmp(var, "diff.mnemonicprefix")) {

diff_mnemonic_prefix = git_config_bool(var, value);

return 0;

}

if (!strcmp(var, "diff.external"))

return git_config_string(&external_diff_cmd_cfg, var, value);

if (!strcmp(var, "diff.wordregex"))

return git_config_string(&diff_word_regex_cfg, var, value);

return git_diff_basic_config(var, value, cb);

}

int git_diff_basic_config(const char *var, const char *value, void *cb)

{

if (!strcmp(var, "diff.renamelimit")) {

diff_rename_limit_default = git_config_int(var, value);

return 0;

}

switch (userdiff_config(var, value)) {

case 0: break;

case -1: return -1;

default: return 0;

}

if (!prefixcmp(var, "diff.color.") || !prefixcmp(var, "color.diff.")) {

int slot = parse_diff_color_slot(var, 11);

if (slot < 0)

return 0;

if (!value)

return config_error_nonbool(var);

color_parse(value, var, diff_colors[slot]);

return 0;

}

/* like GNU diff's --suppress-blank-empty option */

if (!strcmp(var, "diff.suppressblankempty") ||

/* for backwards compatibility */

!strcmp(var, "diff.suppress-blank-empty")) {

diff_suppress_blank_empty = git_config_bool(var, value);

return 0;

}

return git_color_default_config(var, value, cb);

}

static char *quote_two(const char *one, const char *two)

{

int need_one = quote_c_style(one, NULL, NULL, 1);

int need_two = quote_c_style(two, NULL, NULL, 1);

struct strbuf res = STRBUF_INIT;

if (need_one + need_two) {

strbuf_addch(&res, '"');

quote_c_style(one, &res, NULL, 1);

quote_c_style(two, &res, NULL, 1);

strbuf_addch(&res, '"');

} else {

strbuf_addstr(&res, one);

strbuf_addstr(&res, two);

}

return strbuf_detach(&res, NULL);

}

static const char *external_diff(void)

{

static const char *external_diff_cmd = NULL;

static int done_preparing = 0;

if (done_preparing)

return external_diff_cmd;

external_diff_cmd = getenv("GIT_EXTERNAL_DIFF");

if (!external_diff_cmd)

external_diff_cmd = external_diff_cmd_cfg;

done_preparing = 1;

return external_diff_cmd;

}

static struct diff_tempfile {

const char *name; /* filename external diff should read from */

char hex[41];

char mode[10];

char tmp_path[PATH_MAX];

} diff_temp[2];

typedef unsigned long (*sane_truncate_fn)(char *line, unsigned long len);

struct emit_callback {

int color_diff;

unsigned ws_rule;

int blank_at_eof_in_preimage;

int blank_at_eof_in_postimage;

int lno_in_preimage;

int lno_in_postimage;

sane_truncate_fn truncate;

const char **label_path;

struct diff_words_data *diff_words;

int *found_changesp;

FILE *file;

struct strbuf *header;

};

static int count_lines(const char *data, int size)

{

int count, ch, completely_empty = 1, nl_just_seen = 0;

count = 0;

while (0 < size--) {

ch = *data++;

if (ch == '\n') {

count++;

nl_just_seen = 1;

completely_empty = 0;

}

else {

nl_just_seen = 0;

completely_empty = 0;

}

}

if (completely_empty)

return 0;

if (!nl_just_seen)

count++; /* no trailing newline */

return count;

}

static int fill_mmfile(mmfile_t *mf, struct diff_filespec *one)

{

if (!DIFF_FILE_VALID(one)) {

mf->ptr = (char *)""; /* does not matter */

mf->size = 0;

return 0;

}

else if (diff_populate_filespec(one, 0))

return -1;

mf->ptr = one->data;

mf->size = one->size;

return 0;

}

static int count_trailing_blank(mmfile_t *mf, unsigned ws_rule)

{

char *ptr = mf->ptr;

long size = mf->size;

int cnt = 0;

if (!size)

return cnt;

ptr += size - 1; /* pointing at the very end */

if (*ptr != '\n')

; /* incomplete line */

else

ptr--; /* skip the last LF */

while (mf->ptr < ptr) {

char *prev_eol;

for (prev_eol = ptr; mf->ptr <= prev_eol; prev_eol--)

if (*prev_eol == '\n')

break;

if (!ws_blank_line(prev_eol + 1, ptr - prev_eol, ws_rule))

break;

cnt++;

ptr = prev_eol - 1;

}

return cnt;

}

static void check_blank_at_eof(mmfile_t *mf1, mmfile_t *mf2,

struct emit_callback *ecbdata)

{

int l1, l2, at;

unsigned ws_rule = ecbdata->ws_rule;

l1 = count_trailing_blank(mf1, ws_rule);

l2 = count_trailing_blank(mf2, ws_rule);

if (l2 <= l1) {

ecbdata->blank_at_eof_in_preimage = 0;

ecbdata->blank_at_eof_in_postimage = 0;

return;

}

at = count_lines(mf1->ptr, mf1->size);

ecbdata->blank_at_eof_in_preimage = (at - l1) + 1;

at = count_lines(mf2->ptr, mf2->size);

ecbdata->blank_at_eof_in_postimage = (at - l2) + 1;

}

static void emit_line_0(FILE *file, const char *set, const char *reset,

int first, const char *line, int len)

{

int has_trailing_newline, has_trailing_carriage_return;

int nofirst;

if (len == 0) {

has_trailing_newline = (first == '\n');

has_trailing_carriage_return = (!has_trailing_newline &&

(first == '\r'));

nofirst = has_trailing_newline || has_trailing_carriage_return;

} else {

has_trailing_newline = (len > 0 && line[len-1] == '\n');

if (has_trailing_newline)

len--;

has_trailing_carriage_return = (len > 0 && line[len-1] == '\r');

if (has_trailing_carriage_return)

len--;

nofirst = 0;

}

if (len || !nofirst) {

fputs(set, file);

if (!nofirst)

fputc(first, file);

fwrite(line, len, 1, file);

fputs(reset, file);

}

if (has_trailing_carriage_return)

fputc('\r', file);

if (has_trailing_newline)

fputc('\n', file);

}

static void emit_line(FILE *file, const char *set, const char *reset,

const char *line, int len)

{

emit_line_0(file, set, reset, line[0], line+1, len-1);

}

static int new_blank_line_at_eof(struct emit_callback *ecbdata, const char *line, int len)

{

if (!((ecbdata->ws_rule & WS_BLANK_AT_EOF) &&

ecbdata->blank_at_eof_in_preimage &&

ecbdata->blank_at_eof_in_postimage &&

ecbdata->blank_at_eof_in_preimage <= ecbdata->lno_in_preimage &&

ecbdata->blank_at_eof_in_postimage <= ecbdata->lno_in_postimage))

return 0;

return ws_blank_line(line, len, ecbdata->ws_rule);

}

static void emit_add_line(const char *reset,

struct emit_callback *ecbdata,

const char *line, int len)

{

const char *ws = diff_get_color(ecbdata->color_diff, DIFF_WHITESPACE);

const char *set = diff_get_color(ecbdata->color_diff, DIFF_FILE_NEW);

if (!*ws)

emit_line_0(ecbdata->file, set, reset, '+', line, len);

else if (new_blank_line_at_eof(ecbdata, line, len))

/* Blank line at EOF - paint '+' as well */

emit_line_0(ecbdata->file, ws, reset, '+', line, len);

else {

/* Emit just the prefix, then the rest. */

emit_line_0(ecbdata->file, set, reset, '+', "", 0);

ws_check_emit(line, len, ecbdata->ws_rule,

ecbdata->file, set, reset, ws);

}

}

static void emit_hunk_header(struct emit_callback *ecbdata,

const char *line, int len)

{

const char *plain = diff_get_color(ecbdata->color_diff, DIFF_PLAIN);

const char *frag = diff_get_color(ecbdata->color_diff, DIFF_FRAGINFO);

const char *func = diff_get_color(ecbdata->color_diff, DIFF_FUNCINFO);

const char *reset = diff_get_color(ecbdata->color_diff, DIFF_RESET);

static const char atat[2] = { '@', '@' };

const char *cp, *ep;

/*

* As a hunk header must begin with "@@ -<old>, +<new> @@",

* it always is at least 10 bytes long.

*/

if (len < 10 ||

memcmp(line, atat, 2) ||

!(ep = memmem(line + 2, len - 2, atat, 2))) {

emit_line(ecbdata->file, plain, reset, line, len);

return;

}

ep += 2; /* skip over @@ */

/* The hunk header in fraginfo color */

emit_line(ecbdata->file, frag, reset, line, ep - line);

/* blank before the func header */

for (cp = ep; ep - line < len; ep++)

if (*ep != ' ' && *ep != '\t')

break;

if (ep != cp)

emit_line(ecbdata->file, plain, reset, cp, ep - cp);

if (ep < line + len)

emit_line(ecbdata->file, func, reset, ep, line + len - ep);

}

static struct diff_tempfile *claim_diff_tempfile(void) {

int i;

for (i = 0; i < ARRAY_SIZE(diff_temp); i++)

if (!diff_temp[i].name)

return diff_temp + i;

die("BUG: diff is failing to clean up its tempfiles");

}

static int remove_tempfile_installed;

static void remove_tempfile(void)

{

int i;

for (i = 0; i < ARRAY_SIZE(diff_temp); i++) {

if (diff_temp[i].name == diff_temp[i].tmp_path)

unlink_or_warn(diff_temp[i].name);

diff_temp[i].name = NULL;

}

}

static void remove_tempfile_on_signal(int signo)

{

remove_tempfile();

sigchain_pop(signo);

raise(signo);

}

static void print_line_count(FILE *file, int count)

{

switch (count) {

case 0:

fprintf(file, "0,0");

break;

case 1:

fprintf(file, "1");

break;

default:

fprintf(file, "1,%d", count);

break;

}

}

static void emit_rewrite_lines(struct emit_callback *ecb,

int prefix, const char *data, int size)

{

const char *endp = NULL;

static const char *nneof = " No newline at end of file\n";

const char *old = diff_get_color(ecb->color_diff, DIFF_FILE_OLD);

const char *reset = diff_get_color(ecb->color_diff, DIFF_RESET);

while (0 < size) {

int len;

endp = memchr(data, '\n', size);

len = endp ? (endp - data + 1) : size;

if (prefix != '+') {

ecb->lno_in_preimage++;

emit_line_0(ecb->file, old, reset, '-',

data, len);

} else {

ecb->lno_in_postimage++;

emit_add_line(reset, ecb, data, len);

}

size -= len;

data += len;

}

if (!endp) {

const char *plain = diff_get_color(ecb->color_diff,

DIFF_PLAIN);

emit_line_0(ecb->file, plain, reset, '\\',

nneof, strlen(nneof));

}

}

static void emit_rewrite_diff(const char *name_a,

const char *name_b,

struct diff_filespec *one,

struct diff_filespec *two,

struct userdiff_driver *textconv_one,

struct userdiff_driver *textconv_two,

struct diff_options *o)

{

int lc_a, lc_b;

int color_diff = DIFF_OPT_TST(o, COLOR_DIFF);

const char *name_a_tab, *name_b_tab;

const char *metainfo = diff_get_color(color_diff, DIFF_METAINFO);

const char *fraginfo = diff_get_color(color_diff, DIFF_FRAGINFO);

const char *reset = diff_get_color(color_diff, DIFF_RESET);

static struct strbuf a_name = STRBUF_INIT, b_name = STRBUF_INIT;

const char *a_prefix, *b_prefix;

char *data_one, *data_two;

size_t size_one, size_two;

struct emit_callback ecbdata;

if (diff_mnemonic_prefix && DIFF_OPT_TST(o, REVERSE_DIFF)) {

a_prefix = o->b_prefix;

b_prefix = o->a_prefix;

} else {

a_prefix = o->a_prefix;

b_prefix = o->b_prefix;

}

name_a += (*name_a == '/');

name_b += (*name_b == '/');

name_a_tab = strchr(name_a, ' ') ? "\t" : "";

name_b_tab = strchr(name_b, ' ') ? "\t" : "";

strbuf_reset(&a_name);

strbuf_reset(&b_name);

quote_two_c_style(&a_name, a_prefix, name_a, 0);

quote_two_c_style(&b_name, b_prefix, name_b, 0);

size_one = fill_textconv(textconv_one, one, &data_one);

size_two = fill_textconv(textconv_two, two, &data_two);

memset(&ecbdata, 0, sizeof(ecbdata));

ecbdata.color_diff = color_diff;

ecbdata.found_changesp = &o->found_changes;

ecbdata.ws_rule = whitespace_rule(name_b ? name_b : name_a);

ecbdata.file = o->file;

if (ecbdata.ws_rule & WS_BLANK_AT_EOF) {

mmfile_t mf1, mf2;

mf1.ptr = (char *)data_one;

mf2.ptr = (char *)data_two;

mf1.size = size_one;

mf2.size = size_two;

check_blank_at_eof(&mf1, &mf2, &ecbdata);

}

ecbdata.lno_in_preimage = 1;

ecbdata.lno_in_postimage = 1;

lc_a = count_lines(data_one, size_one);

lc_b = count_lines(data_two, size_two);

fprintf(o->file,

"%s--- %s%s%s\n%s+++ %s%s%s\n%s@@ -",

metainfo, a_name.buf, name_a_tab, reset,

metainfo, b_name.buf, name_b_tab, reset, fraginfo);

print_line_count(o->file, lc_a);

fprintf(o->file, " +");

print_line_count(o->file, lc_b);

fprintf(o->file, " @@%s\n", reset);

if (lc_a)

emit_rewrite_lines(&ecbdata, '-', data_one, size_one);

if (lc_b)

emit_rewrite_lines(&ecbdata, '+', data_two, size_two);

if (textconv_one)

free((char *)data_one);

if (textconv_two)

free((char *)data_two);

}

struct diff_words_buffer {

mmfile_t text;

long alloc;

struct diff_words_orig {

const char *begin, *end;

} *orig;

int orig_nr, orig_alloc;

};

static void diff_words_append(char *line, unsigned long len,

struct diff_words_buffer *buffer)

{

ALLOC_GROW(buffer->text.ptr, buffer->text.size + len, buffer->alloc);

line++;

len--;

memcpy(buffer->text.ptr + buffer->text.size, line, len);

buffer->text.size += len;

buffer->text.ptr[buffer->text.size] = '\0';

}

struct diff_words_style_elem

{

const char *prefix;

const char *suffix;

const char *color; /* NULL; filled in by the setup code if

* color is enabled */

};

struct diff_words_style

{

enum diff_words_type type;

struct diff_words_style_elem new, old, ctx;

const char *newline;

};

struct diff_words_style diff_words_styles[] = {

{ DIFF_WORDS_PORCELAIN, {"+", "\n"}, {"-", "\n"}, {" ", "\n"}, "~\n" },

{ DIFF_WORDS_PLAIN, {"{+", "+}"}, {"[-", "-]"}, {"", ""}, "\n" },

{ DIFF_WORDS_COLOR, {"", ""}, {"", ""}, {"", ""}, "\n" }

};

struct diff_words_data {

struct diff_words_buffer minus, plus;

const char *current_plus;

FILE *file;

regex_t *word_regex;

enum diff_words_type type;

struct diff_words_style *style;

};

static int fn_out_diff_words_write_helper(FILE *fp,

struct diff_words_style_elem *st_el,

const char *newline,

size_t count, const char *buf)

{

while (count) {

char *p = memchr(buf, '\n', count);

if (p != buf) {

if (st_el->color && fputs(st_el->color, fp) < 0)

return -1;

if (fputs(st_el->prefix, fp) < 0 ||

fwrite(buf, p ? p - buf : count, 1, fp) != 1 ||

fputs(st_el->suffix, fp) < 0)

return -1;

if (st_el->color && *st_el->color

&& fputs(GIT_COLOR_RESET, fp) < 0)

return -1;

}

if (!p)

return 0;

if (fputs(newline, fp) < 0)

return -1;

count -= p + 1 - buf;

buf = p + 1;

}

return 0;

}

static void fn_out_diff_words_aux(void *priv, char *line, unsigned long len)

{

struct diff_words_data *diff_words = priv;

struct diff_words_style *style = diff_words->style;

int minus_first, minus_len, plus_first, plus_len;

const char *minus_begin, *minus_end, *plus_begin, *plus_end;

if (line[0] != '@' || parse_hunk_header(line, len,

&minus_first, &minus_len, &plus_first, &plus_len))

return;

/* POSIX requires that first be decremented by one if len == 0... */

if (minus_len) {

minus_begin = diff_words->minus.orig[minus_first].begin;

minus_end =

diff_words->minus.orig[minus_first + minus_len - 1].end;

} else

minus_begin = minus_end =

diff_words->minus.orig[minus_first].end;

if (plus_len) {

plus_begin = diff_words->plus.orig[plus_first].begin;

plus_end = diff_words->plus.orig[plus_first + plus_len - 1].end;

} else

plus_begin = plus_end = diff_words->plus.orig[plus_first].end;

if (diff_words->current_plus != plus_begin)

fn_out_diff_words_write_helper(diff_words->file,

&style->ctx, style->newline,

plus_begin - diff_words->current_plus,

diff_words->current_plus);

if (minus_begin != minus_end)

fn_out_diff_words_write_helper(diff_words->file,

&style->old, style->newline,

minus_end - minus_begin, minus_begin);

if (plus_begin != plus_end)

fn_out_diff_words_write_helper(diff_words->file,

&style->new, style->newline,

plus_end - plus_begin, plus_begin);

diff_words->current_plus = plus_end;

}

/* This function starts looking at *begin, and returns 0 iff a word was found. */

static int find_word_boundaries(mmfile_t *buffer, regex_t *word_regex,

int *begin, int *end)

{

if (word_regex && *begin < buffer->size) {

regmatch_t match[1];

if (!regexec(word_regex, buffer->ptr + *begin, 1, match, 0)) {

char *p = memchr(buffer->ptr + *begin + match[0].rm_so,

'\n', match[0].rm_eo - match[0].rm_so);

*end = p ? p - buffer->ptr : match[0].rm_eo + *begin;

*begin += match[0].rm_so;

return *begin >= *end;

}

return -1;

}

/* find the next word */

while (*begin < buffer->size && isspace(buffer->ptr[*begin]))

(*begin)++;

if (*begin >= buffer->size)

return -1;

/* find the end of the word */

*end = *begin + 1;

while (*end < buffer->size && !isspace(buffer->ptr[*end]))

(*end)++;

return 0;

}

/*

* This function splits the words in buffer->text, stores the list with

* newline separator into out, and saves the offsets of the original words

* in buffer->orig.

*/

static void diff_words_fill(struct diff_words_buffer *buffer, mmfile_t *out,

regex_t *word_regex)

{

int i, j;

long alloc = 0;

out->size = 0;

out->ptr = NULL;

/* fake an empty "0th" word */

ALLOC_GROW(buffer->orig, 1, buffer->orig_alloc);

buffer->orig[0].begin = buffer->orig[0].end = buffer->text.ptr;

buffer->orig_nr = 1;

for (i = 0; i < buffer->text.size; i++) {

if (find_word_boundaries(&buffer->text, word_regex, &i, &j))

return;

/* store original boundaries */

ALLOC_GROW(buffer->orig, buffer->orig_nr + 1,

buffer->orig_alloc);

buffer->orig[buffer->orig_nr].begin = buffer->text.ptr + i;

buffer->orig[buffer->orig_nr].end = buffer->text.ptr + j;

buffer->orig_nr++;

/* store one word */

ALLOC_GROW(out->ptr, out->size + j - i + 1, alloc);

memcpy(out->ptr + out->size, buffer->text.ptr + i, j - i);

out->ptr[out->size + j - i] = '\n';

out->size += j - i + 1;

i = j - 1;

}

}

/* this executes the word diff on the accumulated buffers */

static void diff_words_show(struct diff_words_data *diff_words)

{

xpparam_t xpp;

xdemitconf_t xecfg;

xdemitcb_t ecb;

mmfile_t minus, plus;

struct diff_words_style *style = diff_words->style;

/* special case: only removal */

if (!diff_words->plus.text.size) {

fn_out_diff_words_write_helper(diff_words->file,

&style->old, style->newline,

diff_words->minus.text.size, diff_words->minus.text.ptr);

diff_words->minus.text.size = 0;

return;

}

diff_words->current_plus = diff_words->plus.text.ptr;

memset(&xpp, 0, sizeof(xpp));

memset(&xecfg, 0, sizeof(xecfg));

diff_words_fill(&diff_words->minus, &minus, diff_words->word_regex);

diff_words_fill(&diff_words->plus, &plus, diff_words->word_regex);

xpp.flags = XDF_NEED_MINIMAL;

/* as only the hunk header will be parsed, we need a 0-context */

xecfg.ctxlen = 0;

xdi_diff_outf(&minus, &plus, fn_out_diff_words_aux, diff_words,

&xpp, &xecfg, &ecb);

free(minus.ptr);

free(plus.ptr);

if (diff_words->current_plus != diff_words->plus.text.ptr +

diff_words->plus.text.size)

fn_out_diff_words_write_helper(diff_words->file,

&style->ctx, style->newline,

diff_words->plus.text.ptr + diff_words->plus.text.size

- diff_words->current_plus, diff_words->current_plus);

diff_words->minus.text.size = diff_words->plus.text.size = 0;

}

/* In "color-words" mode, show word-diff of words accumulated in the buffer */

static void diff_words_flush(struct emit_callback *ecbdata)

{

if (ecbdata->diff_words->minus.text.size ||

ecbdata->diff_words->plus.text.size)

diff_words_show(ecbdata->diff_words);

}

static void free_diff_words_data(struct emit_callback *ecbdata)

{

if (ecbdata->diff_words) {

diff_words_flush(ecbdata);

free (ecbdata->diff_words->minus.text.ptr);

free (ecbdata->diff_words->minus.orig);

free (ecbdata->diff_words->plus.text.ptr);

free (ecbdata->diff_words->plus.orig);

free(ecbdata->diff_words->word_regex);

free(ecbdata->diff_words);

ecbdata->diff_words = NULL;

}

}

const char *diff_get_color(int diff_use_color, enum color_diff ix)

{

if (diff_use_color)

return diff_colors[ix];

return "";

}

static unsigned long sane_truncate_line(struct emit_callback *ecb, char *line, unsigned long len)

{

const char *cp;

unsigned long allot;

size_t l = len;

if (ecb->truncate)

return ecb->truncate(line, len);

cp = line;

allot = l;

while (0 < l) {

(void) utf8_width(&cp, &l);

if (!cp)

break; /* truncated in the middle? */

}

return allot - l;

}

static void find_lno(const char *line, struct emit_callback *ecbdata)

{

const char *p;

ecbdata->lno_in_preimage = 0;

ecbdata->lno_in_postimage = 0;

p = strchr(line, '-');

if (!p)

return; /* cannot happen */

ecbdata->lno_in_preimage = strtol(p + 1, NULL, 10);

p = strchr(p, '+');

if (!p)

return; /* cannot happen */

ecbdata->lno_in_postimage = strtol(p + 1, NULL, 10);

}

static void fn_out_consume(void *priv, char *line, unsigned long len)

{

struct emit_callback *ecbdata = priv;

const char *meta = diff_get_color(ecbdata->color_diff, DIFF_METAINFO);

const char *plain = diff_get_color(ecbdata->color_diff, DIFF_PLAIN);

const char *reset = diff_get_color(ecbdata->color_diff, DIFF_RESET);

if (ecbdata->header) {

fprintf(ecbdata->file, "%s", ecbdata->header->buf);

strbuf_reset(ecbdata->header);

ecbdata->header = NULL;

}

*(ecbdata->found_changesp) = 1;

if (ecbdata->label_path[0]) {

const char *name_a_tab, *name_b_tab;

name_a_tab = strchr(ecbdata->label_path[0], ' ') ? "\t" : "";

name_b_tab = strchr(ecbdata->label_path[1], ' ') ? "\t" : "";

fprintf(ecbdata->file, "%s--- %s%s%s\n",

meta, ecbdata->label_path[0], reset, name_a_tab);

fprintf(ecbdata->file, "%s+++ %s%s%s\n",

meta, ecbdata->label_path[1], reset, name_b_tab);

ecbdata->label_path[0] = ecbdata->label_path[1] = NULL;

}

if (diff_suppress_blank_empty

&& len == 2 && line[0] == ' ' && line[1] == '\n') {

line[0] = '\n';

len = 1;

}

if (line[0] == '@') {

if (ecbdata->diff_words)

diff_words_flush(ecbdata);

len = sane_truncate_line(ecbdata, line, len);

find_lno(line, ecbdata);

emit_hunk_header(ecbdata, line, len);

if (line[len-1] != '\n')

putc('\n', ecbdata->file);

return;

}

if (len < 1) {

emit_line(ecbdata->file, reset, reset, line, len);

if (ecbdata->diff_words

&& ecbdata->diff_words->type == DIFF_WORDS_PORCELAIN)

fputs("~\n", ecbdata->file);

return;

}

if (ecbdata->diff_words) {

if (line[0] == '-') {

diff_words_append(line, len,

&ecbdata->diff_words->minus);

return;

} else if (line[0] == '+') {

diff_words_append(line, len,

&ecbdata->diff_words->plus);

return;

}

diff_words_flush(ecbdata);

if (ecbdata->diff_words->type == DIFF_WORDS_PORCELAIN) {

emit_line(ecbdata->file, plain, reset, line, len);

fputs("~\n", ecbdata->file);

} else {

/* don't print the prefix character */

emit_line(ecbdata->file, plain, reset, line+1, len-1);

}

return;

}

if (line[0] != '+') {

const char *color =

diff_get_color(ecbdata->color_diff,

line[0] == '-' ? DIFF_FILE_OLD : DIFF_PLAIN);

ecbdata->lno_in_preimage++;

if (line[0] == ' ')

ecbdata->lno_in_postimage++;

emit_line(ecbdata->file, color, reset, line, len);

} else {

ecbdata->lno_in_postimage++;

emit_add_line(reset, ecbdata, line + 1, len - 1);

}

}

static char *pprint_rename(const char *a, const char *b)

{

const char *old = a;

const char *new = b;

struct strbuf name = STRBUF_INIT;

int pfx_length, sfx_length;

int len_a = strlen(a);

int len_b = strlen(b);

int a_midlen, b_midlen;

int qlen_a = quote_c_style(a, NULL, NULL, 0);

int qlen_b = quote_c_style(b, NULL, NULL, 0);

if (qlen_a || qlen_b) {

quote_c_style(a, &name, NULL, 0);

strbuf_addstr(&name, " => ");

quote_c_style(b, &name, NULL, 0);

return strbuf_detach(&name, NULL);

}

/* Find common prefix */

pfx_length = 0;

while (*old && *new && *old == *new) {

if (*old == '/')

pfx_length = old - a + 1;

old++;

new++;

}

/* Find common suffix */

old = a + len_a;

new = b + len_b;

sfx_length = 0;

while (a <= old && b <= new && *old == *new) {

if (*old == '/')

sfx_length = len_a - (old - a);

old--;

new--;

}

/*

* pfx{mid-a => mid-b}sfx

* {pfx-a => pfx-b}sfx

* pfx{sfx-a => sfx-b}

* name-a => name-b

*/

a_midlen = len_a - pfx_length - sfx_length;

b_midlen = len_b - pfx_length - sfx_length;

if (a_midlen < 0)

a_midlen = 0;

if (b_midlen < 0)

b_midlen = 0;

strbuf_grow(&name, pfx_length + a_midlen + b_midlen + sfx_length + 7);

if (pfx_length + sfx_length) {

strbuf_add(&name, a, pfx_length);

strbuf_addch(&name, '{');

}

strbuf_add(&name, a + pfx_length, a_midlen);

strbuf_addstr(&name, " => ");

strbuf_add(&name, b + pfx_length, b_midlen);

if (pfx_length + sfx_length) {

strbuf_addch(&name, '}');

strbuf_add(&name, a + len_a - sfx_length, sfx_length);

}

return strbuf_detach(&name, NULL);

}

struct diffstat_t {

int nr;

int alloc;

struct diffstat_file {

char *from_name;

char *name;

char *print_name;

unsigned is_unmerged:1;

unsigned is_binary:1;

unsigned is_renamed:1;

uintmax_t added, deleted;