2005-04-12 05:55:38 +04: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
|
|
|
|
|
*/
|
|
|
|
|
#include "cache.h"
|
2005-10-15 08:56:46 +04:00
|
|
|
#include "quote.h"
|
2006-05-17 06:02:14 +04:00
|
|
|
#include "dir.h"
|
2006-05-23 16:15:29 +04:00
|
|
|
#include "builtin.h"
|
2007-09-13 03:04:22 +04:00
|
|
|
#include "tree.h"
|
2009-02-17 17:27:11 +03:00
|
|
|
#include "parse-options.h"
|
2005-04-12 05:55:38 +04:00
|
|
|
|
2006-08-15 21:23:48 +04:00
|
|
|
static int abbrev;
|
|
|
|
|
static int show_deleted;
|
|
|
|
|
static int show_cached;
|
|
|
|
|
static int show_others;
|
|
|
|
|
static int show_stage;
|
|
|
|
|
static int show_unmerged;
|
|
|
|
|
static int show_modified;
|
|
|
|
|
static int show_killed;
|
|
|
|
|
static int show_valid_bit;
|
2005-04-15 22:11:01 +04:00
|
|
|
static int line_terminator = '\n';
|
2005-04-12 05:55:38 +04:00
|
|
|
|
2006-08-15 21:23:48 +04:00
|
|
|
static int prefix_len;
|
|
|
|
|
static int prefix_offset;
|
|
|
|
|
static const char **pathspec;
|
|
|
|
|
static int error_unmatch;
|
|
|
|
|
static char *ps_matched;
|
2007-09-13 03:04:22 +04:00
|
|
|
static const char *with_tree;
|
2009-02-17 17:27:11 +03:00
|
|
|
static int exc_given;
|
[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 23:55:33 +04:00
|
|
|
|
2005-04-22 06:47:08 +04:00
|
|
|
static const char *tag_cached = "";
|
|
|
|
|
static const char *tag_unmerged = "";
|
|
|
|
|
static const char *tag_removed = "";
|
|
|
|
|
static const char *tag_other = "";
|
2005-05-13 04:17:54 +04:00
|
|
|
static const char *tag_killed = "";
|
2005-09-20 02:11:15 +04:00
|
|
|
static const char *tag_modified = "";
|
2009-08-20 17:46:57 +04:00
|
|
|
static const char *tag_skip_worktree = "";
|
2005-04-22 06:47:08 +04:00
|
|
|
|
2006-05-17 06:02:14 +04: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 23:55:33 +04:00
|
|
|
{
|
|
|
|
|
int len = prefix_len;
|
|
|
|
|
int offset = prefix_offset;
|
|
|
|
|
|
|
|
|
|
if (len >= ent->len)
|
2008-08-31 20:39:19 +04: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 23:55:33 +04:00
|
|
|
|
2009-01-14 17:54:35 +03:00
|
|
|
if (!match_pathspec(pathspec, ent->name, ent->len, 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 23:55:33 +04:00
|
|
|
return;
|
|
|
|
|
|
2005-10-15 08:56:46 +04:00
|
|
|
fputs(tag, stdout);
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 02:42:15 +04:00
|
|
|
write_name_quoted(ent->name + offset, stdout, line_terminator);
|
[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 23:55:33 +04:00
|
|
|
}
|
|
|
|
|
|
2006-05-17 06:02:14 +04:00
|
|
|
static void show_other_files(struct dir_struct *dir)
|
2005-11-07 04:26:31 +03:00
|
|
|
{
|
|
|
|
|
int i;
|
2007-04-15 03:22:08 +04:00
|
|
|
|
2006-05-17 06:02:14 +04:00
|
|
|
for (i = 0; i < dir->nr; i++) {
|
|
|
|
|
struct dir_entry *ent = dir->entries[i];
|
2008-10-16 19:07:26 +04:00
|
|
|
if (!cache_name_is_other(ent->name, ent->len))
|
|
|
|
|
continue;
|
2005-11-07 04:26:31 +03:00
|
|
|
show_dir_entry(tag_other, ent);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-05-17 06:02:14 +04:00
|
|
|
static void show_killed_files(struct dir_struct *dir)
|
2005-05-13 04:17:54 +04:00
|
|
|
{
|
|
|
|
|
int i;
|
2006-05-17 06:02:14 +04:00
|
|
|
for (i = 0; i < dir->nr; i++) {
|
|
|
|
|
struct dir_entry *ent = dir->entries[i];
|
2005-05-13 04:17:54 +04: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.
|
|
|
|
|
*/
|
|
|
|
|
pos = cache_name_pos(ent->name, ent->len);
|
|
|
|
|
if (0 <= pos)
|
|
|
|
|
die("bug in show-killed-files");
|
|
|
|
|
pos = -pos - 1;
|
|
|
|
|
while (pos < active_nr &&
|
|
|
|
|
ce_stage(active_cache[pos]))
|
|
|
|
|
pos++; /* skip unmerged */
|
|
|
|
|
if (active_nr <= pos)
|
|
|
|
|
break;
|
|
|
|
|
/* pos points at a name immediately after
|
|
|
|
|
* ent->name in the cache. Does it expect
|
|
|
|
|
* ent->name to be a directory?
|
|
|
|
|
*/
|
|
|
|
|
len = ce_namelen(active_cache[pos]);
|
|
|
|
|
if ((ent->len < len) &&
|
|
|
|
|
!strncmp(active_cache[pos]->name,
|
|
|
|
|
ent->name, ent->len) &&
|
|
|
|
|
active_cache[pos]->name[ent->len] == '/')
|
|
|
|
|
killed = 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (0 <= cache_name_pos(ent->name, sp - ent->name)) {
|
|
|
|
|
/* 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 06:02:14 +04:00
|
|
|
show_dir_entry(tag_killed, dir->entries[i]);
|
2005-05-13 04:17:54 +04:00
|
|
|
}
|
2005-04-12 05:55:38 +04: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 23:55:33 +04:00
|
|
|
static void show_ce_entry(const char *tag, struct cache_entry *ce)
|
|
|
|
|
{
|
|
|
|
|
int len = prefix_len;
|
|
|
|
|
int offset = prefix_offset;
|
|
|
|
|
|
|
|
|
|
if (len >= ce_namelen(ce))
|
2008-08-31 20:39:19 +04: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 23:55:33 +04:00
|
|
|
|
2009-01-14 17:54:35 +03:00
|
|
|
if (!match_pathspec(pathspec, ce->name, ce_namelen(ce), 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 23:55:33 +04:00
|
|
|
return;
|
|
|
|
|
|
2006-02-12 12:47:57 +03:00
|
|
|
if (tag && *tag && show_valid_bit &&
|
2008-01-15 03:03:17 +03:00
|
|
|
(ce->ce_flags & CE_VALID)) {
|
2006-02-09 08:50:18 +03:00
|
|
|
static char alttag[4];
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2005-10-15 08:56:46 +04:00
|
|
|
if (!show_stage) {
|
|
|
|
|
fputs(tag, stdout);
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 02:42:15 +04:00
|
|
|
} else {
|
2005-10-15 08:56:46 +04:00
|
|
|
printf("%s%06o %s %d\t",
|
[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 23:55:33 +04:00
|
|
|
tag,
|
2008-01-15 03:03:17 +03:00
|
|
|
ce->ce_mode,
|
2006-03-07 22:59:17 +03:00
|
|
|
abbrev ? find_unique_abbrev(ce->sha1,abbrev)
|
|
|
|
|
: sha1_to_hex(ce->sha1),
|
2005-10-15 08:56:46 +04:00
|
|
|
ce_stage(ce));
|
|
|
|
|
}
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 02:42:15 +04:00
|
|
|
write_name_quoted(ce->name + offset, stdout, line_terminator);
|
[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 23:55:33 +04:00
|
|
|
}
|
|
|
|
|
|
2006-08-01 00:13:55 +04:00
|
|
|
static void show_files(struct dir_struct *dir, const char *prefix)
|
2005-04-12 05:55:38 +04:00
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
/* For cached/deleted files we don't need to even do the readdir */
|
2005-05-13 04:17:54 +04:00
|
|
|
if (show_others || show_killed) {
|
2009-05-15 00:22:36 +04:00
|
|
|
fill_directory(dir, pathspec);
|
2005-05-13 04:17:54 +04:00
|
|
|
if (show_others)
|
2006-05-17 06:02:14 +04:00
|
|
|
show_other_files(dir);
|
2005-05-13 04:17:54 +04:00
|
|
|
if (show_killed)
|
2006-05-17 06:02:14 +04:00
|
|
|
show_killed_files(dir);
|
2005-04-12 05:55:38 +04:00
|
|
|
}
|
2005-04-16 19:33:23 +04:00
|
|
|
if (show_cached | show_stage) {
|
2005-04-12 05:55:38 +04:00
|
|
|
for (i = 0; i < active_nr; i++) {
|
|
|
|
|
struct cache_entry *ce = active_cache[i];
|
2008-02-01 07:23:25 +03:00
|
|
|
int dtype = ce_to_dtype(ce);
|
2009-02-16 15:20:25 +03:00
|
|
|
if (excluded(dir, ce->name, &dtype) !=
|
|
|
|
|
!!(dir->flags & DIR_SHOW_IGNORED))
|
2005-04-28 22:44:04 +04:00
|
|
|
continue;
|
2005-04-16 23:43:32 +04:00
|
|
|
if (show_unmerged && !ce_stage(ce))
|
|
|
|
|
continue;
|
2008-01-15 03:03:17 +03:00
|
|
|
if (ce->ce_flags & CE_UPDATE)
|
2007-09-13 03:04:22 +04:00
|
|
|
continue;
|
2009-08-20 17:46:57 +04:00
|
|
|
show_ce_entry(ce_stage(ce) ? tag_unmerged :
|
|
|
|
|
(ce_skip_worktree(ce) ? tag_skip_worktree : tag_cached), ce);
|
2005-04-12 05:55:38 +04:00
|
|
|
}
|
|
|
|
|
}
|
2005-09-20 02:11:15 +04:00
|
|
|
if (show_deleted | show_modified) {
|
2005-04-12 05:55:38 +04:00
|
|
|
for (i = 0; i < active_nr; i++) {
|
|
|
|
|
struct cache_entry *ce = active_cache[i];
|
|
|
|
|
struct stat st;
|
2005-09-20 02:11:15 +04:00
|
|
|
int err;
|
2008-02-01 07:23:25 +03:00
|
|
|
int dtype = ce_to_dtype(ce);
|
2009-02-16 15:20:25 +03:00
|
|
|
if (excluded(dir, ce->name, &dtype) !=
|
|
|
|
|
!!(dir->flags & DIR_SHOW_IGNORED))
|
2005-04-28 22:44:04 +04:00
|
|
|
continue;
|
2008-11-16 11:10:25 +03:00
|
|
|
if (ce->ce_flags & CE_UPDATE)
|
|
|
|
|
continue;
|
2005-09-20 02:11:15 +04:00
|
|
|
err = lstat(ce->name, &st);
|
|
|
|
|
if (show_deleted && err)
|
|
|
|
|
show_ce_entry(tag_removed, ce);
|
2006-02-09 08:50:18 +03:00
|
|
|
if (show_modified && ce_modified(ce, &st, 0))
|
2005-09-20 02:11:15 +04:00
|
|
|
show_ce_entry(tag_modified, ce);
|
[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 23:55:33 +04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Prune the index to only contain stuff starting with "prefix"
|
|
|
|
|
*/
|
2006-08-01 00:13:55 +04:00
|
|
|
static void prune_cache(const char *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 23:55:33 +04:00
|
|
|
{
|
|
|
|
|
int pos = cache_name_pos(prefix, prefix_len);
|
|
|
|
|
unsigned int first, last;
|
|
|
|
|
|
|
|
|
|
if (pos < 0)
|
|
|
|
|
pos = -pos-1;
|
2007-10-03 09:44:15 +04:00
|
|
|
memmove(active_cache, active_cache + pos,
|
|
|
|
|
(active_nr - pos) * sizeof(struct cache_entry *));
|
[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 23:55:33 +04:00
|
|
|
active_nr -= pos;
|
|
|
|
|
first = 0;
|
|
|
|
|
last = active_nr;
|
|
|
|
|
while (last > first) {
|
|
|
|
|
int next = (last + first) >> 1;
|
|
|
|
|
struct cache_entry *ce = active_cache[next];
|
|
|
|
|
if (!strncmp(ce->name, prefix, prefix_len)) {
|
|
|
|
|
first = next+1;
|
|
|
|
|
continue;
|
2005-04-12 05:55:38 +04: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 23:55:33 +04:00
|
|
|
last = next;
|
|
|
|
|
}
|
|
|
|
|
active_nr = last;
|
|
|
|
|
}
|
|
|
|
|
|
2006-08-01 00:13:55 +04:00
|
|
|
static const char *verify_pathspec(const char *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 23:55:33 +04:00
|
|
|
{
|
[PATCH] git-ls-files: generalized pathspecs
This generalizes the git "glob" string to be a lot more like the
git-diff-* pathspecs (but there are still differences: the diff family
doesn't do any globbing, and because the diff family always generates the
full native pathname, it doesn't have the issue with "..").
It does three things:
- it allows multiple matching strings, ie you can do things like
git-ls-files arch/i386/ include/asm-i386/ | xargs grep pattern
- the "matching" criteria is a combination of "exact path component
match" (the same as the git-diff-* family), and "fnmatch()". However,
you should be careful with the confusion between the git-ls-files
internal globbing and the standard shell globbing, ie
git-ls-files fs/*.c
does globbing in the shell, and does something totally different from
git-ls-files 'fs/*.c'
which does the globbing inside git-ls-files.
The latter has _one_ pathspec with a wildcard, and will match any .c
file anywhere under the fs/ directory, while the former has been
expanded by the shell into having _lots_ of pathspec entries, all of
which are just in the top-level fs/ subdirectory. They will happily
be matched exactly, but we will thus miss all the subdirectories under
fs/.
As a result, the first one will (on the current kernel) match 55 files,
while the second one will match 664 files!
- it uses the generic path prefixing, so that ".." and friends at the
beginning of the path spec work automatically
NOTE! When generating relative pathname output (the default), a
pathspec that causes the base to be outside the current working
directory will be rejected with an error message like:
fatal: git-ls-files: cannot generate relative filenames containing '..'
because we do not actually generate ".." in the output. However, the
".." format works fine for the --full-name case:
cd arch/i386/kernel
git-ls-files --full-name ../mm/
results in
arch/i386/mm/Makefile
arch/i386/mm/boot_ioremap.c
arch/i386/mm/discontig.c
arch/i386/mm/extable.c
arch/i386/mm/fault.c
arch/i386/mm/highmem.c
arch/i386/mm/hugetlbpage.c
arch/i386/mm/init.c
arch/i386/mm/ioremap.c
arch/i386/mm/mmap.c
arch/i386/mm/pageattr.c
arch/i386/mm/pgtable.c
Perhaps more commonly, the generic path prefixing means that "." and
"./" automatically get simplified and work properly.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-22 04:27:50 +04:00
|
|
|
const char **p, *n, *prev;
|
|
|
|
|
unsigned long max;
|
|
|
|
|
|
|
|
|
|
prev = NULL;
|
|
|
|
|
max = PATH_MAX;
|
|
|
|
|
for (p = pathspec; (n = *p) != NULL; p++) {
|
|
|
|
|
int i, len = 0;
|
|
|
|
|
for (i = 0; i < max; i++) {
|
|
|
|
|
char c = n[i];
|
|
|
|
|
if (prev && prev[i] != c)
|
|
|
|
|
break;
|
2005-08-24 04:14:13 +04:00
|
|
|
if (!c || c == '*' || c == '?')
|
[PATCH] git-ls-files: generalized pathspecs
This generalizes the git "glob" string to be a lot more like the
git-diff-* pathspecs (but there are still differences: the diff family
doesn't do any globbing, and because the diff family always generates the
full native pathname, it doesn't have the issue with "..").
It does three things:
- it allows multiple matching strings, ie you can do things like
git-ls-files arch/i386/ include/asm-i386/ | xargs grep pattern
- the "matching" criteria is a combination of "exact path component
match" (the same as the git-diff-* family), and "fnmatch()". However,
you should be careful with the confusion between the git-ls-files
internal globbing and the standard shell globbing, ie
git-ls-files fs/*.c
does globbing in the shell, and does something totally different from
git-ls-files 'fs/*.c'
which does the globbing inside git-ls-files.
The latter has _one_ pathspec with a wildcard, and will match any .c
file anywhere under the fs/ directory, while the former has been
expanded by the shell into having _lots_ of pathspec entries, all of
which are just in the top-level fs/ subdirectory. They will happily
be matched exactly, but we will thus miss all the subdirectories under
fs/.
As a result, the first one will (on the current kernel) match 55 files,
while the second one will match 664 files!
- it uses the generic path prefixing, so that ".." and friends at the
beginning of the path spec work automatically
NOTE! When generating relative pathname output (the default), a
pathspec that causes the base to be outside the current working
directory will be rejected with an error message like:
fatal: git-ls-files: cannot generate relative filenames containing '..'
because we do not actually generate ".." in the output. However, the
".." format works fine for the --full-name case:
cd arch/i386/kernel
git-ls-files --full-name ../mm/
results in
arch/i386/mm/Makefile
arch/i386/mm/boot_ioremap.c
arch/i386/mm/discontig.c
arch/i386/mm/extable.c
arch/i386/mm/fault.c
arch/i386/mm/highmem.c
arch/i386/mm/hugetlbpage.c
arch/i386/mm/init.c
arch/i386/mm/ioremap.c
arch/i386/mm/mmap.c
arch/i386/mm/pageattr.c
arch/i386/mm/pgtable.c
Perhaps more commonly, the generic path prefixing means that "." and
"./" automatically get simplified and work properly.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-22 04:27:50 +04:00
|
|
|
break;
|
|
|
|
|
if (c == '/')
|
|
|
|
|
len = i+1;
|
|
|
|
|
}
|
|
|
|
|
prev = n;
|
|
|
|
|
if (len < max) {
|
|
|
|
|
max = len;
|
|
|
|
|
if (!max)
|
|
|
|
|
break;
|
|
|
|
|
}
|
[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 23:55:33 +04:00
|
|
|
}
|
[PATCH] git-ls-files: generalized pathspecs
This generalizes the git "glob" string to be a lot more like the
git-diff-* pathspecs (but there are still differences: the diff family
doesn't do any globbing, and because the diff family always generates the
full native pathname, it doesn't have the issue with "..").
It does three things:
- it allows multiple matching strings, ie you can do things like
git-ls-files arch/i386/ include/asm-i386/ | xargs grep pattern
- the "matching" criteria is a combination of "exact path component
match" (the same as the git-diff-* family), and "fnmatch()". However,
you should be careful with the confusion between the git-ls-files
internal globbing and the standard shell globbing, ie
git-ls-files fs/*.c
does globbing in the shell, and does something totally different from
git-ls-files 'fs/*.c'
which does the globbing inside git-ls-files.
The latter has _one_ pathspec with a wildcard, and will match any .c
file anywhere under the fs/ directory, while the former has been
expanded by the shell into having _lots_ of pathspec entries, all of
which are just in the top-level fs/ subdirectory. They will happily
be matched exactly, but we will thus miss all the subdirectories under
fs/.
As a result, the first one will (on the current kernel) match 55 files,
while the second one will match 664 files!
- it uses the generic path prefixing, so that ".." and friends at the
beginning of the path spec work automatically
NOTE! When generating relative pathname output (the default), a
pathspec that causes the base to be outside the current working
directory will be rejected with an error message like:
fatal: git-ls-files: cannot generate relative filenames containing '..'
because we do not actually generate ".." in the output. However, the
".." format works fine for the --full-name case:
cd arch/i386/kernel
git-ls-files --full-name ../mm/
results in
arch/i386/mm/Makefile
arch/i386/mm/boot_ioremap.c
arch/i386/mm/discontig.c
arch/i386/mm/extable.c
arch/i386/mm/fault.c
arch/i386/mm/highmem.c
arch/i386/mm/hugetlbpage.c
arch/i386/mm/init.c
arch/i386/mm/ioremap.c
arch/i386/mm/mmap.c
arch/i386/mm/pageattr.c
arch/i386/mm/pgtable.c
Perhaps more commonly, the generic path prefixing means that "." and
"./" automatically get simplified and work properly.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-22 04:27:50 +04:00
|
|
|
|
|
|
|
|
if (prefix_offset > max || memcmp(prev, prefix, prefix_offset))
|
2008-08-31 20:39:19 +04:00
|
|
|
die("git ls-files: cannot generate relative filenames containing '..'");
|
[PATCH] git-ls-files: generalized pathspecs
This generalizes the git "glob" string to be a lot more like the
git-diff-* pathspecs (but there are still differences: the diff family
doesn't do any globbing, and because the diff family always generates the
full native pathname, it doesn't have the issue with "..").
It does three things:
- it allows multiple matching strings, ie you can do things like
git-ls-files arch/i386/ include/asm-i386/ | xargs grep pattern
- the "matching" criteria is a combination of "exact path component
match" (the same as the git-diff-* family), and "fnmatch()". However,
you should be careful with the confusion between the git-ls-files
internal globbing and the standard shell globbing, ie
git-ls-files fs/*.c
does globbing in the shell, and does something totally different from
git-ls-files 'fs/*.c'
which does the globbing inside git-ls-files.
The latter has _one_ pathspec with a wildcard, and will match any .c
file anywhere under the fs/ directory, while the former has been
expanded by the shell into having _lots_ of pathspec entries, all of
which are just in the top-level fs/ subdirectory. They will happily
be matched exactly, but we will thus miss all the subdirectories under
fs/.
As a result, the first one will (on the current kernel) match 55 files,
while the second one will match 664 files!
- it uses the generic path prefixing, so that ".." and friends at the
beginning of the path spec work automatically
NOTE! When generating relative pathname output (the default), a
pathspec that causes the base to be outside the current working
directory will be rejected with an error message like:
fatal: git-ls-files: cannot generate relative filenames containing '..'
because we do not actually generate ".." in the output. However, the
".." format works fine for the --full-name case:
cd arch/i386/kernel
git-ls-files --full-name ../mm/
results in
arch/i386/mm/Makefile
arch/i386/mm/boot_ioremap.c
arch/i386/mm/discontig.c
arch/i386/mm/extable.c
arch/i386/mm/fault.c
arch/i386/mm/highmem.c
arch/i386/mm/hugetlbpage.c
arch/i386/mm/init.c
arch/i386/mm/ioremap.c
arch/i386/mm/mmap.c
arch/i386/mm/pageattr.c
arch/i386/mm/pgtable.c
Perhaps more commonly, the generic path prefixing means that "." and
"./" automatically get simplified and work properly.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-22 04:27:50 +04:00
|
|
|
|
|
|
|
|
prefix_len = max;
|
2007-09-16 02:32:36 +04:00
|
|
|
return max ? xmemdupz(prev, max) : NULL;
|
2005-04-12 05:55:38 +04:00
|
|
|
}
|
|
|
|
|
|
2009-02-07 16:43:03 +03:00
|
|
|
static void strip_trailing_slash_from_submodules(void)
|
|
|
|
|
{
|
|
|
|
|
const char **p;
|
|
|
|
|
|
|
|
|
|
for (p = pathspec; *p != NULL; p++) {
|
|
|
|
|
int len = strlen(*p), pos;
|
|
|
|
|
|
|
|
|
|
if (len < 1 || (*p)[len - 1] != '/')
|
|
|
|
|
continue;
|
|
|
|
|
pos = cache_name_pos(*p, len - 1);
|
|
|
|
|
if (pos >= 0 && S_ISGITLINK(active_cache[pos]->ce_mode))
|
|
|
|
|
*p = xstrndup(*p, len - 1);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-09-13 03:04:22 +04: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.
|
|
|
|
|
*/
|
2007-11-18 12:13:32 +03:00
|
|
|
void overlay_tree_on_cache(const char *tree_name, const char *prefix)
|
2007-09-13 03:04:22 +04:00
|
|
|
{
|
|
|
|
|
struct tree *tree;
|
|
|
|
|
unsigned char sha1[20];
|
|
|
|
|
const char **match;
|
|
|
|
|
struct cache_entry *last_stage0 = NULL;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (get_sha1(tree_name, sha1))
|
|
|
|
|
die("tree-ish %s not found.", tree_name);
|
|
|
|
|
tree = parse_tree_indirect(sha1);
|
|
|
|
|
if (!tree)
|
|
|
|
|
die("bad tree-ish %s", tree_name);
|
|
|
|
|
|
|
|
|
|
/* Hoist the unmerged entries up to stage #3 to make room */
|
|
|
|
|
for (i = 0; i < active_nr; i++) {
|
|
|
|
|
struct cache_entry *ce = active_cache[i];
|
|
|
|
|
if (!ce_stage(ce))
|
|
|
|
|
continue;
|
2008-01-15 03:03:17 +03:00
|
|
|
ce->ce_flags |= CE_STAGEMASK;
|
2007-09-13 03:04:22 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (prefix) {
|
|
|
|
|
static const char *(matchbuf[2]);
|
|
|
|
|
matchbuf[0] = prefix;
|
2008-11-16 11:15:43 +03:00
|
|
|
matchbuf[1] = NULL;
|
2007-09-13 03:04:22 +04:00
|
|
|
match = matchbuf;
|
|
|
|
|
} else
|
|
|
|
|
match = NULL;
|
|
|
|
|
if (read_tree(tree, 1, match))
|
|
|
|
|
die("unable to read tree entries %s", tree_name);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < active_nr; i++) {
|
|
|
|
|
struct cache_entry *ce = active_cache[i];
|
|
|
|
|
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 03:03:17 +03:00
|
|
|
ce->ce_flags |= CE_UPDATE;
|
2007-09-13 03:04:22 +04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-11-18 12:13:32 +03:00
|
|
|
int report_path_error(const char *ps_matched, const char **pathspec, int prefix_offset)
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* Make sure all pathspec matched; otherwise it is an error.
|
|
|
|
|
*/
|
|
|
|
|
int num, errors = 0;
|
|
|
|
|
for (num = 0; pathspec[num]; num++) {
|
|
|
|
|
int other, found_dup;
|
|
|
|
|
|
|
|
|
|
if (ps_matched[num])
|
|
|
|
|
continue;
|
|
|
|
|
/*
|
|
|
|
|
* The caller might have fed identical pathspec
|
|
|
|
|
* twice. Do not barf on such a mistake.
|
|
|
|
|
*/
|
|
|
|
|
for (found_dup = other = 0;
|
|
|
|
|
!found_dup && pathspec[other];
|
|
|
|
|
other++) {
|
|
|
|
|
if (other == num || !ps_matched[other])
|
|
|
|
|
continue;
|
|
|
|
|
if (!strcmp(pathspec[other], pathspec[num]))
|
|
|
|
|
/*
|
|
|
|
|
* Ok, we have a match already.
|
|
|
|
|
*/
|
|
|
|
|
found_dup = 1;
|
|
|
|
|
}
|
|
|
|
|
if (found_dup)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
error("pathspec '%s' did not match any file(s) known to git.",
|
|
|
|
|
pathspec[num] + prefix_offset);
|
|
|
|
|
errors++;
|
|
|
|
|
}
|
|
|
|
|
return errors;
|
|
|
|
|
}
|
|
|
|
|
|
2009-02-17 17:27:11 +03:00
|
|
|
static const char * const ls_files_usage[] = {
|
|
|
|
|
"git ls-files [options] [<file>]*",
|
|
|
|
|
NULL
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int option_parse_z(const struct option *opt,
|
|
|
|
|
const char *arg, int unset)
|
|
|
|
|
{
|
|
|
|
|
line_terminator = unset ? '\n' : '\0';
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int option_parse_exclude(const struct option *opt,
|
|
|
|
|
const char *arg, int unset)
|
|
|
|
|
{
|
|
|
|
|
struct exclude_list *list = opt->value;
|
|
|
|
|
|
|
|
|
|
exc_given = 1;
|
|
|
|
|
add_exclude(arg, "", 0, list);
|
|
|
|
|
|
|
|
|
|
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-29 02:06:25 +04:00
|
|
|
|
2006-07-29 09:44:25 +04:00
|
|
|
int cmd_ls_files(int argc, const char **argv, const char *prefix)
|
2005-04-12 05:55:38 +04:00
|
|
|
{
|
2009-02-17 17:27:11 +03:00
|
|
|
int require_work_tree = 0, show_tag = 0;
|
2006-05-17 06:02:14 +04:00
|
|
|
struct dir_struct dir;
|
2009-02-17 17:27:11 +03:00
|
|
|
struct option builtin_ls_files_options[] = {
|
|
|
|
|
{ OPTION_CALLBACK, 'z', NULL, NULL, NULL,
|
|
|
|
|
"paths are separated with NUL character",
|
|
|
|
|
PARSE_OPT_NOARG, option_parse_z },
|
|
|
|
|
OPT_BOOLEAN('t', NULL, &show_tag,
|
|
|
|
|
"identify the file status with tags"),
|
|
|
|
|
OPT_BOOLEAN('v', NULL, &show_valid_bit,
|
|
|
|
|
"use lowercase letters for 'assume unchanged' files"),
|
|
|
|
|
OPT_BOOLEAN('c', "cached", &show_cached,
|
|
|
|
|
"show cached files in the output (default)"),
|
|
|
|
|
OPT_BOOLEAN('d', "deleted", &show_deleted,
|
|
|
|
|
"show deleted files in the output"),
|
|
|
|
|
OPT_BOOLEAN('m', "modified", &show_modified,
|
|
|
|
|
"show modified files in the output"),
|
|
|
|
|
OPT_BOOLEAN('o', "others", &show_others,
|
|
|
|
|
"show other files in the output"),
|
|
|
|
|
OPT_BIT('i', "ignored", &dir.flags,
|
|
|
|
|
"show ignored files in the output",
|
|
|
|
|
DIR_SHOW_IGNORED),
|
|
|
|
|
OPT_BOOLEAN('s', "stage", &show_stage,
|
|
|
|
|
"show staged contents' object name in the output"),
|
|
|
|
|
OPT_BOOLEAN('k', "killed", &show_killed,
|
|
|
|
|
"show files on the filesystem that need to be removed"),
|
|
|
|
|
OPT_BIT(0, "directory", &dir.flags,
|
|
|
|
|
"show 'other' directories' name only",
|
|
|
|
|
DIR_SHOW_OTHER_DIRECTORIES),
|
2009-05-08 09:01:17 +04:00
|
|
|
OPT_NEGBIT(0, "empty-directory", &dir.flags,
|
2009-03-08 04:27:22 +03:00
|
|
|
"don't show empty directories",
|
2009-02-17 17:27:11 +03:00
|
|
|
DIR_HIDE_EMPTY_DIRECTORIES),
|
|
|
|
|
OPT_BOOLEAN('u', "unmerged", &show_unmerged,
|
|
|
|
|
"show unmerged files in the output"),
|
|
|
|
|
{ OPTION_CALLBACK, 'x', "exclude", &dir.exclude_list[EXC_CMDL], "pattern",
|
|
|
|
|
"skip files matching pattern",
|
|
|
|
|
0, option_parse_exclude },
|
|
|
|
|
{ OPTION_CALLBACK, 'X', "exclude-from", &dir, "file",
|
|
|
|
|
"exclude patterns are read from <file>",
|
|
|
|
|
0, option_parse_exclude_from },
|
|
|
|
|
OPT_STRING(0, "exclude-per-directory", &dir.exclude_per_dir, "file",
|
|
|
|
|
"read additional per-directory exclude patterns in <file>"),
|
|
|
|
|
{ OPTION_CALLBACK, 0, "exclude-standard", &dir, NULL,
|
|
|
|
|
"add the standard git exclusions",
|
|
|
|
|
PARSE_OPT_NOARG, option_parse_exclude_standard },
|
|
|
|
|
{ OPTION_SET_INT, 0, "full-name", &prefix_offset, NULL,
|
|
|
|
|
"make the output relative to the project top directory",
|
|
|
|
|
PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL },
|
|
|
|
|
OPT_BOOLEAN(0, "error-unmatch", &error_unmatch,
|
|
|
|
|
"if any <file> is not in the index, treat this as an error"),
|
|
|
|
|
OPT_STRING(0, "with-tree", &with_tree, "tree-ish",
|
|
|
|
|
"pretend that paths removed since <tree-ish> are still present"),
|
|
|
|
|
OPT__ABBREV(&abbrev),
|
|
|
|
|
OPT_END()
|
|
|
|
|
};
|
2005-04-12 05:55:38 +04:00
|
|
|
|
2006-05-17 06:02:14 +04:00
|
|
|
memset(&dir, 0, sizeof(dir));
|
[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 23:55:33 +04:00
|
|
|
if (prefix)
|
[PATCH] git-ls-files: generalized pathspecs
This generalizes the git "glob" string to be a lot more like the
git-diff-* pathspecs (but there are still differences: the diff family
doesn't do any globbing, and because the diff family always generates the
full native pathname, it doesn't have the issue with "..").
It does three things:
- it allows multiple matching strings, ie you can do things like
git-ls-files arch/i386/ include/asm-i386/ | xargs grep pattern
- the "matching" criteria is a combination of "exact path component
match" (the same as the git-diff-* family), and "fnmatch()". However,
you should be careful with the confusion between the git-ls-files
internal globbing and the standard shell globbing, ie
git-ls-files fs/*.c
does globbing in the shell, and does something totally different from
git-ls-files 'fs/*.c'
which does the globbing inside git-ls-files.
The latter has _one_ pathspec with a wildcard, and will match any .c
file anywhere under the fs/ directory, while the former has been
expanded by the shell into having _lots_ of pathspec entries, all of
which are just in the top-level fs/ subdirectory. They will happily
be matched exactly, but we will thus miss all the subdirectories under
fs/.
As a result, the first one will (on the current kernel) match 55 files,
while the second one will match 664 files!
- it uses the generic path prefixing, so that ".." and friends at the
beginning of the path spec work automatically
NOTE! When generating relative pathname output (the default), a
pathspec that causes the base to be outside the current working
directory will be rejected with an error message like:
fatal: git-ls-files: cannot generate relative filenames containing '..'
because we do not actually generate ".." in the output. However, the
".." format works fine for the --full-name case:
cd arch/i386/kernel
git-ls-files --full-name ../mm/
results in
arch/i386/mm/Makefile
arch/i386/mm/boot_ioremap.c
arch/i386/mm/discontig.c
arch/i386/mm/extable.c
arch/i386/mm/fault.c
arch/i386/mm/highmem.c
arch/i386/mm/hugetlbpage.c
arch/i386/mm/init.c
arch/i386/mm/ioremap.c
arch/i386/mm/mmap.c
arch/i386/mm/pageattr.c
arch/i386/mm/pgtable.c
Perhaps more commonly, the generic path prefixing means that "." and
"./" automatically get simplified and work properly.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-22 04:27:50 +04:00
|
|
|
prefix_offset = strlen(prefix);
|
2008-05-14 21:46:53 +04: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 23:55:33 +04:00
|
|
|
|
2009-05-23 22:53:12 +04:00
|
|
|
argc = parse_options(argc, argv, prefix, builtin_ls_files_options,
|
2009-02-17 17:27:11 +03:00
|
|
|
ls_files_usage, 0);
|
|
|
|
|
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 17:46:57 +04:00
|
|
|
tag_skip_worktree = "S ";
|
2005-04-28 22:44:04 +04:00
|
|
|
}
|
2009-03-21 00:30:51 +03:00
|
|
|
if (show_modified || show_others || show_deleted || (dir.flags & DIR_SHOW_IGNORED) || show_killed)
|
2009-02-17 17:27:11 +03: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 22:44:04 +04:00
|
|
|
|
2007-11-03 14:23:12 +03:00
|
|
|
if (require_work_tree && !is_inside_work_tree())
|
|
|
|
|
setup_work_tree();
|
2007-01-23 15:30:20 +03:00
|
|
|
|
2009-02-17 17:27:11 +03:00
|
|
|
pathspec = get_pathspec(prefix, argv);
|
[PATCH] git-ls-files: generalized pathspecs
This generalizes the git "glob" string to be a lot more like the
git-diff-* pathspecs (but there are still differences: the diff family
doesn't do any globbing, and because the diff family always generates the
full native pathname, it doesn't have the issue with "..").
It does three things:
- it allows multiple matching strings, ie you can do things like
git-ls-files arch/i386/ include/asm-i386/ | xargs grep pattern
- the "matching" criteria is a combination of "exact path component
match" (the same as the git-diff-* family), and "fnmatch()". However,
you should be careful with the confusion between the git-ls-files
internal globbing and the standard shell globbing, ie
git-ls-files fs/*.c
does globbing in the shell, and does something totally different from
git-ls-files 'fs/*.c'
which does the globbing inside git-ls-files.
The latter has _one_ pathspec with a wildcard, and will match any .c
file anywhere under the fs/ directory, while the former has been
expanded by the shell into having _lots_ of pathspec entries, all of
which are just in the top-level fs/ subdirectory. They will happily
be matched exactly, but we will thus miss all the subdirectories under
fs/.
As a result, the first one will (on the current kernel) match 55 files,
while the second one will match 664 files!
- it uses the generic path prefixing, so that ".." and friends at the
beginning of the path spec work automatically
NOTE! When generating relative pathname output (the default), a
pathspec that causes the base to be outside the current working
directory will be rejected with an error message like:
fatal: git-ls-files: cannot generate relative filenames containing '..'
because we do not actually generate ".." in the output. However, the
".." format works fine for the --full-name case:
cd arch/i386/kernel
git-ls-files --full-name ../mm/
results in
arch/i386/mm/Makefile
arch/i386/mm/boot_ioremap.c
arch/i386/mm/discontig.c
arch/i386/mm/extable.c
arch/i386/mm/fault.c
arch/i386/mm/highmem.c
arch/i386/mm/hugetlbpage.c
arch/i386/mm/init.c
arch/i386/mm/ioremap.c
arch/i386/mm/mmap.c
arch/i386/mm/pageattr.c
arch/i386/mm/pgtable.c
Perhaps more commonly, the generic path prefixing means that "." and
"./" automatically get simplified and work properly.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-22 04:27:50 +04:00
|
|
|
|
2009-04-17 22:13:30 +04:00
|
|
|
/* be nice with submodule paths ending in a slash */
|
2009-02-07 16:43:03 +03:00
|
|
|
read_cache();
|
|
|
|
|
if (pathspec)
|
|
|
|
|
strip_trailing_slash_from_submodules();
|
|
|
|
|
|
[PATCH] git-ls-files: generalized pathspecs
This generalizes the git "glob" string to be a lot more like the
git-diff-* pathspecs (but there are still differences: the diff family
doesn't do any globbing, and because the diff family always generates the
full native pathname, it doesn't have the issue with "..").
It does three things:
- it allows multiple matching strings, ie you can do things like
git-ls-files arch/i386/ include/asm-i386/ | xargs grep pattern
- the "matching" criteria is a combination of "exact path component
match" (the same as the git-diff-* family), and "fnmatch()". However,
you should be careful with the confusion between the git-ls-files
internal globbing and the standard shell globbing, ie
git-ls-files fs/*.c
does globbing in the shell, and does something totally different from
git-ls-files 'fs/*.c'
which does the globbing inside git-ls-files.
The latter has _one_ pathspec with a wildcard, and will match any .c
file anywhere under the fs/ directory, while the former has been
expanded by the shell into having _lots_ of pathspec entries, all of
which are just in the top-level fs/ subdirectory. They will happily
be matched exactly, but we will thus miss all the subdirectories under
fs/.
As a result, the first one will (on the current kernel) match 55 files,
while the second one will match 664 files!
- it uses the generic path prefixing, so that ".." and friends at the
beginning of the path spec work automatically
NOTE! When generating relative pathname output (the default), a
pathspec that causes the base to be outside the current working
directory will be rejected with an error message like:
fatal: git-ls-files: cannot generate relative filenames containing '..'
because we do not actually generate ".." in the output. However, the
".." format works fine for the --full-name case:
cd arch/i386/kernel
git-ls-files --full-name ../mm/
results in
arch/i386/mm/Makefile
arch/i386/mm/boot_ioremap.c
arch/i386/mm/discontig.c
arch/i386/mm/extable.c
arch/i386/mm/fault.c
arch/i386/mm/highmem.c
arch/i386/mm/hugetlbpage.c
arch/i386/mm/init.c
arch/i386/mm/ioremap.c
arch/i386/mm/mmap.c
arch/i386/mm/pageattr.c
arch/i386/mm/pgtable.c
Perhaps more commonly, the generic path prefixing means that "." and
"./" automatically get simplified and work properly.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-08-22 04:27:50 +04:00
|
|
|
/* Verify that the pathspec matches the prefix */
|
2008-03-07 10:50:51 +03:00
|
|
|
if (pathspec)
|
2006-08-01 00:13:55 +04:00
|
|
|
prefix = verify_pathspec(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 23:55:33 +04:00
|
|
|
|
2006-02-14 23:40:20 +03:00
|
|
|
/* Treat unmatching pathspec elements as errors */
|
|
|
|
|
if (pathspec && error_unmatch) {
|
|
|
|
|
int num;
|
|
|
|
|
for (num = 0; pathspec[num]; num++)
|
|
|
|
|
;
|
|
|
|
|
ps_matched = xcalloc(1, num);
|
|
|
|
|
}
|
|
|
|
|
|
2009-02-16 15:20:25 +03:00
|
|
|
if ((dir.flags & DIR_SHOW_IGNORED) && !exc_given) {
|
2005-04-22 06:47:08 +04:00
|
|
|
fprintf(stderr, "%s: --ignored needs some exclude pattern\n",
|
|
|
|
|
argv[0]);
|
2005-04-28 22:44:04 +04:00
|
|
|
exit(1);
|
2005-04-12 05:55:38 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* With no flags, we default to showing the cached files */
|
2005-09-20 02:11:15 +04:00
|
|
|
if (!(show_stage | show_deleted | show_others | show_unmerged |
|
|
|
|
|
show_killed | show_modified))
|
2005-04-12 05:55:38 +04:00
|
|
|
show_cached = 1;
|
|
|
|
|
|
[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 23:55:33 +04:00
|
|
|
if (prefix)
|
2006-08-01 00:13:55 +04:00
|
|
|
prune_cache(prefix);
|
2007-09-13 03:04:22 +04: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");
|
2007-11-18 12:13:32 +03:00
|
|
|
overlay_tree_on_cache(with_tree, prefix);
|
2007-09-13 03:04:22 +04:00
|
|
|
}
|
2006-08-01 00:13:55 +04:00
|
|
|
show_files(&dir, prefix);
|
2006-02-14 23:40:20 +03:00
|
|
|
|
|
|
|
|
if (ps_matched) {
|
2007-11-18 12:13:32 +03:00
|
|
|
int bad;
|
|
|
|
|
bad = report_path_error(ps_matched, pathspec, prefix_offset);
|
|
|
|
|
if (bad)
|
2006-11-30 14:28:28 +03:00
|
|
|
fprintf(stderr, "Did you forget to 'git add'?\n");
|
|
|
|
|
|
2007-11-18 12:13:32 +03:00
|
|
|
return bad ? 1 : 0;
|
2006-02-14 23:40:20 +03:00
|
|
|
}
|
|
|
|
|
|
2005-04-12 05:55:38 +04:00
|
|
|
return 0;
|
|
|
|
|
}
|
