pathspec.h

   1 #ifndef PATHSPEC_H
   2 #define PATHSPEC_H
   3
   4 struct index_state;
   5
   6 /* Pathspec magic */
   7 #define PATHSPEC_FROMTOP        (1<<0)
   8 #define PATHSPEC_MAXDEPTH       (1<<1)
   9 #define PATHSPEC_LITERAL        (1<<2)
  10 #define PATHSPEC_GLOB           (1<<3)
  11 #define PATHSPEC_ICASE          (1<<4)
  12 #define PATHSPEC_EXCLUDE        (1<<5)
  13 #define PATHSPEC_ATTR           (1<<6)
  14 #define PATHSPEC_ALL_MAGIC        \
  15         (PATHSPEC_FROMTOP       | \
  16          PATHSPEC_MAXDEPTH      | \
  17          PATHSPEC_LITERAL       | \
  18          PATHSPEC_GLOB          | \
  19          PATHSPEC_ICASE         | \
  20          PATHSPEC_EXCLUDE       | \
  21          PATHSPEC_ATTR)
  22
  23 #define PATHSPEC_ONESTAR 1      /* the pathspec pattern satisfies GFNM_ONESTAR */
  24
  25 /**
  26  * See glossary-context.txt for the syntax of pathspec.
  27  * In memory, a pathspec set is represented by "struct pathspec" and is
  28  * prepared by parse_pathspec().
  29  */
  30 struct pathspec {
  31         int nr;
  32         unsigned int has_wildcard:1;
  33         unsigned int recursive:1;
  34         unsigned int recurse_submodules:1;
  35         unsigned magic;
  36         int max_depth;
  37         struct pathspec_item {
  38                 char *match;
  39                 char *original;
  40                 unsigned magic;
  41                 int len, prefix;
  42                 int nowildcard_len;
  43                 int flags;
  44                 int attr_match_nr;
  45                 struct attr_match {
  46                         char *value;
  47                         enum attr_match_mode {
  48                                 MATCH_SET,
  49                                 MATCH_UNSET,
  50                                 MATCH_VALUE,
  51                                 MATCH_UNSPECIFIED
  52                         } match_mode;
  53                 } *attr_match;
  54                 struct attr_check *attr_check;
  55         } *items;
  56 };
  57
  58 #define GUARD_PATHSPEC(ps, mask) \
  59         do { \
  60                 if ((ps)->magic & ~(mask))             \
  61                         BUG("unsupported magic %x", (ps)->magic & ~(mask)); \
  62         } while (0)
  63
  64 /* parse_pathspec flags */
  65 #define PATHSPEC_PREFER_CWD (1<<0) /* No args means match cwd */
  66 #define PATHSPEC_PREFER_FULL (1<<1) /* No args means match everything */
  67 #define PATHSPEC_MAXDEPTH_VALID (1<<2) /* max_depth field is valid */
  68 /* die if a symlink is part of the given path's directory */
  69 #define PATHSPEC_SYMLINK_LEADING_PATH (1<<3)
  70 #define PATHSPEC_PREFIX_ORIGIN (1<<4)
  71 #define PATHSPEC_KEEP_ORDER (1<<5)
  72 /*
  73  * For the callers that just need pure paths from somewhere else, not
  74  * from command line. Global --*-pathspecs options are ignored. No
  75  * magic is parsed in each pathspec either. If PATHSPEC_LITERAL is
  76  * allowed, then it will automatically set for every pathspec.
  77  */
  78 #define PATHSPEC_LITERAL_PATH (1<<6)
  79
  80 /**
  81  * Given command line arguments and a prefix, convert the input to
  82  * pathspec. die() if any magic in magic_mask is used.
  83  *
  84  * Any arguments used are copied. It is safe for the caller to modify
  85  * or free 'prefix' and 'args' after calling this function.
  86  *
  87  * - magic_mask specifies what features that are NOT supported by the following
  88  * code. If a user attempts to use such a feature, parse_pathspec() can reject
  89  * it early.
  90  *
  91  * - flags specifies other things that the caller wants parse_pathspec to
  92  * perform.
  93  *
  94  * - prefix and args come from cmd_* functions
  95  *
  96  * parse_pathspec() helps catch unsupported features and reject them politely.
  97  * At a lower level, different pathspec-related functions may not support the
  98  * same set of features. Such pathspec-sensitive functions are guarded with
  99  * GUARD_PATHSPEC(), which will die in an unfriendly way when an unsupported
 100  * feature is requested.
 101  *
 102  * The command designers are supposed to make sure that GUARD_PATHSPEC() never
 103  * dies. They have to make sure all unsupported features are caught by
 104  * parse_pathspec(), not by GUARD_PATHSPEC. grepping GUARD_PATHSPEC() should
 105  * give the designers all pathspec-sensitive codepaths and what features they
 106  * support.
 107  *
 108  * A similar process is applied when a new pathspec magic is added. The designer
 109  * lifts the GUARD_PATHSPEC restriction in the functions that support the new
 110  * magic while at the same time making sure this new feature will be
 111  * caught at parse_pathspec() in commands that cannot handle the new magic in
 112  * some cases. grepping parse_pathspec() should help.
 113  */
 114 void parse_pathspec(struct pathspec *pathspec,
 115                     unsigned magic_mask,
 116                     unsigned flags,
 117                     const char *prefix,
 118                     const char **args);
 119 /*
 120  * Same as parse_pathspec() but uses file as input.
 121  * When 'file' is exactly "-" it uses 'stdin' instead.
 122  */
 123 void parse_pathspec_file(struct pathspec *pathspec,
 124                          unsigned magic_mask,
 125                          unsigned flags,
 126                          const char *prefix,
 127                          const char *file,
 128                          int nul_term_line);
 129
 130 void copy_pathspec(struct pathspec *dst, const struct pathspec *src);
 131 void clear_pathspec(struct pathspec *);
 132
 133 static inline int ps_strncmp(const struct pathspec_item *item,
 134                              const char *s1, const char *s2, size_t n)
 135 {
 136         if (item->magic & PATHSPEC_ICASE)
 137                 return strncasecmp(s1, s2, n);
 138         else
 139                 return strncmp(s1, s2, n);
 140 }
 141
 142 static inline int ps_strcmp(const struct pathspec_item *item,
 143                             const char *s1, const char *s2)
 144 {
 145         if (item->magic & PATHSPEC_ICASE)
 146                 return strcasecmp(s1, s2);
 147         else
 148                 return strcmp(s1, s2);
 149 }
 150
 151 enum ps_skip_worktree_action {
 152   PS_HEED_SKIP_WORKTREE = 0,
 153   PS_IGNORE_SKIP_WORKTREE = 1
 154 };
 155 void add_pathspec_matches_against_index(const struct pathspec *pathspec,
 156                                         struct index_state *istate,
 157                                         char *seen,
 158                                         enum ps_skip_worktree_action sw_action);
 159 char *find_pathspecs_matching_against_index(const struct pathspec *pathspec,
 160                                             struct index_state *istate,
 161                                             enum ps_skip_worktree_action sw_action);
 162 char *find_pathspecs_matching_skip_worktree(const struct pathspec *pathspec);
 163 static inline int matches_skip_worktree(const struct pathspec *pathspec,
 164                                         int item, char **seen_ptr)
 165 {
 166         if (!*seen_ptr)
 167                 *seen_ptr = find_pathspecs_matching_skip_worktree(pathspec);
 168         return (*seen_ptr)[item];
 169 }
 170 int match_pathspec_attrs(struct index_state *istate,
 171                          const char *name, int namelen,
 172                          const struct pathspec_item *item);
 173
 174 /*
 175  * Determine whether a pathspec will match only entire index entries (non-sparse
 176  * files and/or entire sparse directories). If the pathspec has the potential to
 177  * match partial contents of a sparse directory, return 1 to indicate the index
 178  * should be expanded to match the  appropriate index entries.
 179  *
 180  * For the sake of simplicity, always return 1 if using a more complex "magic"
 181  * pathspec.
 182  */
 183 int pathspec_needs_expanded_index(struct index_state *istate,
 184                                   const struct pathspec *pathspec);
 185
 186 #endif /* PATHSPEC_H */