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#include "pathspec.h" 15 16struct path_simplify { 17 int len; 18 const char *path; 19}; 20 21/* 22 * Tells read_directory_recursive how a file or directory should be treated. 23 * Values are ordered by significance, e.g. if a directory contains both 24 * excluded and untracked files, it is listed as untracked because 25 * path_untracked > path_excluded. 26 */ 27enum path_treatment { 28 path_none = 0, 29 path_recurse, 30 path_excluded, 31 path_untracked 32}; 33 34static enum path_treatment read_directory_recursive(struct dir_struct *dir, 35 const char *path, int len, 36 int check_only, const struct path_simplify *simplify); 37static int get_dtype(struct dirent *de, const char *path, int len); 38 39/* helper string functions with support for the ignore_case flag */ 40int strcmp_icase(const char *a, const char *b) 41{ 42 return ignore_case ? strcasecmp(a, b) : strcmp(a, b); 43} 44 45int strncmp_icase(const char *a, const char *b, size_t count) 46{ 47 return ignore_case ? strncasecmp(a, b, count) : strncmp(a, b, count); 48} 49 50int fnmatch_icase(const char *pattern, const char *string, int flags) 51{ 52 return fnmatch(pattern, string, flags | (ignore_case ? FNM_CASEFOLD : 0)); 53} 54 55inline int git_fnmatch(const struct pathspec_item *item, 56 const char *pattern, const char *string, 57 int prefix) 58{ 59 if (prefix > 0) { 60 if (ps_strncmp(item, pattern, string, prefix)) 61 return FNM_NOMATCH; 62 pattern += prefix; 63 string += prefix; 64 } 65 if (item->flags & PATHSPEC_ONESTAR) { 66 int pattern_len = strlen(++pattern); 67 int string_len = strlen(string); 68 return string_len < pattern_len || 69 ps_strcmp(item, pattern, 70 string + string_len - pattern_len); 71 } 72 if (item->magic & PATHSPEC_GLOB) 73 return wildmatch(pattern, string, 74 WM_PATHNAME | 75 (item->magic & PATHSPEC_ICASE ? WM_CASEFOLD : 0), 76 NULL); 77 else 78 /* wildmatch has not learned no FNM_PATHNAME mode yet */ 79 return fnmatch(pattern, string, 80 item->magic & PATHSPEC_ICASE ? FNM_CASEFOLD : 0); 81} 82 83static int fnmatch_icase_mem(const char *pattern, int patternlen, 84 const char *string, int stringlen, 85 int flags) 86{ 87 int match_status; 88 struct strbuf pat_buf = STRBUF_INIT; 89 struct strbuf str_buf = STRBUF_INIT; 90 const char *use_pat = pattern; 91 const char *use_str = string; 92 93 if (pattern[patternlen]) { 94 strbuf_add(&pat_buf, pattern, patternlen); 95 use_pat = pat_buf.buf; 96 } 97 if (string[stringlen]) { 98 strbuf_add(&str_buf, string, stringlen); 99 use_str = str_buf.buf; 100 } 101 102 if (ignore_case) 103 flags |= WM_CASEFOLD; 104 match_status = wildmatch(use_pat, use_str, flags, NULL); 105 106 strbuf_release(&pat_buf); 107 strbuf_release(&str_buf); 108 109 return match_status; 110} 111 112static size_t common_prefix_len(const struct pathspec *pathspec) 113{ 114 int n; 115 size_t max = 0; 116 117 /* 118 * ":(icase)path" is treated as a pathspec full of 119 * wildcard. In other words, only prefix is considered common 120 * prefix. If the pathspec is abc/foo abc/bar, running in 121 * subdir xyz, the common prefix is still xyz, not xuz/abc as 122 * in non-:(icase). 123 */ 124 GUARD_PATHSPEC(pathspec, 125 PATHSPEC_FROMTOP | 126 PATHSPEC_MAXDEPTH | 127 PATHSPEC_LITERAL | 128 PATHSPEC_GLOB | 129 PATHSPEC_ICASE); 130 131 for (n = 0; n < pathspec->nr; n++) { 132 size_t i = 0, len = 0, item_len; 133 if (pathspec->items[n].magic & PATHSPEC_ICASE) 134 item_len = pathspec->items[n].prefix; 135 else 136 item_len = pathspec->items[n].nowildcard_len; 137 while (i < item_len && (n == 0 || i < max)) { 138 char c = pathspec->items[n].match[i]; 139 if (c != pathspec->items[0].match[i]) 140 break; 141 if (c == '/') 142 len = i + 1; 143 i++; 144 } 145 if (n == 0 || len < max) { 146 max = len; 147 if (!max) 148 break; 149 } 150 } 151 return max; 152} 153 154/* 155 * Returns a copy of the longest leading path common among all 156 * pathspecs. 157 */ 158char *common_prefix(const struct pathspec *pathspec) 159{ 160 unsigned long len = common_prefix_len(pathspec); 161 162 return len ? xmemdupz(pathspec->items[0].match, len) : NULL; 163} 164 165int fill_directory(struct dir_struct *dir, const struct pathspec *pathspec) 166{ 167 size_t len; 168 169 /* 170 * Calculate common prefix for the pathspec, and 171 * use that to optimize the directory walk 172 */ 173 len = common_prefix_len(pathspec); 174 175 /* Read the directory and prune it */ 176 read_directory(dir, pathspec->nr ? pathspec->_raw[0] : "", len, pathspec); 177 return len; 178} 179 180int within_depth(const char *name, int namelen, 181 int depth, int max_depth) 182{ 183 const char *cp = name, *cpe = name + namelen; 184 185 while (cp < cpe) { 186 if (*cp++ != '/') 187 continue; 188 depth++; 189 if (depth > max_depth) 190 return 0; 191 } 192 return 1; 193} 194 195/* 196 * Does 'match' match the given name? 197 * A match is found if 198 * 199 * (1) the 'match' string is leading directory of 'name', or 200 * (2) the 'match' string is a wildcard and matches 'name', or 201 * (3) the 'match' string is exactly the same as 'name'. 202 * 203 * and the return value tells which case it was. 204 * 205 * It returns 0 when there is no match. 206 */ 207static int match_pathspec_item(const struct pathspec_item *item, int prefix, 208 const char *name, int namelen) 209{ 210 /* name/namelen has prefix cut off by caller */ 211 const char *match = item->match + prefix; 212 int matchlen = item->len - prefix; 213 214 /* 215 * The normal call pattern is: 216 * 1. prefix = common_prefix_len(ps); 217 * 2. prune something, or fill_directory 218 * 3. match_pathspec_depth() 219 * 220 * 'prefix' at #1 may be shorter than the command's prefix and 221 * it's ok for #2 to match extra files. Those extras will be 222 * trimmed at #3. 223 * 224 * Suppose the pathspec is 'foo' and '../bar' running from 225 * subdir 'xyz'. The common prefix at #1 will be empty, thanks 226 * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The 227 * user does not want XYZ/foo, only the "foo" part should be 228 * case-insensitive. We need to filter out XYZ/foo here. In 229 * other words, we do not trust the caller on comparing the 230 * prefix part when :(icase) is involved. We do exact 231 * comparison ourselves. 232 * 233 * Normally the caller (common_prefix_len() in fact) does 234 * _exact_ matching on name[-prefix+1..-1] and we do not need 235 * to check that part. Be defensive and check it anyway, in 236 * case common_prefix_len is changed, or a new caller is 237 * introduced that does not use common_prefix_len. 238 * 239 * If the penalty turns out too high when prefix is really 240 * long, maybe change it to 241 * strncmp(match, name, item->prefix - prefix) 242 */ 243 if (item->prefix && (item->magic & PATHSPEC_ICASE) && 244 strncmp(item->match, name - prefix, item->prefix)) 245 return 0; 246 247 /* If the match was just the prefix, we matched */ 248 if (!*match) 249 return MATCHED_RECURSIVELY; 250 251 if (matchlen <= namelen && !ps_strncmp(item, match, name, matchlen)) { 252 if (matchlen == namelen) 253 return MATCHED_EXACTLY; 254 255 if (match[matchlen-1] == '/' || name[matchlen] == '/') 256 return MATCHED_RECURSIVELY; 257 } 258 259 if (item->nowildcard_len < item->len && 260 !git_fnmatch(item, match, name, 261 item->nowildcard_len - prefix)) 262 return MATCHED_FNMATCH; 263 264 return 0; 265} 266 267/* 268 * Given a name and a list of pathspecs, returns the nature of the 269 * closest (i.e. most specific) match of the name to any of the 270 * pathspecs. 271 * 272 * The caller typically calls this multiple times with the same 273 * pathspec and seen[] array but with different name/namelen 274 * (e.g. entries from the index) and is interested in seeing if and 275 * how each pathspec matches all the names it calls this function 276 * with. A mark is left in the seen[] array for each pathspec element 277 * indicating the closest type of match that element achieved, so if 278 * seen[n] remains zero after multiple invocations, that means the nth 279 * pathspec did not match any names, which could indicate that the 280 * user mistyped the nth pathspec. 281 */ 282int match_pathspec_depth(const struct pathspec *ps, 283 const char *name, int namelen, 284 int prefix, char *seen) 285{ 286 int i, retval = 0; 287 288 GUARD_PATHSPEC(ps, 289 PATHSPEC_FROMTOP | 290 PATHSPEC_MAXDEPTH | 291 PATHSPEC_LITERAL | 292 PATHSPEC_GLOB | 293 PATHSPEC_ICASE); 294 295 if (!ps->nr) { 296 if (!ps->recursive || 297 !(ps->magic & PATHSPEC_MAXDEPTH) || 298 ps->max_depth == -1) 299 return MATCHED_RECURSIVELY; 300 301 if (within_depth(name, namelen, 0, ps->max_depth)) 302 return MATCHED_EXACTLY; 303 else 304 return 0; 305 } 306 307 name += prefix; 308 namelen -= prefix; 309 310 for (i = ps->nr - 1; i >= 0; i--) { 311 int how; 312 if (seen && seen[i] == MATCHED_EXACTLY) 313 continue; 314 how = match_pathspec_item(ps->items+i, prefix, name, namelen); 315 if (ps->recursive && 316 (ps->magic & PATHSPEC_MAXDEPTH) && 317 ps->max_depth != -1 && 318 how && how != MATCHED_FNMATCH) { 319 int len = ps->items[i].len; 320 if (name[len] == '/') 321 len++; 322 if (within_depth(name+len, namelen-len, 0, ps->max_depth)) 323 how = MATCHED_EXACTLY; 324 else 325 how = 0; 326 } 327 if (how) { 328 if (retval < how) 329 retval = how; 330 if (seen && seen[i] < how) 331 seen[i] = how; 332 } 333 } 334 return retval; 335} 336 337/* 338 * Return the length of the "simple" part of a path match limiter. 339 */ 340int simple_length(const char *match) 341{ 342 int len = -1; 343 344 for (;;) { 345 unsigned char c = *match++; 346 len++; 347 if (c == '\0' || is_glob_special(c)) 348 return len; 349 } 350} 351 352int no_wildcard(const char *string) 353{ 354 return string[simple_length(string)] == '\0'; 355} 356 357void parse_exclude_pattern(const char **pattern, 358 int *patternlen, 359 int *flags, 360 int *nowildcardlen) 361{ 362 const char *p = *pattern; 363 size_t i, len; 364 365 *flags = 0; 366 if (*p == '!') { 367 *flags |= EXC_FLAG_NEGATIVE; 368 p++; 369 } 370 len = strlen(p); 371 if (len && p[len - 1] == '/') { 372 len--; 373 *flags |= EXC_FLAG_MUSTBEDIR; 374 } 375 for (i = 0; i < len; i++) { 376 if (p[i] == '/') 377 break; 378 } 379 if (i == len) 380 *flags |= EXC_FLAG_NODIR; 381 *nowildcardlen = simple_length(p); 382 /* 383 * we should have excluded the trailing slash from 'p' too, 384 * but that's one more allocation. Instead just make sure 385 * nowildcardlen does not exceed real patternlen 386 */ 387 if (*nowildcardlen > len) 388 *nowildcardlen = len; 389 if (*p == '*' && no_wildcard(p + 1)) 390 *flags |= EXC_FLAG_ENDSWITH; 391 *pattern = p; 392 *patternlen = len; 393} 394 395void add_exclude(const char *string, const char *base, 396 int baselen, struct exclude_list *el, int srcpos) 397{ 398 struct exclude *x; 399 int patternlen; 400 int flags; 401 int nowildcardlen; 402 403 parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen); 404 if (flags & EXC_FLAG_MUSTBEDIR) { 405 char *s; 406 x = xmalloc(sizeof(*x) + patternlen + 1); 407 s = (char *)(x+1); 408 memcpy(s, string, patternlen); 409 s[patternlen] = '\0'; 410 x->pattern = s; 411 } else { 412 x = xmalloc(sizeof(*x)); 413 x->pattern = string; 414 } 415 x->patternlen = patternlen; 416 x->nowildcardlen = nowildcardlen; 417 x->base = base; 418 x->baselen = baselen; 419 x->flags = flags; 420 x->srcpos = srcpos; 421 ALLOC_GROW(el->excludes, el->nr + 1, el->alloc); 422 el->excludes[el->nr++] = x; 423 x->el = el; 424} 425 426static void *read_skip_worktree_file_from_index(const char *path, size_t *size) 427{ 428 int pos, len; 429 unsigned long sz; 430 enum object_type type; 431 void *data; 432 433 len = strlen(path); 434 pos = cache_name_pos(path, len); 435 if (pos < 0) 436 return NULL; 437 if (!ce_skip_worktree(active_cache[pos])) 438 return NULL; 439 data = read_sha1_file(active_cache[pos]->sha1, &type, &sz); 440 if (!data || type != OBJ_BLOB) { 441 free(data); 442 return NULL; 443 } 444 *size = xsize_t(sz); 445 return data; 446} 447 448/* 449 * Frees memory within el which was allocated for exclude patterns and 450 * the file buffer. Does not free el itself. 451 */ 452void clear_exclude_list(struct exclude_list *el) 453{ 454 int i; 455 456 for (i = 0; i < el->nr; i++) 457 free(el->excludes[i]); 458 free(el->excludes); 459 free(el->filebuf); 460 461 el->nr = 0; 462 el->excludes = NULL; 463 el->filebuf = NULL; 464} 465 466static void check_trailing_spaces(const char *fname, char *buf) 467{ 468 int i, last_space = -1, len = strlen(buf); 469 for (i = 0; i < len; i++) 470 if (buf[i] == '\\') 471 i++; 472 else if (buf[i] == ' ') 473 last_space = i; 474 else 475 last_space = -1; 476 477 if (last_space == len - 1) 478 warning(_("%s: trailing spaces in '%s'. Please quote or remove them."), 479 fname, buf); 480} 481 482int add_excludes_from_file_to_list(const char *fname, 483 const char *base, 484 int baselen, 485 struct exclude_list *el, 486 int check_index) 487{ 488 struct stat st; 489 int fd, i, lineno = 1; 490 size_t size = 0; 491 char *buf, *entry; 492 493 fd = open(fname, O_RDONLY); 494 if (fd < 0 || fstat(fd, &st) < 0) { 495 if (errno != ENOENT) 496 warn_on_inaccessible(fname); 497 if (0 <= fd) 498 close(fd); 499 if (!check_index || 500 (buf = read_skip_worktree_file_from_index(fname, &size)) == NULL) 501 return -1; 502 if (size == 0) { 503 free(buf); 504 return 0; 505 } 506 if (buf[size-1] != '\n') { 507 buf = xrealloc(buf, size+1); 508 buf[size++] = '\n'; 509 } 510 } 511 else { 512 size = xsize_t(st.st_size); 513 if (size == 0) { 514 close(fd); 515 return 0; 516 } 517 buf = xmalloc(size+1); 518 if (read_in_full(fd, buf, size) != size) { 519 free(buf); 520 close(fd); 521 return -1; 522 } 523 buf[size++] = '\n'; 524 close(fd); 525 } 526 527 el->filebuf = buf; 528 entry = buf; 529 for (i = 0; i < size; i++) { 530 if (buf[i] == '\n') { 531 if (entry != buf + i && entry[0] != '#') { 532 buf[i - (i && buf[i-1] == '\r')] = 0; 533 check_trailing_spaces(fname, entry); 534 add_exclude(entry, base, baselen, el, lineno); 535 } 536 lineno++; 537 entry = buf + i + 1; 538 } 539 } 540 return 0; 541} 542 543struct exclude_list *add_exclude_list(struct dir_struct *dir, 544 int group_type, const char *src) 545{ 546 struct exclude_list *el; 547 struct exclude_list_group *group; 548 549 group = &dir->exclude_list_group[group_type]; 550 ALLOC_GROW(group->el, group->nr + 1, group->alloc); 551 el = &group->el[group->nr++]; 552 memset(el, 0, sizeof(*el)); 553 el->src = src; 554 return el; 555} 556 557/* 558 * Used to set up core.excludesfile and .git/info/exclude lists. 559 */ 560void add_excludes_from_file(struct dir_struct *dir, const char *fname) 561{ 562 struct exclude_list *el; 563 el = add_exclude_list(dir, EXC_FILE, fname); 564 if (add_excludes_from_file_to_list(fname, "", 0, el, 0) < 0) 565 die("cannot use %s as an exclude file", fname); 566} 567 568int match_basename(const char *basename, int basenamelen, 569 const char *pattern, int prefix, int patternlen, 570 int flags) 571{ 572 if (prefix == patternlen) { 573 if (patternlen == basenamelen && 574 !strncmp_icase(pattern, basename, basenamelen)) 575 return 1; 576 } else if (flags & EXC_FLAG_ENDSWITH) { 577 /* "*literal" matching against "fooliteral" */ 578 if (patternlen - 1 <= basenamelen && 579 !strncmp_icase(pattern + 1, 580 basename + basenamelen - (patternlen - 1), 581 patternlen - 1)) 582 return 1; 583 } else { 584 if (fnmatch_icase_mem(pattern, patternlen, 585 basename, basenamelen, 586 0) == 0) 587 return 1; 588 } 589 return 0; 590} 591 592int match_pathname(const char *pathname, int pathlen, 593 const char *base, int baselen, 594 const char *pattern, int prefix, int patternlen, 595 int flags) 596{ 597 const char *name; 598 int namelen; 599 600 /* 601 * match with FNM_PATHNAME; the pattern has base implicitly 602 * in front of it. 603 */ 604 if (*pattern == '/') { 605 pattern++; 606 patternlen--; 607 prefix--; 608 } 609 610 /* 611 * baselen does not count the trailing slash. base[] may or 612 * may not end with a trailing slash though. 613 */ 614 if (pathlen < baselen + 1 || 615 (baselen && pathname[baselen] != '/') || 616 strncmp_icase(pathname, base, baselen)) 617 return 0; 618 619 namelen = baselen ? pathlen - baselen - 1 : pathlen; 620 name = pathname + pathlen - namelen; 621 622 if (prefix) { 623 /* 624 * if the non-wildcard part is longer than the 625 * remaining pathname, surely it cannot match. 626 */ 627 if (prefix > namelen) 628 return 0; 629 630 if (strncmp_icase(pattern, name, prefix)) 631 return 0; 632 pattern += prefix; 633 patternlen -= prefix; 634 name += prefix; 635 namelen -= prefix; 636 637 /* 638 * If the whole pattern did not have a wildcard, 639 * then our prefix match is all we need; we 640 * do not need to call fnmatch at all. 641 */ 642 if (!patternlen && !namelen) 643 return 1; 644 } 645 646 return fnmatch_icase_mem(pattern, patternlen, 647 name, namelen, 648 WM_PATHNAME) == 0; 649} 650 651/* 652 * Scan the given exclude list in reverse to see whether pathname 653 * should be ignored. The first match (i.e. the last on the list), if 654 * any, determines the fate. Returns the exclude_list element which 655 * matched, or NULL for undecided. 656 */ 657static struct exclude *last_exclude_matching_from_list(const char *pathname, 658 int pathlen, 659 const char *basename, 660 int *dtype, 661 struct exclude_list *el) 662{ 663 int i; 664 665 if (!el->nr) 666 return NULL; /* undefined */ 667 668 for (i = el->nr - 1; 0 <= i; i--) { 669 struct exclude *x = el->excludes[i]; 670 const char *exclude = x->pattern; 671 int prefix = x->nowildcardlen; 672 673 if (x->flags & EXC_FLAG_MUSTBEDIR) { 674 if (*dtype == DT_UNKNOWN) 675 *dtype = get_dtype(NULL, pathname, pathlen); 676 if (*dtype != DT_DIR) 677 continue; 678 } 679 680 if (x->flags & EXC_FLAG_NODIR) { 681 if (match_basename(basename, 682 pathlen - (basename - pathname), 683 exclude, prefix, x->patternlen, 684 x->flags)) 685 return x; 686 continue; 687 } 688 689 assert(x->baselen == 0 || x->base[x->baselen - 1] == '/'); 690 if (match_pathname(pathname, pathlen, 691 x->base, x->baselen ? x->baselen - 1 : 0, 692 exclude, prefix, x->patternlen, x->flags)) 693 return x; 694 } 695 return NULL; /* undecided */ 696} 697 698/* 699 * Scan the list and let the last match determine the fate. 700 * Return 1 for exclude, 0 for include and -1 for undecided. 701 */ 702int is_excluded_from_list(const char *pathname, 703 int pathlen, const char *basename, int *dtype, 704 struct exclude_list *el) 705{ 706 struct exclude *exclude; 707 exclude = last_exclude_matching_from_list(pathname, pathlen, basename, dtype, el); 708 if (exclude) 709 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1; 710 return -1; /* undecided */ 711} 712 713static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir, 714 const char *pathname, int pathlen, const char *basename, 715 int *dtype_p) 716{ 717 int i, j; 718 struct exclude_list_group *group; 719 struct exclude *exclude; 720 for (i = EXC_CMDL; i <= EXC_FILE; i++) { 721 group = &dir->exclude_list_group[i]; 722 for (j = group->nr - 1; j >= 0; j--) { 723 exclude = last_exclude_matching_from_list( 724 pathname, pathlen, basename, dtype_p, 725 &group->el[j]); 726 if (exclude) 727 return exclude; 728 } 729 } 730 return NULL; 731} 732 733/* 734 * Loads the per-directory exclude list for the substring of base 735 * which has a char length of baselen. 736 */ 737static void prep_exclude(struct dir_struct *dir, const char *base, int baselen) 738{ 739 struct exclude_list_group *group; 740 struct exclude_list *el; 741 struct exclude_stack *stk = NULL; 742 int current; 743 744 group = &dir->exclude_list_group[EXC_DIRS]; 745 746 /* Pop the exclude lists from the EXCL_DIRS exclude_list_group 747 * which originate from directories not in the prefix of the 748 * path being checked. */ 749 while ((stk = dir->exclude_stack) != NULL) { 750 if (stk->baselen <= baselen && 751 !strncmp(dir->basebuf, base, stk->baselen)) 752 break; 753 el = &group->el[dir->exclude_stack->exclude_ix]; 754 dir->exclude_stack = stk->prev; 755 dir->exclude = NULL; 756 free((char *)el->src); /* see strdup() below */ 757 clear_exclude_list(el); 758 free(stk); 759 group->nr--; 760 } 761 762 /* Skip traversing into sub directories if the parent is excluded */ 763 if (dir->exclude) 764 return; 765 766 /* Read from the parent directories and push them down. */ 767 current = stk ? stk->baselen : -1; 768 while (current < baselen) { 769 struct exclude_stack *stk = xcalloc(1, sizeof(*stk)); 770 const char *cp; 771 772 if (current < 0) { 773 cp = base; 774 current = 0; 775 } 776 else { 777 cp = strchr(base + current + 1, '/'); 778 if (!cp) 779 die("oops in prep_exclude"); 780 cp++; 781 } 782 stk->prev = dir->exclude_stack; 783 stk->baselen = cp - base; 784 stk->exclude_ix = group->nr; 785 el = add_exclude_list(dir, EXC_DIRS, NULL); 786 memcpy(dir->basebuf + current, base + current, 787 stk->baselen - current); 788 789 /* Abort if the directory is excluded */ 790 if (stk->baselen) { 791 int dt = DT_DIR; 792 dir->basebuf[stk->baselen - 1] = 0; 793 dir->exclude = last_exclude_matching_from_lists(dir, 794 dir->basebuf, stk->baselen - 1, 795 dir->basebuf + current, &dt); 796 dir->basebuf[stk->baselen - 1] = '/'; 797 if (dir->exclude && 798 dir->exclude->flags & EXC_FLAG_NEGATIVE) 799 dir->exclude = NULL; 800 if (dir->exclude) { 801 dir->basebuf[stk->baselen] = 0; 802 dir->exclude_stack = stk; 803 return; 804 } 805 } 806 807 /* Try to read per-directory file unless path is too long */ 808 if (dir->exclude_per_dir && 809 stk->baselen + strlen(dir->exclude_per_dir) < PATH_MAX) { 810 strcpy(dir->basebuf + stk->baselen, 811 dir->exclude_per_dir); 812 /* 813 * dir->basebuf gets reused by the traversal, but we 814 * need fname to remain unchanged to ensure the src 815 * member of each struct exclude correctly 816 * back-references its source file. Other invocations 817 * of add_exclude_list provide stable strings, so we 818 * strdup() and free() here in the caller. 819 */ 820 el->src = strdup(dir->basebuf); 821 add_excludes_from_file_to_list(dir->basebuf, 822 dir->basebuf, stk->baselen, el, 1); 823 } 824 dir->exclude_stack = stk; 825 current = stk->baselen; 826 } 827 dir->basebuf[baselen] = '\0'; 828} 829 830/* 831 * Loads the exclude lists for the directory containing pathname, then 832 * scans all exclude lists to determine whether pathname is excluded. 833 * Returns the exclude_list element which matched, or NULL for 834 * undecided. 835 */ 836struct exclude *last_exclude_matching(struct dir_struct *dir, 837 const char *pathname, 838 int *dtype_p) 839{ 840 int pathlen = strlen(pathname); 841 const char *basename = strrchr(pathname, '/'); 842 basename = (basename) ? basename+1 : pathname; 843 844 prep_exclude(dir, pathname, basename-pathname); 845 846 if (dir->exclude) 847 return dir->exclude; 848 849 return last_exclude_matching_from_lists(dir, pathname, pathlen, 850 basename, dtype_p); 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 1 if true, otherwise 0. 857 */ 858int is_excluded(struct dir_struct *dir, const char *pathname, int *dtype_p) 859{ 860 struct exclude *exclude = 861 last_exclude_matching(dir, pathname, dtype_p); 862 if (exclude) 863 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1; 864 return 0; 865} 866 867static struct dir_entry *dir_entry_new(const char *pathname, int len) 868{ 869 struct dir_entry *ent; 870 871 ent = xmalloc(sizeof(*ent) + len + 1); 872 ent->len = len; 873 memcpy(ent->name, pathname, len); 874 ent->name[len] = 0; 875 return ent; 876} 877 878static struct dir_entry *dir_add_name(struct dir_struct *dir, const char *pathname, int len) 879{ 880 if (cache_file_exists(pathname, len, ignore_case)) 881 return NULL; 882 883 ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc); 884 return dir->entries[dir->nr++] = dir_entry_new(pathname, len); 885} 886 887struct dir_entry *dir_add_ignored(struct dir_struct *dir, const char *pathname, int len) 888{ 889 if (!cache_name_is_other(pathname, len)) 890 return NULL; 891 892 ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc); 893 return dir->ignored[dir->ignored_nr++] = dir_entry_new(pathname, len); 894} 895 896enum exist_status { 897 index_nonexistent = 0, 898 index_directory, 899 index_gitdir 900}; 901 902/* 903 * Do not use the alphabetically sorted index to look up 904 * the directory name; instead, use the case insensitive 905 * directory hash. 906 */ 907static enum exist_status directory_exists_in_index_icase(const char *dirname, int len) 908{ 909 const struct cache_entry *ce = cache_dir_exists(dirname, len); 910 unsigned char endchar; 911 912 if (!ce) 913 return index_nonexistent; 914 endchar = ce->name[len]; 915 916 /* 917 * The cache_entry structure returned will contain this dirname 918 * and possibly additional path components. 919 */ 920 if (endchar == '/') 921 return index_directory; 922 923 /* 924 * If there are no additional path components, then this cache_entry 925 * represents a submodule. Submodules, despite being directories, 926 * are stored in the cache without a closing slash. 927 */ 928 if (!endchar && S_ISGITLINK(ce->ce_mode)) 929 return index_gitdir; 930 931 /* This should never be hit, but it exists just in case. */ 932 return index_nonexistent; 933} 934 935/* 936 * The index sorts alphabetically by entry name, which 937 * means that a gitlink sorts as '\0' at the end, while 938 * a directory (which is defined not as an entry, but as 939 * the files it contains) will sort with the '/' at the 940 * end. 941 */ 942static enum exist_status directory_exists_in_index(const char *dirname, int len) 943{ 944 int pos; 945 946 if (ignore_case) 947 return directory_exists_in_index_icase(dirname, len); 948 949 pos = cache_name_pos(dirname, len); 950 if (pos < 0) 951 pos = -pos-1; 952 while (pos < active_nr) { 953 const struct cache_entry *ce = active_cache[pos++]; 954 unsigned char endchar; 955 956 if (strncmp(ce->name, dirname, len)) 957 break; 958 endchar = ce->name[len]; 959 if (endchar > '/') 960 break; 961 if (endchar == '/') 962 return index_directory; 963 if (!endchar && S_ISGITLINK(ce->ce_mode)) 964 return index_gitdir; 965 } 966 return index_nonexistent; 967} 968 969/* 970 * When we find a directory when traversing the filesystem, we 971 * have three distinct cases: 972 * 973 * - ignore it 974 * - see it as a directory 975 * - recurse into it 976 * 977 * and which one we choose depends on a combination of existing 978 * git index contents and the flags passed into the directory 979 * traversal routine. 980 * 981 * Case 1: If we *already* have entries in the index under that 982 * directory name, we always recurse into the directory to see 983 * all the files. 984 * 985 * Case 2: If we *already* have that directory name as a gitlink, 986 * we always continue to see it as a gitlink, regardless of whether 987 * there is an actual git directory there or not (it might not 988 * be checked out as a subproject!) 989 * 990 * Case 3: if we didn't have it in the index previously, we 991 * have a few sub-cases: 992 * 993 * (a) if "show_other_directories" is true, we show it as 994 * just a directory, unless "hide_empty_directories" is 995 * also true, in which case we need to check if it contains any 996 * untracked and / or ignored files. 997 * (b) if it looks like a git directory, and we don't have 998 * 'no_gitlinks' set we treat it as a gitlink, and show it 999 * as a directory.1000 * (c) otherwise, we recurse into it.1001 */1002static enum path_treatment treat_directory(struct dir_struct *dir,1003 const char *dirname, int len, int exclude,1004 const struct path_simplify *simplify)1005{1006 /* The "len-1" is to strip the final '/' */1007 switch (directory_exists_in_index(dirname, len-1)) {1008 case index_directory:1009 return path_recurse;10101011 case index_gitdir:1012 return path_none;10131014 case index_nonexistent:1015 if (dir->flags & DIR_SHOW_OTHER_DIRECTORIES)1016 break;1017 if (!(dir->flags & DIR_NO_GITLINKS)) {1018 unsigned char sha1[20];1019 if (resolve_gitlink_ref(dirname, "HEAD", sha1) == 0)1020 return path_untracked;1021 }1022 return path_recurse;1023 }10241025 /* This is the "show_other_directories" case */10261027 if (!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1028 return exclude ? path_excluded : path_untracked;10291030 return read_directory_recursive(dir, dirname, len, 1, simplify);1031}10321033/*1034 * This is an inexact early pruning of any recursive directory1035 * reading - if the path cannot possibly be in the pathspec,1036 * return true, and we'll skip it early.1037 */1038static int simplify_away(const char *path, int pathlen, const struct path_simplify *simplify)1039{1040 if (simplify) {1041 for (;;) {1042 const char *match = simplify->path;1043 int len = simplify->len;10441045 if (!match)1046 break;1047 if (len > pathlen)1048 len = pathlen;1049 if (!memcmp(path, match, len))1050 return 0;1051 simplify++;1052 }1053 return 1;1054 }1055 return 0;1056}10571058/*1059 * This function tells us whether an excluded path matches a1060 * list of "interesting" pathspecs. That is, whether a path matched1061 * by any of the pathspecs could possibly be ignored by excluding1062 * the specified path. This can happen if:1063 *1064 * 1. the path is mentioned explicitly in the pathspec1065 *1066 * 2. the path is a directory prefix of some element in the1067 * pathspec1068 */1069static int exclude_matches_pathspec(const char *path, int len,1070 const struct path_simplify *simplify)1071{1072 if (simplify) {1073 for (; simplify->path; simplify++) {1074 if (len == simplify->len1075 && !memcmp(path, simplify->path, len))1076 return 1;1077 if (len < simplify->len1078 && simplify->path[len] == '/'1079 && !memcmp(path, simplify->path, len))1080 return 1;1081 }1082 }1083 return 0;1084}10851086static int get_index_dtype(const char *path, int len)1087{1088 int pos;1089 const struct cache_entry *ce;10901091 ce = cache_file_exists(path, len, 0);1092 if (ce) {1093 if (!ce_uptodate(ce))1094 return DT_UNKNOWN;1095 if (S_ISGITLINK(ce->ce_mode))1096 return DT_DIR;1097 /*1098 * Nobody actually cares about the1099 * difference between DT_LNK and DT_REG1100 */1101 return DT_REG;1102 }11031104 /* Try to look it up as a directory */1105 pos = cache_name_pos(path, len);1106 if (pos >= 0)1107 return DT_UNKNOWN;1108 pos = -pos-1;1109 while (pos < active_nr) {1110 ce = active_cache[pos++];1111 if (strncmp(ce->name, path, len))1112 break;1113 if (ce->name[len] > '/')1114 break;1115 if (ce->name[len] < '/')1116 continue;1117 if (!ce_uptodate(ce))1118 break; /* continue? */1119 return DT_DIR;1120 }1121 return DT_UNKNOWN;1122}11231124static int get_dtype(struct dirent *de, const char *path, int len)1125{1126 int dtype = de ? DTYPE(de) : DT_UNKNOWN;1127 struct stat st;11281129 if (dtype != DT_UNKNOWN)1130 return dtype;1131 dtype = get_index_dtype(path, len);1132 if (dtype != DT_UNKNOWN)1133 return dtype;1134 if (lstat(path, &st))1135 return dtype;1136 if (S_ISREG(st.st_mode))1137 return DT_REG;1138 if (S_ISDIR(st.st_mode))1139 return DT_DIR;1140 if (S_ISLNK(st.st_mode))1141 return DT_LNK;1142 return dtype;1143}11441145static enum path_treatment treat_one_path(struct dir_struct *dir,1146 struct strbuf *path,1147 const struct path_simplify *simplify,1148 int dtype, struct dirent *de)1149{1150 int exclude;1151 int has_path_in_index = !!cache_file_exists(path->buf, path->len, ignore_case);11521153 if (dtype == DT_UNKNOWN)1154 dtype = get_dtype(de, path->buf, path->len);11551156 /* Always exclude indexed files */1157 if (dtype != DT_DIR && has_path_in_index)1158 return path_none;11591160 /*1161 * When we are looking at a directory P in the working tree,1162 * there are three cases:1163 *1164 * (1) P exists in the index. Everything inside the directory P in1165 * the working tree needs to go when P is checked out from the1166 * index.1167 *1168 * (2) P does not exist in the index, but there is P/Q in the index.1169 * We know P will stay a directory when we check out the contents1170 * of the index, but we do not know yet if there is a directory1171 * P/Q in the working tree to be killed, so we need to recurse.1172 *1173 * (3) P does not exist in the index, and there is no P/Q in the index1174 * to require P to be a directory, either. Only in this case, we1175 * know that everything inside P will not be killed without1176 * recursing.1177 */1178 if ((dir->flags & DIR_COLLECT_KILLED_ONLY) &&1179 (dtype == DT_DIR) &&1180 !has_path_in_index &&1181 (directory_exists_in_index(path->buf, path->len) == index_nonexistent))1182 return path_none;11831184 exclude = is_excluded(dir, path->buf, &dtype);11851186 /*1187 * Excluded? If we don't explicitly want to show1188 * ignored files, ignore it1189 */1190 if (exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))1191 return path_excluded;11921193 switch (dtype) {1194 default:1195 return path_none;1196 case DT_DIR:1197 strbuf_addch(path, '/');1198 return treat_directory(dir, path->buf, path->len, exclude,1199 simplify);1200 case DT_REG:1201 case DT_LNK:1202 return exclude ? path_excluded : path_untracked;1203 }1204}12051206static enum path_treatment treat_path(struct dir_struct *dir,1207 struct dirent *de,1208 struct strbuf *path,1209 int baselen,1210 const struct path_simplify *simplify)1211{1212 int dtype;12131214 if (is_dot_or_dotdot(de->d_name) || !strcmp(de->d_name, ".git"))1215 return path_none;1216 strbuf_setlen(path, baselen);1217 strbuf_addstr(path, de->d_name);1218 if (simplify_away(path->buf, path->len, simplify))1219 return path_none;12201221 dtype = DTYPE(de);1222 return treat_one_path(dir, path, simplify, dtype, de);1223}12241225/*1226 * Read a directory tree. We currently ignore anything but1227 * directories, regular files and symlinks. That's because git1228 * doesn't handle them at all yet. Maybe that will change some1229 * day.1230 *1231 * Also, we ignore the name ".git" (even if it is not a directory).1232 * That likely will not change.1233 *1234 * Returns the most significant path_treatment value encountered in the scan.1235 */1236static enum path_treatment read_directory_recursive(struct dir_struct *dir,1237 const char *base, int baselen,1238 int check_only,1239 const struct path_simplify *simplify)1240{1241 DIR *fdir;1242 enum path_treatment state, subdir_state, dir_state = path_none;1243 struct dirent *de;1244 struct strbuf path = STRBUF_INIT;12451246 strbuf_add(&path, base, baselen);12471248 fdir = opendir(path.len ? path.buf : ".");1249 if (!fdir)1250 goto out;12511252 while ((de = readdir(fdir)) != NULL) {1253 /* check how the file or directory should be treated */1254 state = treat_path(dir, de, &path, baselen, simplify);1255 if (state > dir_state)1256 dir_state = state;12571258 /* recurse into subdir if instructed by treat_path */1259 if (state == path_recurse) {1260 subdir_state = read_directory_recursive(dir, path.buf,1261 path.len, check_only, simplify);1262 if (subdir_state > dir_state)1263 dir_state = subdir_state;1264 }12651266 if (check_only) {1267 /* abort early if maximum state has been reached */1268 if (dir_state == path_untracked)1269 break;1270 /* skip the dir_add_* part */1271 continue;1272 }12731274 /* add the path to the appropriate result list */1275 switch (state) {1276 case path_excluded:1277 if (dir->flags & DIR_SHOW_IGNORED)1278 dir_add_name(dir, path.buf, path.len);1279 else if ((dir->flags & DIR_SHOW_IGNORED_TOO) ||1280 ((dir->flags & DIR_COLLECT_IGNORED) &&1281 exclude_matches_pathspec(path.buf, path.len,1282 simplify)))1283 dir_add_ignored(dir, path.buf, path.len);1284 break;12851286 case path_untracked:1287 if (!(dir->flags & DIR_SHOW_IGNORED))1288 dir_add_name(dir, path.buf, path.len);1289 break;12901291 default:1292 break;1293 }1294 }1295 closedir(fdir);1296 out:1297 strbuf_release(&path);12981299 return dir_state;1300}13011302static int cmp_name(const void *p1, const void *p2)1303{1304 const struct dir_entry *e1 = *(const struct dir_entry **)p1;1305 const struct dir_entry *e2 = *(const struct dir_entry **)p2;13061307 return cache_name_compare(e1->name, e1->len,1308 e2->name, e2->len);1309}13101311static struct path_simplify *create_simplify(const char **pathspec)1312{1313 int nr, alloc = 0;1314 struct path_simplify *simplify = NULL;13151316 if (!pathspec)1317 return NULL;13181319 for (nr = 0 ; ; nr++) {1320 const char *match;1321 if (nr >= alloc) {1322 alloc = alloc_nr(alloc);1323 simplify = xrealloc(simplify, alloc * sizeof(*simplify));1324 }1325 match = *pathspec++;1326 if (!match)1327 break;1328 simplify[nr].path = match;1329 simplify[nr].len = simple_length(match);1330 }1331 simplify[nr].path = NULL;1332 simplify[nr].len = 0;1333 return simplify;1334}13351336static void free_simplify(struct path_simplify *simplify)1337{1338 free(simplify);1339}13401341static int treat_leading_path(struct dir_struct *dir,1342 const char *path, int len,1343 const struct path_simplify *simplify)1344{1345 struct strbuf sb = STRBUF_INIT;1346 int baselen, rc = 0;1347 const char *cp;1348 int old_flags = dir->flags;13491350 while (len && path[len - 1] == '/')1351 len--;1352 if (!len)1353 return 1;1354 baselen = 0;1355 dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;1356 while (1) {1357 cp = path + baselen + !!baselen;1358 cp = memchr(cp, '/', path + len - cp);1359 if (!cp)1360 baselen = len;1361 else1362 baselen = cp - path;1363 strbuf_setlen(&sb, 0);1364 strbuf_add(&sb, path, baselen);1365 if (!is_directory(sb.buf))1366 break;1367 if (simplify_away(sb.buf, sb.len, simplify))1368 break;1369 if (treat_one_path(dir, &sb, simplify,1370 DT_DIR, NULL) == path_none)1371 break; /* do not recurse into it */1372 if (len <= baselen) {1373 rc = 1;1374 break; /* finished checking */1375 }1376 }1377 strbuf_release(&sb);1378 dir->flags = old_flags;1379 return rc;1380}13811382int read_directory(struct dir_struct *dir, const char *path, int len, const struct pathspec *pathspec)1383{1384 struct path_simplify *simplify;13851386 /*1387 * Check out create_simplify()1388 */1389 if (pathspec)1390 GUARD_PATHSPEC(pathspec,1391 PATHSPEC_FROMTOP |1392 PATHSPEC_MAXDEPTH |1393 PATHSPEC_LITERAL |1394 PATHSPEC_GLOB |1395 PATHSPEC_ICASE);13961397 if (has_symlink_leading_path(path, len))1398 return dir->nr;13991400 simplify = create_simplify(pathspec ? pathspec->_raw : NULL);1401 if (!len || treat_leading_path(dir, path, len, simplify))1402 read_directory_recursive(dir, path, len, 0, simplify);1403 free_simplify(simplify);1404 qsort(dir->entries, dir->nr, sizeof(struct dir_entry *), cmp_name);1405 qsort(dir->ignored, dir->ignored_nr, sizeof(struct dir_entry *), cmp_name);1406 return dir->nr;1407}14081409int file_exists(const char *f)1410{1411 struct stat sb;1412 return lstat(f, &sb) == 0;1413}14141415/*1416 * Given two normalized paths (a trailing slash is ok), if subdir is1417 * outside dir, return -1. Otherwise return the offset in subdir that1418 * can be used as relative path to dir.1419 */1420int dir_inside_of(const char *subdir, const char *dir)1421{1422 int offset = 0;14231424 assert(dir && subdir && *dir && *subdir);14251426 while (*dir && *subdir && *dir == *subdir) {1427 dir++;1428 subdir++;1429 offset++;1430 }14311432 /* hel[p]/me vs hel[l]/yeah */1433 if (*dir && *subdir)1434 return -1;14351436 if (!*subdir)1437 return !*dir ? offset : -1; /* same dir */14381439 /* foo/[b]ar vs foo/[] */1440 if (is_dir_sep(dir[-1]))1441 return is_dir_sep(subdir[-1]) ? offset : -1;14421443 /* foo[/]bar vs foo[] */1444 return is_dir_sep(*subdir) ? offset + 1 : -1;1445}14461447int is_inside_dir(const char *dir)1448{1449 char cwd[PATH_MAX];1450 if (!dir)1451 return 0;1452 if (!getcwd(cwd, sizeof(cwd)))1453 die_errno("can't find the current directory");1454 return dir_inside_of(cwd, dir) >= 0;1455}14561457int is_empty_dir(const char *path)1458{1459 DIR *dir = opendir(path);1460 struct dirent *e;1461 int ret = 1;14621463 if (!dir)1464 return 0;14651466 while ((e = readdir(dir)) != NULL)1467 if (!is_dot_or_dotdot(e->d_name)) {1468 ret = 0;1469 break;1470 }14711472 closedir(dir);1473 return ret;1474}14751476static int remove_dir_recurse(struct strbuf *path, int flag, int *kept_up)1477{1478 DIR *dir;1479 struct dirent *e;1480 int ret = 0, original_len = path->len, len, kept_down = 0;1481 int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);1482 int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);1483 unsigned char submodule_head[20];14841485 if ((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&1486 !resolve_gitlink_ref(path->buf, "HEAD", submodule_head)) {1487 /* Do not descend and nuke a nested git work tree. */1488 if (kept_up)1489 *kept_up = 1;1490 return 0;1491 }14921493 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;1494 dir = opendir(path->buf);1495 if (!dir) {1496 /* an empty dir could be removed even if it is unreadble */1497 if (!keep_toplevel)1498 return rmdir(path->buf);1499 else1500 return -1;1501 }1502 if (path->buf[original_len - 1] != '/')1503 strbuf_addch(path, '/');15041505 len = path->len;1506 while ((e = readdir(dir)) != NULL) {1507 struct stat st;1508 if (is_dot_or_dotdot(e->d_name))1509 continue;15101511 strbuf_setlen(path, len);1512 strbuf_addstr(path, e->d_name);1513 if (lstat(path->buf, &st))1514 ; /* fall thru */1515 else if (S_ISDIR(st.st_mode)) {1516 if (!remove_dir_recurse(path, flag, &kept_down))1517 continue; /* happy */1518 } else if (!only_empty && !unlink(path->buf))1519 continue; /* happy, too */15201521 /* path too long, stat fails, or non-directory still exists */1522 ret = -1;1523 break;1524 }1525 closedir(dir);15261527 strbuf_setlen(path, original_len);1528 if (!ret && !keep_toplevel && !kept_down)1529 ret = rmdir(path->buf);1530 else if (kept_up)1531 /*1532 * report the uplevel that it is not an error that we1533 * did not rmdir() our directory.1534 */1535 *kept_up = !ret;1536 return ret;1537}15381539int remove_dir_recursively(struct strbuf *path, int flag)1540{1541 return remove_dir_recurse(path, flag, NULL);1542}15431544void setup_standard_excludes(struct dir_struct *dir)1545{1546 const char *path;1547 char *xdg_path;15481549 dir->exclude_per_dir = ".gitignore";1550 path = git_path("info/exclude");1551 if (!excludes_file) {1552 home_config_paths(NULL, &xdg_path, "ignore");1553 excludes_file = xdg_path;1554 }1555 if (!access_or_warn(path, R_OK, 0))1556 add_excludes_from_file(dir, path);1557 if (excludes_file && !access_or_warn(excludes_file, R_OK, 0))1558 add_excludes_from_file(dir, excludes_file);1559}15601561int remove_path(const char *name)1562{1563 char *slash;15641565 if (unlink(name) && errno != ENOENT && errno != ENOTDIR)1566 return -1;15671568 slash = strrchr(name, '/');1569 if (slash) {1570 char *dirs = xstrdup(name);1571 slash = dirs + (slash - name);1572 do {1573 *slash = '\0';1574 } while (rmdir(dirs) == 0 && (slash = strrchr(dirs, '/')));1575 free(dirs);1576 }1577 return 0;1578}15791580/*1581 * Frees memory within dir which was allocated for exclude lists and1582 * the exclude_stack. Does not free dir itself.1583 */1584void clear_directory(struct dir_struct *dir)1585{1586 int i, j;1587 struct exclude_list_group *group;1588 struct exclude_list *el;1589 struct exclude_stack *stk;15901591 for (i = EXC_CMDL; i <= EXC_FILE; i++) {1592 group = &dir->exclude_list_group[i];1593 for (j = 0; j < group->nr; j++) {1594 el = &group->el[j];1595 if (i == EXC_DIRS)1596 free((char *)el->src);1597 clear_exclude_list(el);1598 }1599 free(group->el);1600 }16011602 stk = dir->exclude_stack;1603 while (stk) {1604 struct exclude_stack *prev = stk->prev;1605 free(stk);1606 stk = prev;1607 }1608}