2005-04-26 16:25:05 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2005 Junio C Hamano
|
|
|
|
*/
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/wait.h>
|
2005-04-28 17:13:01 +00:00
|
|
|
#include <signal.h>
|
2005-04-26 01:22:47 +00:00
|
|
|
#include "cache.h"
|
|
|
|
#include "diff.h"
|
2005-05-21 09:39:09 +00:00
|
|
|
#include "diffcore.h"
|
2005-04-26 01:22:47 +00:00
|
|
|
|
2005-05-10 00:57:56 +00:00
|
|
|
static const char *diff_opts = "-pu";
|
2005-05-19 10:32:35 +00:00
|
|
|
static unsigned char null_sha1[20] = { 0, };
|
2005-05-21 09:39:09 +00:00
|
|
|
|
|
|
|
static int reverse_diff;
|
2005-05-27 22:56:38 +00:00
|
|
|
static int use_size_cache;
|
2005-04-26 01:22:47 +00:00
|
|
|
|
2005-04-26 16:25:05 +00:00
|
|
|
static const char *external_diff(void)
|
2005-04-26 01:22:47 +00:00
|
|
|
{
|
2005-05-10 00:57:56 +00:00
|
|
|
static const char *external_diff_cmd = NULL;
|
2005-04-26 16:25:05 +00:00
|
|
|
static int done_preparing = 0;
|
|
|
|
|
|
|
|
if (done_preparing)
|
|
|
|
return external_diff_cmd;
|
|
|
|
|
2005-04-26 01:22:47 +00:00
|
|
|
/*
|
|
|
|
* Default values above are meant to match the
|
|
|
|
* Linux kernel development style. Examples of
|
|
|
|
* alternative styles you can specify via environment
|
|
|
|
* variables are:
|
|
|
|
*
|
|
|
|
* GIT_DIFF_OPTS="-c";
|
|
|
|
*/
|
2005-05-10 00:57:56 +00:00
|
|
|
if (gitenv("GIT_EXTERNAL_DIFF"))
|
|
|
|
external_diff_cmd = gitenv("GIT_EXTERNAL_DIFF");
|
2005-04-26 16:25:05 +00:00
|
|
|
|
|
|
|
/* In case external diff fails... */
|
2005-05-10 00:57:56 +00:00
|
|
|
diff_opts = gitenv("GIT_DIFF_OPTS") ? : diff_opts;
|
2005-04-26 16:25:05 +00:00
|
|
|
|
|
|
|
done_preparing = 1;
|
|
|
|
return external_diff_cmd;
|
2005-04-26 01:22:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Help to copy the thing properly quoted for the shell safety.
|
|
|
|
* any single quote is replaced with '\'', and the caller is
|
|
|
|
* expected to enclose the result within a single quote pair.
|
|
|
|
*
|
|
|
|
* E.g.
|
|
|
|
* original sq_expand result
|
|
|
|
* name ==> name ==> 'name'
|
|
|
|
* a b ==> a b ==> 'a b'
|
|
|
|
* a'b ==> a'\''b ==> 'a'\''b'
|
|
|
|
*/
|
|
|
|
static char *sq_expand(const char *src)
|
|
|
|
{
|
|
|
|
static char *buf = NULL;
|
|
|
|
int cnt, c;
|
|
|
|
const char *cp;
|
|
|
|
char *bp;
|
|
|
|
|
2005-05-20 02:00:36 +00:00
|
|
|
/* count bytes needed to store the quoted string. */
|
2005-04-26 01:22:47 +00:00
|
|
|
for (cnt = 1, cp = src; *cp; cnt++, cp++)
|
|
|
|
if (*cp == '\'')
|
|
|
|
cnt += 3;
|
|
|
|
|
2005-04-26 19:00:58 +00:00
|
|
|
buf = xmalloc(cnt);
|
2005-04-26 01:22:47 +00:00
|
|
|
bp = buf;
|
|
|
|
while ((c = *src++)) {
|
|
|
|
if (c != '\'')
|
|
|
|
*bp++ = c;
|
|
|
|
else {
|
|
|
|
bp = strcpy(bp, "'\\''");
|
|
|
|
bp += 4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*bp = 0;
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2005-04-26 16:25:05 +00:00
|
|
|
static struct diff_tempfile {
|
2005-05-21 09:39:09 +00:00
|
|
|
const char *name; /* filename external diff should read from */
|
2005-04-26 16:25:05 +00:00
|
|
|
char hex[41];
|
|
|
|
char mode[10];
|
|
|
|
char tmp_path[50];
|
|
|
|
} diff_temp[2];
|
|
|
|
|
2005-05-18 06:29:49 +00:00
|
|
|
static void builtin_diff(const char *name_a,
|
|
|
|
const char *name_b,
|
2005-05-20 02:00:36 +00:00
|
|
|
struct diff_tempfile *temp,
|
2005-05-21 09:39:09 +00:00
|
|
|
const char *xfrm_msg)
|
2005-04-26 01:22:47 +00:00
|
|
|
{
|
2005-05-19 13:23:18 +00:00
|
|
|
int i, next_at, cmd_size;
|
2005-05-01 16:33:12 +00:00
|
|
|
const char *diff_cmd = "diff -L'%s%s' -L'%s%s'";
|
2005-05-04 08:38:06 +00:00
|
|
|
const char *diff_arg = "'%s' '%s'||:"; /* "||:" is to return 0 */
|
2005-04-28 15:04:39 +00:00
|
|
|
const char *input_name_sq[2];
|
|
|
|
const char *path0[2];
|
|
|
|
const char *path1[2];
|
2005-05-18 06:29:49 +00:00
|
|
|
const char *name_sq[2];
|
2005-04-28 15:04:39 +00:00
|
|
|
char *cmd;
|
2005-05-18 06:29:49 +00:00
|
|
|
|
|
|
|
name_sq[0] = sq_expand(name_a);
|
|
|
|
name_sq[1] = sq_expand(name_b);
|
|
|
|
|
2005-05-01 16:33:12 +00:00
|
|
|
/* diff_cmd and diff_arg have 6 %s in total which makes
|
|
|
|
* the sum of these strings 12 bytes larger than required.
|
2005-04-26 16:25:05 +00:00
|
|
|
* we use 2 spaces around diff-opts, and we need to count
|
2005-05-01 16:33:12 +00:00
|
|
|
* terminating NUL, so we subtract 9 here.
|
2005-04-26 16:25:05 +00:00
|
|
|
*/
|
2005-05-19 13:23:18 +00:00
|
|
|
cmd_size = (strlen(diff_cmd) + strlen(diff_opts) +
|
2005-05-01 16:33:12 +00:00
|
|
|
strlen(diff_arg) - 9);
|
2005-04-28 15:04:39 +00:00
|
|
|
for (i = 0; i < 2; i++) {
|
|
|
|
input_name_sq[i] = sq_expand(temp[i].name);
|
|
|
|
if (!strcmp(temp[i].name, "/dev/null")) {
|
|
|
|
path0[i] = "/dev/null";
|
|
|
|
path1[i] = "";
|
|
|
|
} else {
|
2005-05-02 04:53:36 +00:00
|
|
|
path0[i] = i ? "b/" : "a/";
|
2005-05-18 06:29:49 +00:00
|
|
|
path1[i] = name_sq[i];
|
2005-04-28 15:04:39 +00:00
|
|
|
}
|
|
|
|
cmd_size += (strlen(path0[i]) + strlen(path1[i]) +
|
2005-05-01 16:33:12 +00:00
|
|
|
strlen(input_name_sq[i]));
|
2005-04-28 15:04:39 +00:00
|
|
|
}
|
2005-04-26 16:25:05 +00:00
|
|
|
|
2005-04-28 15:04:39 +00:00
|
|
|
cmd = xmalloc(cmd_size);
|
|
|
|
|
|
|
|
next_at = 0;
|
2005-04-26 16:25:05 +00:00
|
|
|
next_at += snprintf(cmd+next_at, cmd_size-next_at,
|
2005-04-28 15:04:39 +00:00
|
|
|
diff_cmd,
|
2005-05-01 16:33:12 +00:00
|
|
|
path0[0], path1[0], path0[1], path1[1]);
|
2005-04-26 16:25:05 +00:00
|
|
|
next_at += snprintf(cmd+next_at, cmd_size-next_at,
|
|
|
|
" %s ", diff_opts);
|
|
|
|
next_at += snprintf(cmd+next_at, cmd_size-next_at,
|
2005-04-28 15:04:39 +00:00
|
|
|
diff_arg, input_name_sq[0], input_name_sq[1]);
|
|
|
|
|
2005-05-18 06:29:49 +00:00
|
|
|
printf("diff --git a/%s b/%s\n", name_a, name_b);
|
2005-05-30 23:40:16 +00:00
|
|
|
if (!path1[0][0]) {
|
2005-05-18 16:10:47 +00:00
|
|
|
printf("new file mode %s\n", temp[1].mode);
|
2005-05-30 23:40:16 +00:00
|
|
|
if (xfrm_msg && xfrm_msg[0])
|
|
|
|
puts(xfrm_msg);
|
|
|
|
}
|
|
|
|
else if (!path1[1][0]) {
|
2005-05-18 16:10:47 +00:00
|
|
|
printf("deleted file mode %s\n", temp[0].mode);
|
2005-05-30 23:40:16 +00:00
|
|
|
if (xfrm_msg && xfrm_msg[0])
|
|
|
|
puts(xfrm_msg);
|
|
|
|
}
|
2005-05-14 01:40:14 +00:00
|
|
|
else {
|
2005-05-18 16:10:47 +00:00
|
|
|
if (strcmp(temp[0].mode, temp[1].mode)) {
|
|
|
|
printf("old mode %s\n", temp[0].mode);
|
|
|
|
printf("new mode %s\n", temp[1].mode);
|
|
|
|
}
|
2005-05-21 09:39:09 +00:00
|
|
|
if (xfrm_msg && xfrm_msg[0])
|
2005-05-27 22:54:06 +00:00
|
|
|
puts(xfrm_msg);
|
2005-05-21 09:39:09 +00:00
|
|
|
|
2005-05-14 01:40:14 +00:00
|
|
|
if (strncmp(temp[0].mode, temp[1].mode, 3))
|
|
|
|
/* we do not run diff between different kind
|
|
|
|
* of objects.
|
|
|
|
*/
|
2005-05-05 23:10:21 +00:00
|
|
|
exit(0);
|
|
|
|
}
|
2005-05-01 16:33:12 +00:00
|
|
|
fflush(NULL);
|
2005-04-26 16:25:05 +00:00
|
|
|
execlp("/bin/sh","sh", "-c", cmd, NULL);
|
2005-04-26 01:22:47 +00:00
|
|
|
}
|
|
|
|
|
2005-05-21 09:39:09 +00:00
|
|
|
struct diff_filespec *alloc_filespec(const char *path)
|
|
|
|
{
|
|
|
|
int namelen = strlen(path);
|
|
|
|
struct diff_filespec *spec = xmalloc(sizeof(*spec) + namelen + 1);
|
|
|
|
spec->path = (char *)(spec + 1);
|
|
|
|
strcpy(spec->path, path);
|
2005-05-22 02:42:18 +00:00
|
|
|
spec->should_free = spec->should_munmap = 0;
|
2005-05-21 09:39:09 +00:00
|
|
|
spec->xfrm_flags = 0;
|
|
|
|
spec->size = 0;
|
2005-05-22 21:33:43 +00:00
|
|
|
spec->data = NULL;
|
2005-05-22 02:42:18 +00:00
|
|
|
spec->mode = 0;
|
|
|
|
memset(spec->sha1, 0, 20);
|
2005-05-21 09:39:09 +00:00
|
|
|
return spec;
|
|
|
|
}
|
|
|
|
|
|
|
|
void fill_filespec(struct diff_filespec *spec, const unsigned char *sha1,
|
|
|
|
unsigned short mode)
|
|
|
|
{
|
2005-05-26 09:24:30 +00:00
|
|
|
if (mode) {
|
|
|
|
spec->mode = DIFF_FILE_CANON_MODE(mode);
|
2005-05-22 02:42:18 +00:00
|
|
|
memcpy(spec->sha1, sha1, 20);
|
|
|
|
spec->sha1_valid = !!memcmp(sha1, null_sha1, 20);
|
|
|
|
}
|
2005-05-21 09:39:09 +00:00
|
|
|
}
|
|
|
|
|
2005-05-04 08:45:24 +00:00
|
|
|
/*
|
|
|
|
* Given a name and sha1 pair, if the dircache tells us the file in
|
|
|
|
* the work tree has that object contents, return true, so that
|
|
|
|
* prepare_temp_file() does not have to inflate and extract.
|
|
|
|
*/
|
|
|
|
static int work_tree_matches(const char *name, const unsigned char *sha1)
|
|
|
|
{
|
|
|
|
struct cache_entry *ce;
|
|
|
|
struct stat st;
|
|
|
|
int pos, len;
|
2005-05-19 10:32:35 +00:00
|
|
|
|
2005-05-04 08:45:24 +00:00
|
|
|
/* 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
|
2005-05-18 06:29:49 +00:00
|
|
|
* tree. This is because most diff-tree comparisons deal with
|
2005-05-04 08:45:24 +00:00
|
|
|
* 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.
|
2005-05-20 02:00:36 +00:00
|
|
|
*/
|
2005-05-04 08:45:24 +00:00
|
|
|
if (!active_cache)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
len = strlen(name);
|
|
|
|
pos = cache_name_pos(name, len);
|
|
|
|
if (pos < 0)
|
|
|
|
return 0;
|
|
|
|
ce = active_cache[pos];
|
2005-05-05 23:10:21 +00:00
|
|
|
if ((lstat(name, &st) < 0) ||
|
2005-05-21 09:39:09 +00:00
|
|
|
!S_ISREG(st.st_mode) || /* careful! */
|
2005-05-15 02:04:25 +00:00
|
|
|
ce_match_stat(ce, &st) ||
|
2005-05-04 08:45:24 +00:00
|
|
|
memcmp(sha1, ce->sha1, 20))
|
|
|
|
return 0;
|
2005-05-21 09:39:09 +00:00
|
|
|
/* 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.
|
|
|
|
*/
|
2005-05-04 08:45:24 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-05-27 22:56:38 +00:00
|
|
|
static struct sha1_size_cache {
|
|
|
|
unsigned char sha1[20];
|
|
|
|
unsigned long size;
|
|
|
|
} **sha1_size_cache;
|
|
|
|
static int sha1_size_cache_nr, sha1_size_cache_alloc;
|
|
|
|
|
|
|
|
static struct sha1_size_cache *locate_size_cache(unsigned char *sha1,
|
|
|
|
unsigned long size)
|
|
|
|
{
|
|
|
|
int first, last;
|
|
|
|
struct sha1_size_cache *e;
|
|
|
|
|
|
|
|
first = 0;
|
|
|
|
last = sha1_size_cache_nr;
|
|
|
|
while (last > first) {
|
|
|
|
int next = (last + first) >> 1;
|
|
|
|
e = sha1_size_cache[next];
|
|
|
|
int cmp = memcmp(e->sha1, sha1, 20);
|
|
|
|
if (!cmp)
|
|
|
|
return e;
|
|
|
|
if (cmp < 0) {
|
|
|
|
last = next;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
first = next+1;
|
|
|
|
}
|
|
|
|
/* not found */
|
|
|
|
if (size == UINT_MAX)
|
|
|
|
return NULL;
|
|
|
|
/* insert to make it at "first" */
|
|
|
|
if (sha1_size_cache_alloc <= sha1_size_cache_nr) {
|
|
|
|
sha1_size_cache_alloc = alloc_nr(sha1_size_cache_alloc);
|
|
|
|
sha1_size_cache = xrealloc(sha1_size_cache,
|
|
|
|
sha1_size_cache_alloc *
|
|
|
|
sizeof(*sha1_size_cache));
|
|
|
|
}
|
|
|
|
sha1_size_cache_nr++;
|
|
|
|
if (first < sha1_size_cache_nr)
|
|
|
|
memmove(sha1_size_cache + first + 1, sha1_size_cache + first,
|
|
|
|
(sha1_size_cache_nr - first - 1) *
|
|
|
|
sizeof(*sha1_size_cache));
|
|
|
|
e = xmalloc(sizeof(struct sha1_size_cache));
|
|
|
|
sha1_size_cache[first] = e;
|
|
|
|
memcpy(e->sha1, sha1, 20);
|
|
|
|
e->size = size;
|
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
2005-05-21 09:39:09 +00: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.
|
|
|
|
*/
|
2005-05-27 22:56:38 +00:00
|
|
|
int diff_populate_filespec(struct diff_filespec *s, int size_only)
|
2005-05-21 09:39:09 +00:00
|
|
|
{
|
|
|
|
int err = 0;
|
2005-05-22 02:42:18 +00:00
|
|
|
if (!DIFF_FILE_VALID(s))
|
2005-05-21 09:39:09 +00:00
|
|
|
die("internal error: asking to populate invalid file.");
|
|
|
|
if (S_ISDIR(s->mode))
|
|
|
|
return -1;
|
|
|
|
|
2005-05-27 22:56:38 +00:00
|
|
|
if (!use_size_cache)
|
|
|
|
size_only = 0;
|
|
|
|
|
2005-05-21 09:39:09 +00:00
|
|
|
if (s->data)
|
|
|
|
return err;
|
|
|
|
if (!s->sha1_valid ||
|
|
|
|
work_tree_matches(s->path, s->sha1)) {
|
|
|
|
struct stat st;
|
|
|
|
int fd;
|
|
|
|
if (lstat(s->path, &st) < 0) {
|
|
|
|
if (errno == ENOENT) {
|
|
|
|
err_empty:
|
|
|
|
err = -1;
|
|
|
|
empty:
|
|
|
|
s->data = "";
|
|
|
|
s->size = 0;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
s->size = st.st_size;
|
|
|
|
if (!s->size)
|
|
|
|
goto empty;
|
2005-05-27 22:56:38 +00:00
|
|
|
if (size_only)
|
|
|
|
return 0;
|
2005-05-21 09:39:09 +00:00
|
|
|
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;
|
|
|
|
s->data = mmap(NULL, s->size, PROT_READ, MAP_PRIVATE, fd, 0);
|
|
|
|
s->should_munmap = 1;
|
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
else {
|
2005-05-27 22:56:38 +00:00
|
|
|
/* We cannot do size only for SHA1 blobs */
|
2005-05-21 09:39:09 +00:00
|
|
|
char type[20];
|
2005-05-27 22:56:38 +00:00
|
|
|
struct sha1_size_cache *e;
|
|
|
|
|
|
|
|
if (size_only) {
|
|
|
|
e = locate_size_cache(s->sha1, UINT_MAX);
|
|
|
|
if (e) {
|
|
|
|
s->size = e->size;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
2005-05-21 09:39:09 +00:00
|
|
|
s->data = read_sha1_file(s->sha1, type, &s->size);
|
|
|
|
s->should_free = 1;
|
2005-05-27 22:56:38 +00:00
|
|
|
if (s->data && size_only)
|
|
|
|
locate_size_cache(s->sha1, s->size);
|
2005-05-21 09:39:09 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void diff_free_filespec_data(struct diff_filespec *s)
|
|
|
|
{
|
|
|
|
if (s->should_free)
|
|
|
|
free(s->data);
|
|
|
|
else if (s->should_munmap)
|
|
|
|
munmap(s->data, s->size);
|
|
|
|
s->should_free = s->should_munmap = 0;
|
2005-05-22 21:33:43 +00:00
|
|
|
s->data = NULL;
|
2005-05-21 09:39:09 +00:00
|
|
|
}
|
|
|
|
|
2005-05-05 23:10:21 +00:00
|
|
|
static void prep_temp_blob(struct diff_tempfile *temp,
|
|
|
|
void *blob,
|
|
|
|
unsigned long size,
|
|
|
|
unsigned char *sha1,
|
|
|
|
int mode)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
strcpy(temp->tmp_path, ".diff_XXXXXX");
|
|
|
|
fd = mkstemp(temp->tmp_path);
|
|
|
|
if (fd < 0)
|
|
|
|
die("unable to create temp-file");
|
|
|
|
if (write(fd, blob, size) != size)
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2005-04-26 16:25:05 +00:00
|
|
|
static void prepare_temp_file(const char *name,
|
|
|
|
struct diff_tempfile *temp,
|
2005-05-21 09:39:09 +00:00
|
|
|
struct diff_filespec *one)
|
2005-04-26 01:22:47 +00:00
|
|
|
{
|
2005-05-22 02:42:18 +00:00
|
|
|
if (!DIFF_FILE_VALID(one)) {
|
2005-04-26 16:25:05 +00:00
|
|
|
not_a_valid_file:
|
2005-04-28 17:13:01 +00:00
|
|
|
/* A '-' entry produces this for file-2, and
|
|
|
|
* a '+' entry produces this for file-1.
|
|
|
|
*/
|
2005-04-26 16:25:05 +00:00
|
|
|
temp->name = "/dev/null";
|
|
|
|
strcpy(temp->hex, ".");
|
|
|
|
strcpy(temp->mode, ".");
|
2005-04-26 01:22:47 +00:00
|
|
|
return;
|
|
|
|
}
|
2005-04-26 16:25:05 +00:00
|
|
|
|
2005-05-19 10:32:35 +00:00
|
|
|
if (!one->sha1_valid ||
|
2005-05-21 09:39:09 +00:00
|
|
|
work_tree_matches(name, one->sha1)) {
|
2005-04-26 16:25:05 +00:00
|
|
|
struct stat st;
|
2005-05-21 09:39:09 +00:00
|
|
|
if (lstat(name, &st) < 0) {
|
2005-04-26 16:25:05 +00:00
|
|
|
if (errno == ENOENT)
|
|
|
|
goto not_a_valid_file;
|
2005-05-21 09:39:09 +00:00
|
|
|
die("stat(%s): %s", name, strerror(errno));
|
2005-04-26 16:25:05 +00:00
|
|
|
}
|
2005-05-05 23:10:21 +00:00
|
|
|
if (S_ISLNK(st.st_mode)) {
|
|
|
|
int ret;
|
|
|
|
char *buf, buf_[1024];
|
|
|
|
buf = ((sizeof(buf_) < st.st_size) ?
|
|
|
|
xmalloc(st.st_size) : buf_);
|
|
|
|
ret = readlink(name, buf, st.st_size);
|
|
|
|
if (ret < 0)
|
|
|
|
die("readlink(%s)", name);
|
|
|
|
prep_temp_blob(temp, buf, st.st_size,
|
|
|
|
(one->sha1_valid ?
|
2005-05-21 09:39:09 +00:00
|
|
|
one->sha1 : null_sha1),
|
2005-05-05 23:10:21 +00:00
|
|
|
(one->sha1_valid ?
|
|
|
|
one->mode : S_IFLNK));
|
|
|
|
}
|
|
|
|
else {
|
2005-05-21 09:39:09 +00:00
|
|
|
/* we can borrow from the file in the work tree */
|
|
|
|
temp->name = name;
|
2005-05-05 23:10:21 +00:00
|
|
|
if (!one->sha1_valid)
|
|
|
|
strcpy(temp->hex, sha1_to_hex(null_sha1));
|
|
|
|
else
|
2005-05-21 09:39:09 +00:00
|
|
|
strcpy(temp->hex, sha1_to_hex(one->sha1));
|
2005-05-30 07:07:39 +00:00
|
|
|
/* 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);
|
2005-05-05 23:10:21 +00:00
|
|
|
}
|
|
|
|
return;
|
2005-04-26 16:25:05 +00:00
|
|
|
}
|
|
|
|
else {
|
2005-05-27 22:56:38 +00:00
|
|
|
if (diff_populate_filespec(one, 0))
|
2005-05-21 09:39:09 +00:00
|
|
|
die("cannot read data blob for %s", one->path);
|
|
|
|
prep_temp_blob(temp, one->data, one->size,
|
|
|
|
one->sha1, one->mode);
|
2005-04-26 16:25:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-28 17:13:01 +00:00
|
|
|
static void remove_tempfile_on_signal(int signo)
|
|
|
|
{
|
|
|
|
remove_tempfile();
|
|
|
|
}
|
|
|
|
|
2005-04-26 16:25:05 +00:00
|
|
|
/* An external diff command takes:
|
|
|
|
*
|
|
|
|
* diff-cmd name infile1 infile1-sha1 infile1-mode \
|
2005-05-19 10:32:35 +00:00
|
|
|
* infile2 infile2-sha1 infile2-mode [ rename-to ]
|
2005-04-26 16:25:05 +00:00
|
|
|
*
|
|
|
|
*/
|
2005-05-26 09:24:30 +00:00
|
|
|
static void run_external_diff(const char *pgm,
|
|
|
|
const char *name,
|
2005-05-19 10:32:35 +00:00
|
|
|
const char *other,
|
2005-05-21 09:39:09 +00:00
|
|
|
struct diff_filespec *one,
|
|
|
|
struct diff_filespec *two,
|
|
|
|
const char *xfrm_msg)
|
2005-04-26 16:25:05 +00:00
|
|
|
{
|
|
|
|
struct diff_tempfile *temp = diff_temp;
|
2005-04-28 17:13:01 +00:00
|
|
|
pid_t pid;
|
|
|
|
int status;
|
2005-04-26 16:25:05 +00:00
|
|
|
static int atexit_asked = 0;
|
|
|
|
|
2005-04-27 16:21:00 +00:00
|
|
|
if (one && two) {
|
|
|
|
prepare_temp_file(name, &temp[0], one);
|
2005-05-18 06:29:49 +00:00
|
|
|
prepare_temp_file(other ? : name, &temp[1], two);
|
2005-04-27 16:21:00 +00:00
|
|
|
if (! atexit_asked &&
|
|
|
|
(temp[0].name == temp[0].tmp_path ||
|
|
|
|
temp[1].name == temp[1].tmp_path)) {
|
|
|
|
atexit_asked = 1;
|
|
|
|
atexit(remove_tempfile);
|
|
|
|
}
|
2005-04-28 17:13:01 +00:00
|
|
|
signal(SIGINT, remove_tempfile_on_signal);
|
2005-04-26 16:25:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fflush(NULL);
|
|
|
|
pid = fork();
|
|
|
|
if (pid < 0)
|
|
|
|
die("unable to fork");
|
|
|
|
if (!pid) {
|
2005-05-19 10:32:35 +00:00
|
|
|
if (pgm) {
|
|
|
|
if (one && two) {
|
2005-05-21 09:39:09 +00:00
|
|
|
const char *exec_arg[10];
|
2005-05-19 10:32:35 +00:00
|
|
|
const char **arg = &exec_arg[0];
|
|
|
|
*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;
|
2005-05-21 09:39:09 +00:00
|
|
|
if (other) {
|
2005-05-19 10:32:35 +00:00
|
|
|
*arg++ = other;
|
2005-05-21 09:39:09 +00:00
|
|
|
*arg++ = xfrm_msg;
|
|
|
|
}
|
2005-05-22 21:33:43 +00:00
|
|
|
*arg = NULL;
|
2005-05-19 10:32:35 +00:00
|
|
|
execvp(pgm, (char *const*) exec_arg);
|
|
|
|
}
|
2005-04-27 16:21:00 +00:00
|
|
|
else
|
|
|
|
execlp(pgm, pgm, name, NULL);
|
|
|
|
}
|
2005-04-26 16:25:05 +00:00
|
|
|
/*
|
|
|
|
* otherwise we use the built-in one.
|
|
|
|
*/
|
2005-04-27 16:21:00 +00:00
|
|
|
if (one && two)
|
2005-05-21 09:39:09 +00:00
|
|
|
builtin_diff(name, other ? : name, temp, xfrm_msg);
|
2005-04-27 16:21:00 +00:00
|
|
|
else
|
|
|
|
printf("* Unmerged path %s\n", name);
|
2005-04-26 16:25:05 +00:00
|
|
|
exit(0);
|
|
|
|
}
|
2005-05-04 08:38:06 +00:00
|
|
|
if (waitpid(pid, &status, 0) < 0 ||
|
|
|
|
!WIFEXITED(status) || WEXITSTATUS(status)) {
|
|
|
|
/* Earlier we did not check the exit status because
|
2005-04-28 17:13:01 +00:00
|
|
|
* diff exits non-zero if files are different, and
|
2005-05-04 08:38:06 +00:00
|
|
|
* we are not interested in knowing that. It was a
|
|
|
|
* mistake which made it harder to quit a diff-*
|
|
|
|
* session that uses the git-apply-patch-script as
|
|
|
|
* the GIT_EXTERNAL_DIFF. A custom GIT_EXTERNAL_DIFF
|
|
|
|
* should also exit non-zero only when it wants to
|
|
|
|
* abort the entire diff-* session.
|
2005-04-28 17:13:01 +00:00
|
|
|
*/
|
|
|
|
remove_tempfile();
|
2005-05-04 08:38:06 +00:00
|
|
|
fprintf(stderr, "external diff died, stopping at %s.\n", name);
|
|
|
|
exit(1);
|
2005-04-28 17:13:01 +00:00
|
|
|
}
|
2005-04-26 16:25:05 +00:00
|
|
|
remove_tempfile();
|
|
|
|
}
|
|
|
|
|
2005-05-26 09:24:30 +00:00
|
|
|
static void run_diff(const char *name,
|
|
|
|
const char *other,
|
|
|
|
struct diff_filespec *one,
|
|
|
|
struct diff_filespec *two,
|
|
|
|
const char *xfrm_msg)
|
|
|
|
{
|
|
|
|
const char *pgm = external_diff();
|
|
|
|
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);
|
|
|
|
run_external_diff(NULL, name, other, one, null, xfrm_msg);
|
|
|
|
free(null);
|
|
|
|
null = alloc_filespec(one->path);
|
|
|
|
run_external_diff(NULL, name, other, null, two, xfrm_msg);
|
|
|
|
free(null);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
run_external_diff(pgm, name, other, one, two, xfrm_msg);
|
|
|
|
}
|
|
|
|
|
2005-05-27 22:54:37 +00:00
|
|
|
void diff_setup(int flags)
|
2005-05-19 10:32:35 +00:00
|
|
|
{
|
2005-05-27 22:54:37 +00:00
|
|
|
if (flags & DIFF_SETUP_REVERSE)
|
|
|
|
reverse_diff = 1;
|
2005-05-27 22:56:38 +00:00
|
|
|
if (flags & 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 oufselves either.
|
|
|
|
*/
|
|
|
|
read_cache();
|
|
|
|
}
|
|
|
|
if (flags & DIFF_SETUP_USE_SIZE_CACHE)
|
|
|
|
use_size_cache = 1;
|
|
|
|
|
2005-05-19 10:32:35 +00:00
|
|
|
}
|
|
|
|
|
2005-05-22 17:04:37 +00:00
|
|
|
struct diff_queue_struct diff_queued_diff;
|
|
|
|
|
|
|
|
void diff_q(struct diff_queue_struct *queue, struct diff_filepair *dp)
|
2005-05-19 10:32:35 +00:00
|
|
|
{
|
2005-05-22 17:04:37 +00:00
|
|
|
if (queue->alloc <= queue->nr) {
|
|
|
|
queue->alloc = alloc_nr(queue->alloc);
|
|
|
|
queue->queue = xrealloc(queue->queue,
|
|
|
|
sizeof(dp) * queue->alloc);
|
2005-05-22 02:42:18 +00:00
|
|
|
}
|
2005-05-22 17:04:37 +00:00
|
|
|
queue->queue[queue->nr++] = dp;
|
2005-05-19 10:32:35 +00:00
|
|
|
}
|
|
|
|
|
2005-05-21 09:40:01 +00:00
|
|
|
struct diff_filepair *diff_queue(struct diff_queue_struct *queue,
|
2005-05-22 17:04:37 +00:00
|
|
|
struct diff_filespec *one,
|
|
|
|
struct diff_filespec *two)
|
2005-05-19 10:32:35 +00:00
|
|
|
{
|
2005-05-21 09:40:01 +00:00
|
|
|
struct diff_filepair *dp = xmalloc(sizeof(*dp));
|
2005-05-21 09:39:09 +00:00
|
|
|
dp->one = one;
|
|
|
|
dp->two = two;
|
[PATCH] Rename/copy detection fix.
The rename/copy detection logic in earlier round was only good
enough to show patch output and discussion on the mailing list
about the diff-raw format updates revealed many problems with
it. This patch fixes all the ones known to me, without making
things I want to do later impossible, mostly related to patch
reordering.
(1) Earlier rename/copy detector determined which one is rename
and which one is copy too early, which made it impossible
to later introduce diffcore transformers to reorder
patches. This patch fixes it by moving that logic to the
very end of the processing.
(2) Earlier output routine diff_flush() was pruning all the
"no-change" entries indiscriminatingly. This was done due
to my false assumption that one of the requirements in the
diff-raw output was not to show such an entry (which
resulted in my incorrect comment about "diff-helper never
being able to be equivalent to built-in diff driver"). My
special thanks go to Linus for correcting me about this.
When we produce diff-raw output, for the downstream to be
able to tell renames from copies, sometimes it _is_
necessary to output "no-change" entries, and this patch
adds diffcore_prune() function for doing it.
(3) Earlier diff_filepair structure was trying to be not too
specific about rename/copy operations, but the purpose of
the structure was to record one or two paths, which _was_
indeed about rename/copy. This patch discards xfrm_msg
field which was trying to be generic for this wrong reason,
and introduces a couple of fields (rename_score and
rename_rank) that are explicitly specific to rename/copy
logic. One thing to note is that the information in a
single diff_filepair structure _still_ does not distinguish
renames from copies, and it is deliberately so. This is to
allow patches to be reordered in later stages.
(4) This patch also adds some tests about diff-raw format
output and makes sure that necessary "no-change" entries
appear on the output.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-23 04:26:09 +00:00
|
|
|
dp->score = 0;
|
2005-05-27 22:55:55 +00:00
|
|
|
dp->source_stays = 0;
|
[PATCH] Add -B flag to diff-* brothers.
A new diffcore transformation, diffcore-break.c, is introduced.
When the -B flag is given, a patch that represents a complete
rewrite is broken into a deletion followed by a creation. This
makes it easier to review such a complete rewrite patch.
The -B flag takes the same syntax as the -M and -C flags to
specify the minimum amount of non-source material the resulting
file needs to have to be considered a complete rewrite, and
defaults to 99% if not specified.
As the new test t4008-diff-break-rewrite.sh demonstrates, if a
file is a complete rewrite, it is broken into a delete/create
pair, which can further be subjected to the usual rename
detection if -M or -C is used. For example, if file0 gets
completely rewritten to make it as if it were rather based on
file1 which itself disappeared, the following happens:
The original change looks like this:
file0 --> file0' (quite different from file0)
file1 --> /dev/null
After diffcore-break runs, it would become this:
file0 --> /dev/null
/dev/null --> file0'
file1 --> /dev/null
Then diffcore-rename matches them up:
file1 --> file0'
The internal score values are finer grained now. Earlier
maximum of 10000 has been raised to 60000; there is no user
visible changes but there is no reason to waste available bits.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-30 07:08:37 +00:00
|
|
|
dp->broken_pair = 0;
|
2005-05-22 17:04:37 +00:00
|
|
|
diff_q(queue, dp);
|
2005-05-21 09:39:09 +00:00
|
|
|
return dp;
|
2005-05-19 10:32:35 +00:00
|
|
|
}
|
|
|
|
|
2005-05-27 22:50:30 +00:00
|
|
|
void diff_free_filepair(struct diff_filepair *p)
|
|
|
|
{
|
|
|
|
diff_free_filespec_data(p->one);
|
|
|
|
diff_free_filespec_data(p->two);
|
|
|
|
free(p);
|
|
|
|
}
|
|
|
|
|
2005-05-24 01:14:03 +00:00
|
|
|
static void diff_flush_raw(struct diff_filepair *p,
|
|
|
|
int line_termination,
|
|
|
|
int inter_name_termination)
|
2005-05-19 10:32:35 +00:00
|
|
|
{
|
2005-05-23 21:55:33 +00:00
|
|
|
int two_paths;
|
|
|
|
char status[10];
|
2005-05-24 08:10:48 +00:00
|
|
|
|
|
|
|
if (line_termination) {
|
|
|
|
const char *err = "path %s cannot be expressed without -z";
|
|
|
|
if (strchr(p->one->path, line_termination) ||
|
|
|
|
strchr(p->one->path, inter_name_termination))
|
|
|
|
die(err, p->one->path);
|
|
|
|
if (strchr(p->two->path, line_termination) ||
|
|
|
|
strchr(p->two->path, inter_name_termination))
|
|
|
|
die(err, p->two->path);
|
|
|
|
}
|
|
|
|
|
2005-05-23 21:55:33 +00:00
|
|
|
switch (p->status) {
|
|
|
|
case 'C': case 'R':
|
|
|
|
two_paths = 1;
|
2005-05-25 23:00:04 +00:00
|
|
|
sprintf(status, "%c%03d", p->status,
|
|
|
|
(int)(0.5 + p->score * 100.0/MAX_SCORE));
|
2005-05-23 21:55:33 +00:00
|
|
|
break;
|
[PATCH] Add -B flag to diff-* brothers.
A new diffcore transformation, diffcore-break.c, is introduced.
When the -B flag is given, a patch that represents a complete
rewrite is broken into a deletion followed by a creation. This
makes it easier to review such a complete rewrite patch.
The -B flag takes the same syntax as the -M and -C flags to
specify the minimum amount of non-source material the resulting
file needs to have to be considered a complete rewrite, and
defaults to 99% if not specified.
As the new test t4008-diff-break-rewrite.sh demonstrates, if a
file is a complete rewrite, it is broken into a delete/create
pair, which can further be subjected to the usual rename
detection if -M or -C is used. For example, if file0 gets
completely rewritten to make it as if it were rather based on
file1 which itself disappeared, the following happens:
The original change looks like this:
file0 --> file0' (quite different from file0)
file1 --> /dev/null
After diffcore-break runs, it would become this:
file0 --> /dev/null
/dev/null --> file0'
file1 --> /dev/null
Then diffcore-rename matches them up:
file1 --> file0'
The internal score values are finer grained now. Earlier
maximum of 10000 has been raised to 60000; there is no user
visible changes but there is no reason to waste available bits.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-30 07:08:37 +00:00
|
|
|
case 'N': case 'D':
|
|
|
|
two_paths = 0;
|
|
|
|
if (p->score)
|
|
|
|
sprintf(status, "%c%03d", p->status,
|
|
|
|
(int)(0.5 + p->score * 100.0/MAX_SCORE));
|
|
|
|
else {
|
|
|
|
status[0] = p->status;
|
|
|
|
status[1] = 0;
|
|
|
|
}
|
|
|
|
break;
|
2005-05-23 21:55:33 +00:00
|
|
|
default:
|
|
|
|
two_paths = 0;
|
|
|
|
status[0] = p->status;
|
|
|
|
status[1] = 0;
|
|
|
|
break;
|
2005-05-22 17:04:37 +00:00
|
|
|
}
|
2005-05-22 02:42:18 +00:00
|
|
|
printf(":%06o %06o %s ",
|
|
|
|
p->one->mode, p->two->mode, sha1_to_hex(p->one->sha1));
|
2005-05-23 21:55:33 +00:00
|
|
|
printf("%s %s%c%s",
|
|
|
|
sha1_to_hex(p->two->sha1),
|
|
|
|
status,
|
|
|
|
inter_name_termination,
|
|
|
|
p->one->path);
|
|
|
|
if (two_paths)
|
|
|
|
printf("%c%s", inter_name_termination, p->two->path);
|
|
|
|
putchar(line_termination);
|
2005-05-19 10:32:35 +00:00
|
|
|
}
|
|
|
|
|
[PATCH] Rename/copy detection fix.
The rename/copy detection logic in earlier round was only good
enough to show patch output and discussion on the mailing list
about the diff-raw format updates revealed many problems with
it. This patch fixes all the ones known to me, without making
things I want to do later impossible, mostly related to patch
reordering.
(1) Earlier rename/copy detector determined which one is rename
and which one is copy too early, which made it impossible
to later introduce diffcore transformers to reorder
patches. This patch fixes it by moving that logic to the
very end of the processing.
(2) Earlier output routine diff_flush() was pruning all the
"no-change" entries indiscriminatingly. This was done due
to my false assumption that one of the requirements in the
diff-raw output was not to show such an entry (which
resulted in my incorrect comment about "diff-helper never
being able to be equivalent to built-in diff driver"). My
special thanks go to Linus for correcting me about this.
When we produce diff-raw output, for the downstream to be
able to tell renames from copies, sometimes it _is_
necessary to output "no-change" entries, and this patch
adds diffcore_prune() function for doing it.
(3) Earlier diff_filepair structure was trying to be not too
specific about rename/copy operations, but the purpose of
the structure was to record one or two paths, which _was_
indeed about rename/copy. This patch discards xfrm_msg
field which was trying to be generic for this wrong reason,
and introduces a couple of fields (rename_score and
rename_rank) that are explicitly specific to rename/copy
logic. One thing to note is that the information in a
single diff_filepair structure _still_ does not distinguish
renames from copies, and it is deliberately so. This is to
allow patches to be reordered in later stages.
(4) This patch also adds some tests about diff-raw format
output and makes sure that necessary "no-change" entries
appear on the output.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-23 04:26:09 +00:00
|
|
|
int diff_unmodified_pair(struct diff_filepair *p)
|
2005-05-19 10:32:35 +00:00
|
|
|
{
|
2005-05-21 09:39:09 +00:00
|
|
|
/* This function is written stricter than necessary to support
|
|
|
|
* the currently implemented transformers, but the idea is to
|
2005-05-21 09:40:01 +00:00
|
|
|
* let transformers to produce diff_filepairs any way they want,
|
2005-05-21 09:39:09 +00:00
|
|
|
* and filter and clean them up here before producing the output.
|
2005-05-19 10:32:35 +00:00
|
|
|
*/
|
2005-05-22 17:04:37 +00:00
|
|
|
struct diff_filespec *one, *two;
|
|
|
|
|
|
|
|
if (DIFF_PAIR_UNMERGED(p))
|
|
|
|
return 0; /* unmerged is interesting */
|
2005-05-19 10:32:35 +00:00
|
|
|
|
2005-05-22 17:04:37 +00:00
|
|
|
one = p->one;
|
|
|
|
two = p->two;
|
2005-05-19 10:32:35 +00:00
|
|
|
|
2005-05-26 09:24:30 +00:00
|
|
|
/* deletion, addition, mode or type change
|
|
|
|
* and rename are all interesting.
|
|
|
|
*/
|
2005-05-22 02:42:18 +00:00
|
|
|
if (DIFF_FILE_VALID(one) != DIFF_FILE_VALID(two) ||
|
2005-05-26 09:24:30 +00:00
|
|
|
DIFF_PAIR_MODE_CHANGED(p) ||
|
2005-05-21 09:39:09 +00:00
|
|
|
strcmp(one->path, two->path))
|
|
|
|
return 0;
|
2005-05-20 02:00:36 +00:00
|
|
|
|
2005-05-21 09:39:09 +00:00
|
|
|
/* both are valid and point at the same path. that is, we are
|
|
|
|
* dealing with a change.
|
2005-05-20 02:00:36 +00:00
|
|
|
*/
|
2005-05-21 09:39:09 +00:00
|
|
|
if (one->sha1_valid && two->sha1_valid &&
|
|
|
|
!memcmp(one->sha1, two->sha1, sizeof(one->sha1)))
|
|
|
|
return 1; /* no change */
|
|
|
|
if (!one->sha1_valid && !two->sha1_valid)
|
|
|
|
return 1; /* both look at the same file on the filesystem. */
|
|
|
|
return 0;
|
2005-05-20 02:00:36 +00:00
|
|
|
}
|
|
|
|
|
2005-05-23 21:55:33 +00:00
|
|
|
static void diff_flush_patch(struct diff_filepair *p)
|
[PATCH] Rename/copy detection fix.
The rename/copy detection logic in earlier round was only good
enough to show patch output and discussion on the mailing list
about the diff-raw format updates revealed many problems with
it. This patch fixes all the ones known to me, without making
things I want to do later impossible, mostly related to patch
reordering.
(1) Earlier rename/copy detector determined which one is rename
and which one is copy too early, which made it impossible
to later introduce diffcore transformers to reorder
patches. This patch fixes it by moving that logic to the
very end of the processing.
(2) Earlier output routine diff_flush() was pruning all the
"no-change" entries indiscriminatingly. This was done due
to my false assumption that one of the requirements in the
diff-raw output was not to show such an entry (which
resulted in my incorrect comment about "diff-helper never
being able to be equivalent to built-in diff driver"). My
special thanks go to Linus for correcting me about this.
When we produce diff-raw output, for the downstream to be
able to tell renames from copies, sometimes it _is_
necessary to output "no-change" entries, and this patch
adds diffcore_prune() function for doing it.
(3) Earlier diff_filepair structure was trying to be not too
specific about rename/copy operations, but the purpose of
the structure was to record one or two paths, which _was_
indeed about rename/copy. This patch discards xfrm_msg
field which was trying to be generic for this wrong reason,
and introduces a couple of fields (rename_score and
rename_rank) that are explicitly specific to rename/copy
logic. One thing to note is that the information in a
single diff_filepair structure _still_ does not distinguish
renames from copies, and it is deliberately so. This is to
allow patches to be reordered in later stages.
(4) This patch also adds some tests about diff-raw format
output and makes sure that necessary "no-change" entries
appear on the output.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-23 04:26:09 +00:00
|
|
|
{
|
|
|
|
const char *name, *other;
|
2005-05-23 21:55:33 +00:00
|
|
|
char msg_[PATH_MAX*2+200], *msg;
|
[PATCH] Rename/copy detection fix.
The rename/copy detection logic in earlier round was only good
enough to show patch output and discussion on the mailing list
about the diff-raw format updates revealed many problems with
it. This patch fixes all the ones known to me, without making
things I want to do later impossible, mostly related to patch
reordering.
(1) Earlier rename/copy detector determined which one is rename
and which one is copy too early, which made it impossible
to later introduce diffcore transformers to reorder
patches. This patch fixes it by moving that logic to the
very end of the processing.
(2) Earlier output routine diff_flush() was pruning all the
"no-change" entries indiscriminatingly. This was done due
to my false assumption that one of the requirements in the
diff-raw output was not to show such an entry (which
resulted in my incorrect comment about "diff-helper never
being able to be equivalent to built-in diff driver"). My
special thanks go to Linus for correcting me about this.
When we produce diff-raw output, for the downstream to be
able to tell renames from copies, sometimes it _is_
necessary to output "no-change" entries, and this patch
adds diffcore_prune() function for doing it.
(3) Earlier diff_filepair structure was trying to be not too
specific about rename/copy operations, but the purpose of
the structure was to record one or two paths, which _was_
indeed about rename/copy. This patch discards xfrm_msg
field which was trying to be generic for this wrong reason,
and introduces a couple of fields (rename_score and
rename_rank) that are explicitly specific to rename/copy
logic. One thing to note is that the information in a
single diff_filepair structure _still_ does not distinguish
renames from copies, and it is deliberately so. This is to
allow patches to be reordered in later stages.
(4) This patch also adds some tests about diff-raw format
output and makes sure that necessary "no-change" entries
appear on the output.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-23 04:26:09 +00:00
|
|
|
|
|
|
|
if (diff_unmodified_pair(p))
|
|
|
|
return;
|
|
|
|
|
|
|
|
name = p->one->path;
|
|
|
|
other = (strcmp(name, p->two->path) ? p->two->path : NULL);
|
|
|
|
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 */
|
|
|
|
|
2005-05-23 21:55:33 +00:00
|
|
|
switch (p->status) {
|
|
|
|
case 'C':
|
|
|
|
sprintf(msg_,
|
|
|
|
"similarity index %d%%\n"
|
|
|
|
"copy from %s\n"
|
2005-05-27 22:54:06 +00:00
|
|
|
"copy to %s",
|
2005-05-24 01:14:03 +00:00
|
|
|
(int)(0.5 + p->score * 100.0/MAX_SCORE),
|
2005-05-23 21:55:33 +00:00
|
|
|
p->one->path, p->two->path);
|
|
|
|
msg = msg_;
|
|
|
|
break;
|
|
|
|
case 'R':
|
|
|
|
sprintf(msg_,
|
|
|
|
"similarity index %d%%\n"
|
|
|
|
"rename old %s\n"
|
2005-05-27 22:54:06 +00:00
|
|
|
"rename new %s",
|
2005-05-24 01:14:03 +00:00
|
|
|
(int)(0.5 + p->score * 100.0/MAX_SCORE),
|
2005-05-23 21:55:33 +00:00
|
|
|
p->one->path, p->two->path);
|
|
|
|
msg = msg_;
|
|
|
|
break;
|
2005-05-30 23:40:16 +00:00
|
|
|
case 'D': case 'N':
|
|
|
|
if (DIFF_PAIR_BROKEN(p)) {
|
|
|
|
sprintf(msg_,
|
|
|
|
"dissimilarity index %d%%",
|
|
|
|
(int)(0.5 + p->score * 100.0/MAX_SCORE));
|
|
|
|
msg = msg_;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
msg = NULL;
|
|
|
|
break;
|
2005-05-23 21:55:33 +00:00
|
|
|
default:
|
|
|
|
msg = NULL;
|
|
|
|
}
|
|
|
|
|
[PATCH] Rename/copy detection fix.
The rename/copy detection logic in earlier round was only good
enough to show patch output and discussion on the mailing list
about the diff-raw format updates revealed many problems with
it. This patch fixes all the ones known to me, without making
things I want to do later impossible, mostly related to patch
reordering.
(1) Earlier rename/copy detector determined which one is rename
and which one is copy too early, which made it impossible
to later introduce diffcore transformers to reorder
patches. This patch fixes it by moving that logic to the
very end of the processing.
(2) Earlier output routine diff_flush() was pruning all the
"no-change" entries indiscriminatingly. This was done due
to my false assumption that one of the requirements in the
diff-raw output was not to show such an entry (which
resulted in my incorrect comment about "diff-helper never
being able to be equivalent to built-in diff driver"). My
special thanks go to Linus for correcting me about this.
When we produce diff-raw output, for the downstream to be
able to tell renames from copies, sometimes it _is_
necessary to output "no-change" entries, and this patch
adds diffcore_prune() function for doing it.
(3) Earlier diff_filepair structure was trying to be not too
specific about rename/copy operations, but the purpose of
the structure was to record one or two paths, which _was_
indeed about rename/copy. This patch discards xfrm_msg
field which was trying to be generic for this wrong reason,
and introduces a couple of fields (rename_score and
rename_rank) that are explicitly specific to rename/copy
logic. One thing to note is that the information in a
single diff_filepair structure _still_ does not distinguish
renames from copies, and it is deliberately so. This is to
allow patches to be reordered in later stages.
(4) This patch also adds some tests about diff-raw format
output and makes sure that necessary "no-change" entries
appear on the output.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-23 04:26:09 +00:00
|
|
|
if (DIFF_PAIR_UNMERGED(p))
|
2005-05-26 09:24:30 +00:00
|
|
|
run_diff(name, NULL, NULL, NULL, NULL);
|
[PATCH] Rename/copy detection fix.
The rename/copy detection logic in earlier round was only good
enough to show patch output and discussion on the mailing list
about the diff-raw format updates revealed many problems with
it. This patch fixes all the ones known to me, without making
things I want to do later impossible, mostly related to patch
reordering.
(1) Earlier rename/copy detector determined which one is rename
and which one is copy too early, which made it impossible
to later introduce diffcore transformers to reorder
patches. This patch fixes it by moving that logic to the
very end of the processing.
(2) Earlier output routine diff_flush() was pruning all the
"no-change" entries indiscriminatingly. This was done due
to my false assumption that one of the requirements in the
diff-raw output was not to show such an entry (which
resulted in my incorrect comment about "diff-helper never
being able to be equivalent to built-in diff driver"). My
special thanks go to Linus for correcting me about this.
When we produce diff-raw output, for the downstream to be
able to tell renames from copies, sometimes it _is_
necessary to output "no-change" entries, and this patch
adds diffcore_prune() function for doing it.
(3) Earlier diff_filepair structure was trying to be not too
specific about rename/copy operations, but the purpose of
the structure was to record one or two paths, which _was_
indeed about rename/copy. This patch discards xfrm_msg
field which was trying to be generic for this wrong reason,
and introduces a couple of fields (rename_score and
rename_rank) that are explicitly specific to rename/copy
logic. One thing to note is that the information in a
single diff_filepair structure _still_ does not distinguish
renames from copies, and it is deliberately so. This is to
allow patches to be reordered in later stages.
(4) This patch also adds some tests about diff-raw format
output and makes sure that necessary "no-change" entries
appear on the output.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-23 04:26:09 +00:00
|
|
|
else
|
2005-05-26 09:24:30 +00:00
|
|
|
run_diff(name, other, p->one, p->two, msg);
|
[PATCH] Rename/copy detection fix.
The rename/copy detection logic in earlier round was only good
enough to show patch output and discussion on the mailing list
about the diff-raw format updates revealed many problems with
it. This patch fixes all the ones known to me, without making
things I want to do later impossible, mostly related to patch
reordering.
(1) Earlier rename/copy detector determined which one is rename
and which one is copy too early, which made it impossible
to later introduce diffcore transformers to reorder
patches. This patch fixes it by moving that logic to the
very end of the processing.
(2) Earlier output routine diff_flush() was pruning all the
"no-change" entries indiscriminatingly. This was done due
to my false assumption that one of the requirements in the
diff-raw output was not to show such an entry (which
resulted in my incorrect comment about "diff-helper never
being able to be equivalent to built-in diff driver"). My
special thanks go to Linus for correcting me about this.
When we produce diff-raw output, for the downstream to be
able to tell renames from copies, sometimes it _is_
necessary to output "no-change" entries, and this patch
adds diffcore_prune() function for doing it.
(3) Earlier diff_filepair structure was trying to be not too
specific about rename/copy operations, but the purpose of
the structure was to record one or two paths, which _was_
indeed about rename/copy. This patch discards xfrm_msg
field which was trying to be generic for this wrong reason,
and introduces a couple of fields (rename_score and
rename_rank) that are explicitly specific to rename/copy
logic. One thing to note is that the information in a
single diff_filepair structure _still_ does not distinguish
renames from copies, and it is deliberately so. This is to
allow patches to be reordered in later stages.
(4) This patch also adds some tests about diff-raw format
output and makes sure that necessary "no-change" entries
appear on the output.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-23 04:26:09 +00:00
|
|
|
}
|
|
|
|
|
2005-05-24 01:14:03 +00:00
|
|
|
int diff_queue_is_empty(void)
|
[PATCH] Rename/copy detection fix.
The rename/copy detection logic in earlier round was only good
enough to show patch output and discussion on the mailing list
about the diff-raw format updates revealed many problems with
it. This patch fixes all the ones known to me, without making
things I want to do later impossible, mostly related to patch
reordering.
(1) Earlier rename/copy detector determined which one is rename
and which one is copy too early, which made it impossible
to later introduce diffcore transformers to reorder
patches. This patch fixes it by moving that logic to the
very end of the processing.
(2) Earlier output routine diff_flush() was pruning all the
"no-change" entries indiscriminatingly. This was done due
to my false assumption that one of the requirements in the
diff-raw output was not to show such an entry (which
resulted in my incorrect comment about "diff-helper never
being able to be equivalent to built-in diff driver"). My
special thanks go to Linus for correcting me about this.
When we produce diff-raw output, for the downstream to be
able to tell renames from copies, sometimes it _is_
necessary to output "no-change" entries, and this patch
adds diffcore_prune() function for doing it.
(3) Earlier diff_filepair structure was trying to be not too
specific about rename/copy operations, but the purpose of
the structure was to record one or two paths, which _was_
indeed about rename/copy. This patch discards xfrm_msg
field which was trying to be generic for this wrong reason,
and introduces a couple of fields (rename_score and
rename_rank) that are explicitly specific to rename/copy
logic. One thing to note is that the information in a
single diff_filepair structure _still_ does not distinguish
renames from copies, and it is deliberately so. This is to
allow patches to be reordered in later stages.
(4) This patch also adds some tests about diff-raw format
output and makes sure that necessary "no-change" entries
appear on the output.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-23 04:26:09 +00:00
|
|
|
{
|
2005-05-24 01:14:03 +00:00
|
|
|
struct diff_queue_struct *q = &diff_queued_diff;
|
2005-05-24 08:10:48 +00:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < q->nr; i++)
|
|
|
|
if (!diff_unmodified_pair(q->queue[i]))
|
|
|
|
return 0;
|
|
|
|
return 1;
|
[PATCH] Rename/copy detection fix.
The rename/copy detection logic in earlier round was only good
enough to show patch output and discussion on the mailing list
about the diff-raw format updates revealed many problems with
it. This patch fixes all the ones known to me, without making
things I want to do later impossible, mostly related to patch
reordering.
(1) Earlier rename/copy detector determined which one is rename
and which one is copy too early, which made it impossible
to later introduce diffcore transformers to reorder
patches. This patch fixes it by moving that logic to the
very end of the processing.
(2) Earlier output routine diff_flush() was pruning all the
"no-change" entries indiscriminatingly. This was done due
to my false assumption that one of the requirements in the
diff-raw output was not to show such an entry (which
resulted in my incorrect comment about "diff-helper never
being able to be equivalent to built-in diff driver"). My
special thanks go to Linus for correcting me about this.
When we produce diff-raw output, for the downstream to be
able to tell renames from copies, sometimes it _is_
necessary to output "no-change" entries, and this patch
adds diffcore_prune() function for doing it.
(3) Earlier diff_filepair structure was trying to be not too
specific about rename/copy operations, but the purpose of
the structure was to record one or two paths, which _was_
indeed about rename/copy. This patch discards xfrm_msg
field which was trying to be generic for this wrong reason,
and introduces a couple of fields (rename_score and
rename_rank) that are explicitly specific to rename/copy
logic. One thing to note is that the information in a
single diff_filepair structure _still_ does not distinguish
renames from copies, and it is deliberately so. This is to
allow patches to be reordered in later stages.
(4) This patch also adds some tests about diff-raw format
output and makes sure that necessary "no-change" entries
appear on the output.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-23 04:26:09 +00:00
|
|
|
}
|
|
|
|
|
2005-05-24 08:10:48 +00:00
|
|
|
#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 ? : "",
|
|
|
|
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 ? : "",
|
|
|
|
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");
|
[PATCH] Add -B flag to diff-* brothers.
A new diffcore transformation, diffcore-break.c, is introduced.
When the -B flag is given, a patch that represents a complete
rewrite is broken into a deletion followed by a creation. This
makes it easier to review such a complete rewrite patch.
The -B flag takes the same syntax as the -M and -C flags to
specify the minimum amount of non-source material the resulting
file needs to have to be considered a complete rewrite, and
defaults to 99% if not specified.
As the new test t4008-diff-break-rewrite.sh demonstrates, if a
file is a complete rewrite, it is broken into a delete/create
pair, which can further be subjected to the usual rename
detection if -M or -C is used. For example, if file0 gets
completely rewritten to make it as if it were rather based on
file1 which itself disappeared, the following happens:
The original change looks like this:
file0 --> file0' (quite different from file0)
file1 --> /dev/null
After diffcore-break runs, it would become this:
file0 --> /dev/null
/dev/null --> file0'
file1 --> /dev/null
Then diffcore-rename matches them up:
file1 --> file0'
The internal score values are finer grained now. Earlier
maximum of 10000 has been raised to 60000; there is no user
visible changes but there is no reason to waste available bits.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-30 07:08:37 +00:00
|
|
|
fprintf(stderr, "score %d, status %c stays %d broken %d\n",
|
|
|
|
p->score, p->status ? : '?',
|
|
|
|
p->source_stays, p->broken_pair);
|
2005-05-24 08:10:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void diff_debug_queue(const char *msg, struct diff_queue_struct *q)
|
2005-05-22 17:04:37 +00:00
|
|
|
{
|
|
|
|
int i;
|
2005-05-24 08:10:48 +00:00
|
|
|
if (msg)
|
|
|
|
fprintf(stderr, "%s\n", msg);
|
|
|
|
fprintf(stderr, "q->nr = %d\n", q->nr);
|
2005-05-22 17:04:37 +00:00
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
struct diff_filepair *p = q->queue[i];
|
2005-05-24 08:10:48 +00:00
|
|
|
diff_debug_filepair(p, i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static void diff_resolve_rename_copy(void)
|
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
struct diff_filepair *p, *pp;
|
|
|
|
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];
|
2005-05-25 22:07:08 +00:00
|
|
|
p->status = 0; /* undecided */
|
2005-05-24 01:14:03 +00:00
|
|
|
if (DIFF_PAIR_UNMERGED(p))
|
|
|
|
p->status = 'U';
|
2005-05-27 22:55:55 +00:00
|
|
|
else if (!DIFF_FILE_VALID(p->one))
|
2005-05-24 01:14:03 +00:00
|
|
|
p->status = 'N';
|
2005-05-30 07:08:07 +00:00
|
|
|
else if (!DIFF_FILE_VALID(p->two))
|
|
|
|
p->status = 'D';
|
2005-05-25 22:07:08 +00:00
|
|
|
else if (DIFF_PAIR_TYPE_CHANGED(p))
|
|
|
|
p->status = 'T';
|
|
|
|
|
|
|
|
/* 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.
|
|
|
|
*/
|
2005-05-29 23:56:48 +00:00
|
|
|
else if (DIFF_PAIR_RENAME(p)) {
|
2005-05-27 22:55:55 +00:00
|
|
|
if (p->source_stays) {
|
|
|
|
p->status = 'C';
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/* See if there is some other filepair that
|
|
|
|
* copies from the same source as us. If so
|
|
|
|
* we are a copy. Otherwise we are a rename.
|
2005-05-24 08:10:48 +00:00
|
|
|
*/
|
2005-05-27 22:55:55 +00:00
|
|
|
for (j = i + 1; j < q->nr; j++) {
|
2005-05-24 08:10:48 +00:00
|
|
|
pp = q->queue[j];
|
|
|
|
if (strcmp(pp->one->path, p->one->path))
|
2005-05-27 22:55:55 +00:00
|
|
|
continue; /* not us */
|
2005-05-29 23:56:48 +00:00
|
|
|
if (!DIFF_PAIR_RENAME(pp))
|
2005-05-27 22:55:55 +00:00
|
|
|
continue; /* not a rename/copy */
|
|
|
|
/* pp is a rename/copy from the same source */
|
|
|
|
p->status = 'C';
|
|
|
|
break;
|
2005-05-24 08:10:48 +00:00
|
|
|
}
|
|
|
|
if (!p->status)
|
2005-05-24 01:14:03 +00:00
|
|
|
p->status = 'R';
|
|
|
|
}
|
2005-05-25 23:00:04 +00:00
|
|
|
else if (memcmp(p->one->sha1, p->two->sha1, 20) ||
|
|
|
|
p->one->mode != p->two->mode)
|
2005-05-24 01:14:03 +00:00
|
|
|
p->status = 'M';
|
2005-06-01 18:38:07 +00:00
|
|
|
else {
|
|
|
|
/* This is a "no-change" entry and should not
|
|
|
|
* happen anymore, but prepare for broken callers.
|
2005-05-27 22:55:55 +00:00
|
|
|
*/
|
2005-06-01 18:38:07 +00:00
|
|
|
error("feeding unmodified %s to diffcore",
|
|
|
|
p->one->path);
|
|
|
|
p->status = 'X';
|
|
|
|
}
|
2005-05-22 17:04:37 +00:00
|
|
|
}
|
2005-05-24 08:10:48 +00:00
|
|
|
diff_debug_queue("resolve-rename-copy done", q);
|
2005-05-22 02:40:36 +00:00
|
|
|
}
|
|
|
|
|
2005-05-23 21:55:33 +00:00
|
|
|
void diff_flush(int diff_output_style, int resolve_rename_copy)
|
2005-05-22 02:40:36 +00:00
|
|
|
{
|
|
|
|
struct diff_queue_struct *q = &diff_queued_diff;
|
|
|
|
int i;
|
2005-05-24 01:14:03 +00:00
|
|
|
int line_termination = '\n';
|
|
|
|
int inter_name_termination = '\t';
|
2005-05-22 02:40:36 +00:00
|
|
|
|
2005-05-24 01:14:03 +00:00
|
|
|
if (diff_output_style == DIFF_FORMAT_MACHINE)
|
2005-05-22 17:04:37 +00:00
|
|
|
line_termination = inter_name_termination = 0;
|
2005-05-24 01:14:03 +00:00
|
|
|
if (resolve_rename_copy)
|
|
|
|
diff_resolve_rename_copy();
|
|
|
|
|
[PATCH] Rename/copy detection fix.
The rename/copy detection logic in earlier round was only good
enough to show patch output and discussion on the mailing list
about the diff-raw format updates revealed many problems with
it. This patch fixes all the ones known to me, without making
things I want to do later impossible, mostly related to patch
reordering.
(1) Earlier rename/copy detector determined which one is rename
and which one is copy too early, which made it impossible
to later introduce diffcore transformers to reorder
patches. This patch fixes it by moving that logic to the
very end of the processing.
(2) Earlier output routine diff_flush() was pruning all the
"no-change" entries indiscriminatingly. This was done due
to my false assumption that one of the requirements in the
diff-raw output was not to show such an entry (which
resulted in my incorrect comment about "diff-helper never
being able to be equivalent to built-in diff driver"). My
special thanks go to Linus for correcting me about this.
When we produce diff-raw output, for the downstream to be
able to tell renames from copies, sometimes it _is_
necessary to output "no-change" entries, and this patch
adds diffcore_prune() function for doing it.
(3) Earlier diff_filepair structure was trying to be not too
specific about rename/copy operations, but the purpose of
the structure was to record one or two paths, which _was_
indeed about rename/copy. This patch discards xfrm_msg
field which was trying to be generic for this wrong reason,
and introduces a couple of fields (rename_score and
rename_rank) that are explicitly specific to rename/copy
logic. One thing to note is that the information in a
single diff_filepair structure _still_ does not distinguish
renames from copies, and it is deliberately so. This is to
allow patches to be reordered in later stages.
(4) This patch also adds some tests about diff-raw format
output and makes sure that necessary "no-change" entries
appear on the output.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-23 04:26:09 +00:00
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
struct diff_filepair *p = q->queue[i];
|
2005-05-26 09:24:30 +00:00
|
|
|
if ((diff_output_style == DIFF_FORMAT_NO_OUTPUT) ||
|
|
|
|
(p->status == 'X'))
|
2005-05-25 22:07:08 +00:00
|
|
|
continue;
|
2005-05-24 01:14:03 +00:00
|
|
|
if (p->status == 0)
|
2005-05-25 22:07:08 +00:00
|
|
|
die("internal error in diff-resolve-rename-copy");
|
2005-05-24 01:14:03 +00:00
|
|
|
switch (diff_output_style) {
|
|
|
|
case DIFF_FORMAT_PATCH:
|
2005-05-23 21:55:33 +00:00
|
|
|
diff_flush_patch(p);
|
2005-05-24 01:14:03 +00:00
|
|
|
break;
|
|
|
|
case DIFF_FORMAT_HUMAN:
|
|
|
|
case DIFF_FORMAT_MACHINE:
|
|
|
|
diff_flush_raw(p, line_termination,
|
|
|
|
inter_name_termination);
|
|
|
|
break;
|
|
|
|
}
|
[PATCH] Rename/copy detection fix.
The rename/copy detection logic in earlier round was only good
enough to show patch output and discussion on the mailing list
about the diff-raw format updates revealed many problems with
it. This patch fixes all the ones known to me, without making
things I want to do later impossible, mostly related to patch
reordering.
(1) Earlier rename/copy detector determined which one is rename
and which one is copy too early, which made it impossible
to later introduce diffcore transformers to reorder
patches. This patch fixes it by moving that logic to the
very end of the processing.
(2) Earlier output routine diff_flush() was pruning all the
"no-change" entries indiscriminatingly. This was done due
to my false assumption that one of the requirements in the
diff-raw output was not to show such an entry (which
resulted in my incorrect comment about "diff-helper never
being able to be equivalent to built-in diff driver"). My
special thanks go to Linus for correcting me about this.
When we produce diff-raw output, for the downstream to be
able to tell renames from copies, sometimes it _is_
necessary to output "no-change" entries, and this patch
adds diffcore_prune() function for doing it.
(3) Earlier diff_filepair structure was trying to be not too
specific about rename/copy operations, but the purpose of
the structure was to record one or two paths, which _was_
indeed about rename/copy. This patch discards xfrm_msg
field which was trying to be generic for this wrong reason,
and introduces a couple of fields (rename_score and
rename_rank) that are explicitly specific to rename/copy
logic. One thing to note is that the information in a
single diff_filepair structure _still_ does not distinguish
renames from copies, and it is deliberately so. This is to
allow patches to be reordered in later stages.
(4) This patch also adds some tests about diff-raw format
output and makes sure that necessary "no-change" entries
appear on the output.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-23 04:26:09 +00:00
|
|
|
}
|
2005-05-27 22:50:30 +00:00
|
|
|
for (i = 0; i < q->nr; i++)
|
|
|
|
diff_free_filepair(q->queue[i]);
|
2005-05-21 09:39:09 +00:00
|
|
|
free(q->queue);
|
|
|
|
q->queue = NULL;
|
|
|
|
q->nr = q->alloc = 0;
|
2005-05-19 10:32:35 +00:00
|
|
|
}
|
|
|
|
|
2005-05-29 23:56:13 +00:00
|
|
|
void diffcore_std(const char **paths,
|
|
|
|
int detect_rename, int rename_score,
|
[PATCH] Add -B flag to diff-* brothers.
A new diffcore transformation, diffcore-break.c, is introduced.
When the -B flag is given, a patch that represents a complete
rewrite is broken into a deletion followed by a creation. This
makes it easier to review such a complete rewrite patch.
The -B flag takes the same syntax as the -M and -C flags to
specify the minimum amount of non-source material the resulting
file needs to have to be considered a complete rewrite, and
defaults to 99% if not specified.
As the new test t4008-diff-break-rewrite.sh demonstrates, if a
file is a complete rewrite, it is broken into a delete/create
pair, which can further be subjected to the usual rename
detection if -M or -C is used. For example, if file0 gets
completely rewritten to make it as if it were rather based on
file1 which itself disappeared, the following happens:
The original change looks like this:
file0 --> file0' (quite different from file0)
file1 --> /dev/null
After diffcore-break runs, it would become this:
file0 --> /dev/null
/dev/null --> file0'
file1 --> /dev/null
Then diffcore-rename matches them up:
file1 --> file0'
The internal score values are finer grained now. Earlier
maximum of 10000 has been raised to 60000; there is no user
visible changes but there is no reason to waste available bits.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-30 07:08:37 +00:00
|
|
|
const char *pickaxe, int pickaxe_opts,
|
2005-05-30 07:09:07 +00:00
|
|
|
int break_opt,
|
|
|
|
const char *orderfile)
|
2005-05-29 23:56:13 +00:00
|
|
|
{
|
|
|
|
if (paths && paths[0])
|
|
|
|
diffcore_pathspec(paths);
|
[PATCH] Add -B flag to diff-* brothers.
A new diffcore transformation, diffcore-break.c, is introduced.
When the -B flag is given, a patch that represents a complete
rewrite is broken into a deletion followed by a creation. This
makes it easier to review such a complete rewrite patch.
The -B flag takes the same syntax as the -M and -C flags to
specify the minimum amount of non-source material the resulting
file needs to have to be considered a complete rewrite, and
defaults to 99% if not specified.
As the new test t4008-diff-break-rewrite.sh demonstrates, if a
file is a complete rewrite, it is broken into a delete/create
pair, which can further be subjected to the usual rename
detection if -M or -C is used. For example, if file0 gets
completely rewritten to make it as if it were rather based on
file1 which itself disappeared, the following happens:
The original change looks like this:
file0 --> file0' (quite different from file0)
file1 --> /dev/null
After diffcore-break runs, it would become this:
file0 --> /dev/null
/dev/null --> file0'
file1 --> /dev/null
Then diffcore-rename matches them up:
file1 --> file0'
The internal score values are finer grained now. Earlier
maximum of 10000 has been raised to 60000; there is no user
visible changes but there is no reason to waste available bits.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-30 07:08:37 +00:00
|
|
|
if (0 <= break_opt)
|
|
|
|
diffcore_break(break_opt);
|
2005-05-29 23:56:13 +00:00
|
|
|
if (detect_rename)
|
|
|
|
diffcore_rename(detect_rename, rename_score);
|
|
|
|
if (pickaxe)
|
|
|
|
diffcore_pickaxe(pickaxe, pickaxe_opts);
|
2005-05-30 07:09:07 +00:00
|
|
|
if (orderfile)
|
|
|
|
diffcore_order(orderfile);
|
2005-05-29 23:56:13 +00:00
|
|
|
}
|
|
|
|
|
2005-04-27 16:21:00 +00:00
|
|
|
void diff_addremove(int addremove, unsigned mode,
|
|
|
|
const unsigned char *sha1,
|
|
|
|
const char *base, const char *path)
|
2005-04-26 16:25:05 +00:00
|
|
|
{
|
2005-04-27 16:21:00 +00:00
|
|
|
char concatpath[PATH_MAX];
|
2005-05-21 09:39:09 +00:00
|
|
|
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).
|
[PATCH] Rename/copy detection fix.
The rename/copy detection logic in earlier round was only good
enough to show patch output and discussion on the mailing list
about the diff-raw format updates revealed many problems with
it. This patch fixes all the ones known to me, without making
things I want to do later impossible, mostly related to patch
reordering.
(1) Earlier rename/copy detector determined which one is rename
and which one is copy too early, which made it impossible
to later introduce diffcore transformers to reorder
patches. This patch fixes it by moving that logic to the
very end of the processing.
(2) Earlier output routine diff_flush() was pruning all the
"no-change" entries indiscriminatingly. This was done due
to my false assumption that one of the requirements in the
diff-raw output was not to show such an entry (which
resulted in my incorrect comment about "diff-helper never
being able to be equivalent to built-in diff driver"). My
special thanks go to Linus for correcting me about this.
When we produce diff-raw output, for the downstream to be
able to tell renames from copies, sometimes it _is_
necessary to output "no-change" entries, and this patch
adds diffcore_prune() function for doing it.
(3) Earlier diff_filepair structure was trying to be not too
specific about rename/copy operations, but the purpose of
the structure was to record one or two paths, which _was_
indeed about rename/copy. This patch discards xfrm_msg
field which was trying to be generic for this wrong reason,
and introduces a couple of fields (rename_score and
rename_rank) that are explicitly specific to rename/copy
logic. One thing to note is that the information in a
single diff_filepair structure _still_ does not distinguish
renames from copies, and it is deliberately so. This is to
allow patches to be reordered in later stages.
(4) This patch also adds some tests about diff-raw format
output and makes sure that necessary "no-change" entries
appear on the output.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-23 04:26:09 +00:00
|
|
|
* Feeding the same new and old to diff_change()
|
2005-05-24 01:14:03 +00:00
|
|
|
* also has the same effect.
|
|
|
|
* Before the final output happens, they are pruned after
|
|
|
|
* merged into rename/copy pairs as appropriate.
|
2005-05-21 09:39:09 +00:00
|
|
|
*/
|
2005-05-20 16:54:07 +00:00
|
|
|
if (reverse_diff)
|
2005-05-21 09:39:09 +00:00
|
|
|
addremove = (addremove == '+' ? '-' :
|
|
|
|
addremove == '-' ? '+' : addremove);
|
2005-05-20 16:54:07 +00:00
|
|
|
|
2005-05-21 09:39:09 +00:00
|
|
|
if (!path) path = "";
|
|
|
|
sprintf(concatpath, "%s%s", base, path);
|
|
|
|
one = alloc_filespec(concatpath);
|
|
|
|
two = alloc_filespec(concatpath);
|
2005-04-26 16:25:05 +00:00
|
|
|
|
2005-05-21 09:39:09 +00:00
|
|
|
if (addremove != '+')
|
|
|
|
fill_filespec(one, sha1, mode);
|
|
|
|
if (addremove != '-')
|
|
|
|
fill_filespec(two, sha1, mode);
|
2005-05-19 10:32:35 +00:00
|
|
|
|
2005-05-22 02:40:36 +00:00
|
|
|
diff_queue(&diff_queued_diff, one, two);
|
2005-04-26 16:25:05 +00:00
|
|
|
}
|
|
|
|
|
2005-05-23 21:55:33 +00:00
|
|
|
void diff_helper_input(unsigned old_mode,
|
|
|
|
unsigned new_mode,
|
|
|
|
const unsigned char *old_sha1,
|
|
|
|
const unsigned char *new_sha1,
|
|
|
|
const char *old_path,
|
|
|
|
int status,
|
|
|
|
int score,
|
|
|
|
const char *new_path)
|
2005-05-22 02:42:18 +00:00
|
|
|
{
|
|
|
|
struct diff_filespec *one, *two;
|
2005-05-23 21:55:33 +00:00
|
|
|
struct diff_filepair *dp;
|
2005-05-22 02:42:18 +00:00
|
|
|
|
|
|
|
one = alloc_filespec(old_path);
|
|
|
|
two = alloc_filespec(new_path);
|
|
|
|
if (old_mode)
|
|
|
|
fill_filespec(one, old_sha1, old_mode);
|
|
|
|
if (new_mode)
|
|
|
|
fill_filespec(two, new_sha1, new_mode);
|
2005-05-23 21:55:33 +00:00
|
|
|
dp = diff_queue(&diff_queued_diff, one, two);
|
2005-05-27 22:53:31 +00:00
|
|
|
dp->score = score * MAX_SCORE / 100;
|
2005-05-23 21:55:33 +00:00
|
|
|
dp->status = status;
|
2005-05-22 02:42:18 +00:00
|
|
|
}
|
|
|
|
|
2005-04-27 16:21:00 +00:00
|
|
|
void diff_change(unsigned old_mode, unsigned new_mode,
|
|
|
|
const unsigned char *old_sha1,
|
|
|
|
const unsigned char *new_sha1,
|
2005-05-22 02:42:18 +00:00
|
|
|
const char *base, const char *path)
|
|
|
|
{
|
2005-04-27 16:21:00 +00:00
|
|
|
char concatpath[PATH_MAX];
|
2005-05-21 09:39:09 +00:00
|
|
|
struct diff_filespec *one, *two;
|
2005-04-27 16:21:00 +00:00
|
|
|
|
2005-05-20 16:54:07 +00:00
|
|
|
if (reverse_diff) {
|
|
|
|
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;
|
|
|
|
}
|
2005-05-21 09:39:09 +00:00
|
|
|
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);
|
|
|
|
|
2005-05-22 02:40:36 +00:00
|
|
|
diff_queue(&diff_queued_diff, one, two);
|
2005-04-27 16:21:00 +00:00
|
|
|
}
|
2005-04-26 16:25:05 +00:00
|
|
|
|
2005-04-27 16:21:00 +00:00
|
|
|
void diff_unmerge(const char *path)
|
|
|
|
{
|
2005-05-22 17:04:37 +00:00
|
|
|
struct diff_filespec *one, *two;
|
|
|
|
one = alloc_filespec(path);
|
|
|
|
two = alloc_filespec(path);
|
|
|
|
diff_queue(&diff_queued_diff, one, two);
|
2005-04-26 01:22:47 +00:00
|
|
|
}
|