2006-04-22 08:57:45 +02:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2005 Junio C Hamano
|
|
|
|
*/
|
|
|
|
#include "cache.h"
|
|
|
|
#include "quote.h"
|
|
|
|
#include "diff.h"
|
|
|
|
#include "diffcore.h"
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
#include "delta.h"
|
2006-04-22 08:57:45 +02:00
|
|
|
#include "xdiff-interface.h"
|
2006-09-08 10:03:18 +02:00
|
|
|
#include "color.h"
|
2007-04-13 08:05:29 +02:00
|
|
|
#include "attr.h"
|
2007-10-19 21:47:56 +02:00
|
|
|
#include "run-command.h"
|
2008-01-02 10:50:11 +01:00
|
|
|
#include "utf8.h"
|
2006-04-22 08:57:45 +02:00
|
|
|
|
2006-12-14 12:15:57 +01:00
|
|
|
#ifdef NO_FAST_WORKING_DIRECTORY
|
|
|
|
#define FAST_WORKING_DIRECTORY 0
|
|
|
|
#else
|
|
|
|
#define FAST_WORKING_DIRECTORY 1
|
|
|
|
#endif
|
|
|
|
|
2006-08-15 19:23:48 +02:00
|
|
|
static int diff_detect_rename_default;
|
Fix the rename detection limit checking
This adds more proper rename detection limits. Instead of just checking
the limit against the number of potential rename destinations, we verify
that the rename matrix (which is what really matters) doesn't grow
ridiculously large, and we also make sure that we don't overflow when
doing the matrix size calculation.
This also changes the default limits from unlimited, to a rename matrix
that is limited to 100 entries on a side. You can raise it with the config
entry, or by using the "-l<n>" command line flag, but at least the default
is now a sane number that avoids spending lots of time (and memory) in
situations that likely don't merit it.
The choice of default value is of course very debatable. Limiting the
rename matrix to a 100x100 size will mean that even if you have just one
obvious rename, but you also create (or delete) 10,000 files, the rename
matrix will be so big that we disable the heuristics. Sounds reasonable to
me, but let's see if people hit this (and, perhaps more importantly,
actually *care*) in real life.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-09-14 19:39:48 +02:00
|
|
|
static int diff_rename_limit_default = 100;
|
2006-08-15 19:23:48 +02:00
|
|
|
static int diff_use_color_default;
|
2007-12-17 14:42:20 +01:00
|
|
|
static const char *external_diff_cmd_cfg;
|
2007-08-31 22:13:42 +02:00
|
|
|
int diff_auto_refresh_index = 1;
|
2006-04-22 08:57:45 +02:00
|
|
|
|
2006-09-08 10:03:18 +02:00
|
|
|
static char diff_colors[][COLOR_MAXLEN] = {
|
2006-07-13 18:06:12 +02:00
|
|
|
"\033[m", /* reset */
|
2006-09-23 07:48:39 +02:00
|
|
|
"", /* PLAIN (normal) */
|
|
|
|
"\033[1m", /* METAINFO (bold) */
|
|
|
|
"\033[36m", /* FRAGINFO (cyan) */
|
|
|
|
"\033[31m", /* OLD (red) */
|
|
|
|
"\033[32m", /* NEW (green) */
|
|
|
|
"\033[33m", /* COMMIT (yellow) */
|
|
|
|
"\033[41m", /* WHITESPACE (red background) */
|
2006-06-13 18:45:44 +02:00
|
|
|
};
|
|
|
|
|
diff --color: use $GIT_DIR/config
This lets you use something like this in your $GIT_DIR/config
file.
[diff]
color = auto
[diff.color]
new = blue
old = yellow
frag = reverse
When diff.color is set to "auto", colored diff is enabled when
the standard output is the terminal. Other choices are "always",
and "never". Usual boolean true/false can also be used.
The colormap entries can specify colors for the following slots:
plain - lines that appear in both old and new file (context)
meta - diff --git header and extended git diff headers
frag - @@ -n,m +l,k @@ lines (hunk header)
old - lines deleted from old file
new - lines added to new file
The following color names can be used:
normal, bold, dim, l, blink, reverse, reset,
black, red, green, yellow, blue, magenta, cyan,
white
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-24 13:06:23 +02:00
|
|
|
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;
|
2006-07-23 11:24:18 +02:00
|
|
|
if (!strcasecmp(var+ofs, "commit"))
|
|
|
|
return DIFF_COMMIT;
|
2006-09-23 07:48:39 +02:00
|
|
|
if (!strcasecmp(var+ofs, "whitespace"))
|
|
|
|
return DIFF_WHITESPACE;
|
diff --color: use $GIT_DIR/config
This lets you use something like this in your $GIT_DIR/config
file.
[diff]
color = auto
[diff.color]
new = blue
old = yellow
frag = reverse
When diff.color is set to "auto", colored diff is enabled when
the standard output is the terminal. Other choices are "always",
and "never". Usual boolean true/false can also be used.
The colormap entries can specify colors for the following slots:
plain - lines that appear in both old and new file (context)
meta - diff --git header and extended git diff headers
frag - @@ -n,m +l,k @@ lines (hunk header)
old - lines deleted from old file
new - lines added to new file
The following color names can be used:
normal, bold, dim, l, blink, reverse, reset,
black, red, green, yellow, blue, magenta, cyan,
white
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-24 13:06:23 +02:00
|
|
|
die("bad config variable '%s'", var);
|
|
|
|
}
|
|
|
|
|
2007-04-23 02:52:55 +02:00
|
|
|
static struct ll_diff_driver {
|
|
|
|
const char *name;
|
|
|
|
struct ll_diff_driver *next;
|
|
|
|
char *cmd;
|
|
|
|
} *user_diff, **user_diff_tail;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Currently there is only "diff.<drivername>.command" variable;
|
|
|
|
* because there are "diff.color.<slot>" variables, we are parsing
|
|
|
|
* this in a bit convoluted way to allow low level diff driver
|
|
|
|
* called "color".
|
|
|
|
*/
|
|
|
|
static int parse_lldiff_command(const char *var, const char *ep, const char *value)
|
|
|
|
{
|
|
|
|
const char *name;
|
|
|
|
int namelen;
|
|
|
|
struct ll_diff_driver *drv;
|
|
|
|
|
|
|
|
name = var + 5;
|
|
|
|
namelen = ep - name;
|
|
|
|
for (drv = user_diff; drv; drv = drv->next)
|
|
|
|
if (!strncmp(drv->name, name, namelen) && !drv->name[namelen])
|
|
|
|
break;
|
|
|
|
if (!drv) {
|
|
|
|
drv = xcalloc(1, sizeof(struct ll_diff_driver));
|
2007-09-16 00:32:36 +02:00
|
|
|
drv->name = xmemdupz(name, namelen);
|
2007-04-23 02:52:55 +02:00
|
|
|
if (!user_diff_tail)
|
|
|
|
user_diff_tail = &user_diff;
|
|
|
|
*user_diff_tail = drv;
|
|
|
|
user_diff_tail = &(drv->next);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!value)
|
|
|
|
return error("%s: lacks value", var);
|
|
|
|
drv->cmd = strdup(value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-07 10:49:58 +02:00
|
|
|
/*
|
|
|
|
* 'diff.<what>.funcname' attribute can be specified in the configuration
|
|
|
|
* to define a customized regexp to find the beginning of a function to
|
|
|
|
* be used for hunk header lines of "diff -p" style output.
|
|
|
|
*/
|
|
|
|
static struct funcname_pattern {
|
|
|
|
char *name;
|
|
|
|
char *pattern;
|
|
|
|
struct funcname_pattern *next;
|
|
|
|
} *funcname_pattern_list;
|
|
|
|
|
|
|
|
static int parse_funcname_pattern(const char *var, const char *ep, const char *value)
|
|
|
|
{
|
|
|
|
const char *name;
|
|
|
|
int namelen;
|
|
|
|
struct funcname_pattern *pp;
|
|
|
|
|
|
|
|
name = var + 5; /* "diff." */
|
|
|
|
namelen = ep - name;
|
|
|
|
|
|
|
|
for (pp = funcname_pattern_list; pp; pp = pp->next)
|
|
|
|
if (!strncmp(pp->name, name, namelen) && !pp->name[namelen])
|
|
|
|
break;
|
|
|
|
if (!pp) {
|
|
|
|
pp = xcalloc(1, sizeof(*pp));
|
2007-09-16 00:32:36 +02:00
|
|
|
pp->name = xmemdupz(name, namelen);
|
2007-07-07 10:49:58 +02:00
|
|
|
pp->next = funcname_pattern_list;
|
|
|
|
funcname_pattern_list = pp;
|
|
|
|
}
|
|
|
|
if (pp->pattern)
|
|
|
|
free(pp->pattern);
|
|
|
|
pp->pattern = xstrdup(value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-08 10:05:16 +02:00
|
|
|
/*
|
|
|
|
* 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)
|
diff --color: use $GIT_DIR/config
This lets you use something like this in your $GIT_DIR/config
file.
[diff]
color = auto
[diff.color]
new = blue
old = yellow
frag = reverse
When diff.color is set to "auto", colored diff is enabled when
the standard output is the terminal. Other choices are "always",
and "never". Usual boolean true/false can also be used.
The colormap entries can specify colors for the following slots:
plain - lines that appear in both old and new file (context)
meta - diff --git header and extended git diff headers
frag - @@ -n,m +l,k @@ lines (hunk header)
old - lines deleted from old file
new - lines added to new file
The following color names can be used:
normal, bold, dim, l, blink, reverse, reset,
black, red, green, yellow, blue, magenta, cyan,
white
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-24 13:06:23 +02:00
|
|
|
{
|
|
|
|
if (!strcmp(var, "diff.renamelimit")) {
|
|
|
|
diff_rename_limit_default = git_config_int(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-12-13 10:13:28 +01:00
|
|
|
if (!strcmp(var, "diff.color") || !strcmp(var, "color.diff")) {
|
2007-12-06 02:26:11 +01:00
|
|
|
diff_use_color_default = git_config_colorbool(var, value, -1);
|
diff --color: use $GIT_DIR/config
This lets you use something like this in your $GIT_DIR/config
file.
[diff]
color = auto
[diff.color]
new = blue
old = yellow
frag = reverse
When diff.color is set to "auto", colored diff is enabled when
the standard output is the terminal. Other choices are "always",
and "never". Usual boolean true/false can also be used.
The colormap entries can specify colors for the following slots:
plain - lines that appear in both old and new file (context)
meta - diff --git header and extended git diff headers
frag - @@ -n,m +l,k @@ lines (hunk header)
old - lines deleted from old file
new - lines added to new file
The following color names can be used:
normal, bold, dim, l, blink, reverse, reset,
black, red, green, yellow, blue, magenta, cyan,
white
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-24 13:06:23 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2006-07-07 13:01:23 +02:00
|
|
|
if (!strcmp(var, "diff.renames")) {
|
|
|
|
if (!value)
|
|
|
|
diff_detect_rename_default = DIFF_DETECT_RENAME;
|
|
|
|
else if (!strcasecmp(value, "copies") ||
|
|
|
|
!strcasecmp(value, "copy"))
|
|
|
|
diff_detect_rename_default = DIFF_DETECT_COPY;
|
|
|
|
else if (git_config_bool(var,value))
|
|
|
|
diff_detect_rename_default = DIFF_DETECT_RENAME;
|
|
|
|
return 0;
|
|
|
|
}
|
2007-08-31 22:13:42 +02:00
|
|
|
if (!strcmp(var, "diff.autorefreshindex")) {
|
|
|
|
diff_auto_refresh_index = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
2007-12-17 14:42:20 +01:00
|
|
|
if (!strcmp(var, "diff.external")) {
|
|
|
|
external_diff_cmd_cfg = xstrdup(value);
|
|
|
|
return 0;
|
|
|
|
}
|
2007-04-23 02:52:55 +02:00
|
|
|
if (!prefixcmp(var, "diff.")) {
|
|
|
|
const char *ep = strrchr(var, '.');
|
|
|
|
|
2007-07-07 10:49:58 +02:00
|
|
|
if (ep != var + 4) {
|
|
|
|
if (!strcmp(ep, ".command"))
|
|
|
|
return parse_lldiff_command(var, ep, value);
|
|
|
|
}
|
2007-04-23 02:52:55 +02:00
|
|
|
}
|
2008-01-04 09:59:34 +01:00
|
|
|
|
|
|
|
return git_diff_basic_config(var, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
int git_diff_basic_config(const char *var, const char *value)
|
|
|
|
{
|
2007-02-20 10:55:07 +01:00
|
|
|
if (!prefixcmp(var, "diff.color.") || !prefixcmp(var, "color.diff.")) {
|
diff --color: use $GIT_DIR/config
This lets you use something like this in your $GIT_DIR/config
file.
[diff]
color = auto
[diff.color]
new = blue
old = yellow
frag = reverse
When diff.color is set to "auto", colored diff is enabled when
the standard output is the terminal. Other choices are "always",
and "never". Usual boolean true/false can also be used.
The colormap entries can specify colors for the following slots:
plain - lines that appear in both old and new file (context)
meta - diff --git header and extended git diff headers
frag - @@ -n,m +l,k @@ lines (hunk header)
old - lines deleted from old file
new - lines added to new file
The following color names can be used:
normal, bold, dim, l, blink, reverse, reset,
black, red, green, yellow, blue, magenta, cyan,
white
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-24 13:06:23 +02:00
|
|
|
int slot = parse_diff_color_slot(var, 11);
|
2006-09-08 10:03:18 +02:00
|
|
|
color_parse(value, var, diff_colors[slot]);
|
diff --color: use $GIT_DIR/config
This lets you use something like this in your $GIT_DIR/config
file.
[diff]
color = auto
[diff.color]
new = blue
old = yellow
frag = reverse
When diff.color is set to "auto", colored diff is enabled when
the standard output is the terminal. Other choices are "always",
and "never". Usual boolean true/false can also be used.
The colormap entries can specify colors for the following slots:
plain - lines that appear in both old and new file (context)
meta - diff --git header and extended git diff headers
frag - @@ -n,m +l,k @@ lines (hunk header)
old - lines deleted from old file
new - lines added to new file
The following color names can be used:
normal, bold, dim, l, blink, reverse, reset,
black, red, green, yellow, blue, magenta, cyan,
white
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-24 13:06:23 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2007-04-23 02:52:55 +02:00
|
|
|
|
2008-01-04 10:16:14 +01:00
|
|
|
if (!prefixcmp(var, "diff.")) {
|
|
|
|
const char *ep = strrchr(var, '.');
|
|
|
|
if (ep != var + 4) {
|
|
|
|
if (!strcmp(ep, ".funcname"))
|
|
|
|
return parse_funcname_pattern(var, ep, value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
diff --color: use $GIT_DIR/config
This lets you use something like this in your $GIT_DIR/config
file.
[diff]
color = auto
[diff.color]
new = blue
old = yellow
frag = reverse
When diff.color is set to "auto", colored diff is enabled when
the standard output is the terminal. Other choices are "always",
and "never". Usual boolean true/false can also be used.
The colormap entries can specify colors for the following slots:
plain - lines that appear in both old and new file (context)
meta - diff --git header and extended git diff headers
frag - @@ -n,m +l,k @@ lines (hunk header)
old - lines deleted from old file
new - lines added to new file
The following color names can be used:
normal, bold, dim, l, blink, reverse, reset,
black, red, green, yellow, blue, magenta, cyan,
white
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-24 13:06:23 +02:00
|
|
|
return git_default_config(var, value);
|
|
|
|
}
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
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);
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
struct strbuf res;
|
2006-04-22 08:57:45 +02:00
|
|
|
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
strbuf_init(&res, 0);
|
2006-04-22 08:57:45 +02:00
|
|
|
if (need_one + need_two) {
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
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);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
2007-09-27 12:58:23 +02:00
|
|
|
return strbuf_detach(&res, NULL);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
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");
|
2007-12-17 14:42:20 +01:00
|
|
|
if (!external_diff_cmd)
|
|
|
|
external_diff_cmd = external_diff_cmd_cfg;
|
2006-04-22 08:57:45 +02:00
|
|
|
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];
|
2007-05-20 15:35:46 +02:00
|
|
|
char tmp_path[PATH_MAX];
|
2006-04-22 08:57:45 +02:00
|
|
|
} diff_temp[2];
|
|
|
|
|
|
|
|
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 void print_line_count(int count)
|
|
|
|
{
|
|
|
|
switch (count) {
|
|
|
|
case 0:
|
|
|
|
printf("0,0");
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
printf("1");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printf("1,%d", count);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-20 15:08:46 +01:00
|
|
|
static void copy_file(int prefix, const char *data, int size,
|
|
|
|
const char *set, const char *reset)
|
2006-04-22 08:57:45 +02:00
|
|
|
{
|
|
|
|
int ch, nl_just_seen = 1;
|
|
|
|
while (0 < size--) {
|
|
|
|
ch = *data++;
|
2007-02-20 15:08:46 +01:00
|
|
|
if (nl_just_seen) {
|
|
|
|
fputs(set, stdout);
|
2006-04-22 08:57:45 +02:00
|
|
|
putchar(prefix);
|
2007-02-20 15:08:46 +01:00
|
|
|
}
|
|
|
|
if (ch == '\n') {
|
2006-04-22 08:57:45 +02:00
|
|
|
nl_just_seen = 1;
|
2007-02-20 15:08:46 +01:00
|
|
|
fputs(reset, stdout);
|
|
|
|
} else
|
2006-04-22 08:57:45 +02:00
|
|
|
nl_just_seen = 0;
|
2007-02-20 15:08:46 +01:00
|
|
|
putchar(ch);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
if (!nl_just_seen)
|
2007-02-20 15:08:46 +01:00
|
|
|
printf("%s\n\\ No newline at end of file\n", reset);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void emit_rewrite_diff(const char *name_a,
|
|
|
|
const char *name_b,
|
|
|
|
struct diff_filespec *one,
|
2007-02-20 15:08:46 +01:00
|
|
|
struct diff_filespec *two,
|
2007-12-18 20:32:14 +01:00
|
|
|
struct diff_options *o)
|
2006-04-22 08:57:45 +02:00
|
|
|
{
|
|
|
|
int lc_a, lc_b;
|
2007-12-18 20:32:14 +01:00
|
|
|
int color_diff = DIFF_OPT_TST(o, COLOR_DIFF);
|
2006-09-23 01:17:58 +02:00
|
|
|
const char *name_a_tab, *name_b_tab;
|
2007-02-20 15:08:46 +01:00
|
|
|
const char *metainfo = diff_get_color(color_diff, DIFF_METAINFO);
|
|
|
|
const char *fraginfo = diff_get_color(color_diff, DIFF_FRAGINFO);
|
|
|
|
const char *old = diff_get_color(color_diff, DIFF_FILE_OLD);
|
|
|
|
const char *new = diff_get_color(color_diff, DIFF_FILE_NEW);
|
|
|
|
const char *reset = diff_get_color(color_diff, DIFF_RESET);
|
2007-12-27 02:13:36 +01:00
|
|
|
static struct strbuf a_name = STRBUF_INIT, b_name = STRBUF_INIT;
|
2006-09-23 01:17:58 +02:00
|
|
|
|
2007-02-24 10:42:06 +01:00
|
|
|
name_a += (*name_a == '/');
|
|
|
|
name_b += (*name_b == '/');
|
2006-09-23 01:17:58 +02:00
|
|
|
name_a_tab = strchr(name_a, ' ') ? "\t" : "";
|
|
|
|
name_b_tab = strchr(name_b, ' ') ? "\t" : "";
|
|
|
|
|
2007-12-27 02:13:36 +01:00
|
|
|
strbuf_reset(&a_name);
|
|
|
|
strbuf_reset(&b_name);
|
|
|
|
quote_two_c_style(&a_name, o->a_prefix, name_a, 0);
|
|
|
|
quote_two_c_style(&b_name, o->b_prefix, name_b, 0);
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
diff_populate_filespec(one, 0);
|
|
|
|
diff_populate_filespec(two, 0);
|
|
|
|
lc_a = count_lines(one->data, one->size);
|
|
|
|
lc_b = count_lines(two->data, two->size);
|
2007-12-27 02:13:36 +01:00
|
|
|
printf("%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);
|
2006-04-22 08:57:45 +02:00
|
|
|
print_line_count(lc_a);
|
|
|
|
printf(" +");
|
|
|
|
print_line_count(lc_b);
|
2007-02-20 15:08:46 +01:00
|
|
|
printf(" @@%s\n", reset);
|
2006-04-22 08:57:45 +02:00
|
|
|
if (lc_a)
|
2007-02-20 15:08:46 +01:00
|
|
|
copy_file('-', one->data, one->size, old, reset);
|
2006-04-22 08:57:45 +02:00
|
|
|
if (lc_b)
|
2007-02-20 15:08:46 +01:00
|
|
|
copy_file('+', two->data, two->size, new, reset);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int fill_mmfile(mmfile_t *mf, struct diff_filespec *one)
|
|
|
|
{
|
|
|
|
if (!DIFF_FILE_VALID(one)) {
|
2006-06-24 19:20:32 +02:00
|
|
|
mf->ptr = (char *)""; /* does not matter */
|
2006-04-22 08:57:45 +02:00
|
|
|
mf->size = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
else if (diff_populate_filespec(one, 0))
|
|
|
|
return -1;
|
|
|
|
mf->ptr = one->data;
|
|
|
|
mf->size = one->size;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-28 23:56:15 +02:00
|
|
|
struct diff_words_buffer {
|
|
|
|
mmfile_t text;
|
|
|
|
long alloc;
|
|
|
|
long current; /* output pointer */
|
|
|
|
int suppressed_newline;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void diff_words_append(char *line, unsigned long len,
|
|
|
|
struct diff_words_buffer *buffer)
|
|
|
|
{
|
|
|
|
if (buffer->text.size + len > buffer->alloc) {
|
|
|
|
buffer->alloc = (buffer->text.size + len) * 3 / 2;
|
|
|
|
buffer->text.ptr = xrealloc(buffer->text.ptr, buffer->alloc);
|
|
|
|
}
|
|
|
|
line++;
|
|
|
|
len--;
|
|
|
|
memcpy(buffer->text.ptr + buffer->text.size, line, len);
|
|
|
|
buffer->text.size += len;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct diff_words_data {
|
|
|
|
struct xdiff_emit_state xm;
|
|
|
|
struct diff_words_buffer minus, plus;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void print_word(struct diff_words_buffer *buffer, int len, int color,
|
|
|
|
int suppress_newline)
|
|
|
|
{
|
|
|
|
const char *ptr;
|
|
|
|
int eol = 0;
|
|
|
|
|
|
|
|
if (len == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ptr = buffer->text.ptr + buffer->current;
|
|
|
|
buffer->current += len;
|
|
|
|
|
|
|
|
if (ptr[len - 1] == '\n') {
|
|
|
|
eol = 1;
|
|
|
|
len--;
|
|
|
|
}
|
|
|
|
|
|
|
|
fputs(diff_get_color(1, color), stdout);
|
|
|
|
fwrite(ptr, len, 1, stdout);
|
|
|
|
fputs(diff_get_color(1, DIFF_RESET), stdout);
|
|
|
|
|
|
|
|
if (eol) {
|
|
|
|
if (suppress_newline)
|
|
|
|
buffer->suppressed_newline = 1;
|
|
|
|
else
|
|
|
|
putchar('\n');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void fn_out_diff_words_aux(void *priv, char *line, unsigned long len)
|
|
|
|
{
|
|
|
|
struct diff_words_data *diff_words = priv;
|
|
|
|
|
|
|
|
if (diff_words->minus.suppressed_newline) {
|
|
|
|
if (line[0] != '+')
|
|
|
|
putchar('\n');
|
|
|
|
diff_words->minus.suppressed_newline = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
len--;
|
|
|
|
switch (line[0]) {
|
|
|
|
case '-':
|
|
|
|
print_word(&diff_words->minus, len, DIFF_FILE_OLD, 1);
|
|
|
|
break;
|
|
|
|
case '+':
|
|
|
|
print_word(&diff_words->plus, len, DIFF_FILE_NEW, 0);
|
|
|
|
break;
|
|
|
|
case ' ':
|
|
|
|
print_word(&diff_words->plus, len, DIFF_PLAIN, 0);
|
|
|
|
diff_words->minus.current += len;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
int i;
|
|
|
|
|
2007-07-04 20:05:46 +02:00
|
|
|
memset(&xecfg, 0, sizeof(xecfg));
|
2006-07-28 23:56:15 +02:00
|
|
|
minus.size = diff_words->minus.text.size;
|
|
|
|
minus.ptr = xmalloc(minus.size);
|
|
|
|
memcpy(minus.ptr, diff_words->minus.text.ptr, minus.size);
|
|
|
|
for (i = 0; i < minus.size; i++)
|
|
|
|
if (isspace(minus.ptr[i]))
|
|
|
|
minus.ptr[i] = '\n';
|
|
|
|
diff_words->minus.current = 0;
|
|
|
|
|
|
|
|
plus.size = diff_words->plus.text.size;
|
|
|
|
plus.ptr = xmalloc(plus.size);
|
|
|
|
memcpy(plus.ptr, diff_words->plus.text.ptr, plus.size);
|
|
|
|
for (i = 0; i < plus.size; i++)
|
|
|
|
if (isspace(plus.ptr[i]))
|
|
|
|
plus.ptr[i] = '\n';
|
|
|
|
diff_words->plus.current = 0;
|
|
|
|
|
|
|
|
xpp.flags = XDF_NEED_MINIMAL;
|
|
|
|
xecfg.ctxlen = diff_words->minus.alloc + diff_words->plus.alloc;
|
|
|
|
ecb.outf = xdiff_outf;
|
|
|
|
ecb.priv = diff_words;
|
|
|
|
diff_words->xm.consume = fn_out_diff_words_aux;
|
2007-12-13 22:25:07 +01:00
|
|
|
xdi_diff(&minus, &plus, &xpp, &xecfg, &ecb);
|
2006-07-28 23:56:15 +02:00
|
|
|
|
|
|
|
free(minus.ptr);
|
|
|
|
free(plus.ptr);
|
|
|
|
diff_words->minus.text.size = diff_words->plus.text.size = 0;
|
|
|
|
|
|
|
|
if (diff_words->minus.suppressed_newline) {
|
|
|
|
putchar('\n');
|
|
|
|
diff_words->minus.suppressed_newline = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-02 10:50:11 +01:00
|
|
|
typedef unsigned long (*sane_truncate_fn)(char *line, unsigned long len);
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
struct emit_callback {
|
2006-06-13 18:45:44 +02:00
|
|
|
struct xdiff_emit_state xm;
|
|
|
|
int nparents, color_diff;
|
2007-12-06 09:14:14 +01:00
|
|
|
unsigned ws_rule;
|
2008-01-02 10:50:11 +01:00
|
|
|
sane_truncate_fn truncate;
|
2006-04-22 08:57:45 +02:00
|
|
|
const char **label_path;
|
2006-07-28 23:56:15 +02:00
|
|
|
struct diff_words_data *diff_words;
|
2007-02-25 23:34:54 +01:00
|
|
|
int *found_changesp;
|
2006-04-22 08:57:45 +02:00
|
|
|
};
|
|
|
|
|
2006-07-28 23:56:15 +02:00
|
|
|
static void free_diff_words_data(struct emit_callback *ecbdata)
|
|
|
|
{
|
|
|
|
if (ecbdata->diff_words) {
|
|
|
|
/* flush buffers */
|
|
|
|
if (ecbdata->diff_words->minus.text.size ||
|
|
|
|
ecbdata->diff_words->plus.text.size)
|
|
|
|
diff_words_show(ecbdata->diff_words);
|
|
|
|
|
|
|
|
if (ecbdata->diff_words->minus.text.ptr)
|
|
|
|
free (ecbdata->diff_words->minus.text.ptr);
|
|
|
|
if (ecbdata->diff_words->plus.text.ptr)
|
|
|
|
free (ecbdata->diff_words->plus.text.ptr);
|
|
|
|
free(ecbdata->diff_words);
|
|
|
|
ecbdata->diff_words = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-23 11:24:18 +02:00
|
|
|
const char *diff_get_color(int diff_use_color, enum color_diff ix)
|
2006-06-13 18:45:44 +02:00
|
|
|
{
|
|
|
|
if (diff_use_color)
|
Tweak diff colors
This patch does:
- always reset the color _before_ printing out the newline.
This is actually important. You (and Johannes) didn't see it, because
it only matters if you set the background, but if you don't do this,
you get some random and funky behaviour if you pick a color with a
non-default background (which still potentially has problems with tabs
etc, but less so).
- allow people to have a different color for the "file headers"
(DIFF_METAINFO) and for the "fragment header" (DIFF_FRAGINFO). Also,
make a difference between "normal color" and "reset colors"
- default to red/green for old/new lines. That's the norm, I'd think.
- instead of that eye-popping (and eye-ball-with-a-fondue-fork-popping)
purple color for metadata, use bold-face for file headers, and cyan for
the frag headers. I actually prefer the "gray background" for that, but
it only works well in xterms, so COLOR_CYAN it is..
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-22 22:53:31 +02:00
|
|
|
return diff_colors[ix];
|
|
|
|
return "";
|
2006-06-13 18:45:44 +02:00
|
|
|
}
|
|
|
|
|
2006-09-23 07:48:39 +02:00
|
|
|
static void emit_line(const char *set, const char *reset, const char *line, int len)
|
|
|
|
{
|
|
|
|
fputs(set, stdout);
|
|
|
|
fwrite(line, len, 1, stdout);
|
|
|
|
fputs(reset, stdout);
|
|
|
|
}
|
|
|
|
|
2007-02-18 17:27:24 +01:00
|
|
|
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(set, reset, line, len);
|
2007-12-13 14:32:29 +01:00
|
|
|
else {
|
|
|
|
/* Emit just the prefix, then the rest. */
|
|
|
|
emit_line(set, reset, line, ecbdata->nparents);
|
|
|
|
(void)check_and_emit_line(line + ecbdata->nparents,
|
|
|
|
len - ecbdata->nparents, ecbdata->ws_rule,
|
|
|
|
stdout, set, reset, ws);
|
|
|
|
}
|
2007-02-18 17:27:24 +01:00
|
|
|
}
|
|
|
|
|
2008-01-02 10:50:11 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2006-06-13 18:45:44 +02:00
|
|
|
static void fn_out_consume(void *priv, char *line, unsigned long len)
|
2006-04-22 08:57:45 +02:00
|
|
|
{
|
|
|
|
int i;
|
2006-09-23 07:48:39 +02:00
|
|
|
int color;
|
2006-04-22 08:57:45 +02:00
|
|
|
struct emit_callback *ecbdata = priv;
|
2006-07-23 11:24:18 +02:00
|
|
|
const char *set = diff_get_color(ecbdata->color_diff, DIFF_METAINFO);
|
|
|
|
const char *reset = diff_get_color(ecbdata->color_diff, DIFF_RESET);
|
2006-04-22 08:57:45 +02:00
|
|
|
|
2007-02-25 23:34:54 +01:00
|
|
|
*(ecbdata->found_changesp) = 1;
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
if (ecbdata->label_path[0]) {
|
2006-09-23 01:17:58 +02:00
|
|
|
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" : "";
|
|
|
|
|
|
|
|
printf("%s--- %s%s%s\n",
|
|
|
|
set, ecbdata->label_path[0], reset, name_a_tab);
|
|
|
|
printf("%s+++ %s%s%s\n",
|
|
|
|
set, ecbdata->label_path[1], reset, name_b_tab);
|
2006-04-22 08:57:45 +02:00
|
|
|
ecbdata->label_path[0] = ecbdata->label_path[1] = NULL;
|
|
|
|
}
|
2006-06-13 18:45:44 +02:00
|
|
|
|
|
|
|
/* This is not really necessary for now because
|
|
|
|
* this codepath only deals with two-way diffs.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < len && line[i] == '@'; i++)
|
|
|
|
;
|
|
|
|
if (2 <= i && i < len && line[i] == ' ') {
|
|
|
|
ecbdata->nparents = i - 1;
|
2008-01-02 10:50:11 +01:00
|
|
|
len = sane_truncate_line(ecbdata, line, len);
|
2006-09-23 07:48:39 +02:00
|
|
|
emit_line(diff_get_color(ecbdata->color_diff, DIFF_FRAGINFO),
|
|
|
|
reset, line, len);
|
2008-01-02 10:50:11 +01:00
|
|
|
if (line[len-1] != '\n')
|
|
|
|
putchar('\n');
|
2006-09-23 07:48:39 +02:00
|
|
|
return;
|
2006-06-13 18:45:44 +02:00
|
|
|
}
|
2006-09-23 07:48:39 +02:00
|
|
|
|
|
|
|
if (len < ecbdata->nparents) {
|
Tweak diff colors
This patch does:
- always reset the color _before_ printing out the newline.
This is actually important. You (and Johannes) didn't see it, because
it only matters if you set the background, but if you don't do this,
you get some random and funky behaviour if you pick a color with a
non-default background (which still potentially has problems with tabs
etc, but less so).
- allow people to have a different color for the "file headers"
(DIFF_METAINFO) and for the "fragment header" (DIFF_FRAGINFO). Also,
make a difference between "normal color" and "reset colors"
- default to red/green for old/new lines. That's the norm, I'd think.
- instead of that eye-popping (and eye-ball-with-a-fondue-fork-popping)
purple color for metadata, use bold-face for file headers, and cyan for
the frag headers. I actually prefer the "gray background" for that, but
it only works well in xterms, so COLOR_CYAN it is..
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-22 22:53:31 +02:00
|
|
|
set = reset;
|
2006-09-23 07:48:39 +02:00
|
|
|
emit_line(reset, reset, line, len);
|
|
|
|
return;
|
2006-06-13 18:45:44 +02:00
|
|
|
}
|
2006-09-23 07:48:39 +02:00
|
|
|
|
|
|
|
color = DIFF_PLAIN;
|
|
|
|
if (ecbdata->diff_words && ecbdata->nparents != 1)
|
|
|
|
/* fall back to normal diff */
|
|
|
|
free_diff_words_data(ecbdata);
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
if (ecbdata->diff_words->minus.text.size ||
|
|
|
|
ecbdata->diff_words->plus.text.size)
|
|
|
|
diff_words_show(ecbdata->diff_words);
|
|
|
|
line++;
|
Tweak diff colors
This patch does:
- always reset the color _before_ printing out the newline.
This is actually important. You (and Johannes) didn't see it, because
it only matters if you set the background, but if you don't do this,
you get some random and funky behaviour if you pick a color with a
non-default background (which still potentially has problems with tabs
etc, but less so).
- allow people to have a different color for the "file headers"
(DIFF_METAINFO) and for the "fragment header" (DIFF_FRAGINFO). Also,
make a difference between "normal color" and "reset colors"
- default to red/green for old/new lines. That's the norm, I'd think.
- instead of that eye-popping (and eye-ball-with-a-fondue-fork-popping)
purple color for metadata, use bold-face for file headers, and cyan for
the frag headers. I actually prefer the "gray background" for that, but
it only works well in xterms, so COLOR_CYAN it is..
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-22 22:53:31 +02:00
|
|
|
len--;
|
2006-09-23 07:48:39 +02:00
|
|
|
emit_line(set, reset, line, len);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (i = 0; i < ecbdata->nparents && len; i++) {
|
|
|
|
if (line[i] == '-')
|
|
|
|
color = DIFF_FILE_OLD;
|
|
|
|
else if (line[i] == '+')
|
|
|
|
color = DIFF_FILE_NEW;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (color != DIFF_FILE_NEW) {
|
|
|
|
emit_line(diff_get_color(ecbdata->color_diff, color),
|
|
|
|
reset, line, len);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
emit_add_line(reset, ecbdata, line, len);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static char *pprint_rename(const char *a, const char *b)
|
|
|
|
{
|
|
|
|
const char *old = a;
|
|
|
|
const char *new = b;
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
struct strbuf name;
|
2006-04-22 08:57:45 +02:00
|
|
|
int pfx_length, sfx_length;
|
|
|
|
int len_a = strlen(a);
|
|
|
|
int len_b = strlen(b);
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
int a_midlen, b_midlen;
|
2007-02-10 15:39:00 +01:00
|
|
|
int qlen_a = quote_c_style(a, NULL, NULL, 0);
|
|
|
|
int qlen_b = quote_c_style(b, NULL, NULL, 0);
|
|
|
|
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
strbuf_init(&name, 0);
|
2007-02-10 15:39:00 +01:00
|
|
|
if (qlen_a || qlen_b) {
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
quote_c_style(a, &name, NULL, 0);
|
|
|
|
strbuf_addstr(&name, " => ");
|
|
|
|
quote_c_style(b, &name, NULL, 0);
|
2007-09-27 12:58:23 +02:00
|
|
|
return strbuf_detach(&name, NULL);
|
2007-02-10 15:39:00 +01:00
|
|
|
}
|
2006-04-22 08:57:45 +02:00
|
|
|
|
|
|
|
/* 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
|
|
|
|
*/
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
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);
|
2006-04-22 08:57:45 +02:00
|
|
|
if (pfx_length + sfx_length) {
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
strbuf_add(&name, a, pfx_length);
|
|
|
|
strbuf_addch(&name, '{');
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
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);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
2007-09-27 12:58:23 +02:00
|
|
|
return strbuf_detach(&name, NULL);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
struct diffstat_t {
|
|
|
|
struct xdiff_emit_state xm;
|
|
|
|
|
|
|
|
int nr;
|
|
|
|
int alloc;
|
|
|
|
struct diffstat_file {
|
2007-12-12 08:46:30 +01:00
|
|
|
char *from_name;
|
2006-04-22 08:57:45 +02:00
|
|
|
char *name;
|
2007-12-12 08:46:30 +01:00
|
|
|
char *print_name;
|
2006-04-22 08:57:45 +02:00
|
|
|
unsigned is_unmerged:1;
|
|
|
|
unsigned is_binary:1;
|
|
|
|
unsigned is_renamed:1;
|
|
|
|
unsigned int added, deleted;
|
|
|
|
} **files;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct diffstat_file *diffstat_add(struct diffstat_t *diffstat,
|
|
|
|
const char *name_a,
|
|
|
|
const char *name_b)
|
|
|
|
{
|
|
|
|
struct diffstat_file *x;
|
|
|
|
x = xcalloc(sizeof (*x), 1);
|
|
|
|
if (diffstat->nr == diffstat->alloc) {
|
|
|
|
diffstat->alloc = alloc_nr(diffstat->alloc);
|
|
|
|
diffstat->files = xrealloc(diffstat->files,
|
|
|
|
diffstat->alloc * sizeof(x));
|
|
|
|
}
|
|
|
|
diffstat->files[diffstat->nr++] = x;
|
|
|
|
if (name_b) {
|
2007-12-12 08:46:30 +01:00
|
|
|
x->from_name = xstrdup(name_a);
|
|
|
|
x->name = xstrdup(name_b);
|
2006-04-22 08:57:45 +02:00
|
|
|
x->is_renamed = 1;
|
|
|
|
}
|
2007-12-12 08:46:30 +01:00
|
|
|
else {
|
|
|
|
x->from_name = NULL;
|
2006-09-02 06:16:31 +02:00
|
|
|
x->name = xstrdup(name_a);
|
2007-12-12 08:46:30 +01:00
|
|
|
}
|
2006-04-22 08:57:45 +02:00
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void diffstat_consume(void *priv, char *line, unsigned long len)
|
|
|
|
{
|
|
|
|
struct diffstat_t *diffstat = priv;
|
|
|
|
struct diffstat_file *x = diffstat->files[diffstat->nr - 1];
|
|
|
|
|
|
|
|
if (line[0] == '+')
|
|
|
|
x->added++;
|
|
|
|
else if (line[0] == '-')
|
|
|
|
x->deleted++;
|
|
|
|
}
|
|
|
|
|
2006-05-20 15:40:29 +02:00
|
|
|
const char mime_boundary_leader[] = "------------";
|
2006-04-22 08:57:45 +02:00
|
|
|
|
2006-09-27 03:53:02 +02:00
|
|
|
static int scale_linear(int it, int width, int max_change)
|
|
|
|
{
|
|
|
|
/*
|
2006-09-28 17:37:39 +02:00
|
|
|
* make sure that at least one '-' is printed if there were deletions,
|
|
|
|
* and likewise for '+'.
|
2006-09-27 03:53:02 +02:00
|
|
|
*/
|
2006-09-28 17:37:39 +02:00
|
|
|
if (max_change < 2)
|
|
|
|
return it;
|
|
|
|
return ((it - 1) * (width - 1) + max_change - 1) / (max_change - 1);
|
2006-09-27 03:53:02 +02:00
|
|
|
}
|
|
|
|
|
2006-09-27 03:59:41 +02:00
|
|
|
static void show_name(const char *prefix, const char *name, int len,
|
|
|
|
const char *reset, const char *set)
|
2006-09-27 03:53:02 +02:00
|
|
|
{
|
2006-09-27 03:59:41 +02:00
|
|
|
printf(" %s%s%-*s%s |", set, prefix, len, name, reset);
|
2006-09-27 03:53:02 +02:00
|
|
|
}
|
|
|
|
|
2006-09-27 03:59:41 +02:00
|
|
|
static void show_graph(char ch, int cnt, const char *set, const char *reset)
|
2006-09-27 03:53:02 +02:00
|
|
|
{
|
|
|
|
if (cnt <= 0)
|
|
|
|
return;
|
2006-09-27 03:59:41 +02:00
|
|
|
printf("%s", set);
|
2006-09-27 03:53:02 +02:00
|
|
|
while (cnt--)
|
|
|
|
putchar(ch);
|
2006-09-27 03:59:41 +02:00
|
|
|
printf("%s", reset);
|
2006-09-27 03:53:02 +02:00
|
|
|
}
|
|
|
|
|
2007-12-12 08:46:30 +01:00
|
|
|
static void fill_print_name(struct diffstat_file *file)
|
|
|
|
{
|
|
|
|
char *pname;
|
|
|
|
|
|
|
|
if (file->print_name)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!file->is_renamed) {
|
|
|
|
struct strbuf buf;
|
|
|
|
strbuf_init(&buf, 0);
|
|
|
|
if (quote_c_style(file->name, &buf, NULL, 0)) {
|
|
|
|
pname = strbuf_detach(&buf, NULL);
|
|
|
|
} else {
|
|
|
|
pname = file->name;
|
|
|
|
strbuf_release(&buf);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
pname = pprint_rename(file->from_name, file->name);
|
|
|
|
}
|
|
|
|
file->print_name = pname;
|
|
|
|
}
|
|
|
|
|
2006-09-27 03:53:02 +02:00
|
|
|
static void show_stats(struct diffstat_t* data, struct diff_options *options)
|
2006-04-22 08:57:45 +02:00
|
|
|
{
|
|
|
|
int i, len, add, del, total, adds = 0, dels = 0;
|
2006-09-27 03:53:02 +02:00
|
|
|
int max_change = 0, max_len = 0;
|
2006-04-22 08:57:45 +02:00
|
|
|
int total_files = data->nr;
|
2006-09-27 03:53:02 +02:00
|
|
|
int width, name_width;
|
2006-09-27 03:59:41 +02:00
|
|
|
const char *reset, *set, *add_c, *del_c;
|
2006-04-22 08:57:45 +02:00
|
|
|
|
|
|
|
if (data->nr == 0)
|
|
|
|
return;
|
|
|
|
|
2006-09-27 03:53:02 +02:00
|
|
|
width = options->stat_width ? options->stat_width : 80;
|
|
|
|
name_width = options->stat_name_width ? options->stat_name_width : 50;
|
|
|
|
|
|
|
|
/* Sanity: give at least 5 columns to the graph,
|
|
|
|
* but leave at least 10 columns for the name.
|
|
|
|
*/
|
|
|
|
if (width < name_width + 15) {
|
|
|
|
if (name_width <= 25)
|
|
|
|
width = name_width + 15;
|
|
|
|
else
|
|
|
|
name_width = width - 15;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Find the longest filename and max number of changes */
|
2007-11-10 20:05:14 +01:00
|
|
|
reset = diff_get_color_opt(options, DIFF_RESET);
|
|
|
|
set = diff_get_color_opt(options, DIFF_PLAIN);
|
|
|
|
add_c = diff_get_color_opt(options, DIFF_FILE_NEW);
|
|
|
|
del_c = diff_get_color_opt(options, DIFF_FILE_OLD);
|
2006-09-27 03:59:41 +02:00
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
for (i = 0; i < data->nr; i++) {
|
|
|
|
struct diffstat_file *file = data->files[i];
|
2006-09-27 03:53:02 +02:00
|
|
|
int change = file->added + file->deleted;
|
2007-12-12 08:46:30 +01:00
|
|
|
fill_print_name(file);
|
|
|
|
len = strlen(file->print_name);
|
2006-04-22 08:57:45 +02:00
|
|
|
if (max_len < len)
|
|
|
|
max_len = len;
|
|
|
|
|
|
|
|
if (file->is_binary || file->is_unmerged)
|
|
|
|
continue;
|
2006-09-27 03:53:02 +02:00
|
|
|
if (max_change < change)
|
|
|
|
max_change = change;
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
2006-09-27 03:53:02 +02:00
|
|
|
/* Compute the width of the graph part;
|
|
|
|
* 10 is for one blank at the beginning of the line plus
|
|
|
|
* " | count " between the name and the graph.
|
|
|
|
*
|
|
|
|
* From here on, name_width is the width of the name area,
|
|
|
|
* and width is the width of the graph area.
|
|
|
|
*/
|
|
|
|
name_width = (name_width < max_len) ? name_width : max_len;
|
|
|
|
if (width < (name_width + 10) + max_change)
|
|
|
|
width = width - (name_width + 10);
|
|
|
|
else
|
|
|
|
width = max_change;
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
for (i = 0; i < data->nr; i++) {
|
2006-06-24 19:20:32 +02:00
|
|
|
const char *prefix = "";
|
2007-12-12 08:46:30 +01:00
|
|
|
char *name = data->files[i]->print_name;
|
2006-04-22 08:57:45 +02:00
|
|
|
int added = data->files[i]->added;
|
|
|
|
int deleted = data->files[i]->deleted;
|
2006-09-27 03:53:02 +02:00
|
|
|
int name_len;
|
2006-04-22 08:57:45 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* "scale" the filename
|
|
|
|
*/
|
2006-09-27 03:53:02 +02:00
|
|
|
len = name_width;
|
|
|
|
name_len = strlen(name);
|
|
|
|
if (name_width < name_len) {
|
2006-04-22 08:57:45 +02:00
|
|
|
char *slash;
|
|
|
|
prefix = "...";
|
2006-09-27 03:53:02 +02:00
|
|
|
len -= 3;
|
|
|
|
name += name_len - len;
|
2006-04-22 08:57:45 +02:00
|
|
|
slash = strchr(name, '/');
|
|
|
|
if (slash)
|
|
|
|
name = slash;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (data->files[i]->is_binary) {
|
2006-09-27 03:59:41 +02:00
|
|
|
show_name(prefix, name, len, reset, set);
|
2007-04-04 15:14:14 +02:00
|
|
|
printf(" Bin ");
|
|
|
|
printf("%s%d%s", del_c, deleted, reset);
|
|
|
|
printf(" -> ");
|
|
|
|
printf("%s%d%s", add_c, added, reset);
|
|
|
|
printf(" bytes");
|
|
|
|
printf("\n");
|
2007-12-12 08:46:30 +01:00
|
|
|
continue;
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
else if (data->files[i]->is_unmerged) {
|
2006-09-27 03:59:41 +02:00
|
|
|
show_name(prefix, name, len, reset, set);
|
2006-09-27 03:53:02 +02:00
|
|
|
printf(" Unmerged\n");
|
2007-12-12 08:46:30 +01:00
|
|
|
continue;
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
else if (!data->files[i]->is_renamed &&
|
|
|
|
(added + deleted == 0)) {
|
|
|
|
total_files--;
|
2007-12-12 08:46:30 +01:00
|
|
|
continue;
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
2006-09-27 03:53:02 +02:00
|
|
|
/*
|
|
|
|
* scale the add/delete
|
|
|
|
*/
|
2006-04-22 08:57:45 +02:00
|
|
|
add = added;
|
|
|
|
del = deleted;
|
|
|
|
total = add + del;
|
|
|
|
adds += add;
|
|
|
|
dels += del;
|
|
|
|
|
2006-09-27 03:53:02 +02:00
|
|
|
if (width <= max_change) {
|
|
|
|
add = scale_linear(add, width, max_change);
|
2006-09-28 17:37:39 +02:00
|
|
|
del = scale_linear(del, width, max_change);
|
|
|
|
total = add + del;
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
2006-09-27 03:59:41 +02:00
|
|
|
show_name(prefix, name, len, reset, set);
|
2006-09-27 03:53:02 +02:00
|
|
|
printf("%5d ", added + deleted);
|
2006-09-27 03:59:41 +02:00
|
|
|
show_graph('+', add, add_c, reset);
|
|
|
|
show_graph('-', del, del_c, reset);
|
2006-09-27 03:53:02 +02:00
|
|
|
putchar('\n');
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
2006-09-27 03:59:41 +02:00
|
|
|
printf("%s %d files changed, %d insertions(+), %d deletions(-)%s\n",
|
|
|
|
set, total_files, adds, dels, reset);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
2006-12-15 05:15:44 +01:00
|
|
|
static void show_shortstats(struct diffstat_t* data)
|
|
|
|
{
|
|
|
|
int i, adds = 0, dels = 0, total_files = data->nr;
|
|
|
|
|
|
|
|
if (data->nr == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < data->nr; i++) {
|
|
|
|
if (!data->files[i]->is_binary &&
|
|
|
|
!data->files[i]->is_unmerged) {
|
|
|
|
int added = data->files[i]->added;
|
|
|
|
int deleted= data->files[i]->deleted;
|
|
|
|
if (!data->files[i]->is_renamed &&
|
|
|
|
(added + deleted == 0)) {
|
|
|
|
total_files--;
|
|
|
|
} else {
|
|
|
|
adds += added;
|
|
|
|
dels += deleted;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
printf(" %d files changed, %d insertions(+), %d deletions(-)\n",
|
|
|
|
total_files, adds, dels);
|
|
|
|
}
|
|
|
|
|
2006-10-12 12:01:00 +02:00
|
|
|
static void show_numstat(struct diffstat_t* data, struct diff_options *options)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2007-12-12 08:46:30 +01:00
|
|
|
if (data->nr == 0)
|
|
|
|
return;
|
|
|
|
|
2006-10-12 12:01:00 +02:00
|
|
|
for (i = 0; i < data->nr; i++) {
|
|
|
|
struct diffstat_file *file = data->files[i];
|
|
|
|
|
2006-12-10 22:50:59 +01:00
|
|
|
if (file->is_binary)
|
|
|
|
printf("-\t-\t");
|
|
|
|
else
|
|
|
|
printf("%d\t%d\t", file->added, file->deleted);
|
2007-12-12 08:46:30 +01:00
|
|
|
if (options->line_termination) {
|
|
|
|
fill_print_name(file);
|
|
|
|
if (!file->is_renamed)
|
|
|
|
write_name_quoted(file->name, stdout,
|
|
|
|
options->line_termination);
|
|
|
|
else {
|
|
|
|
fputs(file->print_name, stdout);
|
|
|
|
putchar(options->line_termination);
|
|
|
|
}
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
} else {
|
2007-12-12 08:46:30 +01:00
|
|
|
if (file->is_renamed) {
|
|
|
|
putchar('\0');
|
|
|
|
write_name_quoted(file->from_name, stdout, '\0');
|
|
|
|
}
|
|
|
|
write_name_quoted(file->name, stdout, '\0');
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
}
|
2006-10-12 12:01:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-12-12 08:46:30 +01:00
|
|
|
static void free_diffstat_info(struct diffstat_t *diffstat)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < diffstat->nr; i++) {
|
|
|
|
struct diffstat_file *f = diffstat->files[i];
|
|
|
|
if (f->name != f->print_name)
|
|
|
|
free(f->print_name);
|
|
|
|
free(f->name);
|
|
|
|
free(f->from_name);
|
|
|
|
free(f);
|
|
|
|
}
|
|
|
|
free(diffstat->files);
|
|
|
|
}
|
|
|
|
|
2006-05-20 23:43:13 +02:00
|
|
|
struct checkdiff_t {
|
|
|
|
struct xdiff_emit_state xm;
|
|
|
|
const char *filename;
|
2007-02-18 17:27:24 +01:00
|
|
|
int lineno, color_diff;
|
2007-12-06 09:14:14 +01:00
|
|
|
unsigned ws_rule;
|
2007-12-13 21:24:52 +01:00
|
|
|
unsigned status;
|
2006-05-20 23:43:13 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static void checkdiff_consume(void *priv, char *line, unsigned long len)
|
|
|
|
{
|
|
|
|
struct checkdiff_t *data = priv;
|
2007-02-18 17:27:24 +01:00
|
|
|
const char *ws = diff_get_color(data->color_diff, DIFF_WHITESPACE);
|
|
|
|
const char *reset = diff_get_color(data->color_diff, DIFF_RESET);
|
|
|
|
const char *set = diff_get_color(data->color_diff, DIFF_FILE_NEW);
|
2007-12-13 14:32:29 +01:00
|
|
|
char *err;
|
2006-05-20 23:43:13 +02:00
|
|
|
|
|
|
|
if (line[0] == '+') {
|
2007-12-13 14:32:29 +01:00
|
|
|
data->status = check_and_emit_line(line + 1, len - 1,
|
|
|
|
data->ws_rule, NULL, NULL, NULL, NULL);
|
|
|
|
if (!data->status)
|
|
|
|
return;
|
|
|
|
err = whitespace_error_string(data->status);
|
2007-12-13 14:32:30 +01:00
|
|
|
printf("%s:%d: %s.\n", data->filename, data->lineno, err);
|
2007-12-13 14:32:29 +01:00
|
|
|
free(err);
|
|
|
|
emit_line(set, reset, line, 1);
|
|
|
|
(void)check_and_emit_line(line + 1, len - 1, data->ws_rule,
|
|
|
|
stdout, set, reset, ws);
|
2006-12-22 03:20:11 +01:00
|
|
|
data->lineno++;
|
2006-05-20 23:43:13 +02:00
|
|
|
} else if (line[0] == ' ')
|
|
|
|
data->lineno++;
|
|
|
|
else if (line[0] == '@') {
|
|
|
|
char *plus = strchr(line, '+');
|
|
|
|
if (plus)
|
2006-05-21 12:01:59 +02:00
|
|
|
data->lineno = strtol(plus, NULL, 10);
|
2006-05-20 23:43:13 +02:00
|
|
|
else
|
|
|
|
die("invalid diff");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-05-05 11:41:53 +02:00
|
|
|
static unsigned char *deflate_it(char *data,
|
|
|
|
unsigned long size,
|
|
|
|
unsigned long *result_size)
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
{
|
2006-05-05 11:41:53 +02:00
|
|
|
int bound;
|
|
|
|
unsigned char *deflated;
|
|
|
|
z_stream stream;
|
|
|
|
|
|
|
|
memset(&stream, 0, sizeof(stream));
|
2006-07-03 22:11:47 +02:00
|
|
|
deflateInit(&stream, zlib_compression_level);
|
2006-05-05 11:41:53 +02:00
|
|
|
bound = deflateBound(&stream, size);
|
|
|
|
deflated = xmalloc(bound);
|
|
|
|
stream.next_out = deflated;
|
|
|
|
stream.avail_out = bound;
|
|
|
|
|
|
|
|
stream.next_in = (unsigned char *)data;
|
|
|
|
stream.avail_in = size;
|
|
|
|
while (deflate(&stream, Z_FINISH) == Z_OK)
|
|
|
|
; /* nothing */
|
|
|
|
deflateEnd(&stream);
|
|
|
|
*result_size = stream.total_out;
|
|
|
|
return deflated;
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
}
|
|
|
|
|
2006-08-17 01:08:14 +02:00
|
|
|
static void emit_binary_diff_body(mmfile_t *one, mmfile_t *two)
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
{
|
2006-05-05 11:41:53 +02:00
|
|
|
void *cp;
|
|
|
|
void *delta;
|
|
|
|
void *deflated;
|
|
|
|
void *data;
|
|
|
|
unsigned long orig_size;
|
|
|
|
unsigned long delta_size;
|
|
|
|
unsigned long deflate_size;
|
|
|
|
unsigned long data_size;
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
|
2006-05-05 11:41:53 +02:00
|
|
|
/* We could do deflated delta, or we could do just deflated two,
|
|
|
|
* whichever is smaller.
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
*/
|
2006-05-05 11:41:53 +02:00
|
|
|
delta = NULL;
|
|
|
|
deflated = deflate_it(two->ptr, two->size, &deflate_size);
|
|
|
|
if (one->size && two->size) {
|
|
|
|
delta = diff_delta(one->ptr, one->size,
|
|
|
|
two->ptr, two->size,
|
|
|
|
&delta_size, deflate_size);
|
|
|
|
if (delta) {
|
|
|
|
void *to_free = delta;
|
|
|
|
orig_size = delta_size;
|
|
|
|
delta = deflate_it(delta, delta_size, &delta_size);
|
|
|
|
free(to_free);
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-05-05 11:41:53 +02:00
|
|
|
if (delta && delta_size < deflate_size) {
|
|
|
|
printf("delta %lu\n", orig_size);
|
|
|
|
free(deflated);
|
|
|
|
data = delta;
|
|
|
|
data_size = delta_size;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
printf("literal %lu\n", two->size);
|
|
|
|
free(delta);
|
|
|
|
data = deflated;
|
|
|
|
data_size = deflate_size;
|
|
|
|
}
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
|
2006-05-05 11:41:53 +02:00
|
|
|
/* emit data encoded in base85 */
|
|
|
|
cp = data;
|
|
|
|
while (data_size) {
|
|
|
|
int bytes = (52 < data_size) ? 52 : data_size;
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
char line[70];
|
2006-05-05 11:41:53 +02:00
|
|
|
data_size -= bytes;
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
if (bytes <= 26)
|
|
|
|
line[0] = bytes + 'A' - 1;
|
|
|
|
else
|
|
|
|
line[0] = bytes - 26 + 'a' - 1;
|
|
|
|
encode_85(line + 1, cp, bytes);
|
2006-06-18 17:18:09 +02:00
|
|
|
cp = (char *) cp + bytes;
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
puts(line);
|
|
|
|
}
|
|
|
|
printf("\n");
|
2006-05-05 11:41:53 +02:00
|
|
|
free(data);
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
}
|
|
|
|
|
2006-08-17 01:08:14 +02:00
|
|
|
static void emit_binary_diff(mmfile_t *one, mmfile_t *two)
|
|
|
|
{
|
|
|
|
printf("GIT binary patch\n");
|
|
|
|
emit_binary_diff_body(one, two);
|
|
|
|
emit_binary_diff_body(two, one);
|
|
|
|
}
|
|
|
|
|
2007-04-13 08:05:29 +02:00
|
|
|
static void setup_diff_attr_check(struct git_attr_check *check)
|
|
|
|
{
|
|
|
|
static struct git_attr *attr_diff;
|
|
|
|
|
2007-07-06 09:18:54 +02:00
|
|
|
if (!attr_diff) {
|
2007-04-13 08:05:29 +02:00
|
|
|
attr_diff = git_attr("diff", 4);
|
2007-07-06 09:18:54 +02:00
|
|
|
}
|
|
|
|
check[0].attr = attr_diff;
|
2007-04-13 08:05:29 +02:00
|
|
|
}
|
|
|
|
|
2007-07-06 09:18:54 +02:00
|
|
|
static void diff_filespec_check_attr(struct diff_filespec *one)
|
2006-04-22 08:57:45 +02:00
|
|
|
{
|
2007-07-07 10:49:58 +02:00
|
|
|
struct git_attr_check attr_diff_check;
|
2007-07-07 21:25:11 +02:00
|
|
|
int check_from_data = 0;
|
2007-04-13 08:05:29 +02:00
|
|
|
|
2007-07-06 09:18:54 +02:00
|
|
|
if (one->checked_attr)
|
|
|
|
return;
|
|
|
|
|
2007-07-07 10:49:58 +02:00
|
|
|
setup_diff_attr_check(&attr_diff_check);
|
2007-07-06 09:18:54 +02:00
|
|
|
one->is_binary = 0;
|
2007-07-07 10:49:58 +02:00
|
|
|
one->funcname_pattern_ident = NULL;
|
2007-07-06 09:18:54 +02:00
|
|
|
|
2007-07-07 10:49:58 +02:00
|
|
|
if (!git_checkattr(one->path, 1, &attr_diff_check)) {
|
2007-07-06 09:18:54 +02:00
|
|
|
const char *value;
|
|
|
|
|
|
|
|
/* binaryness */
|
2007-07-07 10:49:58 +02:00
|
|
|
value = attr_diff_check.value;
|
2007-04-17 06:33:31 +02:00
|
|
|
if (ATTR_TRUE(value))
|
2007-07-06 09:18:54 +02:00
|
|
|
;
|
2007-04-17 06:33:31 +02:00
|
|
|
else if (ATTR_FALSE(value))
|
2007-07-06 09:18:54 +02:00
|
|
|
one->is_binary = 1;
|
2007-07-07 21:25:11 +02:00
|
|
|
else
|
|
|
|
check_from_data = 1;
|
2007-07-06 09:45:10 +02:00
|
|
|
|
2007-07-07 10:49:58 +02:00
|
|
|
/* funcname pattern ident */
|
2007-07-06 09:45:10 +02:00
|
|
|
if (ATTR_TRUE(value) || ATTR_FALSE(value) || ATTR_UNSET(value))
|
|
|
|
;
|
|
|
|
else
|
2007-07-07 10:49:58 +02:00
|
|
|
one->funcname_pattern_ident = value;
|
2007-04-17 06:33:31 +02:00
|
|
|
}
|
2007-04-15 23:35:11 +02:00
|
|
|
|
2007-07-07 21:25:11 +02:00
|
|
|
if (check_from_data) {
|
|
|
|
if (!one->data && DIFF_FILE_VALID(one))
|
|
|
|
diff_populate_filespec(one, 0);
|
2007-07-06 09:18:54 +02:00
|
|
|
|
2007-07-07 21:25:11 +02:00
|
|
|
if (one->data)
|
|
|
|
one->is_binary = buffer_is_binary(one->data, one->size);
|
|
|
|
}
|
2007-07-06 09:18:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int diff_filespec_is_binary(struct diff_filespec *one)
|
|
|
|
{
|
|
|
|
diff_filespec_check_attr(one);
|
|
|
|
return one->is_binary;
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
2007-07-07 10:49:58 +02:00
|
|
|
static const char *funcname_pattern(const char *ident)
|
2007-07-06 09:45:10 +02:00
|
|
|
{
|
2007-07-07 10:49:58 +02:00
|
|
|
struct funcname_pattern *pp;
|
2007-07-06 09:45:10 +02:00
|
|
|
|
2007-07-07 10:49:58 +02:00
|
|
|
for (pp = funcname_pattern_list; pp; pp = pp->next)
|
|
|
|
if (!strcmp(ident, pp->name))
|
|
|
|
return pp->pattern;
|
2007-07-06 09:45:10 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-07-08 09:25:59 +02:00
|
|
|
static struct builtin_funcname_pattern {
|
|
|
|
const char *name;
|
|
|
|
const char *pattern;
|
|
|
|
} builtin_funcname_pattern[] = {
|
|
|
|
{ "java", "!^[ ]*\\(catch\\|do\\|for\\|if\\|instanceof\\|"
|
|
|
|
"new\\|return\\|switch\\|throw\\|while\\)\n"
|
|
|
|
"^[ ]*\\(\\([ ]*"
|
|
|
|
"[A-Za-z_][A-Za-z_0-9]*\\)\\{2,\\}"
|
|
|
|
"[ ]*([^;]*$\\)" },
|
|
|
|
{ "tex", "^\\(\\\\\\(sub\\)*section{.*\\)$" },
|
|
|
|
};
|
|
|
|
|
2007-07-07 10:49:58 +02:00
|
|
|
static const char *diff_funcname_pattern(struct diff_filespec *one)
|
2007-07-06 09:45:10 +02:00
|
|
|
{
|
2007-07-07 10:49:58 +02:00
|
|
|
const char *ident, *pattern;
|
2007-07-08 09:25:59 +02:00
|
|
|
int i;
|
2007-07-06 09:45:10 +02:00
|
|
|
|
|
|
|
diff_filespec_check_attr(one);
|
2007-07-07 10:49:58 +02:00
|
|
|
ident = one->funcname_pattern_ident;
|
2007-07-06 09:45:10 +02:00
|
|
|
|
|
|
|
if (!ident)
|
|
|
|
/*
|
|
|
|
* If the config file has "funcname.default" defined, that
|
|
|
|
* regexp is used; otherwise NULL is returned and xemit uses
|
|
|
|
* the built-in default.
|
|
|
|
*/
|
2007-07-07 10:49:58 +02:00
|
|
|
return funcname_pattern("default");
|
2007-07-06 09:45:10 +02:00
|
|
|
|
|
|
|
/* Look up custom "funcname.$ident" regexp from config. */
|
2007-07-07 10:49:58 +02:00
|
|
|
pattern = funcname_pattern(ident);
|
|
|
|
if (pattern)
|
|
|
|
return pattern;
|
2007-07-06 09:45:10 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* And define built-in fallback patterns here. Note that
|
2008-01-16 13:46:53 +01:00
|
|
|
* these can be overridden by the user's config settings.
|
2007-07-06 09:45:10 +02:00
|
|
|
*/
|
2007-07-08 09:25:59 +02:00
|
|
|
for (i = 0; i < ARRAY_SIZE(builtin_funcname_pattern); i++)
|
|
|
|
if (!strcmp(ident, builtin_funcname_pattern[i].name))
|
|
|
|
return builtin_funcname_pattern[i].pattern;
|
2007-07-06 09:45:10 +02:00
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
static void builtin_diff(const char *name_a,
|
|
|
|
const char *name_b,
|
|
|
|
struct diff_filespec *one,
|
|
|
|
struct diff_filespec *two,
|
|
|
|
const char *xfrm_msg,
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
struct diff_options *o,
|
2006-04-22 08:57:45 +02:00
|
|
|
int complete_rewrite)
|
|
|
|
{
|
|
|
|
mmfile_t mf1, mf2;
|
|
|
|
const char *lbl[2];
|
|
|
|
char *a_one, *b_two;
|
2007-11-10 20:05:14 +01:00
|
|
|
const char *set = diff_get_color_opt(o, DIFF_METAINFO);
|
|
|
|
const char *reset = diff_get_color_opt(o, DIFF_RESET);
|
2006-04-22 08:57:45 +02:00
|
|
|
|
2007-12-18 20:32:14 +01:00
|
|
|
a_one = quote_two(o->a_prefix, name_a + (*name_a == '/'));
|
|
|
|
b_two = quote_two(o->b_prefix, name_b + (*name_b == '/'));
|
2006-04-22 08:57:45 +02:00
|
|
|
lbl[0] = DIFF_FILE_VALID(one) ? a_one : "/dev/null";
|
|
|
|
lbl[1] = DIFF_FILE_VALID(two) ? b_two : "/dev/null";
|
Tweak diff colors
This patch does:
- always reset the color _before_ printing out the newline.
This is actually important. You (and Johannes) didn't see it, because
it only matters if you set the background, but if you don't do this,
you get some random and funky behaviour if you pick a color with a
non-default background (which still potentially has problems with tabs
etc, but less so).
- allow people to have a different color for the "file headers"
(DIFF_METAINFO) and for the "fragment header" (DIFF_FRAGINFO). Also,
make a difference between "normal color" and "reset colors"
- default to red/green for old/new lines. That's the norm, I'd think.
- instead of that eye-popping (and eye-ball-with-a-fondue-fork-popping)
purple color for metadata, use bold-face for file headers, and cyan for
the frag headers. I actually prefer the "gray background" for that, but
it only works well in xterms, so COLOR_CYAN it is..
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-22 22:53:31 +02:00
|
|
|
printf("%sdiff --git %s %s%s\n", set, a_one, b_two, reset);
|
2006-04-22 08:57:45 +02:00
|
|
|
if (lbl[0][0] == '/') {
|
|
|
|
/* /dev/null */
|
Tweak diff colors
This patch does:
- always reset the color _before_ printing out the newline.
This is actually important. You (and Johannes) didn't see it, because
it only matters if you set the background, but if you don't do this,
you get some random and funky behaviour if you pick a color with a
non-default background (which still potentially has problems with tabs
etc, but less so).
- allow people to have a different color for the "file headers"
(DIFF_METAINFO) and for the "fragment header" (DIFF_FRAGINFO). Also,
make a difference between "normal color" and "reset colors"
- default to red/green for old/new lines. That's the norm, I'd think.
- instead of that eye-popping (and eye-ball-with-a-fondue-fork-popping)
purple color for metadata, use bold-face for file headers, and cyan for
the frag headers. I actually prefer the "gray background" for that, but
it only works well in xterms, so COLOR_CYAN it is..
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-22 22:53:31 +02:00
|
|
|
printf("%snew file mode %06o%s\n", set, two->mode, reset);
|
|
|
|
if (xfrm_msg && xfrm_msg[0])
|
|
|
|
printf("%s%s%s\n", set, xfrm_msg, reset);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
else if (lbl[1][0] == '/') {
|
Tweak diff colors
This patch does:
- always reset the color _before_ printing out the newline.
This is actually important. You (and Johannes) didn't see it, because
it only matters if you set the background, but if you don't do this,
you get some random and funky behaviour if you pick a color with a
non-default background (which still potentially has problems with tabs
etc, but less so).
- allow people to have a different color for the "file headers"
(DIFF_METAINFO) and for the "fragment header" (DIFF_FRAGINFO). Also,
make a difference between "normal color" and "reset colors"
- default to red/green for old/new lines. That's the norm, I'd think.
- instead of that eye-popping (and eye-ball-with-a-fondue-fork-popping)
purple color for metadata, use bold-face for file headers, and cyan for
the frag headers. I actually prefer the "gray background" for that, but
it only works well in xterms, so COLOR_CYAN it is..
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-22 22:53:31 +02:00
|
|
|
printf("%sdeleted file mode %06o%s\n", set, one->mode, reset);
|
|
|
|
if (xfrm_msg && xfrm_msg[0])
|
|
|
|
printf("%s%s%s\n", set, xfrm_msg, reset);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (one->mode != two->mode) {
|
Tweak diff colors
This patch does:
- always reset the color _before_ printing out the newline.
This is actually important. You (and Johannes) didn't see it, because
it only matters if you set the background, but if you don't do this,
you get some random and funky behaviour if you pick a color with a
non-default background (which still potentially has problems with tabs
etc, but less so).
- allow people to have a different color for the "file headers"
(DIFF_METAINFO) and for the "fragment header" (DIFF_FRAGINFO). Also,
make a difference between "normal color" and "reset colors"
- default to red/green for old/new lines. That's the norm, I'd think.
- instead of that eye-popping (and eye-ball-with-a-fondue-fork-popping)
purple color for metadata, use bold-face for file headers, and cyan for
the frag headers. I actually prefer the "gray background" for that, but
it only works well in xterms, so COLOR_CYAN it is..
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-22 22:53:31 +02:00
|
|
|
printf("%sold mode %06o%s\n", set, one->mode, reset);
|
|
|
|
printf("%snew mode %06o%s\n", set, two->mode, reset);
|
2006-06-13 18:45:44 +02:00
|
|
|
}
|
Tweak diff colors
This patch does:
- always reset the color _before_ printing out the newline.
This is actually important. You (and Johannes) didn't see it, because
it only matters if you set the background, but if you don't do this,
you get some random and funky behaviour if you pick a color with a
non-default background (which still potentially has problems with tabs
etc, but less so).
- allow people to have a different color for the "file headers"
(DIFF_METAINFO) and for the "fragment header" (DIFF_FRAGINFO). Also,
make a difference between "normal color" and "reset colors"
- default to red/green for old/new lines. That's the norm, I'd think.
- instead of that eye-popping (and eye-ball-with-a-fondue-fork-popping)
purple color for metadata, use bold-face for file headers, and cyan for
the frag headers. I actually prefer the "gray background" for that, but
it only works well in xterms, so COLOR_CYAN it is..
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-22 22:53:31 +02:00
|
|
|
if (xfrm_msg && xfrm_msg[0])
|
|
|
|
printf("%s%s%s\n", set, xfrm_msg, reset);
|
2006-04-22 08:57:45 +02:00
|
|
|
/*
|
|
|
|
* we do not run diff between different kind
|
|
|
|
* of objects.
|
|
|
|
*/
|
|
|
|
if ((one->mode ^ two->mode) & S_IFMT)
|
|
|
|
goto free_ab_and_return;
|
|
|
|
if (complete_rewrite) {
|
2007-12-18 20:32:14 +01:00
|
|
|
emit_rewrite_diff(name_a, name_b, one, two, o);
|
2007-02-25 23:34:54 +01:00
|
|
|
o->found_changes = 1;
|
2006-04-22 08:57:45 +02:00
|
|
|
goto free_ab_and_return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
|
|
|
|
die("unable to read files to diff");
|
|
|
|
|
2007-11-10 20:05:14 +01:00
|
|
|
if (!DIFF_OPT_TST(o, TEXT) &&
|
2007-07-06 09:18:54 +02:00
|
|
|
(diff_filespec_is_binary(one) || diff_filespec_is_binary(two))) {
|
2006-05-05 11:41:53 +02:00
|
|
|
/* Quite common confusing case */
|
|
|
|
if (mf1.size == mf2.size &&
|
|
|
|
!memcmp(mf1.ptr, mf2.ptr, mf1.size))
|
|
|
|
goto free_ab_and_return;
|
2007-11-10 20:05:14 +01:00
|
|
|
if (DIFF_OPT_TST(o, BINARY))
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
emit_binary_diff(&mf1, &mf2);
|
|
|
|
else
|
|
|
|
printf("Binary files %s and %s differ\n",
|
|
|
|
lbl[0], lbl[1]);
|
2007-02-25 23:34:54 +01:00
|
|
|
o->found_changes = 1;
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
}
|
2006-04-22 08:57:45 +02:00
|
|
|
else {
|
|
|
|
/* Crazy xdl interfaces.. */
|
|
|
|
const char *diffopts = getenv("GIT_DIFF_OPTS");
|
|
|
|
xpparam_t xpp;
|
|
|
|
xdemitconf_t xecfg;
|
|
|
|
xdemitcb_t ecb;
|
|
|
|
struct emit_callback ecbdata;
|
2007-07-07 10:49:58 +02:00
|
|
|
const char *funcname_pattern;
|
2007-07-06 09:45:10 +02:00
|
|
|
|
2007-07-07 10:49:58 +02:00
|
|
|
funcname_pattern = diff_funcname_pattern(one);
|
|
|
|
if (!funcname_pattern)
|
|
|
|
funcname_pattern = diff_funcname_pattern(two);
|
2006-04-22 08:57:45 +02:00
|
|
|
|
2007-07-04 20:05:46 +02:00
|
|
|
memset(&xecfg, 0, sizeof(xecfg));
|
2006-06-13 18:45:44 +02:00
|
|
|
memset(&ecbdata, 0, sizeof(ecbdata));
|
2006-04-22 08:57:45 +02:00
|
|
|
ecbdata.label_path = lbl;
|
2007-11-10 20:05:14 +01:00
|
|
|
ecbdata.color_diff = DIFF_OPT_TST(o, COLOR_DIFF);
|
2007-02-25 23:34:54 +01:00
|
|
|
ecbdata.found_changesp = &o->found_changes;
|
2007-12-06 09:14:14 +01:00
|
|
|
ecbdata.ws_rule = whitespace_rule(name_b ? name_b : name_a);
|
2006-06-14 17:40:23 +02:00
|
|
|
xpp.flags = XDF_NEED_MINIMAL | o->xdl_opts;
|
2006-05-13 22:23:48 +02:00
|
|
|
xecfg.ctxlen = o->context;
|
2006-04-22 08:57:45 +02:00
|
|
|
xecfg.flags = XDL_EMIT_FUNCNAMES;
|
2007-07-07 10:49:58 +02:00
|
|
|
if (funcname_pattern)
|
|
|
|
xdiff_set_find_func(&xecfg, funcname_pattern);
|
2006-04-22 08:57:45 +02:00
|
|
|
if (!diffopts)
|
|
|
|
;
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 10:53:29 +01:00
|
|
|
else if (!prefixcmp(diffopts, "--unified="))
|
2006-04-22 08:57:45 +02:00
|
|
|
xecfg.ctxlen = strtoul(diffopts + 10, NULL, 10);
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 10:53:29 +01:00
|
|
|
else if (!prefixcmp(diffopts, "-u"))
|
2006-04-22 08:57:45 +02:00
|
|
|
xecfg.ctxlen = strtoul(diffopts + 2, NULL, 10);
|
2006-06-13 18:45:44 +02:00
|
|
|
ecb.outf = xdiff_outf;
|
2006-04-22 08:57:45 +02:00
|
|
|
ecb.priv = &ecbdata;
|
2006-06-13 18:45:44 +02:00
|
|
|
ecbdata.xm.consume = fn_out_consume;
|
2007-11-10 20:05:14 +01:00
|
|
|
if (DIFF_OPT_TST(o, COLOR_DIFF_WORDS))
|
2006-07-28 23:56:15 +02:00
|
|
|
ecbdata.diff_words =
|
|
|
|
xcalloc(1, sizeof(struct diff_words_data));
|
2007-12-13 22:25:07 +01:00
|
|
|
xdi_diff(&mf1, &mf2, &xpp, &xecfg, &ecb);
|
2007-11-10 20:05:14 +01:00
|
|
|
if (DIFF_OPT_TST(o, COLOR_DIFF_WORDS))
|
2006-07-28 23:56:15 +02:00
|
|
|
free_diff_words_data(&ecbdata);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
free_ab_and_return:
|
2007-05-03 22:05:48 +02:00
|
|
|
diff_free_filespec_data(one);
|
|
|
|
diff_free_filespec_data(two);
|
2006-04-22 08:57:45 +02:00
|
|
|
free(a_one);
|
|
|
|
free(b_two);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void builtin_diffstat(const char *name_a, const char *name_b,
|
|
|
|
struct diff_filespec *one,
|
|
|
|
struct diff_filespec *two,
|
2006-04-26 08:40:09 +02:00
|
|
|
struct diffstat_t *diffstat,
|
2006-06-14 17:40:23 +02:00
|
|
|
struct diff_options *o,
|
2006-04-26 08:40:09 +02:00
|
|
|
int complete_rewrite)
|
2006-04-22 08:57:45 +02:00
|
|
|
{
|
|
|
|
mmfile_t mf1, mf2;
|
|
|
|
struct diffstat_file *data;
|
|
|
|
|
|
|
|
data = diffstat_add(diffstat, name_a, name_b);
|
|
|
|
|
|
|
|
if (!one || !two) {
|
|
|
|
data->is_unmerged = 1;
|
|
|
|
return;
|
|
|
|
}
|
2006-04-26 08:40:09 +02:00
|
|
|
if (complete_rewrite) {
|
|
|
|
diff_populate_filespec(one, 0);
|
|
|
|
diff_populate_filespec(two, 0);
|
|
|
|
data->deleted = count_lines(one->data, one->size);
|
|
|
|
data->added = count_lines(two->data, two->size);
|
2007-05-03 22:05:48 +02:00
|
|
|
goto free_and_return;
|
2006-04-26 08:40:09 +02:00
|
|
|
}
|
2006-04-22 08:57:45 +02:00
|
|
|
if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
|
|
|
|
die("unable to read files to diff");
|
|
|
|
|
2007-07-06 09:18:54 +02:00
|
|
|
if (diff_filespec_is_binary(one) || diff_filespec_is_binary(two)) {
|
2006-04-22 08:57:45 +02:00
|
|
|
data->is_binary = 1;
|
2007-04-04 15:14:14 +02:00
|
|
|
data->added = mf2.size;
|
|
|
|
data->deleted = mf1.size;
|
|
|
|
} else {
|
2006-04-22 08:57:45 +02:00
|
|
|
/* Crazy xdl interfaces.. */
|
|
|
|
xpparam_t xpp;
|
|
|
|
xdemitconf_t xecfg;
|
|
|
|
xdemitcb_t ecb;
|
|
|
|
|
2007-07-04 20:05:46 +02:00
|
|
|
memset(&xecfg, 0, sizeof(xecfg));
|
2006-06-14 17:40:23 +02:00
|
|
|
xpp.flags = XDF_NEED_MINIMAL | o->xdl_opts;
|
2006-04-22 08:57:45 +02:00
|
|
|
ecb.outf = xdiff_outf;
|
|
|
|
ecb.priv = diffstat;
|
2007-12-13 22:25:07 +01:00
|
|
|
xdi_diff(&mf1, &mf2, &xpp, &xecfg, &ecb);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
2007-05-03 22:05:48 +02:00
|
|
|
|
|
|
|
free_and_return:
|
|
|
|
diff_free_filespec_data(one);
|
|
|
|
diff_free_filespec_data(two);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
2006-05-20 23:43:13 +02:00
|
|
|
static void builtin_checkdiff(const char *name_a, const char *name_b,
|
|
|
|
struct diff_filespec *one,
|
2007-02-18 17:27:24 +01:00
|
|
|
struct diff_filespec *two, struct diff_options *o)
|
2006-05-20 23:43:13 +02:00
|
|
|
{
|
|
|
|
mmfile_t mf1, mf2;
|
|
|
|
struct checkdiff_t data;
|
|
|
|
|
|
|
|
if (!two)
|
|
|
|
return;
|
|
|
|
|
|
|
|
memset(&data, 0, sizeof(data));
|
|
|
|
data.xm.consume = checkdiff_consume;
|
|
|
|
data.filename = name_b ? name_b : name_a;
|
|
|
|
data.lineno = 0;
|
2007-11-10 20:05:14 +01:00
|
|
|
data.color_diff = DIFF_OPT_TST(o, COLOR_DIFF);
|
2007-12-06 09:14:14 +01:00
|
|
|
data.ws_rule = whitespace_rule(data.filename);
|
2006-05-20 23:43:13 +02:00
|
|
|
|
|
|
|
if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
|
|
|
|
die("unable to read files to diff");
|
|
|
|
|
2007-07-06 09:18:54 +02:00
|
|
|
if (diff_filespec_is_binary(two))
|
2007-05-03 22:05:48 +02:00
|
|
|
goto free_and_return;
|
2006-05-20 23:43:13 +02:00
|
|
|
else {
|
|
|
|
/* Crazy xdl interfaces.. */
|
|
|
|
xpparam_t xpp;
|
|
|
|
xdemitconf_t xecfg;
|
|
|
|
xdemitcb_t ecb;
|
|
|
|
|
2007-07-04 20:05:46 +02:00
|
|
|
memset(&xecfg, 0, sizeof(xecfg));
|
2006-05-20 23:43:13 +02:00
|
|
|
xpp.flags = XDF_NEED_MINIMAL;
|
|
|
|
ecb.outf = xdiff_outf;
|
|
|
|
ecb.priv = &data;
|
2007-12-13 22:25:07 +01:00
|
|
|
xdi_diff(&mf1, &mf2, &xpp, &xecfg, &ecb);
|
2006-05-20 23:43:13 +02:00
|
|
|
}
|
2007-05-03 22:05:48 +02:00
|
|
|
free_and_return:
|
|
|
|
diff_free_filespec_data(one);
|
|
|
|
diff_free_filespec_data(two);
|
2007-12-13 21:24:52 +01:00
|
|
|
if (data.status)
|
|
|
|
DIFF_OPT_SET(o, CHECK_FAILED);
|
2006-05-20 23:43:13 +02:00
|
|
|
}
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
struct diff_filespec *alloc_filespec(const char *path)
|
|
|
|
{
|
|
|
|
int namelen = strlen(path);
|
|
|
|
struct diff_filespec *spec = xmalloc(sizeof(*spec) + namelen + 1);
|
|
|
|
|
|
|
|
memset(spec, 0, sizeof(*spec));
|
|
|
|
spec->path = (char *)(spec + 1);
|
|
|
|
memcpy(spec->path, path, namelen+1);
|
2007-10-25 20:19:10 +02:00
|
|
|
spec->count = 1;
|
2006-04-22 08:57:45 +02:00
|
|
|
return spec;
|
|
|
|
}
|
|
|
|
|
2007-10-25 20:19:10 +02:00
|
|
|
void free_filespec(struct diff_filespec *spec)
|
|
|
|
{
|
|
|
|
if (!--spec->count) {
|
|
|
|
diff_free_filespec_data(spec);
|
|
|
|
free(spec);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
void fill_filespec(struct diff_filespec *spec, const unsigned char *sha1,
|
|
|
|
unsigned short mode)
|
|
|
|
{
|
|
|
|
if (mode) {
|
|
|
|
spec->mode = canon_mode(mode);
|
2006-08-23 08:49:00 +02:00
|
|
|
hashcpy(spec->sha1, sha1);
|
2006-08-15 22:37:19 +02:00
|
|
|
spec->sha1_valid = !is_null_sha1(sha1);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2007-05-26 00:37:40 +02:00
|
|
|
* Given a name and sha1 pair, if the index tells us the file in
|
2006-04-22 08:57:45 +02:00
|
|
|
* the work tree has that object contents, return true, so that
|
|
|
|
* prepare_temp_file() does not have to inflate and extract.
|
|
|
|
*/
|
2006-12-14 12:15:57 +01:00
|
|
|
static int reuse_worktree_file(const char *name, const unsigned char *sha1, int want_file)
|
2006-04-22 08:57:45 +02:00
|
|
|
{
|
|
|
|
struct cache_entry *ce;
|
|
|
|
struct stat st;
|
|
|
|
int pos, len;
|
|
|
|
|
|
|
|
/* We do not read the cache ourselves here, because the
|
|
|
|
* benchmark with my previous version that always reads cache
|
|
|
|
* shows that it makes things worse for diff-tree comparing
|
|
|
|
* two linux-2.6 kernel trees in an already checked out work
|
|
|
|
* tree. This is because most diff-tree comparisons deal with
|
|
|
|
* only a small number of files, while reading the cache is
|
|
|
|
* expensive for a large project, and its cost outweighs the
|
|
|
|
* savings we get by not inflating the object to a temporary
|
|
|
|
* file. Practically, this code only helps when we are used
|
|
|
|
* by diff-cache --cached, which does read the cache before
|
|
|
|
* calling us.
|
|
|
|
*/
|
|
|
|
if (!active_cache)
|
|
|
|
return 0;
|
|
|
|
|
2006-12-14 12:15:57 +01:00
|
|
|
/* We want to avoid the working directory if our caller
|
|
|
|
* doesn't need the data in a normal file, this system
|
|
|
|
* is rather slow with its stat/open/mmap/close syscalls,
|
|
|
|
* and the object is contained in a pack file. The pack
|
|
|
|
* is probably already open and will be faster to obtain
|
|
|
|
* the data through than the working directory. Loose
|
|
|
|
* objects however would tend to be slower as they need
|
|
|
|
* to be individually opened and inflated.
|
|
|
|
*/
|
2006-12-20 03:26:48 +01:00
|
|
|
if (!FAST_WORKING_DIRECTORY && !want_file && has_sha1_pack(sha1, NULL))
|
2006-12-14 12:15:57 +01:00
|
|
|
return 0;
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
len = strlen(name);
|
|
|
|
pos = cache_name_pos(name, len);
|
|
|
|
if (pos < 0)
|
|
|
|
return 0;
|
|
|
|
ce = active_cache[pos];
|
|
|
|
if ((lstat(name, &st) < 0) ||
|
|
|
|
!S_ISREG(st.st_mode) || /* careful! */
|
|
|
|
ce_match_stat(ce, &st, 0) ||
|
2006-08-17 20:54:57 +02:00
|
|
|
hashcmp(sha1, ce->sha1))
|
2006-04-22 08:57:45 +02:00
|
|
|
return 0;
|
|
|
|
/* we return 1 only when we can stat, it is a regular file,
|
|
|
|
* stat information matches, and sha1 recorded in the cache
|
|
|
|
* matches. I.e. we know the file in the work tree really is
|
|
|
|
* the same as the <name, sha1> pair.
|
|
|
|
*/
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-03-04 09:17:27 +01:00
|
|
|
static int populate_from_stdin(struct diff_filespec *s)
|
|
|
|
{
|
2007-09-06 13:20:09 +02:00
|
|
|
struct strbuf buf;
|
2007-10-21 11:23:49 +02:00
|
|
|
size_t size = 0;
|
2007-09-06 13:20:09 +02:00
|
|
|
|
2007-09-10 12:35:04 +02:00
|
|
|
strbuf_init(&buf, 0);
|
|
|
|
if (strbuf_read(&buf, 0, 0) < 0)
|
2007-09-06 13:20:09 +02:00
|
|
|
return error("error while reading from stdin %s",
|
2007-03-04 09:17:27 +01:00
|
|
|
strerror(errno));
|
2007-09-06 13:20:09 +02:00
|
|
|
|
2007-03-04 09:17:27 +01:00
|
|
|
s->should_munmap = 0;
|
2007-10-21 11:23:49 +02:00
|
|
|
s->data = strbuf_detach(&buf, &size);
|
|
|
|
s->size = size;
|
2007-03-04 09:17:27 +01:00
|
|
|
s->should_free = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
Expose subprojects as special files to "git diff" machinery
The same way we generate diffs on symlinks as the the diff of text of the
symlink, we can generate subproject diffs (when not recursing into them!)
as the diff of the text that describes the subproject.
Of course, since what descibes a subproject is just the SHA1, that's what
we'll use. Add some pretty-printing to make it a bit more obvious what is
going on, and we're done.
So with this, we can get both raw diffs and "textual" diffs of subproject
changes:
- git diff --raw:
:160000 160000 2de597b5ad348b7db04bd10cdd38cd81cbc93ab5 0000000... M sub-A
- git diff:
diff --git a/sub-A b/sub-A
index 2de597b..e8f11a4 160000
--- a/sub-A
+++ b/sub-A
@@ -1 +1 @@
-Subproject commit 2de597b5ad348b7db04bd10cdd38cd81cbc93ab5
+Subproject commit e8f11a45c5c6b9e2fec6d136d3fb5aff75393d42
NOTE! We'll also want to have the ability to recurse into the subproject
and actually diff it recursively, but that will involve a new command line
option (I'd suggest "--subproject" and "-S", but the latter is in use by
pickaxe), and some very different code.
But regardless of ay future recursive behaviour, we need the non-recursive
version too (and it should be the default, at least in the absense of
config options, so that large superprojects don't default to something
extremely expensive).
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-04-15 20:14:28 +02:00
|
|
|
static int diff_populate_gitlink(struct diff_filespec *s, int size_only)
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
char *data = xmalloc(100);
|
|
|
|
len = snprintf(data, 100,
|
|
|
|
"Subproject commit %s\n", sha1_to_hex(s->sha1));
|
|
|
|
s->data = data;
|
|
|
|
s->size = len;
|
|
|
|
s->should_free = 1;
|
|
|
|
if (size_only) {
|
|
|
|
s->data = NULL;
|
|
|
|
free(data);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
/*
|
|
|
|
* While doing rename detection and pickaxe operation, we may need to
|
|
|
|
* grab the data for the blob (or file) for our own in-core comparison.
|
|
|
|
* diff_filespec has data and size fields for this purpose.
|
|
|
|
*/
|
|
|
|
int diff_populate_filespec(struct diff_filespec *s, int size_only)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
if (!DIFF_FILE_VALID(s))
|
|
|
|
die("internal error: asking to populate invalid file.");
|
|
|
|
if (S_ISDIR(s->mode))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (s->data)
|
2007-05-03 22:05:48 +02:00
|
|
|
return 0;
|
Expose subprojects as special files to "git diff" machinery
The same way we generate diffs on symlinks as the the diff of text of the
symlink, we can generate subproject diffs (when not recursing into them!)
as the diff of the text that describes the subproject.
Of course, since what descibes a subproject is just the SHA1, that's what
we'll use. Add some pretty-printing to make it a bit more obvious what is
going on, and we're done.
So with this, we can get both raw diffs and "textual" diffs of subproject
changes:
- git diff --raw:
:160000 160000 2de597b5ad348b7db04bd10cdd38cd81cbc93ab5 0000000... M sub-A
- git diff:
diff --git a/sub-A b/sub-A
index 2de597b..e8f11a4 160000
--- a/sub-A
+++ b/sub-A
@@ -1 +1 @@
-Subproject commit 2de597b5ad348b7db04bd10cdd38cd81cbc93ab5
+Subproject commit e8f11a45c5c6b9e2fec6d136d3fb5aff75393d42
NOTE! We'll also want to have the ability to recurse into the subproject
and actually diff it recursively, but that will involve a new command line
option (I'd suggest "--subproject" and "-S", but the latter is in use by
pickaxe), and some very different code.
But regardless of ay future recursive behaviour, we need the non-recursive
version too (and it should be the default, at least in the absense of
config options, so that large superprojects don't default to something
extremely expensive).
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-04-15 20:14:28 +02:00
|
|
|
|
2007-05-07 10:14:21 +02:00
|
|
|
if (size_only && 0 < s->size)
|
|
|
|
return 0;
|
|
|
|
|
2007-05-21 22:08:28 +02:00
|
|
|
if (S_ISGITLINK(s->mode))
|
Expose subprojects as special files to "git diff" machinery
The same way we generate diffs on symlinks as the the diff of text of the
symlink, we can generate subproject diffs (when not recursing into them!)
as the diff of the text that describes the subproject.
Of course, since what descibes a subproject is just the SHA1, that's what
we'll use. Add some pretty-printing to make it a bit more obvious what is
going on, and we're done.
So with this, we can get both raw diffs and "textual" diffs of subproject
changes:
- git diff --raw:
:160000 160000 2de597b5ad348b7db04bd10cdd38cd81cbc93ab5 0000000... M sub-A
- git diff:
diff --git a/sub-A b/sub-A
index 2de597b..e8f11a4 160000
--- a/sub-A
+++ b/sub-A
@@ -1 +1 @@
-Subproject commit 2de597b5ad348b7db04bd10cdd38cd81cbc93ab5
+Subproject commit e8f11a45c5c6b9e2fec6d136d3fb5aff75393d42
NOTE! We'll also want to have the ability to recurse into the subproject
and actually diff it recursively, but that will involve a new command line
option (I'd suggest "--subproject" and "-S", but the latter is in use by
pickaxe), and some very different code.
But regardless of ay future recursive behaviour, we need the non-recursive
version too (and it should be the default, at least in the absense of
config options, so that large superprojects don't default to something
extremely expensive).
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-04-15 20:14:28 +02:00
|
|
|
return diff_populate_gitlink(s, size_only);
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
if (!s->sha1_valid ||
|
2006-12-14 12:15:57 +01:00
|
|
|
reuse_worktree_file(s->path, s->sha1, 0)) {
|
Rewrite convert_to_{git,working_tree} to use strbuf's.
* Now, those functions take an "out" strbuf argument, where they store their
result if any. In that case, it also returns 1, else it returns 0.
* those functions support "in place" editing, in the sense that it's OK to
call them this way:
convert_to_git(path, sb->buf, sb->len, sb);
When doable, conversions are done in place for real, else the strbuf
content is just replaced with the new one, transparentely for the caller.
If you want to create a new filter working this way, being the accumulation
of filter1, filter2, ... filtern, then your meta_filter would be:
int meta_filter(..., const char *src, size_t len, struct strbuf *sb)
{
int ret = 0;
ret |= filter1(...., src, len, sb);
if (ret) {
src = sb->buf;
len = sb->len;
}
ret |= filter2(...., src, len, sb);
if (ret) {
src = sb->buf;
len = sb->len;
}
....
return ret | filtern(..., src, len, sb);
}
That's why subfilters the convert_to_* functions called were also rewritten
to work this way.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-09-16 15:51:04 +02:00
|
|
|
struct strbuf buf;
|
2006-04-22 08:57:45 +02:00
|
|
|
struct stat st;
|
|
|
|
int fd;
|
Lazy man's auto-CRLF
It currently does NOT know about file attributes, so it does its
conversion purely based on content. Maybe that is more in the "git
philosophy" anyway, since content is king, but I think we should try to do
the file attributes to turn it off on demand.
Anyway, BY DEFAULT it is off regardless, because it requires a
[core]
AutoCRLF = true
in your config file to be enabled. We could make that the default for
Windows, of course, the same way we do some other things (filemode etc).
But you can actually enable it on UNIX, and it will cause:
- "git update-index" will write blobs without CRLF
- "git diff" will diff working tree files without CRLF
- "git checkout" will write files to the working tree _with_ CRLF
and things work fine.
Funnily, it actually shows an odd file in git itself:
git clone -n git test-crlf
cd test-crlf
git config core.autocrlf true
git checkout
git diff
shows a diff for "Documentation/docbook-xsl.css". Why? Because we have
actually checked in that file *with* CRLF! So when "core.autocrlf" is
true, we'll always generate a *different* hash for it in the index,
because the index hash will be for the content _without_ CRLF.
Is this complete? I dunno. It seems to work for me. It doesn't use the
filename at all right now, and that's probably a deficiency (we could
certainly make the "is_binary()" heuristics also take standard filename
heuristics into account).
I don't pass in the filename at all for the "index_fd()" case
(git-update-index), so that would need to be passed around, but this
actually works fine.
NOTE NOTE NOTE! The "is_binary()" heuristics are totally made-up by yours
truly. I will not guarantee that they work at all reasonable. Caveat
emptor. But it _is_ simple, and it _is_ safe, since it's all off by
default.
The patch is pretty simple - the biggest part is the new "convert.c" file,
but even that is really just basic stuff that anybody can write in
"Teaching C 101" as a final project for their first class in programming.
Not to say that it's bug-free, of course - but at least we're not talking
about rocket surgery here.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-13 20:07:23 +01:00
|
|
|
|
2007-03-04 09:17:27 +01:00
|
|
|
if (!strcmp(s->path, "-"))
|
|
|
|
return populate_from_stdin(s);
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
if (lstat(s->path, &st) < 0) {
|
|
|
|
if (errno == ENOENT) {
|
|
|
|
err_empty:
|
|
|
|
err = -1;
|
|
|
|
empty:
|
2006-06-24 19:20:32 +02:00
|
|
|
s->data = (char *)"";
|
2006-04-22 08:57:45 +02:00
|
|
|
s->size = 0;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
}
|
2007-03-07 02:44:37 +01:00
|
|
|
s->size = xsize_t(st.st_size);
|
2006-04-22 08:57:45 +02:00
|
|
|
if (!s->size)
|
|
|
|
goto empty;
|
|
|
|
if (size_only)
|
|
|
|
return 0;
|
|
|
|
if (S_ISLNK(st.st_mode)) {
|
|
|
|
int ret;
|
|
|
|
s->data = xmalloc(s->size);
|
|
|
|
s->should_free = 1;
|
|
|
|
ret = readlink(s->path, s->data, s->size);
|
|
|
|
if (ret < 0) {
|
|
|
|
free(s->data);
|
|
|
|
goto err_empty;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
fd = open(s->path, O_RDONLY);
|
|
|
|
if (fd < 0)
|
|
|
|
goto err_empty;
|
2006-12-24 06:47:23 +01:00
|
|
|
s->data = xmmap(NULL, s->size, PROT_READ, MAP_PRIVATE, fd, 0);
|
2006-04-22 08:57:45 +02:00
|
|
|
close(fd);
|
|
|
|
s->should_munmap = 1;
|
Lazy man's auto-CRLF
It currently does NOT know about file attributes, so it does its
conversion purely based on content. Maybe that is more in the "git
philosophy" anyway, since content is king, but I think we should try to do
the file attributes to turn it off on demand.
Anyway, BY DEFAULT it is off regardless, because it requires a
[core]
AutoCRLF = true
in your config file to be enabled. We could make that the default for
Windows, of course, the same way we do some other things (filemode etc).
But you can actually enable it on UNIX, and it will cause:
- "git update-index" will write blobs without CRLF
- "git diff" will diff working tree files without CRLF
- "git checkout" will write files to the working tree _with_ CRLF
and things work fine.
Funnily, it actually shows an odd file in git itself:
git clone -n git test-crlf
cd test-crlf
git config core.autocrlf true
git checkout
git diff
shows a diff for "Documentation/docbook-xsl.css". Why? Because we have
actually checked in that file *with* CRLF! So when "core.autocrlf" is
true, we'll always generate a *different* hash for it in the index,
because the index hash will be for the content _without_ CRLF.
Is this complete? I dunno. It seems to work for me. It doesn't use the
filename at all right now, and that's probably a deficiency (we could
certainly make the "is_binary()" heuristics also take standard filename
heuristics into account).
I don't pass in the filename at all for the "index_fd()" case
(git-update-index), so that would need to be passed around, but this
actually works fine.
NOTE NOTE NOTE! The "is_binary()" heuristics are totally made-up by yours
truly. I will not guarantee that they work at all reasonable. Caveat
emptor. But it _is_ simple, and it _is_ safe, since it's all off by
default.
The patch is pretty simple - the biggest part is the new "convert.c" file,
but even that is really just basic stuff that anybody can write in
"Teaching C 101" as a final project for their first class in programming.
Not to say that it's bug-free, of course - but at least we're not talking
about rocket surgery here.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-13 20:07:23 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert from working tree format to canonical git format
|
|
|
|
*/
|
Rewrite convert_to_{git,working_tree} to use strbuf's.
* Now, those functions take an "out" strbuf argument, where they store their
result if any. In that case, it also returns 1, else it returns 0.
* those functions support "in place" editing, in the sense that it's OK to
call them this way:
convert_to_git(path, sb->buf, sb->len, sb);
When doable, conversions are done in place for real, else the strbuf
content is just replaced with the new one, transparentely for the caller.
If you want to create a new filter working this way, being the accumulation
of filter1, filter2, ... filtern, then your meta_filter would be:
int meta_filter(..., const char *src, size_t len, struct strbuf *sb)
{
int ret = 0;
ret |= filter1(...., src, len, sb);
if (ret) {
src = sb->buf;
len = sb->len;
}
ret |= filter2(...., src, len, sb);
if (ret) {
src = sb->buf;
len = sb->len;
}
....
return ret | filtern(..., src, len, sb);
}
That's why subfilters the convert_to_* functions called were also rewritten
to work this way.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-09-16 15:51:04 +02:00
|
|
|
strbuf_init(&buf, 0);
|
|
|
|
if (convert_to_git(s->path, s->data, s->size, &buf)) {
|
2007-10-21 11:23:49 +02:00
|
|
|
size_t size = 0;
|
Lazy man's auto-CRLF
It currently does NOT know about file attributes, so it does its
conversion purely based on content. Maybe that is more in the "git
philosophy" anyway, since content is king, but I think we should try to do
the file attributes to turn it off on demand.
Anyway, BY DEFAULT it is off regardless, because it requires a
[core]
AutoCRLF = true
in your config file to be enabled. We could make that the default for
Windows, of course, the same way we do some other things (filemode etc).
But you can actually enable it on UNIX, and it will cause:
- "git update-index" will write blobs without CRLF
- "git diff" will diff working tree files without CRLF
- "git checkout" will write files to the working tree _with_ CRLF
and things work fine.
Funnily, it actually shows an odd file in git itself:
git clone -n git test-crlf
cd test-crlf
git config core.autocrlf true
git checkout
git diff
shows a diff for "Documentation/docbook-xsl.css". Why? Because we have
actually checked in that file *with* CRLF! So when "core.autocrlf" is
true, we'll always generate a *different* hash for it in the index,
because the index hash will be for the content _without_ CRLF.
Is this complete? I dunno. It seems to work for me. It doesn't use the
filename at all right now, and that's probably a deficiency (we could
certainly make the "is_binary()" heuristics also take standard filename
heuristics into account).
I don't pass in the filename at all for the "index_fd()" case
(git-update-index), so that would need to be passed around, but this
actually works fine.
NOTE NOTE NOTE! The "is_binary()" heuristics are totally made-up by yours
truly. I will not guarantee that they work at all reasonable. Caveat
emptor. But it _is_ simple, and it _is_ safe, since it's all off by
default.
The patch is pretty simple - the biggest part is the new "convert.c" file,
but even that is really just basic stuff that anybody can write in
"Teaching C 101" as a final project for their first class in programming.
Not to say that it's bug-free, of course - but at least we're not talking
about rocket surgery here.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-13 20:07:23 +01:00
|
|
|
munmap(s->data, s->size);
|
|
|
|
s->should_munmap = 0;
|
2007-10-21 11:23:49 +02:00
|
|
|
s->data = strbuf_detach(&buf, &size);
|
|
|
|
s->size = size;
|
Lazy man's auto-CRLF
It currently does NOT know about file attributes, so it does its
conversion purely based on content. Maybe that is more in the "git
philosophy" anyway, since content is king, but I think we should try to do
the file attributes to turn it off on demand.
Anyway, BY DEFAULT it is off regardless, because it requires a
[core]
AutoCRLF = true
in your config file to be enabled. We could make that the default for
Windows, of course, the same way we do some other things (filemode etc).
But you can actually enable it on UNIX, and it will cause:
- "git update-index" will write blobs without CRLF
- "git diff" will diff working tree files without CRLF
- "git checkout" will write files to the working tree _with_ CRLF
and things work fine.
Funnily, it actually shows an odd file in git itself:
git clone -n git test-crlf
cd test-crlf
git config core.autocrlf true
git checkout
git diff
shows a diff for "Documentation/docbook-xsl.css". Why? Because we have
actually checked in that file *with* CRLF! So when "core.autocrlf" is
true, we'll always generate a *different* hash for it in the index,
because the index hash will be for the content _without_ CRLF.
Is this complete? I dunno. It seems to work for me. It doesn't use the
filename at all right now, and that's probably a deficiency (we could
certainly make the "is_binary()" heuristics also take standard filename
heuristics into account).
I don't pass in the filename at all for the "index_fd()" case
(git-update-index), so that would need to be passed around, but this
actually works fine.
NOTE NOTE NOTE! The "is_binary()" heuristics are totally made-up by yours
truly. I will not guarantee that they work at all reasonable. Caveat
emptor. But it _is_ simple, and it _is_ safe, since it's all off by
default.
The patch is pretty simple - the biggest part is the new "convert.c" file,
but even that is really just basic stuff that anybody can write in
"Teaching C 101" as a final project for their first class in programming.
Not to say that it's bug-free, of course - but at least we're not talking
about rocket surgery here.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-13 20:07:23 +01:00
|
|
|
s->should_free = 1;
|
|
|
|
}
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
else {
|
2007-02-26 20:55:59 +01:00
|
|
|
enum object_type type;
|
2007-05-07 10:14:21 +02:00
|
|
|
if (size_only)
|
2007-02-26 20:55:59 +01:00
|
|
|
type = sha1_object_info(s->sha1, &s->size);
|
2006-04-22 08:57:45 +02:00
|
|
|
else {
|
2007-02-26 20:55:59 +01:00
|
|
|
s->data = read_sha1_file(s->sha1, &type, &s->size);
|
2006-04-22 08:57:45 +02:00
|
|
|
s->should_free = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-10-03 06:01:03 +02:00
|
|
|
void diff_free_filespec_blob(struct diff_filespec *s)
|
2006-04-22 08:57:45 +02:00
|
|
|
{
|
|
|
|
if (s->should_free)
|
|
|
|
free(s->data);
|
|
|
|
else if (s->should_munmap)
|
|
|
|
munmap(s->data, s->size);
|
2007-05-03 22:05:48 +02:00
|
|
|
|
|
|
|
if (s->should_free || s->should_munmap) {
|
|
|
|
s->should_free = s->should_munmap = 0;
|
|
|
|
s->data = NULL;
|
|
|
|
}
|
2007-09-25 21:29:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void diff_free_filespec_data(struct diff_filespec *s)
|
|
|
|
{
|
2007-10-03 06:01:03 +02:00
|
|
|
diff_free_filespec_blob(s);
|
2006-04-22 08:57:45 +02:00
|
|
|
free(s->cnt_data);
|
|
|
|
s->cnt_data = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void prep_temp_blob(struct diff_tempfile *temp,
|
|
|
|
void *blob,
|
|
|
|
unsigned long size,
|
|
|
|
const unsigned char *sha1,
|
|
|
|
int mode)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
|
2007-05-20 15:35:46 +02:00
|
|
|
fd = git_mkstemp(temp->tmp_path, PATH_MAX, ".diff_XXXXXX");
|
2006-04-22 08:57:45 +02:00
|
|
|
if (fd < 0)
|
2007-07-26 06:34:53 +02:00
|
|
|
die("unable to create temp-file: %s", strerror(errno));
|
2007-01-08 16:58:23 +01:00
|
|
|
if (write_in_full(fd, blob, size) != size)
|
2006-04-22 08:57:45 +02:00
|
|
|
die("unable to write temp-file");
|
|
|
|
close(fd);
|
|
|
|
temp->name = temp->tmp_path;
|
|
|
|
strcpy(temp->hex, sha1_to_hex(sha1));
|
|
|
|
temp->hex[40] = 0;
|
|
|
|
sprintf(temp->mode, "%06o", mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void prepare_temp_file(const char *name,
|
|
|
|
struct diff_tempfile *temp,
|
|
|
|
struct diff_filespec *one)
|
|
|
|
{
|
|
|
|
if (!DIFF_FILE_VALID(one)) {
|
|
|
|
not_a_valid_file:
|
|
|
|
/* A '-' entry produces this for file-2, and
|
|
|
|
* a '+' entry produces this for file-1.
|
|
|
|
*/
|
|
|
|
temp->name = "/dev/null";
|
|
|
|
strcpy(temp->hex, ".");
|
|
|
|
strcpy(temp->mode, ".");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!one->sha1_valid ||
|
2006-12-14 12:15:57 +01:00
|
|
|
reuse_worktree_file(name, one->sha1, 1)) {
|
2006-04-22 08:57:45 +02:00
|
|
|
struct stat st;
|
|
|
|
if (lstat(name, &st) < 0) {
|
|
|
|
if (errno == ENOENT)
|
|
|
|
goto not_a_valid_file;
|
|
|
|
die("stat(%s): %s", name, strerror(errno));
|
|
|
|
}
|
|
|
|
if (S_ISLNK(st.st_mode)) {
|
|
|
|
int ret;
|
|
|
|
char buf[PATH_MAX + 1]; /* ought to be SYMLINK_MAX */
|
2007-03-07 02:44:37 +01:00
|
|
|
size_t sz = xsize_t(st.st_size);
|
2006-04-22 08:57:45 +02:00
|
|
|
if (sizeof(buf) <= st.st_size)
|
|
|
|
die("symlink too long: %s", name);
|
2007-03-07 02:44:37 +01:00
|
|
|
ret = readlink(name, buf, sz);
|
2006-04-22 08:57:45 +02:00
|
|
|
if (ret < 0)
|
|
|
|
die("readlink(%s)", name);
|
2007-03-07 02:44:37 +01:00
|
|
|
prep_temp_blob(temp, buf, sz,
|
2006-04-22 08:57:45 +02:00
|
|
|
(one->sha1_valid ?
|
|
|
|
one->sha1 : null_sha1),
|
|
|
|
(one->sha1_valid ?
|
|
|
|
one->mode : S_IFLNK));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* we can borrow from the file in the work tree */
|
|
|
|
temp->name = name;
|
|
|
|
if (!one->sha1_valid)
|
|
|
|
strcpy(temp->hex, sha1_to_hex(null_sha1));
|
|
|
|
else
|
|
|
|
strcpy(temp->hex, sha1_to_hex(one->sha1));
|
|
|
|
/* Even though we may sometimes borrow the
|
|
|
|
* contents from the work tree, we always want
|
|
|
|
* one->mode. mode is trustworthy even when
|
|
|
|
* !(one->sha1_valid), as long as
|
|
|
|
* DIFF_FILE_VALID(one).
|
|
|
|
*/
|
|
|
|
sprintf(temp->mode, "%06o", one->mode);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (diff_populate_filespec(one, 0))
|
|
|
|
die("cannot read data blob for %s", one->path);
|
|
|
|
prep_temp_blob(temp, one->data, one->size,
|
|
|
|
one->sha1, one->mode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void remove_tempfile(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < 2; i++)
|
|
|
|
if (diff_temp[i].name == diff_temp[i].tmp_path) {
|
|
|
|
unlink(diff_temp[i].name);
|
|
|
|
diff_temp[i].name = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void remove_tempfile_on_signal(int signo)
|
|
|
|
{
|
|
|
|
remove_tempfile();
|
|
|
|
signal(SIGINT, SIG_DFL);
|
|
|
|
raise(signo);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* An external diff command takes:
|
|
|
|
*
|
|
|
|
* diff-cmd name infile1 infile1-sha1 infile1-mode \
|
|
|
|
* infile2 infile2-sha1 infile2-mode [ rename-to ]
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static void run_external_diff(const char *pgm,
|
|
|
|
const char *name,
|
|
|
|
const char *other,
|
|
|
|
struct diff_filespec *one,
|
|
|
|
struct diff_filespec *two,
|
|
|
|
const char *xfrm_msg,
|
|
|
|
int complete_rewrite)
|
|
|
|
{
|
|
|
|
const char *spawn_arg[10];
|
|
|
|
struct diff_tempfile *temp = diff_temp;
|
|
|
|
int retval;
|
|
|
|
static int atexit_asked = 0;
|
|
|
|
const char *othername;
|
|
|
|
const char **arg = &spawn_arg[0];
|
|
|
|
|
|
|
|
othername = (other? other : name);
|
|
|
|
if (one && two) {
|
|
|
|
prepare_temp_file(name, &temp[0], one);
|
|
|
|
prepare_temp_file(othername, &temp[1], two);
|
|
|
|
if (! atexit_asked &&
|
|
|
|
(temp[0].name == temp[0].tmp_path ||
|
|
|
|
temp[1].name == temp[1].tmp_path)) {
|
|
|
|
atexit_asked = 1;
|
|
|
|
atexit(remove_tempfile);
|
|
|
|
}
|
|
|
|
signal(SIGINT, remove_tempfile_on_signal);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (one && two) {
|
|
|
|
*arg++ = pgm;
|
|
|
|
*arg++ = name;
|
|
|
|
*arg++ = temp[0].name;
|
|
|
|
*arg++ = temp[0].hex;
|
|
|
|
*arg++ = temp[0].mode;
|
|
|
|
*arg++ = temp[1].name;
|
|
|
|
*arg++ = temp[1].hex;
|
|
|
|
*arg++ = temp[1].mode;
|
|
|
|
if (other) {
|
|
|
|
*arg++ = other;
|
|
|
|
*arg++ = xfrm_msg;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
*arg++ = pgm;
|
|
|
|
*arg++ = name;
|
|
|
|
}
|
|
|
|
*arg = NULL;
|
2007-10-19 21:47:56 +02:00
|
|
|
fflush(NULL);
|
|
|
|
retval = run_command_v_opt(spawn_arg, 0);
|
2006-04-22 08:57:45 +02:00
|
|
|
remove_tempfile();
|
|
|
|
if (retval) {
|
|
|
|
fprintf(stderr, "external diff died, stopping at %s.\n", name);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-04-23 02:52:55 +02:00
|
|
|
static const char *external_diff_attr(const char *name)
|
|
|
|
{
|
|
|
|
struct git_attr_check attr_diff_check;
|
|
|
|
|
|
|
|
setup_diff_attr_check(&attr_diff_check);
|
|
|
|
if (!git_checkattr(name, 1, &attr_diff_check)) {
|
|
|
|
const char *value = attr_diff_check.value;
|
|
|
|
if (!ATTR_TRUE(value) &&
|
|
|
|
!ATTR_FALSE(value) &&
|
|
|
|
!ATTR_UNSET(value)) {
|
|
|
|
struct ll_diff_driver *drv;
|
|
|
|
|
|
|
|
for (drv = user_diff; drv; drv = drv->next)
|
|
|
|
if (!strcmp(drv->name, value))
|
|
|
|
return drv->cmd;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
static void run_diff_cmd(const char *pgm,
|
|
|
|
const char *name,
|
|
|
|
const char *other,
|
|
|
|
struct diff_filespec *one,
|
|
|
|
struct diff_filespec *two,
|
|
|
|
const char *xfrm_msg,
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
struct diff_options *o,
|
2006-04-22 08:57:45 +02:00
|
|
|
int complete_rewrite)
|
|
|
|
{
|
2007-11-10 20:05:14 +01:00
|
|
|
if (!DIFF_OPT_TST(o, ALLOW_EXTERNAL))
|
2007-04-23 02:52:55 +02:00
|
|
|
pgm = NULL;
|
|
|
|
else {
|
|
|
|
const char *cmd = external_diff_attr(name);
|
|
|
|
if (cmd)
|
|
|
|
pgm = cmd;
|
|
|
|
}
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
if (pgm) {
|
|
|
|
run_external_diff(pgm, name, other, one, two, xfrm_msg,
|
|
|
|
complete_rewrite);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (one && two)
|
|
|
|
builtin_diff(name, other ? other : name,
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
one, two, xfrm_msg, o, complete_rewrite);
|
2006-04-22 08:57:45 +02:00
|
|
|
else
|
|
|
|
printf("* Unmerged path %s\n", name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void diff_fill_sha1_info(struct diff_filespec *one)
|
|
|
|
{
|
|
|
|
if (DIFF_FILE_VALID(one)) {
|
|
|
|
if (!one->sha1_valid) {
|
|
|
|
struct stat st;
|
2007-02-25 23:36:10 +01:00
|
|
|
if (!strcmp(one->path, "-")) {
|
|
|
|
hashcpy(one->sha1, null_sha1);
|
|
|
|
return;
|
|
|
|
}
|
2006-04-22 08:57:45 +02:00
|
|
|
if (lstat(one->path, &st) < 0)
|
|
|
|
die("stat %s", one->path);
|
|
|
|
if (index_path(one->sha1, one->path, &st, 0))
|
|
|
|
die("cannot hash %s\n", one->path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2006-08-23 08:49:00 +02:00
|
|
|
hashclr(one->sha1);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
2007-06-25 00:23:34 +02:00
|
|
|
static int similarity_index(struct diff_filepair *p)
|
|
|
|
{
|
|
|
|
return p->score * 100 / MAX_SCORE;
|
|
|
|
}
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
static void run_diff(struct diff_filepair *p, struct diff_options *o)
|
|
|
|
{
|
|
|
|
const char *pgm = external_diff();
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
struct strbuf msg;
|
|
|
|
char *xfrm_msg;
|
|
|
|
struct diff_filespec *one = p->one;
|
|
|
|
struct diff_filespec *two = p->two;
|
2006-04-22 08:57:45 +02:00
|
|
|
const char *name;
|
|
|
|
const char *other;
|
|
|
|
int complete_rewrite = 0;
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
|
|
|
|
if (DIFF_PAIR_UNMERGED(p)) {
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
run_diff_cmd(pgm, p->one->path, NULL, NULL, NULL, NULL, o, 0);
|
2006-04-22 08:57:45 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
name = p->one->path;
|
2006-04-22 08:57:45 +02:00
|
|
|
other = (strcmp(name, p->two->path) ? p->two->path : NULL);
|
|
|
|
diff_fill_sha1_info(one);
|
|
|
|
diff_fill_sha1_info(two);
|
|
|
|
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
strbuf_init(&msg, PATH_MAX * 2 + 300);
|
2006-04-22 08:57:45 +02:00
|
|
|
switch (p->status) {
|
|
|
|
case DIFF_STATUS_COPIED:
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
strbuf_addf(&msg, "similarity index %d%%", similarity_index(p));
|
|
|
|
strbuf_addstr(&msg, "\ncopy from ");
|
|
|
|
quote_c_style(name, &msg, NULL, 0);
|
|
|
|
strbuf_addstr(&msg, "\ncopy to ");
|
|
|
|
quote_c_style(other, &msg, NULL, 0);
|
|
|
|
strbuf_addch(&msg, '\n');
|
2006-04-22 08:57:45 +02:00
|
|
|
break;
|
|
|
|
case DIFF_STATUS_RENAMED:
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
strbuf_addf(&msg, "similarity index %d%%", similarity_index(p));
|
|
|
|
strbuf_addstr(&msg, "\nrename from ");
|
|
|
|
quote_c_style(name, &msg, NULL, 0);
|
|
|
|
strbuf_addstr(&msg, "\nrename to ");
|
|
|
|
quote_c_style(other, &msg, NULL, 0);
|
|
|
|
strbuf_addch(&msg, '\n');
|
2006-04-22 08:57:45 +02:00
|
|
|
break;
|
|
|
|
case DIFF_STATUS_MODIFIED:
|
|
|
|
if (p->score) {
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
strbuf_addf(&msg, "dissimilarity index %d%%\n",
|
2007-06-25 00:23:34 +02:00
|
|
|
similarity_index(p));
|
2006-04-22 08:57:45 +02:00
|
|
|
complete_rewrite = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* fallthru */
|
|
|
|
default:
|
|
|
|
/* nothing */
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
2006-08-17 20:54:57 +02:00
|
|
|
if (hashcmp(one->sha1, two->sha1)) {
|
2007-11-10 20:05:14 +01:00
|
|
|
int abbrev = DIFF_OPT_TST(o, FULL_INDEX) ? 40 : DEFAULT_ABBREV;
|
2006-04-22 08:57:45 +02:00
|
|
|
|
2007-11-10 20:05:14 +01:00
|
|
|
if (DIFF_OPT_TST(o, BINARY)) {
|
2006-09-07 09:54:22 +02:00
|
|
|
mmfile_t mf;
|
2007-07-06 09:18:54 +02:00
|
|
|
if ((!fill_mmfile(&mf, one) && diff_filespec_is_binary(one)) ||
|
|
|
|
(!fill_mmfile(&mf, two) && diff_filespec_is_binary(two)))
|
2006-09-07 09:54:22 +02:00
|
|
|
abbrev = 40;
|
|
|
|
}
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
strbuf_addf(&msg, "index %.*s..%.*s",
|
2006-05-04 02:21:08 +02:00
|
|
|
abbrev, sha1_to_hex(one->sha1),
|
|
|
|
abbrev, sha1_to_hex(two->sha1));
|
2006-04-22 08:57:45 +02:00
|
|
|
if (one->mode == two->mode)
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
strbuf_addf(&msg, " %06o", one->mode);
|
|
|
|
strbuf_addch(&msg, '\n');
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
if (msg.len)
|
|
|
|
strbuf_setlen(&msg, msg.len - 1);
|
|
|
|
xfrm_msg = msg.len ? msg.buf : NULL;
|
2006-04-22 08:57:45 +02:00
|
|
|
|
|
|
|
if (!pgm &&
|
|
|
|
DIFF_FILE_VALID(one) && DIFF_FILE_VALID(two) &&
|
|
|
|
(S_IFMT & one->mode) != (S_IFMT & two->mode)) {
|
|
|
|
/* a filepair that changes between file and symlink
|
|
|
|
* needs to be split into deletion and creation.
|
|
|
|
*/
|
|
|
|
struct diff_filespec *null = alloc_filespec(two->path);
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
run_diff_cmd(NULL, name, other, one, null, xfrm_msg, o, 0);
|
2006-04-22 08:57:45 +02:00
|
|
|
free(null);
|
|
|
|
null = alloc_filespec(one->path);
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
run_diff_cmd(NULL, name, other, null, two, xfrm_msg, o, 0);
|
2006-04-22 08:57:45 +02:00
|
|
|
free(null);
|
|
|
|
}
|
|
|
|
else
|
binary patch.
This adds "binary patch" to the diff output and teaches apply
what to do with them.
On the diff generation side, traditionally, we said "Binary
files differ\n" without giving anything other than the preimage
and postimage object name on the index line. This was good
enough for applying a patch generated from your own repository
(very useful while rebasing), because the postimage would be
available in such a case. However, this was not useful when the
recipient of such a patch via e-mail were to apply it, even if
the preimage was available.
This patch allows the diff to generate "binary" patch when
operating under --full-index option. The binary patch follows
the usual extended git diff headers, and looks like this:
"GIT binary patch\n"
<length byte><data>"\n"
...
"\n"
Each line is prefixed with a "length-byte", whose value is upper
or lowercase alphabet that encodes number of bytes that the data
on the line decodes to (1..52 -- 'A' means 1, 'B' means 2, ...,
'Z' means 26, 'a' means 27, ...). <data> is 1 or more groups of
5-byte sequence, each of which encodes up to 4 bytes in base85
encoding. Because 52 / 4 * 5 = 65 and we have the length byte,
an output line is capped to 66 characters. The payload is the
same diff-delta as we use in the packfiles.
On the consumption side, git-apply now can decode and apply the
binary patch when --allow-binary-replacement is given, the diff
was generated with --full-index, and the receiving repository
has the preimage blob, which is the same condition as it always
required when accepting an "Binary files differ\n" patch.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-05 01:51:44 +02:00
|
|
|
run_diff_cmd(pgm, name, other, one, two, xfrm_msg, o,
|
2006-04-22 08:57:45 +02:00
|
|
|
complete_rewrite);
|
|
|
|
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
strbuf_release(&msg);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void run_diffstat(struct diff_filepair *p, struct diff_options *o,
|
|
|
|
struct diffstat_t *diffstat)
|
|
|
|
{
|
|
|
|
const char *name;
|
|
|
|
const char *other;
|
2006-04-26 08:40:09 +02:00
|
|
|
int complete_rewrite = 0;
|
2006-04-22 08:57:45 +02:00
|
|
|
|
|
|
|
if (DIFF_PAIR_UNMERGED(p)) {
|
|
|
|
/* unmerged */
|
2006-06-14 17:40:23 +02:00
|
|
|
builtin_diffstat(p->one->path, NULL, NULL, NULL, diffstat, o, 0);
|
2006-04-22 08:57:45 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
name = p->one->path;
|
|
|
|
other = (strcmp(name, p->two->path) ? p->two->path : NULL);
|
|
|
|
|
|
|
|
diff_fill_sha1_info(p->one);
|
|
|
|
diff_fill_sha1_info(p->two);
|
|
|
|
|
2006-04-26 08:40:09 +02:00
|
|
|
if (p->status == DIFF_STATUS_MODIFIED && p->score)
|
|
|
|
complete_rewrite = 1;
|
2006-06-14 17:40:23 +02:00
|
|
|
builtin_diffstat(name, other, p->one, p->two, diffstat, o, complete_rewrite);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
2006-05-20 23:43:13 +02:00
|
|
|
static void run_checkdiff(struct diff_filepair *p, struct diff_options *o)
|
|
|
|
{
|
|
|
|
const char *name;
|
|
|
|
const char *other;
|
|
|
|
|
|
|
|
if (DIFF_PAIR_UNMERGED(p)) {
|
|
|
|
/* unmerged */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
name = p->one->path;
|
|
|
|
other = (strcmp(name, p->two->path) ? p->two->path : NULL);
|
|
|
|
|
|
|
|
diff_fill_sha1_info(p->one);
|
|
|
|
diff_fill_sha1_info(p->two);
|
|
|
|
|
2007-02-18 17:27:24 +01:00
|
|
|
builtin_checkdiff(name, other, p->one, p->two, o);
|
2006-05-20 23:43:13 +02:00
|
|
|
}
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
void diff_setup(struct diff_options *options)
|
|
|
|
{
|
|
|
|
memset(options, 0, sizeof(*options));
|
|
|
|
options->line_termination = '\n';
|
|
|
|
options->break_opt = -1;
|
|
|
|
options->rename_limit = -1;
|
2006-05-13 22:23:48 +02:00
|
|
|
options->context = 3;
|
2006-06-28 00:08:19 +02:00
|
|
|
options->msg_sep = "";
|
2006-04-22 08:57:45 +02:00
|
|
|
|
|
|
|
options->change = diff_change;
|
|
|
|
options->add_remove = diff_addremove;
|
2007-11-10 20:05:14 +01:00
|
|
|
if (diff_use_color_default)
|
|
|
|
DIFF_OPT_SET(options, COLOR_DIFF);
|
|
|
|
else
|
|
|
|
DIFF_OPT_CLR(options, COLOR_DIFF);
|
2006-07-07 13:01:23 +02:00
|
|
|
options->detect_rename = diff_detect_rename_default;
|
2007-12-18 20:32:14 +01:00
|
|
|
|
|
|
|
options->a_prefix = "a/";
|
|
|
|
options->b_prefix = "b/";
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int diff_setup_done(struct diff_options *options)
|
|
|
|
{
|
2006-06-24 19:26:49 +02:00
|
|
|
int count = 0;
|
|
|
|
|
|
|
|
if (options->output_format & DIFF_FORMAT_NAME)
|
|
|
|
count++;
|
|
|
|
if (options->output_format & DIFF_FORMAT_NAME_STATUS)
|
|
|
|
count++;
|
|
|
|
if (options->output_format & DIFF_FORMAT_CHECKDIFF)
|
|
|
|
count++;
|
|
|
|
if (options->output_format & DIFF_FORMAT_NO_OUTPUT)
|
|
|
|
count++;
|
|
|
|
if (count > 1)
|
|
|
|
die("--name-only, --name-status, --check and -s are mutually exclusive");
|
|
|
|
|
2007-11-10 20:05:14 +01:00
|
|
|
if (DIFF_OPT_TST(options, FIND_COPIES_HARDER))
|
2006-08-09 22:17:19 +02:00
|
|
|
options->detect_rename = DIFF_DETECT_COPY;
|
|
|
|
|
2006-06-24 19:21:53 +02:00
|
|
|
if (options->output_format & (DIFF_FORMAT_NAME |
|
|
|
|
DIFF_FORMAT_NAME_STATUS |
|
|
|
|
DIFF_FORMAT_CHECKDIFF |
|
|
|
|
DIFF_FORMAT_NO_OUTPUT))
|
|
|
|
options->output_format &= ~(DIFF_FORMAT_RAW |
|
2006-10-12 12:01:00 +02:00
|
|
|
DIFF_FORMAT_NUMSTAT |
|
2006-06-24 19:21:53 +02:00
|
|
|
DIFF_FORMAT_DIFFSTAT |
|
2006-12-15 05:15:44 +01:00
|
|
|
DIFF_FORMAT_SHORTSTAT |
|
2006-06-24 19:21:53 +02:00
|
|
|
DIFF_FORMAT_SUMMARY |
|
|
|
|
DIFF_FORMAT_PATCH);
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
/*
|
|
|
|
* These cases always need recursive; we do not drop caller-supplied
|
|
|
|
* recursive bits for other formats here.
|
|
|
|
*/
|
2006-06-24 19:21:53 +02:00
|
|
|
if (options->output_format & (DIFF_FORMAT_PATCH |
|
2006-10-12 12:01:00 +02:00
|
|
|
DIFF_FORMAT_NUMSTAT |
|
2006-06-24 19:21:53 +02:00
|
|
|
DIFF_FORMAT_DIFFSTAT |
|
2006-12-15 05:15:44 +01:00
|
|
|
DIFF_FORMAT_SHORTSTAT |
|
2006-10-03 23:09:56 +02:00
|
|
|
DIFF_FORMAT_SUMMARY |
|
2006-06-24 19:21:53 +02:00
|
|
|
DIFF_FORMAT_CHECKDIFF))
|
2007-11-10 20:05:14 +01:00
|
|
|
DIFF_OPT_SET(options, RECURSIVE);
|
2006-05-22 09:31:02 +02:00
|
|
|
/*
|
2006-06-28 00:08:19 +02:00
|
|
|
* Also pickaxe would not work very well if you do not say recursive
|
2006-05-22 09:31:02 +02:00
|
|
|
*/
|
2006-06-28 00:08:19 +02:00
|
|
|
if (options->pickaxe)
|
2007-11-10 20:05:14 +01:00
|
|
|
DIFF_OPT_SET(options, RECURSIVE);
|
2006-05-22 09:31:02 +02:00
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
if (options->detect_rename && options->rename_limit < 0)
|
|
|
|
options->rename_limit = diff_rename_limit_default;
|
|
|
|
if (options->setup & DIFF_SETUP_USE_CACHE) {
|
|
|
|
if (!active_cache)
|
|
|
|
/* read-cache does not die even when it fails
|
|
|
|
* so it is safe for us to do this here. Also
|
|
|
|
* it does not smudge active_cache or active_nr
|
|
|
|
* when it fails, so we do not have to worry about
|
|
|
|
* cleaning it up ourselves either.
|
|
|
|
*/
|
|
|
|
read_cache();
|
|
|
|
}
|
|
|
|
if (options->abbrev <= 0 || 40 < options->abbrev)
|
|
|
|
options->abbrev = 40; /* full */
|
|
|
|
|
2007-03-14 19:12:13 +01:00
|
|
|
/*
|
|
|
|
* It does not make sense to show the first hit we happened
|
|
|
|
* to have found. It does not make sense not to return with
|
|
|
|
* exit code in such a case either.
|
|
|
|
*/
|
2007-11-10 20:05:14 +01:00
|
|
|
if (DIFF_OPT_TST(options, QUIET)) {
|
2007-03-14 19:12:13 +01:00
|
|
|
options->output_format = DIFF_FORMAT_NO_OUTPUT;
|
2007-11-10 20:05:14 +01:00
|
|
|
DIFF_OPT_SET(options, EXIT_WITH_STATUS);
|
2007-03-14 19:12:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we postprocess in diffcore, we cannot simply return
|
|
|
|
* upon the first hit. We need to run diff as usual.
|
|
|
|
*/
|
|
|
|
if (options->pickaxe || options->filter)
|
2007-11-10 20:05:14 +01:00
|
|
|
DIFF_OPT_CLR(options, QUIET);
|
2007-03-14 19:12:13 +01:00
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-06-24 19:20:32 +02:00
|
|
|
static int opt_arg(const char *arg, int arg_short, const char *arg_long, int *val)
|
2006-05-13 22:23:48 +02:00
|
|
|
{
|
|
|
|
char c, *eq;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (*arg != '-')
|
|
|
|
return 0;
|
|
|
|
c = *++arg;
|
|
|
|
if (!c)
|
|
|
|
return 0;
|
|
|
|
if (c == arg_short) {
|
|
|
|
c = *++arg;
|
|
|
|
if (!c)
|
|
|
|
return 1;
|
|
|
|
if (val && isdigit(c)) {
|
|
|
|
char *end;
|
|
|
|
int n = strtoul(arg, &end, 10);
|
|
|
|
if (*end)
|
|
|
|
return 0;
|
|
|
|
*val = n;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (c != '-')
|
|
|
|
return 0;
|
|
|
|
arg++;
|
|
|
|
eq = strchr(arg, '=');
|
|
|
|
if (eq)
|
|
|
|
len = eq - arg;
|
|
|
|
else
|
|
|
|
len = strlen(arg);
|
|
|
|
if (!len || strncmp(arg, arg_long, len))
|
|
|
|
return 0;
|
|
|
|
if (eq) {
|
|
|
|
int n;
|
|
|
|
char *end;
|
|
|
|
if (!isdigit(*++eq))
|
|
|
|
return 0;
|
|
|
|
n = strtoul(eq, &end, 10);
|
|
|
|
if (*end)
|
|
|
|
return 0;
|
|
|
|
*val = n;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-06-08 11:54:57 +02:00
|
|
|
static int diff_scoreopt_parse(const char *opt);
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
int diff_opt_parse(struct diff_options *options, const char **av, int ac)
|
|
|
|
{
|
|
|
|
const char *arg = av[0];
|
2007-11-07 11:20:32 +01:00
|
|
|
|
|
|
|
/* Output format options */
|
2006-04-22 08:57:45 +02:00
|
|
|
if (!strcmp(arg, "-p") || !strcmp(arg, "-u"))
|
2006-06-24 19:21:53 +02:00
|
|
|
options->output_format |= DIFF_FORMAT_PATCH;
|
2006-05-13 22:23:48 +02:00
|
|
|
else if (opt_arg(arg, 'U', "unified", &options->context))
|
2006-06-24 19:21:53 +02:00
|
|
|
options->output_format |= DIFF_FORMAT_PATCH;
|
2006-06-24 19:23:06 +02:00
|
|
|
else if (!strcmp(arg, "--raw"))
|
|
|
|
options->output_format |= DIFF_FORMAT_RAW;
|
2007-11-10 20:05:14 +01:00
|
|
|
else if (!strcmp(arg, "--patch-with-raw"))
|
2006-06-24 19:21:53 +02:00
|
|
|
options->output_format |= DIFF_FORMAT_PATCH | DIFF_FORMAT_RAW;
|
2007-11-10 20:05:14 +01:00
|
|
|
else if (!strcmp(arg, "--numstat"))
|
2006-10-12 12:01:00 +02:00
|
|
|
options->output_format |= DIFF_FORMAT_NUMSTAT;
|
2007-11-10 20:05:14 +01:00
|
|
|
else if (!strcmp(arg, "--shortstat"))
|
2006-12-15 05:15:44 +01:00
|
|
|
options->output_format |= DIFF_FORMAT_SHORTSTAT;
|
2007-11-07 11:20:32 +01:00
|
|
|
else if (!strcmp(arg, "--check"))
|
|
|
|
options->output_format |= DIFF_FORMAT_CHECKDIFF;
|
|
|
|
else if (!strcmp(arg, "--summary"))
|
|
|
|
options->output_format |= DIFF_FORMAT_SUMMARY;
|
|
|
|
else if (!strcmp(arg, "--patch-with-stat"))
|
|
|
|
options->output_format |= DIFF_FORMAT_PATCH | DIFF_FORMAT_DIFFSTAT;
|
|
|
|
else if (!strcmp(arg, "--name-only"))
|
|
|
|
options->output_format |= DIFF_FORMAT_NAME;
|
|
|
|
else if (!strcmp(arg, "--name-status"))
|
|
|
|
options->output_format |= DIFF_FORMAT_NAME_STATUS;
|
|
|
|
else if (!strcmp(arg, "-s"))
|
|
|
|
options->output_format |= DIFF_FORMAT_NO_OUTPUT;
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 10:53:29 +01:00
|
|
|
else if (!prefixcmp(arg, "--stat")) {
|
2006-09-29 00:07:16 +02:00
|
|
|
char *end;
|
|
|
|
int width = options->stat_width;
|
|
|
|
int name_width = options->stat_name_width;
|
|
|
|
arg += 6;
|
|
|
|
end = (char *)arg;
|
|
|
|
|
|
|
|
switch (*arg) {
|
|
|
|
case '-':
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 10:53:29 +01:00
|
|
|
if (!prefixcmp(arg, "-width="))
|
2006-09-29 00:07:16 +02:00
|
|
|
width = strtoul(arg + 7, &end, 10);
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 10:53:29 +01:00
|
|
|
else if (!prefixcmp(arg, "-name-width="))
|
2006-09-29 00:07:16 +02:00
|
|
|
name_width = strtoul(arg + 12, &end, 10);
|
|
|
|
break;
|
|
|
|
case '=':
|
|
|
|
width = strtoul(arg+1, &end, 10);
|
|
|
|
if (*end == ',')
|
|
|
|
name_width = strtoul(end+1, &end, 10);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Important! This checks all the error cases! */
|
|
|
|
if (*end)
|
|
|
|
return 0;
|
2006-06-24 19:21:53 +02:00
|
|
|
options->output_format |= DIFF_FORMAT_DIFFSTAT;
|
2006-09-29 00:07:16 +02:00
|
|
|
options->stat_name_width = name_width;
|
|
|
|
options->stat_width = width;
|
2006-09-27 03:53:02 +02:00
|
|
|
}
|
2007-11-07 11:20:32 +01:00
|
|
|
|
|
|
|
/* renames options */
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 10:53:29 +01:00
|
|
|
else if (!prefixcmp(arg, "-B")) {
|
2007-11-10 20:05:14 +01:00
|
|
|
if ((options->break_opt = diff_scoreopt_parse(arg)) == -1)
|
2006-04-22 08:57:45 +02:00
|
|
|
return -1;
|
|
|
|
}
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 10:53:29 +01:00
|
|
|
else if (!prefixcmp(arg, "-M")) {
|
2007-11-10 20:05:14 +01:00
|
|
|
if ((options->rename_score = diff_scoreopt_parse(arg)) == -1)
|
2006-04-22 08:57:45 +02:00
|
|
|
return -1;
|
|
|
|
options->detect_rename = DIFF_DETECT_RENAME;
|
|
|
|
}
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 10:53:29 +01:00
|
|
|
else if (!prefixcmp(arg, "-C")) {
|
2007-06-11 22:12:19 +02:00
|
|
|
if (options->detect_rename == DIFF_DETECT_COPY)
|
2007-11-10 20:05:14 +01:00
|
|
|
DIFF_OPT_SET(options, FIND_COPIES_HARDER);
|
|
|
|
if ((options->rename_score = diff_scoreopt_parse(arg)) == -1)
|
2006-04-22 08:57:45 +02:00
|
|
|
return -1;
|
|
|
|
options->detect_rename = DIFF_DETECT_COPY;
|
|
|
|
}
|
2007-11-07 11:20:32 +01:00
|
|
|
else if (!strcmp(arg, "--no-renames"))
|
|
|
|
options->detect_rename = 0;
|
|
|
|
|
|
|
|
/* xdiff options */
|
|
|
|
else if (!strcmp(arg, "-w") || !strcmp(arg, "--ignore-all-space"))
|
|
|
|
options->xdl_opts |= XDF_IGNORE_WHITESPACE;
|
|
|
|
else if (!strcmp(arg, "-b") || !strcmp(arg, "--ignore-space-change"))
|
|
|
|
options->xdl_opts |= XDF_IGNORE_WHITESPACE_CHANGE;
|
|
|
|
else if (!strcmp(arg, "--ignore-space-at-eol"))
|
|
|
|
options->xdl_opts |= XDF_IGNORE_WHITESPACE_AT_EOL;
|
|
|
|
|
|
|
|
/* flags options */
|
|
|
|
else if (!strcmp(arg, "--binary")) {
|
|
|
|
options->output_format |= DIFF_FORMAT_PATCH;
|
|
|
|
DIFF_OPT_SET(options, BINARY);
|
|
|
|
}
|
|
|
|
else if (!strcmp(arg, "--full-index"))
|
|
|
|
DIFF_OPT_SET(options, FULL_INDEX);
|
|
|
|
else if (!strcmp(arg, "-a") || !strcmp(arg, "--text"))
|
|
|
|
DIFF_OPT_SET(options, TEXT);
|
|
|
|
else if (!strcmp(arg, "-R"))
|
|
|
|
DIFF_OPT_SET(options, REVERSE_DIFF);
|
2006-04-22 08:57:45 +02:00
|
|
|
else if (!strcmp(arg, "--find-copies-harder"))
|
2007-11-10 20:05:14 +01:00
|
|
|
DIFF_OPT_SET(options, FIND_COPIES_HARDER);
|
Finally implement "git log --follow"
Ok, I've really held off doing this too damn long, because I'm lazy, and I
was always hoping that somebody else would do it.
But no, people keep asking for it, but nobody actually did anything, so I
decided I might as well bite the bullet, and instead of telling people
they could add a "--follow" flag to "git log" to do what they want to do,
I decided that it looks like I just have to do it for them..
The code wasn't actually that complicated, in that the diffstat for this
patch literally says "70 insertions(+), 1 deletions(-)", but I will have
to admit that in order to get to this fairly simple patch, you did have to
know and understand the internal git diff generation machinery pretty
well, and had to really be able to follow how commit generation interacts
with generating patches and generating the log.
So I suspect that while I was right that it wasn't that hard, I might have
been expecting too much of random people - this patch does seem to be
firmly in the core "Linus or Junio" territory.
To make a long story short: I'm sorry for it taking so long until I just
did it.
I'm not going to guarantee that this works for everybody, but you really
can just look at the patch, and after the appropriate appreciative noises
("Ooh, aah") over how clever I am, you can then just notice that the code
itself isn't really that complicated.
All the real new code is in the new "try_to_follow_renames()" function. It
really isn't rocket science: we notice that the pathname we were looking
at went away, so we start a full tree diff and try to see if we can
instead make that pathname be a rename or a copy from some other previous
pathname. And if we can, we just continue, except we show *that*
particular diff, and ever after we use the _previous_ pathname.
One thing to look out for: the "rename detection" is considered to be a
singular event in the _linear_ "git log" output! That's what people want
to do, but I just wanted to point out that this patch is *not* carrying
around a "commit,pathname" kind of pair and it's *not* going to be able to
notice the file coming from multiple *different* files in earlier history.
IOW, if you use "git log --follow", then you get the stupid CVS/SVN kind
of "files have single identities" kind of semantics, and git log will just
pick the identity based on the normal move/copy heuristics _as_if_ the
history could be linearized.
Put another way: I think the model is broken, but given the broken model,
I think this patch does just about as well as you can do. If you have
merges with the same "file" having different filenames over the two
branches, git will just end up picking _one_ of the pathnames at the point
where the newer one goes away. It never looks at multiple pathnames in
parallel.
And if you understood all that, you probably didn't need it explained, and
if you didn't understand the above blathering, it doesn't really mtter to
you. What matters to you is that you can now do
git log -p --follow builtin-rev-list.c
and it will find the point where the old "rev-list.c" got renamed to
"builtin-rev-list.c" and show it as such.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-06-19 23:22:46 +02:00
|
|
|
else if (!strcmp(arg, "--follow"))
|
2007-11-10 20:05:14 +01:00
|
|
|
DIFF_OPT_SET(options, FOLLOW_RENAMES);
|
2006-06-13 18:45:44 +02:00
|
|
|
else if (!strcmp(arg, "--color"))
|
2007-11-10 20:05:14 +01:00
|
|
|
DIFF_OPT_SET(options, COLOR_DIFF);
|
2006-07-07 14:27:24 +02:00
|
|
|
else if (!strcmp(arg, "--no-color"))
|
2007-11-10 20:05:14 +01:00
|
|
|
DIFF_OPT_CLR(options, COLOR_DIFF);
|
2006-07-28 23:56:15 +02:00
|
|
|
else if (!strcmp(arg, "--color-words"))
|
2007-11-10 20:05:14 +01:00
|
|
|
options->flags |= DIFF_OPT_COLOR_DIFF | DIFF_OPT_COLOR_DIFF_WORDS;
|
2007-03-14 01:17:04 +01:00
|
|
|
else if (!strcmp(arg, "--exit-code"))
|
2007-11-10 20:05:14 +01:00
|
|
|
DIFF_OPT_SET(options, EXIT_WITH_STATUS);
|
2007-03-14 19:12:13 +01:00
|
|
|
else if (!strcmp(arg, "--quiet"))
|
2007-11-10 20:05:14 +01:00
|
|
|
DIFF_OPT_SET(options, QUIET);
|
2007-06-30 19:47:07 +02:00
|
|
|
else if (!strcmp(arg, "--ext-diff"))
|
2007-11-10 20:05:14 +01:00
|
|
|
DIFF_OPT_SET(options, ALLOW_EXTERNAL);
|
2007-06-30 19:47:07 +02:00
|
|
|
else if (!strcmp(arg, "--no-ext-diff"))
|
2007-11-10 20:05:14 +01:00
|
|
|
DIFF_OPT_CLR(options, ALLOW_EXTERNAL);
|
2007-11-07 11:20:32 +01:00
|
|
|
|
|
|
|
/* misc options */
|
|
|
|
else if (!strcmp(arg, "-z"))
|
|
|
|
options->line_termination = 0;
|
|
|
|
else if (!prefixcmp(arg, "-l"))
|
|
|
|
options->rename_limit = strtoul(arg+2, NULL, 10);
|
|
|
|
else if (!prefixcmp(arg, "-S"))
|
|
|
|
options->pickaxe = arg + 2;
|
|
|
|
else if (!strcmp(arg, "--pickaxe-all"))
|
|
|
|
options->pickaxe_opts = DIFF_PICKAXE_ALL;
|
|
|
|
else if (!strcmp(arg, "--pickaxe-regex"))
|
|
|
|
options->pickaxe_opts = DIFF_PICKAXE_REGEX;
|
|
|
|
else if (!prefixcmp(arg, "-O"))
|
|
|
|
options->orderfile = arg + 2;
|
|
|
|
else if (!prefixcmp(arg, "--diff-filter="))
|
|
|
|
options->filter = arg + 14;
|
|
|
|
else if (!strcmp(arg, "--abbrev"))
|
|
|
|
options->abbrev = DEFAULT_ABBREV;
|
|
|
|
else if (!prefixcmp(arg, "--abbrev=")) {
|
|
|
|
options->abbrev = strtoul(arg + 9, NULL, 10);
|
|
|
|
if (options->abbrev < MINIMUM_ABBREV)
|
|
|
|
options->abbrev = MINIMUM_ABBREV;
|
|
|
|
else if (40 < options->abbrev)
|
|
|
|
options->abbrev = 40;
|
|
|
|
}
|
2007-12-18 20:32:14 +01:00
|
|
|
else if (!prefixcmp(arg, "--src-prefix="))
|
|
|
|
options->a_prefix = arg + 13;
|
|
|
|
else if (!prefixcmp(arg, "--dst-prefix="))
|
|
|
|
options->b_prefix = arg + 13;
|
|
|
|
else if (!strcmp(arg, "--no-prefix"))
|
|
|
|
options->a_prefix = options->b_prefix = "";
|
2006-04-22 08:57:45 +02:00
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int parse_num(const char **cp_p)
|
|
|
|
{
|
|
|
|
unsigned long num, scale;
|
|
|
|
int ch, dot;
|
|
|
|
const char *cp = *cp_p;
|
|
|
|
|
|
|
|
num = 0;
|
|
|
|
scale = 1;
|
|
|
|
dot = 0;
|
|
|
|
for(;;) {
|
|
|
|
ch = *cp;
|
|
|
|
if ( !dot && ch == '.' ) {
|
|
|
|
scale = 1;
|
|
|
|
dot = 1;
|
|
|
|
} else if ( ch == '%' ) {
|
|
|
|
scale = dot ? scale*100 : 100;
|
|
|
|
cp++; /* % is always at the end */
|
|
|
|
break;
|
|
|
|
} else if ( ch >= '0' && ch <= '9' ) {
|
|
|
|
if ( scale < 100000 ) {
|
|
|
|
scale *= 10;
|
|
|
|
num = (num*10) + (ch-'0');
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
cp++;
|
|
|
|
}
|
|
|
|
*cp_p = cp;
|
|
|
|
|
|
|
|
/* user says num divided by scale and we say internally that
|
|
|
|
* is MAX_SCORE * num / scale.
|
|
|
|
*/
|
2007-03-07 02:44:37 +01:00
|
|
|
return (int)((num >= scale) ? MAX_SCORE : (MAX_SCORE * num / scale));
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
2007-06-08 11:54:57 +02:00
|
|
|
static int diff_scoreopt_parse(const char *opt)
|
2006-04-22 08:57:45 +02:00
|
|
|
{
|
|
|
|
int opt1, opt2, cmd;
|
|
|
|
|
|
|
|
if (*opt++ != '-')
|
|
|
|
return -1;
|
|
|
|
cmd = *opt++;
|
|
|
|
if (cmd != 'M' && cmd != 'C' && cmd != 'B')
|
|
|
|
return -1; /* that is not a -M, -C nor -B option */
|
|
|
|
|
|
|
|
opt1 = parse_num(&opt);
|
|
|
|
if (cmd != 'B')
|
|
|
|
opt2 = 0;
|
|
|
|
else {
|
|
|
|
if (*opt == 0)
|
|
|
|
opt2 = 0;
|
|
|
|
else if (*opt != '/')
|
|
|
|
return -1; /* we expect -B80/99 or -B80 */
|
|
|
|
else {
|
|
|
|
opt++;
|
|
|
|
opt2 = parse_num(&opt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (*opt != 0)
|
|
|
|
return -1;
|
|
|
|
return opt1 | (opt2 << 16);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct diff_queue_struct diff_queued_diff;
|
|
|
|
|
|
|
|
void diff_q(struct diff_queue_struct *queue, struct diff_filepair *dp)
|
|
|
|
{
|
|
|
|
if (queue->alloc <= queue->nr) {
|
|
|
|
queue->alloc = alloc_nr(queue->alloc);
|
|
|
|
queue->queue = xrealloc(queue->queue,
|
|
|
|
sizeof(dp) * queue->alloc);
|
|
|
|
}
|
|
|
|
queue->queue[queue->nr++] = dp;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct diff_filepair *diff_queue(struct diff_queue_struct *queue,
|
|
|
|
struct diff_filespec *one,
|
|
|
|
struct diff_filespec *two)
|
|
|
|
{
|
2006-08-03 21:01:01 +02:00
|
|
|
struct diff_filepair *dp = xcalloc(1, sizeof(*dp));
|
2006-04-22 08:57:45 +02:00
|
|
|
dp->one = one;
|
|
|
|
dp->two = two;
|
|
|
|
if (queue)
|
|
|
|
diff_q(queue, dp);
|
|
|
|
return dp;
|
|
|
|
}
|
|
|
|
|
|
|
|
void diff_free_filepair(struct diff_filepair *p)
|
|
|
|
{
|
2007-10-25 20:19:10 +02:00
|
|
|
free_filespec(p->one);
|
|
|
|
free_filespec(p->two);
|
2006-04-22 08:57:45 +02:00
|
|
|
free(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This is different from find_unique_abbrev() in that
|
|
|
|
* it stuffs the result with dots for alignment.
|
|
|
|
*/
|
|
|
|
const char *diff_unique_abbrev(const unsigned char *sha1, int len)
|
|
|
|
{
|
|
|
|
int abblen;
|
|
|
|
const char *abbrev;
|
|
|
|
if (len == 40)
|
|
|
|
return sha1_to_hex(sha1);
|
|
|
|
|
|
|
|
abbrev = find_unique_abbrev(sha1, len);
|
|
|
|
if (!abbrev)
|
|
|
|
return sha1_to_hex(sha1);
|
|
|
|
abblen = strlen(abbrev);
|
|
|
|
if (abblen < 37) {
|
|
|
|
static char hex[41];
|
|
|
|
if (len < abblen && abblen <= len + 2)
|
|
|
|
sprintf(hex, "%s%.*s", abbrev, len+3-abblen, "..");
|
|
|
|
else
|
|
|
|
sprintf(hex, "%s...", abbrev);
|
|
|
|
return hex;
|
|
|
|
}
|
|
|
|
return sha1_to_hex(sha1);
|
|
|
|
}
|
|
|
|
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
static void diff_flush_raw(struct diff_filepair *p, struct diff_options *opt)
|
2006-04-22 08:57:45 +02:00
|
|
|
{
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
int line_termination = opt->line_termination;
|
|
|
|
int inter_name_termination = line_termination ? '\t' : '\0';
|
2006-04-22 08:57:45 +02:00
|
|
|
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
if (!(opt->output_format & DIFF_FORMAT_NAME_STATUS)) {
|
|
|
|
printf(":%06o %06o %s ", p->one->mode, p->two->mode,
|
|
|
|
diff_unique_abbrev(p->one->sha1, opt->abbrev));
|
|
|
|
printf("%s ", diff_unique_abbrev(p->two->sha1, opt->abbrev));
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
if (p->score) {
|
|
|
|
printf("%c%03d%c", p->status, similarity_index(p),
|
|
|
|
inter_name_termination);
|
|
|
|
} else {
|
|
|
|
printf("%c%c", p->status, inter_name_termination);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
if (p->status == DIFF_STATUS_COPIED || p->status == DIFF_STATUS_RENAMED) {
|
|
|
|
write_name_quoted(p->one->path, stdout, inter_name_termination);
|
|
|
|
write_name_quoted(p->two->path, stdout, line_termination);
|
|
|
|
} else {
|
|
|
|
const char *path = p->one->mode ? p->one->path : p->two->path;
|
|
|
|
write_name_quoted(path, stdout, line_termination);
|
|
|
|
}
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int diff_unmodified_pair(struct diff_filepair *p)
|
|
|
|
{
|
|
|
|
/* This function is written stricter than necessary to support
|
|
|
|
* the currently implemented transformers, but the idea is to
|
|
|
|
* let transformers to produce diff_filepairs any way they want,
|
|
|
|
* and filter and clean them up here before producing the output.
|
|
|
|
*/
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
struct diff_filespec *one = p->one, *two = p->two;
|
2006-04-22 08:57:45 +02:00
|
|
|
|
|
|
|
if (DIFF_PAIR_UNMERGED(p))
|
|
|
|
return 0; /* unmerged is interesting */
|
|
|
|
|
|
|
|
/* deletion, addition, mode or type change
|
|
|
|
* and rename are all interesting.
|
|
|
|
*/
|
|
|
|
if (DIFF_FILE_VALID(one) != DIFF_FILE_VALID(two) ||
|
|
|
|
DIFF_PAIR_MODE_CHANGED(p) ||
|
|
|
|
strcmp(one->path, two->path))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* both are valid and point at the same path. that is, we are
|
|
|
|
* dealing with a change.
|
|
|
|
*/
|
|
|
|
if (one->sha1_valid && two->sha1_valid &&
|
2006-08-17 20:54:57 +02:00
|
|
|
!hashcmp(one->sha1, two->sha1))
|
2006-04-22 08:57:45 +02:00
|
|
|
return 1; /* no change */
|
|
|
|
if (!one->sha1_valid && !two->sha1_valid)
|
|
|
|
return 1; /* both look at the same file on the filesystem. */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void diff_flush_patch(struct diff_filepair *p, struct diff_options *o)
|
|
|
|
{
|
|
|
|
if (diff_unmodified_pair(p))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) ||
|
|
|
|
(DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
|
|
|
|
return; /* no tree diffs in patch format */
|
|
|
|
|
|
|
|
run_diff(p, o);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void diff_flush_stat(struct diff_filepair *p, struct diff_options *o,
|
|
|
|
struct diffstat_t *diffstat)
|
|
|
|
{
|
|
|
|
if (diff_unmodified_pair(p))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) ||
|
|
|
|
(DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
|
|
|
|
return; /* no tree diffs in patch format */
|
|
|
|
|
|
|
|
run_diffstat(p, o, diffstat);
|
|
|
|
}
|
|
|
|
|
2006-05-20 23:43:13 +02:00
|
|
|
static void diff_flush_checkdiff(struct diff_filepair *p,
|
|
|
|
struct diff_options *o)
|
|
|
|
{
|
|
|
|
if (diff_unmodified_pair(p))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) ||
|
|
|
|
(DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
|
|
|
|
return; /* no tree diffs in patch format */
|
|
|
|
|
|
|
|
run_checkdiff(p, o);
|
|
|
|
}
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
int diff_queue_is_empty(void)
|
|
|
|
{
|
|
|
|
struct diff_queue_struct *q = &diff_queued_diff;
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < q->nr; i++)
|
|
|
|
if (!diff_unmodified_pair(q->queue[i]))
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if DIFF_DEBUG
|
|
|
|
void diff_debug_filespec(struct diff_filespec *s, int x, const char *one)
|
|
|
|
{
|
|
|
|
fprintf(stderr, "queue[%d] %s (%s) %s %06o %s\n",
|
|
|
|
x, one ? one : "",
|
|
|
|
s->path,
|
|
|
|
DIFF_FILE_VALID(s) ? "valid" : "invalid",
|
|
|
|
s->mode,
|
|
|
|
s->sha1_valid ? sha1_to_hex(s->sha1) : "");
|
|
|
|
fprintf(stderr, "queue[%d] %s size %lu flags %d\n",
|
|
|
|
x, one ? one : "",
|
|
|
|
s->size, s->xfrm_flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void diff_debug_filepair(const struct diff_filepair *p, int i)
|
|
|
|
{
|
|
|
|
diff_debug_filespec(p->one, i, "one");
|
|
|
|
diff_debug_filespec(p->two, i, "two");
|
2007-10-25 20:20:56 +02:00
|
|
|
fprintf(stderr, "score %d, status %c rename_used %d broken %d\n",
|
2006-04-22 08:57:45 +02:00
|
|
|
p->score, p->status ? p->status : '?',
|
2007-10-25 20:20:56 +02:00
|
|
|
p->one->rename_used, p->broken_pair);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void diff_debug_queue(const char *msg, struct diff_queue_struct *q)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
if (msg)
|
|
|
|
fprintf(stderr, "%s\n", msg);
|
|
|
|
fprintf(stderr, "q->nr = %d\n", q->nr);
|
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
struct diff_filepair *p = q->queue[i];
|
|
|
|
diff_debug_filepair(p, i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static void diff_resolve_rename_copy(void)
|
|
|
|
{
|
2007-10-25 20:20:56 +02:00
|
|
|
int i;
|
|
|
|
struct diff_filepair *p;
|
2006-04-22 08:57:45 +02:00
|
|
|
struct diff_queue_struct *q = &diff_queued_diff;
|
|
|
|
|
|
|
|
diff_debug_queue("resolve-rename-copy", q);
|
|
|
|
|
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
p = q->queue[i];
|
|
|
|
p->status = 0; /* undecided */
|
|
|
|
if (DIFF_PAIR_UNMERGED(p))
|
|
|
|
p->status = DIFF_STATUS_UNMERGED;
|
|
|
|
else if (!DIFF_FILE_VALID(p->one))
|
|
|
|
p->status = DIFF_STATUS_ADDED;
|
|
|
|
else if (!DIFF_FILE_VALID(p->two))
|
|
|
|
p->status = DIFF_STATUS_DELETED;
|
|
|
|
else if (DIFF_PAIR_TYPE_CHANGED(p))
|
|
|
|
p->status = DIFF_STATUS_TYPE_CHANGED;
|
|
|
|
|
|
|
|
/* from this point on, we are dealing with a pair
|
|
|
|
* whose both sides are valid and of the same type, i.e.
|
|
|
|
* either in-place edit or rename/copy edit.
|
|
|
|
*/
|
|
|
|
else if (DIFF_PAIR_RENAME(p)) {
|
2007-10-25 20:20:56 +02:00
|
|
|
/*
|
|
|
|
* A rename might have re-connected a broken
|
|
|
|
* pair up, causing the pathnames to be the
|
|
|
|
* same again. If so, that's not a rename at
|
|
|
|
* all, just a modification..
|
|
|
|
*
|
|
|
|
* Otherwise, see if this source was used for
|
|
|
|
* multiple renames, in which case we decrement
|
|
|
|
* the count, and call it a copy.
|
2006-04-22 08:57:45 +02:00
|
|
|
*/
|
2007-10-25 20:20:56 +02:00
|
|
|
if (!strcmp(p->one->path, p->two->path))
|
|
|
|
p->status = DIFF_STATUS_MODIFIED;
|
|
|
|
else if (--p->one->rename_used > 0)
|
2006-04-22 08:57:45 +02:00
|
|
|
p->status = DIFF_STATUS_COPIED;
|
2007-10-25 20:20:56 +02:00
|
|
|
else
|
2006-04-22 08:57:45 +02:00
|
|
|
p->status = DIFF_STATUS_RENAMED;
|
|
|
|
}
|
2006-08-17 20:54:57 +02:00
|
|
|
else if (hashcmp(p->one->sha1, p->two->sha1) ||
|
2007-02-22 21:50:10 +01:00
|
|
|
p->one->mode != p->two->mode ||
|
|
|
|
is_null_sha1(p->one->sha1))
|
2006-04-22 08:57:45 +02:00
|
|
|
p->status = DIFF_STATUS_MODIFIED;
|
|
|
|
else {
|
|
|
|
/* This is a "no-change" entry and should not
|
|
|
|
* happen anymore, but prepare for broken callers.
|
|
|
|
*/
|
|
|
|
error("feeding unmodified %s to diffcore",
|
|
|
|
p->one->path);
|
|
|
|
p->status = DIFF_STATUS_UNKNOWN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
diff_debug_queue("resolve-rename-copy done", q);
|
|
|
|
}
|
|
|
|
|
2006-06-24 19:21:53 +02:00
|
|
|
static int check_pair_status(struct diff_filepair *p)
|
2006-04-22 08:57:45 +02:00
|
|
|
{
|
|
|
|
switch (p->status) {
|
|
|
|
case DIFF_STATUS_UNKNOWN:
|
2006-06-24 19:21:53 +02:00
|
|
|
return 0;
|
2006-04-22 08:57:45 +02:00
|
|
|
case 0:
|
|
|
|
die("internal error in diff-resolve-rename-copy");
|
|
|
|
default:
|
2006-06-24 19:21:53 +02:00
|
|
|
return 1;
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-06-24 19:21:53 +02:00
|
|
|
static void flush_one_pair(struct diff_filepair *p, struct diff_options *opt)
|
|
|
|
{
|
|
|
|
int fmt = opt->output_format;
|
|
|
|
|
|
|
|
if (fmt & DIFF_FORMAT_CHECKDIFF)
|
|
|
|
diff_flush_checkdiff(p, opt);
|
|
|
|
else if (fmt & (DIFF_FORMAT_RAW | DIFF_FORMAT_NAME_STATUS))
|
|
|
|
diff_flush_raw(p, opt);
|
|
|
|
else if (fmt & DIFF_FORMAT_NAME)
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
write_name_quoted(p->two->path, stdout, opt->line_termination);
|
2006-06-24 19:21:53 +02:00
|
|
|
}
|
|
|
|
|
2006-05-14 14:13:49 +02:00
|
|
|
static void show_file_mode_name(const char *newdelete, struct diff_filespec *fs)
|
|
|
|
{
|
|
|
|
if (fs->mode)
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
printf(" %s mode %06o ", newdelete, fs->mode);
|
2006-05-14 14:13:49 +02:00
|
|
|
else
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
printf(" %s ", newdelete);
|
|
|
|
write_name_quoted(fs->path, stdout, '\n');
|
2006-05-14 14:13:49 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void show_mode_change(struct diff_filepair *p, int show_name)
|
|
|
|
{
|
|
|
|
if (p->one->mode && p->two->mode && p->one->mode != p->two->mode) {
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
printf(" mode change %06o => %06o%c", p->one->mode, p->two->mode,
|
|
|
|
show_name ? ' ' : '\n');
|
2007-02-10 15:37:48 +01:00
|
|
|
if (show_name) {
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
write_name_quoted(p->two->path, stdout, '\n');
|
2007-02-10 15:37:48 +01:00
|
|
|
}
|
2006-05-14 14:13:49 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void show_rename_copy(const char *renamecopy, struct diff_filepair *p)
|
|
|
|
{
|
2007-02-10 15:36:47 +01:00
|
|
|
char *names = pprint_rename(p->one->path, p->two->path);
|
2006-05-14 14:13:49 +02:00
|
|
|
|
2007-06-25 00:23:34 +02:00
|
|
|
printf(" %s %s (%d%%)\n", renamecopy, names, similarity_index(p));
|
2007-02-10 15:36:47 +01:00
|
|
|
free(names);
|
2006-05-14 14:13:49 +02:00
|
|
|
show_mode_change(p, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void diff_summary(struct diff_filepair *p)
|
|
|
|
{
|
|
|
|
switch(p->status) {
|
|
|
|
case DIFF_STATUS_DELETED:
|
|
|
|
show_file_mode_name("delete", p->one);
|
|
|
|
break;
|
|
|
|
case DIFF_STATUS_ADDED:
|
|
|
|
show_file_mode_name("create", p->two);
|
|
|
|
break;
|
|
|
|
case DIFF_STATUS_COPIED:
|
|
|
|
show_rename_copy("copy", p);
|
|
|
|
break;
|
|
|
|
case DIFF_STATUS_RENAMED:
|
|
|
|
show_rename_copy("rename", p);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (p->score) {
|
2007-11-22 08:06:44 +01:00
|
|
|
fputs(" rewrite ", stdout);
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
write_name_quoted(p->two->path, stdout, ' ');
|
|
|
|
printf("(%d%%)\n", similarity_index(p));
|
|
|
|
}
|
|
|
|
show_mode_change(p, !p->score);
|
2006-05-14 14:13:49 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-06-25 03:51:08 +02:00
|
|
|
struct patch_id_t {
|
|
|
|
struct xdiff_emit_state xm;
|
|
|
|
SHA_CTX *ctx;
|
|
|
|
int patchlen;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int remove_space(char *line, int len)
|
|
|
|
{
|
|
|
|
int i;
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
char *dst = line;
|
|
|
|
unsigned char c;
|
2006-06-25 03:51:08 +02:00
|
|
|
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
if (!isspace((c = line[i])))
|
|
|
|
*dst++ = c;
|
2006-06-25 03:51:08 +02:00
|
|
|
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 00:42:15 +02:00
|
|
|
return dst - line;
|
2006-06-25 03:51:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void patch_id_consume(void *priv, char *line, unsigned long len)
|
|
|
|
{
|
|
|
|
struct patch_id_t *data = priv;
|
|
|
|
int new_len;
|
|
|
|
|
|
|
|
/* Ignore line numbers when computing the SHA1 of the patch */
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 10:53:29 +01:00
|
|
|
if (!prefixcmp(line, "@@ -"))
|
2006-06-25 03:51:08 +02:00
|
|
|
return;
|
|
|
|
|
|
|
|
new_len = remove_space(line, len);
|
|
|
|
|
|
|
|
SHA1_Update(data->ctx, line, new_len);
|
|
|
|
data->patchlen += new_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* returns 0 upon success, and writes result into sha1 */
|
|
|
|
static int diff_get_patch_id(struct diff_options *options, unsigned char *sha1)
|
|
|
|
{
|
|
|
|
struct diff_queue_struct *q = &diff_queued_diff;
|
|
|
|
int i;
|
|
|
|
SHA_CTX ctx;
|
|
|
|
struct patch_id_t data;
|
|
|
|
char buffer[PATH_MAX * 4 + 20];
|
|
|
|
|
|
|
|
SHA1_Init(&ctx);
|
|
|
|
memset(&data, 0, sizeof(struct patch_id_t));
|
|
|
|
data.ctx = &ctx;
|
|
|
|
data.xm.consume = patch_id_consume;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
2007-07-04 20:05:46 +02:00
|
|
|
memset(&xecfg, 0, sizeof(xecfg));
|
2006-06-25 03:51:08 +02:00
|
|
|
if (p->status == 0)
|
|
|
|
return error("internal diff status error");
|
|
|
|
if (p->status == DIFF_STATUS_UNKNOWN)
|
|
|
|
continue;
|
|
|
|
if (diff_unmodified_pair(p))
|
|
|
|
continue;
|
|
|
|
if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) ||
|
|
|
|
(DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
|
|
|
|
continue;
|
|
|
|
if (DIFF_PAIR_UNMERGED(p))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
diff_fill_sha1_info(p->one);
|
|
|
|
diff_fill_sha1_info(p->two);
|
|
|
|
if (fill_mmfile(&mf1, p->one) < 0 ||
|
|
|
|
fill_mmfile(&mf2, p->two) < 0)
|
|
|
|
return error("unable to read files to diff");
|
|
|
|
|
|
|
|
len1 = remove_space(p->one->path, strlen(p->one->path));
|
|
|
|
len2 = remove_space(p->two->path, strlen(p->two->path));
|
|
|
|
if (p->one->mode == 0)
|
|
|
|
len1 = snprintf(buffer, sizeof(buffer),
|
|
|
|
"diff--gita/%.*sb/%.*s"
|
|
|
|
"newfilemode%06o"
|
|
|
|
"---/dev/null"
|
|
|
|
"+++b/%.*s",
|
|
|
|
len1, p->one->path,
|
|
|
|
len2, p->two->path,
|
|
|
|
p->two->mode,
|
|
|
|
len2, p->two->path);
|
|
|
|
else if (p->two->mode == 0)
|
|
|
|
len1 = snprintf(buffer, sizeof(buffer),
|
|
|
|
"diff--gita/%.*sb/%.*s"
|
|
|
|
"deletedfilemode%06o"
|
|
|
|
"---a/%.*s"
|
|
|
|
"+++/dev/null",
|
|
|
|
len1, p->one->path,
|
|
|
|
len2, p->two->path,
|
|
|
|
p->one->mode,
|
|
|
|
len1, p->one->path);
|
|
|
|
else
|
|
|
|
len1 = snprintf(buffer, sizeof(buffer),
|
|
|
|
"diff--gita/%.*sb/%.*s"
|
|
|
|
"---a/%.*s"
|
|
|
|
"+++b/%.*s",
|
|
|
|
len1, p->one->path,
|
|
|
|
len2, p->two->path,
|
|
|
|
len1, p->one->path,
|
|
|
|
len2, p->two->path);
|
|
|
|
SHA1_Update(&ctx, buffer, len1);
|
|
|
|
|
|
|
|
xpp.flags = XDF_NEED_MINIMAL;
|
|
|
|
xecfg.ctxlen = 3;
|
2006-06-29 07:49:42 +02:00
|
|
|
xecfg.flags = XDL_EMIT_FUNCNAMES;
|
2006-06-25 03:51:08 +02:00
|
|
|
ecb.outf = xdiff_outf;
|
|
|
|
ecb.priv = &data;
|
2007-12-13 22:25:07 +01:00
|
|
|
xdi_diff(&mf1, &mf2, &xpp, &xecfg, &ecb);
|
2006-06-25 03:51:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
SHA1_Final(sha1, &ctx);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int diff_flush_patch_id(struct diff_options *options, unsigned char *sha1)
|
|
|
|
{
|
|
|
|
struct diff_queue_struct *q = &diff_queued_diff;
|
|
|
|
int i;
|
|
|
|
int result = diff_get_patch_id(options, sha1);
|
|
|
|
|
|
|
|
for (i = 0; i < q->nr; i++)
|
|
|
|
diff_free_filepair(q->queue[i]);
|
|
|
|
|
|
|
|
free(q->queue);
|
|
|
|
q->queue = NULL;
|
|
|
|
q->nr = q->alloc = 0;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2006-06-27 14:09:17 +02:00
|
|
|
static int is_summary_empty(const struct diff_queue_struct *q)
|
2006-04-22 08:57:45 +02:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2006-06-27 14:09:17 +02:00
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
const struct diff_filepair *p = q->queue[i];
|
|
|
|
|
|
|
|
switch (p->status) {
|
|
|
|
case DIFF_STATUS_DELETED:
|
|
|
|
case DIFF_STATUS_ADDED:
|
|
|
|
case DIFF_STATUS_COPIED:
|
|
|
|
case DIFF_STATUS_RENAMED:
|
|
|
|
return 0;
|
|
|
|
default:
|
|
|
|
if (p->score)
|
|
|
|
return 0;
|
|
|
|
if (p->one->mode && p->two->mode &&
|
|
|
|
p->one->mode != p->two->mode)
|
|
|
|
return 0;
|
|
|
|
break;
|
|
|
|
}
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
2006-06-27 14:09:17 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
void diff_flush(struct diff_options *options)
|
|
|
|
{
|
|
|
|
struct diff_queue_struct *q = &diff_queued_diff;
|
2006-06-24 19:21:53 +02:00
|
|
|
int i, output_format = options->output_format;
|
2006-06-27 14:09:17 +02:00
|
|
|
int separator = 0;
|
2006-04-22 08:57:45 +02:00
|
|
|
|
2006-06-24 19:21:53 +02:00
|
|
|
/*
|
|
|
|
* Order: raw, stat, summary, patch
|
|
|
|
* or: name/name-status/checkdiff (other bits clear)
|
|
|
|
*/
|
2006-06-27 14:09:17 +02:00
|
|
|
if (!q->nr)
|
|
|
|
goto free_queue;
|
2006-04-22 08:57:45 +02:00
|
|
|
|
2006-06-24 19:21:53 +02:00
|
|
|
if (output_format & (DIFF_FORMAT_RAW |
|
|
|
|
DIFF_FORMAT_NAME |
|
|
|
|
DIFF_FORMAT_NAME_STATUS |
|
|
|
|
DIFF_FORMAT_CHECKDIFF)) {
|
2006-04-22 08:57:45 +02:00
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
struct diff_filepair *p = q->queue[i];
|
2006-06-24 19:21:53 +02:00
|
|
|
if (check_pair_status(p))
|
|
|
|
flush_one_pair(p, options);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
2006-06-27 14:09:17 +02:00
|
|
|
separator++;
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
2006-06-24 19:21:53 +02:00
|
|
|
|
2006-12-15 05:15:44 +01:00
|
|
|
if (output_format & (DIFF_FORMAT_DIFFSTAT|DIFF_FORMAT_SHORTSTAT|DIFF_FORMAT_NUMSTAT)) {
|
2006-06-25 13:28:19 +02:00
|
|
|
struct diffstat_t diffstat;
|
2006-06-24 19:21:53 +02:00
|
|
|
|
2006-06-25 13:28:19 +02:00
|
|
|
memset(&diffstat, 0, sizeof(struct diffstat_t));
|
|
|
|
diffstat.xm.consume = diffstat_consume;
|
2006-04-22 08:57:45 +02:00
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
struct diff_filepair *p = q->queue[i];
|
2006-06-24 19:21:53 +02:00
|
|
|
if (check_pair_status(p))
|
2006-06-25 13:28:19 +02:00
|
|
|
diff_flush_stat(p, options, &diffstat);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
2006-10-12 12:01:00 +02:00
|
|
|
if (output_format & DIFF_FORMAT_NUMSTAT)
|
|
|
|
show_numstat(&diffstat, options);
|
|
|
|
if (output_format & DIFF_FORMAT_DIFFSTAT)
|
|
|
|
show_stats(&diffstat, options);
|
2007-12-12 08:46:30 +01:00
|
|
|
if (output_format & DIFF_FORMAT_SHORTSTAT)
|
2006-12-15 05:15:44 +01:00
|
|
|
show_shortstats(&diffstat);
|
2007-12-12 08:46:30 +01:00
|
|
|
free_diffstat_info(&diffstat);
|
2006-06-28 00:08:19 +02:00
|
|
|
separator++;
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
2006-06-27 14:09:17 +02:00
|
|
|
if (output_format & DIFF_FORMAT_SUMMARY && !is_summary_empty(q)) {
|
2006-06-24 19:21:53 +02:00
|
|
|
for (i = 0; i < q->nr; i++)
|
|
|
|
diff_summary(q->queue[i]);
|
2006-06-28 00:08:19 +02:00
|
|
|
separator++;
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
2006-06-24 19:21:53 +02:00
|
|
|
if (output_format & DIFF_FORMAT_PATCH) {
|
2006-06-27 14:09:17 +02:00
|
|
|
if (separator) {
|
|
|
|
if (options->stat_sep) {
|
|
|
|
/* attach patch instead of inline */
|
2006-06-24 19:21:53 +02:00
|
|
|
fputs(options->stat_sep, stdout);
|
2006-06-27 14:09:17 +02:00
|
|
|
} else {
|
2006-06-24 19:21:53 +02:00
|
|
|
putchar(options->line_termination);
|
2006-06-27 14:09:17 +02:00
|
|
|
}
|
2006-06-24 19:21:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
struct diff_filepair *p = q->queue[i];
|
|
|
|
if (check_pair_status(p))
|
|
|
|
diff_flush_patch(p, options);
|
|
|
|
}
|
2006-05-14 14:13:49 +02:00
|
|
|
}
|
|
|
|
|
2006-09-07 08:35:42 +02:00
|
|
|
if (output_format & DIFF_FORMAT_CALLBACK)
|
|
|
|
options->format_callback(q, options, options->format_callback_data);
|
|
|
|
|
2006-06-24 19:21:53 +02:00
|
|
|
for (i = 0; i < q->nr; i++)
|
|
|
|
diff_free_filepair(q->queue[i]);
|
2006-06-27 14:09:17 +02:00
|
|
|
free_queue:
|
2006-04-22 08:57:45 +02:00
|
|
|
free(q->queue);
|
|
|
|
q->queue = NULL;
|
|
|
|
q->nr = q->alloc = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void diffcore_apply_filter(const char *filter)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct diff_queue_struct *q = &diff_queued_diff;
|
|
|
|
struct diff_queue_struct outq;
|
|
|
|
outq.queue = NULL;
|
|
|
|
outq.nr = outq.alloc = 0;
|
|
|
|
|
|
|
|
if (!filter)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (strchr(filter, DIFF_STATUS_FILTER_AON)) {
|
|
|
|
int found;
|
|
|
|
for (i = found = 0; !found && i < q->nr; i++) {
|
|
|
|
struct diff_filepair *p = q->queue[i];
|
|
|
|
if (((p->status == DIFF_STATUS_MODIFIED) &&
|
|
|
|
((p->score &&
|
|
|
|
strchr(filter, DIFF_STATUS_FILTER_BROKEN)) ||
|
|
|
|
(!p->score &&
|
|
|
|
strchr(filter, DIFF_STATUS_MODIFIED)))) ||
|
|
|
|
((p->status != DIFF_STATUS_MODIFIED) &&
|
|
|
|
strchr(filter, p->status)))
|
|
|
|
found++;
|
|
|
|
}
|
|
|
|
if (found)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* otherwise we will clear the whole queue
|
|
|
|
* by copying the empty outq at the end of this
|
|
|
|
* function, but first clear the current entries
|
|
|
|
* in the queue.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < q->nr; i++)
|
|
|
|
diff_free_filepair(q->queue[i]);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* Only the matching ones */
|
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
struct diff_filepair *p = q->queue[i];
|
|
|
|
|
|
|
|
if (((p->status == DIFF_STATUS_MODIFIED) &&
|
|
|
|
((p->score &&
|
|
|
|
strchr(filter, DIFF_STATUS_FILTER_BROKEN)) ||
|
|
|
|
(!p->score &&
|
|
|
|
strchr(filter, DIFF_STATUS_MODIFIED)))) ||
|
|
|
|
((p->status != DIFF_STATUS_MODIFIED) &&
|
|
|
|
strchr(filter, p->status)))
|
|
|
|
diff_q(&outq, p);
|
|
|
|
else
|
|
|
|
diff_free_filepair(p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(q->queue);
|
|
|
|
*q = outq;
|
|
|
|
}
|
|
|
|
|
2007-09-08 12:30:22 +02:00
|
|
|
/* Check whether two filespecs with the same mode and size are identical */
|
|
|
|
static int diff_filespec_is_identical(struct diff_filespec *one,
|
|
|
|
struct diff_filespec *two)
|
|
|
|
{
|
|
|
|
if (S_ISGITLINK(one->mode)) {
|
|
|
|
diff_fill_sha1_info(one);
|
|
|
|
diff_fill_sha1_info(two);
|
|
|
|
return !hashcmp(one->sha1, two->sha1);
|
|
|
|
}
|
|
|
|
if (diff_populate_filespec(one, 0))
|
|
|
|
return 0;
|
|
|
|
if (diff_populate_filespec(two, 0))
|
|
|
|
return 0;
|
|
|
|
return !memcmp(one->data, two->data, one->size);
|
|
|
|
}
|
|
|
|
|
git-diff: squelch "empty" diffs
After starting to edit a working tree file but later when your edit ends
up identical to the original (this can also happen when you ran a
wholesale regexp replace with something like "perl -i" that does not
actually modify many of the paths), "git diff" between the index and the
working tree outputs many "empty" diffs that show "diff --git" headers
and nothing else, because these paths are stat-dirty. While it was a
way to warn the user that the earlier action of the user made the index
ineffective as an optimization mechanism, it was felt too loud for the
purpose of warning even to experienced users, and also resulted in
confusing people new to git.
This replaces the "empty" diffs with a single warning message at the
end. Having many such paths hurts performance, and you can run
"git-update-index --refresh" to update the lstat(2) information recorded
in the index in such a case. "git-status" does so as a side effect, and
that is more familiar to the end-user, so we recommend it to them.
The change affects only "git diff" that outputs patch text, because that
is where the annoyance of too many "empty" diff is most strongly felt,
and because the warning message can be safely ignored by downstream
tools without getting mistaken as part of the patch. For the low-level
"git diff-files" and "git diff-index", the traditional behaviour is
retained.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-08-03 22:33:31 +02:00
|
|
|
static void diffcore_skip_stat_unmatch(struct diff_options *diffopt)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct diff_queue_struct *q = &diff_queued_diff;
|
|
|
|
struct diff_queue_struct outq;
|
|
|
|
outq.queue = NULL;
|
|
|
|
outq.nr = outq.alloc = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
struct diff_filepair *p = q->queue[i];
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 1. Entries that come from stat info dirtyness
|
|
|
|
* always have both sides (iow, not create/delete),
|
|
|
|
* one side of the object name is unknown, with
|
|
|
|
* the same mode and size. Keep the ones that
|
|
|
|
* do not match these criteria. They have real
|
|
|
|
* differences.
|
|
|
|
*
|
|
|
|
* 2. At this point, the file is known to be modified,
|
|
|
|
* with the same mode and size, and the object
|
|
|
|
* name of one side is unknown. Need to inspect
|
|
|
|
* the identical contents.
|
|
|
|
*/
|
|
|
|
if (!DIFF_FILE_VALID(p->one) || /* (1) */
|
|
|
|
!DIFF_FILE_VALID(p->two) ||
|
|
|
|
(p->one->sha1_valid && p->two->sha1_valid) ||
|
|
|
|
(p->one->mode != p->two->mode) ||
|
|
|
|
diff_populate_filespec(p->one, 1) ||
|
|
|
|
diff_populate_filespec(p->two, 1) ||
|
|
|
|
(p->one->size != p->two->size) ||
|
2007-09-08 12:30:22 +02:00
|
|
|
!diff_filespec_is_identical(p->one, p->two)) /* (2) */
|
git-diff: squelch "empty" diffs
After starting to edit a working tree file but later when your edit ends
up identical to the original (this can also happen when you ran a
wholesale regexp replace with something like "perl -i" that does not
actually modify many of the paths), "git diff" between the index and the
working tree outputs many "empty" diffs that show "diff --git" headers
and nothing else, because these paths are stat-dirty. While it was a
way to warn the user that the earlier action of the user made the index
ineffective as an optimization mechanism, it was felt too loud for the
purpose of warning even to experienced users, and also resulted in
confusing people new to git.
This replaces the "empty" diffs with a single warning message at the
end. Having many such paths hurts performance, and you can run
"git-update-index --refresh" to update the lstat(2) information recorded
in the index in such a case. "git-status" does so as a side effect, and
that is more familiar to the end-user, so we recommend it to them.
The change affects only "git diff" that outputs patch text, because that
is where the annoyance of too many "empty" diff is most strongly felt,
and because the warning message can be safely ignored by downstream
tools without getting mistaken as part of the patch. For the low-level
"git diff-files" and "git diff-index", the traditional behaviour is
retained.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-08-03 22:33:31 +02:00
|
|
|
diff_q(&outq, p);
|
|
|
|
else {
|
|
|
|
/*
|
|
|
|
* The caller can subtract 1 from skip_stat_unmatch
|
|
|
|
* to determine how many paths were dirty only
|
|
|
|
* due to stat info mismatch.
|
|
|
|
*/
|
2007-11-10 20:05:14 +01:00
|
|
|
if (!DIFF_OPT_TST(diffopt, NO_INDEX))
|
2007-08-15 00:41:00 +02:00
|
|
|
diffopt->skip_stat_unmatch++;
|
git-diff: squelch "empty" diffs
After starting to edit a working tree file but later when your edit ends
up identical to the original (this can also happen when you ran a
wholesale regexp replace with something like "perl -i" that does not
actually modify many of the paths), "git diff" between the index and the
working tree outputs many "empty" diffs that show "diff --git" headers
and nothing else, because these paths are stat-dirty. While it was a
way to warn the user that the earlier action of the user made the index
ineffective as an optimization mechanism, it was felt too loud for the
purpose of warning even to experienced users, and also resulted in
confusing people new to git.
This replaces the "empty" diffs with a single warning message at the
end. Having many such paths hurts performance, and you can run
"git-update-index --refresh" to update the lstat(2) information recorded
in the index in such a case. "git-status" does so as a side effect, and
that is more familiar to the end-user, so we recommend it to them.
The change affects only "git diff" that outputs patch text, because that
is where the annoyance of too many "empty" diff is most strongly felt,
and because the warning message can be safely ignored by downstream
tools without getting mistaken as part of the patch. For the low-level
"git diff-files" and "git diff-index", the traditional behaviour is
retained.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-08-03 22:33:31 +02:00
|
|
|
diff_free_filepair(p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(q->queue);
|
|
|
|
*q = outq;
|
|
|
|
}
|
|
|
|
|
2006-04-22 08:57:45 +02:00
|
|
|
void diffcore_std(struct diff_options *options)
|
|
|
|
{
|
2007-11-10 20:05:14 +01:00
|
|
|
if (DIFF_OPT_TST(options, QUIET))
|
2007-03-14 19:12:13 +01:00
|
|
|
return;
|
2007-06-29 07:56:07 +02:00
|
|
|
|
2007-11-10 20:05:14 +01:00
|
|
|
if (options->skip_stat_unmatch && !DIFF_OPT_TST(options, FIND_COPIES_HARDER))
|
git-diff: squelch "empty" diffs
After starting to edit a working tree file but later when your edit ends
up identical to the original (this can also happen when you ran a
wholesale regexp replace with something like "perl -i" that does not
actually modify many of the paths), "git diff" between the index and the
working tree outputs many "empty" diffs that show "diff --git" headers
and nothing else, because these paths are stat-dirty. While it was a
way to warn the user that the earlier action of the user made the index
ineffective as an optimization mechanism, it was felt too loud for the
purpose of warning even to experienced users, and also resulted in
confusing people new to git.
This replaces the "empty" diffs with a single warning message at the
end. Having many such paths hurts performance, and you can run
"git-update-index --refresh" to update the lstat(2) information recorded
in the index in such a case. "git-status" does so as a side effect, and
that is more familiar to the end-user, so we recommend it to them.
The change affects only "git diff" that outputs patch text, because that
is where the annoyance of too many "empty" diff is most strongly felt,
and because the warning message can be safely ignored by downstream
tools without getting mistaken as part of the patch. For the low-level
"git diff-files" and "git diff-index", the traditional behaviour is
retained.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-08-03 22:33:31 +02:00
|
|
|
diffcore_skip_stat_unmatch(options);
|
2006-04-22 08:57:45 +02:00
|
|
|
if (options->break_opt != -1)
|
|
|
|
diffcore_break(options->break_opt);
|
|
|
|
if (options->detect_rename)
|
|
|
|
diffcore_rename(options);
|
|
|
|
if (options->break_opt != -1)
|
|
|
|
diffcore_merge_broken();
|
|
|
|
if (options->pickaxe)
|
|
|
|
diffcore_pickaxe(options->pickaxe, options->pickaxe_opts);
|
|
|
|
if (options->orderfile)
|
|
|
|
diffcore_order(options->orderfile);
|
|
|
|
diff_resolve_rename_copy();
|
|
|
|
diffcore_apply_filter(options->filter);
|
2007-03-14 19:12:13 +01:00
|
|
|
|
2007-11-10 20:05:14 +01:00
|
|
|
if (diff_queued_diff.nr)
|
|
|
|
DIFF_OPT_SET(options, HAS_CHANGES);
|
|
|
|
else
|
|
|
|
DIFF_OPT_CLR(options, HAS_CHANGES);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
2007-12-14 08:40:27 +01:00
|
|
|
int diff_result_code(struct diff_options *opt, int status)
|
|
|
|
{
|
|
|
|
int result = 0;
|
|
|
|
if (!DIFF_OPT_TST(opt, EXIT_WITH_STATUS) &&
|
|
|
|
!(opt->output_format & DIFF_FORMAT_CHECKDIFF))
|
|
|
|
return status;
|
|
|
|
if (DIFF_OPT_TST(opt, EXIT_WITH_STATUS) &&
|
|
|
|
DIFF_OPT_TST(opt, HAS_CHANGES))
|
|
|
|
result |= 01;
|
|
|
|
if ((opt->output_format & DIFF_FORMAT_CHECKDIFF) &&
|
|
|
|
DIFF_OPT_TST(opt, CHECK_FAILED))
|
|
|
|
result |= 02;
|
|
|
|
return result;
|
|
|
|
}
|
2006-04-22 08:57:45 +02:00
|
|
|
|
|
|
|
void diff_addremove(struct diff_options *options,
|
|
|
|
int addremove, unsigned mode,
|
|
|
|
const unsigned char *sha1,
|
|
|
|
const char *base, const char *path)
|
|
|
|
{
|
|
|
|
char concatpath[PATH_MAX];
|
|
|
|
struct diff_filespec *one, *two;
|
|
|
|
|
|
|
|
/* This may look odd, but it is a preparation for
|
|
|
|
* feeding "there are unchanged files which should
|
|
|
|
* not produce diffs, but when you are doing copy
|
|
|
|
* detection you would need them, so here they are"
|
|
|
|
* entries to the diff-core. They will be prefixed
|
|
|
|
* with something like '=' or '*' (I haven't decided
|
|
|
|
* which but should not make any difference).
|
2007-06-07 09:04:01 +02:00
|
|
|
* Feeding the same new and old to diff_change()
|
2006-04-22 08:57:45 +02:00
|
|
|
* also has the same effect.
|
|
|
|
* Before the final output happens, they are pruned after
|
|
|
|
* merged into rename/copy pairs as appropriate.
|
|
|
|
*/
|
2007-11-10 20:05:14 +01:00
|
|
|
if (DIFF_OPT_TST(options, REVERSE_DIFF))
|
2006-04-22 08:57:45 +02:00
|
|
|
addremove = (addremove == '+' ? '-' :
|
|
|
|
addremove == '-' ? '+' : addremove);
|
|
|
|
|
|
|
|
if (!path) path = "";
|
|
|
|
sprintf(concatpath, "%s%s", base, path);
|
|
|
|
one = alloc_filespec(concatpath);
|
|
|
|
two = alloc_filespec(concatpath);
|
|
|
|
|
|
|
|
if (addremove != '+')
|
|
|
|
fill_filespec(one, sha1, mode);
|
|
|
|
if (addremove != '-')
|
|
|
|
fill_filespec(two, sha1, mode);
|
|
|
|
|
|
|
|
diff_queue(&diff_queued_diff, one, two);
|
2007-11-10 20:05:14 +01:00
|
|
|
DIFF_OPT_SET(options, HAS_CHANGES);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void diff_change(struct diff_options *options,
|
|
|
|
unsigned old_mode, unsigned new_mode,
|
|
|
|
const unsigned char *old_sha1,
|
|
|
|
const unsigned char *new_sha1,
|
2007-06-07 09:04:01 +02:00
|
|
|
const char *base, const char *path)
|
2006-04-22 08:57:45 +02:00
|
|
|
{
|
|
|
|
char concatpath[PATH_MAX];
|
|
|
|
struct diff_filespec *one, *two;
|
|
|
|
|
2007-11-10 20:05:14 +01:00
|
|
|
if (DIFF_OPT_TST(options, REVERSE_DIFF)) {
|
2006-04-22 08:57:45 +02:00
|
|
|
unsigned tmp;
|
|
|
|
const unsigned char *tmp_c;
|
|
|
|
tmp = old_mode; old_mode = new_mode; new_mode = tmp;
|
|
|
|
tmp_c = old_sha1; old_sha1 = new_sha1; new_sha1 = tmp_c;
|
|
|
|
}
|
|
|
|
if (!path) path = "";
|
|
|
|
sprintf(concatpath, "%s%s", base, path);
|
|
|
|
one = alloc_filespec(concatpath);
|
|
|
|
two = alloc_filespec(concatpath);
|
|
|
|
fill_filespec(one, old_sha1, old_mode);
|
|
|
|
fill_filespec(two, new_sha1, new_mode);
|
|
|
|
|
|
|
|
diff_queue(&diff_queued_diff, one, two);
|
2007-11-10 20:05:14 +01:00
|
|
|
DIFF_OPT_SET(options, HAS_CHANGES);
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void diff_unmerge(struct diff_options *options,
|
2007-01-05 10:25:18 +01:00
|
|
|
const char *path,
|
|
|
|
unsigned mode, const unsigned char *sha1)
|
2006-04-22 08:57:45 +02:00
|
|
|
{
|
|
|
|
struct diff_filespec *one, *two;
|
|
|
|
one = alloc_filespec(path);
|
|
|
|
two = alloc_filespec(path);
|
2007-01-05 10:25:18 +01:00
|
|
|
fill_filespec(one, sha1, mode);
|
|
|
|
diff_queue(&diff_queued_diff, one, two)->is_unmerged = 1;
|
2006-04-22 08:57:45 +02:00
|
|
|
}
|