1/* 2 * This handles recursive filename detection with exclude 3 * files, index knowledge etc.. 4 * 5 * See Documentation/technical/api-directory-listing.txt 6 * 7 * Copyright (C) Linus Torvalds, 2005-2006 8 * Junio Hamano, 2005-2006 9 */ 10#include "cache.h" 11#include "dir.h" 12#include "refs.h" 13#include "wildmatch.h" 14 15struct path_simplify { 16 int len; 17 const char *path; 18}; 19 20/* 21 * Tells read_directory_recursive how a file or directory should be treated. 22 * Values are ordered by significance, e.g. if a directory contains both 23 * excluded and untracked files, it is listed as untracked because 24 * path_untracked > path_excluded. 25 */ 26enum path_treatment { 27 path_none = 0, 28 path_recurse, 29 path_excluded, 30 path_untracked 31}; 32 33static enum path_treatment read_directory_recursive(struct dir_struct *dir, 34 const char *path, int len, 35 int check_only, const struct path_simplify *simplify); 36static int get_dtype(struct dirent *de, const char *path, int len); 37 38/* helper string functions with support for the ignore_case flag */ 39int strcmp_icase(const char *a, const char *b) 40{ 41 return ignore_case ? strcasecmp(a, b) : strcmp(a, b); 42} 43 44int strncmp_icase(const char *a, const char *b, size_t count) 45{ 46 return ignore_case ? strncasecmp(a, b, count) : strncmp(a, b, count); 47} 48 49int fnmatch_icase(const char *pattern, const char *string, int flags) 50{ 51 return fnmatch(pattern, string, flags | (ignore_case ? FNM_CASEFOLD : 0)); 52} 53 54inline int git_fnmatch(const char *pattern, const char *string, 55 int flags, int prefix) 56{ 57 int fnm_flags = 0; 58 if (flags & GFNM_PATHNAME) 59 fnm_flags |= FNM_PATHNAME; 60 if (prefix > 0) { 61 if (strncmp(pattern, string, prefix)) 62 return FNM_NOMATCH; 63 pattern += prefix; 64 string += prefix; 65 } 66 if (flags & GFNM_ONESTAR) { 67 int pattern_len = strlen(++pattern); 68 int string_len = strlen(string); 69 return string_len < pattern_len || 70 strcmp(pattern, 71 string + string_len - pattern_len); 72 } 73 return fnmatch(pattern, string, fnm_flags); 74} 75 76static int fnmatch_icase_mem(const char *pattern, int patternlen, 77 const char *string, int stringlen, 78 int flags) 79{ 80 int match_status; 81 struct strbuf pat_buf = STRBUF_INIT; 82 struct strbuf str_buf = STRBUF_INIT; 83 const char *use_pat = pattern; 84 const char *use_str = string; 85 86 if (pattern[patternlen]) { 87 strbuf_add(&pat_buf, pattern, patternlen); 88 use_pat = pat_buf.buf; 89 } 90 if (string[stringlen]) { 91 strbuf_add(&str_buf, string, stringlen); 92 use_str = str_buf.buf; 93 } 94 95 if (ignore_case) 96 flags |= WM_CASEFOLD; 97 match_status = wildmatch(use_pat, use_str, flags, NULL); 98 99 strbuf_release(&pat_buf); 100 strbuf_release(&str_buf); 101 102 return match_status; 103} 104 105static size_t common_prefix_len(const char **pathspec) 106{ 107 const char *n, *first; 108 size_t max = 0; 109 int literal = limit_pathspec_to_literal(); 110 111 if (!pathspec) 112 return max; 113 114 first = *pathspec; 115 while ((n = *pathspec++)) { 116 size_t i, len = 0; 117 for (i = 0; first == n || i < max; i++) { 118 char c = n[i]; 119 if (!c || c != first[i] || (!literal && is_glob_special(c))) 120 break; 121 if (c == '/') 122 len = i + 1; 123 } 124 if (first == n || len < max) { 125 max = len; 126 if (!max) 127 break; 128 } 129 } 130 return max; 131} 132 133/* 134 * Returns a copy of the longest leading path common among all 135 * pathspecs. 136 */ 137char *common_prefix(const char **pathspec) 138{ 139 unsigned long len = common_prefix_len(pathspec); 140 141 return len ? xmemdupz(*pathspec, len) : NULL; 142} 143 144int fill_directory(struct dir_struct *dir, const char **pathspec) 145{ 146 size_t len; 147 148 /* 149 * Calculate common prefix for the pathspec, and 150 * use that to optimize the directory walk 151 */ 152 len = common_prefix_len(pathspec); 153 154 /* Read the directory and prune it */ 155 read_directory(dir, pathspec ? *pathspec : "", len, pathspec); 156 return len; 157} 158 159int within_depth(const char *name, int namelen, 160 int depth, int max_depth) 161{ 162 const char *cp = name, *cpe = name + namelen; 163 164 while (cp < cpe) { 165 if (*cp++ != '/') 166 continue; 167 depth++; 168 if (depth > max_depth) 169 return 0; 170 } 171 return 1; 172} 173 174/* 175 * Does 'match' match the given name? 176 * A match is found if 177 * 178 * (1) the 'match' string is leading directory of 'name', or 179 * (2) the 'match' string is a wildcard and matches 'name', or 180 * (3) the 'match' string is exactly the same as 'name'. 181 * 182 * and the return value tells which case it was. 183 * 184 * It returns 0 when there is no match. 185 */ 186static int match_one(const char *match, const char *name, int namelen) 187{ 188 int matchlen; 189 int literal = limit_pathspec_to_literal(); 190 191 /* If the match was just the prefix, we matched */ 192 if (!*match) 193 return MATCHED_RECURSIVELY; 194 195 if (ignore_case) { 196 for (;;) { 197 unsigned char c1 = tolower(*match); 198 unsigned char c2 = tolower(*name); 199 if (c1 == '\0' || (!literal && is_glob_special(c1))) 200 break; 201 if (c1 != c2) 202 return 0; 203 match++; 204 name++; 205 namelen--; 206 } 207 } else { 208 for (;;) { 209 unsigned char c1 = *match; 210 unsigned char c2 = *name; 211 if (c1 == '\0' || (!literal && is_glob_special(c1))) 212 break; 213 if (c1 != c2) 214 return 0; 215 match++; 216 name++; 217 namelen--; 218 } 219 } 220 221 /* 222 * If we don't match the matchstring exactly, 223 * we need to match by fnmatch 224 */ 225 matchlen = strlen(match); 226 if (strncmp_icase(match, name, matchlen)) { 227 if (literal) 228 return 0; 229 return !fnmatch_icase(match, name, 0) ? MATCHED_FNMATCH : 0; 230 } 231 232 if (namelen == matchlen) 233 return MATCHED_EXACTLY; 234 if (match[matchlen-1] == '/' || name[matchlen] == '/') 235 return MATCHED_RECURSIVELY; 236 return 0; 237} 238 239/* 240 * Given a name and a list of pathspecs, returns the nature of the 241 * closest (i.e. most specific) match of the name to any of the 242 * pathspecs. 243 * 244 * The caller typically calls this multiple times with the same 245 * pathspec and seen[] array but with different name/namelen 246 * (e.g. entries from the index) and is interested in seeing if and 247 * how each pathspec matches all the names it calls this function 248 * with. A mark is left in the seen[] array for each pathspec element 249 * indicating the closest type of match that element achieved, so if 250 * seen[n] remains zero after multiple invocations, that means the nth 251 * pathspec did not match any names, which could indicate that the 252 * user mistyped the nth pathspec. 253 */ 254int match_pathspec(const char **pathspec, const char *name, int namelen, 255 int prefix, char *seen) 256{ 257 int i, retval = 0; 258 259 if (!pathspec) 260 return 1; 261 262 name += prefix; 263 namelen -= prefix; 264 265 for (i = 0; pathspec[i] != NULL; i++) { 266 int how; 267 const char *match = pathspec[i] + prefix; 268 if (seen && seen[i] == MATCHED_EXACTLY) 269 continue; 270 how = match_one(match, name, namelen); 271 if (how) { 272 if (retval < how) 273 retval = how; 274 if (seen && seen[i] < how) 275 seen[i] = how; 276 } 277 } 278 return retval; 279} 280 281/* 282 * Does 'match' match the given name? 283 * A match is found if 284 * 285 * (1) the 'match' string is leading directory of 'name', or 286 * (2) the 'match' string is a wildcard and matches 'name', or 287 * (3) the 'match' string is exactly the same as 'name'. 288 * 289 * and the return value tells which case it was. 290 * 291 * It returns 0 when there is no match. 292 */ 293static int match_pathspec_item(const struct pathspec_item *item, int prefix, 294 const char *name, int namelen) 295{ 296 /* name/namelen has prefix cut off by caller */ 297 const char *match = item->match + prefix; 298 int matchlen = item->len - prefix; 299 300 /* If the match was just the prefix, we matched */ 301 if (!*match) 302 return MATCHED_RECURSIVELY; 303 304 if (matchlen <= namelen && !strncmp(match, name, matchlen)) { 305 if (matchlen == namelen) 306 return MATCHED_EXACTLY; 307 308 if (match[matchlen-1] == '/' || name[matchlen] == '/') 309 return MATCHED_RECURSIVELY; 310 } 311 312 if (item->nowildcard_len < item->len && 313 !git_fnmatch(match, name, 314 item->flags & PATHSPEC_ONESTAR ? GFNM_ONESTAR : 0, 315 item->nowildcard_len - prefix)) 316 return MATCHED_FNMATCH; 317 318 return 0; 319} 320 321/* 322 * Given a name and a list of pathspecs, returns the nature of the 323 * closest (i.e. most specific) match of the name to any of the 324 * pathspecs. 325 * 326 * The caller typically calls this multiple times with the same 327 * pathspec and seen[] array but with different name/namelen 328 * (e.g. entries from the index) and is interested in seeing if and 329 * how each pathspec matches all the names it calls this function 330 * with. A mark is left in the seen[] array for each pathspec element 331 * indicating the closest type of match that element achieved, so if 332 * seen[n] remains zero after multiple invocations, that means the nth 333 * pathspec did not match any names, which could indicate that the 334 * user mistyped the nth pathspec. 335 */ 336int match_pathspec_depth(const struct pathspec *ps, 337 const char *name, int namelen, 338 int prefix, char *seen) 339{ 340 int i, retval = 0; 341 342 if (!ps->nr) { 343 if (!ps->recursive || ps->max_depth == -1) 344 return MATCHED_RECURSIVELY; 345 346 if (within_depth(name, namelen, 0, ps->max_depth)) 347 return MATCHED_EXACTLY; 348 else 349 return 0; 350 } 351 352 name += prefix; 353 namelen -= prefix; 354 355 for (i = ps->nr - 1; i >= 0; i--) { 356 int how; 357 if (seen && seen[i] == MATCHED_EXACTLY) 358 continue; 359 how = match_pathspec_item(ps->items+i, prefix, name, namelen); 360 if (ps->recursive && ps->max_depth != -1 && 361 how && how != MATCHED_FNMATCH) { 362 int len = ps->items[i].len; 363 if (name[len] == '/') 364 len++; 365 if (within_depth(name+len, namelen-len, 0, ps->max_depth)) 366 how = MATCHED_EXACTLY; 367 else 368 how = 0; 369 } 370 if (how) { 371 if (retval < how) 372 retval = how; 373 if (seen && seen[i] < how) 374 seen[i] = how; 375 } 376 } 377 return retval; 378} 379 380/* 381 * Return the length of the "simple" part of a path match limiter. 382 */ 383static int simple_length(const char *match) 384{ 385 int len = -1; 386 387 for (;;) { 388 unsigned char c = *match++; 389 len++; 390 if (c == '\0' || is_glob_special(c)) 391 return len; 392 } 393} 394 395static int no_wildcard(const char *string) 396{ 397 return string[simple_length(string)] == '\0'; 398} 399 400void parse_exclude_pattern(const char **pattern, 401 int *patternlen, 402 int *flags, 403 int *nowildcardlen) 404{ 405 const char *p = *pattern; 406 size_t i, len; 407 408 *flags = 0; 409 if (*p == '!') { 410 *flags |= EXC_FLAG_NEGATIVE; 411 p++; 412 } 413 len = strlen(p); 414 if (len && p[len - 1] == '/') { 415 len--; 416 *flags |= EXC_FLAG_MUSTBEDIR; 417 } 418 for (i = 0; i < len; i++) { 419 if (p[i] == '/') 420 break; 421 } 422 if (i == len) 423 *flags |= EXC_FLAG_NODIR; 424 *nowildcardlen = simple_length(p); 425 /* 426 * we should have excluded the trailing slash from 'p' too, 427 * but that's one more allocation. Instead just make sure 428 * nowildcardlen does not exceed real patternlen 429 */ 430 if (*nowildcardlen > len) 431 *nowildcardlen = len; 432 if (*p == '*' && no_wildcard(p + 1)) 433 *flags |= EXC_FLAG_ENDSWITH; 434 *pattern = p; 435 *patternlen = len; 436} 437 438void add_exclude(const char *string, const char *base, 439 int baselen, struct exclude_list *el, int srcpos) 440{ 441 struct exclude *x; 442 int patternlen; 443 int flags; 444 int nowildcardlen; 445 446 parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen); 447 if (flags & EXC_FLAG_MUSTBEDIR) { 448 char *s; 449 x = xmalloc(sizeof(*x) + patternlen + 1); 450 s = (char *)(x+1); 451 memcpy(s, string, patternlen); 452 s[patternlen] = '\0'; 453 x->pattern = s; 454 } else { 455 x = xmalloc(sizeof(*x)); 456 x->pattern = string; 457 } 458 x->patternlen = patternlen; 459 x->nowildcardlen = nowildcardlen; 460 x->base = base; 461 x->baselen = baselen; 462 x->flags = flags; 463 x->srcpos = srcpos; 464 ALLOC_GROW(el->excludes, el->nr + 1, el->alloc); 465 el->excludes[el->nr++] = x; 466 x->el = el; 467} 468 469static void *read_skip_worktree_file_from_index(const char *path, size_t *size) 470{ 471 int pos, len; 472 unsigned long sz; 473 enum object_type type; 474 void *data; 475 476 len = strlen(path); 477 pos = cache_name_pos(path, len); 478 if (pos < 0) 479 return NULL; 480 if (!ce_skip_worktree(active_cache[pos])) 481 return NULL; 482 data = read_sha1_file(active_cache[pos]->sha1, &type, &sz); 483 if (!data || type != OBJ_BLOB) { 484 free(data); 485 return NULL; 486 } 487 *size = xsize_t(sz); 488 return data; 489} 490 491/* 492 * Frees memory within el which was allocated for exclude patterns and 493 * the file buffer. Does not free el itself. 494 */ 495void clear_exclude_list(struct exclude_list *el) 496{ 497 int i; 498 499 for (i = 0; i < el->nr; i++) 500 free(el->excludes[i]); 501 free(el->excludes); 502 free(el->filebuf); 503 504 el->nr = 0; 505 el->excludes = NULL; 506 el->filebuf = NULL; 507} 508 509int add_excludes_from_file_to_list(const char *fname, 510 const char *base, 511 int baselen, 512 struct exclude_list *el, 513 int check_index) 514{ 515 struct stat st; 516 int fd, i, lineno = 1; 517 size_t size = 0; 518 char *buf, *entry; 519 520 fd = open(fname, O_RDONLY); 521 if (fd < 0 || fstat(fd, &st) < 0) { 522 if (errno != ENOENT) 523 warn_on_inaccessible(fname); 524 if (0 <= fd) 525 close(fd); 526 if (!check_index || 527 (buf = read_skip_worktree_file_from_index(fname, &size)) == NULL) 528 return -1; 529 if (size == 0) { 530 free(buf); 531 return 0; 532 } 533 if (buf[size-1] != '\n') { 534 buf = xrealloc(buf, size+1); 535 buf[size++] = '\n'; 536 } 537 } 538 else { 539 size = xsize_t(st.st_size); 540 if (size == 0) { 541 close(fd); 542 return 0; 543 } 544 buf = xmalloc(size+1); 545 if (read_in_full(fd, buf, size) != size) { 546 free(buf); 547 close(fd); 548 return -1; 549 } 550 buf[size++] = '\n'; 551 close(fd); 552 } 553 554 el->filebuf = buf; 555 entry = buf; 556 for (i = 0; i < size; i++) { 557 if (buf[i] == '\n') { 558 if (entry != buf + i && entry[0] != '#') { 559 buf[i - (i && buf[i-1] == '\r')] = 0; 560 add_exclude(entry, base, baselen, el, lineno); 561 } 562 lineno++; 563 entry = buf + i + 1; 564 } 565 } 566 return 0; 567} 568 569struct exclude_list *add_exclude_list(struct dir_struct *dir, 570 int group_type, const char *src) 571{ 572 struct exclude_list *el; 573 struct exclude_list_group *group; 574 575 group = &dir->exclude_list_group[group_type]; 576 ALLOC_GROW(group->el, group->nr + 1, group->alloc); 577 el = &group->el[group->nr++]; 578 memset(el, 0, sizeof(*el)); 579 el->src = src; 580 return el; 581} 582 583/* 584 * Used to set up core.excludesfile and .git/info/exclude lists. 585 */ 586void add_excludes_from_file(struct dir_struct *dir, const char *fname) 587{ 588 struct exclude_list *el; 589 el = add_exclude_list(dir, EXC_FILE, fname); 590 if (add_excludes_from_file_to_list(fname, "", 0, el, 0) < 0) 591 die("cannot use %s as an exclude file", fname); 592} 593 594int match_basename(const char *basename, int basenamelen, 595 const char *pattern, int prefix, int patternlen, 596 int flags) 597{ 598 if (prefix == patternlen) { 599 if (patternlen == basenamelen && 600 !strncmp_icase(pattern, basename, basenamelen)) 601 return 1; 602 } else if (flags & EXC_FLAG_ENDSWITH) { 603 /* "*literal" matching against "fooliteral" */ 604 if (patternlen - 1 <= basenamelen && 605 !strncmp_icase(pattern + 1, 606 basename + basenamelen - (patternlen - 1), 607 patternlen - 1)) 608 return 1; 609 } else { 610 if (fnmatch_icase_mem(pattern, patternlen, 611 basename, basenamelen, 612 0) == 0) 613 return 1; 614 } 615 return 0; 616} 617 618int match_pathname(const char *pathname, int pathlen, 619 const char *base, int baselen, 620 const char *pattern, int prefix, int patternlen, 621 int flags) 622{ 623 const char *name; 624 int namelen; 625 626 /* 627 * match with FNM_PATHNAME; the pattern has base implicitly 628 * in front of it. 629 */ 630 if (*pattern == '/') { 631 pattern++; 632 patternlen--; 633 prefix--; 634 } 635 636 /* 637 * baselen does not count the trailing slash. base[] may or 638 * may not end with a trailing slash though. 639 */ 640 if (pathlen < baselen + 1 || 641 (baselen && pathname[baselen] != '/') || 642 strncmp_icase(pathname, base, baselen)) 643 return 0; 644 645 namelen = baselen ? pathlen - baselen - 1 : pathlen; 646 name = pathname + pathlen - namelen; 647 648 if (prefix) { 649 /* 650 * if the non-wildcard part is longer than the 651 * remaining pathname, surely it cannot match. 652 */ 653 if (prefix > namelen) 654 return 0; 655 656 if (strncmp_icase(pattern, name, prefix)) 657 return 0; 658 pattern += prefix; 659 patternlen -= prefix; 660 name += prefix; 661 namelen -= prefix; 662 663 /* 664 * If the whole pattern did not have a wildcard, 665 * then our prefix match is all we need; we 666 * do not need to call fnmatch at all. 667 */ 668 if (!patternlen && !namelen) 669 return 1; 670 } 671 672 return fnmatch_icase_mem(pattern, patternlen, 673 name, namelen, 674 WM_PATHNAME) == 0; 675} 676 677/* 678 * Scan the given exclude list in reverse to see whether pathname 679 * should be ignored. The first match (i.e. the last on the list), if 680 * any, determines the fate. Returns the exclude_list element which 681 * matched, or NULL for undecided. 682 */ 683static struct exclude *last_exclude_matching_from_list(const char *pathname, 684 int pathlen, 685 const char *basename, 686 int *dtype, 687 struct exclude_list *el) 688{ 689 int i; 690 691 if (!el->nr) 692 return NULL; /* undefined */ 693 694 for (i = el->nr - 1; 0 <= i; i--) { 695 struct exclude *x = el->excludes[i]; 696 const char *exclude = x->pattern; 697 int prefix = x->nowildcardlen; 698 699 if (x->flags & EXC_FLAG_MUSTBEDIR) { 700 if (*dtype == DT_UNKNOWN) 701 *dtype = get_dtype(NULL, pathname, pathlen); 702 if (*dtype != DT_DIR) 703 continue; 704 } 705 706 if (x->flags & EXC_FLAG_NODIR) { 707 if (match_basename(basename, 708 pathlen - (basename - pathname), 709 exclude, prefix, x->patternlen, 710 x->flags)) 711 return x; 712 continue; 713 } 714 715 assert(x->baselen == 0 || x->base[x->baselen - 1] == '/'); 716 if (match_pathname(pathname, pathlen, 717 x->base, x->baselen ? x->baselen - 1 : 0, 718 exclude, prefix, x->patternlen, x->flags)) 719 return x; 720 } 721 return NULL; /* undecided */ 722} 723 724/* 725 * Scan the list and let the last match determine the fate. 726 * Return 1 for exclude, 0 for include and -1 for undecided. 727 */ 728int is_excluded_from_list(const char *pathname, 729 int pathlen, const char *basename, int *dtype, 730 struct exclude_list *el) 731{ 732 struct exclude *exclude; 733 exclude = last_exclude_matching_from_list(pathname, pathlen, basename, dtype, el); 734 if (exclude) 735 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1; 736 return -1; /* undecided */ 737} 738 739static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir, 740 const char *pathname, int pathlen, const char *basename, 741 int *dtype_p) 742{ 743 int i, j; 744 struct exclude_list_group *group; 745 struct exclude *exclude; 746 for (i = EXC_CMDL; i <= EXC_FILE; i++) { 747 group = &dir->exclude_list_group[i]; 748 for (j = group->nr - 1; j >= 0; j--) { 749 exclude = last_exclude_matching_from_list( 750 pathname, pathlen, basename, dtype_p, 751 &group->el[j]); 752 if (exclude) 753 return exclude; 754 } 755 } 756 return NULL; 757} 758 759/* 760 * Loads the per-directory exclude list for the substring of base 761 * which has a char length of baselen. 762 */ 763static void prep_exclude(struct dir_struct *dir, const char *base, int baselen) 764{ 765 struct exclude_list_group *group; 766 struct exclude_list *el; 767 struct exclude_stack *stk = NULL; 768 int current; 769 770 group = &dir->exclude_list_group[EXC_DIRS]; 771 772 /* Pop the exclude lists from the EXCL_DIRS exclude_list_group 773 * which originate from directories not in the prefix of the 774 * path being checked. */ 775 while ((stk = dir->exclude_stack) != NULL) { 776 if (stk->baselen <= baselen && 777 !strncmp(dir->basebuf, base, stk->baselen)) 778 break; 779 el = &group->el[dir->exclude_stack->exclude_ix]; 780 dir->exclude_stack = stk->prev; 781 dir->exclude = NULL; 782 free((char *)el->src); /* see strdup() below */ 783 clear_exclude_list(el); 784 free(stk); 785 group->nr--; 786 } 787 788 /* Skip traversing into sub directories if the parent is excluded */ 789 if (dir->exclude) 790 return; 791 792 /* Read from the parent directories and push them down. */ 793 current = stk ? stk->baselen : -1; 794 while (current < baselen) { 795 struct exclude_stack *stk = xcalloc(1, sizeof(*stk)); 796 const char *cp; 797 798 if (current < 0) { 799 cp = base; 800 current = 0; 801 } 802 else { 803 cp = strchr(base + current + 1, '/'); 804 if (!cp) 805 die("oops in prep_exclude"); 806 cp++; 807 } 808 stk->prev = dir->exclude_stack; 809 stk->baselen = cp - base; 810 stk->exclude_ix = group->nr; 811 el = add_exclude_list(dir, EXC_DIRS, NULL); 812 memcpy(dir->basebuf + current, base + current, 813 stk->baselen - current); 814 815 /* Abort if the directory is excluded */ 816 if (stk->baselen) { 817 int dt = DT_DIR; 818 dir->basebuf[stk->baselen - 1] = 0; 819 dir->exclude = last_exclude_matching_from_lists(dir, 820 dir->basebuf, stk->baselen - 1, 821 dir->basebuf + current, &dt); 822 dir->basebuf[stk->baselen - 1] = '/'; 823 if (dir->exclude) { 824 dir->basebuf[stk->baselen] = 0; 825 dir->exclude_stack = stk; 826 return; 827 } 828 } 829 830 /* Try to read per-directory file unless path is too long */ 831 if (dir->exclude_per_dir && 832 stk->baselen + strlen(dir->exclude_per_dir) < PATH_MAX) { 833 strcpy(dir->basebuf + stk->baselen, 834 dir->exclude_per_dir); 835 /* 836 * dir->basebuf gets reused by the traversal, but we 837 * need fname to remain unchanged to ensure the src 838 * member of each struct exclude correctly 839 * back-references its source file. Other invocations 840 * of add_exclude_list provide stable strings, so we 841 * strdup() and free() here in the caller. 842 */ 843 el->src = strdup(dir->basebuf); 844 add_excludes_from_file_to_list(dir->basebuf, 845 dir->basebuf, stk->baselen, el, 1); 846 } 847 dir->exclude_stack = stk; 848 current = stk->baselen; 849 } 850 dir->basebuf[baselen] = '\0'; 851} 852 853/* 854 * Loads the exclude lists for the directory containing pathname, then 855 * scans all exclude lists to determine whether pathname is excluded. 856 * Returns the exclude_list element which matched, or NULL for 857 * undecided. 858 */ 859struct exclude *last_exclude_matching(struct dir_struct *dir, 860 const char *pathname, 861 int *dtype_p) 862{ 863 int pathlen = strlen(pathname); 864 const char *basename = strrchr(pathname, '/'); 865 basename = (basename) ? basename+1 : pathname; 866 867 prep_exclude(dir, pathname, basename-pathname); 868 869 if (dir->exclude) 870 return dir->exclude; 871 872 return last_exclude_matching_from_lists(dir, pathname, pathlen, 873 basename, dtype_p); 874} 875 876/* 877 * Loads the exclude lists for the directory containing pathname, then 878 * scans all exclude lists to determine whether pathname is excluded. 879 * Returns 1 if true, otherwise 0. 880 */ 881int is_excluded(struct dir_struct *dir, const char *pathname, int *dtype_p) 882{ 883 struct exclude *exclude = 884 last_exclude_matching(dir, pathname, dtype_p); 885 if (exclude) 886 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1; 887 return 0; 888} 889 890static struct dir_entry *dir_entry_new(const char *pathname, int len) 891{ 892 struct dir_entry *ent; 893 894 ent = xmalloc(sizeof(*ent) + len + 1); 895 ent->len = len; 896 memcpy(ent->name, pathname, len); 897 ent->name[len] = 0; 898 return ent; 899} 900 901static struct dir_entry *dir_add_name(struct dir_struct *dir, const char *pathname, int len) 902{ 903 if (cache_name_exists(pathname, len, ignore_case)) 904 return NULL; 905 906 ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc); 907 return dir->entries[dir->nr++] = dir_entry_new(pathname, len); 908} 909 910struct dir_entry *dir_add_ignored(struct dir_struct *dir, const char *pathname, int len) 911{ 912 if (!cache_name_is_other(pathname, len)) 913 return NULL; 914 915 ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc); 916 return dir->ignored[dir->ignored_nr++] = dir_entry_new(pathname, len); 917} 918 919enum exist_status { 920 index_nonexistent = 0, 921 index_directory, 922 index_gitdir 923}; 924 925/* 926 * Do not use the alphabetically sorted index to look up 927 * the directory name; instead, use the case insensitive 928 * name hash. 929 */ 930static enum exist_status directory_exists_in_index_icase(const char *dirname, int len) 931{ 932 struct cache_entry *ce = cache_name_exists(dirname, len + 1, ignore_case); 933 unsigned char endchar; 934 935 if (!ce) 936 return index_nonexistent; 937 endchar = ce->name[len]; 938 939 /* 940 * The cache_entry structure returned will contain this dirname 941 * and possibly additional path components. 942 */ 943 if (endchar == '/') 944 return index_directory; 945 946 /* 947 * If there are no additional path components, then this cache_entry 948 * represents a submodule. Submodules, despite being directories, 949 * are stored in the cache without a closing slash. 950 */ 951 if (!endchar && S_ISGITLINK(ce->ce_mode)) 952 return index_gitdir; 953 954 /* This should never be hit, but it exists just in case. */ 955 return index_nonexistent; 956} 957 958/* 959 * The index sorts alphabetically by entry name, which 960 * means that a gitlink sorts as '\0' at the end, while 961 * a directory (which is defined not as an entry, but as 962 * the files it contains) will sort with the '/' at the 963 * end. 964 */ 965static enum exist_status directory_exists_in_index(const char *dirname, int len) 966{ 967 int pos; 968 969 if (ignore_case) 970 return directory_exists_in_index_icase(dirname, len); 971 972 pos = cache_name_pos(dirname, len); 973 if (pos < 0) 974 pos = -pos-1; 975 while (pos < active_nr) { 976 struct cache_entry *ce = active_cache[pos++]; 977 unsigned char endchar; 978 979 if (strncmp(ce->name, dirname, len)) 980 break; 981 endchar = ce->name[len]; 982 if (endchar > '/') 983 break; 984 if (endchar == '/') 985 return index_directory; 986 if (!endchar && S_ISGITLINK(ce->ce_mode)) 987 return index_gitdir; 988 } 989 return index_nonexistent; 990} 991 992/* 993 * When we find a directory when traversing the filesystem, we 994 * have three distinct cases: 995 * 996 * - ignore it 997 * - see it as a directory 998 * - recurse into it 999 *1000 * and which one we choose depends on a combination of existing1001 * git index contents and the flags passed into the directory1002 * traversal routine.1003 *1004 * Case 1: If we *already* have entries in the index under that1005 * directory name, we always recurse into the directory to see1006 * all the files.1007 *1008 * Case 2: If we *already* have that directory name as a gitlink,1009 * we always continue to see it as a gitlink, regardless of whether1010 * there is an actual git directory there or not (it might not1011 * be checked out as a subproject!)1012 *1013 * Case 3: if we didn't have it in the index previously, we1014 * have a few sub-cases:1015 *1016 * (a) if "show_other_directories" is true, we show it as1017 * just a directory, unless "hide_empty_directories" is1018 * also true, in which case we need to check if it contains any1019 * untracked and / or ignored files.1020 * (b) if it looks like a git directory, and we don't have1021 * 'no_gitlinks' set we treat it as a gitlink, and show it1022 * as a directory.1023 * (c) otherwise, we recurse into it.1024 */1025static enum path_treatment treat_directory(struct dir_struct *dir,1026 const char *dirname, int len, int exclude,1027 const struct path_simplify *simplify)1028{1029 /* The "len-1" is to strip the final '/' */1030 switch (directory_exists_in_index(dirname, len-1)) {1031 case index_directory:1032 return path_recurse;10331034 case index_gitdir:1035 if (dir->flags & DIR_SHOW_OTHER_DIRECTORIES)1036 return path_none;1037 return path_untracked;10381039 case index_nonexistent:1040 if (dir->flags & DIR_SHOW_OTHER_DIRECTORIES)1041 break;1042 if (!(dir->flags & DIR_NO_GITLINKS)) {1043 unsigned char sha1[20];1044 if (resolve_gitlink_ref(dirname, "HEAD", sha1) == 0)1045 return path_untracked;1046 }1047 return path_recurse;1048 }10491050 /* This is the "show_other_directories" case */10511052 if (!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1053 return exclude ? path_excluded : path_untracked;10541055 return read_directory_recursive(dir, dirname, len, 1, simplify);1056}10571058/*1059 * This is an inexact early pruning of any recursive directory1060 * reading - if the path cannot possibly be in the pathspec,1061 * return true, and we'll skip it early.1062 */1063static int simplify_away(const char *path, int pathlen, const struct path_simplify *simplify)1064{1065 if (simplify) {1066 for (;;) {1067 const char *match = simplify->path;1068 int len = simplify->len;10691070 if (!match)1071 break;1072 if (len > pathlen)1073 len = pathlen;1074 if (!memcmp(path, match, len))1075 return 0;1076 simplify++;1077 }1078 return 1;1079 }1080 return 0;1081}10821083/*1084 * This function tells us whether an excluded path matches a1085 * list of "interesting" pathspecs. That is, whether a path matched1086 * by any of the pathspecs could possibly be ignored by excluding1087 * the specified path. This can happen if:1088 *1089 * 1. the path is mentioned explicitly in the pathspec1090 *1091 * 2. the path is a directory prefix of some element in the1092 * pathspec1093 */1094static int exclude_matches_pathspec(const char *path, int len,1095 const struct path_simplify *simplify)1096{1097 if (simplify) {1098 for (; simplify->path; simplify++) {1099 if (len == simplify->len1100 && !memcmp(path, simplify->path, len))1101 return 1;1102 if (len < simplify->len1103 && simplify->path[len] == '/'1104 && !memcmp(path, simplify->path, len))1105 return 1;1106 }1107 }1108 return 0;1109}11101111static int get_index_dtype(const char *path, int len)1112{1113 int pos;1114 struct cache_entry *ce;11151116 ce = cache_name_exists(path, len, 0);1117 if (ce) {1118 if (!ce_uptodate(ce))1119 return DT_UNKNOWN;1120 if (S_ISGITLINK(ce->ce_mode))1121 return DT_DIR;1122 /*1123 * Nobody actually cares about the1124 * difference between DT_LNK and DT_REG1125 */1126 return DT_REG;1127 }11281129 /* Try to look it up as a directory */1130 pos = cache_name_pos(path, len);1131 if (pos >= 0)1132 return DT_UNKNOWN;1133 pos = -pos-1;1134 while (pos < active_nr) {1135 ce = active_cache[pos++];1136 if (strncmp(ce->name, path, len))1137 break;1138 if (ce->name[len] > '/')1139 break;1140 if (ce->name[len] < '/')1141 continue;1142 if (!ce_uptodate(ce))1143 break; /* continue? */1144 return DT_DIR;1145 }1146 return DT_UNKNOWN;1147}11481149static int get_dtype(struct dirent *de, const char *path, int len)1150{1151 int dtype = de ? DTYPE(de) : DT_UNKNOWN;1152 struct stat st;11531154 if (dtype != DT_UNKNOWN)1155 return dtype;1156 dtype = get_index_dtype(path, len);1157 if (dtype != DT_UNKNOWN)1158 return dtype;1159 if (lstat(path, &st))1160 return dtype;1161 if (S_ISREG(st.st_mode))1162 return DT_REG;1163 if (S_ISDIR(st.st_mode))1164 return DT_DIR;1165 if (S_ISLNK(st.st_mode))1166 return DT_LNK;1167 return dtype;1168}11691170static enum path_treatment treat_one_path(struct dir_struct *dir,1171 struct strbuf *path,1172 const struct path_simplify *simplify,1173 int dtype, struct dirent *de)1174{1175 int exclude;1176 int has_path_in_index = !!cache_name_exists(path->buf, path->len, ignore_case);11771178 if (dtype == DT_UNKNOWN)1179 dtype = get_dtype(de, path->buf, path->len);11801181 /* Always exclude indexed files */1182 if (dtype != DT_DIR && has_path_in_index)1183 return path_none;11841185 /*1186 * When we are looking at a directory P in the working tree,1187 * there are three cases:1188 *1189 * (1) P exists in the index. Everything inside the directory P in1190 * the working tree needs to go when P is checked out from the1191 * index.1192 *1193 * (2) P does not exist in the index, but there is P/Q in the index.1194 * We know P will stay a directory when we check out the contents1195 * of the index, but we do not know yet if there is a directory1196 * P/Q in the working tree to be killed, so we need to recurse.1197 *1198 * (3) P does not exist in the index, and there is no P/Q in the index1199 * to require P to be a directory, either. Only in this case, we1200 * know that everything inside P will not be killed without1201 * recursing.1202 */1203 if ((dir->flags & DIR_COLLECT_KILLED_ONLY) &&1204 (dtype == DT_DIR) &&1205 !has_path_in_index &&1206 (directory_exists_in_index(path->buf, path->len) == index_nonexistent))1207 return path_none;12081209 exclude = is_excluded(dir, path->buf, &dtype);12101211 /*1212 * Excluded? If we don't explicitly want to show1213 * ignored files, ignore it1214 */1215 if (exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))1216 return path_excluded;12171218 switch (dtype) {1219 default:1220 return path_none;1221 case DT_DIR:1222 strbuf_addch(path, '/');1223 return treat_directory(dir, path->buf, path->len, exclude,1224 simplify);1225 case DT_REG:1226 case DT_LNK:1227 return exclude ? path_excluded : path_untracked;1228 }1229}12301231static enum path_treatment treat_path(struct dir_struct *dir,1232 struct dirent *de,1233 struct strbuf *path,1234 int baselen,1235 const struct path_simplify *simplify)1236{1237 int dtype;12381239 if (is_dot_or_dotdot(de->d_name) || !strcmp(de->d_name, ".git"))1240 return path_none;1241 strbuf_setlen(path, baselen);1242 strbuf_addstr(path, de->d_name);1243 if (simplify_away(path->buf, path->len, simplify))1244 return path_none;12451246 dtype = DTYPE(de);1247 return treat_one_path(dir, path, simplify, dtype, de);1248}12491250/*1251 * Read a directory tree. We currently ignore anything but1252 * directories, regular files and symlinks. That's because git1253 * doesn't handle them at all yet. Maybe that will change some1254 * day.1255 *1256 * Also, we ignore the name ".git" (even if it is not a directory).1257 * That likely will not change.1258 *1259 * Returns the most significant path_treatment value encountered in the scan.1260 */1261static enum path_treatment read_directory_recursive(struct dir_struct *dir,1262 const char *base, int baselen,1263 int check_only,1264 const struct path_simplify *simplify)1265{1266 DIR *fdir;1267 enum path_treatment state, subdir_state, dir_state = path_none;1268 struct dirent *de;1269 struct strbuf path = STRBUF_INIT;12701271 strbuf_add(&path, base, baselen);12721273 fdir = opendir(path.len ? path.buf : ".");1274 if (!fdir)1275 goto out;12761277 while ((de = readdir(fdir)) != NULL) {1278 /* check how the file or directory should be treated */1279 state = treat_path(dir, de, &path, baselen, simplify);1280 if (state > dir_state)1281 dir_state = state;12821283 /* recurse into subdir if instructed by treat_path */1284 if (state == path_recurse) {1285 subdir_state = read_directory_recursive(dir, path.buf,1286 path.len, check_only, simplify);1287 if (subdir_state > dir_state)1288 dir_state = subdir_state;1289 }12901291 if (check_only) {1292 /* abort early if maximum state has been reached */1293 if (dir_state == path_untracked)1294 break;1295 /* skip the dir_add_* part */1296 continue;1297 }12981299 /* add the path to the appropriate result list */1300 switch (state) {1301 case path_excluded:1302 if (dir->flags & DIR_SHOW_IGNORED)1303 dir_add_name(dir, path.buf, path.len);1304 else if ((dir->flags & DIR_SHOW_IGNORED_TOO) ||1305 ((dir->flags & DIR_COLLECT_IGNORED) &&1306 exclude_matches_pathspec(path.buf, path.len,1307 simplify)))1308 dir_add_ignored(dir, path.buf, path.len);1309 break;13101311 case path_untracked:1312 if (!(dir->flags & DIR_SHOW_IGNORED))1313 dir_add_name(dir, path.buf, path.len);1314 break;13151316 default:1317 break;1318 }1319 }1320 closedir(fdir);1321 out:1322 strbuf_release(&path);13231324 return dir_state;1325}13261327static int cmp_name(const void *p1, const void *p2)1328{1329 const struct dir_entry *e1 = *(const struct dir_entry **)p1;1330 const struct dir_entry *e2 = *(const struct dir_entry **)p2;13311332 return cache_name_compare(e1->name, e1->len,1333 e2->name, e2->len);1334}13351336static struct path_simplify *create_simplify(const char **pathspec)1337{1338 int nr, alloc = 0;1339 struct path_simplify *simplify = NULL;13401341 if (!pathspec)1342 return NULL;13431344 for (nr = 0 ; ; nr++) {1345 const char *match;1346 if (nr >= alloc) {1347 alloc = alloc_nr(alloc);1348 simplify = xrealloc(simplify, alloc * sizeof(*simplify));1349 }1350 match = *pathspec++;1351 if (!match)1352 break;1353 simplify[nr].path = match;1354 simplify[nr].len = simple_length(match);1355 }1356 simplify[nr].path = NULL;1357 simplify[nr].len = 0;1358 return simplify;1359}13601361static void free_simplify(struct path_simplify *simplify)1362{1363 free(simplify);1364}13651366static int treat_leading_path(struct dir_struct *dir,1367 const char *path, int len,1368 const struct path_simplify *simplify)1369{1370 struct strbuf sb = STRBUF_INIT;1371 int baselen, rc = 0;1372 const char *cp;1373 int old_flags = dir->flags;13741375 while (len && path[len - 1] == '/')1376 len--;1377 if (!len)1378 return 1;1379 baselen = 0;1380 dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;1381 while (1) {1382 cp = path + baselen + !!baselen;1383 cp = memchr(cp, '/', path + len - cp);1384 if (!cp)1385 baselen = len;1386 else1387 baselen = cp - path;1388 strbuf_setlen(&sb, 0);1389 strbuf_add(&sb, path, baselen);1390 if (!is_directory(sb.buf))1391 break;1392 if (simplify_away(sb.buf, sb.len, simplify))1393 break;1394 if (treat_one_path(dir, &sb, simplify,1395 DT_DIR, NULL) == path_none)1396 break; /* do not recurse into it */1397 if (len <= baselen) {1398 rc = 1;1399 break; /* finished checking */1400 }1401 }1402 strbuf_release(&sb);1403 dir->flags = old_flags;1404 return rc;1405}14061407int read_directory(struct dir_struct *dir, const char *path, int len, const char **pathspec)1408{1409 struct path_simplify *simplify;14101411 if (has_symlink_leading_path(path, len))1412 return dir->nr;14131414 simplify = create_simplify(pathspec);1415 if (!len || treat_leading_path(dir, path, len, simplify))1416 read_directory_recursive(dir, path, len, 0, simplify);1417 free_simplify(simplify);1418 qsort(dir->entries, dir->nr, sizeof(struct dir_entry *), cmp_name);1419 qsort(dir->ignored, dir->ignored_nr, sizeof(struct dir_entry *), cmp_name);1420 return dir->nr;1421}14221423int file_exists(const char *f)1424{1425 struct stat sb;1426 return lstat(f, &sb) == 0;1427}14281429/*1430 * Given two normalized paths (a trailing slash is ok), if subdir is1431 * outside dir, return -1. Otherwise return the offset in subdir that1432 * can be used as relative path to dir.1433 */1434int dir_inside_of(const char *subdir, const char *dir)1435{1436 int offset = 0;14371438 assert(dir && subdir && *dir && *subdir);14391440 while (*dir && *subdir && *dir == *subdir) {1441 dir++;1442 subdir++;1443 offset++;1444 }14451446 /* hel[p]/me vs hel[l]/yeah */1447 if (*dir && *subdir)1448 return -1;14491450 if (!*subdir)1451 return !*dir ? offset : -1; /* same dir */14521453 /* foo/[b]ar vs foo/[] */1454 if (is_dir_sep(dir[-1]))1455 return is_dir_sep(subdir[-1]) ? offset : -1;14561457 /* foo[/]bar vs foo[] */1458 return is_dir_sep(*subdir) ? offset + 1 : -1;1459}14601461int is_inside_dir(const char *dir)1462{1463 char cwd[PATH_MAX];1464 if (!dir)1465 return 0;1466 if (!getcwd(cwd, sizeof(cwd)))1467 die_errno("can't find the current directory");1468 return dir_inside_of(cwd, dir) >= 0;1469}14701471int is_empty_dir(const char *path)1472{1473 DIR *dir = opendir(path);1474 struct dirent *e;1475 int ret = 1;14761477 if (!dir)1478 return 0;14791480 while ((e = readdir(dir)) != NULL)1481 if (!is_dot_or_dotdot(e->d_name)) {1482 ret = 0;1483 break;1484 }14851486 closedir(dir);1487 return ret;1488}14891490static int remove_dir_recurse(struct strbuf *path, int flag, int *kept_up)1491{1492 DIR *dir;1493 struct dirent *e;1494 int ret = 0, original_len = path->len, len, kept_down = 0;1495 int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);1496 int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);1497 unsigned char submodule_head[20];14981499 if ((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&1500 !resolve_gitlink_ref(path->buf, "HEAD", submodule_head)) {1501 /* Do not descend and nuke a nested git work tree. */1502 if (kept_up)1503 *kept_up = 1;1504 return 0;1505 }15061507 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;1508 dir = opendir(path->buf);1509 if (!dir) {1510 /* an empty dir could be removed even if it is unreadble */1511 if (!keep_toplevel)1512 return rmdir(path->buf);1513 else1514 return -1;1515 }1516 if (path->buf[original_len - 1] != '/')1517 strbuf_addch(path, '/');15181519 len = path->len;1520 while ((e = readdir(dir)) != NULL) {1521 struct stat st;1522 if (is_dot_or_dotdot(e->d_name))1523 continue;15241525 strbuf_setlen(path, len);1526 strbuf_addstr(path, e->d_name);1527 if (lstat(path->buf, &st))1528 ; /* fall thru */1529 else if (S_ISDIR(st.st_mode)) {1530 if (!remove_dir_recurse(path, flag, &kept_down))1531 continue; /* happy */1532 } else if (!only_empty && !unlink(path->buf))1533 continue; /* happy, too */15341535 /* path too long, stat fails, or non-directory still exists */1536 ret = -1;1537 break;1538 }1539 closedir(dir);15401541 strbuf_setlen(path, original_len);1542 if (!ret && !keep_toplevel && !kept_down)1543 ret = rmdir(path->buf);1544 else if (kept_up)1545 /*1546 * report the uplevel that it is not an error that we1547 * did not rmdir() our directory.1548 */1549 *kept_up = !ret;1550 return ret;1551}15521553int remove_dir_recursively(struct strbuf *path, int flag)1554{1555 return remove_dir_recurse(path, flag, NULL);1556}15571558void setup_standard_excludes(struct dir_struct *dir)1559{1560 const char *path;1561 char *xdg_path;15621563 dir->exclude_per_dir = ".gitignore";1564 path = git_path("info/exclude");1565 if (!excludes_file) {1566 home_config_paths(NULL, &xdg_path, "ignore");1567 excludes_file = xdg_path;1568 }1569 if (!access_or_warn(path, R_OK))1570 add_excludes_from_file(dir, path);1571 if (excludes_file && !access_or_warn(excludes_file, R_OK))1572 add_excludes_from_file(dir, excludes_file);1573}15741575int remove_path(const char *name)1576{1577 char *slash;15781579 if (unlink(name) && errno != ENOENT && errno != ENOTDIR)1580 return -1;15811582 slash = strrchr(name, '/');1583 if (slash) {1584 char *dirs = xstrdup(name);1585 slash = dirs + (slash - name);1586 do {1587 *slash = '\0';1588 } while (rmdir(dirs) == 0 && (slash = strrchr(dirs, '/')));1589 free(dirs);1590 }1591 return 0;1592}15931594static int pathspec_item_cmp(const void *a_, const void *b_)1595{1596 struct pathspec_item *a, *b;15971598 a = (struct pathspec_item *)a_;1599 b = (struct pathspec_item *)b_;1600 return strcmp(a->match, b->match);1601}16021603int init_pathspec(struct pathspec *pathspec, const char **paths)1604{1605 const char **p = paths;1606 int i;16071608 memset(pathspec, 0, sizeof(*pathspec));1609 if (!p)1610 return 0;1611 while (*p)1612 p++;1613 pathspec->raw = paths;1614 pathspec->nr = p - paths;1615 if (!pathspec->nr)1616 return 0;16171618 pathspec->items = xmalloc(sizeof(struct pathspec_item)*pathspec->nr);1619 for (i = 0; i < pathspec->nr; i++) {1620 struct pathspec_item *item = pathspec->items+i;1621 const char *path = paths[i];16221623 item->match = path;1624 item->len = strlen(path);1625 item->flags = 0;1626 if (limit_pathspec_to_literal()) {1627 item->nowildcard_len = item->len;1628 } else {1629 item->nowildcard_len = simple_length(path);1630 if (item->nowildcard_len < item->len) {1631 pathspec->has_wildcard = 1;1632 if (path[item->nowildcard_len] == '*' &&1633 no_wildcard(path + item->nowildcard_len + 1))1634 item->flags |= PATHSPEC_ONESTAR;1635 }1636 }1637 }16381639 qsort(pathspec->items, pathspec->nr,1640 sizeof(struct pathspec_item), pathspec_item_cmp);16411642 return 0;1643}16441645void free_pathspec(struct pathspec *pathspec)1646{1647 free(pathspec->items);1648 pathspec->items = NULL;1649}16501651int limit_pathspec_to_literal(void)1652{1653 static int flag = -1;1654 if (flag < 0)1655 flag = git_env_bool(GIT_LITERAL_PATHSPECS_ENVIRONMENT, 0);1656 return flag;1657}16581659/*1660 * Frees memory within dir which was allocated for exclude lists and1661 * the exclude_stack. Does not free dir itself.1662 */1663void clear_directory(struct dir_struct *dir)1664{1665 int i, j;1666 struct exclude_list_group *group;1667 struct exclude_list *el;1668 struct exclude_stack *stk;16691670 for (i = EXC_CMDL; i <= EXC_FILE; i++) {1671 group = &dir->exclude_list_group[i];1672 for (j = 0; j < group->nr; j++) {1673 el = &group->el[j];1674 if (i == EXC_DIRS)1675 free((char *)el->src);1676 clear_exclude_list(el);1677 }1678 free(group->el);1679 }16801681 stk = dir->exclude_stack;1682 while (stk) {1683 struct exclude_stack *prev = stk->prev;1684 free(stk);1685 stk = prev;1686 }1687}