]>
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 | */ |
84b8b5d1 NTND |
18 | void add_pathspec_matches_against_index(const struct pathspec *pathspec, |
19 | char *seen) | |
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 | */ | |
84b8b5d1 | 29 | for (i = 0; i < pathspec->nr; i++) |
6f525e71 AS |
30 | if (!seen[i]) |
31 | num_unmatched++; | |
32 | if (!num_unmatched) | |
33 | return; | |
34 | for (i = 0; i < active_nr; i++) { | |
9c5e6c80 | 35 | const struct cache_entry *ce = active_cache[i]; |
429bb40a | 36 | ce_path_match(ce, pathspec, seen); |
6f525e71 AS |
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 | */ |
84b8b5d1 | 48 | char *find_pathspecs_matching_against_index(const struct pathspec *pathspec) |
6f525e71 | 49 | { |
84b8b5d1 NTND |
50 | char *seen = xcalloc(pathspec->nr, 1); |
51 | add_pathspec_matches_against_index(pathspec, seen); | |
6f525e71 AS |
52 | return seen; |
53 | } | |
9d67b61f AS |
54 | |
55 | /* | |
64acde94 NTND |
56 | * Magic pathspec |
57 | * | |
64acde94 NTND |
58 | * Possible future magic semantics include stuff like: |
59 | * | |
64acde94 NTND |
60 | * { PATHSPEC_RECURSIVE, '*', "recursive" }, |
61 | * { PATHSPEC_REGEXP, '\0', "regexp" }, | |
62 | * | |
63 | */ | |
64acde94 NTND |
64 | |
65 | static struct pathspec_magic { | |
66 | unsigned bit; | |
67 | char mnemonic; /* this cannot be ':'! */ | |
68 | const char *name; | |
69 | } pathspec_magic[] = { | |
70 | { PATHSPEC_FROMTOP, '/', "top" }, | |
5c6933d2 | 71 | { PATHSPEC_LITERAL, 0, "literal" }, |
bd30c2e4 | 72 | { PATHSPEC_GLOB, '\0', "glob" }, |
93d93537 | 73 | { PATHSPEC_ICASE, '\0', "icase" }, |
ef79b1f8 | 74 | { PATHSPEC_EXCLUDE, '!', "exclude" }, |
64acde94 NTND |
75 | }; |
76 | ||
5d8f084a | 77 | static void prefix_magic(struct strbuf *sb, int prefixlen, unsigned magic) |
1649612a NTND |
78 | { |
79 | int i; | |
80 | strbuf_addstr(sb, ":("); | |
81 | for (i = 0; i < ARRAY_SIZE(pathspec_magic); i++) | |
5d8f084a | 82 | if (magic & pathspec_magic[i].bit) { |
1649612a NTND |
83 | if (sb->buf[sb->len - 1] != '(') |
84 | strbuf_addch(sb, ','); | |
85 | strbuf_addstr(sb, pathspec_magic[i].name); | |
86 | } | |
87 | strbuf_addf(sb, ",prefix:%d)", prefixlen); | |
88 | } | |
89 | ||
db7e8598 BW |
90 | static inline int get_literal_global(void) |
91 | { | |
92 | static int literal = -1; | |
93 | ||
94 | if (literal < 0) | |
95 | literal = git_env_bool(GIT_LITERAL_PATHSPECS_ENVIRONMENT, 0); | |
96 | ||
97 | return literal; | |
98 | } | |
99 | ||
100 | static inline int get_glob_global(void) | |
101 | { | |
102 | static int glob = -1; | |
103 | ||
104 | if (glob < 0) | |
105 | glob = git_env_bool(GIT_GLOB_PATHSPECS_ENVIRONMENT, 0); | |
106 | ||
107 | return glob; | |
108 | } | |
109 | ||
110 | static inline int get_noglob_global(void) | |
111 | { | |
112 | static int noglob = -1; | |
113 | ||
114 | if (noglob < 0) | |
115 | noglob = git_env_bool(GIT_NOGLOB_PATHSPECS_ENVIRONMENT, 0); | |
116 | ||
117 | return noglob; | |
118 | } | |
119 | ||
120 | static inline int get_icase_global(void) | |
121 | { | |
122 | static int icase = -1; | |
123 | ||
124 | if (icase < 0) | |
125 | icase = git_env_bool(GIT_ICASE_PATHSPECS_ENVIRONMENT, 0); | |
126 | ||
127 | return icase; | |
128 | } | |
129 | ||
130 | static int get_global_magic(int element_magic) | |
131 | { | |
132 | int global_magic = 0; | |
133 | ||
134 | if (get_literal_global()) | |
135 | global_magic |= PATHSPEC_LITERAL; | |
136 | ||
137 | /* --glob-pathspec is overridden by :(literal) */ | |
138 | if (get_glob_global() && !(element_magic & PATHSPEC_LITERAL)) | |
139 | global_magic |= PATHSPEC_GLOB; | |
140 | ||
141 | if (get_glob_global() && get_noglob_global()) | |
142 | die(_("global 'glob' and 'noglob' pathspec settings are incompatible")); | |
143 | ||
144 | if (get_icase_global()) | |
145 | global_magic |= PATHSPEC_ICASE; | |
146 | ||
147 | if ((global_magic & PATHSPEC_LITERAL) && | |
148 | (global_magic & ~PATHSPEC_LITERAL)) | |
149 | die(_("global 'literal' pathspec setting is incompatible " | |
150 | "with all other global pathspec settings")); | |
151 | ||
152 | /* --noglob-pathspec adds :(literal) _unless_ :(glob) is specified */ | |
153 | if (get_noglob_global() && !(element_magic & PATHSPEC_GLOB)) | |
154 | global_magic |= PATHSPEC_LITERAL; | |
155 | ||
156 | return global_magic; | |
157 | } | |
158 | ||
8881fde0 BW |
159 | /* |
160 | * Parse the pathspec element looking for long magic | |
161 | * | |
162 | * saves all magic in 'magic' | |
163 | * if prefix magic is used, save the prefix length in 'prefix_len' | |
164 | * returns the position in 'elem' after all magic has been parsed | |
165 | */ | |
166 | static const char *parse_long_magic(unsigned *magic, int *prefix_len, | |
167 | const char *elem) | |
168 | { | |
169 | const char *pos; | |
170 | const char *nextat; | |
171 | ||
172 | for (pos = elem + 2; *pos && *pos != ')'; pos = nextat) { | |
173 | size_t len = strcspn(pos, ",)"); | |
174 | int i; | |
175 | ||
176 | if (pos[len] == ',') | |
177 | nextat = pos + len + 1; /* handle ',' */ | |
178 | else | |
179 | nextat = pos + len; /* handle ')' and '\0' */ | |
180 | ||
181 | if (!len) | |
182 | continue; | |
183 | ||
184 | if (starts_with(pos, "prefix:")) { | |
185 | char *endptr; | |
186 | *prefix_len = strtol(pos + 7, &endptr, 10); | |
187 | if (endptr - pos != len) | |
188 | die(_("invalid parameter for pathspec magic 'prefix'")); | |
189 | continue; | |
190 | } | |
191 | ||
192 | for (i = 0; i < ARRAY_SIZE(pathspec_magic); i++) { | |
193 | if (strlen(pathspec_magic[i].name) == len && | |
194 | !strncmp(pathspec_magic[i].name, pos, len)) { | |
195 | *magic |= pathspec_magic[i].bit; | |
196 | break; | |
197 | } | |
198 | } | |
199 | ||
200 | if (ARRAY_SIZE(pathspec_magic) <= i) | |
201 | die(_("Invalid pathspec magic '%.*s' in '%s'"), | |
202 | (int) len, pos, elem); | |
203 | } | |
204 | ||
205 | if (*pos != ')') | |
206 | die(_("Missing ')' at the end of pathspec magic in '%s'"), | |
207 | elem); | |
208 | pos++; | |
209 | ||
210 | return pos; | |
211 | } | |
212 | ||
b4bebdce BW |
213 | /* |
214 | * Parse the pathspec element looking for short magic | |
215 | * | |
216 | * saves all magic in 'magic' | |
217 | * returns the position in 'elem' after all magic has been parsed | |
218 | */ | |
219 | static const char *parse_short_magic(unsigned *magic, const char *elem) | |
220 | { | |
221 | const char *pos; | |
222 | ||
223 | for (pos = elem + 1; *pos && *pos != ':'; pos++) { | |
224 | char ch = *pos; | |
225 | int i; | |
226 | ||
227 | if (!is_pathspec_magic(ch)) | |
228 | break; | |
229 | ||
230 | for (i = 0; i < ARRAY_SIZE(pathspec_magic); i++) { | |
231 | if (pathspec_magic[i].mnemonic == ch) { | |
232 | *magic |= pathspec_magic[i].bit; | |
233 | break; | |
234 | } | |
235 | } | |
236 | ||
237 | if (ARRAY_SIZE(pathspec_magic) <= i) | |
238 | die(_("Unimplemented pathspec magic '%c' in '%s'"), | |
239 | ch, elem); | |
240 | } | |
241 | ||
242 | if (*pos == ':') | |
243 | pos++; | |
244 | ||
245 | return pos; | |
246 | } | |
247 | ||
1b6112c5 BW |
248 | static const char *parse_element_magic(unsigned *magic, int *prefix_len, |
249 | const char *elem) | |
250 | { | |
251 | if (elem[0] != ':' || get_literal_global()) | |
252 | return elem; /* nothing to do */ | |
253 | else if (elem[1] == '(') | |
254 | /* longhand */ | |
255 | return parse_long_magic(magic, prefix_len, elem); | |
256 | else | |
257 | /* shorthand */ | |
258 | return parse_short_magic(magic, elem); | |
259 | } | |
260 | ||
5590215b BW |
261 | static void strip_submodule_slash_cheap(struct pathspec_item *item) |
262 | { | |
263 | if (item->len >= 1 && item->match[item->len - 1] == '/') { | |
264 | int i = cache_name_pos(item->match, item->len - 1); | |
265 | ||
266 | if (i >= 0 && S_ISGITLINK(active_cache[i]->ce_mode)) { | |
267 | item->len--; | |
268 | item->match[item->len] = '\0'; | |
269 | } | |
270 | } | |
271 | } | |
272 | ||
273 | static void strip_submodule_slash_expensive(struct pathspec_item *item) | |
274 | { | |
275 | int i; | |
276 | ||
277 | for (i = 0; i < active_nr; i++) { | |
278 | struct cache_entry *ce = active_cache[i]; | |
279 | int ce_len = ce_namelen(ce); | |
280 | ||
281 | if (!S_ISGITLINK(ce->ce_mode)) | |
282 | continue; | |
283 | ||
284 | if (item->len <= ce_len || item->match[ce_len] != '/' || | |
285 | memcmp(ce->name, item->match, ce_len)) | |
286 | continue; | |
287 | ||
288 | if (item->len == ce_len + 1) { | |
289 | /* strip trailing slash */ | |
290 | item->len--; | |
291 | item->match[item->len] = '\0'; | |
292 | } else { | |
293 | die(_("Pathspec '%s' is in submodule '%.*s'"), | |
294 | item->original, ce_len, ce->name); | |
295 | } | |
296 | } | |
297 | } | |
298 | ||
64acde94 NTND |
299 | /* |
300 | * Take an element of a pathspec and check for magic signatures. | |
87323bda | 301 | * Append the result to the prefix. Return the magic bitmap. |
64acde94 NTND |
302 | * |
303 | * For now, we only parse the syntax and throw out anything other than | |
304 | * "top" magic. | |
305 | * | |
306 | * NEEDSWORK: This needs to be rewritten when we start migrating | |
307 | * get_pathspec() users to use the "struct pathspec" interface. For | |
308 | * example, a pathspec element may be marked as case-insensitive, but | |
309 | * the prefix part must always match literally, and a single stupid | |
310 | * string cannot express such a case. | |
9d67b61f | 311 | */ |
2aee5849 | 312 | static unsigned prefix_pathspec(struct pathspec_item *item, unsigned flags, |
87323bda NTND |
313 | const char *prefix, int prefixlen, |
314 | const char *elt) | |
9d67b61f | 315 | { |
db7e8598 | 316 | unsigned magic = 0, element_magic = 0; |
5d8f084a | 317 | const char *copyfrom = elt; |
87323bda | 318 | char *match; |
5590215b | 319 | int pathspec_prefix = -1; |
64acde94 | 320 | |
db7e8598 | 321 | /* PATHSPEC_LITERAL_PATH ignores magic */ |
1b6112c5 | 322 | if (flags & PATHSPEC_LITERAL_PATH) { |
db7e8598 | 323 | magic = PATHSPEC_LITERAL; |
1b6112c5 BW |
324 | } else { |
325 | copyfrom = parse_element_magic(&element_magic, | |
326 | &pathspec_prefix, | |
327 | elt); | |
328 | magic |= element_magic; | |
db7e8598 | 329 | magic |= get_global_magic(element_magic); |
1b6112c5 | 330 | } |
87323bda | 331 | |
233c3e6c NTND |
332 | if (pathspec_prefix >= 0 && |
333 | (prefixlen || (prefix && *prefix))) | |
334 | die("BUG: 'prefix' magic is supposed to be used at worktree's root"); | |
335 | ||
bd30c2e4 NTND |
336 | if ((magic & PATHSPEC_LITERAL) && (magic & PATHSPEC_GLOB)) |
337 | die(_("%s: 'literal' and 'glob' are incompatible"), elt); | |
338 | ||
233c3e6c NTND |
339 | if (pathspec_prefix >= 0) { |
340 | match = xstrdup(copyfrom); | |
341 | prefixlen = pathspec_prefix; | |
342 | } else if (magic & PATHSPEC_FROMTOP) { | |
87323bda | 343 | match = xstrdup(copyfrom); |
645a29c4 NTND |
344 | prefixlen = 0; |
345 | } else { | |
346 | match = prefix_path_gently(prefix, prefixlen, &prefixlen, copyfrom); | |
347 | if (!match) | |
348 | die(_("%s: '%s' is outside repository"), elt, copyfrom); | |
349 | } | |
34305f77 | 350 | item->match = match; |
dad2586a NTND |
351 | /* |
352 | * Prefix the pathspec (keep all magic) and assign to | |
353 | * original. Useful for passing to another command. | |
354 | */ | |
5d8f084a | 355 | if ((flags & PATHSPEC_PREFIX_ORIGIN) && |
db7e8598 | 356 | prefixlen && !get_literal_global()) { |
dad2586a | 357 | struct strbuf sb = STRBUF_INIT; |
5d8f084a BW |
358 | |
359 | /* Preserve the actual prefix length of each pattern */ | |
360 | prefix_magic(&sb, prefixlen, element_magic); | |
361 | ||
dad2586a NTND |
362 | strbuf_addstr(&sb, match); |
363 | item->original = strbuf_detach(&sb, NULL); | |
8aee769f BW |
364 | } else { |
365 | item->original = xstrdup(elt); | |
366 | } | |
87323bda | 367 | item->len = strlen(item->match); |
645a29c4 | 368 | item->prefix = prefixlen; |
b69bb3fc | 369 | |
5590215b BW |
370 | if (flags & PATHSPEC_STRIP_SUBMODULE_SLASH_CHEAP) |
371 | strip_submodule_slash_cheap(item); | |
b69bb3fc | 372 | |
87450244 | 373 | if (flags & PATHSPEC_STRIP_SUBMODULE_SLASH_EXPENSIVE) |
5590215b | 374 | strip_submodule_slash_expensive(item); |
87450244 | 375 | |
5c6933d2 | 376 | if (magic & PATHSPEC_LITERAL) |
87323bda | 377 | item->nowildcard_len = item->len; |
645a29c4 | 378 | else { |
87323bda | 379 | item->nowildcard_len = simple_length(item->match); |
645a29c4 NTND |
380 | if (item->nowildcard_len < prefixlen) |
381 | item->nowildcard_len = prefixlen; | |
382 | } | |
87323bda | 383 | item->flags = 0; |
bd30c2e4 NTND |
384 | if (magic & PATHSPEC_GLOB) { |
385 | /* | |
386 | * FIXME: should we enable ONESTAR in _GLOB for | |
387 | * pattern "* * / * . c"? | |
388 | */ | |
389 | } else { | |
390 | if (item->nowildcard_len < item->len && | |
391 | item->match[item->nowildcard_len] == '*' && | |
392 | no_wildcard(item->match + item->nowildcard_len + 1)) | |
393 | item->flags |= PATHSPEC_ONESTAR; | |
9d67b61f | 394 | } |
645a29c4 NTND |
395 | |
396 | /* sanity checks, pathspec matchers assume these are sane */ | |
397 | assert(item->nowildcard_len <= item->len && | |
398 | item->prefix <= item->len); | |
87323bda NTND |
399 | return magic; |
400 | } | |
401 | ||
402 | static int pathspec_item_cmp(const void *a_, const void *b_) | |
403 | { | |
404 | struct pathspec_item *a, *b; | |
405 | ||
406 | a = (struct pathspec_item *)a_; | |
407 | b = (struct pathspec_item *)b_; | |
408 | return strcmp(a->match, b->match); | |
409 | } | |
410 | ||
411 | static void NORETURN unsupported_magic(const char *pattern, | |
2aee5849 | 412 | unsigned magic) |
87323bda NTND |
413 | { |
414 | struct strbuf sb = STRBUF_INIT; | |
93f3ddb2 BW |
415 | int i; |
416 | for (i = 0; i < ARRAY_SIZE(pathspec_magic); i++) { | |
87323bda NTND |
417 | const struct pathspec_magic *m = pathspec_magic + i; |
418 | if (!(magic & m->bit)) | |
419 | continue; | |
420 | if (sb.len) | |
2aee5849 BW |
421 | strbuf_addstr(&sb, ", "); |
422 | ||
423 | if (m->mnemonic) | |
424 | strbuf_addf(&sb, _("'%s' (mnemonic: '%c')"), | |
425 | m->name, m->mnemonic); | |
87323bda NTND |
426 | else |
427 | strbuf_addf(&sb, "'%s'", m->name); | |
87323bda NTND |
428 | } |
429 | /* | |
430 | * We may want to substitute "this command" with a command | |
431 | * name. E.g. when add--interactive dies when running | |
432 | * "checkout -p" | |
433 | */ | |
434 | die(_("%s: pathspec magic not supported by this command: %s"), | |
435 | pattern, sb.buf); | |
9d67b61f | 436 | } |
512aaf94 AS |
437 | |
438 | /* | |
87323bda NTND |
439 | * Given command line arguments and a prefix, convert the input to |
440 | * pathspec. die() if any magic in magic_mask is used. | |
512aaf94 | 441 | */ |
87323bda NTND |
442 | void parse_pathspec(struct pathspec *pathspec, |
443 | unsigned magic_mask, unsigned flags, | |
444 | const char *prefix, const char **argv) | |
512aaf94 | 445 | { |
87323bda NTND |
446 | struct pathspec_item *item; |
447 | const char *entry = argv ? *argv : NULL; | |
d426430e | 448 | int i, n, prefixlen, warn_empty_string, nr_exclude = 0; |
87323bda NTND |
449 | |
450 | memset(pathspec, 0, sizeof(*pathspec)); | |
451 | ||
6330a171 NTND |
452 | if (flags & PATHSPEC_MAXDEPTH_VALID) |
453 | pathspec->magic |= PATHSPEC_MAXDEPTH; | |
454 | ||
87323bda NTND |
455 | /* No arguments, no prefix -> no pathspec */ |
456 | if (!entry && !prefix) | |
457 | return; | |
458 | ||
fc12261f NTND |
459 | if ((flags & PATHSPEC_PREFER_CWD) && |
460 | (flags & PATHSPEC_PREFER_FULL)) | |
461 | die("BUG: PATHSPEC_PREFER_CWD and PATHSPEC_PREFER_FULL are incompatible"); | |
462 | ||
87323bda NTND |
463 | /* No arguments with prefix -> prefix pathspec */ |
464 | if (!entry) { | |
fc12261f NTND |
465 | if (flags & PATHSPEC_PREFER_FULL) |
466 | return; | |
467 | ||
468 | if (!(flags & PATHSPEC_PREFER_CWD)) | |
469 | die("BUG: PATHSPEC_PREFER_CWD requires arguments"); | |
470 | ||
51a60f5b | 471 | pathspec->items = item = xcalloc(1, sizeof(*item)); |
8aee769f BW |
472 | item->match = xstrdup(prefix); |
473 | item->original = xstrdup(prefix); | |
87323bda | 474 | item->nowildcard_len = item->len = strlen(prefix); |
645a29c4 | 475 | item->prefix = item->len; |
87323bda | 476 | pathspec->nr = 1; |
87323bda | 477 | return; |
512aaf94 | 478 | } |
87323bda NTND |
479 | |
480 | n = 0; | |
d426430e EX |
481 | warn_empty_string = 1; |
482 | while (argv[n]) { | |
483 | if (*argv[n] == '\0' && warn_empty_string) { | |
484 | warning(_("empty strings as pathspecs will be made invalid in upcoming releases. " | |
485 | "please use . instead if you meant to match all paths")); | |
486 | warn_empty_string = 0; | |
487 | } | |
87323bda | 488 | n++; |
d426430e | 489 | } |
87323bda NTND |
490 | |
491 | pathspec->nr = n; | |
b32fa95f JK |
492 | ALLOC_ARRAY(pathspec->items, n); |
493 | item = pathspec->items; | |
87323bda NTND |
494 | prefixlen = prefix ? strlen(prefix) : 0; |
495 | ||
496 | for (i = 0; i < n; i++) { | |
87323bda NTND |
497 | entry = argv[i]; |
498 | ||
2aee5849 | 499 | item[i].magic = prefix_pathspec(item + i, flags, |
87323bda | 500 | prefix, prefixlen, entry); |
db7e8598 | 501 | |
ef79b1f8 NTND |
502 | if (item[i].magic & PATHSPEC_EXCLUDE) |
503 | nr_exclude++; | |
87323bda | 504 | if (item[i].magic & magic_mask) |
2aee5849 | 505 | unsupported_magic(entry, item[i].magic & magic_mask); |
87450244 NTND |
506 | |
507 | if ((flags & PATHSPEC_SYMLINK_LEADING_PATH) && | |
508 | has_symlink_leading_path(item[i].match, item[i].len)) { | |
509 | die(_("pathspec '%s' is beyond a symbolic link"), entry); | |
510 | } | |
511 | ||
87323bda NTND |
512 | if (item[i].nowildcard_len < item[i].len) |
513 | pathspec->has_wildcard = 1; | |
514 | pathspec->magic |= item[i].magic; | |
515 | } | |
516 | ||
ef79b1f8 NTND |
517 | if (nr_exclude == n) |
518 | die(_("There is nothing to exclude from by :(exclude) patterns.\n" | |
519 | "Perhaps you forgot to add either ':/' or '.' ?")); | |
520 | ||
931eab64 NTND |
521 | |
522 | if (pathspec->magic & PATHSPEC_MAXDEPTH) { | |
523 | if (flags & PATHSPEC_KEEP_ORDER) | |
524 | die("BUG: PATHSPEC_MAXDEPTH_VALID and PATHSPEC_KEEP_ORDER are incompatible"); | |
9ed0d8d6 | 525 | QSORT(pathspec->items, pathspec->nr, pathspec_item_cmp); |
931eab64 | 526 | } |
64acde94 NTND |
527 | } |
528 | ||
e4d92cdc NTND |
529 | void copy_pathspec(struct pathspec *dst, const struct pathspec *src) |
530 | { | |
8aee769f BW |
531 | int i; |
532 | ||
e4d92cdc | 533 | *dst = *src; |
b32fa95f | 534 | ALLOC_ARRAY(dst->items, dst->nr); |
45ccef87 | 535 | COPY_ARRAY(dst->items, src->items, dst->nr); |
8aee769f BW |
536 | |
537 | for (i = 0; i < dst->nr; i++) { | |
538 | dst->items[i].match = xstrdup(src->items[i].match); | |
539 | dst->items[i].original = xstrdup(src->items[i].original); | |
540 | } | |
e4d92cdc | 541 | } |
9a087274 | 542 | |
ed6e8038 | 543 | void clear_pathspec(struct pathspec *pathspec) |
9a087274 | 544 | { |
8aee769f BW |
545 | int i; |
546 | ||
547 | for (i = 0; i < pathspec->nr; i++) { | |
548 | free(pathspec->items[i].match); | |
549 | free(pathspec->items[i].original); | |
550 | } | |
9a087274 NTND |
551 | free(pathspec->items); |
552 | pathspec->items = NULL; | |
8aee769f | 553 | pathspec->nr = 0; |
512aaf94 | 554 | } |