mirror of
https://github.com/git/git
synced 2024-08-26 19:19:18 +00:00
![Elijah Newren](/assets/img/avatar_default.png)
Provide more statistics in trace2 output that include the number of directories and total paths visited by the directory traversal logic. Subsequent patches will take advantage of this to ensure we do not unnecessarily traverse into ignored directories. Signed-off-by: Elijah Newren <newren@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
551 lines
17 KiB
C
551 lines
17 KiB
C
#ifndef DIR_H
|
|
#define DIR_H
|
|
|
|
#include "cache.h"
|
|
#include "hashmap.h"
|
|
#include "strbuf.h"
|
|
|
|
/**
|
|
* The directory listing API is used to enumerate paths in the work tree,
|
|
* optionally taking `.git/info/exclude` and `.gitignore` files per directory
|
|
* into account.
|
|
*/
|
|
|
|
/**
|
|
* Calling sequence
|
|
* ----------------
|
|
*
|
|
* Note: The index may be checked for .gitignore files that are
|
|
* CE_SKIP_WORKTREE marked. If you want to exclude files, make sure you have
|
|
* loaded the index first.
|
|
*
|
|
* - Prepare `struct dir_struct dir` using `dir_init()` function.
|
|
*
|
|
* - To add single exclude pattern, call `add_pattern_list()` and then
|
|
* `add_pattern()`.
|
|
*
|
|
* - To add patterns from a file (e.g. `.git/info/exclude`), call
|
|
* `add_patterns_from_file()` , and/or set `dir.exclude_per_dir`.
|
|
*
|
|
* - A short-hand function `setup_standard_excludes()` can be used to set
|
|
* up the standard set of exclude settings, instead of manually calling
|
|
* the add_pattern*() family of functions.
|
|
*
|
|
* - Call `fill_directory()`.
|
|
*
|
|
* - Use `dir.entries[]` and `dir.ignored[]`.
|
|
*
|
|
* - Call `dir_clear()` when the contained elements are no longer in use.
|
|
*
|
|
*/
|
|
|
|
struct dir_entry {
|
|
unsigned int len;
|
|
char name[FLEX_ARRAY]; /* more */
|
|
};
|
|
|
|
#define PATTERN_FLAG_NODIR 1
|
|
#define PATTERN_FLAG_ENDSWITH 4
|
|
#define PATTERN_FLAG_MUSTBEDIR 8
|
|
#define PATTERN_FLAG_NEGATIVE 16
|
|
|
|
struct path_pattern {
|
|
/*
|
|
* This allows callers of last_matching_pattern() etc.
|
|
* to determine the origin of the matching pattern.
|
|
*/
|
|
struct pattern_list *pl;
|
|
|
|
const char *pattern;
|
|
int patternlen;
|
|
int nowildcardlen;
|
|
const char *base;
|
|
int baselen;
|
|
unsigned flags; /* PATTERN_FLAG_* */
|
|
|
|
/*
|
|
* Counting starts from 1 for line numbers in ignore files,
|
|
* and from -1 decrementing for patterns from CLI args.
|
|
*/
|
|
int srcpos;
|
|
};
|
|
|
|
/* used for hashmaps for cone patterns */
|
|
struct pattern_entry {
|
|
struct hashmap_entry ent;
|
|
char *pattern;
|
|
size_t patternlen;
|
|
};
|
|
|
|
/*
|
|
* Each excludes file will be parsed into a fresh exclude_list which
|
|
* is appended to the relevant exclude_list_group (either EXC_DIRS or
|
|
* EXC_FILE). An exclude_list within the EXC_CMDL exclude_list_group
|
|
* can also be used to represent the list of --exclude values passed
|
|
* via CLI args.
|
|
*/
|
|
struct pattern_list {
|
|
int nr;
|
|
int alloc;
|
|
|
|
/* remember pointer to exclude file contents so we can free() */
|
|
char *filebuf;
|
|
|
|
/* origin of list, e.g. path to filename, or descriptive string */
|
|
const char *src;
|
|
|
|
struct path_pattern **patterns;
|
|
|
|
/*
|
|
* While scanning the excludes, we attempt to match the patterns
|
|
* with a more restricted set that allows us to use hashsets for
|
|
* matching logic, which is faster than the linear lookup in the
|
|
* excludes array above. If non-zero, that check succeeded.
|
|
*/
|
|
unsigned use_cone_patterns;
|
|
unsigned full_cone;
|
|
|
|
/*
|
|
* Stores paths where everything starting with those paths
|
|
* is included.
|
|
*/
|
|
struct hashmap recursive_hashmap;
|
|
|
|
/*
|
|
* Used to check single-level parents of blobs.
|
|
*/
|
|
struct hashmap parent_hashmap;
|
|
};
|
|
|
|
/*
|
|
* The contents of the per-directory exclude files are lazily read on
|
|
* demand and then cached in memory, one per exclude_stack struct, in
|
|
* order to avoid opening and parsing each one every time that
|
|
* directory is traversed.
|
|
*/
|
|
struct exclude_stack {
|
|
struct exclude_stack *prev; /* the struct exclude_stack for the parent directory */
|
|
int baselen;
|
|
int exclude_ix; /* index of exclude_list within EXC_DIRS exclude_list_group */
|
|
struct untracked_cache_dir *ucd;
|
|
};
|
|
|
|
struct exclude_list_group {
|
|
int nr, alloc;
|
|
struct pattern_list *pl;
|
|
};
|
|
|
|
struct oid_stat {
|
|
struct stat_data stat;
|
|
struct object_id oid;
|
|
int valid;
|
|
};
|
|
|
|
/*
|
|
* Untracked cache
|
|
*
|
|
* The following inputs are sufficient to determine what files in a
|
|
* directory are excluded:
|
|
*
|
|
* - The list of files and directories of the directory in question
|
|
* - The $GIT_DIR/index
|
|
* - dir_struct flags
|
|
* - The content of $GIT_DIR/info/exclude
|
|
* - The content of core.excludesfile
|
|
* - The content (or the lack) of .gitignore of all parent directories
|
|
* from $GIT_WORK_TREE
|
|
* - The check_only flag in read_directory_recursive (for
|
|
* DIR_HIDE_EMPTY_DIRECTORIES)
|
|
*
|
|
* The first input can be checked using directory mtime. In many
|
|
* filesystems, directory mtime (stat_data field) is updated when its
|
|
* files or direct subdirs are added or removed.
|
|
*
|
|
* The second one can be hooked from cache_tree_invalidate_path().
|
|
* Whenever a file (or a submodule) is added or removed from a
|
|
* directory, we invalidate that directory.
|
|
*
|
|
* The remaining inputs are easy, their SHA-1 could be used to verify
|
|
* their contents (exclude_sha1[], info_exclude_sha1[] and
|
|
* excludes_file_sha1[])
|
|
*/
|
|
struct untracked_cache_dir {
|
|
struct untracked_cache_dir **dirs;
|
|
char **untracked;
|
|
struct stat_data stat_data;
|
|
unsigned int untracked_alloc, dirs_nr, dirs_alloc;
|
|
unsigned int untracked_nr;
|
|
unsigned int check_only : 1;
|
|
/* all data except 'dirs' in this struct are good */
|
|
unsigned int valid : 1;
|
|
unsigned int recurse : 1;
|
|
/* null object ID means this directory does not have .gitignore */
|
|
struct object_id exclude_oid;
|
|
char name[FLEX_ARRAY];
|
|
};
|
|
|
|
struct untracked_cache {
|
|
struct oid_stat ss_info_exclude;
|
|
struct oid_stat ss_excludes_file;
|
|
const char *exclude_per_dir;
|
|
struct strbuf ident;
|
|
/*
|
|
* dir_struct#flags must match dir_flags or the untracked
|
|
* cache is ignored.
|
|
*/
|
|
unsigned dir_flags;
|
|
struct untracked_cache_dir *root;
|
|
/* Statistics */
|
|
int dir_created;
|
|
int gitignore_invalidated;
|
|
int dir_invalidated;
|
|
int dir_opened;
|
|
/* fsmonitor invalidation data */
|
|
unsigned int use_fsmonitor : 1;
|
|
};
|
|
|
|
/**
|
|
* structure is used to pass directory traversal options to the library and to
|
|
* record the paths discovered. A single `struct dir_struct` is used regardless
|
|
* of whether or not the traversal recursively descends into subdirectories.
|
|
*/
|
|
struct dir_struct {
|
|
|
|
/* The number of members in `entries[]` array. */
|
|
int nr;
|
|
|
|
/* Internal use; keeps track of allocation of `entries[]` array.*/
|
|
int alloc;
|
|
|
|
/* The number of members in `ignored[]` array. */
|
|
int ignored_nr;
|
|
|
|
int ignored_alloc;
|
|
|
|
/* bit-field of options */
|
|
enum {
|
|
|
|
/**
|
|
* Return just ignored files in `entries[]`, not untracked files.
|
|
* This flag is mutually exclusive with `DIR_SHOW_IGNORED_TOO`.
|
|
*/
|
|
DIR_SHOW_IGNORED = 1<<0,
|
|
|
|
/* Include a directory that is not tracked. */
|
|
DIR_SHOW_OTHER_DIRECTORIES = 1<<1,
|
|
|
|
/* Do not include a directory that is not tracked and is empty. */
|
|
DIR_HIDE_EMPTY_DIRECTORIES = 1<<2,
|
|
|
|
/**
|
|
* If set, recurse into a directory that looks like a Git directory.
|
|
* Otherwise it is shown as a directory.
|
|
*/
|
|
DIR_NO_GITLINKS = 1<<3,
|
|
|
|
/**
|
|
* Special mode for git-add. Return ignored files in `ignored[]` and
|
|
* untracked files in `entries[]`. Only returns ignored files that match
|
|
* pathspec exactly (no wildcards). Does not recurse into ignored
|
|
* directories.
|
|
*/
|
|
DIR_COLLECT_IGNORED = 1<<4,
|
|
|
|
/**
|
|
* Similar to `DIR_SHOW_IGNORED`, but return ignored files in
|
|
* `ignored[]` in addition to untracked files in `entries[]`.
|
|
* This flag is mutually exclusive with `DIR_SHOW_IGNORED`.
|
|
*/
|
|
DIR_SHOW_IGNORED_TOO = 1<<5,
|
|
|
|
DIR_COLLECT_KILLED_ONLY = 1<<6,
|
|
|
|
/**
|
|
* Only has meaning if `DIR_SHOW_IGNORED_TOO` is also set; if this is
|
|
* set, the untracked contents of untracked directories are also
|
|
* returned in `entries[]`.
|
|
*/
|
|
DIR_KEEP_UNTRACKED_CONTENTS = 1<<7,
|
|
|
|
/**
|
|
* Only has meaning if `DIR_SHOW_IGNORED_TOO` is also set; if this is
|
|
* set, returns ignored files and directories that match an exclude
|
|
* pattern. If a directory matches an exclude pattern, then the
|
|
* directory is returned and the contained paths are not. A directory
|
|
* that does not match an exclude pattern will not be returned even if
|
|
* all of its contents are ignored. In this case, the contents are
|
|
* returned as individual entries.
|
|
*
|
|
* If this is set, files and directories that explicitly match an ignore
|
|
* pattern are reported. Implicitly ignored directories (directories that
|
|
* do not match an ignore pattern, but whose contents are all ignored)
|
|
* are not reported, instead all of the contents are reported.
|
|
*/
|
|
DIR_SHOW_IGNORED_TOO_MODE_MATCHING = 1<<8,
|
|
|
|
DIR_SKIP_NESTED_GIT = 1<<9
|
|
} flags;
|
|
|
|
/* An array of `struct dir_entry`, each element of which describes a path. */
|
|
struct dir_entry **entries;
|
|
|
|
/**
|
|
* used for ignored paths with the `DIR_SHOW_IGNORED_TOO` and
|
|
* `DIR_COLLECT_IGNORED` flags.
|
|
*/
|
|
struct dir_entry **ignored;
|
|
|
|
/**
|
|
* The name of the file to be read in each directory for excluded files
|
|
* (typically `.gitignore`).
|
|
*/
|
|
const char *exclude_per_dir;
|
|
|
|
/*
|
|
* We maintain three groups of exclude pattern lists:
|
|
*
|
|
* EXC_CMDL lists patterns explicitly given on the command line.
|
|
* EXC_DIRS lists patterns obtained from per-directory ignore files.
|
|
* EXC_FILE lists patterns from fallback ignore files, e.g.
|
|
* - .git/info/exclude
|
|
* - core.excludesfile
|
|
*
|
|
* Each group contains multiple exclude lists, a single list
|
|
* per source.
|
|
*/
|
|
#define EXC_CMDL 0
|
|
#define EXC_DIRS 1
|
|
#define EXC_FILE 2
|
|
struct exclude_list_group exclude_list_group[3];
|
|
|
|
/*
|
|
* Temporary variables which are used during loading of the
|
|
* per-directory exclude lists.
|
|
*
|
|
* exclude_stack points to the top of the exclude_stack, and
|
|
* basebuf contains the full path to the current
|
|
* (sub)directory in the traversal. Exclude points to the
|
|
* matching exclude struct if the directory is excluded.
|
|
*/
|
|
struct exclude_stack *exclude_stack;
|
|
struct path_pattern *pattern;
|
|
struct strbuf basebuf;
|
|
|
|
/* Enable untracked file cache if set */
|
|
struct untracked_cache *untracked;
|
|
struct oid_stat ss_info_exclude;
|
|
struct oid_stat ss_excludes_file;
|
|
unsigned unmanaged_exclude_files;
|
|
|
|
/* Stats about the traversal */
|
|
unsigned visited_paths;
|
|
unsigned visited_directories;
|
|
};
|
|
|
|
/*Count the number of slashes for string s*/
|
|
int count_slashes(const char *s);
|
|
|
|
/*
|
|
* The ordering of these constants is significant, with
|
|
* higher-numbered match types signifying "closer" (i.e. more
|
|
* specific) matches which will override lower-numbered match types
|
|
* when populating the seen[] array.
|
|
*/
|
|
#define MATCHED_RECURSIVELY 1
|
|
#define MATCHED_RECURSIVELY_LEADING_PATHSPEC 2
|
|
#define MATCHED_FNMATCH 3
|
|
#define MATCHED_EXACTLY 4
|
|
int simple_length(const char *match);
|
|
int no_wildcard(const char *string);
|
|
char *common_prefix(const struct pathspec *pathspec);
|
|
int match_pathspec(const struct index_state *istate,
|
|
const struct pathspec *pathspec,
|
|
const char *name, int namelen,
|
|
int prefix, char *seen, int is_dir);
|
|
int report_path_error(const char *ps_matched, const struct pathspec *pathspec);
|
|
int within_depth(const char *name, int namelen, int depth, int max_depth);
|
|
|
|
void dir_init(struct dir_struct *dir);
|
|
|
|
int fill_directory(struct dir_struct *dir,
|
|
struct index_state *istate,
|
|
const struct pathspec *pathspec);
|
|
int read_directory(struct dir_struct *, struct index_state *istate,
|
|
const char *path, int len,
|
|
const struct pathspec *pathspec);
|
|
|
|
enum pattern_match_result {
|
|
UNDECIDED = -1,
|
|
NOT_MATCHED = 0,
|
|
MATCHED = 1,
|
|
MATCHED_RECURSIVE = 2,
|
|
};
|
|
|
|
/*
|
|
* Scan the list of patterns to determine if the ordered list
|
|
* of patterns matches on 'pathname'.
|
|
*
|
|
* Return 1 for a match, 0 for not matched and -1 for undecided.
|
|
*/
|
|
enum pattern_match_result path_matches_pattern_list(const char *pathname,
|
|
int pathlen,
|
|
const char *basename, int *dtype,
|
|
struct pattern_list *pl,
|
|
struct index_state *istate);
|
|
struct dir_entry *dir_add_ignored(struct dir_struct *dir,
|
|
struct index_state *istate,
|
|
const char *pathname, int len);
|
|
|
|
/*
|
|
* these implement the matching logic for dir.c:excluded_from_list and
|
|
* attr.c:path_matches()
|
|
*/
|
|
int match_basename(const char *, int,
|
|
const char *, int, int, unsigned);
|
|
int match_pathname(const char *, int,
|
|
const char *, int,
|
|
const char *, int, int, unsigned);
|
|
|
|
struct path_pattern *last_matching_pattern(struct dir_struct *dir,
|
|
struct index_state *istate,
|
|
const char *name, int *dtype);
|
|
|
|
int is_excluded(struct dir_struct *dir,
|
|
struct index_state *istate,
|
|
const char *name, int *dtype);
|
|
|
|
int pl_hashmap_cmp(const void *unused_cmp_data,
|
|
const struct hashmap_entry *a,
|
|
const struct hashmap_entry *b,
|
|
const void *key);
|
|
int hashmap_contains_parent(struct hashmap *map,
|
|
const char *path,
|
|
struct strbuf *buffer);
|
|
struct pattern_list *add_pattern_list(struct dir_struct *dir,
|
|
int group_type, const char *src);
|
|
int add_patterns_from_file_to_list(const char *fname, const char *base, int baselen,
|
|
struct pattern_list *pl, struct index_state *istate);
|
|
void add_patterns_from_file(struct dir_struct *, const char *fname);
|
|
int add_patterns_from_blob_to_list(struct object_id *oid,
|
|
const char *base, int baselen,
|
|
struct pattern_list *pl);
|
|
void parse_path_pattern(const char **string, int *patternlen, unsigned *flags, int *nowildcardlen);
|
|
void add_pattern(const char *string, const char *base,
|
|
int baselen, struct pattern_list *pl, int srcpos);
|
|
void clear_pattern_list(struct pattern_list *pl);
|
|
void dir_clear(struct dir_struct *dir);
|
|
|
|
int repo_file_exists(struct repository *repo, const char *path);
|
|
int file_exists(const char *);
|
|
|
|
int is_inside_dir(const char *dir);
|
|
int dir_inside_of(const char *subdir, const char *dir);
|
|
|
|
static inline int is_dot_or_dotdot(const char *name)
|
|
{
|
|
return (name[0] == '.' &&
|
|
(name[1] == '\0' ||
|
|
(name[1] == '.' && name[2] == '\0')));
|
|
}
|
|
|
|
int is_empty_dir(const char *dir);
|
|
|
|
void setup_standard_excludes(struct dir_struct *dir);
|
|
|
|
char *get_sparse_checkout_filename(void);
|
|
int get_sparse_checkout_patterns(struct pattern_list *pl);
|
|
|
|
/* Constants for remove_dir_recursively: */
|
|
|
|
/*
|
|
* If a non-directory is found within path, stop and return an error.
|
|
* (In this case some empty directories might already have been
|
|
* removed.)
|
|
*/
|
|
#define REMOVE_DIR_EMPTY_ONLY 01
|
|
|
|
/*
|
|
* If any Git work trees are found within path, skip them without
|
|
* considering it an error.
|
|
*/
|
|
#define REMOVE_DIR_KEEP_NESTED_GIT 02
|
|
|
|
/* Remove the contents of path, but leave path itself. */
|
|
#define REMOVE_DIR_KEEP_TOPLEVEL 04
|
|
|
|
/*
|
|
* Remove path and its contents, recursively. flags is a combination
|
|
* of the above REMOVE_DIR_* constants. Return 0 on success.
|
|
*
|
|
* This function uses path as temporary scratch space, but restores it
|
|
* before returning.
|
|
*/
|
|
int remove_dir_recursively(struct strbuf *path, int flag);
|
|
|
|
/* tries to remove the path with empty directories along it, ignores ENOENT */
|
|
int remove_path(const char *path);
|
|
|
|
int fspathcmp(const char *a, const char *b);
|
|
int fspathncmp(const char *a, const char *b, size_t count);
|
|
|
|
/*
|
|
* The prefix part of pattern must not contains wildcards.
|
|
*/
|
|
struct pathspec_item;
|
|
int git_fnmatch(const struct pathspec_item *item,
|
|
const char *pattern, const char *string,
|
|
int prefix);
|
|
|
|
int submodule_path_match(const struct index_state *istate,
|
|
const struct pathspec *ps,
|
|
const char *submodule_name,
|
|
char *seen);
|
|
|
|
static inline int ce_path_match(const struct index_state *istate,
|
|
const struct cache_entry *ce,
|
|
const struct pathspec *pathspec,
|
|
char *seen)
|
|
{
|
|
return match_pathspec(istate, pathspec, ce->name, ce_namelen(ce), 0, seen,
|
|
S_ISDIR(ce->ce_mode) || S_ISGITLINK(ce->ce_mode));
|
|
}
|
|
|
|
static inline int dir_path_match(const struct index_state *istate,
|
|
const struct dir_entry *ent,
|
|
const struct pathspec *pathspec,
|
|
int prefix, char *seen)
|
|
{
|
|
int has_trailing_dir = ent->len && ent->name[ent->len - 1] == '/';
|
|
int len = has_trailing_dir ? ent->len - 1 : ent->len;
|
|
return match_pathspec(istate, pathspec, ent->name, len, prefix, seen,
|
|
has_trailing_dir);
|
|
}
|
|
|
|
int cmp_dir_entry(const void *p1, const void *p2);
|
|
int check_dir_entry_contains(const struct dir_entry *out, const struct dir_entry *in);
|
|
|
|
void untracked_cache_invalidate_path(struct index_state *, const char *, int safe_path);
|
|
void untracked_cache_remove_from_index(struct index_state *, const char *);
|
|
void untracked_cache_add_to_index(struct index_state *, const char *);
|
|
|
|
void free_untracked_cache(struct untracked_cache *);
|
|
struct untracked_cache *read_untracked_extension(const void *data, unsigned long sz);
|
|
void write_untracked_extension(struct strbuf *out, struct untracked_cache *untracked);
|
|
void add_untracked_cache(struct index_state *istate);
|
|
void remove_untracked_cache(struct index_state *istate);
|
|
|
|
/*
|
|
* Connect a worktree to a git directory by creating (or overwriting) a
|
|
* '.git' file containing the location of the git directory. In the git
|
|
* directory set the core.worktree setting to indicate where the worktree is.
|
|
* When `recurse_into_nested` is set, recurse into any nested submodules,
|
|
* connecting them as well.
|
|
*/
|
|
void connect_work_tree_and_git_dir(const char *work_tree,
|
|
const char *git_dir,
|
|
int recurse_into_nested);
|
|
void relocate_gitdir(const char *path,
|
|
const char *old_git_dir,
|
|
const char *new_git_dir);
|
|
#endif
|