зеркало из https://github.com/microsoft/git.git
Merge branch 'ab/read-tree'
Code simplification by removing support for a caller that is long gone. * ab/read-tree: tree.h API: simplify read_tree_recursive() signature tree.h API: expose read_tree_1() as read_tree_at() archive: stop passing "stage" through read_tree_recursive() ls-files: refactor away read_tree() ls-files: don't needlessly pass around stage variable tree.c API: move read_tree() into builtin/ls-files.c ls-files tests: add meaningful --with-tree tests show tests: add test for "git show <tree>"
This commit is contained in:
Junio C Hamano
Коммит
ad16f748f2
30
archive.c
30
archive.c
|
|
@ -104,7 +104,6 @@ struct directory {
|
|||
struct object_id oid;
|
||||
int baselen, len;
|
||||
unsigned mode;
|
||||
int stage;
|
||||
char path[FLEX_ARRAY];
|
||||
};
|
||||
|
||||
|
|
@ -135,7 +134,7 @@ static int check_attr_export_subst(const struct attr_check *check)
|
|||
}
|
||||
|
||||
static int write_archive_entry(const struct object_id *oid, const char *base,
|
||||
int baselen, const char *filename, unsigned mode, int stage,
|
||||
int baselen, const char *filename, unsigned mode,
|
||||
void *context)
|
||||
{
|
||||
static struct strbuf path = STRBUF_INIT;
|
||||
|
|
@ -194,7 +193,7 @@ static int write_archive_entry(const struct object_id *oid, const char *base,
|
|||
|
||||
static void queue_directory(const unsigned char *sha1,
|
||||
struct strbuf *base, const char *filename,
|
||||
unsigned mode, int stage, struct archiver_context *c)
|
||||
unsigned mode, struct archiver_context *c)
|
||||
{
|
||||
struct directory *d;
|
||||
size_t len = st_add4(base->len, 1, strlen(filename), 1);
|
||||
|
|
@ -202,7 +201,6 @@ static void queue_directory(const unsigned char *sha1,
|
|||
d->up = c->bottom;
|
||||
d->baselen = base->len;
|
||||
d->mode = mode;
|
||||
d->stage = stage;
|
||||
c->bottom = d;
|
||||
d->len = xsnprintf(d->path, len, "%.*s%s/", (int)base->len, base->buf, filename);
|
||||
hashcpy(d->oid.hash, sha1);
|
||||
|
|
@ -221,14 +219,14 @@ static int write_directory(struct archiver_context *c)
|
|||
write_directory(c) ||
|
||||
write_archive_entry(&d->oid, d->path, d->baselen,
|
||||
d->path + d->baselen, d->mode,
|
||||
d->stage, c) != READ_TREE_RECURSIVE;
|
||||
c) != READ_TREE_RECURSIVE;
|
||||
free(d);
|
||||
return ret ? -1 : 0;
|
||||
}
|
||||
|
||||
static int queue_or_write_archive_entry(const struct object_id *oid,
|
||||
struct strbuf *base, const char *filename,
|
||||
unsigned mode, int stage, void *context)
|
||||
unsigned mode, void *context)
|
||||
{
|
||||
struct archiver_context *c = context;
|
||||
|
||||
|
|
@ -253,14 +251,14 @@ static int queue_or_write_archive_entry(const struct object_id *oid,
|
|||
if (check_attr_export_ignore(check))
|
||||
return 0;
|
||||
queue_directory(oid->hash, base, filename,
|
||||
mode, stage, c);
|
||||
mode, c);
|
||||
return READ_TREE_RECURSIVE;
|
||||
}
|
||||
|
||||
if (write_directory(c))
|
||||
return -1;
|
||||
return write_archive_entry(oid, base->buf, base->len, filename, mode,
|
||||
stage, context);
|
||||
context);
|
||||
}
|
||||
|
||||
struct extra_file_info {
|
||||
|
|
@ -313,10 +311,10 @@ int write_archive_entries(struct archiver_args *args,
|
|||
git_attr_set_direction(GIT_ATTR_INDEX);
|
||||
}
|
||||
|
||||
err = read_tree_recursive(args->repo, args->tree, "",
|
||||
0, 0, &args->pathspec,
|
||||
queue_or_write_archive_entry,
|
||||
&context);
|
||||
err = read_tree(args->repo, args->tree,
|
||||
&args->pathspec,
|
||||
queue_or_write_archive_entry,
|
||||
&context);
|
||||
if (err == READ_TREE_RECURSIVE)
|
||||
err = 0;
|
||||
while (context.bottom) {
|
||||
|
|
@ -375,7 +373,7 @@ struct path_exists_context {
|
|||
|
||||
static int reject_entry(const struct object_id *oid, struct strbuf *base,
|
||||
const char *filename, unsigned mode,
|
||||
int stage, void *context)
|
||||
void *context)
|
||||
{
|
||||
int ret = -1;
|
||||
struct path_exists_context *ctx = context;
|
||||
|
|
@ -402,9 +400,9 @@ static int path_exists(struct archiver_args *args, const char *path)
|
|||
ctx.args = args;
|
||||
parse_pathspec(&ctx.pathspec, 0, 0, "", paths);
|
||||
ctx.pathspec.recursive = 1;
|
||||
ret = read_tree_recursive(args->repo, args->tree, "",
|
||||
0, 0, &ctx.pathspec,
|
||||
reject_entry, &ctx);
|
||||
ret = read_tree(args->repo, args->tree,
|
||||
&ctx.pathspec,
|
||||
reject_entry, &ctx);
|
||||
clear_pathspec(&ctx.pathspec);
|
||||
return ret != 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -114,7 +114,7 @@ static int post_checkout_hook(struct commit *old_commit, struct commit *new_comm
|
|||
}
|
||||
|
||||
static int update_some(const struct object_id *oid, struct strbuf *base,
|
||||
const char *pathname, unsigned mode, int stage, void *context)
|
||||
const char *pathname, unsigned mode, void *context)
|
||||
{
|
||||
int len;
|
||||
struct cache_entry *ce;
|
||||
|
|
@ -155,8 +155,8 @@ static int update_some(const struct object_id *oid, struct strbuf *base,
|
|||
|
||||
static int read_tree_some(struct tree *tree, const struct pathspec *pathspec)
|
||||
{
|
||||
read_tree_recursive(the_repository, tree, "", 0, 0,
|
||||
pathspec, update_some, NULL);
|
||||
read_tree(the_repository, tree,
|
||||
pathspec, update_some, NULL);
|
||||
|
||||
/* update the index with the given tree's info
|
||||
* for all args, expanding wildcards, and exit
|
||||
|
|
@ -322,7 +322,7 @@ static void mark_ce_for_checkout_overlay(struct cache_entry *ce,
|
|||
* If it comes from the tree-ish, we already know it
|
||||
* matches the pathspec and could just stamp
|
||||
* CE_MATCHED to it from update_some(). But we still
|
||||
* need ps_matched and read_tree_recursive (and
|
||||
* need ps_matched and read_tree (and
|
||||
* eventually tree_entry_interesting) cannot fill
|
||||
* ps_matched yet. Once it can, we can avoid calling
|
||||
* match_pathspec() for _all_ entries when
|
||||
|
|
|
|||
|
|
@ -599,7 +599,7 @@ static int show_tag_object(const struct object_id *oid, struct rev_info *rev)
|
|||
|
||||
static int show_tree_object(const struct object_id *oid,
|
||||
struct strbuf *base,
|
||||
const char *pathname, unsigned mode, int stage, void *context)
|
||||
const char *pathname, unsigned mode, void *context)
|
||||
{
|
||||
FILE *file = context;
|
||||
fprintf(file, "%s%s\n", pathname, S_ISDIR(mode) ? "/" : "");
|
||||
|
|
@ -681,9 +681,9 @@ int cmd_show(int argc, const char **argv, const char *prefix)
|
|||
diff_get_color_opt(&rev.diffopt, DIFF_COMMIT),
|
||||
name,
|
||||
diff_get_color_opt(&rev.diffopt, DIFF_RESET));
|
||||
read_tree_recursive(the_repository, (struct tree *)o, "",
|
||||
0, 0, &match_all, show_tree_object,
|
||||
rev.diffopt.file);
|
||||
read_tree(the_repository, (struct tree *)o,
|
||||
&match_all, show_tree_object,
|
||||
rev.diffopt.file);
|
||||
rev.shown_one = 1;
|
||||
break;
|
||||
case OBJ_COMMIT:
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@
|
|||
#include "dir.h"
|
||||
#include "builtin.h"
|
||||
#include "tree.h"
|
||||
#include "cache-tree.h"
|
||||
#include "parse-options.h"
|
||||
#include "resolve-undo.h"
|
||||
#include "string-list.h"
|
||||
|
|
@ -420,6 +421,53 @@ static int get_common_prefix_len(const char *common_prefix)
|
|||
return common_prefix_len;
|
||||
}
|
||||
|
||||
static int read_one_entry_opt(struct index_state *istate,
|
||||
const struct object_id *oid,
|
||||
struct strbuf *base,
|
||||
const char *pathname,
|
||||
unsigned mode, int opt)
|
||||
{
|
||||
int len;
|
||||
struct cache_entry *ce;
|
||||
|
||||
if (S_ISDIR(mode))
|
||||
return READ_TREE_RECURSIVE;
|
||||
|
||||
len = strlen(pathname);
|
||||
ce = make_empty_cache_entry(istate, base->len + len);
|
||||
|
||||
ce->ce_mode = create_ce_mode(mode);
|
||||
ce->ce_flags = create_ce_flags(1);
|
||||
ce->ce_namelen = base->len + len;
|
||||
memcpy(ce->name, base->buf, base->len);
|
||||
memcpy(ce->name + base->len, pathname, len+1);
|
||||
oidcpy(&ce->oid, oid);
|
||||
return add_index_entry(istate, ce, opt);
|
||||
}
|
||||
|
||||
static int read_one_entry(const struct object_id *oid, struct strbuf *base,
|
||||
const char *pathname, unsigned mode,
|
||||
void *context)
|
||||
{
|
||||
struct index_state *istate = context;
|
||||
return read_one_entry_opt(istate, oid, base, pathname,
|
||||
mode,
|
||||
ADD_CACHE_OK_TO_ADD|ADD_CACHE_SKIP_DFCHECK);
|
||||
}
|
||||
|
||||
/*
|
||||
* This is used when the caller knows there is no existing entries at
|
||||
* the stage that will conflict with the entry being added.
|
||||
*/
|
||||
static int read_one_entry_quick(const struct object_id *oid, struct strbuf *base,
|
||||
const char *pathname, unsigned mode,
|
||||
void *context)
|
||||
{
|
||||
struct index_state *istate = context;
|
||||
return read_one_entry_opt(istate, oid, base, pathname,
|
||||
mode, ADD_CACHE_JUST_APPEND);
|
||||
}
|
||||
|
||||
/*
|
||||
* Read the tree specified with --with-tree option
|
||||
* (typically, HEAD) into stage #1 and then
|
||||
|
|
@ -436,6 +484,8 @@ void overlay_tree_on_index(struct index_state *istate,
|
|||
struct pathspec pathspec;
|
||||
struct cache_entry *last_stage0 = NULL;
|
||||
int i;
|
||||
read_tree_fn_t fn = NULL;
|
||||
int err;
|
||||
|
||||
if (get_oid(tree_name, &oid))
|
||||
die("tree-ish %s not found.", tree_name);
|
||||
|
|
@ -458,9 +508,32 @@ void overlay_tree_on_index(struct index_state *istate,
|
|||
PATHSPEC_PREFER_CWD, prefix, matchbuf);
|
||||
} else
|
||||
memset(&pathspec, 0, sizeof(pathspec));
|
||||
if (read_tree(the_repository, tree, 1, &pathspec, istate))
|
||||
|
||||
/*
|
||||
* See if we have cache entry at the stage. If so,
|
||||
* do it the original slow way, otherwise, append and then
|
||||
* sort at the end.
|
||||
*/
|
||||
for (i = 0; !fn && i < istate->cache_nr; i++) {
|
||||
const struct cache_entry *ce = istate->cache[i];
|
||||
if (ce_stage(ce) == 1)
|
||||
fn = read_one_entry;
|
||||
}
|
||||
|
||||
if (!fn)
|
||||
fn = read_one_entry_quick;
|
||||
err = read_tree(the_repository, tree, &pathspec, fn, istate);
|
||||
if (err)
|
||||
die("unable to read tree entries %s", tree_name);
|
||||
|
||||
/*
|
||||
* Sort the cache entry -- we need to nuke the cache tree, though.
|
||||
*/
|
||||
if (fn == read_one_entry_quick) {
|
||||
cache_tree_free(&istate->cache_tree);
|
||||
QSORT(istate->cache, istate->cache_nr, cmp_cache_name_compare);
|
||||
}
|
||||
|
||||
for (i = 0; i < istate->cache_nr; i++) {
|
||||
struct cache_entry *ce = istate->cache[i];
|
||||
switch (ce_stage(ce)) {
|
||||
|
|
|
|||
|
|
@ -62,7 +62,7 @@ static int show_recursive(const char *base, int baselen, const char *pathname)
|
|||
}
|
||||
|
||||
static int show_tree(const struct object_id *oid, struct strbuf *base,
|
||||
const char *pathname, unsigned mode, int stage, void *context)
|
||||
const char *pathname, unsigned mode, void *context)
|
||||
{
|
||||
int retval = 0;
|
||||
int baselen;
|
||||
|
|
@ -185,6 +185,6 @@ int cmd_ls_tree(int argc, const char **argv, const char *prefix)
|
|||
tree = parse_tree_indirect(&oid);
|
||||
if (!tree)
|
||||
die("not a tree object");
|
||||
return !!read_tree_recursive(the_repository, tree, "", 0, 0,
|
||||
&pathspec, show_tree, NULL);
|
||||
return !!read_tree(the_repository, tree,
|
||||
&pathspec, show_tree, NULL);
|
||||
}
|
||||
|
|
|
|||
2
cache.h
2
cache.h
|
|
@ -803,7 +803,7 @@ static inline int index_pos_to_insert_pos(uintmax_t pos)
|
|||
#define ADD_CACHE_OK_TO_ADD 1 /* Ok to add */
|
||||
#define ADD_CACHE_OK_TO_REPLACE 2 /* Ok to replace file/directory */
|
||||
#define ADD_CACHE_SKIP_DFCHECK 4 /* Ok to skip DF conflict checks */
|
||||
#define ADD_CACHE_JUST_APPEND 8 /* Append only; tree.c::read_tree() */
|
||||
#define ADD_CACHE_JUST_APPEND 8 /* Append only */
|
||||
#define ADD_CACHE_NEW_ONLY 16 /* Do not replace existing ones */
|
||||
#define ADD_CACHE_KEEP_CACHE_TREE 32 /* Do not invalidate cache-tree */
|
||||
#define ADD_CACHE_RENORMALIZE 64 /* Pass along HASH_RENORMALIZE */
|
||||
|
|
|
|||
|
|
@ -453,7 +453,7 @@ static void unpack_trees_finish(struct merge_options *opt)
|
|||
|
||||
static int save_files_dirs(const struct object_id *oid,
|
||||
struct strbuf *base, const char *path,
|
||||
unsigned int mode, int stage, void *context)
|
||||
unsigned int mode, void *context)
|
||||
{
|
||||
struct path_hashmap_entry *entry;
|
||||
int baselen = base->len;
|
||||
|
|
@ -473,8 +473,8 @@ static void get_files_dirs(struct merge_options *opt, struct tree *tree)
|
|||
{
|
||||
struct pathspec match_all;
|
||||
memset(&match_all, 0, sizeof(match_all));
|
||||
read_tree_recursive(opt->repo, tree, "", 0, 0,
|
||||
&match_all, save_files_dirs, opt);
|
||||
read_tree(opt->repo, tree,
|
||||
&match_all, save_files_dirs, opt);
|
||||
}
|
||||
|
||||
static int get_tree_entry_if_blob(struct repository *r,
|
||||
|
|
|
|||
|
|
@ -47,6 +47,12 @@ test_expect_success setup '
|
|||
git add .
|
||||
'
|
||||
|
||||
test_expect_success 'usage' '
|
||||
test_expect_code 128 git ls-files --with-tree=HEAD -u &&
|
||||
test_expect_code 128 git ls-files --with-tree=HEAD -s &&
|
||||
test_expect_code 128 git ls-files --recurse-submodules --with-tree=HEAD
|
||||
'
|
||||
|
||||
test_expect_success 'git ls-files --with-tree should succeed from subdir' '
|
||||
# We have to run from a sub-directory to trigger prune_path
|
||||
# Then we finally get to run our --with-tree test
|
||||
|
|
@ -60,4 +66,39 @@ test_expect_success \
|
|||
'git ls-files --with-tree should add entries from named tree.' \
|
||||
'test_cmp expected output'
|
||||
|
||||
test_expect_success 'no duplicates in --with-tree output' '
|
||||
git ls-files --with-tree=HEAD >actual &&
|
||||
sort -u actual >expected &&
|
||||
test_cmp expected actual
|
||||
'
|
||||
|
||||
test_expect_success 'setup: output in a conflict' '
|
||||
test_create_repo conflict &&
|
||||
test_commit -C conflict BASE file &&
|
||||
test_commit -C conflict A file foo &&
|
||||
git -C conflict reset --hard BASE &&
|
||||
test_commit -C conflict B file bar
|
||||
'
|
||||
|
||||
test_expect_success 'output in a conflict' '
|
||||
test_must_fail git -C conflict merge A B &&
|
||||
cat >expected <<-\EOF &&
|
||||
file
|
||||
file
|
||||
file
|
||||
file
|
||||
EOF
|
||||
git -C conflict ls-files --with-tree=HEAD >actual &&
|
||||
test_cmp expected actual
|
||||
'
|
||||
|
||||
test_expect_success 'output with removed .git/index' '
|
||||
cat >expected <<-\EOF &&
|
||||
file
|
||||
EOF
|
||||
rm conflict/.git/index &&
|
||||
git -C conflict ls-files --with-tree=HEAD >actual &&
|
||||
test_cmp expected actual
|
||||
'
|
||||
|
||||
test_done
|
||||
|
|
|
|||
|
|
@ -38,6 +38,45 @@ test_expect_success 'showing two commits' '
|
|||
test_cmp expect actual.filtered
|
||||
'
|
||||
|
||||
test_expect_success 'showing a tree' '
|
||||
cat >expected <<-EOF &&
|
||||
tree main1:
|
||||
|
||||
main1.t
|
||||
EOF
|
||||
git show main1: >actual &&
|
||||
test_cmp expected actual
|
||||
'
|
||||
|
||||
test_expect_success 'showing two trees' '
|
||||
cat >expected <<-EOF &&
|
||||
tree main1^{tree}
|
||||
|
||||
main1.t
|
||||
|
||||
tree main2^{tree}
|
||||
|
||||
main1.t
|
||||
main2.t
|
||||
EOF
|
||||
git show main1^{tree} main2^{tree} >actual &&
|
||||
test_cmp expected actual
|
||||
'
|
||||
|
||||
test_expect_success 'showing a trees is not recursive' '
|
||||
git worktree add not-recursive main1 &&
|
||||
mkdir not-recursive/a &&
|
||||
test_commit -C not-recursive a/file &&
|
||||
cat >expected <<-EOF &&
|
||||
tree HEAD^{tree}
|
||||
|
||||
a/
|
||||
main1.t
|
||||
EOF
|
||||
git -C not-recursive show HEAD^{tree} >actual &&
|
||||
test_cmp expected actual
|
||||
'
|
||||
|
||||
test_expect_success 'showing a range walks (linear)' '
|
||||
cat >expect <<-EOF &&
|
||||
commit $(git rev-parse main3)
|
||||
|
|
|
|||
119
tree.c
119
tree.c
|
|
@ -11,58 +11,10 @@
|
|||
|
||||
const char *tree_type = "tree";
|
||||
|
||||
static int read_one_entry_opt(struct index_state *istate,
|
||||
const struct object_id *oid,
|
||||
const char *base, int baselen,
|
||||
const char *pathname,
|
||||
unsigned mode, int stage, int opt)
|
||||
{
|
||||
int len;
|
||||
struct cache_entry *ce;
|
||||
|
||||
if (S_ISDIR(mode))
|
||||
return READ_TREE_RECURSIVE;
|
||||
|
||||
len = strlen(pathname);
|
||||
ce = make_empty_cache_entry(istate, baselen + len);
|
||||
|
||||
ce->ce_mode = create_ce_mode(mode);
|
||||
ce->ce_flags = create_ce_flags(stage);
|
||||
ce->ce_namelen = baselen + len;
|
||||
memcpy(ce->name, base, baselen);
|
||||
memcpy(ce->name + baselen, pathname, len+1);
|
||||
oidcpy(&ce->oid, oid);
|
||||
return add_index_entry(istate, ce, opt);
|
||||
}
|
||||
|
||||
static int read_one_entry(const struct object_id *oid, struct strbuf *base,
|
||||
const char *pathname, unsigned mode, int stage,
|
||||
void *context)
|
||||
{
|
||||
struct index_state *istate = context;
|
||||
return read_one_entry_opt(istate, oid, base->buf, base->len, pathname,
|
||||
mode, stage,
|
||||
ADD_CACHE_OK_TO_ADD|ADD_CACHE_SKIP_DFCHECK);
|
||||
}
|
||||
|
||||
/*
|
||||
* This is used when the caller knows there is no existing entries at
|
||||
* the stage that will conflict with the entry being added.
|
||||
*/
|
||||
static int read_one_entry_quick(const struct object_id *oid, struct strbuf *base,
|
||||
const char *pathname, unsigned mode, int stage,
|
||||
void *context)
|
||||
{
|
||||
struct index_state *istate = context;
|
||||
return read_one_entry_opt(istate, oid, base->buf, base->len, pathname,
|
||||
mode, stage,
|
||||
ADD_CACHE_JUST_APPEND);
|
||||
}
|
||||
|
||||
static int read_tree_1(struct repository *r,
|
||||
struct tree *tree, struct strbuf *base,
|
||||
int stage, const struct pathspec *pathspec,
|
||||
read_tree_fn_t fn, void *context)
|
||||
int read_tree_at(struct repository *r,
|
||||
struct tree *tree, struct strbuf *base,
|
||||
const struct pathspec *pathspec,
|
||||
read_tree_fn_t fn, void *context)
|
||||
{
|
||||
struct tree_desc desc;
|
||||
struct name_entry entry;
|
||||
|
|
@ -86,7 +38,7 @@ static int read_tree_1(struct repository *r,
|
|||
}
|
||||
|
||||
switch (fn(&entry.oid, base,
|
||||
entry.path, entry.mode, stage, context)) {
|
||||
entry.path, entry.mode, context)) {
|
||||
case 0:
|
||||
continue;
|
||||
case READ_TREE_RECURSIVE:
|
||||
|
|
@ -119,9 +71,9 @@ static int read_tree_1(struct repository *r,
|
|||
len = tree_entry_len(&entry);
|
||||
strbuf_add(base, entry.path, len);
|
||||
strbuf_addch(base, '/');
|
||||
retval = read_tree_1(r, lookup_tree(r, &oid),
|
||||
base, stage, pathspec,
|
||||
fn, context);
|
||||
retval = read_tree_at(r, lookup_tree(r, &oid),
|
||||
base, pathspec,
|
||||
fn, context);
|
||||
strbuf_setlen(base, oldlen);
|
||||
if (retval)
|
||||
return -1;
|
||||
|
|
@ -129,17 +81,13 @@ static int read_tree_1(struct repository *r,
|
|||
return 0;
|
||||
}
|
||||
|
||||
int read_tree_recursive(struct repository *r,
|
||||
struct tree *tree,
|
||||
const char *base, int baselen,
|
||||
int stage, const struct pathspec *pathspec,
|
||||
read_tree_fn_t fn, void *context)
|
||||
int read_tree(struct repository *r,
|
||||
struct tree *tree,
|
||||
const struct pathspec *pathspec,
|
||||
read_tree_fn_t fn, void *context)
|
||||
{
|
||||
struct strbuf sb = STRBUF_INIT;
|
||||
int ret;
|
||||
|
||||
strbuf_add(&sb, base, baselen);
|
||||
ret = read_tree_1(r, tree, &sb, stage, pathspec, fn, context);
|
||||
int ret = read_tree_at(r, tree, &sb, pathspec, fn, context);
|
||||
strbuf_release(&sb);
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -154,47 +102,6 @@ int cmp_cache_name_compare(const void *a_, const void *b_)
|
|||
ce2->name, ce2->ce_namelen, ce_stage(ce2));
|
||||
}
|
||||
|
||||
int read_tree(struct repository *r, struct tree *tree, int stage,
|
||||
struct pathspec *match, struct index_state *istate)
|
||||
{
|
||||
read_tree_fn_t fn = NULL;
|
||||
int i, err;
|
||||
|
||||
/*
|
||||
* Currently the only existing callers of this function all
|
||||
* call it with stage=1 and after making sure there is nothing
|
||||
* at that stage; we could always use read_one_entry_quick().
|
||||
*
|
||||
* But when we decide to straighten out git-read-tree not to
|
||||
* use unpack_trees() in some cases, this will probably start
|
||||
* to matter.
|
||||
*/
|
||||
|
||||
/*
|
||||
* See if we have cache entry at the stage. If so,
|
||||
* do it the original slow way, otherwise, append and then
|
||||
* sort at the end.
|
||||
*/
|
||||
for (i = 0; !fn && i < istate->cache_nr; i++) {
|
||||
const struct cache_entry *ce = istate->cache[i];
|
||||
if (ce_stage(ce) == stage)
|
||||
fn = read_one_entry;
|
||||
}
|
||||
|
||||
if (!fn)
|
||||
fn = read_one_entry_quick;
|
||||
err = read_tree_recursive(r, tree, "", 0, stage, match, fn, istate);
|
||||
if (fn == read_one_entry || err)
|
||||
return err;
|
||||
|
||||
/*
|
||||
* Sort the cache entry -- we need to nuke the cache tree, though.
|
||||
*/
|
||||
cache_tree_free(&istate->cache_tree);
|
||||
QSORT(istate->cache, istate->cache_nr, cmp_cache_name_compare);
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct tree *lookup_tree(struct repository *r, const struct object_id *oid)
|
||||
{
|
||||
struct object *obj = lookup_object(r, oid);
|
||||
|
|
|
|||
18
tree.h
18
tree.h
|
|
@ -31,16 +31,16 @@ struct tree *parse_tree_indirect(const struct object_id *oid);
|
|||
int cmp_cache_name_compare(const void *a_, const void *b_);
|
||||
|
||||
#define READ_TREE_RECURSIVE 1
|
||||
typedef int (*read_tree_fn_t)(const struct object_id *, struct strbuf *, const char *, unsigned int, int, void *);
|
||||
typedef int (*read_tree_fn_t)(const struct object_id *, struct strbuf *, const char *, unsigned int, void *);
|
||||
|
||||
int read_tree_recursive(struct repository *r,
|
||||
struct tree *tree,
|
||||
const char *base, int baselen,
|
||||
int stage, const struct pathspec *pathspec,
|
||||
read_tree_fn_t fn, void *context);
|
||||
int read_tree_at(struct repository *r,
|
||||
struct tree *tree, struct strbuf *base,
|
||||
const struct pathspec *pathspec,
|
||||
read_tree_fn_t fn, void *context);
|
||||
|
||||
int read_tree(struct repository *r, struct tree *tree,
|
||||
int stage, struct pathspec *pathspec,
|
||||
struct index_state *istate);
|
||||
int read_tree(struct repository *r,
|
||||
struct tree *tree,
|
||||
const struct pathspec *pathspec,
|
||||
read_tree_fn_t fn, void *context);
|
||||
|
||||
#endif /* TREE_H */
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче