rev-list: disable object/refname ambiguity check with --stdin

diff --git a/pathspec.c b/pathspec.c
index 82ede57206cd136933f5df4de7537c7d85ab14db..87b3b82f1fd9baee7758159e5e3119b6da0655e3 100644 (file)
--- a/pathspec.c
+++ b/pathspec.c
@@ -32,7 +32,7 @@ void add_pathspec_matches_against_index(const struct pathspec *pathspec,
        if (!num_unmatched)
                return;
        for (i = 0; i < active_nr; i++) {
-               struct cache_entry *ce = active_cache[i];
+               const struct cache_entry *ce = active_cache[i];
                match_pathspec_depth(pathspec, ce->name, ce_namelen(ce), 0, seen);
        }
 }
@@ -57,8 +57,6 @@ char *find_pathspecs_matching_against_index(const struct pathspec *pathspec)
  *
  * Possible future magic semantics include stuff like:
  *
- *     { PATHSPEC_NOGLOB, '!', "noglob" },
- *     { PATHSPEC_ICASE, '\0', "icase" },
  *     { PATHSPEC_RECURSIVE, '*', "recursive" },
  *     { PATHSPEC_REGEXP, '\0', "regexp" },
  *
@@ -70,6 +68,9 @@ static struct pathspec_magic {
        const char *name;
 } pathspec_magic[] = {
        { PATHSPEC_FROMTOP, '/', "top" },
+       { PATHSPEC_LITERAL,   0, "literal" },
+       { PATHSPEC_GLOB,   '\0', "glob" },
+       { PATHSPEC_ICASE,  '\0', "icase" },
 };
 
 /*
@@ -91,12 +92,47 @@ static unsigned prefix_pathspec(struct pathspec_item *item,
                                const char *prefix, int prefixlen,
                                const char *elt)
 {
-       unsigned magic = 0, short_magic = 0;
+       static int literal_global = -1;
+       static int glob_global = -1;
+       static int noglob_global = -1;
+       static int icase_global = -1;
+       unsigned magic = 0, short_magic = 0, global_magic = 0;
        const char *copyfrom = elt, *long_magic_end = NULL;
        char *match;
        int i, pathspec_prefix = -1;
 
-       if (elt[0] != ':') {
+       if (literal_global < 0)
+               literal_global = git_env_bool(GIT_LITERAL_PATHSPECS_ENVIRONMENT, 0);
+       if (literal_global)
+               global_magic |= PATHSPEC_LITERAL;
+
+       if (glob_global < 0)
+               glob_global = git_env_bool(GIT_GLOB_PATHSPECS_ENVIRONMENT, 0);
+       if (glob_global)
+               global_magic |= PATHSPEC_GLOB;
+
+       if (noglob_global < 0)
+               noglob_global = git_env_bool(GIT_NOGLOB_PATHSPECS_ENVIRONMENT, 0);
+
+       if (glob_global && noglob_global)
+               die(_("global 'glob' and 'noglob' pathspec settings are incompatible"));
+
+
+       if (icase_global < 0)
+               icase_global = git_env_bool(GIT_ICASE_PATHSPECS_ENVIRONMENT, 0);
+       if (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"));
+
+       if (flags & PATHSPEC_LITERAL_PATH)
+               global_magic = 0;
+
+       if (elt[0] != ':' || literal_global ||
+           (flags & PATHSPEC_LITERAL_PATH)) {
                ; /* nothing to do */
        } else if (elt[1] == '(') {
                /* longhand */
@@ -161,10 +197,23 @@ static unsigned prefix_pathspec(struct pathspec_item *item,
        magic |= short_magic;
        *p_short_magic = short_magic;
 
+       /* --noglob-pathspec adds :(literal) _unless_ :(glob) is specified */
+       if (noglob_global && !(magic & PATHSPEC_GLOB))
+               global_magic |= PATHSPEC_LITERAL;
+
+       /* --glob-pathspec is overridden by :(literal) */
+       if ((global_magic & PATHSPEC_GLOB) && (magic & PATHSPEC_LITERAL))
+               global_magic &= ~PATHSPEC_GLOB;
+
+       magic |= global_magic;
+
        if (pathspec_prefix >= 0 &&
            (prefixlen || (prefix && *prefix)))
                die("BUG: 'prefix' magic is supposed to be used at worktree's root");
 
+       if ((magic & PATHSPEC_LITERAL) && (magic & PATHSPEC_GLOB))
+               die(_("%s: 'literal' and 'glob' are incompatible"), elt);
+
        if (pathspec_prefix >= 0) {
                match = xstrdup(copyfrom);
                prefixlen = pathspec_prefix;
@@ -184,9 +233,11 @@ static unsigned prefix_pathspec(struct pathspec_item *item,
        if (flags & PATHSPEC_PREFIX_ORIGIN) {
                struct strbuf sb = STRBUF_INIT;
                const char *start = elt;
-               if (prefixlen && !limit_pathspec_to_literal()) {
+               if (prefixlen && !literal_global) {
                        /* Preserve the actual prefix length of each pattern */
-                       if (long_magic_end) {
+                       if (short_magic)
+                               die("BUG: prefixing on short magic is not supported");
+                       else if (long_magic_end) {
                                strbuf_add(&sb, start, long_magic_end - start);
                                strbuf_addf(&sb, ",prefix:%d", prefixlen);
                                start = long_magic_end;
@@ -232,7 +283,7 @@ static unsigned prefix_pathspec(struct pathspec_item *item,
                                     elt, ce_len, ce->name);
                }
 
-       if (limit_pathspec_to_literal())
+       if (magic & PATHSPEC_LITERAL)
                item->nowildcard_len = item->len;
        else {
                item->nowildcard_len = simple_length(item->match);
@@ -240,10 +291,17 @@ static unsigned prefix_pathspec(struct pathspec_item *item,
                        item->nowildcard_len = prefixlen;
        }
        item->flags = 0;
-       if (item->nowildcard_len < item->len &&
-           item->match[item->nowildcard_len] == '*' &&
-           no_wildcard(item->match + item->nowildcard_len + 1))
-               item->flags |= PATHSPEC_ONESTAR;
+       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;
+       }
 
        /* sanity checks, pathspec matchers assume these are sane */
        assert(item->nowildcard_len <= item->len &&
@@ -351,6 +409,9 @@ void parse_pathspec(struct pathspec *pathspec,
                item[i].magic = prefix_pathspec(item + i, &short_magic,
                                                argv + i, flags,
                                                prefix, prefixlen, entry);
+               if ((flags & PATHSPEC_LITERAL_PATH) &&
+                   !(magic_mask & PATHSPEC_LITERAL))
+                       item[i].magic |= PATHSPEC_LITERAL;
                if (item[i].magic & magic_mask)
                        unsupported_magic(entry,
                                          item[i].magic & magic_mask,
@@ -398,7 +459,8 @@ const char **get_pathspec(const char *prefix, const char **pathspec)
 {
        struct pathspec ps;
        parse_pathspec(&ps,
-                      PATHSPEC_ALL_MAGIC & ~PATHSPEC_FROMTOP,
+                      PATHSPEC_ALL_MAGIC &
+                      ~(PATHSPEC_FROMTOP | PATHSPEC_LITERAL),
                       PATHSPEC_PREFER_CWD,
                       prefix, pathspec);
        return ps._raw;