2008-05-24 05:28:56 +00:00
|
|
|
/*
|
|
|
|
* "diff --no-index" support
|
|
|
|
* Copyright (c) 2007 by Johannes Schindelin
|
|
|
|
* Copyright (c) 2008 by Junio C Hamano
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "cache.h"
|
|
|
|
#include "color.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "blob.h"
|
|
|
|
#include "tag.h"
|
|
|
|
#include "diff.h"
|
|
|
|
#include "diffcore.h"
|
|
|
|
#include "revision.h"
|
|
|
|
#include "log-tree.h"
|
|
|
|
#include "builtin.h"
|
2008-07-21 18:03:49 +00:00
|
|
|
#include "string-list.h"
|
2014-03-19 15:58:22 +00:00
|
|
|
#include "dir.h"
|
2008-05-24 05:28:56 +00:00
|
|
|
|
2014-03-19 15:58:21 +00:00
|
|
|
static int read_directory_contents(const char *path, struct string_list *list)
|
2008-05-24 05:28:56 +00:00
|
|
|
{
|
|
|
|
DIR *dir;
|
|
|
|
struct dirent *e;
|
|
|
|
|
|
|
|
if (!(dir = opendir(path)))
|
|
|
|
return error("Could not open directory %s", path);
|
|
|
|
|
|
|
|
while ((e = readdir(dir)))
|
2014-03-19 15:58:22 +00:00
|
|
|
if (!is_dot_or_dotdot(e->d_name))
|
2010-06-25 23:41:35 +00:00
|
|
|
string_list_insert(list, e->d_name);
|
2008-05-24 05:28:56 +00:00
|
|
|
|
|
|
|
closedir(dir);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-28 03:14:47 +00:00
|
|
|
/*
|
|
|
|
* This should be "(standard input)" or something, but it will
|
|
|
|
* probably expose many more breakages in the way no-index code
|
|
|
|
* is bolted onto the diff callchain.
|
|
|
|
*/
|
|
|
|
static const char file_from_standard_input[] = "-";
|
|
|
|
|
2008-05-24 05:28:56 +00:00
|
|
|
static int get_mode(const char *path, int *mode)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (!path || !strcmp(path, "/dev/null"))
|
|
|
|
*mode = 0;
|
2013-05-02 19:26:08 +00:00
|
|
|
#ifdef GIT_WINDOWS_NATIVE
|
2009-03-07 15:51:33 +00:00
|
|
|
else if (!strcasecmp(path, "nul"))
|
|
|
|
*mode = 0;
|
|
|
|
#endif
|
2012-06-28 03:14:47 +00:00
|
|
|
else if (path == file_from_standard_input)
|
2008-05-24 05:28:56 +00:00
|
|
|
*mode = create_ce_mode(0666);
|
2009-01-29 16:30:51 +00:00
|
|
|
else if (lstat(path, &st))
|
2008-05-24 05:28:56 +00:00
|
|
|
return error("Could not access '%s'", path);
|
|
|
|
else
|
|
|
|
*mode = st.st_mode;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-28 03:14:47 +00:00
|
|
|
static int populate_from_stdin(struct diff_filespec *s)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
size_t size = 0;
|
|
|
|
|
|
|
|
if (strbuf_read(&buf, 0, 0) < 0)
|
|
|
|
return error("error while reading from stdin %s",
|
|
|
|
strerror(errno));
|
|
|
|
|
|
|
|
s->should_munmap = 0;
|
|
|
|
s->data = strbuf_detach(&buf, &size);
|
|
|
|
s->size = size;
|
|
|
|
s->should_free = 1;
|
|
|
|
s->is_stdin = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct diff_filespec *noindex_filespec(const char *name, int mode)
|
|
|
|
{
|
|
|
|
struct diff_filespec *s;
|
|
|
|
|
|
|
|
if (!name)
|
|
|
|
name = "/dev/null";
|
|
|
|
s = alloc_filespec(name);
|
2012-08-27 18:54:28 +00:00
|
|
|
fill_filespec(s, null_sha1, 0, mode);
|
2012-06-28 03:14:47 +00:00
|
|
|
if (name == file_from_standard_input)
|
|
|
|
populate_from_stdin(s);
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2008-05-24 05:28:56 +00:00
|
|
|
static int queue_diff(struct diff_options *o,
|
2012-04-25 19:37:38 +00:00
|
|
|
const char *name1, const char *name2)
|
2008-05-24 05:28:56 +00:00
|
|
|
{
|
|
|
|
int mode1 = 0, mode2 = 0;
|
|
|
|
|
|
|
|
if (get_mode(name1, &mode1) || get_mode(name2, &mode2))
|
|
|
|
return -1;
|
|
|
|
|
2015-03-22 05:11:27 +00:00
|
|
|
if (mode1 && mode2 && S_ISDIR(mode1) != S_ISDIR(mode2)) {
|
|
|
|
struct diff_filespec *d1, *d2;
|
|
|
|
|
|
|
|
if (S_ISDIR(mode1)) {
|
|
|
|
/* 2 is file that is created */
|
|
|
|
d1 = noindex_filespec(NULL, 0);
|
|
|
|
d2 = noindex_filespec(name2, mode2);
|
|
|
|
name2 = NULL;
|
|
|
|
mode2 = 0;
|
|
|
|
} else {
|
|
|
|
/* 1 is file that is deleted */
|
|
|
|
d1 = noindex_filespec(name1, mode1);
|
|
|
|
d2 = noindex_filespec(NULL, 0);
|
|
|
|
name1 = NULL;
|
|
|
|
mode1 = 0;
|
|
|
|
}
|
|
|
|
/* emit that file */
|
|
|
|
diff_queue(&diff_queued_diff, d1, d2);
|
|
|
|
|
|
|
|
/* and then let the entire directory be created or deleted */
|
|
|
|
}
|
2008-05-24 05:28:56 +00:00
|
|
|
|
|
|
|
if (S_ISDIR(mode1) || S_ISDIR(mode2)) {
|
2012-04-25 19:37:38 +00:00
|
|
|
struct strbuf buffer1 = STRBUF_INIT;
|
|
|
|
struct strbuf buffer2 = STRBUF_INIT;
|
2010-07-04 19:46:19 +00:00
|
|
|
struct string_list p1 = STRING_LIST_INIT_DUP;
|
|
|
|
struct string_list p2 = STRING_LIST_INIT_DUP;
|
2012-04-25 19:37:38 +00:00
|
|
|
int i1, i2, ret = 0;
|
2012-05-16 14:28:31 +00:00
|
|
|
size_t len1 = 0, len2 = 0;
|
2008-05-24 05:28:56 +00:00
|
|
|
|
2014-03-19 15:58:21 +00:00
|
|
|
if (name1 && read_directory_contents(name1, &p1))
|
2008-05-24 05:28:56 +00:00
|
|
|
return -1;
|
2014-03-19 15:58:21 +00:00
|
|
|
if (name2 && read_directory_contents(name2, &p2)) {
|
2008-07-21 18:03:49 +00:00
|
|
|
string_list_clear(&p1, 0);
|
2008-05-24 05:28:56 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (name1) {
|
2012-04-25 19:37:38 +00:00
|
|
|
strbuf_addstr(&buffer1, name1);
|
use strbuf_complete to conditionally append slash
When working with paths in strbufs, we frequently want to
ensure that a directory contains a trailing slash before
appending to it. We can shorten this code (and make the
intent more obvious) by calling strbuf_complete.
Most of these cases are trivially identical conversions, but
there are two things to note:
- in a few cases we did not check that the strbuf is
non-empty (which would lead to an out-of-bounds memory
access). These were generally not triggerable in
practice, either from earlier assertions, or typically
because we would have just fed the strbuf to opendir(),
which would choke on an empty path.
- in a few cases we indexed the buffer with "original_len"
or similar, rather than the current sb->len, and it is
not immediately obvious from the diff that they are the
same. In all of these cases, I manually verified that
the strbuf does not change between the assignment and
the strbuf_complete call.
This does not convert cases which look like:
if (sb->len && !is_dir_sep(sb->buf[sb->len - 1]))
strbuf_addch(sb, '/');
as those are obviously semantically different. Some of these
cases arguably should be doing that, but that is out of
scope for this change, which aims purely for cleanup with no
behavior change (and at least it will make such sites easier
to find and examine in the future, as we can grep for
strbuf_complete).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-09-24 21:08:35 +00:00
|
|
|
strbuf_complete(&buffer1, '/');
|
2012-05-16 14:28:31 +00:00
|
|
|
len1 = buffer1.len;
|
2008-05-24 05:28:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (name2) {
|
2012-04-25 19:37:38 +00:00
|
|
|
strbuf_addstr(&buffer2, name2);
|
use strbuf_complete to conditionally append slash
When working with paths in strbufs, we frequently want to
ensure that a directory contains a trailing slash before
appending to it. We can shorten this code (and make the
intent more obvious) by calling strbuf_complete.
Most of these cases are trivially identical conversions, but
there are two things to note:
- in a few cases we did not check that the strbuf is
non-empty (which would lead to an out-of-bounds memory
access). These were generally not triggerable in
practice, either from earlier assertions, or typically
because we would have just fed the strbuf to opendir(),
which would choke on an empty path.
- in a few cases we indexed the buffer with "original_len"
or similar, rather than the current sb->len, and it is
not immediately obvious from the diff that they are the
same. In all of these cases, I manually verified that
the strbuf does not change between the assignment and
the strbuf_complete call.
This does not convert cases which look like:
if (sb->len && !is_dir_sep(sb->buf[sb->len - 1]))
strbuf_addch(sb, '/');
as those are obviously semantically different. Some of these
cases arguably should be doing that, but that is out of
scope for this change, which aims purely for cleanup with no
behavior change (and at least it will make such sites easier
to find and examine in the future, as we can grep for
strbuf_complete).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-09-24 21:08:35 +00:00
|
|
|
strbuf_complete(&buffer2, '/');
|
2012-05-16 14:28:31 +00:00
|
|
|
len2 = buffer2.len;
|
2008-05-24 05:28:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i1 = i2 = 0; !ret && (i1 < p1.nr || i2 < p2.nr); ) {
|
|
|
|
const char *n1, *n2;
|
|
|
|
int comp;
|
|
|
|
|
2012-05-16 14:28:31 +00:00
|
|
|
strbuf_setlen(&buffer1, len1);
|
|
|
|
strbuf_setlen(&buffer2, len2);
|
|
|
|
|
2008-05-24 05:28:56 +00:00
|
|
|
if (i1 == p1.nr)
|
|
|
|
comp = 1;
|
|
|
|
else if (i2 == p2.nr)
|
|
|
|
comp = -1;
|
|
|
|
else
|
2012-04-25 19:37:38 +00:00
|
|
|
comp = strcmp(p1.items[i1].string, p2.items[i2].string);
|
2008-05-24 05:28:56 +00:00
|
|
|
|
|
|
|
if (comp > 0)
|
|
|
|
n1 = NULL;
|
|
|
|
else {
|
2012-04-25 19:37:38 +00:00
|
|
|
strbuf_addstr(&buffer1, p1.items[i1++].string);
|
|
|
|
n1 = buffer1.buf;
|
2008-05-24 05:28:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (comp < 0)
|
|
|
|
n2 = NULL;
|
|
|
|
else {
|
2012-04-25 19:37:38 +00:00
|
|
|
strbuf_addstr(&buffer2, p2.items[i2++].string);
|
|
|
|
n2 = buffer2.buf;
|
2008-05-24 05:28:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ret = queue_diff(o, n1, n2);
|
|
|
|
}
|
2008-07-21 18:03:49 +00:00
|
|
|
string_list_clear(&p1, 0);
|
|
|
|
string_list_clear(&p2, 0);
|
2012-05-16 14:50:31 +00:00
|
|
|
strbuf_release(&buffer1);
|
|
|
|
strbuf_release(&buffer2);
|
2008-05-24 05:28:56 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
} else {
|
|
|
|
struct diff_filespec *d1, *d2;
|
|
|
|
|
|
|
|
if (DIFF_OPT_TST(o, REVERSE_DIFF)) {
|
|
|
|
unsigned tmp;
|
|
|
|
const char *tmp_c;
|
|
|
|
tmp = mode1; mode1 = mode2; mode2 = tmp;
|
|
|
|
tmp_c = name1; name1 = name2; name2 = tmp_c;
|
|
|
|
}
|
|
|
|
|
2012-06-28 03:14:47 +00:00
|
|
|
d1 = noindex_filespec(name1, mode1);
|
|
|
|
d2 = noindex_filespec(name2, mode2);
|
2008-05-24 05:28:56 +00:00
|
|
|
diff_queue(&diff_queued_diff, d1, d2);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-25 23:11:39 +00:00
|
|
|
/* append basename of F to D */
|
|
|
|
static void append_basename(struct strbuf *path, const char *dir, const char *file)
|
|
|
|
{
|
|
|
|
const char *tail = strrchr(file, '/');
|
|
|
|
|
|
|
|
strbuf_addstr(path, dir);
|
|
|
|
while (path->len && path->buf[path->len - 1] == '/')
|
|
|
|
path->len--;
|
|
|
|
strbuf_addch(path, '/');
|
|
|
|
strbuf_addstr(path, tail ? tail + 1 : file);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DWIM "diff D F" into "diff D/F F" and "diff F D" into "diff F D/F"
|
|
|
|
* Note that we append the basename of F to D/, so "diff a/b/file D"
|
|
|
|
* becomes "diff a/b/file D/file", not "diff a/b/file D/a/b/file".
|
|
|
|
*/
|
|
|
|
static void fixup_paths(const char **path, struct strbuf *replacement)
|
|
|
|
{
|
|
|
|
unsigned int isdir0, isdir1;
|
|
|
|
|
|
|
|
if (path[0] == file_from_standard_input ||
|
|
|
|
path[1] == file_from_standard_input)
|
|
|
|
return;
|
|
|
|
isdir0 = is_directory(path[0]);
|
|
|
|
isdir1 = is_directory(path[1]);
|
|
|
|
if (isdir0 == isdir1)
|
|
|
|
return;
|
|
|
|
if (isdir0) {
|
|
|
|
append_basename(replacement, path[0], path[1]);
|
|
|
|
path[0] = replacement->buf;
|
|
|
|
} else {
|
|
|
|
append_basename(replacement, path[1], path[0]);
|
|
|
|
path[1] = replacement->buf;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-05-24 05:28:56 +00:00
|
|
|
void diff_no_index(struct rev_info *revs,
|
|
|
|
int argc, const char **argv,
|
2013-12-11 09:58:42 +00:00
|
|
|
const char *prefix)
|
2008-05-24 05:28:56 +00:00
|
|
|
{
|
2012-06-27 19:05:52 +00:00
|
|
|
int i, prefixlen;
|
2012-06-27 18:51:15 +00:00
|
|
|
const char *paths[2];
|
2015-03-25 23:11:39 +00:00
|
|
|
struct strbuf replacement = STRBUF_INIT;
|
2008-05-24 05:28:56 +00:00
|
|
|
|
|
|
|
diff_setup(&revs->diffopt);
|
|
|
|
for (i = 1; i < argc - 2; ) {
|
|
|
|
int j;
|
|
|
|
if (!strcmp(argv[i], "--no-index"))
|
|
|
|
i++;
|
2009-01-06 18:53:32 +00:00
|
|
|
else if (!strcmp(argv[i], "--"))
|
|
|
|
i++;
|
2008-05-24 05:28:56 +00:00
|
|
|
else {
|
|
|
|
j = diff_opt_parse(&revs->diffopt, argv + i, argc - i);
|
diff-no-index: correctly diagnose error return from diff_opt_parse()
diff_opt_parse() returns the number of options parsed, or often
returns error() which is defined to return -1. Yes, return value of
0 is "I did not process that option at all", which should cause the
caller to say that, but negative return should not be forgotten.
This bug caused "diff --no-index" to infinitely show the same error
message because the returned value was used to decrement the loop
control variable, e.g.
$ git diff --no-index --color=words a b
error: option `color' expects "always", "auto", or "never"
error: option `color' expects "always", "auto", or "never"
...
Instead, make it act like so:
$ git diff --no-index --color=words a b
error: option `color' expects "always", "auto", or "never"
fatal: invalid diff option/value: --color=words
Reported-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-03-31 18:47:17 +00:00
|
|
|
if (j <= 0)
|
2008-05-24 05:28:56 +00:00
|
|
|
die("invalid diff option/value: %s", argv[i]);
|
|
|
|
i += j;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-27 19:05:52 +00:00
|
|
|
prefixlen = prefix ? strlen(prefix) : 0;
|
|
|
|
for (i = 0; i < 2; i++) {
|
|
|
|
const char *p = argv[argc - 2 + i];
|
|
|
|
if (!strcmp(p, "-"))
|
2008-05-24 05:28:56 +00:00
|
|
|
/*
|
2012-06-27 19:05:52 +00:00
|
|
|
* stdin should be spelled as "-"; if you have
|
|
|
|
* path that is "-", spell it as "./-".
|
2008-05-24 05:28:56 +00:00
|
|
|
*/
|
2012-06-28 03:14:47 +00:00
|
|
|
p = file_from_standard_input;
|
2012-06-27 19:05:52 +00:00
|
|
|
else if (prefixlen)
|
|
|
|
p = xstrdup(prefix_filename(prefix, prefixlen, p));
|
|
|
|
paths[i] = p;
|
2008-05-24 05:28:56 +00:00
|
|
|
}
|
2015-03-25 23:11:39 +00:00
|
|
|
|
|
|
|
fixup_paths(paths, &replacement);
|
|
|
|
|
2009-02-18 06:48:06 +00:00
|
|
|
revs->diffopt.skip_stat_unmatch = 1;
|
2009-03-25 17:19:46 +00:00
|
|
|
if (!revs->diffopt.output_format)
|
|
|
|
revs->diffopt.output_format = DIFF_FORMAT_PATCH;
|
2008-05-24 05:28:56 +00:00
|
|
|
|
|
|
|
DIFF_OPT_SET(&revs->diffopt, NO_INDEX);
|
|
|
|
|
|
|
|
revs->max_count = -2;
|
2012-08-03 12:16:24 +00:00
|
|
|
diff_setup_done(&revs->diffopt);
|
2008-05-24 05:28:56 +00:00
|
|
|
|
2012-06-15 20:32:55 +00:00
|
|
|
setup_diff_pager(&revs->diffopt);
|
|
|
|
DIFF_OPT_SET(&revs->diffopt, EXIT_WITH_STATUS);
|
|
|
|
|
2012-06-27 18:51:15 +00:00
|
|
|
if (queue_diff(&revs->diffopt, paths[0], paths[1]))
|
2008-05-24 05:28:56 +00:00
|
|
|
exit(1);
|
2008-08-19 03:08:09 +00:00
|
|
|
diff_set_mnemonic_prefix(&revs->diffopt, "1/", "2/");
|
2008-05-24 05:28:56 +00:00
|
|
|
diffcore_std(&revs->diffopt);
|
|
|
|
diff_flush(&revs->diffopt);
|
|
|
|
|
2015-03-25 23:11:39 +00:00
|
|
|
strbuf_release(&replacement);
|
|
|
|
|
2008-05-24 05:28:56 +00:00
|
|
|
/*
|
|
|
|
* The return code for --no-index imitates diff(1):
|
|
|
|
* 0 = no changes, 1 = changes, else error
|
|
|
|
*/
|
2012-06-21 18:09:51 +00:00
|
|
|
exit(diff_result_code(&revs->diffopt, 0));
|
2008-05-24 05:28:56 +00:00
|
|
|
}
|