2005-04-12 01:55:38 +00:00
|
|
|
/*
|
|
|
|
* This merges the file listing in the directory cache index
|
|
|
|
* with the actual working directory list, and shows different
|
|
|
|
* combinations of the two.
|
|
|
|
*
|
|
|
|
* Copyright (C) Linus Torvalds, 2005
|
|
|
|
*/
|
2017-06-22 18:43:48 +00:00
|
|
|
#define NO_THE_INDEX_COMPATIBILITY_MACROS
|
2005-04-12 01:55:38 +00:00
|
|
|
#include "cache.h"
|
2017-06-22 18:43:48 +00:00
|
|
|
#include "repository.h"
|
2017-06-14 18:07:36 +00:00
|
|
|
#include "config.h"
|
2005-10-15 04:56:46 +00:00
|
|
|
#include "quote.h"
|
2006-05-17 02:02:14 +00:00
|
|
|
#include "dir.h"
|
2006-05-23 12:15:29 +00:00
|
|
|
#include "builtin.h"
|
2007-09-12 23:04:22 +00:00
|
|
|
#include "tree.h"
|
2009-02-17 14:27:11 +00:00
|
|
|
#include "parse-options.h"
|
2009-12-25 18:08:04 +00:00
|
|
|
#include "resolve-undo.h"
|
|
|
|
#include "string-list.h"
|
2013-07-14 08:35:25 +00:00
|
|
|
#include "pathspec.h"
|
2016-10-07 18:18:49 +00:00
|
|
|
#include "run-command.h"
|
2017-04-13 17:12:23 +00:00
|
|
|
#include "submodule.h"
|
2005-04-12 01:55:38 +00:00
|
|
|
|
2006-08-15 17:23:48 +00:00
|
|
|
static int abbrev;
|
|
|
|
static int show_deleted;
|
|
|
|
static int show_cached;
|
|
|
|
static int show_others;
|
|
|
|
static int show_stage;
|
|
|
|
static int show_unmerged;
|
2009-12-25 18:08:04 +00:00
|
|
|
static int show_resolve_undo;
|
2006-08-15 17:23:48 +00:00
|
|
|
static int show_modified;
|
|
|
|
static int show_killed;
|
|
|
|
static int show_valid_bit;
|
2005-04-15 18:11:01 +00:00
|
|
|
static int line_terminator = '\n';
|
2010-07-30 22:35:59 +00:00
|
|
|
static int debug_mode;
|
2016-01-16 06:50:02 +00:00
|
|
|
static int show_eol;
|
2016-10-07 18:18:49 +00:00
|
|
|
static int recurse_submodules;
|
2005-04-12 01:55:38 +00:00
|
|
|
|
2010-06-03 13:39:18 +00:00
|
|
|
static const char *prefix;
|
|
|
|
static int max_prefix_len;
|
2006-08-15 17:23:48 +00:00
|
|
|
static int prefix_len;
|
2013-07-14 08:35:43 +00:00
|
|
|
static struct pathspec pathspec;
|
2006-08-15 17:23:48 +00:00
|
|
|
static int error_unmatch;
|
|
|
|
static char *ps_matched;
|
2007-09-12 23:04:22 +00:00
|
|
|
static const char *with_tree;
|
2009-02-17 14:27:11 +00:00
|
|
|
static int exc_given;
|
2013-01-06 16:58:04 +00:00
|
|
|
static int exclude_args;
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
|
2005-04-22 02:47:08 +00:00
|
|
|
static const char *tag_cached = "";
|
|
|
|
static const char *tag_unmerged = "";
|
|
|
|
static const char *tag_removed = "";
|
|
|
|
static const char *tag_other = "";
|
2005-05-13 00:17:54 +00:00
|
|
|
static const char *tag_killed = "";
|
2005-09-19 22:11:15 +00:00
|
|
|
static const char *tag_modified = "";
|
2009-08-20 13:46:57 +00:00
|
|
|
static const char *tag_skip_worktree = "";
|
2009-12-25 18:08:04 +00:00
|
|
|
static const char *tag_resolve_undo = "";
|
2005-04-22 02:47:08 +00:00
|
|
|
|
2017-06-12 22:13:59 +00:00
|
|
|
static void write_eolinfo(const struct index_state *istate,
|
|
|
|
const struct cache_entry *ce, const char *path)
|
2016-01-16 06:50:02 +00:00
|
|
|
{
|
2017-06-12 22:13:59 +00:00
|
|
|
if (show_eol) {
|
2016-01-16 06:50:02 +00:00
|
|
|
struct stat st;
|
|
|
|
const char *i_txt = "";
|
|
|
|
const char *w_txt = "";
|
|
|
|
const char *a_txt = get_convert_attr_ascii(path);
|
|
|
|
if (ce && S_ISREG(ce->ce_mode))
|
2017-06-12 22:13:59 +00:00
|
|
|
i_txt = get_cached_convert_stats_ascii(istate,
|
2017-06-12 22:13:52 +00:00
|
|
|
ce->name);
|
2016-01-16 06:50:02 +00:00
|
|
|
if (!lstat(path, &st) && S_ISREG(st.st_mode))
|
|
|
|
w_txt = get_wt_convert_stats_ascii(path);
|
|
|
|
printf("i/%-5s w/%-5s attr/%-17s\t", i_txt, w_txt, a_txt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-25 15:53:46 +00:00
|
|
|
static void write_name(const char *name)
|
2010-06-03 13:39:18 +00:00
|
|
|
{
|
quote.c: substitute path_relative with relative_path
Substitute the function path_relative in quote.c with the function
relative_path. Function relative_path can be treated as an enhanced
and more robust version of path_relative.
Outputs of path_relative and it's replacement (relative_path) are the
same for the following cases:
path prefix output of path_relative output of relative_path
======== ========= ======================= =======================
/a/b/c/ /a/b/ c/ c/
/a/b/c /a/b/ c c
/a/ /a/b/ ../ ../
/ /a/b/ ../../ ../../
/a/c /a/b/ ../c ../c
/x/y /a/b/ ../../x/y ../../x/y
a/b/c/ a/b/ c/ c/
a/ a/b/ ../ ../
x/y a/b/ ../../x/y ../../x/y
/a/b (empty) /a/b /a/b
/a/b (null) /a/b /a/b
a/b (empty) a/b a/b
a/b (null) a/b a/b
But if both of the path and the prefix are the same, or the returned
relative path should be the current directory, the outputs of both
functions are different. Function relative_path returns "./", while
function path_relative returns empty string.
path prefix output of path_relative output of relative_path
======== ========= ======================= =======================
/a/b/ /a/b/ (empty) ./
a/b/ a/b/ (empty) ./
(empty) (null) (empty) ./
(empty) (empty) (empty) ./
But the callers of path_relative can handle such cases, or never
encounter this issue at all, because:
* In function quote_path_relative, if the output of path_relative is
empty, append "./" to it, like:
if (!out->len)
strbuf_addstr(out, "./");
* Another caller is write_name_quoted_relative, which is only used
by builtin/ls-files.c. git-ls-files only show files, so path of
files will never be identical with the prefix of a directory.
The following differences show that path_relative does not handle
extra slashes properly:
path prefix output of path_relative output of relative_path
======== ========= ======================= =======================
/a//b//c/ //a/b// ../../../../a//b//c/ c/
a/b//c a//b ../b//c c
And if prefix has no trailing slash, path_relative does not work
properly either. But since prefix always has a trailing slash, it's
not a problem.
path prefix output of path_relative output of relative_path
======== ========= ======================= =======================
/a/b/c/ /a/b b/c/ c/
/a/b /a/b b ./
/a/b/ /a/b b/ ./
/a /a/b/ ../../a ../
a/b/c/ a/b b/c/ c/
a/b/ a/b b/ ./
a a/b ../a ../
x/y a/b/ ../x/y ../../x/y
a/c a/b c ../c
/a/ /a/b (empty) ../
(empty) /a/b ../../ ./
One tricky part in this conversion is write_name() function in
ls-files.c. It takes a counted string, <name, len>, that is to be
made relative to <prefix, prefix_len> and then quoted. Because
write_name_quoted_relative() still takes these two parameters as
counted string, but ignores the count and treat these two as
NUL-terminated strings, this conversion needs to be audited for its
callers:
- For <name, len>, all three callers of write_name() passes a
NUL-terminated string and its true length, so this patch makes
"len" unused.
- For <prefix, prefix_len>, prefix could be a string that is longer
than empty while prefix_len could be 0 when "--full-name" option
is used. This is fixed by checking prefix_len in write_name()
and calling write_name_quoted_relative() with NULL when
prefix_len is set to 0. Again, this makes "prefix_len" given to
write_name_quoted_relative() unused, without introducing a bug.
Signed-off-by: Jiang Xin <worldhello.net@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-06-25 15:53:44 +00:00
|
|
|
/*
|
2013-06-25 15:53:46 +00:00
|
|
|
* With "--full-name", prefix_len=0; this caller needs to pass
|
|
|
|
* an empty string in that case (a NULL is good for "").
|
quote.c: substitute path_relative with relative_path
Substitute the function path_relative in quote.c with the function
relative_path. Function relative_path can be treated as an enhanced
and more robust version of path_relative.
Outputs of path_relative and it's replacement (relative_path) are the
same for the following cases:
path prefix output of path_relative output of relative_path
======== ========= ======================= =======================
/a/b/c/ /a/b/ c/ c/
/a/b/c /a/b/ c c
/a/ /a/b/ ../ ../
/ /a/b/ ../../ ../../
/a/c /a/b/ ../c ../c
/x/y /a/b/ ../../x/y ../../x/y
a/b/c/ a/b/ c/ c/
a/ a/b/ ../ ../
x/y a/b/ ../../x/y ../../x/y
/a/b (empty) /a/b /a/b
/a/b (null) /a/b /a/b
a/b (empty) a/b a/b
a/b (null) a/b a/b
But if both of the path and the prefix are the same, or the returned
relative path should be the current directory, the outputs of both
functions are different. Function relative_path returns "./", while
function path_relative returns empty string.
path prefix output of path_relative output of relative_path
======== ========= ======================= =======================
/a/b/ /a/b/ (empty) ./
a/b/ a/b/ (empty) ./
(empty) (null) (empty) ./
(empty) (empty) (empty) ./
But the callers of path_relative can handle such cases, or never
encounter this issue at all, because:
* In function quote_path_relative, if the output of path_relative is
empty, append "./" to it, like:
if (!out->len)
strbuf_addstr(out, "./");
* Another caller is write_name_quoted_relative, which is only used
by builtin/ls-files.c. git-ls-files only show files, so path of
files will never be identical with the prefix of a directory.
The following differences show that path_relative does not handle
extra slashes properly:
path prefix output of path_relative output of relative_path
======== ========= ======================= =======================
/a//b//c/ //a/b// ../../../../a//b//c/ c/
a/b//c a//b ../b//c c
And if prefix has no trailing slash, path_relative does not work
properly either. But since prefix always has a trailing slash, it's
not a problem.
path prefix output of path_relative output of relative_path
======== ========= ======================= =======================
/a/b/c/ /a/b b/c/ c/
/a/b /a/b b ./
/a/b/ /a/b b/ ./
/a /a/b/ ../../a ../
a/b/c/ a/b b/c/ c/
a/b/ a/b b/ ./
a a/b ../a ../
x/y a/b/ ../x/y ../../x/y
a/c a/b c ../c
/a/ /a/b (empty) ../
(empty) /a/b ../../ ./
One tricky part in this conversion is write_name() function in
ls-files.c. It takes a counted string, <name, len>, that is to be
made relative to <prefix, prefix_len> and then quoted. Because
write_name_quoted_relative() still takes these two parameters as
counted string, but ignores the count and treat these two as
NUL-terminated strings, this conversion needs to be audited for its
callers:
- For <name, len>, all three callers of write_name() passes a
NUL-terminated string and its true length, so this patch makes
"len" unused.
- For <prefix, prefix_len>, prefix could be a string that is longer
than empty while prefix_len could be 0 when "--full-name" option
is used. This is fixed by checking prefix_len in write_name()
and calling write_name_quoted_relative() with NULL when
prefix_len is set to 0. Again, this makes "prefix_len" given to
write_name_quoted_relative() unused, without introducing a bug.
Signed-off-by: Jiang Xin <worldhello.net@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-06-25 15:53:44 +00:00
|
|
|
*/
|
2013-06-25 15:53:46 +00:00
|
|
|
write_name_quoted_relative(name, prefix_len ? prefix : NULL,
|
|
|
|
stdout, line_terminator);
|
2010-06-03 13:39:18 +00:00
|
|
|
}
|
|
|
|
|
2017-06-12 22:14:08 +00:00
|
|
|
static const char *get_tag(const struct cache_entry *ce, const char *tag)
|
|
|
|
{
|
|
|
|
static char alttag[4];
|
|
|
|
|
|
|
|
if (tag && *tag && show_valid_bit && (ce->ce_flags & CE_VALID)) {
|
|
|
|
memcpy(alttag, tag, 3);
|
|
|
|
|
|
|
|
if (isalpha(tag[0])) {
|
|
|
|
alttag[0] = tolower(tag[0]);
|
|
|
|
} else if (tag[0] == '?') {
|
|
|
|
alttag[0] = '!';
|
|
|
|
} else {
|
|
|
|
alttag[0] = 'v';
|
|
|
|
alttag[1] = tag[0];
|
|
|
|
alttag[2] = ' ';
|
|
|
|
alttag[3] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
tag = alttag;
|
|
|
|
}
|
|
|
|
|
|
|
|
return tag;
|
|
|
|
}
|
|
|
|
|
2017-06-12 22:14:07 +00:00
|
|
|
static void print_debug(const struct cache_entry *ce)
|
|
|
|
{
|
|
|
|
if (debug_mode) {
|
|
|
|
const struct stat_data *sd = &ce->ce_stat_data;
|
|
|
|
|
|
|
|
printf(" ctime: %d:%d\n", sd->sd_ctime.sec, sd->sd_ctime.nsec);
|
|
|
|
printf(" mtime: %d:%d\n", sd->sd_mtime.sec, sd->sd_mtime.nsec);
|
|
|
|
printf(" dev: %d\tino: %d\n", sd->sd_dev, sd->sd_ino);
|
|
|
|
printf(" uid: %d\tgid: %d\n", sd->sd_uid, sd->sd_gid);
|
|
|
|
printf(" size: %d\tflags: %x\n", sd->sd_size, ce->ce_flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-05-17 02:02:14 +00:00
|
|
|
static void show_dir_entry(const char *tag, struct dir_entry *ent)
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
{
|
2010-06-03 13:39:18 +00:00
|
|
|
int len = max_prefix_len;
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
|
2017-05-11 22:04:25 +00:00
|
|
|
if (len > ent->len)
|
2008-08-31 16:39:19 +00:00
|
|
|
die("git ls-files: internal error - directory entry not superset of prefix");
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
|
2014-01-24 13:40:29 +00:00
|
|
|
if (!dir_path_match(ent, &pathspec, len, ps_matched))
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
return;
|
|
|
|
|
2005-10-15 04:56:46 +00:00
|
|
|
fputs(tag, stdout);
|
2017-06-12 22:13:59 +00:00
|
|
|
write_eolinfo(NULL, NULL, ent->name);
|
2013-06-25 15:53:46 +00:00
|
|
|
write_name(ent->name);
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
}
|
|
|
|
|
2017-06-12 22:14:01 +00:00
|
|
|
static void show_other_files(const struct index_state *istate,
|
|
|
|
const struct dir_struct *dir)
|
2005-11-07 01:26:31 +00:00
|
|
|
{
|
|
|
|
int i;
|
2007-04-14 23:22:08 +00:00
|
|
|
|
2006-05-17 02:02:14 +00:00
|
|
|
for (i = 0; i < dir->nr; i++) {
|
|
|
|
struct dir_entry *ent = dir->entries[i];
|
2017-06-12 22:14:01 +00:00
|
|
|
if (!index_name_is_other(istate, ent->name, ent->len))
|
2008-10-16 15:07:26 +00:00
|
|
|
continue;
|
2005-11-07 01:26:31 +00:00
|
|
|
show_dir_entry(tag_other, ent);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-12 22:14:00 +00:00
|
|
|
static void show_killed_files(const struct index_state *istate,
|
|
|
|
const struct dir_struct *dir)
|
2005-05-13 00:17:54 +00:00
|
|
|
{
|
|
|
|
int i;
|
2006-05-17 02:02:14 +00:00
|
|
|
for (i = 0; i < dir->nr; i++) {
|
|
|
|
struct dir_entry *ent = dir->entries[i];
|
2005-05-13 00:17:54 +00:00
|
|
|
char *cp, *sp;
|
|
|
|
int pos, len, killed = 0;
|
|
|
|
|
|
|
|
for (cp = ent->name; cp - ent->name < ent->len; cp = sp + 1) {
|
|
|
|
sp = strchr(cp, '/');
|
|
|
|
if (!sp) {
|
|
|
|
/* If ent->name is prefix of an entry in the
|
|
|
|
* cache, it will be killed.
|
|
|
|
*/
|
2017-06-12 22:14:00 +00:00
|
|
|
pos = index_name_pos(istate, ent->name, ent->len);
|
2005-05-13 00:17:54 +00:00
|
|
|
if (0 <= pos)
|
2016-07-26 16:05:50 +00:00
|
|
|
die("BUG: killed-file %.*s not found",
|
|
|
|
ent->len, ent->name);
|
2005-05-13 00:17:54 +00:00
|
|
|
pos = -pos - 1;
|
2017-06-12 22:14:00 +00:00
|
|
|
while (pos < istate->cache_nr &&
|
|
|
|
ce_stage(istate->cache[pos]))
|
2005-05-13 00:17:54 +00:00
|
|
|
pos++; /* skip unmerged */
|
2017-06-12 22:14:00 +00:00
|
|
|
if (istate->cache_nr <= pos)
|
2005-05-13 00:17:54 +00:00
|
|
|
break;
|
|
|
|
/* pos points at a name immediately after
|
|
|
|
* ent->name in the cache. Does it expect
|
|
|
|
* ent->name to be a directory?
|
|
|
|
*/
|
2017-06-12 22:14:00 +00:00
|
|
|
len = ce_namelen(istate->cache[pos]);
|
2005-05-13 00:17:54 +00:00
|
|
|
if ((ent->len < len) &&
|
2017-06-12 22:14:00 +00:00
|
|
|
!strncmp(istate->cache[pos]->name,
|
2005-05-13 00:17:54 +00:00
|
|
|
ent->name, ent->len) &&
|
2017-06-12 22:14:00 +00:00
|
|
|
istate->cache[pos]->name[ent->len] == '/')
|
2005-05-13 00:17:54 +00:00
|
|
|
killed = 1;
|
|
|
|
break;
|
|
|
|
}
|
2017-06-12 22:14:00 +00:00
|
|
|
if (0 <= index_name_pos(istate, ent->name, sp - ent->name)) {
|
2005-05-13 00:17:54 +00:00
|
|
|
/* If any of the leading directories in
|
|
|
|
* ent->name is registered in the cache,
|
|
|
|
* ent->name will be killed.
|
|
|
|
*/
|
|
|
|
killed = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (killed)
|
2006-05-17 02:02:14 +00:00
|
|
|
show_dir_entry(tag_killed, dir->entries[i]);
|
2005-05-13 00:17:54 +00:00
|
|
|
}
|
2005-04-12 01:55:38 +00:00
|
|
|
}
|
|
|
|
|
2017-06-22 18:43:48 +00:00
|
|
|
static void show_files(struct repository *repo, struct dir_struct *dir);
|
2016-10-07 18:18:50 +00:00
|
|
|
|
2017-06-22 18:43:48 +00:00
|
|
|
static void show_submodule(struct repository *superproject,
|
|
|
|
struct dir_struct *dir, const char *path)
|
2016-10-07 18:18:49 +00:00
|
|
|
{
|
2017-06-22 18:43:48 +00:00
|
|
|
struct repository submodule;
|
|
|
|
|
|
|
|
if (repo_submodule_init(&submodule, superproject, path))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (repo_read_index(&submodule) < 0)
|
|
|
|
die("index file corrupt");
|
|
|
|
|
|
|
|
repo_read_gitmodules(&submodule);
|
|
|
|
|
|
|
|
show_files(&submodule, dir);
|
|
|
|
|
|
|
|
repo_clear(&submodule);
|
2016-10-07 18:18:49 +00:00
|
|
|
}
|
|
|
|
|
2017-06-22 18:43:48 +00:00
|
|
|
static void show_ce(struct repository *repo, struct dir_struct *dir,
|
|
|
|
const struct cache_entry *ce, const char *fullname,
|
|
|
|
const char *tag)
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
{
|
2017-06-22 18:43:48 +00:00
|
|
|
if (max_prefix_len > strlen(fullname))
|
2008-08-31 16:39:19 +00:00
|
|
|
die("git ls-files: internal error - cache entry not superset of prefix");
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
|
2016-10-07 18:18:51 +00:00
|
|
|
if (recurse_submodules && S_ISGITLINK(ce->ce_mode) &&
|
2017-06-22 18:43:48 +00:00
|
|
|
is_submodule_active(repo, ce->name)) {
|
|
|
|
show_submodule(repo, dir, ce->name);
|
|
|
|
} else if (match_pathspec(&pathspec, fullname, strlen(fullname),
|
|
|
|
max_prefix_len, ps_matched,
|
2016-10-07 18:18:49 +00:00
|
|
|
S_ISDIR(ce->ce_mode) ||
|
|
|
|
S_ISGITLINK(ce->ce_mode))) {
|
2017-06-12 22:14:08 +00:00
|
|
|
tag = get_tag(ce, tag);
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
|
2016-10-07 18:18:49 +00:00
|
|
|
if (!show_stage) {
|
|
|
|
fputs(tag, stdout);
|
|
|
|
} else {
|
|
|
|
printf("%s%06o %s %d\t",
|
|
|
|
tag,
|
|
|
|
ce->ce_mode,
|
2016-10-26 20:14:44 +00:00
|
|
|
find_unique_abbrev(ce->oid.hash, abbrev),
|
2016-10-07 18:18:49 +00:00
|
|
|
ce_stage(ce));
|
|
|
|
}
|
2017-06-22 18:43:48 +00:00
|
|
|
write_eolinfo(repo->index, ce, fullname);
|
|
|
|
write_name(fullname);
|
2017-06-12 22:14:07 +00:00
|
|
|
print_debug(ce);
|
2006-02-09 05:50:18 +00:00
|
|
|
}
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
}
|
|
|
|
|
2017-06-12 22:14:02 +00:00
|
|
|
static void show_ru_info(const struct index_state *istate)
|
2009-12-25 18:08:04 +00:00
|
|
|
{
|
2010-07-03 12:41:54 +00:00
|
|
|
struct string_list_item *item;
|
|
|
|
|
2017-06-12 22:14:02 +00:00
|
|
|
if (!istate->resolve_undo)
|
2009-12-25 18:08:04 +00:00
|
|
|
return;
|
2010-07-03 12:41:54 +00:00
|
|
|
|
2017-06-12 22:14:02 +00:00
|
|
|
for_each_string_list_item(item, istate->resolve_undo) {
|
2010-07-03 12:41:54 +00:00
|
|
|
const char *path = item->string;
|
|
|
|
struct resolve_undo_info *ui = item->util;
|
|
|
|
int i, len;
|
|
|
|
|
|
|
|
len = strlen(path);
|
|
|
|
if (len < max_prefix_len)
|
|
|
|
continue; /* outside of the prefix */
|
2014-01-24 13:40:30 +00:00
|
|
|
if (!match_pathspec(&pathspec, path, len,
|
2014-01-24 13:40:33 +00:00
|
|
|
max_prefix_len, ps_matched, 0))
|
2010-07-03 12:41:54 +00:00
|
|
|
continue; /* uninterested */
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
|
|
if (!ui->mode[i])
|
|
|
|
continue;
|
|
|
|
printf("%s%06o %s %d\t", tag_resolve_undo, ui->mode[i],
|
|
|
|
find_unique_abbrev(ui->sha1[i], abbrev),
|
|
|
|
i + 1);
|
2013-06-25 15:53:46 +00:00
|
|
|
write_name(path);
|
2010-07-03 12:41:54 +00:00
|
|
|
}
|
|
|
|
}
|
2009-12-25 18:08:04 +00:00
|
|
|
}
|
|
|
|
|
2017-06-12 22:14:03 +00:00
|
|
|
static int ce_excluded(struct dir_struct *dir, struct index_state *istate,
|
2017-06-22 18:43:48 +00:00
|
|
|
const char *fullname, const struct cache_entry *ce)
|
2012-06-06 04:17:52 +00:00
|
|
|
{
|
|
|
|
int dtype = ce_to_dtype(ce);
|
2017-06-22 18:43:48 +00:00
|
|
|
return is_excluded(dir, istate, fullname, &dtype);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void construct_fullname(struct strbuf *out, const struct repository *repo,
|
|
|
|
const struct cache_entry *ce)
|
|
|
|
{
|
|
|
|
strbuf_reset(out);
|
|
|
|
if (repo->submodule_prefix)
|
|
|
|
strbuf_addstr(out, repo->submodule_prefix);
|
|
|
|
strbuf_addstr(out, ce->name);
|
2012-06-06 04:17:52 +00:00
|
|
|
}
|
|
|
|
|
2017-06-22 18:43:48 +00:00
|
|
|
static void show_files(struct repository *repo, struct dir_struct *dir)
|
2005-04-12 01:55:38 +00:00
|
|
|
{
|
|
|
|
int i;
|
2017-06-22 18:43:48 +00:00
|
|
|
struct strbuf fullname = STRBUF_INIT;
|
2005-04-12 01:55:38 +00:00
|
|
|
|
|
|
|
/* For cached/deleted files we don't need to even do the readdir */
|
2005-05-13 00:17:54 +00:00
|
|
|
if (show_others || show_killed) {
|
ls-files -k: a directory only can be killed if the index has a non-directory
"ls-files -o" and "ls-files -k" both traverse the working tree down
to find either all untracked paths or those that will be "killed"
(removed from the working tree to make room) when the paths recorded
in the index are checked out. It is necessary to traverse the
working tree fully when enumerating all the "other" paths, but when
we are only interested in "killed" paths, we can take advantage of
the fact that paths that do not overlap with entries in the index
can never be killed.
The treat_one_path() helper function, which is called during the
recursive traversal, is the ideal place to implement an
optimization.
When we are looking at a directory P in the working tree, there are
three cases:
(1) P exists in the index. Everything inside the directory P in
the working tree needs to go when P is checked out from the
index.
(2) P does not exist in the index, but there is P/Q in the index.
We know P will stay a directory when we check out the contents
of the index, but we do not know yet if there is a directory
P/Q in the working tree to be killed, so we need to recurse.
(3) P does not exist in the index, and there is no P/Q in the index
to require P to be a directory, either. Only in this case, we
know that everything inside P will not be killed without
recursing.
Note that this helper is called by treat_leading_path() that decides
if we need to traverse only subdirectories of a single common
leading directory, which is essential for this optimization to be
correct. This caller checks each level of the leading path
component from shallower directory to deeper ones, and that is what
allows us to only check if the path appears in the index. If the
call to treat_one_path() weren't there, given a path P/Q/R, the real
traversal may start from directory P/Q/R, even when the index
records P as a regular file, and we would end up having to check if
any leading subpath in P/Q/R, e.g. P, appears in the index.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-08-15 19:13:46 +00:00
|
|
|
if (!show_others)
|
|
|
|
dir->flags |= DIR_COLLECT_KILLED_ONLY;
|
2017-06-22 18:43:48 +00:00
|
|
|
fill_directory(dir, repo->index, &pathspec);
|
2005-05-13 00:17:54 +00:00
|
|
|
if (show_others)
|
2017-06-22 18:43:48 +00:00
|
|
|
show_other_files(repo->index, dir);
|
2005-05-13 00:17:54 +00:00
|
|
|
if (show_killed)
|
2017-06-22 18:43:48 +00:00
|
|
|
show_killed_files(repo->index, dir);
|
2005-04-12 01:55:38 +00:00
|
|
|
}
|
2013-06-13 18:19:44 +00:00
|
|
|
if (show_cached || show_stage) {
|
2017-06-22 18:43:48 +00:00
|
|
|
for (i = 0; i < repo->index->cache_nr; i++) {
|
|
|
|
const struct cache_entry *ce = repo->index->cache[i];
|
|
|
|
|
|
|
|
construct_fullname(&fullname, repo, ce);
|
|
|
|
|
2012-06-01 18:28:00 +00:00
|
|
|
if ((dir->flags & DIR_SHOW_IGNORED) &&
|
2017-06-22 18:43:48 +00:00
|
|
|
!ce_excluded(dir, repo->index, fullname.buf, ce))
|
ls-files: unbreak "ls-files -i"
Commit b5227d8 changed the behavior of "ls-files" with
respect to includes, but accidentally broke the "-i" option
The original behavior was:
1. if no "-i" is given, cull all results according to --exclude*
2. if "-i" is given, show the inverse of (1)
The broken behavior was:
1. if no "-i" is given:
a. for "-o", cull results according to --exclude*
b. for index files, always show all
2. if "-i" is given:
a. for "-o", shows the inverse of (1a)
b. for index files, always show all
The fixed behavior keeps the new (1b) behavior introduced
by b5227d8, but fixes the (2b) behavior to show only ignored
files, not all files.
This patch also tweaks the documentation. The original text
was somewhat obscure in the first place, but it is also now
inaccurate (the relationship between (1b) and (2b) is not
quite a "reverse").
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-10-30 19:05:52 +00:00
|
|
|
continue;
|
2005-04-16 19:43:32 +00:00
|
|
|
if (show_unmerged && !ce_stage(ce))
|
|
|
|
continue;
|
2008-01-15 00:03:17 +00:00
|
|
|
if (ce->ce_flags & CE_UPDATE)
|
2007-09-12 23:04:22 +00:00
|
|
|
continue;
|
2017-06-22 18:43:48 +00:00
|
|
|
show_ce(repo, dir, ce, fullname.buf,
|
|
|
|
ce_stage(ce) ? tag_unmerged :
|
|
|
|
(ce_skip_worktree(ce) ? tag_skip_worktree :
|
|
|
|
tag_cached));
|
2005-04-12 01:55:38 +00:00
|
|
|
}
|
|
|
|
}
|
2013-06-13 18:19:44 +00:00
|
|
|
if (show_deleted || show_modified) {
|
2017-06-22 18:43:48 +00:00
|
|
|
for (i = 0; i < repo->index->cache_nr; i++) {
|
|
|
|
const struct cache_entry *ce = repo->index->cache[i];
|
2005-04-12 01:55:38 +00:00
|
|
|
struct stat st;
|
2005-09-19 22:11:15 +00:00
|
|
|
int err;
|
2017-06-22 18:43:48 +00:00
|
|
|
|
|
|
|
construct_fullname(&fullname, repo, ce);
|
|
|
|
|
2012-06-01 18:28:00 +00:00
|
|
|
if ((dir->flags & DIR_SHOW_IGNORED) &&
|
2017-06-22 18:43:48 +00:00
|
|
|
!ce_excluded(dir, repo->index, fullname.buf, ce))
|
ls-files: unbreak "ls-files -i"
Commit b5227d8 changed the behavior of "ls-files" with
respect to includes, but accidentally broke the "-i" option
The original behavior was:
1. if no "-i" is given, cull all results according to --exclude*
2. if "-i" is given, show the inverse of (1)
The broken behavior was:
1. if no "-i" is given:
a. for "-o", cull results according to --exclude*
b. for index files, always show all
2. if "-i" is given:
a. for "-o", shows the inverse of (1a)
b. for index files, always show all
The fixed behavior keeps the new (1b) behavior introduced
by b5227d8, but fixes the (2b) behavior to show only ignored
files, not all files.
This patch also tweaks the documentation. The original text
was somewhat obscure in the first place, but it is also now
inaccurate (the relationship between (1b) and (2b) is not
quite a "reverse").
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-10-30 19:05:52 +00:00
|
|
|
continue;
|
2008-11-16 08:10:25 +00:00
|
|
|
if (ce->ce_flags & CE_UPDATE)
|
|
|
|
continue;
|
2009-08-20 13:46:58 +00:00
|
|
|
if (ce_skip_worktree(ce))
|
|
|
|
continue;
|
2017-06-22 18:43:48 +00:00
|
|
|
err = lstat(fullname.buf, &st);
|
2005-09-19 22:11:15 +00:00
|
|
|
if (show_deleted && err)
|
2017-06-22 18:43:48 +00:00
|
|
|
show_ce(repo, dir, ce, fullname.buf, tag_removed);
|
|
|
|
if (show_modified && ie_modified(repo->index, ce, &st, 0))
|
|
|
|
show_ce(repo, dir, ce, fullname.buf, tag_modified);
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
}
|
|
|
|
}
|
2017-06-22 18:43:48 +00:00
|
|
|
|
|
|
|
strbuf_release(&fullname);
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Prune the index to only contain stuff starting with "prefix"
|
|
|
|
*/
|
2017-06-12 22:14:04 +00:00
|
|
|
static void prune_index(struct index_state *istate,
|
|
|
|
const char *prefix, size_t prefixlen)
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
{
|
2017-02-10 19:42:28 +00:00
|
|
|
int pos;
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
unsigned int first, last;
|
|
|
|
|
2017-07-16 11:16:01 +00:00
|
|
|
if (!prefix || !istate->cache_nr)
|
2017-02-10 19:42:28 +00:00
|
|
|
return;
|
2017-06-12 22:14:04 +00:00
|
|
|
pos = index_name_pos(istate, prefix, prefixlen);
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
if (pos < 0)
|
|
|
|
pos = -pos-1;
|
2017-02-10 20:03:30 +00:00
|
|
|
first = pos;
|
2017-06-12 22:14:04 +00:00
|
|
|
last = istate->cache_nr;
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
while (last > first) {
|
|
|
|
int next = (last + first) >> 1;
|
2017-06-12 22:14:04 +00:00
|
|
|
const struct cache_entry *ce = istate->cache[next];
|
2017-02-10 19:42:28 +00:00
|
|
|
if (!strncmp(ce->name, prefix, prefixlen)) {
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
first = next+1;
|
|
|
|
continue;
|
2005-04-12 01:55:38 +00:00
|
|
|
}
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
last = next;
|
|
|
|
}
|
2017-07-15 20:00:45 +00:00
|
|
|
MOVE_ARRAY(istate->cache, istate->cache + pos, last - pos);
|
2017-06-12 22:14:04 +00:00
|
|
|
istate->cache_nr = last - pos;
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
}
|
|
|
|
|
2017-05-11 22:04:25 +00:00
|
|
|
static int get_common_prefix_len(const char *common_prefix)
|
|
|
|
{
|
|
|
|
int common_prefix_len;
|
|
|
|
|
|
|
|
if (!common_prefix)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
common_prefix_len = strlen(common_prefix);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the prefix has a trailing slash, strip it so that submodules wont
|
|
|
|
* be pruned from the index.
|
|
|
|
*/
|
|
|
|
if (common_prefix[common_prefix_len - 1] == '/')
|
|
|
|
common_prefix_len--;
|
|
|
|
|
|
|
|
return common_prefix_len;
|
|
|
|
}
|
|
|
|
|
2007-09-12 23:04:22 +00:00
|
|
|
/*
|
|
|
|
* Read the tree specified with --with-tree option
|
|
|
|
* (typically, HEAD) into stage #1 and then
|
|
|
|
* squash them down to stage #0. This is used for
|
|
|
|
* --error-unmatch to list and check the path patterns
|
|
|
|
* that were given from the command line. We are not
|
|
|
|
* going to write this index out.
|
|
|
|
*/
|
2017-06-12 22:13:58 +00:00
|
|
|
void overlay_tree_on_index(struct index_state *istate,
|
|
|
|
const char *tree_name, const char *prefix)
|
2007-09-12 23:04:22 +00:00
|
|
|
{
|
|
|
|
struct tree *tree;
|
2017-05-06 22:10:31 +00:00
|
|
|
struct object_id oid;
|
2011-03-25 09:34:19 +00:00
|
|
|
struct pathspec pathspec;
|
2007-09-12 23:04:22 +00:00
|
|
|
struct cache_entry *last_stage0 = NULL;
|
|
|
|
int i;
|
|
|
|
|
2017-05-06 22:10:31 +00:00
|
|
|
if (get_oid(tree_name, &oid))
|
2007-09-12 23:04:22 +00:00
|
|
|
die("tree-ish %s not found.", tree_name);
|
2017-05-06 22:10:37 +00:00
|
|
|
tree = parse_tree_indirect(&oid);
|
2007-09-12 23:04:22 +00:00
|
|
|
if (!tree)
|
|
|
|
die("bad tree-ish %s", tree_name);
|
|
|
|
|
|
|
|
/* Hoist the unmerged entries up to stage #3 to make room */
|
2017-06-12 22:13:58 +00:00
|
|
|
for (i = 0; i < istate->cache_nr; i++) {
|
|
|
|
struct cache_entry *ce = istate->cache[i];
|
2007-09-12 23:04:22 +00:00
|
|
|
if (!ce_stage(ce))
|
|
|
|
continue;
|
2008-01-15 00:03:17 +00:00
|
|
|
ce->ce_flags |= CE_STAGEMASK;
|
2007-09-12 23:04:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (prefix) {
|
2013-07-14 08:35:59 +00:00
|
|
|
static const char *(matchbuf[1]);
|
|
|
|
matchbuf[0] = NULL;
|
|
|
|
parse_pathspec(&pathspec, PATHSPEC_ALL_MAGIC,
|
|
|
|
PATHSPEC_PREFER_CWD, prefix, matchbuf);
|
2007-09-12 23:04:22 +00:00
|
|
|
} else
|
2013-07-14 08:35:59 +00:00
|
|
|
memset(&pathspec, 0, sizeof(pathspec));
|
2017-06-12 22:13:58 +00:00
|
|
|
if (read_tree(tree, 1, &pathspec, istate))
|
2007-09-12 23:04:22 +00:00
|
|
|
die("unable to read tree entries %s", tree_name);
|
|
|
|
|
2017-06-12 22:13:58 +00:00
|
|
|
for (i = 0; i < istate->cache_nr; i++) {
|
|
|
|
struct cache_entry *ce = istate->cache[i];
|
2007-09-12 23:04:22 +00:00
|
|
|
switch (ce_stage(ce)) {
|
|
|
|
case 0:
|
|
|
|
last_stage0 = ce;
|
|
|
|
/* fallthru */
|
|
|
|
default:
|
|
|
|
continue;
|
|
|
|
case 1:
|
|
|
|
/*
|
|
|
|
* If there is stage #0 entry for this, we do not
|
|
|
|
* need to show it. We use CE_UPDATE bit to mark
|
|
|
|
* such an entry.
|
|
|
|
*/
|
|
|
|
if (last_stage0 &&
|
|
|
|
!strcmp(last_stage0->name, ce->name))
|
2008-01-15 00:03:17 +00:00
|
|
|
ce->ce_flags |= CE_UPDATE;
|
2007-09-12 23:04:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-17 14:27:11 +00:00
|
|
|
static const char * const ls_files_usage[] = {
|
2015-01-13 07:44:47 +00:00
|
|
|
N_("git ls-files [<options>] [<file>...]"),
|
2009-02-17 14:27:11 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static int option_parse_exclude(const struct option *opt,
|
|
|
|
const char *arg, int unset)
|
|
|
|
{
|
2013-01-16 13:25:58 +00:00
|
|
|
struct string_list *exclude_list = opt->value;
|
2009-02-17 14:27:11 +00:00
|
|
|
|
|
|
|
exc_given = 1;
|
2013-01-16 13:25:58 +00:00
|
|
|
string_list_append(exclude_list, arg);
|
2009-02-17 14:27:11 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int option_parse_exclude_from(const struct option *opt,
|
|
|
|
const char *arg, int unset)
|
|
|
|
{
|
|
|
|
struct dir_struct *dir = opt->value;
|
|
|
|
|
|
|
|
exc_given = 1;
|
|
|
|
add_excludes_from_file(dir, arg);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int option_parse_exclude_standard(const struct option *opt,
|
|
|
|
const char *arg, int unset)
|
|
|
|
{
|
|
|
|
struct dir_struct *dir = opt->value;
|
|
|
|
|
|
|
|
exc_given = 1;
|
|
|
|
setup_standard_excludes(dir);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-28 22:06:25 +00:00
|
|
|
|
2010-06-03 13:39:18 +00:00
|
|
|
int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
|
2005-04-12 01:55:38 +00:00
|
|
|
{
|
2013-01-16 13:25:58 +00:00
|
|
|
int require_work_tree = 0, show_tag = 0, i;
|
2010-06-03 13:39:18 +00:00
|
|
|
const char *max_prefix;
|
2006-05-17 02:02:14 +00:00
|
|
|
struct dir_struct dir;
|
2013-01-16 13:25:58 +00:00
|
|
|
struct exclude_list *el;
|
|
|
|
struct string_list exclude_list = STRING_LIST_INIT_NODUP;
|
2009-02-17 14:27:11 +00:00
|
|
|
struct option builtin_ls_files_options[] = {
|
2016-01-31 11:35:46 +00:00
|
|
|
/* Think twice before adding "--nul" synonym to this */
|
|
|
|
OPT_SET_INT('z', NULL, &line_terminator,
|
|
|
|
N_("paths are separated with NUL character"), '\0'),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('t', NULL, &show_tag,
|
2012-08-20 12:32:20 +00:00
|
|
|
N_("identify the file status with tags")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('v', NULL, &show_valid_bit,
|
2012-08-20 12:32:20 +00:00
|
|
|
N_("use lowercase letters for 'assume unchanged' files")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('c', "cached", &show_cached,
|
2012-08-20 12:32:20 +00:00
|
|
|
N_("show cached files in the output (default)")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('d', "deleted", &show_deleted,
|
2012-08-20 12:32:20 +00:00
|
|
|
N_("show deleted files in the output")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('m', "modified", &show_modified,
|
2012-08-20 12:32:20 +00:00
|
|
|
N_("show modified files in the output")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('o', "others", &show_others,
|
2012-08-20 12:32:20 +00:00
|
|
|
N_("show other files in the output")),
|
2009-02-17 14:27:11 +00:00
|
|
|
OPT_BIT('i', "ignored", &dir.flags,
|
2012-08-20 12:32:20 +00:00
|
|
|
N_("show ignored files in the output"),
|
2009-02-17 14:27:11 +00:00
|
|
|
DIR_SHOW_IGNORED),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('s', "stage", &show_stage,
|
2012-08-20 12:32:20 +00:00
|
|
|
N_("show staged contents' object name in the output")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('k', "killed", &show_killed,
|
2012-08-20 12:32:20 +00:00
|
|
|
N_("show files on the filesystem that need to be removed")),
|
2009-02-17 14:27:11 +00:00
|
|
|
OPT_BIT(0, "directory", &dir.flags,
|
2014-08-30 19:56:01 +00:00
|
|
|
N_("show 'other' directories' names only"),
|
2009-02-17 14:27:11 +00:00
|
|
|
DIR_SHOW_OTHER_DIRECTORIES),
|
2016-01-16 06:50:02 +00:00
|
|
|
OPT_BOOL(0, "eol", &show_eol, N_("show line endings of files")),
|
2009-05-08 05:01:17 +00:00
|
|
|
OPT_NEGBIT(0, "empty-directory", &dir.flags,
|
2012-08-20 12:32:20 +00:00
|
|
|
N_("don't show empty directories"),
|
2009-02-17 14:27:11 +00:00
|
|
|
DIR_HIDE_EMPTY_DIRECTORIES),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('u', "unmerged", &show_unmerged,
|
2012-08-20 12:32:20 +00:00
|
|
|
N_("show unmerged files in the output")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL(0, "resolve-undo", &show_resolve_undo,
|
2012-08-20 12:32:20 +00:00
|
|
|
N_("show resolve-undo information")),
|
2013-01-24 05:19:10 +00:00
|
|
|
{ OPTION_CALLBACK, 'x', "exclude", &exclude_list, N_("pattern"),
|
2012-08-20 12:32:20 +00:00
|
|
|
N_("skip files matching pattern"),
|
2009-02-17 14:27:11 +00:00
|
|
|
0, option_parse_exclude },
|
2012-08-20 12:32:20 +00:00
|
|
|
{ OPTION_CALLBACK, 'X', "exclude-from", &dir, N_("file"),
|
|
|
|
N_("exclude patterns are read from <file>"),
|
2009-02-17 14:27:11 +00:00
|
|
|
0, option_parse_exclude_from },
|
2012-08-20 12:32:20 +00:00
|
|
|
OPT_STRING(0, "exclude-per-directory", &dir.exclude_per_dir, N_("file"),
|
|
|
|
N_("read additional per-directory exclude patterns in <file>")),
|
2009-02-17 14:27:11 +00:00
|
|
|
{ OPTION_CALLBACK, 0, "exclude-standard", &dir, NULL,
|
2012-08-20 12:32:20 +00:00
|
|
|
N_("add the standard git exclusions"),
|
2009-02-17 14:27:11 +00:00
|
|
|
PARSE_OPT_NOARG, option_parse_exclude_standard },
|
2010-06-03 13:39:18 +00:00
|
|
|
{ OPTION_SET_INT, 0, "full-name", &prefix_len, NULL,
|
2012-08-20 12:32:20 +00:00
|
|
|
N_("make the output relative to the project top directory"),
|
2009-02-17 14:27:11 +00:00
|
|
|
PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL },
|
2016-10-07 18:18:49 +00:00
|
|
|
OPT_BOOL(0, "recurse-submodules", &recurse_submodules,
|
|
|
|
N_("recurse through submodules")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL(0, "error-unmatch", &error_unmatch,
|
2012-08-20 12:32:20 +00:00
|
|
|
N_("if any <file> is not in the index, treat this as an error")),
|
|
|
|
OPT_STRING(0, "with-tree", &with_tree, N_("tree-ish"),
|
|
|
|
N_("pretend that paths removed since <tree-ish> are still present")),
|
2009-02-17 14:27:11 +00:00
|
|
|
OPT__ABBREV(&abbrev),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL(0, "debug", &debug_mode, N_("show debugging data")),
|
2009-02-17 14:27:11 +00:00
|
|
|
OPT_END()
|
|
|
|
};
|
2005-04-12 01:55:38 +00:00
|
|
|
|
2010-10-22 06:48:14 +00:00
|
|
|
if (argc == 2 && !strcmp(argv[1], "-h"))
|
|
|
|
usage_with_options(ls_files_usage, builtin_ls_files_options);
|
|
|
|
|
2006-05-17 02:02:14 +00:00
|
|
|
memset(&dir, 0, sizeof(dir));
|
2010-06-03 13:39:18 +00:00
|
|
|
prefix = cmd_prefix;
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
if (prefix)
|
2010-06-03 13:39:18 +00:00
|
|
|
prefix_len = strlen(prefix);
|
2008-05-14 17:46:53 +00:00
|
|
|
git_config(git_default_config, NULL);
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
|
2017-06-22 18:43:48 +00:00
|
|
|
if (repo_read_index(the_repository) < 0)
|
2009-08-20 13:47:01 +00:00
|
|
|
die("index file corrupt");
|
|
|
|
|
2009-05-23 18:53:12 +00:00
|
|
|
argc = parse_options(argc, argv, prefix, builtin_ls_files_options,
|
2009-02-17 14:27:11 +00:00
|
|
|
ls_files_usage, 0);
|
2013-01-16 13:25:58 +00:00
|
|
|
el = add_exclude_list(&dir, EXC_CMDL, "--exclude option");
|
|
|
|
for (i = 0; i < exclude_list.nr; i++) {
|
|
|
|
add_exclude(exclude_list.items[i].string, "", 0, el, --exclude_args);
|
|
|
|
}
|
2009-02-17 14:27:11 +00:00
|
|
|
if (show_tag || show_valid_bit) {
|
|
|
|
tag_cached = "H ";
|
|
|
|
tag_unmerged = "M ";
|
|
|
|
tag_removed = "R ";
|
|
|
|
tag_modified = "C ";
|
|
|
|
tag_other = "? ";
|
|
|
|
tag_killed = "K ";
|
2009-08-20 13:46:57 +00:00
|
|
|
tag_skip_worktree = "S ";
|
2009-12-25 18:08:04 +00:00
|
|
|
tag_resolve_undo = "U ";
|
2005-04-28 18:44:04 +00:00
|
|
|
}
|
2009-03-20 21:30:51 +00:00
|
|
|
if (show_modified || show_others || show_deleted || (dir.flags & DIR_SHOW_IGNORED) || show_killed)
|
2009-02-17 14:27:11 +00:00
|
|
|
require_work_tree = 1;
|
|
|
|
if (show_unmerged)
|
|
|
|
/*
|
|
|
|
* There's no point in showing unmerged unless
|
|
|
|
* you also show the stage information.
|
|
|
|
*/
|
|
|
|
show_stage = 1;
|
|
|
|
if (dir.exclude_per_dir)
|
|
|
|
exc_given = 1;
|
2005-04-28 18:44:04 +00:00
|
|
|
|
2007-11-03 11:23:12 +00:00
|
|
|
if (require_work_tree && !is_inside_work_tree())
|
|
|
|
setup_work_tree();
|
2007-01-23 12:30:20 +00:00
|
|
|
|
2016-10-07 18:18:50 +00:00
|
|
|
if (recurse_submodules)
|
2017-06-22 18:43:48 +00:00
|
|
|
repo_read_gitmodules(the_repository);
|
2016-10-07 18:18:50 +00:00
|
|
|
|
2016-10-07 18:18:49 +00:00
|
|
|
if (recurse_submodules &&
|
|
|
|
(show_stage || show_deleted || show_others || show_unmerged ||
|
2016-10-07 18:18:50 +00:00
|
|
|
show_killed || show_modified || show_resolve_undo || with_tree))
|
2016-10-07 18:18:49 +00:00
|
|
|
die("ls-files --recurse-submodules unsupported mode");
|
|
|
|
|
|
|
|
if (recurse_submodules && error_unmatch)
|
|
|
|
die("ls-files --recurse-submodules does not support "
|
|
|
|
"--error-unmatch");
|
|
|
|
|
2013-07-14 08:35:43 +00:00
|
|
|
parse_pathspec(&pathspec, 0,
|
2017-05-11 22:04:25 +00:00
|
|
|
PATHSPEC_PREFER_CWD,
|
2013-07-14 08:35:43 +00:00
|
|
|
prefix, argv);
|
2009-02-07 13:43:03 +00:00
|
|
|
|
2016-10-07 18:18:51 +00:00
|
|
|
/*
|
|
|
|
* Find common prefix for all pathspec's
|
|
|
|
* This is used as a performance optimization which unfortunately cannot
|
2017-06-22 18:43:48 +00:00
|
|
|
* be done when recursing into submodules because when a pathspec is
|
|
|
|
* given which spans repository boundaries you can't simply remove the
|
|
|
|
* submodule entry because the pathspec may match something inside the
|
|
|
|
* submodule.
|
2016-10-07 18:18:51 +00:00
|
|
|
*/
|
|
|
|
if (recurse_submodules)
|
|
|
|
max_prefix = NULL;
|
|
|
|
else
|
|
|
|
max_prefix = common_prefix(&pathspec);
|
2017-05-11 22:04:25 +00:00
|
|
|
max_prefix_len = get_common_prefix_len(max_prefix);
|
|
|
|
|
2017-06-22 18:43:48 +00:00
|
|
|
prune_index(the_repository->index, max_prefix, max_prefix_len);
|
[PATCH] Make "git-ls-files" work in subdirectories
This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do
cd arch/i386
git-ls-files
and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).
The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).
The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.
For example, when doing
git-ls-files 'arch/i386/p*/*.c'
the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.
This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.
For example:
git-ls-files 'arch/i386/*.[ch]'
will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).
Also, while
git-ls-files arch/i386/
will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.
These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do
git-ls-files fs/*.c | xargs grep some_pattern
and it does what you want.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-21 19:55:33 +00:00
|
|
|
|
2006-02-14 20:40:20 +00:00
|
|
|
/* Treat unmatching pathspec elements as errors */
|
2013-07-14 08:35:43 +00:00
|
|
|
if (pathspec.nr && error_unmatch)
|
2015-08-20 16:57:32 +00:00
|
|
|
ps_matched = xcalloc(pathspec.nr, 1);
|
2006-02-14 20:40:20 +00:00
|
|
|
|
2009-10-09 01:53:35 +00:00
|
|
|
if ((dir.flags & DIR_SHOW_IGNORED) && !exc_given)
|
|
|
|
die("ls-files --ignored needs some exclude pattern");
|
2005-04-12 01:55:38 +00:00
|
|
|
|
|
|
|
/* With no flags, we default to showing the cached files */
|
2013-06-13 18:19:44 +00:00
|
|
|
if (!(show_stage || show_deleted || show_others || show_unmerged ||
|
|
|
|
show_killed || show_modified || show_resolve_undo))
|
2005-04-12 01:55:38 +00:00
|
|
|
show_cached = 1;
|
|
|
|
|
2007-09-12 23:04:22 +00:00
|
|
|
if (with_tree) {
|
|
|
|
/*
|
|
|
|
* Basic sanity check; show-stages and show-unmerged
|
|
|
|
* would not make any sense with this option.
|
|
|
|
*/
|
|
|
|
if (show_stage || show_unmerged)
|
|
|
|
die("ls-files --with-tree is incompatible with -s or -u");
|
2017-06-22 18:43:48 +00:00
|
|
|
overlay_tree_on_index(the_repository->index, with_tree, max_prefix);
|
2007-09-12 23:04:22 +00:00
|
|
|
}
|
2017-06-22 18:43:48 +00:00
|
|
|
|
|
|
|
show_files(the_repository, &dir);
|
|
|
|
|
2009-12-25 18:08:04 +00:00
|
|
|
if (show_resolve_undo)
|
2017-06-22 18:43:48 +00:00
|
|
|
show_ru_info(the_repository->index);
|
2006-02-14 20:40:20 +00:00
|
|
|
|
|
|
|
if (ps_matched) {
|
2007-11-18 09:13:32 +00:00
|
|
|
int bad;
|
2013-07-14 08:35:53 +00:00
|
|
|
bad = report_path_error(ps_matched, &pathspec, prefix);
|
2007-11-18 09:13:32 +00:00
|
|
|
if (bad)
|
2006-11-30 11:28:28 +00:00
|
|
|
fprintf(stderr, "Did you forget to 'git add'?\n");
|
|
|
|
|
2007-11-18 09:13:32 +00:00
|
|
|
return bad ? 1 : 0;
|
2006-02-14 20:40:20 +00:00
|
|
|
}
|
|
|
|
|
2005-04-12 01:55:38 +00:00
|
|
|
return 0;
|
|
|
|
}
|