From: Junio C Hamano <gitster@pobox.com>
Date: Fri, 21 May 2010 11:02:17 +0000 (-0700)
Subject: Merge branch 'tr/word-diff'
X-Git-Tag: v1.7.2-rc0~124
X-Git-Url: https://git.lorimer.id.au/gitweb.git/diff_plain/1bdd46cd3a2fe1e0aeb965fb0edb493064e24495?ds=inline;hp=-c

Merge branch 'tr/word-diff'

* tr/word-diff:
diff: add --word-diff option that generalizes --color-words

Conflicts:
diff.c
---

1bdd46cd3a2fe1e0aeb965fb0edb493064e24495
diff --combined Documentation/diff-options.txt
index 4a968591cb,a616ca589f..0d89aaaf2a
--- a/Documentation/diff-options.txt
+++ b/Documentation/diff-options.txt
@@@ -21,7 -21,6 +21,7 @@@ endif::git-format-patch[
  ifndef::git-format-patch[]
  -p::
  -u::
 +--patch::
  	Generate patch (see section on generating patches).
  	{git-diff? This is the default.}
  endif::git-format-patch[]
@@@ -95,8 -94,8 +95,8 @@@ Also, when `--raw` or `--numstat` has b
  pathnames and use NULs as output field terminators.
  endif::git-log[]
  ifndef::git-log[]
 -	When `--raw` or `--numstat` has been given, do not munge
 -	pathnames and use NULs as output field terminators.
 +	When `--raw`, `--numstat`, `--name-only` or `--name-status` has been
 +	given, do not munge pathnames and use NULs as output field terminators.
  endif::git-log[]
  +
  Without this option, each pathname output will have TAB, LF, double quotes,
@@@ -127,11 -126,39 +127,39 @@@ any of those replacements occurred
  	gives the default to color output.
  	Same as `--color=never`.
  
- --color-words[=<regex>]::
- 	Show colored word diff, i.e., color words which have changed.
- 	By default, words are separated by whitespace.
+ --word-diff[=<mode>]::
+ 	Show a word diff, using the <mode> to delimit changed words.
+ 	By default, words are delimited by whitespace; see
+ 	`--word-diff-regex` below.  The <mode> defaults to 'plain', and
+ 	must be one of:
+ +
+ --
+ color::
+ 	Highlight changed words using only colors.  Implies `--color`.
+ plain::
+ 	Show words as `[-removed-]` and `{+added+}`.  Makes no
+ 	attempts to escape the delimiters if they appear in the input,
+ 	so the output may be ambiguous.
+ porcelain::
+ 	Use a special line-based format intended for script
+ 	consumption.  Added/removed/unchanged runs are printed in the
+ 	usual unified diff format, starting with a `+`/`-`/` `
+ 	character at the beginning of the line and extending to the
+ 	end of the line.  Newlines in the input are represented by a
+ 	tilde `~` on a line of its own.
+ none::
+ 	Disable word diff again.
+ --
+ +
+ Note that despite the name of the first mode, color is used to
+ highlight the changed parts in all modes if enabled.
+ 
+ --word-diff-regex=<regex>::
+ 	Use <regex> to decide what a word is, instead of considering
+ 	runs of non-whitespace to be a word.  Also implies
+ 	`--word-diff` unless it was already enabled.
  +
- When a <regex> is specified, every non-overlapping match of the
+ Every non-overlapping match of the
  <regex> is considered a word.  Anything between these matches is
  considered whitespace and ignored(!) for the purposes of finding
  differences.  You may want to append `|[^[:space:]]` to your regular
@@@ -143,6 -170,10 +171,10 @@@ The regex can also be set via a diff dr
  linkgit:gitattributes[1] or linkgit:git-config[1].  Giving it explicitly
  overrides any diff driver or configuration setting.  Diff drivers
  override configuration settings.
+ 
+ --color-words[=<regex>]::
+ 	Equivalent to `--word-diff=color` plus (if a regex was
+ 	specified) `--word-diff-regex=<regex>`.
  endif::git-format-patch[]
  
  --no-renames::
diff --combined Documentation/gitattributes.txt
index a8500d1772,7554fcd07f..0523a57698
--- a/Documentation/gitattributes.txt
+++ b/Documentation/gitattributes.txt
@@@ -360,7 -360,7 +360,7 @@@ patterns are available
  Customizing word diff
  ^^^^^^^^^^^^^^^^^^^^^
  
- You can customize the rules that `git diff --color-words` uses to
+ You can customize the rules that `git diff --word-diff` uses to
  split words in a line, by specifying an appropriate regular expression
  in the "diff.*.wordRegex" configuration variable.  For example, in TeX
  a backslash followed by a sequence of letters forms a command, but
@@@ -414,26 -414,6 +414,26 @@@ because it quickly conveys the changes 
  should generate it separately and send it as a comment _in
  addition to_ the usual binary diff that you might send.
  
 +Because text conversion can be slow, especially when doing a
 +large number of them with `git log -p`, git provides a mechanism
 +to cache the output and use it in future diffs.  To enable
 +caching, set the "cachetextconv" variable in your diff driver's
 +config. For example:
 +
 +------------------------
 +[diff "jpg"]
 +	textconv = exif
 +	cachetextconv = true
 +------------------------
 +
 +This will cache the result of running "exif" on each blob
 +indefinitely. If you change the textconv config variable for a
 +diff driver, git will automatically invalidate the cache entries
 +and re-run the textconv filter. If you want to invalidate the
 +cache manually (e.g., because your version of "exif" was updated
 +and now produces better output), you can remove the cache
 +manually with `git update-ref -d refs/notes/textconv/jpg` (where
 +"jpg" is the name of the diff driver, as in the example above).
  
  Performing a three-way merge
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
diff --combined diff.c
index 43a313deba,d81a57a3c4..502b301670
--- a/diff.c
+++ b/diff.c
@@@ -14,7 -14,6 +14,7 @@@
  #include "userdiff.h"
  #include "sigchain.h"
  #include "submodule.h"
 +#include "ll-merge.h"
  
  #ifdef NO_FAST_WORKING_DIRECTORY
  #define FAST_WORKING_DIRECTORY 0
@@@ -44,8 -43,7 +44,8 @@@ static char diff_colors[][COLOR_MAXLEN
  };
  
  static void diff_filespec_load_driver(struct diff_filespec *one);
 -static char *run_textconv(const char *, struct diff_filespec *, size_t *);
 +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)
  {
@@@ -467,8 -465,8 +467,8 @@@ static void emit_rewrite_diff(const cha
  			      const char *name_b,
  			      struct diff_filespec *one,
  			      struct diff_filespec *two,
 -			      const char *textconv_one,
 -			      const char *textconv_two,
 +			      struct userdiff_driver *textconv_one,
 +			      struct userdiff_driver *textconv_two,
  			      struct diff_options *o)
  {
  	int lc_a, lc_b;
@@@ -479,7 -477,7 +479,7 @@@
  	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;
 -	const char *data_one, *data_two;
 +	char *data_one, *data_two;
  	size_t size_one, size_two;
  	struct emit_callback ecbdata;
  
@@@ -501,8 -499,26 +501,8 @@@
  	quote_two_c_style(&a_name, a_prefix, name_a, 0);
  	quote_two_c_style(&b_name, b_prefix, name_b, 0);
  
 -	diff_populate_filespec(one, 0);
 -	diff_populate_filespec(two, 0);
 -	if (textconv_one) {
 -		data_one = run_textconv(textconv_one, one, &size_one);
 -		if (!data_one)
 -			die("unable to read files to diff");
 -	}
 -	else {
 -		data_one = one->data;
 -		size_one = one->size;
 -	}
 -	if (textconv_two) {
 -		data_two = run_textconv(textconv_two, two, &size_two);
 -		if (!data_two)
 -			die("unable to read files to diff");
 -	}
 -	else {
 -		data_two = two->data;
 -		size_two = two->size;
 -	}
 +	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;
@@@ -534,10 -550,6 +534,10 @@@
  		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 {
@@@ -560,16 -572,68 +560,68 @@@ static void diff_words_append(char *lin
  	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;
  
@@@ -593,16 -657,17 +645,17 @@@
  		plus_begin = plus_end = diff_words->plus.orig[plus_first].end;
  
  	if (diff_words->current_plus != plus_begin)
- 		fwrite(diff_words->current_plus,
- 				plus_begin - diff_words->current_plus, 1,
- 				diff_words->file);
+ 		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)
- 		color_fwrite_lines(diff_words->file,
- 				diff_get_color(1, DIFF_FILE_OLD),
+ 		fn_out_diff_words_write_helper(diff_words->file,
+ 				&style->old, style->newline,
  				minus_end - minus_begin, minus_begin);
  	if (plus_begin != plus_end)
- 		color_fwrite_lines(diff_words->file,
- 				diff_get_color(1, DIFF_FILE_NEW),
+ 		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;
@@@ -683,12 -748,14 +736,13 @@@ static void diff_words_show(struct diff
  {
  	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) {
- 		color_fwrite_lines(diff_words->file,
- 			diff_get_color(1, DIFF_FILE_OLD),
+ 		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;
@@@ -704,15 -771,15 +758,15 @@@
  	/* 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);
 +		      &xpp, &xecfg);
  	free(minus.ptr);
  	free(plus.ptr);
  	if (diff_words->current_plus != diff_words->plus.text.ptr +
  			diff_words->plus.text.size)
- 		fwrite(diff_words->current_plus,
+ 		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, 1,
- 			diff_words->file);
+ 			- diff_words->current_plus, diff_words->current_plus);
  	diff_words->minus.text.size = diff_words->plus.text.size = 0;
  }
  
@@@ -824,6 -891,9 +878,9 @@@ static void fn_out_consume(void *priv, 
  
  	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;
  	}
  
@@@ -838,9 -908,13 +895,13 @@@
  			return;
  		}
  		diff_words_flush(ecbdata);
- 		line++;
- 		len--;
- 		emit_line(ecbdata->file, plain, reset, line, len);
+ 		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;
  	}
  
@@@ -935,7 -1009,7 +996,7 @@@ struct diffstat_t 
  		unsigned is_unmerged:1;
  		unsigned is_binary:1;
  		unsigned is_renamed:1;
 -		unsigned int added, deleted;
 +		uintmax_t added, deleted;
  	} **files;
  };
  
@@@ -1027,7 -1101,7 +1088,7 @@@ static void fill_print_name(struct diff
  static void show_stats(struct diffstat_t *data, struct diff_options *options)
  {
  	int i, len, add, del, adds = 0, dels = 0;
 -	int max_change = 0, max_len = 0;
 +	uintmax_t max_change = 0, max_len = 0;
  	int total_files = data->nr;
  	int width, name_width;
  	const char *reset, *set, *add_c, *del_c;
@@@ -1056,7 -1130,7 +1117,7 @@@
  
  	for (i = 0; i < data->nr; i++) {
  		struct diffstat_file *file = data->files[i];
 -		int change = file->added + file->deleted;
 +		uintmax_t change = file->added + file->deleted;
  		fill_print_name(file);
  		len = strlen(file->print_name);
  		if (max_len < len)
@@@ -1084,8 -1158,8 +1145,8 @@@
  	for (i = 0; i < data->nr; i++) {
  		const char *prefix = "";
  		char *name = data->files[i]->print_name;
 -		int added = data->files[i]->added;
 -		int deleted = data->files[i]->deleted;
 +		uintmax_t added = data->files[i]->added;
 +		uintmax_t deleted = data->files[i]->deleted;
  		int name_len;
  
  		/*
@@@ -1106,11 -1180,9 +1167,11 @@@
  		if (data->files[i]->is_binary) {
  			show_name(options->file, prefix, name, len);
  			fprintf(options->file, "  Bin ");
 -			fprintf(options->file, "%s%d%s", del_c, deleted, reset);
 +			fprintf(options->file, "%s%"PRIuMAX"%s",
 +				del_c, deleted, reset);
  			fprintf(options->file, " -> ");
 -			fprintf(options->file, "%s%d%s", add_c, added, reset);
 +			fprintf(options->file, "%s%"PRIuMAX"%s",
 +				add_c, added, reset);
  			fprintf(options->file, " bytes");
  			fprintf(options->file, "\n");
  			continue;
@@@ -1139,7 -1211,7 +1200,7 @@@
  			del = scale_linear(del, width, max_change);
  		}
  		show_name(options->file, prefix, name, len);
 -		fprintf(options->file, "%5d%s", added + deleted,
 +		fprintf(options->file, "%5"PRIuMAX"%s", added + deleted,
  				added + deleted ? " " : "");
  		show_graph(options->file, '+', add, add_c, reset);
  		show_graph(options->file, '-', del, del_c, reset);
@@@ -1189,8 -1261,7 +1250,8 @@@ static void show_numstat(struct diffsta
  			fprintf(options->file, "-\t-\t");
  		else
  			fprintf(options->file,
 -				"%d\t%d\t", file->added, file->deleted);
 +				"%"PRIuMAX"\t%"PRIuMAX"\t",
 +				file->added, file->deleted);
  		if (options->line_termination) {
  			fill_print_name(file);
  			if (!file->is_renamed)
@@@ -1360,32 -1431,37 +1421,32 @@@ static void free_diffstat_info(struct d
  struct checkdiff_t {
  	const char *filename;
  	int lineno;
 +	int conflict_marker_size;
  	struct diff_options *o;
  	unsigned ws_rule;
  	unsigned status;
  };
  
 -static int is_conflict_marker(const char *line, unsigned long len)
 +static int is_conflict_marker(const char *line, int marker_size, unsigned long len)
  {
  	char firstchar;
  	int cnt;
  
 -	if (len < 8)
 +	if (len < marker_size + 1)
  		return 0;
  	firstchar = line[0];
  	switch (firstchar) {
 -	case '=': case '>': case '<':
 +	case '=': case '>': case '<': case '|':
  		break;
  	default:
  		return 0;
  	}
 -	for (cnt = 1; cnt < 7; cnt++)
 +	for (cnt = 1; cnt < marker_size; cnt++)
  		if (line[cnt] != firstchar)
  			return 0;
 -	/* line[0] thru line[6] are same as firstchar */
 -	if (firstchar == '=') {
 -		/* divider between ours and theirs? */
 -		if (len != 8 || line[7] != '\n')
 -			return 0;
 -	} else if (len < 8 || !isspace(line[7])) {
 -		/* not divider before ours nor after theirs */
 +	/* line[1] thru line[marker_size-1] are same as firstchar */
 +	if (len < marker_size + 1 || !isspace(line[marker_size]))
  		return 0;
 -	}
  	return 1;
  }
  
@@@ -1393,7 -1469,6 +1454,7 @@@ static void checkdiff_consume(void *pri
  {
  	struct checkdiff_t *data = priv;
  	int color_diff = DIFF_OPT_TST(data->o, COLOR_DIFF);
 +	int marker_size = data->conflict_marker_size;
  	const char *ws = diff_get_color(color_diff, DIFF_WHITESPACE);
  	const char *reset = diff_get_color(color_diff, DIFF_RESET);
  	const char *set = diff_get_color(color_diff, DIFF_FILE_NEW);
@@@ -1402,7 -1477,7 +1463,7 @@@
  	if (line[0] == '+') {
  		unsigned bad;
  		data->lineno++;
 -		if (is_conflict_marker(line + 1, len - 1)) {
 +		if (is_conflict_marker(line + 1, marker_size, len - 1)) {
  			data->status |= 1;
  			fprintf(data->o->file,
  				"%s:%d: leftover conflict marker\n",
@@@ -1568,26 -1643,14 +1629,26 @@@ void diff_set_mnemonic_prefix(struct di
  		options->b_prefix = b;
  }
  
 -static const char *get_textconv(struct diff_filespec *one)
 +static struct userdiff_driver *get_textconv(struct diff_filespec *one)
  {
  	if (!DIFF_FILE_VALID(one))
  		return NULL;
  	if (!S_ISREG(one->mode))
  		return NULL;
  	diff_filespec_load_driver(one);
 -	return one->driver->textconv;
 +	if (!one->driver->textconv)
 +		return NULL;
 +
 +	if (one->driver->textconv_want_cache && !one->driver->textconv_cache) {
 +		struct notes_cache *c = xmalloc(sizeof(*c));
 +		struct strbuf name = STRBUF_INIT;
 +
 +		strbuf_addf(&name, "textconv/%s", one->driver->name);
 +		notes_cache_init(c, name.buf, one->driver->textconv);
 +		one->driver->textconv_cache = c;
 +	}
 +
 +	return one->driver;
  }
  
  static void builtin_diff(const char *name_a,
@@@ -1604,8 -1667,7 +1665,8 @@@
  	const char *set = diff_get_color_opt(o, DIFF_METAINFO);
  	const char *reset = diff_get_color_opt(o, DIFF_RESET);
  	const char *a_prefix, *b_prefix;
 -	const char *textconv_one = NULL, *textconv_two = NULL;
 +	struct userdiff_driver *textconv_one = NULL;
 +	struct userdiff_driver *textconv_two = NULL;
  	struct strbuf header = STRBUF_INIT;
  
  	if (DIFF_OPT_TST(o, SUBMODULE_LOG) &&
@@@ -1679,11 -1741,12 +1740,11 @@@
  		}
  	}
  
 -	if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
 -		die("unable to read files to diff");
 -
  	if (!DIFF_OPT_TST(o, TEXT) &&
 -	    ( (diff_filespec_is_binary(one) && !textconv_one) ||
 -	      (diff_filespec_is_binary(two) && !textconv_two) )) {
 +	    ( (!textconv_one && diff_filespec_is_binary(one)) ||
 +	      (!textconv_two && diff_filespec_is_binary(two)) )) {
 +		if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
 +			die("unable to read files to diff");
  		/* Quite common confusing case */
  		if (mf1.size == mf2.size &&
  		    !memcmp(mf1.ptr, mf2.ptr, mf1.size))
@@@ -1702,6 -1765,7 +1763,6 @@@
  		const char *diffopts = getenv("GIT_DIFF_OPTS");
  		xpparam_t xpp;
  		xdemitconf_t xecfg;
 -		xdemitcb_t ecb;
  		struct emit_callback ecbdata;
  		const struct userdiff_funcname *pe;
  
@@@ -1710,8 -1774,20 +1771,8 @@@
  			strbuf_reset(&header);
  		}
  
 -		if (textconv_one) {
 -			size_t size;
 -			mf1.ptr = run_textconv(textconv_one, one, &size);
 -			if (!mf1.ptr)
 -				die("unable to read files to diff");
 -			mf1.size = size;
 -		}
 -		if (textconv_two) {
 -			size_t size;
 -			mf2.ptr = run_textconv(textconv_two, two, &size);
 -			if (!mf2.ptr)
 -				die("unable to read files to diff");
 -			mf2.size = size;
 -		}
 +		mf1.size = fill_textconv(textconv_one, one, &mf1.ptr);
 +		mf2.size = fill_textconv(textconv_two, two, &mf2.ptr);
  
  		pe = diff_funcname_pattern(one);
  		if (!pe)
@@@ -1740,10 -1816,13 +1801,13 @@@
  			xecfg.ctxlen = strtoul(diffopts + 10, NULL, 10);
  		else if (!prefixcmp(diffopts, "-u"))
  			xecfg.ctxlen = strtoul(diffopts + 2, NULL, 10);
- 		if (DIFF_OPT_TST(o, COLOR_DIFF_WORDS)) {
+ 		if (o->word_diff) {
+ 			int i;
+ 
  			ecbdata.diff_words =
  				xcalloc(1, sizeof(struct diff_words_data));
  			ecbdata.diff_words->file = o->file;
+ 			ecbdata.diff_words->type = o->word_diff;
  			if (!o->word_regex)
  				o->word_regex = userdiff_word_regex(one);
  			if (!o->word_regex)
@@@ -1759,10 -1838,23 +1823,23 @@@
  					die ("Invalid regular expression: %s",
  							o->word_regex);
  			}
+ 			for (i = 0; i < ARRAY_SIZE(diff_words_styles); i++) {
+ 				if (o->word_diff == diff_words_styles[i].type) {
+ 					ecbdata.diff_words->style =
+ 						&diff_words_styles[i];
+ 					break;
+ 				}
+ 			}
+ 			if (DIFF_OPT_TST(o, COLOR_DIFF)) {
+ 				struct diff_words_style *st = ecbdata.diff_words->style;
+ 				st->old.color = diff_get_color_opt(o, DIFF_FILE_OLD);
+ 				st->new.color = diff_get_color_opt(o, DIFF_FILE_NEW);
+ 				st->ctx.color = diff_get_color_opt(o, DIFF_PLAIN);
+ 			}
  		}
  		xdi_diff_outf(&mf1, &mf2, fn_out_consume, &ecbdata,
 -			      &xpp, &xecfg, &ecb);
 +			      &xpp, &xecfg);
- 		if (DIFF_OPT_TST(o, COLOR_DIFF_WORDS))
+ 		if (o->word_diff)
  			free_diff_words_data(&ecbdata);
  		if (textconv_one)
  			free(mf1.ptr);
@@@ -1814,12 -1906,13 +1891,12 @@@ static void builtin_diffstat(const cha
  		/* Crazy xdl interfaces.. */
  		xpparam_t xpp;
  		xdemitconf_t xecfg;
 -		xdemitcb_t ecb;
  
  		memset(&xpp, 0, sizeof(xpp));
  		memset(&xecfg, 0, sizeof(xecfg));
  		xpp.flags = XDF_NEED_MINIMAL | o->xdl_opts;
  		xdi_diff_outf(&mf1, &mf2, diffstat_consume, diffstat,
 -			      &xpp, &xecfg, &ecb);
 +			      &xpp, &xecfg);
  	}
  
   free_and_return:
@@@ -1844,7 -1937,6 +1921,7 @@@ static void builtin_checkdiff(const cha
  	data.lineno = 0;
  	data.o = o;
  	data.ws_rule = whitespace_rule(attr_path);
 +	data.conflict_marker_size = ll_merge_marker_size(attr_path);
  
  	if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
  		die("unable to read files to diff");
@@@ -1861,13 -1953,14 +1938,13 @@@
  		/* Crazy xdl interfaces.. */
  		xpparam_t xpp;
  		xdemitconf_t xecfg;
 -		xdemitcb_t ecb;
  
  		memset(&xpp, 0, sizeof(xpp));
  		memset(&xecfg, 0, sizeof(xecfg));
  		xecfg.ctxlen = 1; /* at least one context line */
  		xpp.flags = XDF_NEED_MINIMAL;
  		xdi_diff_outf(&mf1, &mf2, checkdiff_consume, &data,
 -			      &xpp, &xecfg, &ecb);
 +			      &xpp, &xecfg);
  
  		if (data.ws_rule & WS_BLANK_AT_EOF) {
  			struct emit_callback ecbdata;
@@@ -2701,7 -2794,7 +2778,7 @@@ int diff_opt_parse(struct diff_options 
  	const char *arg = av[0];
  
  	/* Output format options */
 -	if (!strcmp(arg, "-p") || !strcmp(arg, "-u"))
 +	if (!strcmp(arg, "-p") || !strcmp(arg, "-u") || !strcmp(arg, "--patch"))
  		options->output_format |= DIFF_FORMAT_PATCH;
  	else if (opt_arg(arg, 'U', "unified", &options->context))
  		options->output_format |= DIFF_FORMAT_PATCH;
@@@ -2829,13 -2922,37 +2906,37 @@@
  		DIFF_OPT_CLR(options, COLOR_DIFF);
  	else if (!strcmp(arg, "--color-words")) {
  		DIFF_OPT_SET(options, COLOR_DIFF);
- 		DIFF_OPT_SET(options, COLOR_DIFF_WORDS);
+ 		options->word_diff = DIFF_WORDS_COLOR;
  	}
  	else if (!prefixcmp(arg, "--color-words=")) {
  		DIFF_OPT_SET(options, COLOR_DIFF);
- 		DIFF_OPT_SET(options, COLOR_DIFF_WORDS);
+ 		options->word_diff = DIFF_WORDS_COLOR;
  		options->word_regex = arg + 14;
  	}
+ 	else if (!strcmp(arg, "--word-diff")) {
+ 		if (options->word_diff == DIFF_WORDS_NONE)
+ 			options->word_diff = DIFF_WORDS_PLAIN;
+ 	}
+ 	else if (!prefixcmp(arg, "--word-diff=")) {
+ 		const char *type = arg + 12;
+ 		if (!strcmp(type, "plain"))
+ 			options->word_diff = DIFF_WORDS_PLAIN;
+ 		else if (!strcmp(type, "color")) {
+ 			DIFF_OPT_SET(options, COLOR_DIFF);
+ 			options->word_diff = DIFF_WORDS_COLOR;
+ 		}
+ 		else if (!strcmp(type, "porcelain"))
+ 			options->word_diff = DIFF_WORDS_PORCELAIN;
+ 		else if (!strcmp(type, "none"))
+ 			options->word_diff = DIFF_WORDS_NONE;
+ 		else
+ 			die("bad --word-diff argument: %s", type);
+ 	}
+ 	else if (!prefixcmp(arg, "--word-diff-regex=")) {
+ 		if (options->word_diff == DIFF_WORDS_NONE)
+ 			options->word_diff = DIFF_WORDS_PLAIN;
+ 		options->word_regex = arg + 18;
+ 	}
  	else if (!strcmp(arg, "--exit-code"))
  		DIFF_OPT_SET(options, EXIT_WITH_STATUS);
  	else if (!strcmp(arg, "--quiet"))
@@@ -3362,6 -3479,7 +3463,6 @@@ static int diff_get_patch_id(struct dif
  	for (i = 0; i < q->nr; i++) {
  		xpparam_t xpp;
  		xdemitconf_t xecfg;
 -		xdemitcb_t ecb;
  		mmfile_t mf1, mf2;
  		struct diff_filepair *p = q->queue[i];
  		int len1, len2;
@@@ -3423,7 -3541,7 +3524,7 @@@
  		xecfg.ctxlen = 3;
  		xecfg.flags = XDL_EMIT_FUNCNAMES;
  		xdi_diff_outf(&mf1, &mf2, patch_id_consume, &data,
 -			      &xpp, &xecfg, &ecb);
 +			      &xpp, &xecfg);
  	}
  
  	git_SHA1_Final(sha1, &ctx);
@@@ -3895,47 -4013,3 +3996,47 @@@ static char *run_textconv(const char *p
  
  	return strbuf_detach(&buf, outsize);
  }
 +
 +static size_t fill_textconv(struct userdiff_driver *driver,
 +			    struct diff_filespec *df,
 +			    char **outbuf)
 +{
 +	size_t size;
 +
 +	if (!driver || !driver->textconv) {
 +		if (!DIFF_FILE_VALID(df)) {
 +			*outbuf = "";
 +			return 0;
 +		}
 +		if (diff_populate_filespec(df, 0))
 +			die("unable to read files to diff");
 +		*outbuf = df->data;
 +		return df->size;
 +	}
 +
 +	if (driver->textconv_cache) {
 +		*outbuf = notes_cache_get(driver->textconv_cache, df->sha1,
 +					  &size);
 +		if (*outbuf)
 +			return size;
 +	}
 +
 +	*outbuf = run_textconv(driver->textconv, df, &size);
 +	if (!*outbuf)
 +		die("unable to read files to diff");
 +
 +	if (driver->textconv_cache) {
 +		/* ignore errors, as we might be in a readonly repository */
 +		notes_cache_put(driver->textconv_cache, df->sha1, *outbuf,
 +				size);
 +		/*
 +		 * we could save up changes and flush them all at the end,
 +		 * but we would need an extra call after all diffing is done.
 +		 * Since generating a cache entry is the slow path anyway,
 +		 * this extra overhead probably isn't a big deal.
 +		 */
 +		notes_cache_write(driver->textconv_cache);
 +	}
 +
 +	return size;
 +}