#define USE_THE_REPOSITORY_VARIABLE #include "git-compat-util.h" #include "advice.h" #include "strvec.h" #include "repository.h" #include "parse.h" #include "dir.h" #include "environment.h" #include "gettext.h" #include "hex.h" #include "name-hash.h" #include "tree.h" #include "tree-walk.h" #include "cache-tree.h" #include "unpack-trees.h" #include "progress.h" #include "refs.h" #include "attr.h" #include "read-cache.h" #include "split-index.h" #include "sparse-index.h" #include "submodule.h" #include "submodule-config.h" #include "symlinks.h" #include "trace2.h" #include "fsmonitor.h" #include "object-store-ll.h" #include "promisor-remote.h" #include "entry.h" #include "parallel-checkout.h" #include "setup.h" /* * Error messages expected by scripts out of plumbing commands such as * read-tree. Non-scripted Porcelain is not required to use these messages * and in fact are encouraged to reword them to better suit their particular * situation better. See how "git checkout" and "git merge" replaces * them using setup_unpack_trees_porcelain(), for example. */ static const char *unpack_plumbing_errors[NB_UNPACK_TREES_WARNING_TYPES] = …; #define ERRORMSG(o,type) … static const char *super_prefixed(const char *path, const char *super_prefix) { … } void setup_unpack_trees_porcelain(struct unpack_trees_options *opts, const char *cmd) { … } void clear_unpack_trees_porcelain(struct unpack_trees_options *opts) { … } static int do_add_entry(struct unpack_trees_options *o, struct cache_entry *ce, unsigned int set, unsigned int clear) { … } static void add_entry(struct unpack_trees_options *o, const struct cache_entry *ce, unsigned int set, unsigned int clear) { … } /* * add error messages on path <path> * corresponding to the type <e> with the message <msg> * indicating if it should be display in porcelain or not */ static int add_rejected_path(struct unpack_trees_options *o, enum unpack_trees_error_types e, const char *path) { … } /* * display all the error messages stored in a nice way */ static void display_error_msgs(struct unpack_trees_options *o) { … } /* * display all the warning messages stored in a nice way */ static void display_warning_msgs(struct unpack_trees_options *o) { … } static int check_submodule_move_head(const struct cache_entry *ce, const char *old_id, const char *new_id, struct unpack_trees_options *o) { … } /* * Perform the loading of the repository's gitmodules file. This function is * used by 'check_update()' to perform loading of the gitmodules file in two * different situations: * (1) before removing entries from the working tree if the gitmodules file has * been marked for removal. This situation is specified by 'state' == NULL. * (2) before checking out entries to the working tree if the gitmodules file * has been marked for update. This situation is specified by 'state' != NULL. */ static void load_gitmodules_file(struct index_state *index, struct checkout *state) { … } static struct progress *get_progress(struct unpack_trees_options *o, struct index_state *index) { … } static void setup_collided_checkout_detection(struct checkout *state, struct index_state *index) { … } static void report_collided_checkout(struct index_state *index) { … } static int must_checkout(const struct cache_entry *ce) { … } static int check_updates(struct unpack_trees_options *o, struct index_state *index) { … } static int verify_uptodate_sparse(const struct cache_entry *ce, struct unpack_trees_options *o); static int verify_absent_sparse(const struct cache_entry *ce, enum unpack_trees_error_types, struct unpack_trees_options *o); static int apply_sparse_checkout(struct index_state *istate, struct cache_entry *ce, struct unpack_trees_options *o) { … } static int warn_conflicted_path(struct index_state *istate, int i, struct unpack_trees_options *o) { … } static inline int call_unpack_fn(const struct cache_entry * const *src, struct unpack_trees_options *o) { … } static void mark_ce_used(struct cache_entry *ce, struct unpack_trees_options *o) { … } static void mark_all_ce_unused(struct index_state *index) { … } static int locate_in_src_index(const struct cache_entry *ce, struct unpack_trees_options *o) { … } /* * We call unpack_index_entry() with an unmerged cache entry * only in diff-index, and it wants a single callback. Skip * the other unmerged entry with the same name. */ static void mark_ce_used_same_name(struct cache_entry *ce, struct unpack_trees_options *o) { … } static struct cache_entry *next_cache_entry(struct unpack_trees_options *o) { … } static void add_same_unmerged(const struct cache_entry *ce, struct unpack_trees_options *o) { … } static int unpack_index_entry(struct cache_entry *ce, struct unpack_trees_options *o) { … } static int find_cache_pos(struct traverse_info *, const char *p, size_t len); static void restore_cache_bottom(struct traverse_info *info, int bottom) { … } static int switch_cache_bottom(struct traverse_info *info) { … } static inline int are_same_oid(struct name_entry *name_j, struct name_entry *name_k) { … } static int all_trees_same_as_cache_tree(int n, unsigned long dirmask, struct name_entry *names, struct traverse_info *info) { … } static int index_pos_by_traverse_info(struct name_entry *names, struct traverse_info *info) { … } /* * Fast path if we detect that all trees are the same as cache-tree at this * path. We'll walk these trees in an iterative loop using cache-tree/index * instead of ODB since we already know what these trees contain. */ static int traverse_by_cache_tree(int pos, int nr_entries, int nr_names, struct traverse_info *info) { … } static int traverse_trees_recursive(int n, unsigned long dirmask, unsigned long df_conflicts, struct name_entry *names, struct traverse_info *info) { … } /* * Compare the traverse-path to the cache entry without actually * having to generate the textual representation of the traverse * path. * * NOTE! This *only* compares up to the size of the traverse path * itself - the caller needs to do the final check for the cache * entry having more data at the end! */ static int do_compare_entry_piecewise(const struct cache_entry *ce, const struct traverse_info *info, const char *name, size_t namelen, unsigned mode) { … } static int do_compare_entry(const struct cache_entry *ce, const struct traverse_info *info, const char *name, size_t namelen, unsigned mode) { … } static int compare_entry(const struct cache_entry *ce, const struct traverse_info *info, const struct name_entry *n) { … } static int ce_in_traverse_path(const struct cache_entry *ce, const struct traverse_info *info) { … } static struct cache_entry *create_ce_entry(const struct traverse_info *info, const struct name_entry *n, int stage, struct index_state *istate, int is_transient, int is_sparse_directory) { … } /* * Determine whether the path specified by 'p' should be unpacked as a new * sparse directory in a sparse index. A new sparse directory 'A/': * - must be outside the sparse cone. * - must not already be in the index (i.e., no index entry with name 'A/' * exists). * - must not have any child entries in the index (i.e., no index entry * 'A/<something>' exists). * If 'p' meets the above requirements, return 1; otherwise, return 0. */ static int entry_is_new_sparse_dir(const struct traverse_info *info, const struct name_entry *p) { … } /* * Note that traverse_by_cache_tree() duplicates some logic in this function * without actually calling it. If you change the logic here you may need to * check and change there as well. */ static int unpack_single_entry(int n, unsigned long mask, unsigned long dirmask, struct cache_entry **src, const struct name_entry *names, const struct traverse_info *info, int *is_new_sparse_dir) { … } static int unpack_failed(struct unpack_trees_options *o, const char *message) { … } /* * The tree traversal is looking at name p. If we have a matching entry, * return it. If name p is a directory in the index, do not return * anything, as we will want to match it when the traversal descends into * the directory. */ static int find_cache_pos(struct traverse_info *info, const char *p, size_t p_len) { … } /* * Given a sparse directory entry 'ce', compare ce->name to * info->traverse_path + p->path + '/' if info->traverse_path * is non-empty. * * Compare ce->name to p->path + '/' otherwise. Note that * ce->name must end in a trailing '/' because it is a sparse * directory entry. */ static int sparse_dir_matches_path(const struct cache_entry *ce, struct traverse_info *info, const struct name_entry *p) { … } static struct cache_entry *find_cache_entry(struct traverse_info *info, const struct name_entry *p) { … } static void debug_path(struct traverse_info *info) { … } static void debug_name_entry(int i, struct name_entry *n) { … } static void debug_unpack_callback(int n, unsigned long mask, unsigned long dirmask, struct name_entry *names, struct traverse_info *info) { … } /* * Returns true if and only if the given cache_entry is a * sparse-directory entry that matches the given name_entry * from the tree walk at the given traverse_info. */ static int is_sparse_directory_entry(struct cache_entry *ce, const struct name_entry *name, struct traverse_info *info) { … } static int unpack_sparse_callback(int n, unsigned long mask, unsigned long dirmask, struct name_entry *names, struct traverse_info *info) { … } /* * Note that traverse_by_cache_tree() duplicates some logic in this function * without actually calling it. If you change the logic here you may need to * check and change there as well. */ static int unpack_callback(int n, unsigned long mask, unsigned long dirmask, struct name_entry *names, struct traverse_info *info) { … } static int clear_ce_flags_1(struct index_state *istate, struct cache_entry **cache, int nr, struct strbuf *prefix, int select_mask, int clear_mask, struct pattern_list *pl, enum pattern_match_result default_match, int progress_nr); /* Whole directory matching */ static int clear_ce_flags_dir(struct index_state *istate, struct cache_entry **cache, int nr, struct strbuf *prefix, char *basename, int select_mask, int clear_mask, struct pattern_list *pl, enum pattern_match_result default_match, int progress_nr) { … } /* * Traverse the index, find every entry that matches according to * o->pl. Do "ce_flags &= ~clear_mask" on those entries. Return the * number of traversed entries. * * If select_mask is non-zero, only entries whose ce_flags has on of * those bits enabled are traversed. * * cache : pointer to an index entry * prefix_len : an offset to its path * * The current path ("prefix") including the trailing '/' is * cache[0]->name[0..(prefix_len-1)] * Top level path has prefix_len zero. */ static int clear_ce_flags_1(struct index_state *istate, struct cache_entry **cache, int nr, struct strbuf *prefix, int select_mask, int clear_mask, struct pattern_list *pl, enum pattern_match_result default_match, int progress_nr) { … } static int clear_ce_flags(struct index_state *istate, int select_mask, int clear_mask, struct pattern_list *pl, int show_progress) { … } /* * Set/Clear CE_NEW_SKIP_WORKTREE according to $GIT_DIR/info/sparse-checkout */ static void mark_new_skip_worktree(struct pattern_list *pl, struct index_state *istate, int select_flag, int skip_wt_flag, int show_progress) { … } static void populate_from_existing_patterns(struct unpack_trees_options *o, struct pattern_list *pl) { … } static void update_sparsity_for_prefix(const char *prefix, struct index_state *istate) { … } static int verify_absent(const struct cache_entry *, enum unpack_trees_error_types, struct unpack_trees_options *); /* * N-way merge "len" trees. Returns 0 on success, -1 on failure to manipulate the * resulting index, -2 on failure to reflect the changes to the work tree. * * CE_ADDED, CE_UNPACKED and CE_NEW_SKIP_WORKTREE are used internally */ int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options *o) { … } /* * Update SKIP_WORKTREE bits according to sparsity patterns, and update * working directory to match. * * CE_NEW_SKIP_WORKTREE is used internally. */ enum update_sparsity_result update_sparsity(struct unpack_trees_options *o, struct pattern_list *pl) { … } /* Here come the merge functions */ static int reject_merge(const struct cache_entry *ce, struct unpack_trees_options *o) { … } static int same(const struct cache_entry *a, const struct cache_entry *b) { … } /* * When a CE gets turned into an unmerged entry, we * want it to be up-to-date */ static int verify_uptodate_1(const struct cache_entry *ce, struct unpack_trees_options *o, enum unpack_trees_error_types error_type) { … } int verify_uptodate(const struct cache_entry *ce, struct unpack_trees_options *o) { … } static int verify_uptodate_sparse(const struct cache_entry *ce, struct unpack_trees_options *o) { … } /* * TODO: We should actually invalidate o->internal.result, not src_index [1]. * But since cache tree and untracked cache both are not copied to * o->internal.result until unpacking is complete, we invalidate them on * src_index instead with the assumption that they will be copied to * dst_index at the end. * * [1] src_index->cache_tree is also used in unpack_callback() so if * we invalidate o->internal.result, we need to update it to use * o->internal.result.cache_tree as well. */ static void invalidate_ce_path(const struct cache_entry *ce, struct unpack_trees_options *o) { … } /* * Check that checking out ce->sha1 in subdir ce->name is not * going to overwrite any working files. */ static int verify_clean_submodule(const char *old_sha1, const struct cache_entry *ce, struct unpack_trees_options *o) { … } static int verify_clean_subdirectory(const struct cache_entry *ce, struct unpack_trees_options *o) { … } /* * This gets called when there was no index entry for the tree entry 'dst', * but we found a file in the working tree that 'lstat()' said was fine, * and we're on a case-insensitive filesystem. * * See if we can find a case-insensitive match in the index that also * matches the stat information, and assume it's that other file! */ static int icase_exists(struct unpack_trees_options *o, const char *name, int len, struct stat *st) { … } enum absent_checking_type { … }; static int check_ok_to_remove(const char *name, int len, int dtype, const struct cache_entry *ce, struct stat *st, enum unpack_trees_error_types error_type, enum absent_checking_type absent_type, struct unpack_trees_options *o) { … } /* * We do not want to remove or overwrite a working tree file that * is not tracked, unless it is ignored. */ static int verify_absent_1(const struct cache_entry *ce, enum unpack_trees_error_types error_type, enum absent_checking_type absent_type, struct unpack_trees_options *o) { … } static int verify_absent(const struct cache_entry *ce, enum unpack_trees_error_types error_type, struct unpack_trees_options *o) { … } static int verify_absent_if_directory(const struct cache_entry *ce, enum unpack_trees_error_types error_type, struct unpack_trees_options *o) { … } static int verify_absent_sparse(const struct cache_entry *ce, enum unpack_trees_error_types error_type, struct unpack_trees_options *o) { … } static int merged_entry(const struct cache_entry *ce, const struct cache_entry *old, struct unpack_trees_options *o) { … } static int merged_sparse_dir(const struct cache_entry * const *src, int n, struct unpack_trees_options *o) { … } static int deleted_entry(const struct cache_entry *ce, const struct cache_entry *old, struct unpack_trees_options *o) { … } static int keep_entry(const struct cache_entry *ce, struct unpack_trees_options *o) { … } #if DBRT_DEBUG static void show_stage_entry(FILE *o, const char *label, const struct cache_entry *ce) { if (!ce) fprintf(o, "%s (missing)\n", label); else fprintf(o, "%s%06o %s %d\t%s\n", label, ce->ce_mode, oid_to_hex(&ce->oid), ce_stage(ce), ce->name); } #endif int threeway_merge(const struct cache_entry * const *stages, struct unpack_trees_options *o) { … } /* * Two-way merge. * * The rule is to "carry forward" what is in the index without losing * information across a "fast-forward", favoring a successful merge * over a merge failure when it makes sense. For details of the * "carry forward" rule, please see <Documentation/git-read-tree.txt>. * */ int twoway_merge(const struct cache_entry * const *src, struct unpack_trees_options *o) { … } /* * Bind merge. * * Keep the index entries at stage0, collapse stage1 but make sure * stage0 does not have anything there. */ int bind_merge(const struct cache_entry * const *src, struct unpack_trees_options *o) { … } /* * One-way merge. * * The rule is: * - take the stat information from stage0, take the data from stage1 */ int oneway_merge(const struct cache_entry * const *src, struct unpack_trees_options *o) { … } /* * Merge worktree and untracked entries in a stash entry. * * Ignore all index entries. Collapse remaining trees but make sure that they * don't have any conflicting files. */ int stash_worktree_untracked_merge(const struct cache_entry * const *src, struct unpack_trees_options *o) { … }
Codebase Browser
git