2013-01-06 16:58:08 +00:00
|
|
|
#include "cache.h"
|
|
|
|
#include "dir.h"
|
|
|
|
#include "pathspec.h"
|
2017-03-13 18:23:21 +00:00
|
|
|
#include "attr.h"
|
2013-01-06 16:58:08 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Finds which of the given pathspecs match items in the index.
|
|
|
|
*
|
|
|
|
* For each pathspec, sets the corresponding entry in the seen[] array
|
|
|
|
* (which should be specs items long, i.e. the same size as pathspec)
|
|
|
|
* to the nature of the "closest" (i.e. most specific) match found for
|
|
|
|
* that pathspec in the index, if it was a closer type of match than
|
|
|
|
* the existing entry. As an optimization, matching is skipped
|
|
|
|
* altogether if seen[] already only contains non-zero entries.
|
|
|
|
*
|
|
|
|
* If seen[] has not already been written to, it may make sense
|
2013-01-06 16:58:09 +00:00
|
|
|
* to use find_pathspecs_matching_against_index() instead.
|
2013-01-06 16:58:08 +00:00
|
|
|
*/
|
2013-07-14 08:36:00 +00:00
|
|
|
void add_pathspec_matches_against_index(const struct pathspec *pathspec,
|
|
|
|
char *seen)
|
2013-01-06 16:58:08 +00:00
|
|
|
{
|
|
|
|
int num_unmatched = 0, i;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since we are walking the index as if we were walking the directory,
|
|
|
|
* we have to mark the matched pathspec as seen; otherwise we will
|
|
|
|
* mistakenly think that the user gave a pathspec that did not match
|
|
|
|
* anything.
|
|
|
|
*/
|
2013-07-14 08:36:00 +00:00
|
|
|
for (i = 0; i < pathspec->nr; i++)
|
2013-01-06 16:58:08 +00:00
|
|
|
if (!seen[i])
|
|
|
|
num_unmatched++;
|
|
|
|
if (!num_unmatched)
|
|
|
|
return;
|
|
|
|
for (i = 0; i < active_nr; i++) {
|
Convert "struct cache_entry *" to "const ..." wherever possible
I attempted to make index_state->cache[] a "const struct cache_entry **"
to find out how existing entries in index are modified and where. The
question I have is what do we do if we really need to keep track of on-disk
changes in the index. The result is
- diff-lib.c: setting CE_UPTODATE
- name-hash.c: setting CE_HASHED
- preload-index.c, read-cache.c, unpack-trees.c and
builtin/update-index: obvious
- entry.c: write_entry() may refresh the checked out entry via
fill_stat_cache_info(). This causes "non-const struct cache_entry
*" in builtin/apply.c, builtin/checkout-index.c and
builtin/checkout.c
- builtin/ls-files.c: --with-tree changes stagemask and may set
CE_UPDATE
Of these, write_entry() and its call sites are probably most
interesting because it modifies on-disk info. But this is stat info
and can be retrieved via refresh, at least for porcelain
commands. Other just uses ce_flags for local purposes.
So, keeping track of "dirty" entries is just a matter of setting a
flag in index modification functions exposed by read-cache.c. Except
unpack-trees, the rest of the code base does not do anything funny
behind read-cache's back.
The actual patch is less valueable than the summary above. But if
anyone wants to re-identify the above sites. Applying this patch, then
this:
diff --git a/cache.h b/cache.h
index 430d021..1692891 100644
--- a/cache.h
+++ b/cache.h
@@ -267,7 +267,7 @@ static inline unsigned int canon_mode(unsigned int mode)
#define cache_entry_size(len) (offsetof(struct cache_entry,name) + (len) + 1)
struct index_state {
- struct cache_entry **cache;
+ const struct cache_entry **cache;
unsigned int version;
unsigned int cache_nr, cache_alloc, cache_changed;
struct string_list *resolve_undo;
will help quickly identify them without bogus warnings.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 15:29:00 +00:00
|
|
|
const struct cache_entry *ce = active_cache[i];
|
2014-01-24 13:40:28 +00:00
|
|
|
ce_path_match(ce, pathspec, seen);
|
2013-01-06 16:58:08 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Finds which of the given pathspecs match items in the index.
|
|
|
|
*
|
2013-01-06 16:58:09 +00:00
|
|
|
* This is a one-shot wrapper around add_pathspec_matches_against_index()
|
|
|
|
* which allocates, populates, and returns a seen[] array indicating the
|
|
|
|
* nature of the "closest" (i.e. most specific) matches which each of the
|
|
|
|
* given pathspecs achieves against all items in the index.
|
2013-01-06 16:58:08 +00:00
|
|
|
*/
|
2013-07-14 08:36:00 +00:00
|
|
|
char *find_pathspecs_matching_against_index(const struct pathspec *pathspec)
|
2013-01-06 16:58:08 +00:00
|
|
|
{
|
2013-07-14 08:36:00 +00:00
|
|
|
char *seen = xcalloc(pathspec->nr, 1);
|
|
|
|
add_pathspec_matches_against_index(pathspec, seen);
|
2013-01-06 16:58:08 +00:00
|
|
|
return seen;
|
|
|
|
}
|
2013-01-06 16:58:10 +00:00
|
|
|
|
|
|
|
/*
|
2013-07-14 08:35:25 +00:00
|
|
|
* Magic pathspec
|
|
|
|
*
|
|
|
|
* Possible future magic semantics include stuff like:
|
|
|
|
*
|
|
|
|
* { PATHSPEC_RECURSIVE, '*', "recursive" },
|
|
|
|
* { PATHSPEC_REGEXP, '\0', "regexp" },
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static struct pathspec_magic {
|
|
|
|
unsigned bit;
|
|
|
|
char mnemonic; /* this cannot be ':'! */
|
|
|
|
const char *name;
|
|
|
|
} pathspec_magic[] = {
|
2017-01-04 18:04:10 +00:00
|
|
|
{ PATHSPEC_FROMTOP, '/', "top" },
|
|
|
|
{ PATHSPEC_LITERAL, '\0', "literal" },
|
|
|
|
{ PATHSPEC_GLOB, '\0', "glob" },
|
|
|
|
{ PATHSPEC_ICASE, '\0', "icase" },
|
|
|
|
{ PATHSPEC_EXCLUDE, '!', "exclude" },
|
2017-03-13 18:23:21 +00:00
|
|
|
{ PATHSPEC_ATTR, '\0', "attr" },
|
2013-07-14 08:35:25 +00:00
|
|
|
};
|
|
|
|
|
2017-01-04 18:04:04 +00:00
|
|
|
static void prefix_magic(struct strbuf *sb, int prefixlen, unsigned magic)
|
pathspec.c: support adding prefix magic to a pathspec with mnemonic magic
Back in 233c3e6 (parse_pathspec: preserve prefix length via
PATHSPEC_PREFIX_ORIGIN - 2013-07-14), parse_pathspec() is taught to
save prefix length as a dynamic magic. This is needed when the
pathspec is passed to another process and and prefix lenght would be
lost.
Back then we support two cases. If the pathspec is normal, e.g. "abc",
we simply add the prefix to become ":(prefix:2)abc". If the pathspec
contains long magic, e.g. ":(foo,bar)abc" then we turn it to
":(foo,bar,prefix:2)abc". We do not support prefixing on short form,
because the only supported mnemonic '/' disappears after the the
preprocessing steps.
With the introduction of exclude magic with mnemonic '!', we need to
add support for the short form case so that ':!abc' becomes
':(exclude,prefix:2)abc'. Without this, it will break
cd Documentation
git add -p -- . ':!technical'
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-12-06 07:30:49 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
strbuf_addstr(sb, ":(");
|
|
|
|
for (i = 0; i < ARRAY_SIZE(pathspec_magic); i++)
|
2017-01-04 18:04:04 +00:00
|
|
|
if (magic & pathspec_magic[i].bit) {
|
pathspec.c: support adding prefix magic to a pathspec with mnemonic magic
Back in 233c3e6 (parse_pathspec: preserve prefix length via
PATHSPEC_PREFIX_ORIGIN - 2013-07-14), parse_pathspec() is taught to
save prefix length as a dynamic magic. This is needed when the
pathspec is passed to another process and and prefix lenght would be
lost.
Back then we support two cases. If the pathspec is normal, e.g. "abc",
we simply add the prefix to become ":(prefix:2)abc". If the pathspec
contains long magic, e.g. ":(foo,bar)abc" then we turn it to
":(foo,bar,prefix:2)abc". We do not support prefixing on short form,
because the only supported mnemonic '/' disappears after the the
preprocessing steps.
With the introduction of exclude magic with mnemonic '!', we need to
add support for the short form case so that ':!abc' becomes
':(exclude,prefix:2)abc'. Without this, it will break
cd Documentation
git add -p -- . ':!technical'
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-12-06 07:30:49 +00:00
|
|
|
if (sb->buf[sb->len - 1] != '(')
|
|
|
|
strbuf_addch(sb, ',');
|
|
|
|
strbuf_addstr(sb, pathspec_magic[i].name);
|
|
|
|
}
|
|
|
|
strbuf_addf(sb, ",prefix:%d)", prefixlen);
|
|
|
|
}
|
|
|
|
|
pathspec: allow escaped query values
In our own .gitattributes file we have attributes such as:
*.[ch] whitespace=indent,trail,space
When querying for attributes we want to be able to ask for the exact
value, i.e.
git ls-files :(attr:whitespace=indent,trail,space)
should work, but the commas are used in the attr magic to introduce
the next attr, such that this query currently fails with
fatal: Invalid pathspec magic 'trail' in ':(attr:whitespace=indent,trail,space)'
This change allows escaping characters by a backslash, such that the query
git ls-files :(attr:whitespace=indent\,trail\,space)
will match all path that have the value "indent,trail,space" for the
whitespace attribute. To accomplish this, we need to modify two places.
First `parse_long_magic` needs to not stop early upon seeing a comma or
closing paren that is escaped. As a second step we need to remove any
escaping from the attr value.
Based on a patch by Stefan Beller <sbeller@google.com>
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-13 18:23:22 +00:00
|
|
|
static size_t strcspn_escaped(const char *s, const char *stop)
|
|
|
|
{
|
|
|
|
const char *i;
|
|
|
|
|
|
|
|
for (i = s; *i; i++) {
|
|
|
|
/* skip the escaped character */
|
|
|
|
if (i[0] == '\\' && i[1]) {
|
|
|
|
i++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strchr(stop, *i))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return i - s;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int invalid_value_char(const char ch)
|
|
|
|
{
|
|
|
|
if (isalnum(ch) || strchr(",-_", ch))
|
|
|
|
return 0;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *attr_value_unescape(const char *value)
|
|
|
|
{
|
|
|
|
const char *src;
|
|
|
|
char *dst, *ret;
|
|
|
|
|
|
|
|
ret = xmallocz(strlen(value));
|
|
|
|
for (src = value, dst = ret; *src; src++, dst++) {
|
|
|
|
if (*src == '\\') {
|
|
|
|
if (!src[1])
|
|
|
|
die(_("Escape character '\\' not allowed as "
|
|
|
|
"last character in attr value"));
|
|
|
|
src++;
|
|
|
|
}
|
|
|
|
if (invalid_value_char(*src))
|
|
|
|
die("cannot use '%c' for value matching", *src);
|
|
|
|
*dst = *src;
|
|
|
|
}
|
|
|
|
*dst = '\0';
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-03-13 18:23:21 +00:00
|
|
|
static void parse_pathspec_attr_match(struct pathspec_item *item, const char *value)
|
|
|
|
{
|
|
|
|
struct string_list_item *si;
|
|
|
|
struct string_list list = STRING_LIST_INIT_DUP;
|
|
|
|
|
|
|
|
if (item->attr_check || item->attr_match)
|
|
|
|
die(_("Only one 'attr:' specification is allowed."));
|
|
|
|
|
|
|
|
if (!value || !*value)
|
|
|
|
die(_("attr spec must not be empty"));
|
|
|
|
|
|
|
|
string_list_split(&list, value, ' ', -1);
|
|
|
|
string_list_remove_empty_items(&list, 0);
|
|
|
|
|
|
|
|
item->attr_check = attr_check_alloc();
|
|
|
|
item->attr_match = xcalloc(list.nr, sizeof(struct attr_match));
|
|
|
|
|
|
|
|
for_each_string_list_item(si, &list) {
|
|
|
|
size_t attr_len;
|
|
|
|
char *attr_name;
|
|
|
|
const struct git_attr *a;
|
|
|
|
|
|
|
|
int j = item->attr_match_nr++;
|
|
|
|
const char *attr = si->string;
|
|
|
|
struct attr_match *am = &item->attr_match[j];
|
|
|
|
|
|
|
|
switch (*attr) {
|
|
|
|
case '!':
|
|
|
|
am->match_mode = MATCH_UNSPECIFIED;
|
|
|
|
attr++;
|
|
|
|
attr_len = strlen(attr);
|
|
|
|
break;
|
|
|
|
case '-':
|
|
|
|
am->match_mode = MATCH_UNSET;
|
|
|
|
attr++;
|
|
|
|
attr_len = strlen(attr);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
attr_len = strcspn(attr, "=");
|
|
|
|
if (attr[attr_len] != '=')
|
|
|
|
am->match_mode = MATCH_SET;
|
|
|
|
else {
|
pathspec: allow escaped query values
In our own .gitattributes file we have attributes such as:
*.[ch] whitespace=indent,trail,space
When querying for attributes we want to be able to ask for the exact
value, i.e.
git ls-files :(attr:whitespace=indent,trail,space)
should work, but the commas are used in the attr magic to introduce
the next attr, such that this query currently fails with
fatal: Invalid pathspec magic 'trail' in ':(attr:whitespace=indent,trail,space)'
This change allows escaping characters by a backslash, such that the query
git ls-files :(attr:whitespace=indent\,trail\,space)
will match all path that have the value "indent,trail,space" for the
whitespace attribute. To accomplish this, we need to modify two places.
First `parse_long_magic` needs to not stop early upon seeing a comma or
closing paren that is escaped. As a second step we need to remove any
escaping from the attr value.
Based on a patch by Stefan Beller <sbeller@google.com>
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-13 18:23:22 +00:00
|
|
|
const char *v = &attr[attr_len + 1];
|
2017-03-13 18:23:21 +00:00
|
|
|
am->match_mode = MATCH_VALUE;
|
pathspec: allow escaped query values
In our own .gitattributes file we have attributes such as:
*.[ch] whitespace=indent,trail,space
When querying for attributes we want to be able to ask for the exact
value, i.e.
git ls-files :(attr:whitespace=indent,trail,space)
should work, but the commas are used in the attr magic to introduce
the next attr, such that this query currently fails with
fatal: Invalid pathspec magic 'trail' in ':(attr:whitespace=indent,trail,space)'
This change allows escaping characters by a backslash, such that the query
git ls-files :(attr:whitespace=indent\,trail\,space)
will match all path that have the value "indent,trail,space" for the
whitespace attribute. To accomplish this, we need to modify two places.
First `parse_long_magic` needs to not stop early upon seeing a comma or
closing paren that is escaped. As a second step we need to remove any
escaping from the attr value.
Based on a patch by Stefan Beller <sbeller@google.com>
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-13 18:23:22 +00:00
|
|
|
am->value = attr_value_unescape(v);
|
2017-03-13 18:23:21 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
attr_name = xmemdupz(attr, attr_len);
|
|
|
|
a = git_attr(attr_name);
|
|
|
|
if (!a)
|
|
|
|
die(_("invalid attribute name %s"), attr_name);
|
|
|
|
|
|
|
|
attr_check_append(item->attr_check, a);
|
|
|
|
|
|
|
|
free(attr_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (item->attr_check->nr != item->attr_match_nr)
|
|
|
|
die("BUG: should have same number of entries");
|
|
|
|
|
|
|
|
string_list_clear(&list, 0);
|
|
|
|
}
|
|
|
|
|
2017-01-04 18:04:05 +00:00
|
|
|
static inline int get_literal_global(void)
|
|
|
|
{
|
|
|
|
static int literal = -1;
|
|
|
|
|
|
|
|
if (literal < 0)
|
|
|
|
literal = git_env_bool(GIT_LITERAL_PATHSPECS_ENVIRONMENT, 0);
|
|
|
|
|
|
|
|
return literal;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int get_glob_global(void)
|
|
|
|
{
|
|
|
|
static int glob = -1;
|
|
|
|
|
|
|
|
if (glob < 0)
|
|
|
|
glob = git_env_bool(GIT_GLOB_PATHSPECS_ENVIRONMENT, 0);
|
|
|
|
|
|
|
|
return glob;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int get_noglob_global(void)
|
|
|
|
{
|
|
|
|
static int noglob = -1;
|
|
|
|
|
|
|
|
if (noglob < 0)
|
|
|
|
noglob = git_env_bool(GIT_NOGLOB_PATHSPECS_ENVIRONMENT, 0);
|
|
|
|
|
|
|
|
return noglob;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int get_icase_global(void)
|
|
|
|
{
|
|
|
|
static int icase = -1;
|
|
|
|
|
|
|
|
if (icase < 0)
|
|
|
|
icase = git_env_bool(GIT_ICASE_PATHSPECS_ENVIRONMENT, 0);
|
|
|
|
|
|
|
|
return icase;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int get_global_magic(int element_magic)
|
|
|
|
{
|
|
|
|
int global_magic = 0;
|
|
|
|
|
|
|
|
if (get_literal_global())
|
|
|
|
global_magic |= PATHSPEC_LITERAL;
|
|
|
|
|
|
|
|
/* --glob-pathspec is overridden by :(literal) */
|
|
|
|
if (get_glob_global() && !(element_magic & PATHSPEC_LITERAL))
|
|
|
|
global_magic |= PATHSPEC_GLOB;
|
|
|
|
|
|
|
|
if (get_glob_global() && get_noglob_global())
|
|
|
|
die(_("global 'glob' and 'noglob' pathspec settings are incompatible"));
|
|
|
|
|
|
|
|
if (get_icase_global())
|
|
|
|
global_magic |= PATHSPEC_ICASE;
|
|
|
|
|
|
|
|
if ((global_magic & PATHSPEC_LITERAL) &&
|
|
|
|
(global_magic & ~PATHSPEC_LITERAL))
|
|
|
|
die(_("global 'literal' pathspec setting is incompatible "
|
|
|
|
"with all other global pathspec settings"));
|
|
|
|
|
|
|
|
/* --noglob-pathspec adds :(literal) _unless_ :(glob) is specified */
|
|
|
|
if (get_noglob_global() && !(element_magic & PATHSPEC_GLOB))
|
|
|
|
global_magic |= PATHSPEC_LITERAL;
|
|
|
|
|
|
|
|
return global_magic;
|
|
|
|
}
|
|
|
|
|
2017-01-04 18:04:07 +00:00
|
|
|
/*
|
|
|
|
* Parse the pathspec element looking for long magic
|
|
|
|
*
|
|
|
|
* saves all magic in 'magic'
|
|
|
|
* if prefix magic is used, save the prefix length in 'prefix_len'
|
|
|
|
* returns the position in 'elem' after all magic has been parsed
|
|
|
|
*/
|
|
|
|
static const char *parse_long_magic(unsigned *magic, int *prefix_len,
|
2017-03-13 18:23:21 +00:00
|
|
|
struct pathspec_item *item,
|
2017-01-04 18:04:07 +00:00
|
|
|
const char *elem)
|
|
|
|
{
|
|
|
|
const char *pos;
|
|
|
|
const char *nextat;
|
|
|
|
|
|
|
|
for (pos = elem + 2; *pos && *pos != ')'; pos = nextat) {
|
pathspec: allow escaped query values
In our own .gitattributes file we have attributes such as:
*.[ch] whitespace=indent,trail,space
When querying for attributes we want to be able to ask for the exact
value, i.e.
git ls-files :(attr:whitespace=indent,trail,space)
should work, but the commas are used in the attr magic to introduce
the next attr, such that this query currently fails with
fatal: Invalid pathspec magic 'trail' in ':(attr:whitespace=indent,trail,space)'
This change allows escaping characters by a backslash, such that the query
git ls-files :(attr:whitespace=indent\,trail\,space)
will match all path that have the value "indent,trail,space" for the
whitespace attribute. To accomplish this, we need to modify two places.
First `parse_long_magic` needs to not stop early upon seeing a comma or
closing paren that is escaped. As a second step we need to remove any
escaping from the attr value.
Based on a patch by Stefan Beller <sbeller@google.com>
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-13 18:23:22 +00:00
|
|
|
size_t len = strcspn_escaped(pos, ",)");
|
2017-01-04 18:04:07 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
if (pos[len] == ',')
|
|
|
|
nextat = pos + len + 1; /* handle ',' */
|
|
|
|
else
|
|
|
|
nextat = pos + len; /* handle ')' and '\0' */
|
|
|
|
|
|
|
|
if (!len)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (starts_with(pos, "prefix:")) {
|
|
|
|
char *endptr;
|
|
|
|
*prefix_len = strtol(pos + 7, &endptr, 10);
|
|
|
|
if (endptr - pos != len)
|
|
|
|
die(_("invalid parameter for pathspec magic 'prefix'"));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2017-03-13 18:23:21 +00:00
|
|
|
if (starts_with(pos, "attr:")) {
|
|
|
|
char *attr_body = xmemdupz(pos + 5, len - 5);
|
|
|
|
parse_pathspec_attr_match(item, attr_body);
|
|
|
|
*magic |= PATHSPEC_ATTR;
|
|
|
|
free(attr_body);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2017-01-04 18:04:07 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(pathspec_magic); i++) {
|
|
|
|
if (strlen(pathspec_magic[i].name) == len &&
|
|
|
|
!strncmp(pathspec_magic[i].name, pos, len)) {
|
|
|
|
*magic |= pathspec_magic[i].bit;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ARRAY_SIZE(pathspec_magic) <= i)
|
|
|
|
die(_("Invalid pathspec magic '%.*s' in '%s'"),
|
|
|
|
(int) len, pos, elem);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*pos != ')')
|
|
|
|
die(_("Missing ')' at the end of pathspec magic in '%s'"),
|
|
|
|
elem);
|
|
|
|
pos++;
|
|
|
|
|
|
|
|
return pos;
|
|
|
|
}
|
|
|
|
|
2017-01-04 18:04:06 +00:00
|
|
|
/*
|
|
|
|
* Parse the pathspec element looking for short magic
|
|
|
|
*
|
|
|
|
* saves all magic in 'magic'
|
|
|
|
* returns the position in 'elem' after all magic has been parsed
|
|
|
|
*/
|
|
|
|
static const char *parse_short_magic(unsigned *magic, const char *elem)
|
|
|
|
{
|
|
|
|
const char *pos;
|
|
|
|
|
|
|
|
for (pos = elem + 1; *pos && *pos != ':'; pos++) {
|
|
|
|
char ch = *pos;
|
|
|
|
int i;
|
|
|
|
|
2017-02-08 05:05:28 +00:00
|
|
|
/* Special case alias for '!' */
|
|
|
|
if (ch == '^') {
|
|
|
|
*magic |= PATHSPEC_EXCLUDE;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2017-01-04 18:04:06 +00:00
|
|
|
if (!is_pathspec_magic(ch))
|
|
|
|
break;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(pathspec_magic); i++) {
|
|
|
|
if (pathspec_magic[i].mnemonic == ch) {
|
|
|
|
*magic |= pathspec_magic[i].bit;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ARRAY_SIZE(pathspec_magic) <= i)
|
|
|
|
die(_("Unimplemented pathspec magic '%c' in '%s'"),
|
|
|
|
ch, elem);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*pos == ':')
|
|
|
|
pos++;
|
|
|
|
|
|
|
|
return pos;
|
|
|
|
}
|
|
|
|
|
2017-01-04 18:04:08 +00:00
|
|
|
static const char *parse_element_magic(unsigned *magic, int *prefix_len,
|
2017-03-13 18:23:21 +00:00
|
|
|
struct pathspec_item *item,
|
2017-01-04 18:04:08 +00:00
|
|
|
const char *elem)
|
|
|
|
{
|
|
|
|
if (elem[0] != ':' || get_literal_global())
|
|
|
|
return elem; /* nothing to do */
|
|
|
|
else if (elem[1] == '(')
|
|
|
|
/* longhand */
|
2017-03-13 18:23:21 +00:00
|
|
|
return parse_long_magic(magic, prefix_len, item, elem);
|
2017-01-04 18:04:08 +00:00
|
|
|
else
|
|
|
|
/* shorthand */
|
|
|
|
return parse_short_magic(magic, elem);
|
|
|
|
}
|
|
|
|
|
2017-01-04 18:04:09 +00:00
|
|
|
static void strip_submodule_slash_cheap(struct pathspec_item *item)
|
|
|
|
{
|
|
|
|
if (item->len >= 1 && item->match[item->len - 1] == '/') {
|
|
|
|
int i = cache_name_pos(item->match, item->len - 1);
|
|
|
|
|
|
|
|
if (i >= 0 && S_ISGITLINK(active_cache[i]->ce_mode)) {
|
|
|
|
item->len--;
|
|
|
|
item->match[item->len] = '\0';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void strip_submodule_slash_expensive(struct pathspec_item *item)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < active_nr; i++) {
|
|
|
|
struct cache_entry *ce = active_cache[i];
|
|
|
|
int ce_len = ce_namelen(ce);
|
|
|
|
|
|
|
|
if (!S_ISGITLINK(ce->ce_mode))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (item->len <= ce_len || item->match[ce_len] != '/' ||
|
|
|
|
memcmp(ce->name, item->match, ce_len))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (item->len == ce_len + 1) {
|
|
|
|
/* strip trailing slash */
|
|
|
|
item->len--;
|
|
|
|
item->match[item->len] = '\0';
|
|
|
|
} else {
|
|
|
|
die(_("Pathspec '%s' is in submodule '%.*s'"),
|
|
|
|
item->original, ce_len, ce->name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
pathspec: give better message for submodule related pathspec error
Every once in a while someone complains to the mailing list to have
run into this weird assertion[1]. The usual response from the mailing
list is link to old discussions[2], and acknowledging the problem
stating it is known.
This patch accomplishes two things:
1. Switch assert() to die("BUG") to give a more readable message.
2. Take one of the cases where we hit a BUG and turn it into a normal
"there was something wrong with the input" message.
This assertion triggered for cases where there wasn't a programming
bug, but just bogus input. In particular, if the user asks for a
pathspec that is inside a submodule, we shouldn't assert() or
die("BUG"); we should tell the user their request is bogus.
The only reason we did not check for it, is the expensive nature
of such a check, so callers avoid setting the flag
PATHSPEC_STRIP_SUBMODULE_SLASH_EXPENSIVE. However when we die due
to bogus input, the expense of CPU cycles spent outweighs the user
wondering what went wrong, so run that check unconditionally before
dying with a more generic error message.
Note: There is a case (e.g. "git -C submodule add .") in which we call
strip_submodule_slash_expensive, as git-add requests it via the flag
PATHSPEC_STRIP_SUBMODULE_SLASH_EXPENSIVE, but the assert used to
trigger nevertheless, because the flag PATHSPEC_LITERAL was not set,
such that we executed
if (item->nowildcard_len < prefixlen)
item->nowildcard_len = prefixlen;
and prefixlen was not adapted (e.g. it was computed from "submodule/")
So in the die_inside_submodule_path function we also need handle paths,
that were stripped before, i.e. are the exact submodule path. This
is why the conditions in die_inside_submodule_path are slightly
different than in strip_submodule_slash_expensive.
[1] https://www.google.com/search?q=item-%3Enowildcard_len
[2] http://git.661346.n2.nabble.com/assert-failed-in-submodule-edge-case-td7628687.html
https://www.spinics.net/lists/git/msg249473.html
Helped-by: Jeff King <peff@peff.net>
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-09 23:16:50 +00:00
|
|
|
static void die_inside_submodule_path(struct pathspec_item *item)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < active_nr; i++) {
|
|
|
|
struct cache_entry *ce = active_cache[i];
|
|
|
|
int ce_len = ce_namelen(ce);
|
|
|
|
|
|
|
|
if (!S_ISGITLINK(ce->ce_mode))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (item->len < ce_len ||
|
|
|
|
!(item->match[ce_len] == '/' || item->match[ce_len] == '\0') ||
|
|
|
|
memcmp(ce->name, item->match, ce_len))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
die(_("Pathspec '%s' is in submodule '%.*s'"),
|
|
|
|
item->original, ce_len, ce->name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-14 08:35:25 +00:00
|
|
|
/*
|
2017-01-04 18:04:11 +00:00
|
|
|
* Perform the initialization of a pathspec_item based on a pathspec element.
|
2013-01-06 16:58:10 +00:00
|
|
|
*/
|
2017-01-04 18:04:11 +00:00
|
|
|
static void init_pathspec_item(struct pathspec_item *item, unsigned flags,
|
|
|
|
const char *prefix, int prefixlen,
|
|
|
|
const char *elt)
|
2013-01-06 16:58:10 +00:00
|
|
|
{
|
2017-01-04 18:04:05 +00:00
|
|
|
unsigned magic = 0, element_magic = 0;
|
2017-01-04 18:04:04 +00:00
|
|
|
const char *copyfrom = elt;
|
2013-07-14 08:35:28 +00:00
|
|
|
char *match;
|
2017-01-04 18:04:09 +00:00
|
|
|
int pathspec_prefix = -1;
|
2013-07-14 08:35:25 +00:00
|
|
|
|
2017-03-13 18:23:21 +00:00
|
|
|
item->attr_check = NULL;
|
|
|
|
item->attr_match = NULL;
|
|
|
|
item->attr_match_nr = 0;
|
|
|
|
|
2017-01-04 18:04:05 +00:00
|
|
|
/* PATHSPEC_LITERAL_PATH ignores magic */
|
2017-01-04 18:04:08 +00:00
|
|
|
if (flags & PATHSPEC_LITERAL_PATH) {
|
2017-01-04 18:04:05 +00:00
|
|
|
magic = PATHSPEC_LITERAL;
|
2017-01-04 18:04:08 +00:00
|
|
|
} else {
|
|
|
|
copyfrom = parse_element_magic(&element_magic,
|
|
|
|
&pathspec_prefix,
|
2017-03-13 18:23:21 +00:00
|
|
|
item,
|
2017-01-04 18:04:08 +00:00
|
|
|
elt);
|
|
|
|
magic |= element_magic;
|
2017-01-04 18:04:05 +00:00
|
|
|
magic |= get_global_magic(element_magic);
|
2017-01-04 18:04:08 +00:00
|
|
|
}
|
2013-07-14 08:35:28 +00:00
|
|
|
|
2017-01-04 18:04:11 +00:00
|
|
|
item->magic = magic;
|
|
|
|
|
2013-07-14 08:36:04 +00:00
|
|
|
if (pathspec_prefix >= 0 &&
|
|
|
|
(prefixlen || (prefix && *prefix)))
|
|
|
|
die("BUG: 'prefix' magic is supposed to be used at worktree's root");
|
|
|
|
|
2013-07-14 08:36:08 +00:00
|
|
|
if ((magic & PATHSPEC_LITERAL) && (magic & PATHSPEC_GLOB))
|
|
|
|
die(_("%s: 'literal' and 'glob' are incompatible"), elt);
|
|
|
|
|
2017-01-04 18:04:10 +00:00
|
|
|
/* Create match string which will be used for pathspec matching */
|
2013-07-14 08:36:04 +00:00
|
|
|
if (pathspec_prefix >= 0) {
|
|
|
|
match = xstrdup(copyfrom);
|
|
|
|
prefixlen = pathspec_prefix;
|
|
|
|
} else if (magic & PATHSPEC_FROMTOP) {
|
2013-07-14 08:35:28 +00:00
|
|
|
match = xstrdup(copyfrom);
|
2013-07-14 08:36:03 +00:00
|
|
|
prefixlen = 0;
|
|
|
|
} else {
|
2017-01-04 18:04:10 +00:00
|
|
|
match = prefix_path_gently(prefix, prefixlen,
|
|
|
|
&prefixlen, copyfrom);
|
2013-07-14 08:36:03 +00:00
|
|
|
if (!match)
|
|
|
|
die(_("%s: '%s' is outside repository"), elt, copyfrom);
|
|
|
|
}
|
2017-01-04 18:04:10 +00:00
|
|
|
|
2017-01-04 18:04:00 +00:00
|
|
|
item->match = match;
|
2017-01-04 18:04:10 +00:00
|
|
|
item->len = strlen(item->match);
|
|
|
|
item->prefix = prefixlen;
|
|
|
|
|
2013-07-14 08:35:35 +00:00
|
|
|
/*
|
|
|
|
* Prefix the pathspec (keep all magic) and assign to
|
|
|
|
* original. Useful for passing to another command.
|
|
|
|
*/
|
2017-01-04 18:04:04 +00:00
|
|
|
if ((flags & PATHSPEC_PREFIX_ORIGIN) &&
|
2017-01-04 18:04:05 +00:00
|
|
|
prefixlen && !get_literal_global()) {
|
2013-07-14 08:35:35 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2017-01-04 18:04:04 +00:00
|
|
|
|
|
|
|
/* Preserve the actual prefix length of each pattern */
|
|
|
|
prefix_magic(&sb, prefixlen, element_magic);
|
|
|
|
|
2013-07-14 08:35:35 +00:00
|
|
|
strbuf_addstr(&sb, match);
|
|
|
|
item->original = strbuf_detach(&sb, NULL);
|
2017-01-04 18:04:01 +00:00
|
|
|
} else {
|
|
|
|
item->original = xstrdup(elt);
|
|
|
|
}
|
2013-07-14 08:35:33 +00:00
|
|
|
|
2017-01-04 18:04:09 +00:00
|
|
|
if (flags & PATHSPEC_STRIP_SUBMODULE_SLASH_CHEAP)
|
|
|
|
strip_submodule_slash_cheap(item);
|
2013-07-14 08:35:33 +00:00
|
|
|
|
2013-07-14 08:35:34 +00:00
|
|
|
if (flags & PATHSPEC_STRIP_SUBMODULE_SLASH_EXPENSIVE)
|
2017-01-04 18:04:09 +00:00
|
|
|
strip_submodule_slash_expensive(item);
|
2013-07-14 08:35:34 +00:00
|
|
|
|
2017-01-04 18:04:10 +00:00
|
|
|
if (magic & PATHSPEC_LITERAL) {
|
2013-07-14 08:35:28 +00:00
|
|
|
item->nowildcard_len = item->len;
|
2017-01-04 18:04:10 +00:00
|
|
|
} else {
|
2013-07-14 08:35:28 +00:00
|
|
|
item->nowildcard_len = simple_length(item->match);
|
2013-07-14 08:36:03 +00:00
|
|
|
if (item->nowildcard_len < prefixlen)
|
|
|
|
item->nowildcard_len = prefixlen;
|
|
|
|
}
|
2017-01-04 18:04:10 +00:00
|
|
|
|
2013-07-14 08:35:28 +00:00
|
|
|
item->flags = 0;
|
2013-07-14 08:36:08 +00:00
|
|
|
if (magic & PATHSPEC_GLOB) {
|
|
|
|
/*
|
|
|
|
* FIXME: should we enable ONESTAR in _GLOB for
|
|
|
|
* pattern "* * / * . c"?
|
|
|
|
*/
|
|
|
|
} else {
|
|
|
|
if (item->nowildcard_len < item->len &&
|
|
|
|
item->match[item->nowildcard_len] == '*' &&
|
|
|
|
no_wildcard(item->match + item->nowildcard_len + 1))
|
|
|
|
item->flags |= PATHSPEC_ONESTAR;
|
2013-01-06 16:58:10 +00:00
|
|
|
}
|
2013-07-14 08:36:03 +00:00
|
|
|
|
|
|
|
/* sanity checks, pathspec matchers assume these are sane */
|
pathspec: give better message for submodule related pathspec error
Every once in a while someone complains to the mailing list to have
run into this weird assertion[1]. The usual response from the mailing
list is link to old discussions[2], and acknowledging the problem
stating it is known.
This patch accomplishes two things:
1. Switch assert() to die("BUG") to give a more readable message.
2. Take one of the cases where we hit a BUG and turn it into a normal
"there was something wrong with the input" message.
This assertion triggered for cases where there wasn't a programming
bug, but just bogus input. In particular, if the user asks for a
pathspec that is inside a submodule, we shouldn't assert() or
die("BUG"); we should tell the user their request is bogus.
The only reason we did not check for it, is the expensive nature
of such a check, so callers avoid setting the flag
PATHSPEC_STRIP_SUBMODULE_SLASH_EXPENSIVE. However when we die due
to bogus input, the expense of CPU cycles spent outweighs the user
wondering what went wrong, so run that check unconditionally before
dying with a more generic error message.
Note: There is a case (e.g. "git -C submodule add .") in which we call
strip_submodule_slash_expensive, as git-add requests it via the flag
PATHSPEC_STRIP_SUBMODULE_SLASH_EXPENSIVE, but the assert used to
trigger nevertheless, because the flag PATHSPEC_LITERAL was not set,
such that we executed
if (item->nowildcard_len < prefixlen)
item->nowildcard_len = prefixlen;
and prefixlen was not adapted (e.g. it was computed from "submodule/")
So in the die_inside_submodule_path function we also need handle paths,
that were stripped before, i.e. are the exact submodule path. This
is why the conditions in die_inside_submodule_path are slightly
different than in strip_submodule_slash_expensive.
[1] https://www.google.com/search?q=item-%3Enowildcard_len
[2] http://git.661346.n2.nabble.com/assert-failed-in-submodule-edge-case-td7628687.html
https://www.spinics.net/lists/git/msg249473.html
Helped-by: Jeff King <peff@peff.net>
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-09 23:16:50 +00:00
|
|
|
if (item->nowildcard_len > item->len ||
|
|
|
|
item->prefix > item->len) {
|
|
|
|
/*
|
|
|
|
* This case can be triggered by the user pointing us to a
|
|
|
|
* pathspec inside a submodule, which is an input error.
|
|
|
|
* Detect that here and complain, but fallback in the
|
|
|
|
* non-submodule case to a BUG, as we have no idea what
|
|
|
|
* would trigger that.
|
|
|
|
*/
|
|
|
|
die_inside_submodule_path(item);
|
|
|
|
die ("BUG: item->nowildcard_len > item->len || item->prefix > item->len)");
|
|
|
|
}
|
2013-07-14 08:35:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int pathspec_item_cmp(const void *a_, const void *b_)
|
|
|
|
{
|
|
|
|
struct pathspec_item *a, *b;
|
|
|
|
|
|
|
|
a = (struct pathspec_item *)a_;
|
|
|
|
b = (struct pathspec_item *)b_;
|
|
|
|
return strcmp(a->match, b->match);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void NORETURN unsupported_magic(const char *pattern,
|
2017-01-04 18:04:03 +00:00
|
|
|
unsigned magic)
|
2013-07-14 08:35:28 +00:00
|
|
|
{
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2017-01-04 18:04:02 +00:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(pathspec_magic); i++) {
|
2013-07-14 08:35:28 +00:00
|
|
|
const struct pathspec_magic *m = pathspec_magic + i;
|
|
|
|
if (!(magic & m->bit))
|
|
|
|
continue;
|
|
|
|
if (sb.len)
|
2017-01-04 18:04:03 +00:00
|
|
|
strbuf_addstr(&sb, ", ");
|
|
|
|
|
|
|
|
if (m->mnemonic)
|
|
|
|
strbuf_addf(&sb, _("'%s' (mnemonic: '%c')"),
|
|
|
|
m->name, m->mnemonic);
|
2013-07-14 08:35:28 +00:00
|
|
|
else
|
|
|
|
strbuf_addf(&sb, "'%s'", m->name);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* We may want to substitute "this command" with a command
|
|
|
|
* name. E.g. when add--interactive dies when running
|
|
|
|
* "checkout -p"
|
|
|
|
*/
|
|
|
|
die(_("%s: pathspec magic not supported by this command: %s"),
|
|
|
|
pattern, sb.buf);
|
2013-01-06 16:58:10 +00:00
|
|
|
}
|
2013-01-06 16:58:11 +00:00
|
|
|
|
|
|
|
/*
|
2013-07-14 08:35:28 +00:00
|
|
|
* Given command line arguments and a prefix, convert the input to
|
|
|
|
* pathspec. die() if any magic in magic_mask is used.
|
2013-01-06 16:58:11 +00:00
|
|
|
*/
|
2013-07-14 08:35:28 +00:00
|
|
|
void parse_pathspec(struct pathspec *pathspec,
|
|
|
|
unsigned magic_mask, unsigned flags,
|
|
|
|
const char *prefix, const char **argv)
|
2013-01-06 16:58:11 +00:00
|
|
|
{
|
2013-07-14 08:35:28 +00:00
|
|
|
struct pathspec_item *item;
|
|
|
|
const char *entry = argv ? *argv : NULL;
|
2016-06-22 23:00:24 +00:00
|
|
|
int i, n, prefixlen, warn_empty_string, nr_exclude = 0;
|
2013-07-14 08:35:28 +00:00
|
|
|
|
|
|
|
memset(pathspec, 0, sizeof(*pathspec));
|
|
|
|
|
2013-07-14 08:35:32 +00:00
|
|
|
if (flags & PATHSPEC_MAXDEPTH_VALID)
|
|
|
|
pathspec->magic |= PATHSPEC_MAXDEPTH;
|
|
|
|
|
2013-07-14 08:35:28 +00:00
|
|
|
/* No arguments, no prefix -> no pathspec */
|
|
|
|
if (!entry && !prefix)
|
|
|
|
return;
|
|
|
|
|
2013-07-14 08:35:30 +00:00
|
|
|
if ((flags & PATHSPEC_PREFER_CWD) &&
|
|
|
|
(flags & PATHSPEC_PREFER_FULL))
|
|
|
|
die("BUG: PATHSPEC_PREFER_CWD and PATHSPEC_PREFER_FULL are incompatible");
|
|
|
|
|
2013-07-14 08:35:28 +00:00
|
|
|
/* No arguments with prefix -> prefix pathspec */
|
|
|
|
if (!entry) {
|
2013-07-14 08:35:30 +00:00
|
|
|
if (flags & PATHSPEC_PREFER_FULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!(flags & PATHSPEC_PREFER_CWD))
|
|
|
|
die("BUG: PATHSPEC_PREFER_CWD requires arguments");
|
|
|
|
|
2014-07-19 13:56:26 +00:00
|
|
|
pathspec->items = item = xcalloc(1, sizeof(*item));
|
2017-01-04 18:04:01 +00:00
|
|
|
item->match = xstrdup(prefix);
|
|
|
|
item->original = xstrdup(prefix);
|
2013-07-14 08:35:28 +00:00
|
|
|
item->nowildcard_len = item->len = strlen(prefix);
|
2013-07-14 08:36:03 +00:00
|
|
|
item->prefix = item->len;
|
2013-07-14 08:35:28 +00:00
|
|
|
pathspec->nr = 1;
|
|
|
|
return;
|
2013-01-06 16:58:11 +00:00
|
|
|
}
|
2013-07-14 08:35:28 +00:00
|
|
|
|
|
|
|
n = 0;
|
2016-06-22 23:00:24 +00:00
|
|
|
warn_empty_string = 1;
|
|
|
|
while (argv[n]) {
|
|
|
|
if (*argv[n] == '\0' && warn_empty_string) {
|
|
|
|
warning(_("empty strings as pathspecs will be made invalid in upcoming releases. "
|
|
|
|
"please use . instead if you meant to match all paths"));
|
|
|
|
warn_empty_string = 0;
|
|
|
|
}
|
2013-07-14 08:35:28 +00:00
|
|
|
n++;
|
2016-06-22 23:00:24 +00:00
|
|
|
}
|
2013-07-14 08:35:28 +00:00
|
|
|
|
|
|
|
pathspec->nr = n;
|
2017-02-08 05:08:15 +00:00
|
|
|
ALLOC_ARRAY(pathspec->items, n + 1);
|
2016-02-22 22:44:25 +00:00
|
|
|
item = pathspec->items;
|
2013-07-14 08:35:28 +00:00
|
|
|
prefixlen = prefix ? strlen(prefix) : 0;
|
|
|
|
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
entry = argv[i];
|
|
|
|
|
2017-01-04 18:04:11 +00:00
|
|
|
init_pathspec_item(item + i, flags, prefix, prefixlen, entry);
|
2017-01-04 18:04:05 +00:00
|
|
|
|
2013-12-06 07:30:48 +00:00
|
|
|
if (item[i].magic & PATHSPEC_EXCLUDE)
|
|
|
|
nr_exclude++;
|
2013-07-14 08:35:28 +00:00
|
|
|
if (item[i].magic & magic_mask)
|
2017-01-04 18:04:03 +00:00
|
|
|
unsupported_magic(entry, item[i].magic & magic_mask);
|
2013-07-14 08:35:34 +00:00
|
|
|
|
|
|
|
if ((flags & PATHSPEC_SYMLINK_LEADING_PATH) &&
|
|
|
|
has_symlink_leading_path(item[i].match, item[i].len)) {
|
|
|
|
die(_("pathspec '%s' is beyond a symbolic link"), entry);
|
|
|
|
}
|
|
|
|
|
2013-07-14 08:35:28 +00:00
|
|
|
if (item[i].nowildcard_len < item[i].len)
|
|
|
|
pathspec->has_wildcard = 1;
|
|
|
|
pathspec->magic |= item[i].magic;
|
|
|
|
}
|
|
|
|
|
2017-02-08 05:08:15 +00:00
|
|
|
/*
|
|
|
|
* If everything is an exclude pattern, add one positive pattern
|
|
|
|
* that matches everyting. We allocated an extra one for this.
|
|
|
|
*/
|
|
|
|
if (nr_exclude == n) {
|
|
|
|
int plen = (!(flags & PATHSPEC_PREFER_CWD)) ? 0 : prefixlen;
|
|
|
|
init_pathspec_item(item + n, 0, prefix, plen, "");
|
|
|
|
pathspec->nr++;
|
|
|
|
}
|
2013-07-14 08:35:45 +00:00
|
|
|
|
|
|
|
if (pathspec->magic & PATHSPEC_MAXDEPTH) {
|
|
|
|
if (flags & PATHSPEC_KEEP_ORDER)
|
|
|
|
die("BUG: PATHSPEC_MAXDEPTH_VALID and PATHSPEC_KEEP_ORDER are incompatible");
|
2016-09-29 15:27:31 +00:00
|
|
|
QSORT(pathspec->items, pathspec->nr, pathspec_item_cmp);
|
2013-07-14 08:35:45 +00:00
|
|
|
}
|
2013-07-14 08:35:25 +00:00
|
|
|
}
|
|
|
|
|
2013-07-14 08:35:27 +00:00
|
|
|
void copy_pathspec(struct pathspec *dst, const struct pathspec *src)
|
|
|
|
{
|
2017-03-13 18:23:21 +00:00
|
|
|
int i, j;
|
2017-01-04 18:04:01 +00:00
|
|
|
|
2013-07-14 08:35:27 +00:00
|
|
|
*dst = *src;
|
2016-02-22 22:44:25 +00:00
|
|
|
ALLOC_ARRAY(dst->items, dst->nr);
|
2016-09-25 07:24:03 +00:00
|
|
|
COPY_ARRAY(dst->items, src->items, dst->nr);
|
2017-01-04 18:04:01 +00:00
|
|
|
|
|
|
|
for (i = 0; i < dst->nr; i++) {
|
2017-03-13 18:23:21 +00:00
|
|
|
struct pathspec_item *d = &dst->items[i];
|
|
|
|
struct pathspec_item *s = &src->items[i];
|
|
|
|
|
|
|
|
d->match = xstrdup(s->match);
|
|
|
|
d->original = xstrdup(s->original);
|
|
|
|
|
|
|
|
ALLOC_ARRAY(d->attr_match, d->attr_match_nr);
|
|
|
|
COPY_ARRAY(d->attr_match, s->attr_match, d->attr_match_nr);
|
|
|
|
for (j = 0; j < d->attr_match_nr; j++) {
|
|
|
|
const char *value = s->attr_match[j].value;
|
|
|
|
d->attr_match[j].value = xstrdup_or_null(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
d->attr_check = attr_check_dup(s->attr_check);
|
2017-01-04 18:04:01 +00:00
|
|
|
}
|
2013-07-14 08:35:27 +00:00
|
|
|
}
|
2013-07-14 08:35:59 +00:00
|
|
|
|
2016-06-02 21:09:22 +00:00
|
|
|
void clear_pathspec(struct pathspec *pathspec)
|
2013-07-14 08:35:59 +00:00
|
|
|
{
|
2017-03-13 18:23:21 +00:00
|
|
|
int i, j;
|
2017-01-04 18:04:01 +00:00
|
|
|
|
|
|
|
for (i = 0; i < pathspec->nr; i++) {
|
|
|
|
free(pathspec->items[i].match);
|
|
|
|
free(pathspec->items[i].original);
|
2017-03-13 18:23:21 +00:00
|
|
|
|
|
|
|
for (j = 0; j < pathspec->items[j].attr_match_nr; j++)
|
|
|
|
free(pathspec->items[i].attr_match[j].value);
|
|
|
|
free(pathspec->items[i].attr_match);
|
|
|
|
|
|
|
|
if (pathspec->items[i].attr_check)
|
|
|
|
attr_check_free(pathspec->items[i].attr_check);
|
2017-01-04 18:04:01 +00:00
|
|
|
}
|
2017-03-13 18:23:21 +00:00
|
|
|
|
2013-07-14 08:35:59 +00:00
|
|
|
free(pathspec->items);
|
|
|
|
pathspec->items = NULL;
|
2017-01-04 18:04:01 +00:00
|
|
|
pathspec->nr = 0;
|
2013-01-06 16:58:11 +00:00
|
|
|
}
|