1#include "cache.h" 2#include "dir.h" 3#include "pathspec.h" 4 5/* 6 * Finds which of the given pathspecs match items in the index. 7 * 8 * For each pathspec, sets the corresponding entry in the seen[] array 9 * (which should be specs items long, i.e. the same size as pathspec) 10 * to the nature of the "closest" (i.e. most specific) match found for 11 * that pathspec in the index, if it was a closer type of match than 12 * the existing entry. As an optimization, matching is skipped 13 * altogether if seen[] already only contains non-zero entries. 14 * 15 * If seen[] has not already been written to, it may make sense 16 * to use find_pathspecs_matching_against_index() instead. 17 */ 18void add_pathspec_matches_against_index(const char **pathspec, 19 char *seen, int specs) 20{ 21 int num_unmatched = 0, i; 22 23 /* 24 * Since we are walking the index as if we were walking the directory, 25 * we have to mark the matched pathspec as seen; otherwise we will 26 * mistakenly think that the user gave a pathspec that did not match 27 * anything. 28 */ 29 for (i = 0; i < specs; i++) 30 if (!seen[i]) 31 num_unmatched++; 32 if (!num_unmatched) 33 return; 34 for (i = 0; i < active_nr; i++) { 35 struct cache_entry *ce = active_cache[i]; 36 match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, seen); 37 } 38} 39 40/* 41 * Finds which of the given pathspecs match items in the index. 42 * 43 * This is a one-shot wrapper around add_pathspec_matches_against_index() 44 * which allocates, populates, and returns a seen[] array indicating the 45 * nature of the "closest" (i.e. most specific) matches which each of the 46 * given pathspecs achieves against all items in the index. 47 */ 48char *find_pathspecs_matching_against_index(const char **pathspec) 49{ 50 char *seen; 51 int i; 52 53 for (i = 0; pathspec[i]; i++) 54 ; /* just counting */ 55 seen = xcalloc(i, 1); 56 add_pathspec_matches_against_index(pathspec, seen, i); 57 return seen; 58} 59 60/* 61 * Check the index to see whether path refers to a submodule, or 62 * something inside a submodule. If the former, returns the path with 63 * any trailing slash stripped. If the latter, dies with an error 64 * message. 65 */ 66const char *check_path_for_gitlink(const char *path) 67{ 68 int i, path_len = strlen(path); 69 for (i = 0; i < active_nr; i++) { 70 struct cache_entry *ce = active_cache[i]; 71 if (S_ISGITLINK(ce->ce_mode)) { 72 int ce_len = ce_namelen(ce); 73 if (path_len <= ce_len || path[ce_len] != '/' || 74 memcmp(ce->name, path, ce_len)) 75 /* path does not refer to this 76 * submodule or anything inside it */ 77 continue; 78 if (path_len == ce_len + 1) { 79 /* path refers to submodule; 80 * strip trailing slash */ 81 return xstrndup(ce->name, ce_len); 82 } else { 83 die (_("Path '%s' is in submodule '%.*s'"), 84 path, ce_len, ce->name); 85 } 86 } 87 } 88 return path; 89} 90 91/* 92 * Dies if the given path refers to a file inside a symlinked 93 * directory in the index. 94 */ 95void die_if_path_beyond_symlink(const char *path, const char *prefix) 96{ 97 if (has_symlink_leading_path(path, strlen(path))) { 98 int len = prefix ? strlen(prefix) : 0; 99 die(_("'%s' is beyond a symbolic link"), path + len); 100 } 101} 102 103/* 104 * Magic pathspec 105 * 106 * Possible future magic semantics include stuff like: 107 * 108 * { PATHSPEC_NOGLOB, '!', "noglob" }, 109 * { PATHSPEC_ICASE, '\0', "icase" }, 110 * { PATHSPEC_RECURSIVE, '*', "recursive" }, 111 * { PATHSPEC_REGEXP, '\0', "regexp" }, 112 * 113 */ 114 115static struct pathspec_magic { 116 unsigned bit; 117 char mnemonic; /* this cannot be ':'! */ 118 const char *name; 119} pathspec_magic[] = { 120 { PATHSPEC_FROMTOP, '/', "top" }, 121}; 122 123/* 124 * Take an element of a pathspec and check for magic signatures. 125 * Append the result to the prefix. Return the magic bitmap. 126 * 127 * For now, we only parse the syntax and throw out anything other than 128 * "top" magic. 129 * 130 * NEEDSWORK: This needs to be rewritten when we start migrating 131 * get_pathspec() users to use the "struct pathspec" interface. For 132 * example, a pathspec element may be marked as case-insensitive, but 133 * the prefix part must always match literally, and a single stupid 134 * string cannot express such a case. 135 */ 136static unsigned prefix_pathspec(struct pathspec_item *item, 137 unsigned *p_short_magic, 138 const char **raw, unsigned flags, 139 const char *prefix, int prefixlen, 140 const char *elt) 141{ 142 unsigned magic = 0, short_magic = 0; 143 const char *copyfrom = elt; 144 char *match; 145 int i; 146 147 if (elt[0] != ':') { 148 ; /* nothing to do */ 149 } else if (elt[1] == '(') { 150 /* longhand */ 151 const char *nextat; 152 for (copyfrom = elt + 2; 153 *copyfrom && *copyfrom != ')'; 154 copyfrom = nextat) { 155 size_t len = strcspn(copyfrom, ",)"); 156 if (copyfrom[len] == ',') 157 nextat = copyfrom + len + 1; 158 else 159 /* handle ')' and '\0' */ 160 nextat = copyfrom + len; 161 if (!len) 162 continue; 163 for (i = 0; i < ARRAY_SIZE(pathspec_magic); i++) 164 if (strlen(pathspec_magic[i].name) == len && 165 !strncmp(pathspec_magic[i].name, copyfrom, len)) { 166 magic |= pathspec_magic[i].bit; 167 break; 168 } 169 if (ARRAY_SIZE(pathspec_magic) <= i) 170 die(_("Invalid pathspec magic '%.*s' in '%s'"), 171 (int) len, copyfrom, elt); 172 } 173 if (*copyfrom != ')') 174 die(_("Missing ')' at the end of pathspec magic in '%s'"), elt); 175 copyfrom++; 176 } else { 177 /* shorthand */ 178 for (copyfrom = elt + 1; 179 *copyfrom && *copyfrom != ':'; 180 copyfrom++) { 181 char ch = *copyfrom; 182 183 if (!is_pathspec_magic(ch)) 184 break; 185 for (i = 0; i < ARRAY_SIZE(pathspec_magic); i++) 186 if (pathspec_magic[i].mnemonic == ch) { 187 short_magic |= pathspec_magic[i].bit; 188 break; 189 } 190 if (ARRAY_SIZE(pathspec_magic) <= i) 191 die(_("Unimplemented pathspec magic '%c' in '%s'"), 192 ch, elt); 193 } 194 if (*copyfrom == ':') 195 copyfrom++; 196 } 197 198 magic |= short_magic; 199 *p_short_magic = short_magic; 200 201 if (magic & PATHSPEC_FROMTOP) 202 match = xstrdup(copyfrom); 203 else 204 match = prefix_path(prefix, prefixlen, copyfrom); 205 *raw = item->match = match; 206 item->original = elt; 207 item->len = strlen(item->match); 208 if (limit_pathspec_to_literal()) 209 item->nowildcard_len = item->len; 210 else 211 item->nowildcard_len = simple_length(item->match); 212 item->flags = 0; 213 if (item->nowildcard_len < item->len && 214 item->match[item->nowildcard_len] == '*' && 215 no_wildcard(item->match + item->nowildcard_len + 1)) 216 item->flags |= PATHSPEC_ONESTAR; 217 return magic; 218} 219 220static int pathspec_item_cmp(const void *a_, const void *b_) 221{ 222 struct pathspec_item *a, *b; 223 224 a = (struct pathspec_item *)a_; 225 b = (struct pathspec_item *)b_; 226 return strcmp(a->match, b->match); 227} 228 229static void NORETURN unsupported_magic(const char *pattern, 230 unsigned magic, 231 unsigned short_magic) 232{ 233 struct strbuf sb = STRBUF_INIT; 234 int i, n; 235 for (n = i = 0; i < ARRAY_SIZE(pathspec_magic); i++) { 236 const struct pathspec_magic *m = pathspec_magic + i; 237 if (!(magic & m->bit)) 238 continue; 239 if (sb.len) 240 strbuf_addstr(&sb, " "); 241 if (short_magic & m->bit) 242 strbuf_addf(&sb, "'%c'", m->mnemonic); 243 else 244 strbuf_addf(&sb, "'%s'", m->name); 245 n++; 246 } 247 /* 248 * We may want to substitute "this command" with a command 249 * name. E.g. when add--interactive dies when running 250 * "checkout -p" 251 */ 252 die(_("%s: pathspec magic not supported by this command: %s"), 253 pattern, sb.buf); 254} 255 256/* 257 * Given command line arguments and a prefix, convert the input to 258 * pathspec. die() if any magic in magic_mask is used. 259 */ 260void parse_pathspec(struct pathspec *pathspec, 261 unsigned magic_mask, unsigned flags, 262 const char *prefix, const char **argv) 263{ 264 struct pathspec_item *item; 265 const char *entry = argv ? *argv : NULL; 266 int i, n, prefixlen; 267 268 memset(pathspec, 0, sizeof(*pathspec)); 269 270 /* No arguments, no prefix -> no pathspec */ 271 if (!entry && !prefix) 272 return; 273 274 /* No arguments with prefix -> prefix pathspec */ 275 if (!entry) { 276 static const char *raw[2]; 277 278 pathspec->items = item = xmalloc(sizeof(*item)); 279 memset(item, 0, sizeof(*item)); 280 item->match = prefix; 281 item->original = prefix; 282 item->nowildcard_len = item->len = strlen(prefix); 283 raw[0] = prefix; 284 raw[1] = NULL; 285 pathspec->nr = 1; 286 pathspec->raw = raw; 287 return; 288 } 289 290 n = 0; 291 while (argv[n]) 292 n++; 293 294 pathspec->nr = n; 295 pathspec->items = item = xmalloc(sizeof(*item) * n); 296 pathspec->raw = argv; 297 prefixlen = prefix ? strlen(prefix) : 0; 298 299 for (i = 0; i < n; i++) { 300 unsigned short_magic; 301 entry = argv[i]; 302 303 item[i].magic = prefix_pathspec(item + i, &short_magic, 304 argv + i, flags, 305 prefix, prefixlen, entry); 306 if (item[i].magic & magic_mask) 307 unsupported_magic(entry, 308 item[i].magic & magic_mask, 309 short_magic); 310 if (item[i].nowildcard_len < item[i].len) 311 pathspec->has_wildcard = 1; 312 pathspec->magic |= item[i].magic; 313 } 314 315 qsort(pathspec->items, pathspec->nr, 316 sizeof(struct pathspec_item), pathspec_item_cmp); 317} 318 319/* 320 * N.B. get_pathspec() is deprecated in favor of the "struct pathspec" 321 * based interface - see pathspec.c:parse_pathspec(). 322 * 323 * Arguments: 324 * - prefix - a path relative to the root of the working tree 325 * - pathspec - a list of paths underneath the prefix path 326 * 327 * Iterates over pathspec, prepending each path with prefix, 328 * and return the resulting list. 329 * 330 * If pathspec is empty, return a singleton list containing prefix. 331 * 332 * If pathspec and prefix are both empty, return an empty list. 333 * 334 * This is typically used by built-in commands such as add.c, in order 335 * to normalize argv arguments provided to the built-in into a list of 336 * paths to process, all relative to the root of the working tree. 337 */ 338const char **get_pathspec(const char *prefix, const char **pathspec) 339{ 340 struct pathspec ps; 341 parse_pathspec(&ps, 342 PATHSPEC_ALL_MAGIC & ~PATHSPEC_FROMTOP, 343 0, prefix, pathspec); 344 return ps.raw; 345} 346 347void copy_pathspec(struct pathspec *dst, const struct pathspec *src) 348{ 349 *dst = *src; 350 dst->items = xmalloc(sizeof(struct pathspec_item) * dst->nr); 351 memcpy(dst->items, src->items, 352 sizeof(struct pathspec_item) * dst->nr); 353}