]>
Commit | Line | Data |
---|---|---|
6f525e71 AS |
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 | |
4b78d7bc | 16 | * to use find_pathspecs_matching_against_index() instead. |
6f525e71 | 17 | */ |
4b78d7bc AS |
18 | void add_pathspec_matches_against_index(const char **pathspec, |
19 | char *seen, int specs) | |
6f525e71 AS |
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 | * | |
4b78d7bc AS |
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. | |
6f525e71 | 47 | */ |
4b78d7bc | 48 | char *find_pathspecs_matching_against_index(const char **pathspec) |
6f525e71 AS |
49 | { |
50 | char *seen; | |
51 | int i; | |
52 | ||
53 | for (i = 0; pathspec[i]; i++) | |
54 | ; /* just counting */ | |
55 | seen = xcalloc(i, 1); | |
4b78d7bc | 56 | add_pathspec_matches_against_index(pathspec, seen, i); |
6f525e71 AS |
57 | return seen; |
58 | } | |
9d67b61f AS |
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 | */ | |
66 | const 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 | } | |
512aaf94 AS |
90 | |
91 | /* | |
92 | * Dies if the given path refers to a file inside a symlinked | |
93 | * directory in the index. | |
94 | */ | |
95 | void 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 | } | |
64acde94 NTND |
102 | |
103 | /* | |
104 | * Magic pathspec | |
105 | * | |
64acde94 NTND |
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 | */ | |
64acde94 NTND |
114 | |
115 | static 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. | |
87323bda | 125 | * Append the result to the prefix. Return the magic bitmap. |
64acde94 NTND |
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 | */ | |
87323bda NTND |
136 | static 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) | |
64acde94 | 141 | { |
87323bda | 142 | unsigned magic = 0, short_magic = 0; |
64acde94 | 143 | const char *copyfrom = elt; |
87323bda | 144 | char *match; |
64acde94 NTND |
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) | |
f01d9820 | 170 | die(_("Invalid pathspec magic '%.*s' in '%s'"), |
64acde94 NTND |
171 | (int) len, copyfrom, elt); |
172 | } | |
173 | if (*copyfrom != ')') | |
f01d9820 | 174 | die(_("Missing ')' at the end of pathspec magic in '%s'"), elt); |
64acde94 NTND |
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) { | |
87323bda | 187 | short_magic |= pathspec_magic[i].bit; |
64acde94 NTND |
188 | break; |
189 | } | |
190 | if (ARRAY_SIZE(pathspec_magic) <= i) | |
f01d9820 | 191 | die(_("Unimplemented pathspec magic '%c' in '%s'"), |
64acde94 NTND |
192 | ch, elt); |
193 | } | |
194 | if (*copyfrom == ':') | |
195 | copyfrom++; | |
196 | } | |
197 | ||
87323bda NTND |
198 | magic |= short_magic; |
199 | *p_short_magic = short_magic; | |
200 | ||
64acde94 | 201 | if (magic & PATHSPEC_FROMTOP) |
87323bda | 202 | match = xstrdup(copyfrom); |
64acde94 | 203 | else |
87323bda NTND |
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 | ||
219 | static 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 | ||
228 | static 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 | */ | |
259 | void 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); | |
64acde94 NTND |
315 | } |
316 | ||
317 | /* | |
318 | * N.B. get_pathspec() is deprecated in favor of the "struct pathspec" | |
87323bda | 319 | * based interface - see pathspec.c:parse_pathspec(). |
64acde94 NTND |
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 | */ | |
336 | const char **get_pathspec(const char *prefix, const char **pathspec) | |
337 | { | |
87323bda NTND |
338 | struct pathspec ps; |
339 | parse_pathspec(&ps, | |
340 | PATHSPEC_ALL_MAGIC & ~PATHSPEC_FROMTOP, | |
341 | 0, prefix, pathspec); | |
342 | return ps.raw; | |
64acde94 | 343 | } |
e4d92cdc NTND |
344 | |
345 | void 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 | } |