10 * Finds which of the given pathspecs match items in the index.
12 * For each pathspec, sets the corresponding entry in the seen[] array
13 * (which should be specs items long, i.e. the same size as pathspec)
14 * to the nature of the "closest" (i.e. most specific) match found for
15 * that pathspec in the index, if it was a closer type of match than
16 * the existing entry. As an optimization, matching is skipped
17 * altogether if seen[] already only contains non-zero entries.
19 * If seen[] has not already been written to, it may make sense
20 * to use find_pathspecs_matching_against_index() instead.
22 void add_pathspec_matches_against_index(const struct pathspec *pathspec,
23 const struct index_state *istate,
26 int num_unmatched = 0, i;
29 * Since we are walking the index as if we were walking the directory,
30 * we have to mark the matched pathspec as seen; otherwise we will
31 * mistakenly think that the user gave a pathspec that did not match
34 for (i = 0; i < pathspec->nr; i++)
39 for (i = 0; i < istate->cache_nr; i++) {
40 const struct cache_entry *ce = istate->cache[i];
41 ce_path_match(istate, ce, pathspec, seen);
46 * Finds which of the given pathspecs match items in the index.
48 * This is a one-shot wrapper around add_pathspec_matches_against_index()
49 * which allocates, populates, and returns a seen[] array indicating the
50 * nature of the "closest" (i.e. most specific) matches which each of the
51 * given pathspecs achieves against all items in the index.
53 char *find_pathspecs_matching_against_index(const struct pathspec *pathspec,
54 const struct index_state *istate)
56 char *seen = xcalloc(pathspec->nr, 1);
57 add_pathspec_matches_against_index(pathspec, istate, seen);
64 * Possible future magic semantics include stuff like:
66 * { PATHSPEC_RECURSIVE, '*', "recursive" },
67 * { PATHSPEC_REGEXP, '\0', "regexp" },
71 static struct pathspec_magic {
73 char mnemonic; /* this cannot be ':'! */
75 } pathspec_magic[] = {
76 { PATHSPEC_FROMTOP, '/', "top" },
77 { PATHSPEC_LITERAL, '\0', "literal" },
78 { PATHSPEC_GLOB, '\0', "glob" },
79 { PATHSPEC_ICASE, '\0', "icase" },
80 { PATHSPEC_EXCLUDE, '!', "exclude" },
81 { PATHSPEC_ATTR, '\0', "attr" },
84 static void prefix_magic(struct strbuf *sb, int prefixlen, unsigned magic)
87 strbuf_addstr(sb, ":(");
88 for (i = 0; i < ARRAY_SIZE(pathspec_magic); i++)
89 if (magic & pathspec_magic[i].bit) {
90 if (sb->buf[sb->len - 1] != '(')
91 strbuf_addch(sb, ',');
92 strbuf_addstr(sb, pathspec_magic[i].name);
94 strbuf_addf(sb, ",prefix:%d)", prefixlen);
97 static size_t strcspn_escaped(const char *s, const char *stop)
101 for (i = s; *i; i++) {
102 /* skip the escaped character */
103 if (i[0] == '\\' && i[1]) {
108 if (strchr(stop, *i))
114 static inline int invalid_value_char(const char ch)
116 if (isalnum(ch) || strchr(",-_", ch))
121 static char *attr_value_unescape(const char *value)
126 ret = xmallocz(strlen(value));
127 for (src = value, dst = ret; *src; src++, dst++) {
130 die(_("Escape character '\\' not allowed as "
131 "last character in attr value"));
134 if (invalid_value_char(*src))
135 die("cannot use '%c' for value matching", *src);
142 static void parse_pathspec_attr_match(struct pathspec_item *item, const char *value)
144 struct string_list_item *si;
145 struct string_list list = STRING_LIST_INIT_DUP;
147 if (item->attr_check || item->attr_match)
148 die(_("Only one 'attr:' specification is allowed."));
150 if (!value || !*value)
151 die(_("attr spec must not be empty"));
153 string_list_split(&list, value, ' ', -1);
154 string_list_remove_empty_items(&list, 0);
156 item->attr_check = attr_check_alloc();
157 item->attr_match = xcalloc(list.nr, sizeof(struct attr_match));
159 for_each_string_list_item(si, &list) {
162 const struct git_attr *a;
164 int j = item->attr_match_nr++;
165 const char *attr = si->string;
166 struct attr_match *am = &item->attr_match[j];
170 am->match_mode = MATCH_UNSPECIFIED;
172 attr_len = strlen(attr);
175 am->match_mode = MATCH_UNSET;
177 attr_len = strlen(attr);
180 attr_len = strcspn(attr, "=");
181 if (attr[attr_len] != '=')
182 am->match_mode = MATCH_SET;
184 const char *v = &attr[attr_len + 1];
185 am->match_mode = MATCH_VALUE;
186 am->value = attr_value_unescape(v);
191 attr_name = xmemdupz(attr, attr_len);
192 a = git_attr(attr_name);
194 die(_("invalid attribute name %s"), attr_name);
196 attr_check_append(item->attr_check, a);
201 if (item->attr_check->nr != item->attr_match_nr)
202 BUG("should have same number of entries");
204 string_list_clear(&list, 0);
207 static inline int get_literal_global(void)
209 static int literal = -1;
212 literal = git_env_bool(GIT_LITERAL_PATHSPECS_ENVIRONMENT, 0);
217 static inline int get_glob_global(void)
219 static int glob = -1;
222 glob = git_env_bool(GIT_GLOB_PATHSPECS_ENVIRONMENT, 0);
227 static inline int get_noglob_global(void)
229 static int noglob = -1;
232 noglob = git_env_bool(GIT_NOGLOB_PATHSPECS_ENVIRONMENT, 0);
237 static inline int get_icase_global(void)
239 static int icase = -1;
242 icase = git_env_bool(GIT_ICASE_PATHSPECS_ENVIRONMENT, 0);
247 static int get_global_magic(int element_magic)
249 int global_magic = 0;
251 if (get_literal_global())
252 global_magic |= PATHSPEC_LITERAL;
254 /* --glob-pathspec is overridden by :(literal) */
255 if (get_glob_global() && !(element_magic & PATHSPEC_LITERAL))
256 global_magic |= PATHSPEC_GLOB;
258 if (get_glob_global() && get_noglob_global())
259 die(_("global 'glob' and 'noglob' pathspec settings are incompatible"));
261 if (get_icase_global())
262 global_magic |= PATHSPEC_ICASE;
264 if ((global_magic & PATHSPEC_LITERAL) &&
265 (global_magic & ~PATHSPEC_LITERAL))
266 die(_("global 'literal' pathspec setting is incompatible "
267 "with all other global pathspec settings"));
269 /* --noglob-pathspec adds :(literal) _unless_ :(glob) is specified */
270 if (get_noglob_global() && !(element_magic & PATHSPEC_GLOB))
271 global_magic |= PATHSPEC_LITERAL;
277 * Parse the pathspec element looking for long magic
279 * saves all magic in 'magic'
280 * if prefix magic is used, save the prefix length in 'prefix_len'
281 * returns the position in 'elem' after all magic has been parsed
283 static const char *parse_long_magic(unsigned *magic, int *prefix_len,
284 struct pathspec_item *item,
290 for (pos = elem + 2; *pos && *pos != ')'; pos = nextat) {
291 size_t len = strcspn_escaped(pos, ",)");
295 nextat = pos + len + 1; /* handle ',' */
297 nextat = pos + len; /* handle ')' and '\0' */
302 if (starts_with(pos, "prefix:")) {
304 *prefix_len = strtol(pos + 7, &endptr, 10);
305 if (endptr - pos != len)
306 die(_("invalid parameter for pathspec magic 'prefix'"));
310 if (starts_with(pos, "attr:")) {
311 char *attr_body = xmemdupz(pos + 5, len - 5);
312 parse_pathspec_attr_match(item, attr_body);
313 *magic |= PATHSPEC_ATTR;
318 for (i = 0; i < ARRAY_SIZE(pathspec_magic); i++) {
319 if (strlen(pathspec_magic[i].name) == len &&
320 !strncmp(pathspec_magic[i].name, pos, len)) {
321 *magic |= pathspec_magic[i].bit;
326 if (ARRAY_SIZE(pathspec_magic) <= i)
327 die(_("Invalid pathspec magic '%.*s' in '%s'"),
328 (int) len, pos, elem);
332 die(_("Missing ')' at the end of pathspec magic in '%s'"),
340 * Parse the pathspec element looking for short magic
342 * saves all magic in 'magic'
343 * returns the position in 'elem' after all magic has been parsed
345 static const char *parse_short_magic(unsigned *magic, const char *elem)
349 for (pos = elem + 1; *pos && *pos != ':'; pos++) {
353 /* Special case alias for '!' */
355 *magic |= PATHSPEC_EXCLUDE;
359 if (!is_pathspec_magic(ch))
362 for (i = 0; i < ARRAY_SIZE(pathspec_magic); i++) {
363 if (pathspec_magic[i].mnemonic == ch) {
364 *magic |= pathspec_magic[i].bit;
369 if (ARRAY_SIZE(pathspec_magic) <= i)
370 die(_("Unimplemented pathspec magic '%c' in '%s'"),
380 static const char *parse_element_magic(unsigned *magic, int *prefix_len,
381 struct pathspec_item *item,
384 if (elem[0] != ':' || get_literal_global())
385 return elem; /* nothing to do */
386 else if (elem[1] == '(')
388 return parse_long_magic(magic, prefix_len, item, elem);
391 return parse_short_magic(magic, elem);
395 * Perform the initialization of a pathspec_item based on a pathspec element.
397 static void init_pathspec_item(struct pathspec_item *item, unsigned flags,
398 const char *prefix, int prefixlen,
401 unsigned magic = 0, element_magic = 0;
402 const char *copyfrom = elt;
404 int pathspec_prefix = -1;
406 item->attr_check = NULL;
407 item->attr_match = NULL;
408 item->attr_match_nr = 0;
410 /* PATHSPEC_LITERAL_PATH ignores magic */
411 if (flags & PATHSPEC_LITERAL_PATH) {
412 magic = PATHSPEC_LITERAL;
414 copyfrom = parse_element_magic(&element_magic,
418 magic |= element_magic;
419 magic |= get_global_magic(element_magic);
424 if (pathspec_prefix >= 0 &&
425 (prefixlen || (prefix && *prefix)))
426 BUG("'prefix' magic is supposed to be used at worktree's root");
428 if ((magic & PATHSPEC_LITERAL) && (magic & PATHSPEC_GLOB))
429 die(_("%s: 'literal' and 'glob' are incompatible"), elt);
431 /* Create match string which will be used for pathspec matching */
432 if (pathspec_prefix >= 0) {
433 match = xstrdup(copyfrom);
434 prefixlen = pathspec_prefix;
435 } else if (magic & PATHSPEC_FROMTOP) {
436 match = xstrdup(copyfrom);
439 match = prefix_path_gently(prefix, prefixlen,
440 &prefixlen, copyfrom);
442 const char *hint_path = get_git_work_tree();
444 hint_path = get_git_dir();
445 die(_("%s: '%s' is outside repository at '%s'"), elt,
446 copyfrom, absolute_path(hint_path));
451 item->len = strlen(item->match);
452 item->prefix = prefixlen;
455 * Prefix the pathspec (keep all magic) and assign to
456 * original. Useful for passing to another command.
458 if ((flags & PATHSPEC_PREFIX_ORIGIN) &&
459 !get_literal_global()) {
460 struct strbuf sb = STRBUF_INIT;
462 /* Preserve the actual prefix length of each pattern */
463 prefix_magic(&sb, prefixlen, element_magic);
465 strbuf_addstr(&sb, match);
466 item->original = strbuf_detach(&sb, NULL);
468 item->original = xstrdup(elt);
471 if (magic & PATHSPEC_LITERAL) {
472 item->nowildcard_len = item->len;
474 item->nowildcard_len = simple_length(item->match);
475 if (item->nowildcard_len < prefixlen)
476 item->nowildcard_len = prefixlen;
480 if (magic & PATHSPEC_GLOB) {
482 * FIXME: should we enable ONESTAR in _GLOB for
483 * pattern "* * / * . c"?
486 if (item->nowildcard_len < item->len &&
487 item->match[item->nowildcard_len] == '*' &&
488 no_wildcard(item->match + item->nowildcard_len + 1))
489 item->flags |= PATHSPEC_ONESTAR;
492 /* sanity checks, pathspec matchers assume these are sane */
493 if (item->nowildcard_len > item->len ||
494 item->prefix > item->len) {
495 BUG("error initializing pathspec_item");
499 static int pathspec_item_cmp(const void *a_, const void *b_)
501 struct pathspec_item *a, *b;
503 a = (struct pathspec_item *)a_;
504 b = (struct pathspec_item *)b_;
505 return strcmp(a->match, b->match);
508 static void NORETURN unsupported_magic(const char *pattern,
511 struct strbuf sb = STRBUF_INIT;
513 for (i = 0; i < ARRAY_SIZE(pathspec_magic); i++) {
514 const struct pathspec_magic *m = pathspec_magic + i;
515 if (!(magic & m->bit))
518 strbuf_addstr(&sb, ", ");
521 strbuf_addf(&sb, _("'%s' (mnemonic: '%c')"),
522 m->name, m->mnemonic);
524 strbuf_addf(&sb, "'%s'", m->name);
527 * We may want to substitute "this command" with a command
528 * name. E.g. when add--interactive dies when running
531 die(_("%s: pathspec magic not supported by this command: %s"),
535 void parse_pathspec(struct pathspec *pathspec,
536 unsigned magic_mask, unsigned flags,
537 const char *prefix, const char **argv)
539 struct pathspec_item *item;
540 const char *entry = argv ? *argv : NULL;
541 int i, n, prefixlen, nr_exclude = 0;
543 memset(pathspec, 0, sizeof(*pathspec));
545 if (flags & PATHSPEC_MAXDEPTH_VALID)
546 pathspec->magic |= PATHSPEC_MAXDEPTH;
548 /* No arguments, no prefix -> no pathspec */
549 if (!entry && !prefix)
552 if ((flags & PATHSPEC_PREFER_CWD) &&
553 (flags & PATHSPEC_PREFER_FULL))
554 BUG("PATHSPEC_PREFER_CWD and PATHSPEC_PREFER_FULL are incompatible");
556 /* No arguments with prefix -> prefix pathspec */
558 if (flags & PATHSPEC_PREFER_FULL)
561 if (!(flags & PATHSPEC_PREFER_CWD))
562 BUG("PATHSPEC_PREFER_CWD requires arguments");
564 pathspec->items = item = xcalloc(1, sizeof(*item));
565 item->match = xstrdup(prefix);
566 item->original = xstrdup(prefix);
567 item->nowildcard_len = item->len = strlen(prefix);
568 item->prefix = item->len;
575 if (*argv[n] == '\0')
576 die("empty string is not a valid pathspec. "
577 "please use . instead if you meant to match all paths");
582 ALLOC_ARRAY(pathspec->items, n + 1);
583 item = pathspec->items;
584 prefixlen = prefix ? strlen(prefix) : 0;
586 for (i = 0; i < n; i++) {
589 init_pathspec_item(item + i, flags, prefix, prefixlen, entry);
591 if (item[i].magic & PATHSPEC_EXCLUDE)
593 if (item[i].magic & magic_mask)
594 unsupported_magic(entry, item[i].magic & magic_mask);
596 if ((flags & PATHSPEC_SYMLINK_LEADING_PATH) &&
597 has_symlink_leading_path(item[i].match, item[i].len)) {
598 die(_("pathspec '%s' is beyond a symbolic link"), entry);
601 if (item[i].nowildcard_len < item[i].len)
602 pathspec->has_wildcard = 1;
603 pathspec->magic |= item[i].magic;
607 * If everything is an exclude pattern, add one positive pattern
608 * that matches everything. We allocated an extra one for this.
610 if (nr_exclude == n) {
611 int plen = (!(flags & PATHSPEC_PREFER_CWD)) ? 0 : prefixlen;
612 init_pathspec_item(item + n, 0, prefix, plen, "");
616 if (pathspec->magic & PATHSPEC_MAXDEPTH) {
617 if (flags & PATHSPEC_KEEP_ORDER)
618 BUG("PATHSPEC_MAXDEPTH_VALID and PATHSPEC_KEEP_ORDER are incompatible");
619 QSORT(pathspec->items, pathspec->nr, pathspec_item_cmp);
623 void parse_pathspec_file(struct pathspec *pathspec, unsigned magic_mask,
624 unsigned flags, const char *prefix,
625 const char *file, int nul_term_line)
627 struct strvec parsed_file = STRVEC_INIT;
628 strbuf_getline_fn getline_fn = nul_term_line ? strbuf_getline_nul :
630 struct strbuf buf = STRBUF_INIT;
631 struct strbuf unquoted = STRBUF_INIT;
634 if (!strcmp(file, "-"))
637 in = xfopen(file, "r");
639 while (getline_fn(&buf, in) != EOF) {
640 if (!nul_term_line && buf.buf[0] == '"') {
641 strbuf_reset(&unquoted);
642 if (unquote_c_style(&unquoted, buf.buf, NULL))
643 die(_("line is badly quoted: %s"), buf.buf);
644 strbuf_swap(&buf, &unquoted);
646 strvec_push(&parsed_file, buf.buf);
650 strbuf_release(&unquoted);
651 strbuf_release(&buf);
655 parse_pathspec(pathspec, magic_mask, flags, prefix, parsed_file.v);
656 strvec_clear(&parsed_file);
659 void copy_pathspec(struct pathspec *dst, const struct pathspec *src)
664 ALLOC_ARRAY(dst->items, dst->nr);
665 COPY_ARRAY(dst->items, src->items, dst->nr);
667 for (i = 0; i < dst->nr; i++) {
668 struct pathspec_item *d = &dst->items[i];
669 struct pathspec_item *s = &src->items[i];
671 d->match = xstrdup(s->match);
672 d->original = xstrdup(s->original);
674 ALLOC_ARRAY(d->attr_match, d->attr_match_nr);
675 COPY_ARRAY(d->attr_match, s->attr_match, d->attr_match_nr);
676 for (j = 0; j < d->attr_match_nr; j++) {
677 const char *value = s->attr_match[j].value;
678 d->attr_match[j].value = xstrdup_or_null(value);
681 d->attr_check = attr_check_dup(s->attr_check);
685 void clear_pathspec(struct pathspec *pathspec)
689 for (i = 0; i < pathspec->nr; i++) {
690 free(pathspec->items[i].match);
691 free(pathspec->items[i].original);
693 for (j = 0; j < pathspec->items[i].attr_match_nr; j++)
694 free(pathspec->items[i].attr_match[j].value);
695 free(pathspec->items[i].attr_match);
697 if (pathspec->items[i].attr_check)
698 attr_check_free(pathspec->items[i].attr_check);
701 FREE_AND_NULL(pathspec->items);
705 int match_pathspec_attrs(const struct index_state *istate,
706 const char *name, int namelen,
707 const struct pathspec_item *item)
710 char *to_free = NULL;
713 name = to_free = xmemdupz(name, namelen);
715 git_check_attr(istate, name, item->attr_check);
719 for (i = 0; i < item->attr_match_nr; i++) {
722 enum attr_match_mode match_mode;
724 value = item->attr_check->items[i].value;
725 match_mode = item->attr_match[i].match_mode;
727 if (ATTR_TRUE(value))
728 matched = (match_mode == MATCH_SET);
729 else if (ATTR_FALSE(value))
730 matched = (match_mode == MATCH_UNSET);
731 else if (ATTR_UNSET(value))
732 matched = (match_mode == MATCH_UNSPECIFIED);
734 matched = (match_mode == MATCH_VALUE &&
735 !strcmp(item->attr_match[i].value, value));