system_path: move RUNTIME_PREFIX to a sub-function

diff --git a/pathspec.c b/pathspec.c
index e53530e7a6fb3fb09b6b7c43edd6357939eb0f9c..7ababb315944d5536ec251b19937beef5def2538 100644 (file)
--- a/pathspec.c
+++ b/pathspec.c
@@ -296,22 +296,33 @@ static void strip_submodule_slash_expensive(struct pathspec_item *item)
        }
 }
 
+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);
+       }
+}
+
 /*
- * Take an element of a pathspec and check for magic signatures.
- * Append the result to the prefix. Return the magic bitmap.
- *
- * For now, we only parse the syntax and throw out anything other than
- * "top" magic.
- *
- * NEEDSWORK: This needs to be rewritten when we start migrating
- * get_pathspec() users to use the "struct pathspec" interface.  For
- * example, a pathspec element may be marked as case-insensitive, but
- * the prefix part must always match literally, and a single stupid
- * string cannot express such a case.
+ * Perform the initialization of a pathspec_item based on a pathspec element.
  */
-static unsigned prefix_pathspec(struct pathspec_item *item, unsigned flags,
-                               const char *prefix, int prefixlen,
-                               const char *elt)
+static void init_pathspec_item(struct pathspec_item *item, unsigned flags,
+                              const char *prefix, int prefixlen,
+                              const char *elt)
 {
        unsigned magic = 0, element_magic = 0;
        const char *copyfrom = elt;
@@ -329,6 +340,8 @@ static unsigned prefix_pathspec(struct pathspec_item *item, unsigned flags,
                magic |= get_global_magic(element_magic);
        }
 
+       item->magic = magic;
+
        if (pathspec_prefix >= 0 &&
            (prefixlen || (prefix && *prefix)))
                die("BUG: 'prefix' magic is supposed to be used at worktree's root");
@@ -399,9 +412,18 @@ static unsigned prefix_pathspec(struct pathspec_item *item, unsigned flags,
        }
 
        /* sanity checks, pathspec matchers assume these are sane */
-       assert(item->nowildcard_len <= item->len &&
-              item->prefix         <= item->len);
-       return magic;
+       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)");
+       }
 }
 
 static int pathspec_item_cmp(const void *a_, const void *b_)
@@ -501,8 +523,7 @@ void parse_pathspec(struct pathspec *pathspec,
        for (i = 0; i < n; i++) {
                entry = argv[i];
 
-               item[i].magic = prefix_pathspec(item + i, flags,
-                                               prefix, prefixlen, entry);
+               init_pathspec_item(item + i, flags, prefix, prefixlen, entry);
 
                if (item[i].magic & PATHSPEC_EXCLUDE)
                        nr_exclude++;