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 209 if ((flags & PATHSPEC_STRIP_SUBMODULE_SLASH_CHEAP) && 210 (item->len >= 1 && item->match[item->len - 1] == '/') && 211 (i = cache_name_pos(item->match, item->len - 1)) >= 0 && 212 S_ISGITLINK(active_cache[i]->ce_mode)) { 213 item->len--; 214 match[item->len] = '\0'; 215 } 216 217 if (flags & PATHSPEC_STRIP_SUBMODULE_SLASH_EXPENSIVE) 218 for (i = 0; i < active_nr; i++) { 219 struct cache_entry *ce = active_cache[i]; 220 int ce_len = ce_namelen(ce); 221 222 if (!S_ISGITLINK(ce->ce_mode)) 223 continue; 224 225 if (item->len <= ce_len || match[ce_len] != '/' || 226 memcmp(ce->name, match, ce_len)) 227 continue; 228 if (item->len == ce_len + 1) { 229 /* strip trailing slash */ 230 item->len--; 231 match[item->len] = '\0'; 232 } else 233 die (_("Pathspec '%s' is in submodule '%.*s'"), 234 elt, ce_len, ce->name); 235 } 236 237 if (limit_pathspec_to_literal()) 238 item->nowildcard_len = item->len; 239 else 240 item->nowildcard_len = simple_length(item->match); 241 item->flags = 0; 242 if (item->nowildcard_len < item->len && 243 item->match[item->nowildcard_len] == '*' && 244 no_wildcard(item->match + item->nowildcard_len + 1)) 245 item->flags |= PATHSPEC_ONESTAR; 246 return magic; 247} 248 249static int pathspec_item_cmp(const void *a_, const void *b_) 250{ 251 struct pathspec_item *a, *b; 252 253 a = (struct pathspec_item *)a_; 254 b = (struct pathspec_item *)b_; 255 return strcmp(a->match, b->match); 256} 257 258static void NORETURN unsupported_magic(const char *pattern, 259 unsigned magic, 260 unsigned short_magic) 261{ 262 struct strbuf sb = STRBUF_INIT; 263 int i, n; 264 for (n = i = 0; i < ARRAY_SIZE(pathspec_magic); i++) { 265 const struct pathspec_magic *m = pathspec_magic + i; 266 if (!(magic & m->bit)) 267 continue; 268 if (sb.len) 269 strbuf_addstr(&sb, " "); 270 if (short_magic & m->bit) 271 strbuf_addf(&sb, "'%c'", m->mnemonic); 272 else 273 strbuf_addf(&sb, "'%s'", m->name); 274 n++; 275 } 276 /* 277 * We may want to substitute "this command" with a command 278 * name. E.g. when add--interactive dies when running 279 * "checkout -p" 280 */ 281 die(_("%s: pathspec magic not supported by this command: %s"), 282 pattern, sb.buf); 283} 284 285/* 286 * Given command line arguments and a prefix, convert the input to 287 * pathspec. die() if any magic in magic_mask is used. 288 */ 289void parse_pathspec(struct pathspec *pathspec, 290 unsigned magic_mask, unsigned flags, 291 const char *prefix, const char **argv) 292{ 293 struct pathspec_item *item; 294 const char *entry = argv ? *argv : NULL; 295 int i, n, prefixlen; 296 297 memset(pathspec, 0, sizeof(*pathspec)); 298 299 if (flags & PATHSPEC_MAXDEPTH_VALID) 300 pathspec->magic |= PATHSPEC_MAXDEPTH; 301 302 /* No arguments, no prefix -> no pathspec */ 303 if (!entry && !prefix) 304 return; 305 306 if ((flags & PATHSPEC_PREFER_CWD) && 307 (flags & PATHSPEC_PREFER_FULL)) 308 die("BUG: PATHSPEC_PREFER_CWD and PATHSPEC_PREFER_FULL are incompatible"); 309 310 /* No arguments with prefix -> prefix pathspec */ 311 if (!entry) { 312 static const char *raw[2]; 313 314 if (flags & PATHSPEC_PREFER_FULL) 315 return; 316 317 if (!(flags & PATHSPEC_PREFER_CWD)) 318 die("BUG: PATHSPEC_PREFER_CWD requires arguments"); 319 320 pathspec->items = item = xmalloc(sizeof(*item)); 321 memset(item, 0, sizeof(*item)); 322 item->match = prefix; 323 item->original = prefix; 324 item->nowildcard_len = item->len = strlen(prefix); 325 raw[0] = prefix; 326 raw[1] = NULL; 327 pathspec->nr = 1; 328 pathspec->raw = raw; 329 return; 330 } 331 332 n = 0; 333 while (argv[n]) 334 n++; 335 336 pathspec->nr = n; 337 pathspec->items = item = xmalloc(sizeof(*item) * n); 338 pathspec->raw = argv; 339 prefixlen = prefix ? strlen(prefix) : 0; 340 341 for (i = 0; i < n; i++) { 342 unsigned short_magic; 343 entry = argv[i]; 344 345 item[i].magic = prefix_pathspec(item + i, &short_magic, 346 argv + i, flags, 347 prefix, prefixlen, entry); 348 if (item[i].magic & magic_mask) 349 unsupported_magic(entry, 350 item[i].magic & magic_mask, 351 short_magic); 352 353 if ((flags & PATHSPEC_SYMLINK_LEADING_PATH) && 354 has_symlink_leading_path(item[i].match, item[i].len)) { 355 die(_("pathspec '%s' is beyond a symbolic link"), entry); 356 } 357 358 if (item[i].nowildcard_len < item[i].len) 359 pathspec->has_wildcard = 1; 360 pathspec->magic |= item[i].magic; 361 } 362 363 if (pathspec->magic & PATHSPEC_MAXDEPTH) 364 qsort(pathspec->items, pathspec->nr, 365 sizeof(struct pathspec_item), pathspec_item_cmp); 366} 367 368/* 369 * N.B. get_pathspec() is deprecated in favor of the "struct pathspec" 370 * based interface - see pathspec.c:parse_pathspec(). 371 * 372 * Arguments: 373 * - prefix - a path relative to the root of the working tree 374 * - pathspec - a list of paths underneath the prefix path 375 * 376 * Iterates over pathspec, prepending each path with prefix, 377 * and return the resulting list. 378 * 379 * If pathspec is empty, return a singleton list containing prefix. 380 * 381 * If pathspec and prefix are both empty, return an empty list. 382 * 383 * This is typically used by built-in commands such as add.c, in order 384 * to normalize argv arguments provided to the built-in into a list of 385 * paths to process, all relative to the root of the working tree. 386 */ 387const char **get_pathspec(const char *prefix, const char **pathspec) 388{ 389 struct pathspec ps; 390 parse_pathspec(&ps, 391 PATHSPEC_ALL_MAGIC & ~PATHSPEC_FROMTOP, 392 PATHSPEC_PREFER_CWD, 393 prefix, pathspec); 394 return ps.raw; 395} 396 397void copy_pathspec(struct pathspec *dst, const struct pathspec *src) 398{ 399 *dst = *src; 400 dst->items = xmalloc(sizeof(struct pathspec_item) * dst->nr); 401 memcpy(dst->items, src->items, 402 sizeof(struct pathspec_item) * dst->nr); 403}