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 { 16int len; 17const char*path; 18}; 19 20static intread_directory_recursive(struct dir_struct *dir,const char*path,int len, 21int check_only,const struct path_simplify *simplify); 22static intget_dtype(struct dirent *de,const char*path,int len); 23 24/* helper string functions with support for the ignore_case flag */ 25intstrcmp_icase(const char*a,const char*b) 26{ 27return ignore_case ?strcasecmp(a, b) :strcmp(a, b); 28} 29 30intstrncmp_icase(const char*a,const char*b,size_t count) 31{ 32return ignore_case ?strncasecmp(a, b, count) :strncmp(a, b, count); 33} 34 35intfnmatch_icase(const char*pattern,const char*string,int flags) 36{ 37returnfnmatch(pattern, string, flags | (ignore_case ? FNM_CASEFOLD :0)); 38} 39 40inlineintgit_fnmatch(const char*pattern,const char*string, 41int flags,int prefix) 42{ 43int fnm_flags =0; 44if(flags & GFNM_PATHNAME) 45 fnm_flags |= FNM_PATHNAME; 46if(prefix >0) { 47if(strncmp(pattern, string, prefix)) 48return FNM_NOMATCH; 49 pattern += prefix; 50 string += prefix; 51} 52if(flags & GFNM_ONESTAR) { 53int pattern_len =strlen(++pattern); 54int string_len =strlen(string); 55return string_len < pattern_len || 56strcmp(pattern, 57 string + string_len - pattern_len); 58} 59returnfnmatch(pattern, string, fnm_flags); 60} 61 62static intfnmatch_icase_mem(const char*pattern,int patternlen, 63const char*string,int stringlen, 64int flags) 65{ 66int match_status; 67struct strbuf pat_buf = STRBUF_INIT; 68struct strbuf str_buf = STRBUF_INIT; 69const char*use_pat = pattern; 70const char*use_str = string; 71 72if(pattern[patternlen]) { 73strbuf_add(&pat_buf, pattern, patternlen); 74 use_pat = pat_buf.buf; 75} 76if(string[stringlen]) { 77strbuf_add(&str_buf, string, stringlen); 78 use_str = str_buf.buf; 79} 80 81if(ignore_case) 82 flags |= WM_CASEFOLD; 83 match_status =wildmatch(use_pat, use_str, flags, NULL); 84 85strbuf_release(&pat_buf); 86strbuf_release(&str_buf); 87 88return match_status; 89} 90 91static size_tcommon_prefix_len(const char**pathspec) 92{ 93const char*n, *first; 94size_t max =0; 95int literal =limit_pathspec_to_literal(); 96 97if(!pathspec) 98return max; 99 100 first = *pathspec; 101while((n = *pathspec++)) { 102size_t i, len =0; 103for(i =0; first == n || i < max; i++) { 104char c = n[i]; 105if(!c || c != first[i] || (!literal &&is_glob_special(c))) 106break; 107if(c =='/') 108 len = i +1; 109} 110if(first == n || len < max) { 111 max = len; 112if(!max) 113break; 114} 115} 116return max; 117} 118 119/* 120 * Returns a copy of the longest leading path common among all 121 * pathspecs. 122 */ 123char*common_prefix(const char**pathspec) 124{ 125unsigned long len =common_prefix_len(pathspec); 126 127return len ?xmemdupz(*pathspec, len) : NULL; 128} 129 130intfill_directory(struct dir_struct *dir,const char**pathspec) 131{ 132size_t len; 133 134/* 135 * Calculate common prefix for the pathspec, and 136 * use that to optimize the directory walk 137 */ 138 len =common_prefix_len(pathspec); 139 140/* Read the directory and prune it */ 141read_directory(dir, pathspec ? *pathspec :"", len, pathspec); 142return len; 143} 144 145intwithin_depth(const char*name,int namelen, 146int depth,int max_depth) 147{ 148const char*cp = name, *cpe = name + namelen; 149 150while(cp < cpe) { 151if(*cp++ !='/') 152continue; 153 depth++; 154if(depth > max_depth) 155return0; 156} 157return1; 158} 159 160/* 161 * Does 'match' match the given name? 162 * A match is found if 163 * 164 * (1) the 'match' string is leading directory of 'name', or 165 * (2) the 'match' string is a wildcard and matches 'name', or 166 * (3) the 'match' string is exactly the same as 'name'. 167 * 168 * and the return value tells which case it was. 169 * 170 * It returns 0 when there is no match. 171 */ 172static intmatch_one(const char*match,const char*name,int namelen) 173{ 174int matchlen; 175int literal =limit_pathspec_to_literal(); 176 177/* If the match was just the prefix, we matched */ 178if(!*match) 179return MATCHED_RECURSIVELY; 180 181if(ignore_case) { 182for(;;) { 183unsigned char c1 =tolower(*match); 184unsigned char c2 =tolower(*name); 185if(c1 =='\0'|| (!literal &&is_glob_special(c1))) 186break; 187if(c1 != c2) 188return0; 189 match++; 190 name++; 191 namelen--; 192} 193}else{ 194for(;;) { 195unsigned char c1 = *match; 196unsigned char c2 = *name; 197if(c1 =='\0'|| (!literal &&is_glob_special(c1))) 198break; 199if(c1 != c2) 200return0; 201 match++; 202 name++; 203 namelen--; 204} 205} 206 207/* 208 * If we don't match the matchstring exactly, 209 * we need to match by fnmatch 210 */ 211 matchlen =strlen(match); 212if(strncmp_icase(match, name, matchlen)) { 213if(literal) 214return0; 215return!fnmatch_icase(match, name,0) ? MATCHED_FNMATCH :0; 216} 217 218if(namelen == matchlen) 219return MATCHED_EXACTLY; 220if(match[matchlen-1] =='/'|| name[matchlen] =='/') 221return MATCHED_RECURSIVELY; 222return0; 223} 224 225/* 226 * Given a name and a list of pathspecs, returns the nature of the 227 * closest (i.e. most specific) match of the name to any of the 228 * pathspecs. 229 * 230 * The caller typically calls this multiple times with the same 231 * pathspec and seen[] array but with different name/namelen 232 * (e.g. entries from the index) and is interested in seeing if and 233 * how each pathspec matches all the names it calls this function 234 * with. A mark is left in the seen[] array for each pathspec element 235 * indicating the closest type of match that element achieved, so if 236 * seen[n] remains zero after multiple invocations, that means the nth 237 * pathspec did not match any names, which could indicate that the 238 * user mistyped the nth pathspec. 239 */ 240intmatch_pathspec(const char**pathspec,const char*name,int namelen, 241int prefix,char*seen) 242{ 243int i, retval =0; 244 245if(!pathspec) 246return1; 247 248 name += prefix; 249 namelen -= prefix; 250 251for(i =0; pathspec[i] != NULL; i++) { 252int how; 253const char*match = pathspec[i] + prefix; 254if(seen && seen[i] == MATCHED_EXACTLY) 255continue; 256 how =match_one(match, name, namelen); 257if(how) { 258if(retval < how) 259 retval = how; 260if(seen && seen[i] < how) 261 seen[i] = how; 262} 263} 264return retval; 265} 266 267/* 268 * Does 'match' match the given name? 269 * A match is found if 270 * 271 * (1) the 'match' string is leading directory of 'name', or 272 * (2) the 'match' string is a wildcard and matches 'name', or 273 * (3) the 'match' string is exactly the same as 'name'. 274 * 275 * and the return value tells which case it was. 276 * 277 * It returns 0 when there is no match. 278 */ 279static intmatch_pathspec_item(const struct pathspec_item *item,int prefix, 280const char*name,int namelen) 281{ 282/* name/namelen has prefix cut off by caller */ 283const char*match = item->match + prefix; 284int matchlen = item->len - prefix; 285 286/* If the match was just the prefix, we matched */ 287if(!*match) 288return MATCHED_RECURSIVELY; 289 290if(matchlen <= namelen && !strncmp(match, name, matchlen)) { 291if(matchlen == namelen) 292return MATCHED_EXACTLY; 293 294if(match[matchlen-1] =='/'|| name[matchlen] =='/') 295return MATCHED_RECURSIVELY; 296} 297 298if(item->nowildcard_len < item->len && 299!git_fnmatch(match, name, 300 item->flags & PATHSPEC_ONESTAR ? GFNM_ONESTAR :0, 301 item->nowildcard_len - prefix)) 302return MATCHED_FNMATCH; 303 304return0; 305} 306 307/* 308 * Given a name and a list of pathspecs, returns the nature of the 309 * closest (i.e. most specific) match of the name to any of the 310 * pathspecs. 311 * 312 * The caller typically calls this multiple times with the same 313 * pathspec and seen[] array but with different name/namelen 314 * (e.g. entries from the index) and is interested in seeing if and 315 * how each pathspec matches all the names it calls this function 316 * with. A mark is left in the seen[] array for each pathspec element 317 * indicating the closest type of match that element achieved, so if 318 * seen[n] remains zero after multiple invocations, that means the nth 319 * pathspec did not match any names, which could indicate that the 320 * user mistyped the nth pathspec. 321 */ 322intmatch_pathspec_depth(const struct pathspec *ps, 323const char*name,int namelen, 324int prefix,char*seen) 325{ 326int i, retval =0; 327 328if(!ps->nr) { 329if(!ps->recursive || ps->max_depth == -1) 330return MATCHED_RECURSIVELY; 331 332if(within_depth(name, namelen,0, ps->max_depth)) 333return MATCHED_EXACTLY; 334else 335return0; 336} 337 338 name += prefix; 339 namelen -= prefix; 340 341for(i = ps->nr -1; i >=0; i--) { 342int how; 343if(seen && seen[i] == MATCHED_EXACTLY) 344continue; 345 how =match_pathspec_item(ps->items+i, prefix, name, namelen); 346if(ps->recursive && ps->max_depth != -1&& 347 how && how != MATCHED_FNMATCH) { 348int len = ps->items[i].len; 349if(name[len] =='/') 350 len++; 351if(within_depth(name+len, namelen-len,0, ps->max_depth)) 352 how = MATCHED_EXACTLY; 353else 354 how =0; 355} 356if(how) { 357if(retval < how) 358 retval = how; 359if(seen && seen[i] < how) 360 seen[i] = how; 361} 362} 363return retval; 364} 365 366/* 367 * Return the length of the "simple" part of a path match limiter. 368 */ 369static intsimple_length(const char*match) 370{ 371int len = -1; 372 373for(;;) { 374unsigned char c = *match++; 375 len++; 376if(c =='\0'||is_glob_special(c)) 377return len; 378} 379} 380 381static intno_wildcard(const char*string) 382{ 383return string[simple_length(string)] =='\0'; 384} 385 386voidparse_exclude_pattern(const char**pattern, 387int*patternlen, 388int*flags, 389int*nowildcardlen) 390{ 391const char*p = *pattern; 392size_t i, len; 393 394*flags =0; 395if(*p =='!') { 396*flags |= EXC_FLAG_NEGATIVE; 397 p++; 398} 399 len =strlen(p); 400if(len && p[len -1] =='/') { 401 len--; 402*flags |= EXC_FLAG_MUSTBEDIR; 403} 404for(i =0; i < len; i++) { 405if(p[i] =='/') 406break; 407} 408if(i == len) 409*flags |= EXC_FLAG_NODIR; 410*nowildcardlen =simple_length(p); 411/* 412 * we should have excluded the trailing slash from 'p' too, 413 * but that's one more allocation. Instead just make sure 414 * nowildcardlen does not exceed real patternlen 415 */ 416if(*nowildcardlen > len) 417*nowildcardlen = len; 418if(*p =='*'&&no_wildcard(p +1)) 419*flags |= EXC_FLAG_ENDSWITH; 420*pattern = p; 421*patternlen = len; 422} 423 424voidadd_exclude(const char*string,const char*base, 425int baselen,struct exclude_list *el,int srcpos) 426{ 427struct exclude *x; 428int patternlen; 429int flags; 430int nowildcardlen; 431 432parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen); 433if(flags & EXC_FLAG_MUSTBEDIR) { 434char*s; 435 x =xmalloc(sizeof(*x) + patternlen +1); 436 s = (char*)(x+1); 437memcpy(s, string, patternlen); 438 s[patternlen] ='\0'; 439 x->pattern = s; 440}else{ 441 x =xmalloc(sizeof(*x)); 442 x->pattern = string; 443} 444 x->patternlen = patternlen; 445 x->nowildcardlen = nowildcardlen; 446 x->base = base; 447 x->baselen = baselen; 448 x->flags = flags; 449 x->srcpos = srcpos; 450ALLOC_GROW(el->excludes, el->nr +1, el->alloc); 451 el->excludes[el->nr++] = x; 452 x->el = el; 453} 454 455static void*read_skip_worktree_file_from_index(const char*path,size_t*size) 456{ 457int pos, len; 458unsigned long sz; 459enum object_type type; 460void*data; 461struct index_state *istate = &the_index; 462 463 len =strlen(path); 464 pos =index_name_pos(istate, path, len); 465if(pos <0) 466return NULL; 467if(!ce_skip_worktree(istate->cache[pos])) 468return NULL; 469 data =read_sha1_file(istate->cache[pos]->sha1, &type, &sz); 470if(!data || type != OBJ_BLOB) { 471free(data); 472return NULL; 473} 474*size =xsize_t(sz); 475return data; 476} 477 478/* 479 * Frees memory within el which was allocated for exclude patterns and 480 * the file buffer. Does not free el itself. 481 */ 482voidclear_exclude_list(struct exclude_list *el) 483{ 484int i; 485 486for(i =0; i < el->nr; i++) 487free(el->excludes[i]); 488free(el->excludes); 489free(el->filebuf); 490 491 el->nr =0; 492 el->excludes = NULL; 493 el->filebuf = NULL; 494} 495 496intadd_excludes_from_file_to_list(const char*fname, 497const char*base, 498int baselen, 499struct exclude_list *el, 500int check_index) 501{ 502struct stat st; 503int fd, i, lineno =1; 504size_t size =0; 505char*buf, *entry; 506 507 fd =open(fname, O_RDONLY); 508if(fd <0||fstat(fd, &st) <0) { 509if(errno != ENOENT) 510warn_on_inaccessible(fname); 511if(0<= fd) 512close(fd); 513if(!check_index || 514(buf =read_skip_worktree_file_from_index(fname, &size)) == NULL) 515return-1; 516if(size ==0) { 517free(buf); 518return0; 519} 520if(buf[size-1] !='\n') { 521 buf =xrealloc(buf, size+1); 522 buf[size++] ='\n'; 523} 524} 525else{ 526 size =xsize_t(st.st_size); 527if(size ==0) { 528close(fd); 529return0; 530} 531 buf =xmalloc(size+1); 532if(read_in_full(fd, buf, size) != size) { 533free(buf); 534close(fd); 535return-1; 536} 537 buf[size++] ='\n'; 538close(fd); 539} 540 541 el->filebuf = buf; 542 entry = buf; 543for(i =0; i < size; i++) { 544if(buf[i] =='\n') { 545if(entry != buf + i && entry[0] !='#') { 546 buf[i - (i && buf[i-1] =='\r')] =0; 547add_exclude(entry, base, baselen, el, lineno); 548} 549 lineno++; 550 entry = buf + i +1; 551} 552} 553return0; 554} 555 556struct exclude_list *add_exclude_list(struct dir_struct *dir, 557int group_type,const char*src) 558{ 559struct exclude_list *el; 560struct exclude_list_group *group; 561 562 group = &dir->exclude_list_group[group_type]; 563ALLOC_GROW(group->el, group->nr +1, group->alloc); 564 el = &group->el[group->nr++]; 565memset(el,0,sizeof(*el)); 566 el->src = src; 567return el; 568} 569 570/* 571 * Used to set up core.excludesfile and .git/info/exclude lists. 572 */ 573voidadd_excludes_from_file(struct dir_struct *dir,const char*fname) 574{ 575struct exclude_list *el; 576 el =add_exclude_list(dir, EXC_FILE, fname); 577if(add_excludes_from_file_to_list(fname,"",0, el,0) <0) 578die("cannot use%sas an exclude file", fname); 579} 580 581/* 582 * Loads the per-directory exclude list for the substring of base 583 * which has a char length of baselen. 584 */ 585static voidprep_exclude(struct dir_struct *dir,const char*base,int baselen) 586{ 587struct exclude_list_group *group; 588struct exclude_list *el; 589struct exclude_stack *stk = NULL; 590int current; 591 592if((!dir->exclude_per_dir) || 593(baselen +strlen(dir->exclude_per_dir) >= PATH_MAX)) 594return;/* too long a path -- ignore */ 595 596 group = &dir->exclude_list_group[EXC_DIRS]; 597 598/* Pop the exclude lists from the EXCL_DIRS exclude_list_group 599 * which originate from directories not in the prefix of the 600 * path being checked. */ 601while((stk = dir->exclude_stack) != NULL) { 602if(stk->baselen <= baselen && 603!strncmp(dir->basebuf, base, stk->baselen)) 604break; 605 el = &group->el[dir->exclude_stack->exclude_ix]; 606 dir->exclude_stack = stk->prev; 607free((char*)el->src);/* see strdup() below */ 608clear_exclude_list(el); 609free(stk); 610 group->nr--; 611} 612 613/* Read from the parent directories and push them down. */ 614 current = stk ? stk->baselen : -1; 615while(current < baselen) { 616struct exclude_stack *stk =xcalloc(1,sizeof(*stk)); 617const char*cp; 618 619if(current <0) { 620 cp = base; 621 current =0; 622} 623else{ 624 cp =strchr(base + current +1,'/'); 625if(!cp) 626die("oops in prep_exclude"); 627 cp++; 628} 629 stk->prev = dir->exclude_stack; 630 stk->baselen = cp - base; 631memcpy(dir->basebuf + current, base + current, 632 stk->baselen - current); 633strcpy(dir->basebuf + stk->baselen, dir->exclude_per_dir); 634/* 635 * dir->basebuf gets reused by the traversal, but we 636 * need fname to remain unchanged to ensure the src 637 * member of each struct exclude correctly 638 * back-references its source file. Other invocations 639 * of add_exclude_list provide stable strings, so we 640 * strdup() and free() here in the caller. 641 */ 642 el =add_exclude_list(dir, EXC_DIRS,strdup(dir->basebuf)); 643 stk->exclude_ix = group->nr -1; 644add_excludes_from_file_to_list(dir->basebuf, 645 dir->basebuf, stk->baselen, 646 el,1); 647 dir->exclude_stack = stk; 648 current = stk->baselen; 649} 650 dir->basebuf[baselen] ='\0'; 651} 652 653intmatch_basename(const char*basename,int basenamelen, 654const char*pattern,int prefix,int patternlen, 655int flags) 656{ 657if(prefix == patternlen) { 658if(patternlen == basenamelen && 659!strncmp_icase(pattern, basename, basenamelen)) 660return1; 661}else if(flags & EXC_FLAG_ENDSWITH) { 662/* "*literal" matching against "fooliteral" */ 663if(patternlen -1<= basenamelen && 664!strncmp_icase(pattern +1, 665 basename + basenamelen - (patternlen -1), 666 patternlen -1)) 667return1; 668}else{ 669if(fnmatch_icase_mem(pattern, patternlen, 670 basename, basenamelen, 6710) ==0) 672return1; 673} 674return0; 675} 676 677intmatch_pathname(const char*pathname,int pathlen, 678const char*base,int baselen, 679const char*pattern,int prefix,int patternlen, 680int flags) 681{ 682const char*name; 683int namelen; 684 685/* 686 * match with FNM_PATHNAME; the pattern has base implicitly 687 * in front of it. 688 */ 689if(*pattern =='/') { 690 pattern++; 691 patternlen--; 692 prefix--; 693} 694 695/* 696 * baselen does not count the trailing slash. base[] may or 697 * may not end with a trailing slash though. 698 */ 699if(pathlen < baselen +1|| 700(baselen && pathname[baselen] !='/') || 701strncmp_icase(pathname, base, baselen)) 702return0; 703 704 namelen = baselen ? pathlen - baselen -1: pathlen; 705 name = pathname + pathlen - namelen; 706 707if(prefix) { 708/* 709 * if the non-wildcard part is longer than the 710 * remaining pathname, surely it cannot match. 711 */ 712if(prefix > namelen) 713return0; 714 715if(strncmp_icase(pattern, name, prefix)) 716return0; 717 pattern += prefix; 718 patternlen -= prefix; 719 name += prefix; 720 namelen -= prefix; 721 722/* 723 * If the whole pattern did not have a wildcard, 724 * then our prefix match is all we need; we 725 * do not need to call fnmatch at all. 726 */ 727if(!patternlen && !namelen) 728return1; 729} 730 731returnfnmatch_icase_mem(pattern, patternlen, 732 name, namelen, 733 WM_PATHNAME) ==0; 734} 735 736/* 737 * Scan the given exclude list in reverse to see whether pathname 738 * should be ignored. The first match (i.e. the last on the list), if 739 * any, determines the fate. Returns the exclude_list element which 740 * matched, or NULL for undecided. 741 */ 742static struct exclude *last_exclude_matching_from_list(const char*pathname, 743int pathlen, 744const char*basename, 745int*dtype, 746struct exclude_list *el) 747{ 748int i; 749 750if(!el->nr) 751return NULL;/* undefined */ 752 753for(i = el->nr -1;0<= i; i--) { 754struct exclude *x = el->excludes[i]; 755const char*exclude = x->pattern; 756int prefix = x->nowildcardlen; 757 758if(x->flags & EXC_FLAG_MUSTBEDIR) { 759if(*dtype == DT_UNKNOWN) 760*dtype =get_dtype(NULL, pathname, pathlen); 761if(*dtype != DT_DIR) 762continue; 763} 764 765if(x->flags & EXC_FLAG_NODIR) { 766if(match_basename(basename, 767 pathlen - (basename - pathname), 768 exclude, prefix, x->patternlen, 769 x->flags)) 770return x; 771continue; 772} 773 774assert(x->baselen ==0|| x->base[x->baselen -1] =='/'); 775if(match_pathname(pathname, pathlen, 776 x->base, x->baselen ? x->baselen -1:0, 777 exclude, prefix, x->patternlen, x->flags)) 778return x; 779} 780return NULL;/* undecided */ 781} 782 783/* 784 * Scan the list and let the last match determine the fate. 785 * Return 1 for exclude, 0 for include and -1 for undecided. 786 */ 787intis_excluded_from_list(const char*pathname, 788int pathlen,const char*basename,int*dtype, 789struct exclude_list *el) 790{ 791struct exclude *exclude; 792 exclude =last_exclude_matching_from_list(pathname, pathlen, basename, dtype, el); 793if(exclude) 794return exclude->flags & EXC_FLAG_NEGATIVE ?0:1; 795return-1;/* undecided */ 796} 797 798/* 799 * Loads the exclude lists for the directory containing pathname, then 800 * scans all exclude lists to determine whether pathname is excluded. 801 * Returns the exclude_list element which matched, or NULL for 802 * undecided. 803 */ 804static struct exclude *last_exclude_matching(struct dir_struct *dir, 805const char*pathname, 806int*dtype_p) 807{ 808int pathlen =strlen(pathname); 809int i, j; 810struct exclude_list_group *group; 811struct exclude *exclude; 812const char*basename =strrchr(pathname,'/'); 813 basename = (basename) ? basename+1: pathname; 814 815prep_exclude(dir, pathname, basename-pathname); 816 817for(i = EXC_CMDL; i <= EXC_FILE; i++) { 818 group = &dir->exclude_list_group[i]; 819for(j = group->nr -1; j >=0; j--) { 820 exclude =last_exclude_matching_from_list( 821 pathname, pathlen, basename, dtype_p, 822&group->el[j]); 823if(exclude) 824return exclude; 825} 826} 827return NULL; 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 1 if true, otherwise 0. 834 */ 835static intis_excluded(struct dir_struct *dir,const char*pathname,int*dtype_p) 836{ 837struct exclude *exclude = 838last_exclude_matching(dir, pathname, dtype_p); 839if(exclude) 840return exclude->flags & EXC_FLAG_NEGATIVE ?0:1; 841return0; 842} 843 844voidpath_exclude_check_init(struct path_exclude_check *check, 845struct dir_struct *dir) 846{ 847 check->dir = dir; 848 check->exclude = NULL; 849strbuf_init(&check->path,256); 850} 851 852voidpath_exclude_check_clear(struct path_exclude_check *check) 853{ 854strbuf_release(&check->path); 855} 856 857/* 858 * For each subdirectory in name, starting with the top-most, checks 859 * to see if that subdirectory is excluded, and if so, returns the 860 * corresponding exclude structure. Otherwise, checks whether name 861 * itself (which is presumably a file) is excluded. 862 * 863 * A path to a directory known to be excluded is left in check->path to 864 * optimize for repeated checks for files in the same excluded directory. 865 */ 866struct exclude *last_exclude_matching_path(struct path_exclude_check *check, 867const char*name,int namelen, 868int*dtype) 869{ 870int i; 871struct strbuf *path = &check->path; 872struct exclude *exclude; 873 874/* 875 * we allow the caller to pass namelen as an optimization; it 876 * must match the length of the name, as we eventually call 877 * is_excluded() on the whole name string. 878 */ 879if(namelen <0) 880 namelen =strlen(name); 881 882/* 883 * If path is non-empty, and name is equal to path or a 884 * subdirectory of path, name should be excluded, because 885 * it's inside a directory which is already known to be 886 * excluded and was previously left in check->path. 887 */ 888if(path->len && 889 path->len <= namelen && 890!memcmp(name, path->buf, path->len) && 891(!name[path->len] || name[path->len] =='/')) 892return check->exclude; 893 894strbuf_setlen(path,0); 895for(i =0; name[i]; i++) { 896int ch = name[i]; 897 898if(ch =='/') { 899int dt = DT_DIR; 900 exclude =last_exclude_matching(check->dir, 901 path->buf, &dt); 902if(exclude) { 903 check->exclude = exclude; 904return exclude; 905} 906} 907strbuf_addch(path, ch); 908} 909 910/* An entry in the index; cannot be a directory with subentries */ 911strbuf_setlen(path,0); 912 913returnlast_exclude_matching(check->dir, name, dtype); 914} 915 916/* 917 * Is this name excluded? This is for a caller like show_files() that 918 * do not honor directory hierarchy and iterate through paths that are 919 * possibly in an ignored directory. 920 */ 921intis_path_excluded(struct path_exclude_check *check, 922const char*name,int namelen,int*dtype) 923{ 924struct exclude *exclude = 925last_exclude_matching_path(check, name, namelen, dtype); 926if(exclude) 927return exclude->flags & EXC_FLAG_NEGATIVE ?0:1; 928return0; 929} 930 931static struct dir_entry *dir_entry_new(const char*pathname,int len) 932{ 933struct dir_entry *ent; 934 935 ent =xmalloc(sizeof(*ent) + len +1); 936 ent->len = len; 937memcpy(ent->name, pathname, len); 938 ent->name[len] =0; 939return ent; 940} 941 942static struct dir_entry *dir_add_name(struct dir_struct *dir,const char*pathname,int len) 943{ 944if(!(dir->flags & DIR_SHOW_IGNORED) && 945cache_name_exists(pathname, len, ignore_case)) 946return NULL; 947 948ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc); 949return dir->entries[dir->nr++] =dir_entry_new(pathname, len); 950} 951 952struct dir_entry *dir_add_ignored(struct dir_struct *dir,const char*pathname,int len) 953{ 954if(!cache_name_is_other(pathname, len)) 955return NULL; 956 957ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc); 958return dir->ignored[dir->ignored_nr++] =dir_entry_new(pathname, len); 959} 960 961enum exist_status { 962 index_nonexistent =0, 963 index_directory, 964 index_gitdir 965}; 966 967/* 968 * Do not use the alphabetically stored index to look up 969 * the directory name; instead, use the case insensitive 970 * name hash. 971 */ 972static enum exist_status directory_exists_in_index_icase(const char*dirname,int len) 973{ 974struct cache_entry *ce =index_name_exists(&the_index, dirname, len +1, ignore_case); 975unsigned char endchar; 976 977if(!ce) 978return index_nonexistent; 979 endchar = ce->name[len]; 980 981/* 982 * The cache_entry structure returned will contain this dirname 983 * and possibly additional path components. 984 */ 985if(endchar =='/') 986return index_directory; 987 988/* 989 * If there are no additional path components, then this cache_entry 990 * represents a submodule. Submodules, despite being directories, 991 * are stored in the cache without a closing slash. 992 */ 993if(!endchar &&S_ISGITLINK(ce->ce_mode)) 994return index_gitdir; 995 996/* This should never be hit, but it exists just in case. */ 997return index_nonexistent; 998} 9991000/*1001 * The index sorts alphabetically by entry name, which1002 * means that a gitlink sorts as '\0' at the end, while1003 * a directory (which is defined not as an entry, but as1004 * the files it contains) will sort with the '/' at the1005 * end.1006 */1007static enum exist_status directory_exists_in_index(const char*dirname,int len)1008{1009int pos;10101011if(ignore_case)1012returndirectory_exists_in_index_icase(dirname, len);10131014 pos =cache_name_pos(dirname, len);1015if(pos <0)1016 pos = -pos-1;1017while(pos < active_nr) {1018struct cache_entry *ce = active_cache[pos++];1019unsigned char endchar;10201021if(strncmp(ce->name, dirname, len))1022break;1023 endchar = ce->name[len];1024if(endchar >'/')1025break;1026if(endchar =='/')1027return index_directory;1028if(!endchar &&S_ISGITLINK(ce->ce_mode))1029return index_gitdir;1030}1031return index_nonexistent;1032}10331034/*1035 * When we find a directory when traversing the filesystem, we1036 * have three distinct cases:1037 *1038 * - ignore it1039 * - see it as a directory1040 * - recurse into it1041 *1042 * and which one we choose depends on a combination of existing1043 * git index contents and the flags passed into the directory1044 * traversal routine.1045 *1046 * Case 1: If we *already* have entries in the index under that1047 * directory name, we recurse into the directory to see all the files,1048 * unless the directory is excluded and we want to show ignored1049 * directories1050 *1051 * Case 2: If we *already* have that directory name as a gitlink,1052 * we always continue to see it as a gitlink, regardless of whether1053 * there is an actual git directory there or not (it might not1054 * be checked out as a subproject!)1055 *1056 * Case 3: if we didn't have it in the index previously, we1057 * have a few sub-cases:1058 *1059 * (a) if "show_other_directories" is true, we show it as1060 * just a directory, unless "hide_empty_directories" is1061 * also true and the directory is empty, in which case1062 * we just ignore it entirely.1063 * if we are looking for ignored directories, look if it1064 * contains only ignored files to decide if it must be shown as1065 * ignored or not.1066 * (b) if it looks like a git directory, and we don't have1067 * 'no_gitlinks' set we treat it as a gitlink, and show it1068 * as a directory.1069 * (c) otherwise, we recurse into it.1070 */1071enum directory_treatment {1072 show_directory,1073 ignore_directory,1074 recurse_into_directory1075};10761077static enum directory_treatment treat_directory(struct dir_struct *dir,1078const char*dirname,int len,int exclude,1079const struct path_simplify *simplify)1080{1081/* The "len-1" is to strip the final '/' */1082switch(directory_exists_in_index(dirname, len-1)) {1083case index_directory:1084if((dir->flags & DIR_SHOW_OTHER_DIRECTORIES) && exclude)1085break;10861087return recurse_into_directory;10881089case index_gitdir:1090if(dir->flags & DIR_SHOW_OTHER_DIRECTORIES)1091return ignore_directory;1092return show_directory;10931094case index_nonexistent:1095if(dir->flags & DIR_SHOW_OTHER_DIRECTORIES)1096break;1097if(!(dir->flags & DIR_NO_GITLINKS)) {1098unsigned char sha1[20];1099if(resolve_gitlink_ref(dirname,"HEAD", sha1) ==0)1100return show_directory;1101}1102return recurse_into_directory;1103}11041105/* This is the "show_other_directories" case */11061107/* might be a sub directory in an excluded directory */1108if(!exclude) {1109struct path_exclude_check check;1110int dt = DT_DIR;1111path_exclude_check_init(&check, dir);1112 exclude =is_path_excluded(&check, dirname, len, &dt);1113path_exclude_check_clear(&check);1114}11151116/*1117 * We are looking for ignored files and our directory is not ignored,1118 * check if it contains only ignored files1119 */1120if((dir->flags & DIR_SHOW_IGNORED) && !exclude) {1121int ignored;1122 dir->flags &= ~DIR_SHOW_IGNORED;1123 dir->flags |= DIR_HIDE_EMPTY_DIRECTORIES;1124 ignored =read_directory_recursive(dir, dirname, len,1, simplify);1125 dir->flags &= ~DIR_HIDE_EMPTY_DIRECTORIES;1126 dir->flags |= DIR_SHOW_IGNORED;11271128return ignored ? ignore_directory : show_directory;1129}1130if(!(dir->flags & DIR_SHOW_IGNORED) &&1131!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1132return show_directory;1133if(!read_directory_recursive(dir, dirname, len,1, simplify))1134return ignore_directory;1135return show_directory;1136}11371138/*1139 * Decide what to do when we find a file while traversing the1140 * filesystem. Mostly two cases:1141 *1142 * 1. We are looking for ignored files1143 * (a) File is ignored, include it1144 * (b) File is in ignored path, include it1145 * (c) File is not ignored, exclude it1146 *1147 * 2. Other scenarios, include the file if not excluded1148 *1149 * Return 1 for exclude, 0 for include.1150 */1151static inttreat_file(struct dir_struct *dir,struct strbuf *path,int exclude,int*dtype)1152{1153struct path_exclude_check check;1154int exclude_file =0;11551156/* Always exclude indexed files */1157if(index_name_exists(&the_index, path->buf, path->len, ignore_case))1158return1;11591160if(exclude)1161 exclude_file = !(dir->flags & DIR_SHOW_IGNORED);1162else if(dir->flags & DIR_SHOW_IGNORED) {1163path_exclude_check_init(&check, dir);11641165if(!is_path_excluded(&check, path->buf, path->len, dtype))1166 exclude_file =1;11671168path_exclude_check_clear(&check);1169}11701171return exclude_file;1172}11731174/*1175 * This is an inexact early pruning of any recursive directory1176 * reading - if the path cannot possibly be in the pathspec,1177 * return true, and we'll skip it early.1178 */1179static intsimplify_away(const char*path,int pathlen,const struct path_simplify *simplify)1180{1181if(simplify) {1182for(;;) {1183const char*match = simplify->path;1184int len = simplify->len;11851186if(!match)1187break;1188if(len > pathlen)1189 len = pathlen;1190if(!memcmp(path, match, len))1191return0;1192 simplify++;1193}1194return1;1195}1196return0;1197}11981199/*1200 * This function tells us whether an excluded path matches a1201 * list of "interesting" pathspecs. That is, whether a path matched1202 * by any of the pathspecs could possibly be ignored by excluding1203 * the specified path. This can happen if:1204 *1205 * 1. the path is mentioned explicitly in the pathspec1206 *1207 * 2. the path is a directory prefix of some element in the1208 * pathspec1209 */1210static intexclude_matches_pathspec(const char*path,int len,1211const struct path_simplify *simplify)1212{1213if(simplify) {1214for(; simplify->path; simplify++) {1215if(len == simplify->len1216&& !memcmp(path, simplify->path, len))1217return1;1218if(len < simplify->len1219&& simplify->path[len] =='/'1220&& !memcmp(path, simplify->path, len))1221return1;1222}1223}1224return0;1225}12261227static intget_index_dtype(const char*path,int len)1228{1229int pos;1230struct cache_entry *ce;12311232 ce =cache_name_exists(path, len,0);1233if(ce) {1234if(!ce_uptodate(ce))1235return DT_UNKNOWN;1236if(S_ISGITLINK(ce->ce_mode))1237return DT_DIR;1238/*1239 * Nobody actually cares about the1240 * difference between DT_LNK and DT_REG1241 */1242return DT_REG;1243}12441245/* Try to look it up as a directory */1246 pos =cache_name_pos(path, len);1247if(pos >=0)1248return DT_UNKNOWN;1249 pos = -pos-1;1250while(pos < active_nr) {1251 ce = active_cache[pos++];1252if(strncmp(ce->name, path, len))1253break;1254if(ce->name[len] >'/')1255break;1256if(ce->name[len] <'/')1257continue;1258if(!ce_uptodate(ce))1259break;/* continue? */1260return DT_DIR;1261}1262return DT_UNKNOWN;1263}12641265static intget_dtype(struct dirent *de,const char*path,int len)1266{1267int dtype = de ?DTYPE(de) : DT_UNKNOWN;1268struct stat st;12691270if(dtype != DT_UNKNOWN)1271return dtype;1272 dtype =get_index_dtype(path, len);1273if(dtype != DT_UNKNOWN)1274return dtype;1275if(lstat(path, &st))1276return dtype;1277if(S_ISREG(st.st_mode))1278return DT_REG;1279if(S_ISDIR(st.st_mode))1280return DT_DIR;1281if(S_ISLNK(st.st_mode))1282return DT_LNK;1283return dtype;1284}12851286enum path_treatment {1287 path_ignored,1288 path_handled,1289 path_recurse1290};12911292static enum path_treatment treat_one_path(struct dir_struct *dir,1293struct strbuf *path,1294const struct path_simplify *simplify,1295int dtype,struct dirent *de)1296{1297int exclude =is_excluded(dir, path->buf, &dtype);1298if(exclude && (dir->flags & DIR_COLLECT_IGNORED)1299&&exclude_matches_pathspec(path->buf, path->len, simplify))1300dir_add_ignored(dir, path->buf, path->len);13011302/*1303 * Excluded? If we don't explicitly want to show1304 * ignored files, ignore it1305 */1306if(exclude && !(dir->flags & DIR_SHOW_IGNORED))1307return path_ignored;13081309if(dtype == DT_UNKNOWN)1310 dtype =get_dtype(de, path->buf, path->len);13111312switch(dtype) {1313default:1314return path_ignored;1315case DT_DIR:1316strbuf_addch(path,'/');1317switch(treat_directory(dir, path->buf, path->len, exclude, simplify)) {1318case show_directory:1319break;1320case recurse_into_directory:1321return path_recurse;1322case ignore_directory:1323return path_ignored;1324}1325break;1326case DT_REG:1327case DT_LNK:1328switch(treat_file(dir, path, exclude, &dtype)) {1329case1:1330return path_ignored;1331default:1332break;1333}1334}1335return path_handled;1336}13371338static enum path_treatment treat_path(struct dir_struct *dir,1339struct dirent *de,1340struct strbuf *path,1341int baselen,1342const struct path_simplify *simplify)1343{1344int dtype;13451346if(is_dot_or_dotdot(de->d_name) || !strcmp(de->d_name,".git"))1347return path_ignored;1348strbuf_setlen(path, baselen);1349strbuf_addstr(path, de->d_name);1350if(simplify_away(path->buf, path->len, simplify))1351return path_ignored;13521353 dtype =DTYPE(de);1354returntreat_one_path(dir, path, simplify, dtype, de);1355}13561357/*1358 * Read a directory tree. We currently ignore anything but1359 * directories, regular files and symlinks. That's because git1360 * doesn't handle them at all yet. Maybe that will change some1361 * day.1362 *1363 * Also, we ignore the name ".git" (even if it is not a directory).1364 * That likely will not change.1365 */1366static intread_directory_recursive(struct dir_struct *dir,1367const char*base,int baselen,1368int check_only,1369const struct path_simplify *simplify)1370{1371DIR*fdir;1372int contents =0;1373struct dirent *de;1374struct strbuf path = STRBUF_INIT;13751376strbuf_add(&path, base, baselen);13771378 fdir =opendir(path.len ? path.buf :".");1379if(!fdir)1380goto out;13811382while((de =readdir(fdir)) != NULL) {1383switch(treat_path(dir, de, &path, baselen, simplify)) {1384case path_recurse:1385 contents +=read_directory_recursive(dir, path.buf,1386 path.len, check_only, simplify);1387continue;1388case path_ignored:1389continue;1390case path_handled:1391break;1392}1393 contents++;1394if(check_only)1395break;1396dir_add_name(dir, path.buf, path.len);1397}1398closedir(fdir);1399 out:1400strbuf_release(&path);14011402return contents;1403}14041405static intcmp_name(const void*p1,const void*p2)1406{1407const struct dir_entry *e1 = *(const struct dir_entry **)p1;1408const struct dir_entry *e2 = *(const struct dir_entry **)p2;14091410returncache_name_compare(e1->name, e1->len,1411 e2->name, e2->len);1412}14131414static struct path_simplify *create_simplify(const char**pathspec)1415{1416int nr, alloc =0;1417struct path_simplify *simplify = NULL;14181419if(!pathspec)1420return NULL;14211422for(nr =0; ; nr++) {1423const char*match;1424if(nr >= alloc) {1425 alloc =alloc_nr(alloc);1426 simplify =xrealloc(simplify, alloc *sizeof(*simplify));1427}1428 match = *pathspec++;1429if(!match)1430break;1431 simplify[nr].path = match;1432 simplify[nr].len =simple_length(match);1433}1434 simplify[nr].path = NULL;1435 simplify[nr].len =0;1436return simplify;1437}14381439static voidfree_simplify(struct path_simplify *simplify)1440{1441free(simplify);1442}14431444static inttreat_leading_path(struct dir_struct *dir,1445const char*path,int len,1446const struct path_simplify *simplify)1447{1448struct strbuf sb = STRBUF_INIT;1449int baselen, rc =0;1450const char*cp;14511452while(len && path[len -1] =='/')1453 len--;1454if(!len)1455return1;1456 baselen =0;1457while(1) {1458 cp = path + baselen + !!baselen;1459 cp =memchr(cp,'/', path + len - cp);1460if(!cp)1461 baselen = len;1462else1463 baselen = cp - path;1464strbuf_setlen(&sb,0);1465strbuf_add(&sb, path, baselen);1466if(!is_directory(sb.buf))1467break;1468if(simplify_away(sb.buf, sb.len, simplify))1469break;1470if(treat_one_path(dir, &sb, simplify,1471 DT_DIR, NULL) == path_ignored)1472break;/* do not recurse into it */1473if(len <= baselen) {1474 rc =1;1475break;/* finished checking */1476}1477}1478strbuf_release(&sb);1479return rc;1480}14811482intread_directory(struct dir_struct *dir,const char*path,int len,const char**pathspec)1483{1484struct path_simplify *simplify;14851486if(has_symlink_leading_path(path, len))1487return dir->nr;14881489 simplify =create_simplify(pathspec);1490if(!len ||treat_leading_path(dir, path, len, simplify))1491read_directory_recursive(dir, path, len,0, simplify);1492free_simplify(simplify);1493qsort(dir->entries, dir->nr,sizeof(struct dir_entry *), cmp_name);1494qsort(dir->ignored, dir->ignored_nr,sizeof(struct dir_entry *), cmp_name);1495return dir->nr;1496}14971498intfile_exists(const char*f)1499{1500struct stat sb;1501returnlstat(f, &sb) ==0;1502}15031504/*1505 * Given two normalized paths (a trailing slash is ok), if subdir is1506 * outside dir, return -1. Otherwise return the offset in subdir that1507 * can be used as relative path to dir.1508 */1509intdir_inside_of(const char*subdir,const char*dir)1510{1511int offset =0;15121513assert(dir && subdir && *dir && *subdir);15141515while(*dir && *subdir && *dir == *subdir) {1516 dir++;1517 subdir++;1518 offset++;1519}15201521/* hel[p]/me vs hel[l]/yeah */1522if(*dir && *subdir)1523return-1;15241525if(!*subdir)1526return!*dir ? offset : -1;/* same dir */15271528/* foo/[b]ar vs foo/[] */1529if(is_dir_sep(dir[-1]))1530returnis_dir_sep(subdir[-1]) ? offset : -1;15311532/* foo[/]bar vs foo[] */1533returnis_dir_sep(*subdir) ? offset +1: -1;1534}15351536intis_inside_dir(const char*dir)1537{1538char cwd[PATH_MAX];1539if(!dir)1540return0;1541if(!getcwd(cwd,sizeof(cwd)))1542die_errno("can't find the current directory");1543returndir_inside_of(cwd, dir) >=0;1544}15451546intis_empty_dir(const char*path)1547{1548DIR*dir =opendir(path);1549struct dirent *e;1550int ret =1;15511552if(!dir)1553return0;15541555while((e =readdir(dir)) != NULL)1556if(!is_dot_or_dotdot(e->d_name)) {1557 ret =0;1558break;1559}15601561closedir(dir);1562return ret;1563}15641565static intremove_dir_recurse(struct strbuf *path,int flag,int*kept_up)1566{1567DIR*dir;1568struct dirent *e;1569int ret =0, original_len = path->len, len, kept_down =0;1570int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);1571int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);1572unsigned char submodule_head[20];15731574if((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&1575!resolve_gitlink_ref(path->buf,"HEAD", submodule_head)) {1576/* Do not descend and nuke a nested git work tree. */1577if(kept_up)1578*kept_up =1;1579return0;1580}15811582 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;1583 dir =opendir(path->buf);1584if(!dir) {1585/* an empty dir could be removed even if it is unreadble */1586if(!keep_toplevel)1587returnrmdir(path->buf);1588else1589return-1;1590}1591if(path->buf[original_len -1] !='/')1592strbuf_addch(path,'/');15931594 len = path->len;1595while((e =readdir(dir)) != NULL) {1596struct stat st;1597if(is_dot_or_dotdot(e->d_name))1598continue;15991600strbuf_setlen(path, len);1601strbuf_addstr(path, e->d_name);1602if(lstat(path->buf, &st))1603;/* fall thru */1604else if(S_ISDIR(st.st_mode)) {1605if(!remove_dir_recurse(path, flag, &kept_down))1606continue;/* happy */1607}else if(!only_empty && !unlink(path->buf))1608continue;/* happy, too */16091610/* path too long, stat fails, or non-directory still exists */1611 ret = -1;1612break;1613}1614closedir(dir);16151616strbuf_setlen(path, original_len);1617if(!ret && !keep_toplevel && !kept_down)1618 ret =rmdir(path->buf);1619else if(kept_up)1620/*1621 * report the uplevel that it is not an error that we1622 * did not rmdir() our directory.1623 */1624*kept_up = !ret;1625return ret;1626}16271628intremove_dir_recursively(struct strbuf *path,int flag)1629{1630returnremove_dir_recurse(path, flag, NULL);1631}16321633voidsetup_standard_excludes(struct dir_struct *dir)1634{1635const char*path;1636char*xdg_path;16371638 dir->exclude_per_dir =".gitignore";1639 path =git_path("info/exclude");1640if(!excludes_file) {1641home_config_paths(NULL, &xdg_path,"ignore");1642 excludes_file = xdg_path;1643}1644if(!access_or_warn(path, R_OK))1645add_excludes_from_file(dir, path);1646if(excludes_file && !access_or_warn(excludes_file, R_OK))1647add_excludes_from_file(dir, excludes_file);1648}16491650intremove_path(const char*name)1651{1652char*slash;16531654if(unlink(name) && errno != ENOENT && errno != ENOTDIR)1655return-1;16561657 slash =strrchr(name,'/');1658if(slash) {1659char*dirs =xstrdup(name);1660 slash = dirs + (slash - name);1661do{1662*slash ='\0';1663}while(rmdir(dirs) ==0&& (slash =strrchr(dirs,'/')));1664free(dirs);1665}1666return0;1667}16681669static intpathspec_item_cmp(const void*a_,const void*b_)1670{1671struct pathspec_item *a, *b;16721673 a = (struct pathspec_item *)a_;1674 b = (struct pathspec_item *)b_;1675returnstrcmp(a->match, b->match);1676}16771678intinit_pathspec(struct pathspec *pathspec,const char**paths)1679{1680const char**p = paths;1681int i;16821683memset(pathspec,0,sizeof(*pathspec));1684if(!p)1685return0;1686while(*p)1687 p++;1688 pathspec->raw = paths;1689 pathspec->nr = p - paths;1690if(!pathspec->nr)1691return0;16921693 pathspec->items =xmalloc(sizeof(struct pathspec_item)*pathspec->nr);1694for(i =0; i < pathspec->nr; i++) {1695struct pathspec_item *item = pathspec->items+i;1696const char*path = paths[i];16971698 item->match = path;1699 item->len =strlen(path);1700 item->flags =0;1701if(limit_pathspec_to_literal()) {1702 item->nowildcard_len = item->len;1703}else{1704 item->nowildcard_len =simple_length(path);1705if(item->nowildcard_len < item->len) {1706 pathspec->has_wildcard =1;1707if(path[item->nowildcard_len] =='*'&&1708no_wildcard(path + item->nowildcard_len +1))1709 item->flags |= PATHSPEC_ONESTAR;1710}1711}1712}17131714qsort(pathspec->items, pathspec->nr,1715sizeof(struct pathspec_item), pathspec_item_cmp);17161717return0;1718}17191720voidfree_pathspec(struct pathspec *pathspec)1721{1722free(pathspec->items);1723 pathspec->items = NULL;1724}17251726intlimit_pathspec_to_literal(void)1727{1728static int flag = -1;1729if(flag <0)1730 flag =git_env_bool(GIT_LITERAL_PATHSPECS_ENVIRONMENT,0);1731return flag;1732}17331734/*1735 * Frees memory within dir which was allocated for exclude lists and1736 * the exclude_stack. Does not free dir itself.1737 */1738voidclear_directory(struct dir_struct *dir)1739{1740int i, j;1741struct exclude_list_group *group;1742struct exclude_list *el;1743struct exclude_stack *stk;17441745for(i = EXC_CMDL; i <= EXC_FILE; i++) {1746 group = &dir->exclude_list_group[i];1747for(j =0; j < group->nr; j++) {1748 el = &group->el[j];1749if(i == EXC_DIRS)1750free((char*)el->src);1751clear_exclude_list(el);1752}1753free(group->el);1754}17551756 stk = dir->exclude_stack;1757while(stk) {1758struct exclude_stack *prev = stk->prev;1759free(stk);1760 stk = prev;1761}1762}