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->len = strlen(item->match); 207 if (limit_pathspec_to_literal()) 208 item->nowildcard_len = item->len; 209 else 210 item->nowildcard_len = simple_length(item->match); 211 item->flags = 0; 212 if (item->nowildcard_len < item->len && 213 item->match[item->nowildcard_len] == '*' && 214 no_wildcard(item->match + item->nowildcard_len + 1)) 215 item->flags |= PATHSPEC_ONESTAR; 216 return magic; 217} 218 219static int pathspec_item_cmp(const void *a_, const void *b_) 220{ 221 struct pathspec_item *a, *b; 222 223 a = (struct pathspec_item *)a_; 224 b = (struct pathspec_item *)b_; 225 return strcmp(a->match, b->match); 226} 227 228static void NORETURN unsupported_magic(const char *pattern, 229 unsigned magic, 230 unsigned short_magic) 231{ 232 struct strbuf sb = STRBUF_INIT; 233 int i, n; 234 for (n = i = 0; i < ARRAY_SIZE(pathspec_magic); i++) { 235 const struct pathspec_magic *m = pathspec_magic + i; 236 if (!(magic & m->bit)) 237 continue; 238 if (sb.len) 239 strbuf_addstr(&sb, " "); 240 if (short_magic & m->bit) 241 strbuf_addf(&sb, "'%c'", m->mnemonic); 242 else 243 strbuf_addf(&sb, "'%s'", m->name); 244 n++; 245 } 246 /* 247 * We may want to substitute "this command" with a command 248 * name. E.g. when add--interactive dies when running 249 * "checkout -p" 250 */ 251 die(_("%s: pathspec magic not supported by this command: %s"), 252 pattern, sb.buf); 253} 254 255/* 256 * Given command line arguments and a prefix, convert the input to 257 * pathspec. die() if any magic in magic_mask is used. 258 */ 259void parse_pathspec(struct pathspec *pathspec, 260 unsigned magic_mask, unsigned flags, 261 const char *prefix, const char **argv) 262{ 263 struct pathspec_item *item; 264 const char *entry = argv ? *argv : NULL; 265 int i, n, prefixlen; 266 267 memset(pathspec, 0, sizeof(*pathspec)); 268 269 /* No arguments, no prefix -> no pathspec */ 270 if (!entry && !prefix) 271 return; 272 273 /* No arguments with prefix -> prefix pathspec */ 274 if (!entry) { 275 static const char *raw[2]; 276 277 pathspec->items = item = xmalloc(sizeof(*item)); 278 memset(item, 0, sizeof(*item)); 279 item->match = prefix; 280 item->nowildcard_len = item->len = strlen(prefix); 281 raw[0] = prefix; 282 raw[1] = NULL; 283 pathspec->nr = 1; 284 pathspec->raw = raw; 285 return; 286 } 287 288 n = 0; 289 while (argv[n]) 290 n++; 291 292 pathspec->nr = n; 293 pathspec->items = item = xmalloc(sizeof(*item) * n); 294 pathspec->raw = argv; 295 prefixlen = prefix ? strlen(prefix) : 0; 296 297 for (i = 0; i < n; i++) { 298 unsigned short_magic; 299 entry = argv[i]; 300 301 item[i].magic = prefix_pathspec(item + i, &short_magic, 302 argv + i, flags, 303 prefix, prefixlen, entry); 304 if (item[i].magic & magic_mask) 305 unsupported_magic(entry, 306 item[i].magic & magic_mask, 307 short_magic); 308 if (item[i].nowildcard_len < item[i].len) 309 pathspec->has_wildcard = 1; 310 pathspec->magic |= item[i].magic; 311 } 312 313 qsort(pathspec->items, pathspec->nr, 314 sizeof(struct pathspec_item), pathspec_item_cmp); 315} 316 317/* 318 * N.B. get_pathspec() is deprecated in favor of the "struct pathspec" 319 * based interface - see pathspec.c:parse_pathspec(). 320 * 321 * Arguments: 322 * - prefix - a path relative to the root of the working tree 323 * - pathspec - a list of paths underneath the prefix path 324 * 325 * Iterates over pathspec, prepending each path with prefix, 326 * and return the resulting list. 327 * 328 * If pathspec is empty, return a singleton list containing prefix. 329 * 330 * If pathspec and prefix are both empty, return an empty list. 331 * 332 * This is typically used by built-in commands such as add.c, in order 333 * to normalize argv arguments provided to the built-in into a list of 334 * paths to process, all relative to the root of the working tree. 335 */ 336const char **get_pathspec(const char *prefix, const char **pathspec) 337{ 338 struct pathspec ps; 339 parse_pathspec(&ps, 340 PATHSPEC_ALL_MAGIC & ~PATHSPEC_FROMTOP, 341 0, prefix, pathspec); 342 return ps.raw; 343} 344 345void copy_pathspec(struct pathspec *dst, const struct pathspec *src) 346{ 347 *dst = *src; 348 dst->items = xmalloc(sizeof(struct pathspec_item) * dst->nr); 349 memcpy(dst->items, src->items, 350 sizeof(struct pathspec_item) * dst->nr); 351}