2006-05-17 02:02:14 +00:00
|
|
|
/*
|
|
|
|
* This handles recursive filename detection with exclude
|
|
|
|
* files, index knowledge etc..
|
|
|
|
*
|
|
|
|
* Copyright (C) Linus Torvalds, 2005-2006
|
|
|
|
* Junio Hamano, 2005-2006
|
|
|
|
*/
|
|
|
|
#include "cache.h"
|
|
|
|
#include "dir.h"
|
2007-04-11 21:49:44 +00:00
|
|
|
#include "refs.h"
|
2006-05-17 02:02:14 +00:00
|
|
|
|
Optimize directory listing with pathspec limiter.
The way things are set up, you can now pass a "pathspec" to the
"read_directory()" function. If you pass NULL, it acts exactly
like it used to do (read everything). If you pass a non-NULL
pointer, it will simplify it into a "these are the prefixes
without any special characters", and stop any readdir() early if
the path in question doesn't match any of the prefixes.
NOTE! This does *not* obviate the need for the caller to do the *exact*
pathspec match later. It's a first-level filter on "read_directory()", but
it does not do the full pathspec thing. Maybe it should. But in the
meantime, builtin-add.c really does need to do first
read_directory(dir, .., pathspec);
if (pathspec)
prune_directory(dir, pathspec, baselen);
ie the "prune_directory()" part will do the *exact* pathspec pruning,
while the "read_directory()" will use the pathspec just to do some quick
high-level pruning of the directories it will recurse into.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-03-31 03:39:30 +00:00
|
|
|
struct path_simplify {
|
|
|
|
int len;
|
|
|
|
const char *path;
|
|
|
|
};
|
|
|
|
|
2007-04-11 21:49:44 +00:00
|
|
|
static int read_directory_recursive(struct dir_struct *dir,
|
|
|
|
const char *path, const char *base, int baselen,
|
|
|
|
int check_only, const struct path_simplify *simplify);
|
2008-02-01 04:23:25 +00:00
|
|
|
static int get_dtype(struct dirent *de, const char *path);
|
2007-04-11 21:49:44 +00:00
|
|
|
|
2006-05-19 23:07:51 +00:00
|
|
|
int common_prefix(const char **pathspec)
|
|
|
|
{
|
|
|
|
const char *path, *slash, *next;
|
|
|
|
int prefix;
|
|
|
|
|
|
|
|
if (!pathspec)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
path = *pathspec;
|
|
|
|
slash = strrchr(path, '/');
|
|
|
|
if (!slash)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
prefix = slash - path + 1;
|
|
|
|
while ((next = *++pathspec) != NULL) {
|
|
|
|
int len = strlen(next);
|
2007-04-23 08:21:25 +00:00
|
|
|
if (len >= prefix && !memcmp(path, next, prefix))
|
2006-05-19 23:07:51 +00:00
|
|
|
continue;
|
2007-04-23 08:21:25 +00:00
|
|
|
len = prefix - 1;
|
2006-05-19 23:07:51 +00:00
|
|
|
for (;;) {
|
|
|
|
if (!len)
|
|
|
|
return 0;
|
|
|
|
if (next[--len] != '/')
|
|
|
|
continue;
|
|
|
|
if (memcmp(path, next, len+1))
|
|
|
|
continue;
|
|
|
|
prefix = len + 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return prefix;
|
|
|
|
}
|
|
|
|
|
Optimize match_pathspec() to avoid fnmatch()
"git add *" is actually fundamentally different from "git add .", and
yeah, you should generally use the latter.
The reason? The argument list is actually something different from what
you think it is. For git, it's a "pathspec", so what actualy happens is
that in *both* cases, it will really traverse the whole tree, and then
match every file it finds against the pathspec.
So think of the arguments not as a file list, but as a random bunch of
patterns to match against the files you have!
Which is why the cost is actually approximately O(n*m), where "n" is the
size of the working tree, and "m" is the number of pathspecs.
So the reason "git add ." is fast is actually that "m" in that case is
just 1 (just one trivial pattern), and then "git add *" is slow because
"m" is large (lots of complicated patterns). In both cases, 'n' is the
same (== the whole set of files in your working tree).
Anyway, here's a trivial patch that doesn't change this fundamental fact,
but that avoids doing anything *expensive* until we've done some cheap
initial tests. It may or may not help your test-case, but it's pretty
simple and it matches the other git optimizations in this area (ie
"conceptually handle the general case, but optimize the simple cases where
we can exit early")
Notice how this patch doesn' actually change the fundamental O(n^2)
behaviour, but it makes it much cheaper by generally avoiding the
expensive 'fnmatch' and 'strlen/strncmp' when they are obviously not
needed.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-04-19 21:22:38 +00:00
|
|
|
static inline int special_char(unsigned char c1)
|
|
|
|
{
|
2008-08-13 22:34:34 +00:00
|
|
|
return !c1 || c1 == '*' || c1 == '[' || c1 == '?' || c1 == '\\';
|
Optimize match_pathspec() to avoid fnmatch()
"git add *" is actually fundamentally different from "git add .", and
yeah, you should generally use the latter.
The reason? The argument list is actually something different from what
you think it is. For git, it's a "pathspec", so what actualy happens is
that in *both* cases, it will really traverse the whole tree, and then
match every file it finds against the pathspec.
So think of the arguments not as a file list, but as a random bunch of
patterns to match against the files you have!
Which is why the cost is actually approximately O(n*m), where "n" is the
size of the working tree, and "m" is the number of pathspecs.
So the reason "git add ." is fast is actually that "m" in that case is
just 1 (just one trivial pattern), and then "git add *" is slow because
"m" is large (lots of complicated patterns). In both cases, 'n' is the
same (== the whole set of files in your working tree).
Anyway, here's a trivial patch that doesn't change this fundamental fact,
but that avoids doing anything *expensive* until we've done some cheap
initial tests. It may or may not help your test-case, but it's pretty
simple and it matches the other git optimizations in this area (ie
"conceptually handle the general case, but optimize the simple cases where
we can exit early")
Notice how this patch doesn' actually change the fundamental O(n^2)
behaviour, but it makes it much cheaper by generally avoiding the
expensive 'fnmatch' and 'strlen/strncmp' when they are obviously not
needed.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-04-19 21:22:38 +00:00
|
|
|
}
|
|
|
|
|
2006-12-25 11:09:52 +00:00
|
|
|
/*
|
|
|
|
* Does 'match' matches the given name?
|
|
|
|
* A match is found if
|
|
|
|
*
|
|
|
|
* (1) the 'match' string is leading directory of 'name', or
|
|
|
|
* (2) the 'match' string is a wildcard and matches 'name', or
|
|
|
|
* (3) the 'match' string is exactly the same as 'name'.
|
|
|
|
*
|
|
|
|
* and the return value tells which case it was.
|
|
|
|
*
|
|
|
|
* It returns 0 when there is no match.
|
|
|
|
*/
|
2006-05-19 23:07:51 +00:00
|
|
|
static int match_one(const char *match, const char *name, int namelen)
|
|
|
|
{
|
|
|
|
int matchlen;
|
|
|
|
|
|
|
|
/* If the match was just the prefix, we matched */
|
Optimize match_pathspec() to avoid fnmatch()
"git add *" is actually fundamentally different from "git add .", and
yeah, you should generally use the latter.
The reason? The argument list is actually something different from what
you think it is. For git, it's a "pathspec", so what actualy happens is
that in *both* cases, it will really traverse the whole tree, and then
match every file it finds against the pathspec.
So think of the arguments not as a file list, but as a random bunch of
patterns to match against the files you have!
Which is why the cost is actually approximately O(n*m), where "n" is the
size of the working tree, and "m" is the number of pathspecs.
So the reason "git add ." is fast is actually that "m" in that case is
just 1 (just one trivial pattern), and then "git add *" is slow because
"m" is large (lots of complicated patterns). In both cases, 'n' is the
same (== the whole set of files in your working tree).
Anyway, here's a trivial patch that doesn't change this fundamental fact,
but that avoids doing anything *expensive* until we've done some cheap
initial tests. It may or may not help your test-case, but it's pretty
simple and it matches the other git optimizations in this area (ie
"conceptually handle the general case, but optimize the simple cases where
we can exit early")
Notice how this patch doesn' actually change the fundamental O(n^2)
behaviour, but it makes it much cheaper by generally avoiding the
expensive 'fnmatch' and 'strlen/strncmp' when they are obviously not
needed.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-04-19 21:22:38 +00:00
|
|
|
if (!*match)
|
2006-12-25 11:09:52 +00:00
|
|
|
return MATCHED_RECURSIVELY;
|
2006-05-19 23:07:51 +00:00
|
|
|
|
Optimize match_pathspec() to avoid fnmatch()
"git add *" is actually fundamentally different from "git add .", and
yeah, you should generally use the latter.
The reason? The argument list is actually something different from what
you think it is. For git, it's a "pathspec", so what actualy happens is
that in *both* cases, it will really traverse the whole tree, and then
match every file it finds against the pathspec.
So think of the arguments not as a file list, but as a random bunch of
patterns to match against the files you have!
Which is why the cost is actually approximately O(n*m), where "n" is the
size of the working tree, and "m" is the number of pathspecs.
So the reason "git add ." is fast is actually that "m" in that case is
just 1 (just one trivial pattern), and then "git add *" is slow because
"m" is large (lots of complicated patterns). In both cases, 'n' is the
same (== the whole set of files in your working tree).
Anyway, here's a trivial patch that doesn't change this fundamental fact,
but that avoids doing anything *expensive* until we've done some cheap
initial tests. It may or may not help your test-case, but it's pretty
simple and it matches the other git optimizations in this area (ie
"conceptually handle the general case, but optimize the simple cases where
we can exit early")
Notice how this patch doesn' actually change the fundamental O(n^2)
behaviour, but it makes it much cheaper by generally avoiding the
expensive 'fnmatch' and 'strlen/strncmp' when they are obviously not
needed.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-04-19 21:22:38 +00:00
|
|
|
for (;;) {
|
|
|
|
unsigned char c1 = *match;
|
|
|
|
unsigned char c2 = *name;
|
|
|
|
if (special_char(c1))
|
|
|
|
break;
|
|
|
|
if (c1 != c2)
|
|
|
|
return 0;
|
|
|
|
match++;
|
|
|
|
name++;
|
|
|
|
namelen--;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-05-19 23:07:51 +00:00
|
|
|
/*
|
|
|
|
* If we don't match the matchstring exactly,
|
|
|
|
* we need to match by fnmatch
|
|
|
|
*/
|
Optimize match_pathspec() to avoid fnmatch()
"git add *" is actually fundamentally different from "git add .", and
yeah, you should generally use the latter.
The reason? The argument list is actually something different from what
you think it is. For git, it's a "pathspec", so what actualy happens is
that in *both* cases, it will really traverse the whole tree, and then
match every file it finds against the pathspec.
So think of the arguments not as a file list, but as a random bunch of
patterns to match against the files you have!
Which is why the cost is actually approximately O(n*m), where "n" is the
size of the working tree, and "m" is the number of pathspecs.
So the reason "git add ." is fast is actually that "m" in that case is
just 1 (just one trivial pattern), and then "git add *" is slow because
"m" is large (lots of complicated patterns). In both cases, 'n' is the
same (== the whole set of files in your working tree).
Anyway, here's a trivial patch that doesn't change this fundamental fact,
but that avoids doing anything *expensive* until we've done some cheap
initial tests. It may or may not help your test-case, but it's pretty
simple and it matches the other git optimizations in this area (ie
"conceptually handle the general case, but optimize the simple cases where
we can exit early")
Notice how this patch doesn' actually change the fundamental O(n^2)
behaviour, but it makes it much cheaper by generally avoiding the
expensive 'fnmatch' and 'strlen/strncmp' when they are obviously not
needed.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-04-19 21:22:38 +00:00
|
|
|
matchlen = strlen(match);
|
2006-05-19 23:07:51 +00:00
|
|
|
if (strncmp(match, name, matchlen))
|
2006-12-25 11:09:52 +00:00
|
|
|
return !fnmatch(match, name, 0) ? MATCHED_FNMATCH : 0;
|
2006-05-19 23:07:51 +00:00
|
|
|
|
2008-04-15 03:14:09 +00:00
|
|
|
if (namelen == matchlen)
|
2006-12-25 11:09:52 +00:00
|
|
|
return MATCHED_EXACTLY;
|
|
|
|
if (match[matchlen-1] == '/' || name[matchlen] == '/')
|
|
|
|
return MATCHED_RECURSIVELY;
|
|
|
|
return 0;
|
2006-05-19 23:07:51 +00:00
|
|
|
}
|
|
|
|
|
2006-12-25 11:09:52 +00:00
|
|
|
/*
|
|
|
|
* Given a name and a list of pathspecs, see if the name matches
|
|
|
|
* any of the pathspecs. The caller is also interested in seeing
|
|
|
|
* all pathspec matches some names it calls this function with
|
|
|
|
* (otherwise the user could have mistyped the unmatched pathspec),
|
|
|
|
* and a mark is left in seen[] array for pathspec element that
|
|
|
|
* actually matched anything.
|
|
|
|
*/
|
2006-05-19 23:07:51 +00:00
|
|
|
int match_pathspec(const char **pathspec, const char *name, int namelen, int prefix, char *seen)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
const char *match;
|
|
|
|
|
|
|
|
name += prefix;
|
|
|
|
namelen -= prefix;
|
|
|
|
|
|
|
|
for (retval = 0; (match = *pathspec++) != NULL; seen++) {
|
2006-12-25 11:09:52 +00:00
|
|
|
int how;
|
|
|
|
if (retval && *seen == MATCHED_EXACTLY)
|
2006-05-19 23:07:51 +00:00
|
|
|
continue;
|
|
|
|
match += prefix;
|
2006-12-25 11:09:52 +00:00
|
|
|
how = match_one(match, name, namelen);
|
|
|
|
if (how) {
|
|
|
|
if (retval < how)
|
|
|
|
retval = how;
|
|
|
|
if (*seen < how)
|
|
|
|
*seen = how;
|
2006-05-19 23:07:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2007-10-28 20:27:13 +00:00
|
|
|
static int no_wildcard(const char *string)
|
|
|
|
{
|
|
|
|
return string[strcspn(string, "*?[{")] == '\0';
|
|
|
|
}
|
|
|
|
|
2006-05-17 02:02:14 +00:00
|
|
|
void add_exclude(const char *string, const char *base,
|
|
|
|
int baselen, struct exclude_list *which)
|
|
|
|
{
|
2008-01-31 09:17:48 +00:00
|
|
|
struct exclude *x;
|
|
|
|
size_t len;
|
|
|
|
int to_exclude = 1;
|
|
|
|
int flags = 0;
|
2006-05-17 02:02:14 +00:00
|
|
|
|
2007-10-28 20:27:13 +00:00
|
|
|
if (*string == '!') {
|
2008-01-31 09:17:48 +00:00
|
|
|
to_exclude = 0;
|
2007-10-28 20:27:13 +00:00
|
|
|
string++;
|
|
|
|
}
|
2008-01-31 09:17:48 +00:00
|
|
|
len = strlen(string);
|
|
|
|
if (len && string[len - 1] == '/') {
|
|
|
|
char *s;
|
|
|
|
x = xmalloc(sizeof(*x) + len);
|
|
|
|
s = (char*)(x+1);
|
|
|
|
memcpy(s, string, len - 1);
|
|
|
|
s[len - 1] = '\0';
|
|
|
|
string = s;
|
|
|
|
x->pattern = s;
|
|
|
|
flags = EXC_FLAG_MUSTBEDIR;
|
|
|
|
} else {
|
|
|
|
x = xmalloc(sizeof(*x));
|
|
|
|
x->pattern = string;
|
|
|
|
}
|
|
|
|
x->to_exclude = to_exclude;
|
2007-10-28 20:27:13 +00:00
|
|
|
x->patternlen = strlen(string);
|
2006-05-17 02:02:14 +00:00
|
|
|
x->base = base;
|
|
|
|
x->baselen = baselen;
|
2008-01-31 09:17:48 +00:00
|
|
|
x->flags = flags;
|
2007-10-28 20:27:13 +00:00
|
|
|
if (!strchr(string, '/'))
|
|
|
|
x->flags |= EXC_FLAG_NODIR;
|
|
|
|
if (no_wildcard(string))
|
|
|
|
x->flags |= EXC_FLAG_NOWILDCARD;
|
|
|
|
if (*string == '*' && no_wildcard(string+1))
|
|
|
|
x->flags |= EXC_FLAG_ENDSWITH;
|
2007-11-29 09:11:46 +00:00
|
|
|
ALLOC_GROW(which->excludes, which->nr + 1, which->alloc);
|
2006-05-17 02:02:14 +00:00
|
|
|
which->excludes[which->nr++] = x;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int add_excludes_from_file_1(const char *fname,
|
|
|
|
const char *base,
|
|
|
|
int baselen,
|
2007-11-29 10:17:44 +00:00
|
|
|
char **buf_p,
|
2006-05-17 02:02:14 +00:00
|
|
|
struct exclude_list *which)
|
|
|
|
{
|
2006-08-27 23:55:46 +00:00
|
|
|
struct stat st;
|
2006-05-17 02:02:14 +00:00
|
|
|
int fd, i;
|
2007-03-07 01:44:37 +00:00
|
|
|
size_t size;
|
2006-05-17 02:02:14 +00:00
|
|
|
char *buf, *entry;
|
|
|
|
|
|
|
|
fd = open(fname, O_RDONLY);
|
2006-08-27 23:55:46 +00:00
|
|
|
if (fd < 0 || fstat(fd, &st) < 0)
|
2006-05-17 02:02:14 +00:00
|
|
|
goto err;
|
2007-03-07 01:44:37 +00:00
|
|
|
size = xsize_t(st.st_size);
|
2006-05-17 02:02:14 +00:00
|
|
|
if (size == 0) {
|
|
|
|
close(fd);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
buf = xmalloc(size+1);
|
2007-01-08 15:58:08 +00:00
|
|
|
if (read_in_full(fd, buf, size) != size)
|
2007-12-16 04:53:26 +00:00
|
|
|
{
|
|
|
|
free(buf);
|
2006-05-17 02:02:14 +00:00
|
|
|
goto err;
|
2007-12-16 04:53:26 +00:00
|
|
|
}
|
2006-05-17 02:02:14 +00:00
|
|
|
close(fd);
|
|
|
|
|
2007-11-29 10:17:44 +00:00
|
|
|
if (buf_p)
|
|
|
|
*buf_p = buf;
|
2006-05-17 02:02:14 +00:00
|
|
|
buf[size++] = '\n';
|
|
|
|
entry = buf;
|
|
|
|
for (i = 0; i < size; i++) {
|
|
|
|
if (buf[i] == '\n') {
|
|
|
|
if (entry != buf + i && entry[0] != '#') {
|
|
|
|
buf[i - (i && buf[i-1] == '\r')] = 0;
|
|
|
|
add_exclude(entry, base, baselen, which);
|
|
|
|
}
|
|
|
|
entry = buf + i + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
|
|
|
if (0 <= fd)
|
|
|
|
close(fd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void add_excludes_from_file(struct dir_struct *dir, const char *fname)
|
|
|
|
{
|
2007-11-29 10:17:44 +00:00
|
|
|
if (add_excludes_from_file_1(fname, "", 0, NULL,
|
2006-05-17 02:02:14 +00:00
|
|
|
&dir->exclude_list[EXC_FILE]) < 0)
|
|
|
|
die("cannot use %s as an exclude file", fname);
|
|
|
|
}
|
|
|
|
|
2007-11-29 10:17:44 +00:00
|
|
|
static void prep_exclude(struct dir_struct *dir, const char *base, int baselen)
|
2006-05-17 02:02:14 +00:00
|
|
|
{
|
2007-11-29 10:17:44 +00:00
|
|
|
struct exclude_list *el;
|
|
|
|
struct exclude_stack *stk = NULL;
|
|
|
|
int current;
|
|
|
|
|
|
|
|
if ((!dir->exclude_per_dir) ||
|
|
|
|
(baselen + strlen(dir->exclude_per_dir) >= PATH_MAX))
|
|
|
|
return; /* too long a path -- ignore */
|
|
|
|
|
|
|
|
/* Pop the ones that are not the prefix of the path being checked. */
|
|
|
|
el = &dir->exclude_list[EXC_DIRS];
|
|
|
|
while ((stk = dir->exclude_stack) != NULL) {
|
|
|
|
if (stk->baselen <= baselen &&
|
|
|
|
!strncmp(dir->basebuf, base, stk->baselen))
|
|
|
|
break;
|
|
|
|
dir->exclude_stack = stk->prev;
|
|
|
|
while (stk->exclude_ix < el->nr)
|
|
|
|
free(el->excludes[--el->nr]);
|
|
|
|
free(stk->filebuf);
|
|
|
|
free(stk);
|
2006-05-17 02:02:14 +00:00
|
|
|
}
|
|
|
|
|
2007-11-29 10:17:44 +00:00
|
|
|
/* Read from the parent directories and push them down. */
|
|
|
|
current = stk ? stk->baselen : -1;
|
|
|
|
while (current < baselen) {
|
|
|
|
struct exclude_stack *stk = xcalloc(1, sizeof(*stk));
|
|
|
|
const char *cp;
|
2006-05-17 02:02:14 +00:00
|
|
|
|
2007-11-29 10:17:44 +00:00
|
|
|
if (current < 0) {
|
|
|
|
cp = base;
|
|
|
|
current = 0;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
cp = strchr(base + current + 1, '/');
|
|
|
|
if (!cp)
|
|
|
|
die("oops in prep_exclude");
|
|
|
|
cp++;
|
|
|
|
}
|
|
|
|
stk->prev = dir->exclude_stack;
|
|
|
|
stk->baselen = cp - base;
|
|
|
|
stk->exclude_ix = el->nr;
|
|
|
|
memcpy(dir->basebuf + current, base + current,
|
|
|
|
stk->baselen - current);
|
|
|
|
strcpy(dir->basebuf + stk->baselen, dir->exclude_per_dir);
|
|
|
|
add_excludes_from_file_1(dir->basebuf,
|
|
|
|
dir->basebuf, stk->baselen,
|
|
|
|
&stk->filebuf, el);
|
|
|
|
dir->exclude_stack = stk;
|
|
|
|
current = stk->baselen;
|
|
|
|
}
|
|
|
|
dir->basebuf[baselen] = '\0';
|
2006-05-17 02:02:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Scan the list and let the last match determines the fate.
|
|
|
|
* Return 1 for exclude, 0 for include and -1 for undecided.
|
|
|
|
*/
|
|
|
|
static int excluded_1(const char *pathname,
|
2008-02-01 04:23:25 +00:00
|
|
|
int pathlen, const char *basename, int *dtype,
|
2006-05-17 02:02:14 +00:00
|
|
|
struct exclude_list *el)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (el->nr) {
|
|
|
|
for (i = el->nr - 1; 0 <= i; i--) {
|
|
|
|
struct exclude *x = el->excludes[i];
|
|
|
|
const char *exclude = x->pattern;
|
2007-10-28 20:27:13 +00:00
|
|
|
int to_exclude = x->to_exclude;
|
2006-05-17 02:02:14 +00:00
|
|
|
|
2008-02-01 04:23:25 +00:00
|
|
|
if (x->flags & EXC_FLAG_MUSTBEDIR) {
|
|
|
|
if (*dtype == DT_UNKNOWN)
|
|
|
|
*dtype = get_dtype(NULL, pathname);
|
|
|
|
if (*dtype != DT_DIR)
|
|
|
|
continue;
|
|
|
|
}
|
2008-01-31 09:17:48 +00:00
|
|
|
|
2007-10-28 20:27:13 +00:00
|
|
|
if (x->flags & EXC_FLAG_NODIR) {
|
2006-05-17 02:02:14 +00:00
|
|
|
/* match basename */
|
2007-10-28 20:27:13 +00:00
|
|
|
if (x->flags & EXC_FLAG_NOWILDCARD) {
|
|
|
|
if (!strcmp(exclude, basename))
|
|
|
|
return to_exclude;
|
|
|
|
} else if (x->flags & EXC_FLAG_ENDSWITH) {
|
|
|
|
if (x->patternlen - 1 <= pathlen &&
|
|
|
|
!strcmp(exclude + 1, pathname + pathlen - x->patternlen + 1))
|
|
|
|
return to_exclude;
|
|
|
|
} else {
|
|
|
|
if (fnmatch(exclude, basename, 0) == 0)
|
|
|
|
return to_exclude;
|
|
|
|
}
|
2006-05-17 02:02:14 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* match with FNM_PATHNAME:
|
|
|
|
* exclude has base (baselen long) implicitly
|
|
|
|
* in front of it.
|
|
|
|
*/
|
|
|
|
int baselen = x->baselen;
|
|
|
|
if (*exclude == '/')
|
|
|
|
exclude++;
|
|
|
|
|
|
|
|
if (pathlen < baselen ||
|
|
|
|
(baselen && pathname[baselen-1] != '/') ||
|
|
|
|
strncmp(pathname, x->base, baselen))
|
|
|
|
continue;
|
|
|
|
|
2007-10-28 20:27:13 +00:00
|
|
|
if (x->flags & EXC_FLAG_NOWILDCARD) {
|
|
|
|
if (!strcmp(exclude, pathname + baselen))
|
|
|
|
return to_exclude;
|
|
|
|
} else {
|
|
|
|
if (fnmatch(exclude, pathname+baselen,
|
|
|
|
FNM_PATHNAME) == 0)
|
|
|
|
return to_exclude;
|
|
|
|
}
|
2006-05-17 02:02:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1; /* undecided */
|
|
|
|
}
|
|
|
|
|
2008-02-01 04:23:25 +00:00
|
|
|
int excluded(struct dir_struct *dir, const char *pathname, int *dtype_p)
|
2006-05-17 02:02:14 +00:00
|
|
|
{
|
|
|
|
int pathlen = strlen(pathname);
|
|
|
|
int st;
|
2007-10-28 20:27:13 +00:00
|
|
|
const char *basename = strrchr(pathname, '/');
|
|
|
|
basename = (basename) ? basename+1 : pathname;
|
2006-05-17 02:02:14 +00:00
|
|
|
|
2007-11-29 10:17:44 +00:00
|
|
|
prep_exclude(dir, pathname, basename-pathname);
|
2006-05-17 02:02:14 +00:00
|
|
|
for (st = EXC_CMDL; st <= EXC_FILE; st++) {
|
2008-01-31 09:17:48 +00:00
|
|
|
switch (excluded_1(pathname, pathlen, basename,
|
2008-02-01 04:23:25 +00:00
|
|
|
dtype_p, &dir->exclude_list[st])) {
|
2006-05-17 02:02:14 +00:00
|
|
|
case 0:
|
|
|
|
return 0;
|
|
|
|
case 1:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-11-08 23:35:32 +00:00
|
|
|
static struct dir_entry *dir_entry_new(const char *pathname, int len)
|
|
|
|
{
|
2006-05-17 02:02:14 +00:00
|
|
|
struct dir_entry *ent;
|
|
|
|
|
|
|
|
ent = xmalloc(sizeof(*ent) + len + 1);
|
|
|
|
ent->len = len;
|
|
|
|
memcpy(ent->name, pathname, len);
|
|
|
|
ent->name[len] = 0;
|
2006-12-29 19:01:31 +00:00
|
|
|
return ent;
|
2006-05-17 02:02:14 +00:00
|
|
|
}
|
|
|
|
|
2007-06-11 13:39:44 +00:00
|
|
|
struct dir_entry *dir_add_name(struct dir_struct *dir, const char *pathname, int len)
|
|
|
|
{
|
2008-03-21 23:52:46 +00:00
|
|
|
if (cache_name_exists(pathname, len, ignore_case))
|
2007-06-11 13:39:44 +00:00
|
|
|
return NULL;
|
|
|
|
|
2007-06-16 22:43:40 +00:00
|
|
|
ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc);
|
2007-06-11 13:39:44 +00:00
|
|
|
return dir->entries[dir->nr++] = dir_entry_new(pathname, len);
|
|
|
|
}
|
|
|
|
|
2007-06-11 13:39:50 +00:00
|
|
|
struct dir_entry *dir_add_ignored(struct dir_struct *dir, const char *pathname, int len)
|
|
|
|
{
|
|
|
|
if (cache_name_pos(pathname, len) >= 0)
|
|
|
|
return NULL;
|
|
|
|
|
2007-06-16 22:43:40 +00:00
|
|
|
ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc);
|
2007-06-11 13:39:50 +00:00
|
|
|
return dir->ignored[dir->ignored_nr++] = dir_entry_new(pathname, len);
|
|
|
|
}
|
|
|
|
|
2007-04-11 21:49:44 +00:00
|
|
|
enum exist_status {
|
|
|
|
index_nonexistent = 0,
|
|
|
|
index_directory,
|
|
|
|
index_gitdir,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The index sorts alphabetically by entry name, which
|
|
|
|
* means that a gitlink sorts as '\0' at the end, while
|
|
|
|
* a directory (which is defined not as an entry, but as
|
|
|
|
* the files it contains) will sort with the '/' at the
|
|
|
|
* end.
|
|
|
|
*/
|
|
|
|
static enum exist_status directory_exists_in_index(const char *dirname, int len)
|
2006-05-17 02:02:14 +00:00
|
|
|
{
|
|
|
|
int pos = cache_name_pos(dirname, len);
|
2007-04-11 21:49:44 +00:00
|
|
|
if (pos < 0)
|
|
|
|
pos = -pos-1;
|
|
|
|
while (pos < active_nr) {
|
|
|
|
struct cache_entry *ce = active_cache[pos++];
|
|
|
|
unsigned char endchar;
|
|
|
|
|
|
|
|
if (strncmp(ce->name, dirname, len))
|
|
|
|
break;
|
|
|
|
endchar = ce->name[len];
|
|
|
|
if (endchar > '/')
|
|
|
|
break;
|
|
|
|
if (endchar == '/')
|
|
|
|
return index_directory;
|
2008-01-15 00:03:17 +00:00
|
|
|
if (!endchar && S_ISGITLINK(ce->ce_mode))
|
2007-04-11 21:49:44 +00:00
|
|
|
return index_gitdir;
|
|
|
|
}
|
|
|
|
return index_nonexistent;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When we find a directory when traversing the filesystem, we
|
|
|
|
* have three distinct cases:
|
|
|
|
*
|
|
|
|
* - ignore it
|
|
|
|
* - see it as a directory
|
|
|
|
* - recurse into it
|
|
|
|
*
|
|
|
|
* and which one we choose depends on a combination of existing
|
|
|
|
* git index contents and the flags passed into the directory
|
|
|
|
* traversal routine.
|
|
|
|
*
|
|
|
|
* Case 1: If we *already* have entries in the index under that
|
|
|
|
* directory name, we always recurse into the directory to see
|
|
|
|
* all the files.
|
|
|
|
*
|
|
|
|
* Case 2: If we *already* have that directory name as a gitlink,
|
|
|
|
* we always continue to see it as a gitlink, regardless of whether
|
|
|
|
* there is an actual git directory there or not (it might not
|
|
|
|
* be checked out as a subproject!)
|
|
|
|
*
|
|
|
|
* Case 3: if we didn't have it in the index previously, we
|
|
|
|
* have a few sub-cases:
|
|
|
|
*
|
|
|
|
* (a) if "show_other_directories" is true, we show it as
|
|
|
|
* just a directory, unless "hide_empty_directories" is
|
|
|
|
* also true and the directory is empty, in which case
|
|
|
|
* we just ignore it entirely.
|
|
|
|
* (b) if it looks like a git directory, and we don't have
|
2007-05-21 20:08:28 +00:00
|
|
|
* 'no_gitlinks' set we treat it as a gitlink, and show it
|
2007-04-11 21:49:44 +00:00
|
|
|
* as a directory.
|
|
|
|
* (c) otherwise, we recurse into it.
|
|
|
|
*/
|
|
|
|
enum directory_treatment {
|
|
|
|
show_directory,
|
|
|
|
ignore_directory,
|
|
|
|
recurse_into_directory,
|
|
|
|
};
|
|
|
|
|
|
|
|
static enum directory_treatment treat_directory(struct dir_struct *dir,
|
|
|
|
const char *dirname, int len,
|
|
|
|
const struct path_simplify *simplify)
|
|
|
|
{
|
|
|
|
/* The "len-1" is to strip the final '/' */
|
|
|
|
switch (directory_exists_in_index(dirname, len-1)) {
|
|
|
|
case index_directory:
|
|
|
|
return recurse_into_directory;
|
|
|
|
|
|
|
|
case index_gitdir:
|
2007-04-12 21:32:21 +00:00
|
|
|
if (dir->show_other_directories)
|
|
|
|
return ignore_directory;
|
2007-04-11 21:49:44 +00:00
|
|
|
return show_directory;
|
|
|
|
|
|
|
|
case index_nonexistent:
|
|
|
|
if (dir->show_other_directories)
|
|
|
|
break;
|
2007-05-21 20:08:28 +00:00
|
|
|
if (!dir->no_gitlinks) {
|
2007-04-11 21:49:44 +00:00
|
|
|
unsigned char sha1[20];
|
|
|
|
if (resolve_gitlink_ref(dirname, "HEAD", sha1) == 0)
|
|
|
|
return show_directory;
|
|
|
|
}
|
|
|
|
return recurse_into_directory;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This is the "show_other_directories" case */
|
|
|
|
if (!dir->hide_empty_directories)
|
|
|
|
return show_directory;
|
|
|
|
if (!read_directory_recursive(dir, dirname, dirname, len, 1, simplify))
|
|
|
|
return ignore_directory;
|
|
|
|
return show_directory;
|
2006-05-17 02:02:14 +00:00
|
|
|
}
|
|
|
|
|
Optimize directory listing with pathspec limiter.
The way things are set up, you can now pass a "pathspec" to the
"read_directory()" function. If you pass NULL, it acts exactly
like it used to do (read everything). If you pass a non-NULL
pointer, it will simplify it into a "these are the prefixes
without any special characters", and stop any readdir() early if
the path in question doesn't match any of the prefixes.
NOTE! This does *not* obviate the need for the caller to do the *exact*
pathspec match later. It's a first-level filter on "read_directory()", but
it does not do the full pathspec thing. Maybe it should. But in the
meantime, builtin-add.c really does need to do first
read_directory(dir, .., pathspec);
if (pathspec)
prune_directory(dir, pathspec, baselen);
ie the "prune_directory()" part will do the *exact* pathspec pruning,
while the "read_directory()" will use the pathspec just to do some quick
high-level pruning of the directories it will recurse into.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-03-31 03:39:30 +00:00
|
|
|
/*
|
|
|
|
* This is an inexact early pruning of any recursive directory
|
|
|
|
* reading - if the path cannot possibly be in the pathspec,
|
|
|
|
* return true, and we'll skip it early.
|
|
|
|
*/
|
|
|
|
static int simplify_away(const char *path, int pathlen, const struct path_simplify *simplify)
|
|
|
|
{
|
|
|
|
if (simplify) {
|
|
|
|
for (;;) {
|
|
|
|
const char *match = simplify->path;
|
|
|
|
int len = simplify->len;
|
|
|
|
|
|
|
|
if (!match)
|
|
|
|
break;
|
|
|
|
if (len > pathlen)
|
|
|
|
len = pathlen;
|
|
|
|
if (!memcmp(path, match, len))
|
|
|
|
return 0;
|
|
|
|
simplify++;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
builtin-add: simplify (and increase accuracy of) exclude handling
Previously, the code would always set up the excludes, and then manually
pick through the pathspec we were given, assuming that non-added but
existing paths were just ignored. This was mostly correct, but would
erroneously mark a totally empty directory as 'ignored'.
Instead, we now use the collect_ignored option of dir_struct, which
unambiguously tells us whether a path was ignored. This simplifies the
code, and means empty directories are now just not mentioned at all.
Furthermore, we now conditionally ask dir_struct to respect excludes,
depending on whether the '-f' flag has been set. This means we don't have
to pick through the result, checking for an 'ignored' flag; ignored entries
were either added or not in the first place.
We can safely get rid of the special 'ignored' flags to dir_entry, which
were not used anywhere else.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Jonas Fonseca <fonseca@diku.dk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-06-12 21:42:14 +00:00
|
|
|
static int in_pathspec(const char *path, int len, const struct path_simplify *simplify)
|
|
|
|
{
|
|
|
|
if (simplify) {
|
|
|
|
for (; simplify->path; simplify++) {
|
|
|
|
if (len == simplify->len
|
|
|
|
&& !memcmp(path, simplify->path, len))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
Fix directory scanner to correctly ignore files without d_type
On Fri, 19 Oct 2007, Todd T. Fries wrote:
> If DT_UNKNOWN exists, then we have to do a stat() of some form to
> find out the right type.
That happened in the case of a pathname that was ignored, and we did
not ask for "dir->show_ignored". That test used to be *together*
with the "DTYPE(de) != DT_DIR", but splitting the two tests up
means that we can do that (common) test before we even bother to
calculate the real dtype.
Of course, that optimization only matters for systems that don't
have, or don't fill in DTYPE properly.
I also clarified the real relationship between "exclude" and
"dir->show_ignored". It used to do
if (exclude != dir->show_ignored) {
..
which wasn't exactly obvious, because it triggers for two different
cases:
- the path is marked excluded, but we are not interested in ignored
files: ignore it
- the path is *not* excluded, but we *are* interested in ignored
files: ignore it unless it's a directory, in which case we might
have ignored files inside the directory and need to recurse
into it).
so this splits them into those two cases, since the first case
doesn't even care about the type.
I also made a the DT_UNKNOWN case a separate helper function,
and added some commentary to the cases.
Linus
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
2007-10-19 17:59:22 +00:00
|
|
|
static int get_dtype(struct dirent *de, const char *path)
|
|
|
|
{
|
2008-02-01 04:23:25 +00:00
|
|
|
int dtype = de ? DTYPE(de) : DT_UNKNOWN;
|
Fix directory scanner to correctly ignore files without d_type
On Fri, 19 Oct 2007, Todd T. Fries wrote:
> If DT_UNKNOWN exists, then we have to do a stat() of some form to
> find out the right type.
That happened in the case of a pathname that was ignored, and we did
not ask for "dir->show_ignored". That test used to be *together*
with the "DTYPE(de) != DT_DIR", but splitting the two tests up
means that we can do that (common) test before we even bother to
calculate the real dtype.
Of course, that optimization only matters for systems that don't
have, or don't fill in DTYPE properly.
I also clarified the real relationship between "exclude" and
"dir->show_ignored". It used to do
if (exclude != dir->show_ignored) {
..
which wasn't exactly obvious, because it triggers for two different
cases:
- the path is marked excluded, but we are not interested in ignored
files: ignore it
- the path is *not* excluded, but we *are* interested in ignored
files: ignore it unless it's a directory, in which case we might
have ignored files inside the directory and need to recurse
into it).
so this splits them into those two cases, since the first case
doesn't even care about the type.
I also made a the DT_UNKNOWN case a separate helper function,
and added some commentary to the cases.
Linus
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
2007-10-19 17:59:22 +00:00
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (dtype != DT_UNKNOWN)
|
|
|
|
return dtype;
|
|
|
|
if (lstat(path, &st))
|
|
|
|
return dtype;
|
|
|
|
if (S_ISREG(st.st_mode))
|
|
|
|
return DT_REG;
|
|
|
|
if (S_ISDIR(st.st_mode))
|
|
|
|
return DT_DIR;
|
|
|
|
if (S_ISLNK(st.st_mode))
|
|
|
|
return DT_LNK;
|
|
|
|
return dtype;
|
|
|
|
}
|
|
|
|
|
2006-05-17 02:02:14 +00:00
|
|
|
/*
|
|
|
|
* Read a directory tree. We currently ignore anything but
|
|
|
|
* directories, regular files and symlinks. That's because git
|
|
|
|
* doesn't handle them at all yet. Maybe that will change some
|
|
|
|
* day.
|
|
|
|
*
|
|
|
|
* Also, we ignore the name ".git" (even if it is not a directory).
|
|
|
|
* That likely will not change.
|
|
|
|
*/
|
Optimize directory listing with pathspec limiter.
The way things are set up, you can now pass a "pathspec" to the
"read_directory()" function. If you pass NULL, it acts exactly
like it used to do (read everything). If you pass a non-NULL
pointer, it will simplify it into a "these are the prefixes
without any special characters", and stop any readdir() early if
the path in question doesn't match any of the prefixes.
NOTE! This does *not* obviate the need for the caller to do the *exact*
pathspec match later. It's a first-level filter on "read_directory()", but
it does not do the full pathspec thing. Maybe it should. But in the
meantime, builtin-add.c really does need to do first
read_directory(dir, .., pathspec);
if (pathspec)
prune_directory(dir, pathspec, baselen);
ie the "prune_directory()" part will do the *exact* pathspec pruning,
while the "read_directory()" will use the pathspec just to do some quick
high-level pruning of the directories it will recurse into.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-03-31 03:39:30 +00:00
|
|
|
static int read_directory_recursive(struct dir_struct *dir, const char *path, const char *base, int baselen, int check_only, const struct path_simplify *simplify)
|
2006-05-17 02:02:14 +00:00
|
|
|
{
|
|
|
|
DIR *fdir = opendir(path);
|
|
|
|
int contents = 0;
|
|
|
|
|
|
|
|
if (fdir) {
|
|
|
|
struct dirent *de;
|
2006-08-26 14:09:17 +00:00
|
|
|
char fullname[PATH_MAX + 1];
|
2006-05-17 02:02:14 +00:00
|
|
|
memcpy(fullname, base, baselen);
|
|
|
|
|
|
|
|
while ((de = readdir(fdir)) != NULL) {
|
Fix directory scanner to correctly ignore files without d_type
On Fri, 19 Oct 2007, Todd T. Fries wrote:
> If DT_UNKNOWN exists, then we have to do a stat() of some form to
> find out the right type.
That happened in the case of a pathname that was ignored, and we did
not ask for "dir->show_ignored". That test used to be *together*
with the "DTYPE(de) != DT_DIR", but splitting the two tests up
means that we can do that (common) test before we even bother to
calculate the real dtype.
Of course, that optimization only matters for systems that don't
have, or don't fill in DTYPE properly.
I also clarified the real relationship between "exclude" and
"dir->show_ignored". It used to do
if (exclude != dir->show_ignored) {
..
which wasn't exactly obvious, because it triggers for two different
cases:
- the path is marked excluded, but we are not interested in ignored
files: ignore it
- the path is *not* excluded, but we *are* interested in ignored
files: ignore it unless it's a directory, in which case we might
have ignored files inside the directory and need to recurse
into it).
so this splits them into those two cases, since the first case
doesn't even care about the type.
I also made a the DT_UNKNOWN case a separate helper function,
and added some commentary to the cases.
Linus
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
2007-10-19 17:59:22 +00:00
|
|
|
int len, dtype;
|
2007-05-07 02:35:04 +00:00
|
|
|
int exclude;
|
2006-05-17 02:02:14 +00:00
|
|
|
|
|
|
|
if ((de->d_name[0] == '.') &&
|
|
|
|
(de->d_name[1] == 0 ||
|
|
|
|
!strcmp(de->d_name + 1, ".") ||
|
|
|
|
!strcmp(de->d_name + 1, "git")))
|
|
|
|
continue;
|
|
|
|
len = strlen(de->d_name);
|
2007-04-10 04:13:58 +00:00
|
|
|
/* Ignore overly long pathnames! */
|
|
|
|
if (len + baselen + 8 > sizeof(fullname))
|
|
|
|
continue;
|
2006-05-17 02:02:14 +00:00
|
|
|
memcpy(fullname + baselen, de->d_name, len+1);
|
Optimize directory listing with pathspec limiter.
The way things are set up, you can now pass a "pathspec" to the
"read_directory()" function. If you pass NULL, it acts exactly
like it used to do (read everything). If you pass a non-NULL
pointer, it will simplify it into a "these are the prefixes
without any special characters", and stop any readdir() early if
the path in question doesn't match any of the prefixes.
NOTE! This does *not* obviate the need for the caller to do the *exact*
pathspec match later. It's a first-level filter on "read_directory()", but
it does not do the full pathspec thing. Maybe it should. But in the
meantime, builtin-add.c really does need to do first
read_directory(dir, .., pathspec);
if (pathspec)
prune_directory(dir, pathspec, baselen);
ie the "prune_directory()" part will do the *exact* pathspec pruning,
while the "read_directory()" will use the pathspec just to do some quick
high-level pruning of the directories it will recurse into.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-03-31 03:39:30 +00:00
|
|
|
if (simplify_away(fullname, baselen + len, simplify))
|
|
|
|
continue;
|
2007-05-07 02:35:04 +00:00
|
|
|
|
2008-02-01 04:23:25 +00:00
|
|
|
dtype = DTYPE(de);
|
|
|
|
exclude = excluded(dir, fullname, &dtype);
|
builtin-add: simplify (and increase accuracy of) exclude handling
Previously, the code would always set up the excludes, and then manually
pick through the pathspec we were given, assuming that non-added but
existing paths were just ignored. This was mostly correct, but would
erroneously mark a totally empty directory as 'ignored'.
Instead, we now use the collect_ignored option of dir_struct, which
unambiguously tells us whether a path was ignored. This simplifies the
code, and means empty directories are now just not mentioned at all.
Furthermore, we now conditionally ask dir_struct to respect excludes,
depending on whether the '-f' flag has been set. This means we don't have
to pick through the result, checking for an 'ignored' flag; ignored entries
were either added or not in the first place.
We can safely get rid of the special 'ignored' flags to dir_entry, which
were not used anywhere else.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Jonas Fonseca <fonseca@diku.dk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-06-12 21:42:14 +00:00
|
|
|
if (exclude && dir->collect_ignored
|
|
|
|
&& in_pathspec(fullname, baselen + len, simplify))
|
2007-06-11 13:39:50 +00:00
|
|
|
dir_add_ignored(dir, fullname, baselen + len);
|
Fix directory scanner to correctly ignore files without d_type
On Fri, 19 Oct 2007, Todd T. Fries wrote:
> If DT_UNKNOWN exists, then we have to do a stat() of some form to
> find out the right type.
That happened in the case of a pathname that was ignored, and we did
not ask for "dir->show_ignored". That test used to be *together*
with the "DTYPE(de) != DT_DIR", but splitting the two tests up
means that we can do that (common) test before we even bother to
calculate the real dtype.
Of course, that optimization only matters for systems that don't
have, or don't fill in DTYPE properly.
I also clarified the real relationship between "exclude" and
"dir->show_ignored". It used to do
if (exclude != dir->show_ignored) {
..
which wasn't exactly obvious, because it triggers for two different
cases:
- the path is marked excluded, but we are not interested in ignored
files: ignore it
- the path is *not* excluded, but we *are* interested in ignored
files: ignore it unless it's a directory, in which case we might
have ignored files inside the directory and need to recurse
into it).
so this splits them into those two cases, since the first case
doesn't even care about the type.
I also made a the DT_UNKNOWN case a separate helper function,
and added some commentary to the cases.
Linus
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
2007-10-19 17:59:22 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Excluded? If we don't explicitly want to show
|
|
|
|
* ignored files, ignore it
|
|
|
|
*/
|
|
|
|
if (exclude && !dir->show_ignored)
|
|
|
|
continue;
|
|
|
|
|
2008-02-01 04:23:25 +00:00
|
|
|
if (dtype == DT_UNKNOWN)
|
|
|
|
dtype = get_dtype(de, fullname);
|
Fix directory scanner to correctly ignore files without d_type
On Fri, 19 Oct 2007, Todd T. Fries wrote:
> If DT_UNKNOWN exists, then we have to do a stat() of some form to
> find out the right type.
That happened in the case of a pathname that was ignored, and we did
not ask for "dir->show_ignored". That test used to be *together*
with the "DTYPE(de) != DT_DIR", but splitting the two tests up
means that we can do that (common) test before we even bother to
calculate the real dtype.
Of course, that optimization only matters for systems that don't
have, or don't fill in DTYPE properly.
I also clarified the real relationship between "exclude" and
"dir->show_ignored". It used to do
if (exclude != dir->show_ignored) {
..
which wasn't exactly obvious, because it triggers for two different
cases:
- the path is marked excluded, but we are not interested in ignored
files: ignore it
- the path is *not* excluded, but we *are* interested in ignored
files: ignore it unless it's a directory, in which case we might
have ignored files inside the directory and need to recurse
into it).
so this splits them into those two cases, since the first case
doesn't even care about the type.
I also made a the DT_UNKNOWN case a separate helper function,
and added some commentary to the cases.
Linus
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
2007-10-19 17:59:22 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Do we want to see just the ignored files?
|
|
|
|
* We still need to recurse into directories,
|
|
|
|
* even if we don't ignore them, since the
|
|
|
|
* directory may contain files that we do..
|
|
|
|
*/
|
|
|
|
if (!exclude && dir->show_ignored) {
|
|
|
|
if (dtype != DT_DIR)
|
2006-12-29 18:08:19 +00:00
|
|
|
continue;
|
|
|
|
}
|
2006-05-17 02:02:14 +00:00
|
|
|
|
Fix directory scanner to correctly ignore files without d_type
On Fri, 19 Oct 2007, Todd T. Fries wrote:
> If DT_UNKNOWN exists, then we have to do a stat() of some form to
> find out the right type.
That happened in the case of a pathname that was ignored, and we did
not ask for "dir->show_ignored". That test used to be *together*
with the "DTYPE(de) != DT_DIR", but splitting the two tests up
means that we can do that (common) test before we even bother to
calculate the real dtype.
Of course, that optimization only matters for systems that don't
have, or don't fill in DTYPE properly.
I also clarified the real relationship between "exclude" and
"dir->show_ignored". It used to do
if (exclude != dir->show_ignored) {
..
which wasn't exactly obvious, because it triggers for two different
cases:
- the path is marked excluded, but we are not interested in ignored
files: ignore it
- the path is *not* excluded, but we *are* interested in ignored
files: ignore it unless it's a directory, in which case we might
have ignored files inside the directory and need to recurse
into it).
so this splits them into those two cases, since the first case
doesn't even care about the type.
I also made a the DT_UNKNOWN case a separate helper function,
and added some commentary to the cases.
Linus
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
2007-10-19 17:59:22 +00:00
|
|
|
switch (dtype) {
|
2006-05-17 02:02:14 +00:00
|
|
|
default:
|
|
|
|
continue;
|
|
|
|
case DT_DIR:
|
|
|
|
memcpy(fullname + baselen + len, "/", 2);
|
|
|
|
len++;
|
2007-04-11 21:49:44 +00:00
|
|
|
switch (treat_directory(dir, fullname, baselen + len, simplify)) {
|
|
|
|
case show_directory:
|
2007-05-07 02:35:04 +00:00
|
|
|
if (exclude != dir->show_ignored)
|
|
|
|
continue;
|
2006-05-17 02:02:14 +00:00
|
|
|
break;
|
2007-04-11 21:49:44 +00:00
|
|
|
case recurse_into_directory:
|
|
|
|
contents += read_directory_recursive(dir,
|
|
|
|
fullname, fullname, baselen + len, 0, simplify);
|
|
|
|
continue;
|
|
|
|
case ignore_directory:
|
|
|
|
continue;
|
2006-05-17 02:02:14 +00:00
|
|
|
}
|
2007-04-11 21:49:44 +00:00
|
|
|
break;
|
2006-05-17 02:02:14 +00:00
|
|
|
case DT_REG:
|
|
|
|
case DT_LNK:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
contents++;
|
2006-09-28 00:44:30 +00:00
|
|
|
if (check_only)
|
|
|
|
goto exit_early;
|
|
|
|
else
|
2006-12-29 19:01:31 +00:00
|
|
|
dir_add_name(dir, fullname, baselen + len);
|
2006-05-17 02:02:14 +00:00
|
|
|
}
|
2006-09-28 00:44:30 +00:00
|
|
|
exit_early:
|
2006-05-17 02:02:14 +00:00
|
|
|
closedir(fdir);
|
|
|
|
}
|
|
|
|
|
|
|
|
return contents;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cmp_name(const void *p1, const void *p2)
|
|
|
|
{
|
|
|
|
const struct dir_entry *e1 = *(const struct dir_entry **)p1;
|
|
|
|
const struct dir_entry *e2 = *(const struct dir_entry **)p2;
|
|
|
|
|
|
|
|
return cache_name_compare(e1->name, e1->len,
|
|
|
|
e2->name, e2->len);
|
|
|
|
}
|
|
|
|
|
Optimize directory listing with pathspec limiter.
The way things are set up, you can now pass a "pathspec" to the
"read_directory()" function. If you pass NULL, it acts exactly
like it used to do (read everything). If you pass a non-NULL
pointer, it will simplify it into a "these are the prefixes
without any special characters", and stop any readdir() early if
the path in question doesn't match any of the prefixes.
NOTE! This does *not* obviate the need for the caller to do the *exact*
pathspec match later. It's a first-level filter on "read_directory()", but
it does not do the full pathspec thing. Maybe it should. But in the
meantime, builtin-add.c really does need to do first
read_directory(dir, .., pathspec);
if (pathspec)
prune_directory(dir, pathspec, baselen);
ie the "prune_directory()" part will do the *exact* pathspec pruning,
while the "read_directory()" will use the pathspec just to do some quick
high-level pruning of the directories it will recurse into.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-03-31 03:39:30 +00:00
|
|
|
/*
|
|
|
|
* Return the length of the "simple" part of a path match limiter.
|
|
|
|
*/
|
|
|
|
static int simple_length(const char *match)
|
2006-05-17 02:02:14 +00:00
|
|
|
{
|
Optimize directory listing with pathspec limiter.
The way things are set up, you can now pass a "pathspec" to the
"read_directory()" function. If you pass NULL, it acts exactly
like it used to do (read everything). If you pass a non-NULL
pointer, it will simplify it into a "these are the prefixes
without any special characters", and stop any readdir() early if
the path in question doesn't match any of the prefixes.
NOTE! This does *not* obviate the need for the caller to do the *exact*
pathspec match later. It's a first-level filter on "read_directory()", but
it does not do the full pathspec thing. Maybe it should. But in the
meantime, builtin-add.c really does need to do first
read_directory(dir, .., pathspec);
if (pathspec)
prune_directory(dir, pathspec, baselen);
ie the "prune_directory()" part will do the *exact* pathspec pruning,
while the "read_directory()" will use the pathspec just to do some quick
high-level pruning of the directories it will recurse into.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-03-31 03:39:30 +00:00
|
|
|
const char special[256] = {
|
|
|
|
[0] = 1, ['?'] = 1,
|
|
|
|
['\\'] = 1, ['*'] = 1,
|
|
|
|
['['] = 1
|
|
|
|
};
|
|
|
|
int len = -1;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
unsigned char c = *match++;
|
|
|
|
len++;
|
|
|
|
if (special[c])
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct path_simplify *create_simplify(const char **pathspec)
|
|
|
|
{
|
|
|
|
int nr, alloc = 0;
|
|
|
|
struct path_simplify *simplify = NULL;
|
|
|
|
|
|
|
|
if (!pathspec)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
for (nr = 0 ; ; nr++) {
|
|
|
|
const char *match;
|
|
|
|
if (nr >= alloc) {
|
|
|
|
alloc = alloc_nr(alloc);
|
|
|
|
simplify = xrealloc(simplify, alloc * sizeof(*simplify));
|
|
|
|
}
|
|
|
|
match = *pathspec++;
|
|
|
|
if (!match)
|
|
|
|
break;
|
|
|
|
simplify[nr].path = match;
|
|
|
|
simplify[nr].len = simple_length(match);
|
|
|
|
}
|
|
|
|
simplify[nr].path = NULL;
|
|
|
|
simplify[nr].len = 0;
|
|
|
|
return simplify;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_simplify(struct path_simplify *simplify)
|
|
|
|
{
|
Avoid unnecessary "if-before-free" tests.
This change removes all obvious useless if-before-free tests.
E.g., it replaces code like this:
if (some_expression)
free (some_expression);
with the now-equivalent:
free (some_expression);
It is equivalent not just because POSIX has required free(NULL)
to work for a long time, but simply because it has worked for
so long that no reasonable porting target fails the test.
Here's some evidence from nearly 1.5 years ago:
http://www.winehq.org/pipermail/wine-patches/2006-October/031544.html
FYI, the change below was prepared by running the following:
git ls-files -z | xargs -0 \
perl -0x3b -pi -e \
's/\bif\s*\(\s*(\S+?)(?:\s*!=\s*NULL)?\s*\)\s+(free\s*\(\s*\1\s*\))/$2/s'
Note however, that it doesn't handle brace-enclosed blocks like
"if (x) { free (x); }". But that's ok, since there were none like
that in git sources.
Beware: if you do use the above snippet, note that it can
produce syntactically invalid C code. That happens when the
affected "if"-statement has a matching "else".
E.g., it would transform this
if (x)
free (x);
else
foo ();
into this:
free (x);
else
foo ();
There were none of those here, either.
If you're interested in automating detection of the useless
tests, you might like the useless-if-before-free script in gnulib:
[it *does* detect brace-enclosed free statements, and has a --name=S
option to make it detect free-like functions with different names]
http://git.sv.gnu.org/gitweb/?p=gnulib.git;a=blob;f=build-aux/useless-if-before-free
Addendum:
Remove one more (in imap-send.c), spotted by Jean-Luc Herren <jlh@gmx.ch>.
Signed-off-by: Jim Meyering <meyering@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-31 17:26:32 +00:00
|
|
|
free(simplify);
|
Optimize directory listing with pathspec limiter.
The way things are set up, you can now pass a "pathspec" to the
"read_directory()" function. If you pass NULL, it acts exactly
like it used to do (read everything). If you pass a non-NULL
pointer, it will simplify it into a "these are the prefixes
without any special characters", and stop any readdir() early if
the path in question doesn't match any of the prefixes.
NOTE! This does *not* obviate the need for the caller to do the *exact*
pathspec match later. It's a first-level filter on "read_directory()", but
it does not do the full pathspec thing. Maybe it should. But in the
meantime, builtin-add.c really does need to do first
read_directory(dir, .., pathspec);
if (pathspec)
prune_directory(dir, pathspec, baselen);
ie the "prune_directory()" part will do the *exact* pathspec pruning,
while the "read_directory()" will use the pathspec just to do some quick
high-level pruning of the directories it will recurse into.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-03-31 03:39:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int read_directory(struct dir_struct *dir, const char *path, const char *base, int baselen, const char **pathspec)
|
|
|
|
{
|
|
|
|
struct path_simplify *simplify = create_simplify(pathspec);
|
2006-05-17 02:46:16 +00:00
|
|
|
|
Optimize directory listing with pathspec limiter.
The way things are set up, you can now pass a "pathspec" to the
"read_directory()" function. If you pass NULL, it acts exactly
like it used to do (read everything). If you pass a non-NULL
pointer, it will simplify it into a "these are the prefixes
without any special characters", and stop any readdir() early if
the path in question doesn't match any of the prefixes.
NOTE! This does *not* obviate the need for the caller to do the *exact*
pathspec match later. It's a first-level filter on "read_directory()", but
it does not do the full pathspec thing. Maybe it should. But in the
meantime, builtin-add.c really does need to do first
read_directory(dir, .., pathspec);
if (pathspec)
prune_directory(dir, pathspec, baselen);
ie the "prune_directory()" part will do the *exact* pathspec pruning,
while the "read_directory()" will use the pathspec just to do some quick
high-level pruning of the directories it will recurse into.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-03-31 03:39:30 +00:00
|
|
|
read_directory_recursive(dir, path, base, baselen, 0, simplify);
|
|
|
|
free_simplify(simplify);
|
2006-05-17 02:02:14 +00:00
|
|
|
qsort(dir->entries, dir->nr, sizeof(struct dir_entry *), cmp_name);
|
2007-06-11 13:39:50 +00:00
|
|
|
qsort(dir->ignored, dir->ignored_nr, sizeof(struct dir_entry *), cmp_name);
|
2006-05-17 02:02:14 +00:00
|
|
|
return dir->nr;
|
|
|
|
}
|
2006-09-08 08:05:34 +00:00
|
|
|
|
2007-11-29 09:11:46 +00:00
|
|
|
int file_exists(const char *f)
|
2006-09-08 08:05:34 +00:00
|
|
|
{
|
2007-11-29 09:11:46 +00:00
|
|
|
struct stat sb;
|
2007-11-18 09:58:16 +00:00
|
|
|
return lstat(f, &sb) == 0;
|
2006-09-08 08:05:34 +00:00
|
|
|
}
|
2007-08-01 00:29:17 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* get_relative_cwd() gets the prefix of the current working directory
|
|
|
|
* relative to 'dir'. If we are not inside 'dir', it returns NULL.
|
2007-08-01 18:26:59 +00:00
|
|
|
*
|
|
|
|
* As a convenience, it also returns NULL if 'dir' is already NULL. The
|
|
|
|
* reason for this behaviour is that it is natural for functions returning
|
|
|
|
* directory names to return NULL to say "this directory does not exist"
|
|
|
|
* or "this directory is invalid". These cases are usually handled the
|
|
|
|
* same as if the cwd is not inside 'dir' at all, so get_relative_cwd()
|
|
|
|
* returns NULL for both of them.
|
|
|
|
*
|
|
|
|
* Most notably, get_relative_cwd(buffer, size, get_git_work_tree())
|
|
|
|
* unifies the handling of "outside work tree" with "no work tree at all".
|
2007-08-01 00:29:17 +00:00
|
|
|
*/
|
|
|
|
char *get_relative_cwd(char *buffer, int size, const char *dir)
|
|
|
|
{
|
|
|
|
char *cwd = buffer;
|
|
|
|
|
|
|
|
if (!dir)
|
|
|
|
return NULL;
|
|
|
|
if (!getcwd(buffer, size))
|
|
|
|
die("can't find the current directory: %s", strerror(errno));
|
|
|
|
|
|
|
|
if (!is_absolute_path(dir))
|
|
|
|
dir = make_absolute_path(dir);
|
|
|
|
|
|
|
|
while (*dir && *dir == *cwd) {
|
|
|
|
dir++;
|
|
|
|
cwd++;
|
|
|
|
}
|
|
|
|
if (*dir)
|
|
|
|
return NULL;
|
|
|
|
if (*cwd == '/')
|
|
|
|
return cwd + 1;
|
|
|
|
return cwd;
|
|
|
|
}
|
|
|
|
|
|
|
|
int is_inside_dir(const char *dir)
|
|
|
|
{
|
|
|
|
char buffer[PATH_MAX];
|
|
|
|
return get_relative_cwd(buffer, sizeof(buffer), dir) != NULL;
|
|
|
|
}
|
2007-09-28 15:28:54 +00:00
|
|
|
|
|
|
|
int remove_dir_recursively(struct strbuf *path, int only_empty)
|
|
|
|
{
|
|
|
|
DIR *dir = opendir(path->buf);
|
|
|
|
struct dirent *e;
|
|
|
|
int ret = 0, original_len = path->len, len;
|
|
|
|
|
|
|
|
if (!dir)
|
|
|
|
return -1;
|
|
|
|
if (path->buf[original_len - 1] != '/')
|
|
|
|
strbuf_addch(path, '/');
|
|
|
|
|
|
|
|
len = path->len;
|
|
|
|
while ((e = readdir(dir)) != NULL) {
|
|
|
|
struct stat st;
|
|
|
|
if ((e->d_name[0] == '.') &&
|
|
|
|
((e->d_name[1] == 0) ||
|
|
|
|
((e->d_name[1] == '.') && e->d_name[2] == 0)))
|
|
|
|
continue; /* "." and ".." */
|
|
|
|
|
|
|
|
strbuf_setlen(path, len);
|
|
|
|
strbuf_addstr(path, e->d_name);
|
|
|
|
if (lstat(path->buf, &st))
|
|
|
|
; /* fall thru */
|
|
|
|
else if (S_ISDIR(st.st_mode)) {
|
|
|
|
if (!remove_dir_recursively(path, only_empty))
|
|
|
|
continue; /* happy */
|
|
|
|
} else if (!only_empty && !unlink(path->buf))
|
|
|
|
continue; /* happy, too */
|
|
|
|
|
|
|
|
/* path too long, stat fails, or non-directory still exists */
|
|
|
|
ret = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
closedir(dir);
|
|
|
|
|
|
|
|
strbuf_setlen(path, original_len);
|
|
|
|
if (!ret)
|
|
|
|
ret = rmdir(path->buf);
|
|
|
|
return ret;
|
|
|
|
}
|
core.excludesfile clean-up
There are inconsistencies in the way commands currently handle
the core.excludesfile configuration variable. The problem is
the variable is too new to be noticed by anything other than
git-add and git-status.
* git-ls-files does not notice any of the "ignore" files by
default, as it predates the standardized set of ignore files.
The calling scripts established the convention to use
.git/info/exclude, .gitignore, and later core.excludesfile.
* git-add and git-status know about it because they call
add_excludes_from_file() directly with their own notion of
which standard set of ignore files to use. This is just a
stupid duplication of code that need to be updated every time
the definition of the standard set of ignore files is
changed.
* git-read-tree takes --exclude-per-directory=<gitignore>,
not because the flexibility was needed. Again, this was
because the option predates the standardization of the ignore
files.
* git-merge-recursive uses hardcoded per-directory .gitignore
and nothing else. git-clean (scripted version) does not
honor core.* because its call to underlying ls-files does not
know about it. git-clean in C (parked in 'pu') doesn't either.
We probably could change git-ls-files to use the standard set
when no excludes are specified on the command line and ignore
processing was asked, or something like that, but that will be a
change in semantics and might break people's scripts in a subtle
way. I am somewhat reluctant to make such a change.
On the other hand, I think it makes perfect sense to fix
git-read-tree, git-merge-recursive and git-clean to follow the
same rule as other commands. I do not think of a valid use case
to give an exclude-per-directory that is nonstandard to
read-tree command, outside a "negative" test in the t1004 test
script.
This patch is the first step to untangle this mess.
The next step would be to teach read-tree, merge-recursive and
clean (in C) to use setup_standard_excludes().
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-14 08:05:00 +00:00
|
|
|
|
|
|
|
void setup_standard_excludes(struct dir_struct *dir)
|
|
|
|
{
|
|
|
|
const char *path;
|
|
|
|
|
|
|
|
dir->exclude_per_dir = ".gitignore";
|
|
|
|
path = git_path("info/exclude");
|
|
|
|
if (!access(path, R_OK))
|
|
|
|
add_excludes_from_file(dir, path);
|
|
|
|
if (excludes_file && !access(excludes_file, R_OK))
|
|
|
|
add_excludes_from_file(dir, excludes_file);
|
|
|
|
}
|