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 466int add_excludes_from_file_to_list(const char *fname, 467 const char *base, 468 int baselen, 469 struct exclude_list *el, 470 int check_index) 471{ 472 struct stat st; 473 int fd, i, lineno = 1; 474 size_t size = 0; 475 char *buf, *entry; 476 477 fd = open(fname, O_RDONLY); 478 if (fd < 0 || fstat(fd, &st) < 0) { 479 if (errno != ENOENT) 480 warn_on_inaccessible(fname); 481 if (0 <= fd) 482 close(fd); 483 if (!check_index || 484 (buf = read_skip_worktree_file_from_index(fname, &size)) == NULL) 485 return -1; 486 if (size == 0) { 487 free(buf); 488 return 0; 489 } 490 if (buf[size-1] != '\n') { 491 buf = xrealloc(buf, size+1); 492 buf[size++] = '\n'; 493 } 494 } 495 else { 496 size = xsize_t(st.st_size); 497 if (size == 0) { 498 close(fd); 499 return 0; 500 } 501 buf = xmalloc(size+1); 502 if (read_in_full(fd, buf, size) != size) { 503 free(buf); 504 close(fd); 505 return -1; 506 } 507 buf[size++] = '\n'; 508 close(fd); 509 } 510 511 el->filebuf = buf; 512 entry = buf; 513 for (i = 0; i < size; i++) { 514 if (buf[i] == '\n') { 515 if (entry != buf + i && entry[0] != '#') { 516 buf[i - (i && buf[i-1] == '\r')] = 0; 517 add_exclude(entry, base, baselen, el, lineno); 518 } 519 lineno++; 520 entry = buf + i + 1; 521 } 522 } 523 return 0; 524} 525 526struct exclude_list *add_exclude_list(struct dir_struct *dir, 527 int group_type, const char *src) 528{ 529 struct exclude_list *el; 530 struct exclude_list_group *group; 531 532 group = &dir->exclude_list_group[group_type]; 533 ALLOC_GROW(group->el, group->nr + 1, group->alloc); 534 el = &group->el[group->nr++]; 535 memset(el, 0, sizeof(*el)); 536 el->src = src; 537 return el; 538} 539 540/* 541 * Used to set up core.excludesfile and .git/info/exclude lists. 542 */ 543void add_excludes_from_file(struct dir_struct *dir, const char *fname) 544{ 545 struct exclude_list *el; 546 el = add_exclude_list(dir, EXC_FILE, fname); 547 if (add_excludes_from_file_to_list(fname, "", 0, el, 0) < 0) 548 die("cannot use %s as an exclude file", fname); 549} 550 551int match_basename(const char *basename, int basenamelen, 552 const char *pattern, int prefix, int patternlen, 553 int flags) 554{ 555 if (prefix == patternlen) { 556 if (patternlen == basenamelen && 557 !strncmp_icase(pattern, basename, basenamelen)) 558 return 1; 559 } else if (flags & EXC_FLAG_ENDSWITH) { 560 /* "*literal" matching against "fooliteral" */ 561 if (patternlen - 1 <= basenamelen && 562 !strncmp_icase(pattern + 1, 563 basename + basenamelen - (patternlen - 1), 564 patternlen - 1)) 565 return 1; 566 } else { 567 if (fnmatch_icase_mem(pattern, patternlen, 568 basename, basenamelen, 569 0) == 0) 570 return 1; 571 } 572 return 0; 573} 574 575int match_pathname(const char *pathname, int pathlen, 576 const char *base, int baselen, 577 const char *pattern, int prefix, int patternlen, 578 int flags) 579{ 580 const char *name; 581 int namelen; 582 583 /* 584 * match with FNM_PATHNAME; the pattern has base implicitly 585 * in front of it. 586 */ 587 if (*pattern == '/') { 588 pattern++; 589 patternlen--; 590 prefix--; 591 } 592 593 /* 594 * baselen does not count the trailing slash. base[] may or 595 * may not end with a trailing slash though. 596 */ 597 if (pathlen < baselen + 1 || 598 (baselen && pathname[baselen] != '/') || 599 strncmp_icase(pathname, base, baselen)) 600 return 0; 601 602 namelen = baselen ? pathlen - baselen - 1 : pathlen; 603 name = pathname + pathlen - namelen; 604 605 if (prefix) { 606 /* 607 * if the non-wildcard part is longer than the 608 * remaining pathname, surely it cannot match. 609 */ 610 if (prefix > namelen) 611 return 0; 612 613 if (strncmp_icase(pattern, name, prefix)) 614 return 0; 615 pattern += prefix; 616 patternlen -= prefix; 617 name += prefix; 618 namelen -= prefix; 619 620 /* 621 * If the whole pattern did not have a wildcard, 622 * then our prefix match is all we need; we 623 * do not need to call fnmatch at all. 624 */ 625 if (!patternlen && !namelen) 626 return 1; 627 } 628 629 return fnmatch_icase_mem(pattern, patternlen, 630 name, namelen, 631 WM_PATHNAME) == 0; 632} 633 634/* 635 * Scan the given exclude list in reverse to see whether pathname 636 * should be ignored. The first match (i.e. the last on the list), if 637 * any, determines the fate. Returns the exclude_list element which 638 * matched, or NULL for undecided. 639 */ 640static struct exclude *last_exclude_matching_from_list(const char *pathname, 641 int pathlen, 642 const char *basename, 643 int *dtype, 644 struct exclude_list *el) 645{ 646 int i; 647 648 if (!el->nr) 649 return NULL; /* undefined */ 650 651 for (i = el->nr - 1; 0 <= i; i--) { 652 struct exclude *x = el->excludes[i]; 653 const char *exclude = x->pattern; 654 int prefix = x->nowildcardlen; 655 656 if (x->flags & EXC_FLAG_MUSTBEDIR) { 657 if (*dtype == DT_UNKNOWN) 658 *dtype = get_dtype(NULL, pathname, pathlen); 659 if (*dtype != DT_DIR) 660 continue; 661 } 662 663 if (x->flags & EXC_FLAG_NODIR) { 664 if (match_basename(basename, 665 pathlen - (basename - pathname), 666 exclude, prefix, x->patternlen, 667 x->flags)) 668 return x; 669 continue; 670 } 671 672 assert(x->baselen == 0 || x->base[x->baselen - 1] == '/'); 673 if (match_pathname(pathname, pathlen, 674 x->base, x->baselen ? x->baselen - 1 : 0, 675 exclude, prefix, x->patternlen, x->flags)) 676 return x; 677 } 678 return NULL; /* undecided */ 679} 680 681/* 682 * Scan the list and let the last match determine the fate. 683 * Return 1 for exclude, 0 for include and -1 for undecided. 684 */ 685int is_excluded_from_list(const char *pathname, 686 int pathlen, const char *basename, int *dtype, 687 struct exclude_list *el) 688{ 689 struct exclude *exclude; 690 exclude = last_exclude_matching_from_list(pathname, pathlen, basename, dtype, el); 691 if (exclude) 692 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1; 693 return -1; /* undecided */ 694} 695 696static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir, 697 const char *pathname, int pathlen, const char *basename, 698 int *dtype_p) 699{ 700 int i, j; 701 struct exclude_list_group *group; 702 struct exclude *exclude; 703 for (i = EXC_CMDL; i <= EXC_FILE; i++) { 704 group = &dir->exclude_list_group[i]; 705 for (j = group->nr - 1; j >= 0; j--) { 706 exclude = last_exclude_matching_from_list( 707 pathname, pathlen, basename, dtype_p, 708 &group->el[j]); 709 if (exclude) 710 return exclude; 711 } 712 } 713 return NULL; 714} 715 716/* 717 * Loads the per-directory exclude list for the substring of base 718 * which has a char length of baselen. 719 */ 720static void prep_exclude(struct dir_struct *dir, const char *base, int baselen) 721{ 722 struct exclude_list_group *group; 723 struct exclude_list *el; 724 struct exclude_stack *stk = NULL; 725 int current; 726 727 group = &dir->exclude_list_group[EXC_DIRS]; 728 729 /* Pop the exclude lists from the EXCL_DIRS exclude_list_group 730 * which originate from directories not in the prefix of the 731 * path being checked. */ 732 while ((stk = dir->exclude_stack) != NULL) { 733 if (stk->baselen <= baselen && 734 !strncmp(dir->basebuf, base, stk->baselen)) 735 break; 736 el = &group->el[dir->exclude_stack->exclude_ix]; 737 dir->exclude_stack = stk->prev; 738 dir->exclude = NULL; 739 free((char *)el->src); /* see strdup() below */ 740 clear_exclude_list(el); 741 free(stk); 742 group->nr--; 743 } 744 745 /* Skip traversing into sub directories if the parent is excluded */ 746 if (dir->exclude) 747 return; 748 749 /* Read from the parent directories and push them down. */ 750 current = stk ? stk->baselen : -1; 751 while (current < baselen) { 752 struct exclude_stack *stk = xcalloc(1, sizeof(*stk)); 753 const char *cp; 754 755 if (current < 0) { 756 cp = base; 757 current = 0; 758 } 759 else { 760 cp = strchr(base + current + 1, '/'); 761 if (!cp) 762 die("oops in prep_exclude"); 763 cp++; 764 } 765 stk->prev = dir->exclude_stack; 766 stk->baselen = cp - base; 767 stk->exclude_ix = group->nr; 768 el = add_exclude_list(dir, EXC_DIRS, NULL); 769 memcpy(dir->basebuf + current, base + current, 770 stk->baselen - current); 771 772 /* Abort if the directory is excluded */ 773 if (stk->baselen) { 774 int dt = DT_DIR; 775 dir->basebuf[stk->baselen - 1] = 0; 776 dir->exclude = last_exclude_matching_from_lists(dir, 777 dir->basebuf, stk->baselen - 1, 778 dir->basebuf + current, &dt); 779 dir->basebuf[stk->baselen - 1] = '/'; 780 if (dir->exclude && 781 dir->exclude->flags & EXC_FLAG_NEGATIVE) 782 dir->exclude = NULL; 783 if (dir->exclude) { 784 dir->basebuf[stk->baselen] = 0; 785 dir->exclude_stack = stk; 786 return; 787 } 788 } 789 790 /* Try to read per-directory file unless path is too long */ 791 if (dir->exclude_per_dir && 792 stk->baselen + strlen(dir->exclude_per_dir) < PATH_MAX) { 793 strcpy(dir->basebuf + stk->baselen, 794 dir->exclude_per_dir); 795 /* 796 * dir->basebuf gets reused by the traversal, but we 797 * need fname to remain unchanged to ensure the src 798 * member of each struct exclude correctly 799 * back-references its source file. Other invocations 800 * of add_exclude_list provide stable strings, so we 801 * strdup() and free() here in the caller. 802 */ 803 el->src = strdup(dir->basebuf); 804 add_excludes_from_file_to_list(dir->basebuf, 805 dir->basebuf, stk->baselen, el, 1); 806 } 807 dir->exclude_stack = stk; 808 current = stk->baselen; 809 } 810 dir->basebuf[baselen] = '\0'; 811} 812 813/* 814 * Loads the exclude lists for the directory containing pathname, then 815 * scans all exclude lists to determine whether pathname is excluded. 816 * Returns the exclude_list element which matched, or NULL for 817 * undecided. 818 */ 819struct exclude *last_exclude_matching(struct dir_struct *dir, 820 const char *pathname, 821 int *dtype_p) 822{ 823 int pathlen = strlen(pathname); 824 const char *basename = strrchr(pathname, '/'); 825 basename = (basename) ? basename+1 : pathname; 826 827 prep_exclude(dir, pathname, basename-pathname); 828 829 if (dir->exclude) 830 return dir->exclude; 831 832 return last_exclude_matching_from_lists(dir, pathname, pathlen, 833 basename, dtype_p); 834} 835 836/* 837 * Loads the exclude lists for the directory containing pathname, then 838 * scans all exclude lists to determine whether pathname is excluded. 839 * Returns 1 if true, otherwise 0. 840 */ 841int is_excluded(struct dir_struct *dir, const char *pathname, int *dtype_p) 842{ 843 struct exclude *exclude = 844 last_exclude_matching(dir, pathname, dtype_p); 845 if (exclude) 846 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1; 847 return 0; 848} 849 850static struct dir_entry *dir_entry_new(const char *pathname, int len) 851{ 852 struct dir_entry *ent; 853 854 ent = xmalloc(sizeof(*ent) + len + 1); 855 ent->len = len; 856 memcpy(ent->name, pathname, len); 857 ent->name[len] = 0; 858 return ent; 859} 860 861static struct dir_entry *dir_add_name(struct dir_struct *dir, const char *pathname, int len) 862{ 863 if (cache_file_exists(pathname, len, ignore_case)) 864 return NULL; 865 866 ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc); 867 return dir->entries[dir->nr++] = dir_entry_new(pathname, len); 868} 869 870struct dir_entry *dir_add_ignored(struct dir_struct *dir, const char *pathname, int len) 871{ 872 if (!cache_name_is_other(pathname, len)) 873 return NULL; 874 875 ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc); 876 return dir->ignored[dir->ignored_nr++] = dir_entry_new(pathname, len); 877} 878 879enum exist_status { 880 index_nonexistent = 0, 881 index_directory, 882 index_gitdir 883}; 884 885/* 886 * Do not use the alphabetically sorted index to look up 887 * the directory name; instead, use the case insensitive 888 * directory hash. 889 */ 890static enum exist_status directory_exists_in_index_icase(const char *dirname, int len) 891{ 892 const struct cache_entry *ce = cache_dir_exists(dirname, len); 893 unsigned char endchar; 894 895 if (!ce) 896 return index_nonexistent; 897 endchar = ce->name[len]; 898 899 /* 900 * The cache_entry structure returned will contain this dirname 901 * and possibly additional path components. 902 */ 903 if (endchar == '/') 904 return index_directory; 905 906 /* 907 * If there are no additional path components, then this cache_entry 908 * represents a submodule. Submodules, despite being directories, 909 * are stored in the cache without a closing slash. 910 */ 911 if (!endchar && S_ISGITLINK(ce->ce_mode)) 912 return index_gitdir; 913 914 /* This should never be hit, but it exists just in case. */ 915 return index_nonexistent; 916} 917 918/* 919 * The index sorts alphabetically by entry name, which 920 * means that a gitlink sorts as '\0' at the end, while 921 * a directory (which is defined not as an entry, but as 922 * the files it contains) will sort with the '/' at the 923 * end. 924 */ 925static enum exist_status directory_exists_in_index(const char *dirname, int len) 926{ 927 int pos; 928 929 if (ignore_case) 930 return directory_exists_in_index_icase(dirname, len); 931 932 pos = cache_name_pos(dirname, len); 933 if (pos < 0) 934 pos = -pos-1; 935 while (pos < active_nr) { 936 const struct cache_entry *ce = active_cache[pos++]; 937 unsigned char endchar; 938 939 if (strncmp(ce->name, dirname, len)) 940 break; 941 endchar = ce->name[len]; 942 if (endchar > '/') 943 break; 944 if (endchar == '/') 945 return index_directory; 946 if (!endchar && S_ISGITLINK(ce->ce_mode)) 947 return index_gitdir; 948 } 949 return index_nonexistent; 950} 951 952/* 953 * When we find a directory when traversing the filesystem, we 954 * have three distinct cases: 955 * 956 * - ignore it 957 * - see it as a directory 958 * - recurse into it 959 * 960 * and which one we choose depends on a combination of existing 961 * git index contents and the flags passed into the directory 962 * traversal routine. 963 * 964 * Case 1: If we *already* have entries in the index under that 965 * directory name, we always recurse into the directory to see 966 * all the files. 967 * 968 * Case 2: If we *already* have that directory name as a gitlink, 969 * we always continue to see it as a gitlink, regardless of whether 970 * there is an actual git directory there or not (it might not 971 * be checked out as a subproject!) 972 * 973 * Case 3: if we didn't have it in the index previously, we 974 * have a few sub-cases: 975 * 976 * (a) if "show_other_directories" is true, we show it as 977 * just a directory, unless "hide_empty_directories" is 978 * also true, in which case we need to check if it contains any 979 * untracked and / or ignored files. 980 * (b) if it looks like a git directory, and we don't have 981 * 'no_gitlinks' set we treat it as a gitlink, and show it 982 * as a directory. 983 * (c) otherwise, we recurse into it. 984 */ 985static enum path_treatment treat_directory(struct dir_struct *dir, 986 const char *dirname, int len, int exclude, 987 const struct path_simplify *simplify) 988{ 989 /* The "len-1" is to strip the final '/' */ 990 switch (directory_exists_in_index(dirname, len-1)) { 991 case index_directory: 992 return path_recurse; 993 994 case index_gitdir: 995 return path_none; 996 997 case index_nonexistent: 998 if (dir->flags & DIR_SHOW_OTHER_DIRECTORIES) 999 break;1000 if (!(dir->flags & DIR_NO_GITLINKS)) {1001 unsigned char sha1[20];1002 if (resolve_gitlink_ref(dirname, "HEAD", sha1) == 0)1003 return path_untracked;1004 }1005 return path_recurse;1006 }10071008 /* This is the "show_other_directories" case */10091010 if (!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1011 return exclude ? path_excluded : path_untracked;10121013 return read_directory_recursive(dir, dirname, len, 1, simplify);1014}10151016/*1017 * This is an inexact early pruning of any recursive directory1018 * reading - if the path cannot possibly be in the pathspec,1019 * return true, and we'll skip it early.1020 */1021static int simplify_away(const char *path, int pathlen, const struct path_simplify *simplify)1022{1023 if (simplify) {1024 for (;;) {1025 const char *match = simplify->path;1026 int len = simplify->len;10271028 if (!match)1029 break;1030 if (len > pathlen)1031 len = pathlen;1032 if (!memcmp(path, match, len))1033 return 0;1034 simplify++;1035 }1036 return 1;1037 }1038 return 0;1039}10401041/*1042 * This function tells us whether an excluded path matches a1043 * list of "interesting" pathspecs. That is, whether a path matched1044 * by any of the pathspecs could possibly be ignored by excluding1045 * the specified path. This can happen if:1046 *1047 * 1. the path is mentioned explicitly in the pathspec1048 *1049 * 2. the path is a directory prefix of some element in the1050 * pathspec1051 */1052static int exclude_matches_pathspec(const char *path, int len,1053 const struct path_simplify *simplify)1054{1055 if (simplify) {1056 for (; simplify->path; simplify++) {1057 if (len == simplify->len1058 && !memcmp(path, simplify->path, len))1059 return 1;1060 if (len < simplify->len1061 && simplify->path[len] == '/'1062 && !memcmp(path, simplify->path, len))1063 return 1;1064 }1065 }1066 return 0;1067}10681069static int get_index_dtype(const char *path, int len)1070{1071 int pos;1072 const struct cache_entry *ce;10731074 ce = cache_file_exists(path, len, 0);1075 if (ce) {1076 if (!ce_uptodate(ce))1077 return DT_UNKNOWN;1078 if (S_ISGITLINK(ce->ce_mode))1079 return DT_DIR;1080 /*1081 * Nobody actually cares about the1082 * difference between DT_LNK and DT_REG1083 */1084 return DT_REG;1085 }10861087 /* Try to look it up as a directory */1088 pos = cache_name_pos(path, len);1089 if (pos >= 0)1090 return DT_UNKNOWN;1091 pos = -pos-1;1092 while (pos < active_nr) {1093 ce = active_cache[pos++];1094 if (strncmp(ce->name, path, len))1095 break;1096 if (ce->name[len] > '/')1097 break;1098 if (ce->name[len] < '/')1099 continue;1100 if (!ce_uptodate(ce))1101 break; /* continue? */1102 return DT_DIR;1103 }1104 return DT_UNKNOWN;1105}11061107static int get_dtype(struct dirent *de, const char *path, int len)1108{1109 int dtype = de ? DTYPE(de) : DT_UNKNOWN;1110 struct stat st;11111112 if (dtype != DT_UNKNOWN)1113 return dtype;1114 dtype = get_index_dtype(path, len);1115 if (dtype != DT_UNKNOWN)1116 return dtype;1117 if (lstat(path, &st))1118 return dtype;1119 if (S_ISREG(st.st_mode))1120 return DT_REG;1121 if (S_ISDIR(st.st_mode))1122 return DT_DIR;1123 if (S_ISLNK(st.st_mode))1124 return DT_LNK;1125 return dtype;1126}11271128static enum path_treatment treat_one_path(struct dir_struct *dir,1129 struct strbuf *path,1130 const struct path_simplify *simplify,1131 int dtype, struct dirent *de)1132{1133 int exclude;1134 int has_path_in_index = !!cache_file_exists(path->buf, path->len, ignore_case);11351136 if (dtype == DT_UNKNOWN)1137 dtype = get_dtype(de, path->buf, path->len);11381139 /* Always exclude indexed files */1140 if (dtype != DT_DIR && has_path_in_index)1141 return path_none;11421143 /*1144 * When we are looking at a directory P in the working tree,1145 * there are three cases:1146 *1147 * (1) P exists in the index. Everything inside the directory P in1148 * the working tree needs to go when P is checked out from the1149 * index.1150 *1151 * (2) P does not exist in the index, but there is P/Q in the index.1152 * We know P will stay a directory when we check out the contents1153 * of the index, but we do not know yet if there is a directory1154 * P/Q in the working tree to be killed, so we need to recurse.1155 *1156 * (3) P does not exist in the index, and there is no P/Q in the index1157 * to require P to be a directory, either. Only in this case, we1158 * know that everything inside P will not be killed without1159 * recursing.1160 */1161 if ((dir->flags & DIR_COLLECT_KILLED_ONLY) &&1162 (dtype == DT_DIR) &&1163 !has_path_in_index &&1164 (directory_exists_in_index(path->buf, path->len) == index_nonexistent))1165 return path_none;11661167 exclude = is_excluded(dir, path->buf, &dtype);11681169 /*1170 * Excluded? If we don't explicitly want to show1171 * ignored files, ignore it1172 */1173 if (exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))1174 return path_excluded;11751176 switch (dtype) {1177 default:1178 return path_none;1179 case DT_DIR:1180 strbuf_addch(path, '/');1181 return treat_directory(dir, path->buf, path->len, exclude,1182 simplify);1183 case DT_REG:1184 case DT_LNK:1185 return exclude ? path_excluded : path_untracked;1186 }1187}11881189static enum path_treatment treat_path(struct dir_struct *dir,1190 struct dirent *de,1191 struct strbuf *path,1192 int baselen,1193 const struct path_simplify *simplify)1194{1195 int dtype;11961197 if (is_dot_or_dotdot(de->d_name) || !strcmp(de->d_name, ".git"))1198 return path_none;1199 strbuf_setlen(path, baselen);1200 strbuf_addstr(path, de->d_name);1201 if (simplify_away(path->buf, path->len, simplify))1202 return path_none;12031204 dtype = DTYPE(de);1205 return treat_one_path(dir, path, simplify, dtype, de);1206}12071208/*1209 * Read a directory tree. We currently ignore anything but1210 * directories, regular files and symlinks. That's because git1211 * doesn't handle them at all yet. Maybe that will change some1212 * day.1213 *1214 * Also, we ignore the name ".git" (even if it is not a directory).1215 * That likely will not change.1216 *1217 * Returns the most significant path_treatment value encountered in the scan.1218 */1219static enum path_treatment read_directory_recursive(struct dir_struct *dir,1220 const char *base, int baselen,1221 int check_only,1222 const struct path_simplify *simplify)1223{1224 DIR *fdir;1225 enum path_treatment state, subdir_state, dir_state = path_none;1226 struct dirent *de;1227 struct strbuf path = STRBUF_INIT;12281229 strbuf_add(&path, base, baselen);12301231 fdir = opendir(path.len ? path.buf : ".");1232 if (!fdir)1233 goto out;12341235 while ((de = readdir(fdir)) != NULL) {1236 /* check how the file or directory should be treated */1237 state = treat_path(dir, de, &path, baselen, simplify);1238 if (state > dir_state)1239 dir_state = state;12401241 /* recurse into subdir if instructed by treat_path */1242 if (state == path_recurse) {1243 subdir_state = read_directory_recursive(dir, path.buf,1244 path.len, check_only, simplify);1245 if (subdir_state > dir_state)1246 dir_state = subdir_state;1247 }12481249 if (check_only) {1250 /* abort early if maximum state has been reached */1251 if (dir_state == path_untracked)1252 break;1253 /* skip the dir_add_* part */1254 continue;1255 }12561257 /* add the path to the appropriate result list */1258 switch (state) {1259 case path_excluded:1260 if (dir->flags & DIR_SHOW_IGNORED)1261 dir_add_name(dir, path.buf, path.len);1262 else if ((dir->flags & DIR_SHOW_IGNORED_TOO) ||1263 ((dir->flags & DIR_COLLECT_IGNORED) &&1264 exclude_matches_pathspec(path.buf, path.len,1265 simplify)))1266 dir_add_ignored(dir, path.buf, path.len);1267 break;12681269 case path_untracked:1270 if (!(dir->flags & DIR_SHOW_IGNORED))1271 dir_add_name(dir, path.buf, path.len);1272 break;12731274 default:1275 break;1276 }1277 }1278 closedir(fdir);1279 out:1280 strbuf_release(&path);12811282 return dir_state;1283}12841285static int cmp_name(const void *p1, const void *p2)1286{1287 const struct dir_entry *e1 = *(const struct dir_entry **)p1;1288 const struct dir_entry *e2 = *(const struct dir_entry **)p2;12891290 return cache_name_compare(e1->name, e1->len,1291 e2->name, e2->len);1292}12931294static struct path_simplify *create_simplify(const char **pathspec)1295{1296 int nr, alloc = 0;1297 struct path_simplify *simplify = NULL;12981299 if (!pathspec)1300 return NULL;13011302 for (nr = 0 ; ; nr++) {1303 const char *match;1304 if (nr >= alloc) {1305 alloc = alloc_nr(alloc);1306 simplify = xrealloc(simplify, alloc * sizeof(*simplify));1307 }1308 match = *pathspec++;1309 if (!match)1310 break;1311 simplify[nr].path = match;1312 simplify[nr].len = simple_length(match);1313 }1314 simplify[nr].path = NULL;1315 simplify[nr].len = 0;1316 return simplify;1317}13181319static void free_simplify(struct path_simplify *simplify)1320{1321 free(simplify);1322}13231324static int treat_leading_path(struct dir_struct *dir,1325 const char *path, int len,1326 const struct path_simplify *simplify)1327{1328 struct strbuf sb = STRBUF_INIT;1329 int baselen, rc = 0;1330 const char *cp;1331 int old_flags = dir->flags;13321333 while (len && path[len - 1] == '/')1334 len--;1335 if (!len)1336 return 1;1337 baselen = 0;1338 dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;1339 while (1) {1340 cp = path + baselen + !!baselen;1341 cp = memchr(cp, '/', path + len - cp);1342 if (!cp)1343 baselen = len;1344 else1345 baselen = cp - path;1346 strbuf_setlen(&sb, 0);1347 strbuf_add(&sb, path, baselen);1348 if (!is_directory(sb.buf))1349 break;1350 if (simplify_away(sb.buf, sb.len, simplify))1351 break;1352 if (treat_one_path(dir, &sb, simplify,1353 DT_DIR, NULL) == path_none)1354 break; /* do not recurse into it */1355 if (len <= baselen) {1356 rc = 1;1357 break; /* finished checking */1358 }1359 }1360 strbuf_release(&sb);1361 dir->flags = old_flags;1362 return rc;1363}13641365int read_directory(struct dir_struct *dir, const char *path, int len, const struct pathspec *pathspec)1366{1367 struct path_simplify *simplify;13681369 /*1370 * Check out create_simplify()1371 */1372 if (pathspec)1373 GUARD_PATHSPEC(pathspec,1374 PATHSPEC_FROMTOP |1375 PATHSPEC_MAXDEPTH |1376 PATHSPEC_LITERAL |1377 PATHSPEC_GLOB |1378 PATHSPEC_ICASE);13791380 if (has_symlink_leading_path(path, len))1381 return dir->nr;13821383 simplify = create_simplify(pathspec ? pathspec->_raw : NULL);1384 if (!len || treat_leading_path(dir, path, len, simplify))1385 read_directory_recursive(dir, path, len, 0, simplify);1386 free_simplify(simplify);1387 qsort(dir->entries, dir->nr, sizeof(struct dir_entry *), cmp_name);1388 qsort(dir->ignored, dir->ignored_nr, sizeof(struct dir_entry *), cmp_name);1389 return dir->nr;1390}13911392int file_exists(const char *f)1393{1394 struct stat sb;1395 return lstat(f, &sb) == 0;1396}13971398/*1399 * Given two normalized paths (a trailing slash is ok), if subdir is1400 * outside dir, return -1. Otherwise return the offset in subdir that1401 * can be used as relative path to dir.1402 */1403int dir_inside_of(const char *subdir, const char *dir)1404{1405 int offset = 0;14061407 assert(dir && subdir && *dir && *subdir);14081409 while (*dir && *subdir && *dir == *subdir) {1410 dir++;1411 subdir++;1412 offset++;1413 }14141415 /* hel[p]/me vs hel[l]/yeah */1416 if (*dir && *subdir)1417 return -1;14181419 if (!*subdir)1420 return !*dir ? offset : -1; /* same dir */14211422 /* foo/[b]ar vs foo/[] */1423 if (is_dir_sep(dir[-1]))1424 return is_dir_sep(subdir[-1]) ? offset : -1;14251426 /* foo[/]bar vs foo[] */1427 return is_dir_sep(*subdir) ? offset + 1 : -1;1428}14291430int is_inside_dir(const char *dir)1431{1432 char cwd[PATH_MAX];1433 if (!dir)1434 return 0;1435 if (!getcwd(cwd, sizeof(cwd)))1436 die_errno("can't find the current directory");1437 return dir_inside_of(cwd, dir) >= 0;1438}14391440int is_empty_dir(const char *path)1441{1442 DIR *dir = opendir(path);1443 struct dirent *e;1444 int ret = 1;14451446 if (!dir)1447 return 0;14481449 while ((e = readdir(dir)) != NULL)1450 if (!is_dot_or_dotdot(e->d_name)) {1451 ret = 0;1452 break;1453 }14541455 closedir(dir);1456 return ret;1457}14581459static int remove_dir_recurse(struct strbuf *path, int flag, int *kept_up)1460{1461 DIR *dir;1462 struct dirent *e;1463 int ret = 0, original_len = path->len, len, kept_down = 0;1464 int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);1465 int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);1466 unsigned char submodule_head[20];14671468 if ((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&1469 !resolve_gitlink_ref(path->buf, "HEAD", submodule_head)) {1470 /* Do not descend and nuke a nested git work tree. */1471 if (kept_up)1472 *kept_up = 1;1473 return 0;1474 }14751476 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;1477 dir = opendir(path->buf);1478 if (!dir) {1479 if (errno == EACCES && !keep_toplevel)1480 /*1481 * An empty dir could be removable even if it1482 * is unreadable:1483 */1484 return rmdir(path->buf);1485 else1486 return -1;1487 }1488 if (path->buf[original_len - 1] != '/')1489 strbuf_addch(path, '/');14901491 len = path->len;1492 while ((e = readdir(dir)) != NULL) {1493 struct stat st;1494 if (is_dot_or_dotdot(e->d_name))1495 continue;14961497 strbuf_setlen(path, len);1498 strbuf_addstr(path, e->d_name);1499 if (lstat(path->buf, &st))1500 ; /* fall thru */1501 else if (S_ISDIR(st.st_mode)) {1502 if (!remove_dir_recurse(path, flag, &kept_down))1503 continue; /* happy */1504 } else if (!only_empty && !unlink(path->buf))1505 continue; /* happy, too */15061507 /* path too long, stat fails, or non-directory still exists */1508 ret = -1;1509 break;1510 }1511 closedir(dir);15121513 strbuf_setlen(path, original_len);1514 if (!ret && !keep_toplevel && !kept_down)1515 ret = rmdir(path->buf);1516 else if (kept_up)1517 /*1518 * report the uplevel that it is not an error that we1519 * did not rmdir() our directory.1520 */1521 *kept_up = !ret;1522 return ret;1523}15241525int remove_dir_recursively(struct strbuf *path, int flag)1526{1527 return remove_dir_recurse(path, flag, NULL);1528}15291530void setup_standard_excludes(struct dir_struct *dir)1531{1532 const char *path;1533 char *xdg_path;15341535 dir->exclude_per_dir = ".gitignore";1536 path = git_path("info/exclude");1537 if (!excludes_file) {1538 home_config_paths(NULL, &xdg_path, "ignore");1539 excludes_file = xdg_path;1540 }1541 if (!access_or_warn(path, R_OK, 0))1542 add_excludes_from_file(dir, path);1543 if (excludes_file && !access_or_warn(excludes_file, R_OK, 0))1544 add_excludes_from_file(dir, excludes_file);1545}15461547int remove_path(const char *name)1548{1549 char *slash;15501551 if (unlink(name) && errno != ENOENT && errno != ENOTDIR)1552 return -1;15531554 slash = strrchr(name, '/');1555 if (slash) {1556 char *dirs = xstrdup(name);1557 slash = dirs + (slash - name);1558 do {1559 *slash = '\0';1560 } while (rmdir(dirs) == 0 && (slash = strrchr(dirs, '/')));1561 free(dirs);1562 }1563 return 0;1564}15651566/*1567 * Frees memory within dir which was allocated for exclude lists and1568 * the exclude_stack. Does not free dir itself.1569 */1570void clear_directory(struct dir_struct *dir)1571{1572 int i, j;1573 struct exclude_list_group *group;1574 struct exclude_list *el;1575 struct exclude_stack *stk;15761577 for (i = EXC_CMDL; i <= EXC_FILE; i++) {1578 group = &dir->exclude_list_group[i];1579 for (j = 0; j < group->nr; j++) {1580 el = &group->el[j];1581 if (i == EXC_DIRS)1582 free((char *)el->src);1583 clear_exclude_list(el);1584 }1585 free(group->el);1586 }15871588 stk = dir->exclude_stack;1589 while (stk) {1590 struct exclude_stack *prev = stk->prev;1591 free(stk);1592 stk = prev;1593 }1594}