/*

* Copyright (C) 2005 Junio C Hamano

*/

#include "cache.h"

#include "tempfile.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 "submodule-config.h"

#include "submodule.h"

#include "ll-merge.h"

#include "string-list.h"

#include "argv-array.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 = 400;

static int diff_suppress_blank_empty;

static int diff_use_color_default = -1;

static int diff_context_default = 3;

static const char *diff_word_regex_cfg;

static const char *external_diff_cmd_cfg;

static const char *diff_order_file_cfg;

int diff_auto_refresh_index = 1;

static int diff_mnemonic_prefix;

static int diff_no_prefix;

static int diff_stat_graph_width;

static int diff_dirstat_permille_default = 30;

static struct diff_options default_diff_options;

static long diff_algorithm;

static char diff_colors[][COLOR_MAXLEN] = {

GIT_COLOR_RESET,

GIT_COLOR_NORMAL, /* CONTEXT */

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 int parse_diff_color_slot(const char *var)

{

if (!strcasecmp(var, "context") || !strcasecmp(var, "plain"))

return DIFF_CONTEXT;

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

return DIFF_METAINFO;

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

return DIFF_FRAGINFO;

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

return DIFF_FILE_OLD;

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

return DIFF_FILE_NEW;

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

return DIFF_COMMIT;

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

return DIFF_WHITESPACE;

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

return DIFF_FUNCINFO;

return -1;

}

static int parse_dirstat_params(struct diff_options *options, const char *params_string,

struct strbuf *errmsg)

{

char *params_copy = xstrdup(params_string);

struct string_list params = STRING_LIST_INIT_NODUP;

int ret = 0;

int i;

if (*params_copy)

string_list_split_in_place(&params, params_copy, ',', -1);

for (i = 0; i < params.nr; i++) {

const char *p = params.items[i].string;

if (!strcmp(p, "changes")) {

DIFF_OPT_CLR(options, DIRSTAT_BY_LINE);

DIFF_OPT_CLR(options, DIRSTAT_BY_FILE);

} else if (!strcmp(p, "lines")) {

DIFF_OPT_SET(options, DIRSTAT_BY_LINE);

DIFF_OPT_CLR(options, DIRSTAT_BY_FILE);

} else if (!strcmp(p, "files")) {

DIFF_OPT_CLR(options, DIRSTAT_BY_LINE);

DIFF_OPT_SET(options, DIRSTAT_BY_FILE);

} else if (!strcmp(p, "noncumulative")) {

DIFF_OPT_CLR(options, DIRSTAT_CUMULATIVE);

} else if (!strcmp(p, "cumulative")) {

DIFF_OPT_SET(options, DIRSTAT_CUMULATIVE);

} else if (isdigit(*p)) {

char *end;

int permille = strtoul(p, &end, 10) * 10;

if (*end == '.' && isdigit(*++end)) {

/* only use first digit */

permille += *end - '0';

/* .. and ignore any further digits */

while (isdigit(*++end))

; /* nothing */

}

if (!*end)

options->dirstat_permille = permille;

else {

strbuf_addf(errmsg, _(" Failed to parse dirstat cut-off percentage '%s'\n"),

p);

ret++;

}

} else {

strbuf_addf(errmsg, _(" Unknown dirstat parameter '%s'\n"), p);

ret++;

}

}

string_list_clear(&params, 0);

free(params_copy);

return ret;

}

static int parse_submodule_params(struct diff_options *options, const char *value)

{

if (!strcmp(value, "log"))

DIFF_OPT_SET(options, SUBMODULE_LOG);

else if (!strcmp(value, "short"))

DIFF_OPT_CLR(options, SUBMODULE_LOG);

else

return -1;

return 0;

}

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;

}

long parse_algorithm_value(const char *value)

{

if (!value)

return -1;

else if (!strcasecmp(value, "myers") || !strcasecmp(value, "default"))

return 0;

else if (!strcasecmp(value, "minimal"))

return XDF_NEED_MINIMAL;

else if (!strcasecmp(value, "patience"))

return XDF_PATIENCE_DIFF;

else if (!strcasecmp(value, "histogram"))

return XDF_HISTOGRAM_DIFF;

return -1;

}

/*

* 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);

return 0;

}

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

diff_context_default = git_config_int(var, value);

if (diff_context_default < 0)

return -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.noprefix")) {

diff_no_prefix = git_config_bool(var, value);

return 0;

}

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

diff_stat_graph_width = git_config_int(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);

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

return git_config_pathname(&diff_order_file_cfg, var, value);

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

handle_ignore_submodules_arg(&default_diff_options, value);

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

if (parse_submodule_params(&default_diff_options, value))

warning(_("Unknown value for 'diff.submodule' config variable: '%s'"),

value);

return 0;

}

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

diff_algorithm = parse_algorithm_value(value);

if (diff_algorithm < 0)

return -1;

return 0;

}

if (git_color_config(var, value, cb) < 0)

return -1;

return git_diff_basic_config(var, value, cb);

}

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

{

const char *name;

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

diff_rename_limit_default = git_config_int(var, value);

return 0;

}

if (userdiff_config(var, value) < 0)

return -1;

if (skip_prefix(var, "diff.color.", &name) ||

skip_prefix(var, "color.diff.", &name)) {

int slot = parse_diff_color_slot(name);

if (slot < 0)

return 0;

if (!value)

return config_error_nonbool(var);

return color_parse(value, diff_colors[slot]);

}

/* 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;

}

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

struct strbuf errmsg = STRBUF_INIT;

default_diff_options.dirstat_permille = diff_dirstat_permille_default;

if (parse_dirstat_params(&default_diff_options, value, &errmsg))

warning(_("Found errors in 'diff.dirstat' config variable:\n%s"),

errmsg.buf);

strbuf_release(&errmsg);

diff_dirstat_permille_default = default_diff_options.dirstat_permille;

return 0;

}

if (starts_with(var, "submodule."))

return parse_submodule_config_option(var, value);

return git_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;

}

/*

* Keep track of files used for diffing. Sometimes such an entry

* refers to a temporary file, sometimes to an existing file, and

* sometimes to "/dev/null".

*/

static struct diff_tempfile {

/*

* filename external diff should read from, or NULL if this

* entry is currently not in use:

*/

const char *name;

char hex[GIT_SHA1_HEXSZ + 1];

char mode[10];

/*

* If this diff_tempfile instance refers to a temporary file,

* this tempfile object is used to manage its lifetime.

*/

struct tempfile tempfile;

} 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;

struct diff_options *opt;

int *found_changesp;

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;

}

/* like fill_mmfile, but only for size, so we can avoid retrieving blob */

static unsigned long diff_filespec_size(struct diff_filespec *one)

{

if (!DIFF_FILE_VALID(one))

return 0;

diff_populate_filespec(one, CHECK_SIZE_ONLY);

return one->size;

}

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(struct diff_options *o, const char *set, const char *reset,

int first, const char *line, int len)

{

int has_trailing_newline, has_trailing_carriage_return;

int nofirst;

FILE *file = o->file;

fputs(diff_line_prefix(o), file);

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(struct diff_options *o, const char *set, const char *reset,

const char *line, int len)

{

emit_line_0(o, 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_line_checked(const char *reset,

struct emit_callback *ecbdata,

const char *line, int len,

enum color_diff color,

unsigned ws_error_highlight,

char sign)

{

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

const char *ws = NULL;

if (ecbdata->opt->ws_error_highlight & ws_error_highlight) {

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

if (!*ws)

ws = NULL;

}

if (!ws)

emit_line_0(ecbdata->opt, set, reset, sign, line, len);

else if (sign == '+' && new_blank_line_at_eof(ecbdata, line, len))

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

emit_line_0(ecbdata->opt, ws, reset, sign, line, len);

else {

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

emit_line_0(ecbdata->opt, set, reset, sign, "", 0);

ws_check_emit(line, len, ecbdata->ws_rule,

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

}

}

static void emit_add_line(const char *reset,

struct emit_callback *ecbdata,

const char *line, int len)

{

emit_line_checked(reset, ecbdata, line, len,

DIFF_FILE_NEW, WSEH_NEW, '+');

}

static void emit_del_line(const char *reset,

struct emit_callback *ecbdata,

const char *line, int len)

{

emit_line_checked(reset, ecbdata, line, len,

DIFF_FILE_OLD, WSEH_OLD, '-');

}

static void emit_context_line(const char *reset,

struct emit_callback *ecbdata,

const char *line, int len)

{

emit_line_checked(reset, ecbdata, line, len,

DIFF_CONTEXT, WSEH_CONTEXT, ' ');

}

static void emit_hunk_header(struct emit_callback *ecbdata,

const char *line, int len)

{

const char *context = diff_get_color(ecbdata->color_diff, DIFF_CONTEXT);

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;

struct strbuf msgbuf = STRBUF_INIT;

int org_len = len;

int i = 1;

/*

* 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->opt, context, reset, line, len);

return;

}

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

/* The hunk header in fraginfo color */

strbuf_addstr(&msgbuf, frag);

strbuf_add(&msgbuf, line, ep - line);

strbuf_addstr(&msgbuf, reset);

/*

* trailing "\r\n"

*/

for ( ; i < 3; i++)

if (line[len - i] == '\r' || line[len - i] == '\n')

len--;

/* blank before the func header */

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

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

break;

if (ep != cp) {

strbuf_addstr(&msgbuf, context);

strbuf_add(&msgbuf, cp, ep - cp);

strbuf_addstr(&msgbuf, reset);

}

if (ep < line + len) {

strbuf_addstr(&msgbuf, func);

strbuf_add(&msgbuf, ep, line + len - ep);

strbuf_addstr(&msgbuf, reset);

}

strbuf_add(&msgbuf, line + len, org_len - len);

emit_line(ecbdata->opt, "", "", msgbuf.buf, msgbuf.len);

strbuf_release(&msgbuf);

}

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 void remove_tempfile(void)

{

int i;

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

if (is_tempfile_active(&diff_temp[i].tempfile))

delete_tempfile(&diff_temp[i].tempfile);

diff_temp[i].name = NULL;

}

}

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 *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_del_line(reset, ecb, data, len);

} else {

ecb->lno_in_postimage++;

emit_add_line(reset, ecb, data, len);

}

size -= len;

data += len;

}

if (!endp) {

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

DIFF_CONTEXT);

putc('\n', ecb->opt->file);

emit_line_0(ecb->opt, context, 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;

const char *name_a_tab, *name_b_tab;

const char *metainfo = diff_get_color(o->use_color, DIFF_METAINFO);

const char *fraginfo = diff_get_color(o->use_color, DIFF_FRAGINFO);

const char *reset = diff_get_color(o->use_color, 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;

const char *line_prefix = diff_line_prefix(o);

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 = want_color(o->use_color);

ecbdata.found_changesp = &o->found_changes;

ecbdata.ws_rule = whitespace_rule(name_b);

ecbdata.opt = o;

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%s\n%s%s+++ %s%s%s\n%s%s@@ -",

line_prefix, metainfo, a_name.buf, name_a_tab, reset,

line_prefix, metainfo, b_name.buf, name_b_tab, reset,

line_prefix, fraginfo);

if (!o->irreversible_delete)

print_line_count(o->file, lc_a);

else

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

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

print_line_count(o->file, lc_b);

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

if (lc_a && !o->irreversible_delete)

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;

};

static 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;

int last_minus;

struct diff_options *opt;

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,

const char *line_prefix)

{

int print = 0;

while (count) {

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

if (print)

fputs(line_prefix, fp);

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;

print = 1;

}

return 0;

}

/*

* '--color-words' algorithm can be described as:

*

* 1. collect a the minus/plus lines of a diff hunk, divided into

* minus-lines and plus-lines;

*

* 2. break both minus-lines and plus-lines into words and

* place them into two mmfile_t with one word for each line;

*

* 3. use xdiff to run diff on the two mmfile_t to get the words level diff;

*

* And for the common parts of the both file, we output the plus side text.

* diff_words->current_plus is used to trace the current position of the plus file

* which printed. diff_words->last_minus is used to trace the last minus word

* printed.

*

* For '--graph' to work with '--color-words', we need to output the graph prefix

* on each line of color words output. Generally, there are two conditions on

* which we should output the prefix.

*

* 1. diff_words->last_minus == 0 &&

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

*

* that is: the plus text must start as a new line, and if there is no minus

* word printed, a graph prefix must be printed.

*

* 2. diff_words->current_plus > diff_words->plus.text.ptr &&

* *(diff_words->current_plus - 1) == '\n'

*

* that is: a graph prefix must be printed following a '\n'

*/

static int color_words_output_graph_prefix(struct diff_words_data *diff_words)

{

if ((diff_words->last_minus == 0 &&

diff_words->current_plus == diff_words->plus.text.ptr) ||

(diff_words->current_plus > diff_words->plus.text.ptr &&

*(diff_words->current_plus - 1) == '\n')) {

return 1;

} else {

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;

struct diff_options *opt = diff_words->opt;

const char *line_prefix;

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

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

return;

assert(opt);

line_prefix = diff_line_prefix(opt);

/* 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 (color_words_output_graph_prefix(diff_words)) {

fputs(line_prefix, diff_words->opt->file);

}

if (diff_words->current_plus != plus_begin) {

fn_out_diff_words_write_helper(diff_words->opt->file,

&style->ctx, style->newline,

plus_begin - diff_words->current_plus,

diff_words->current_plus, line_prefix);

if (*(plus_begin - 1) == '\n')

fputs(line_prefix, diff_words->opt->file);

}

if (minus_begin != minus_end) {

fn_out_diff_words_write_helper(diff_words->opt->file,

&style->old, style->newline,

minus_end - minus_begin, minus_begin,

line_prefix);

}

if (plus_begin != plus_end) {

fn_out_diff_words_write_helper(diff_words->opt->file,

&style->new, style->newline,

plus_end - plus_begin, plus_begin,

line_prefix);

}

diff_words->current_plus = plus_end;

diff_words->last_minus = minus_first;

}

/* 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);