2006-01-07 09:33:54 +00:00
|
|
|
#include "cache.h"
|
2007-08-09 20:42:50 +00:00
|
|
|
#include "cache-tree.h"
|
2023-02-24 00:09:27 +00:00
|
|
|
#include "hex.h"
|
2005-04-18 18:39:48 +00:00
|
|
|
#include "tree.h"
|
2023-04-11 07:41:49 +00:00
|
|
|
#include "object-name.h"
|
2018-05-15 23:42:15 +00:00
|
|
|
#include "object-store.h"
|
2005-04-18 18:39:48 +00:00
|
|
|
#include "blob.h"
|
2005-09-05 06:03:51 +00:00
|
|
|
#include "commit.h"
|
|
|
|
#include "tag.h"
|
2018-05-15 21:48:42 +00:00
|
|
|
#include "alloc.h"
|
2006-05-29 19:16:12 +00:00
|
|
|
#include "tree-walk.h"
|
2018-06-29 01:21:51 +00:00
|
|
|
#include "repository.h"
|
2005-04-18 18:39:48 +00:00
|
|
|
|
|
|
|
const char *tree_type = "tree";
|
|
|
|
|
2021-03-20 22:37:50 +00:00
|
|
|
int read_tree_at(struct repository *r,
|
|
|
|
struct tree *tree, struct strbuf *base,
|
|
|
|
const struct pathspec *pathspec,
|
|
|
|
read_tree_fn_t fn, void *context)
|
2005-04-22 23:42:37 +00:00
|
|
|
{
|
2006-05-29 19:17:28 +00:00
|
|
|
struct tree_desc desc;
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-30 16:45:45 +00:00
|
|
|
struct name_entry entry;
|
2017-05-06 22:10:15 +00:00
|
|
|
struct object_id oid;
|
2011-10-24 06:36:10 +00:00
|
|
|
int len, oldlen = base->len;
|
|
|
|
enum interesting retval = entry_not_interesting;
|
2006-05-29 19:17:28 +00:00
|
|
|
|
2006-01-26 06:13:36 +00:00
|
|
|
if (parse_tree(tree))
|
|
|
|
return -1;
|
2006-05-29 19:17:28 +00:00
|
|
|
|
2007-03-21 17:08:25 +00:00
|
|
|
init_tree_desc(&desc, tree->buffer, tree->size);
|
2006-05-29 19:17:28 +00:00
|
|
|
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-30 16:45:45 +00:00
|
|
|
while (tree_entry(&desc, &entry)) {
|
2011-10-24 06:36:10 +00:00
|
|
|
if (retval != all_entries_interesting) {
|
2018-11-18 16:47:57 +00:00
|
|
|
retval = tree_entry_interesting(r->index, &entry,
|
|
|
|
base, 0, pathspec);
|
2011-10-24 06:36:10 +00:00
|
|
|
if (retval == all_entries_not_interesting)
|
2011-03-25 09:34:18 +00:00
|
|
|
break;
|
2011-10-24 06:36:10 +00:00
|
|
|
if (retval == entry_not_interesting)
|
2011-03-25 09:34:18 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-07-14 18:26:31 +00:00
|
|
|
|
2019-01-15 00:39:44 +00:00
|
|
|
switch (fn(&entry.oid, base,
|
2021-03-20 22:37:51 +00:00
|
|
|
entry.path, entry.mode, context)) {
|
2005-11-26 17:38:20 +00:00
|
|
|
case 0:
|
|
|
|
continue;
|
|
|
|
case READ_TREE_RECURSIVE:
|
2009-02-11 01:42:04 +00:00
|
|
|
break;
|
2005-11-26 17:38:20 +00:00
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
2009-01-25 00:52:05 +00:00
|
|
|
|
2011-03-25 09:34:18 +00:00
|
|
|
if (S_ISDIR(entry.mode))
|
2019-01-15 00:39:44 +00:00
|
|
|
oidcpy(&oid, &entry.oid);
|
2011-03-25 09:34:18 +00:00
|
|
|
else if (S_ISGITLINK(entry.mode)) {
|
|
|
|
struct commit *commit;
|
2009-01-25 00:52:05 +00:00
|
|
|
|
2019-01-29 20:47:56 +00:00
|
|
|
commit = lookup_commit(r, &entry.oid);
|
2009-01-25 00:52:05 +00:00
|
|
|
if (!commit)
|
2011-03-25 09:34:18 +00:00
|
|
|
die("Commit %s in submodule path %s%s not found",
|
2019-01-15 00:39:44 +00:00
|
|
|
oid_to_hex(&entry.oid),
|
2011-03-25 09:34:18 +00:00
|
|
|
base->buf, entry.path);
|
2009-01-25 00:52:05 +00:00
|
|
|
|
libs: use "struct repository *" argument, not "the_repository"
As can easily be seen from grepping in our sources, we had these uses
of "the_repository" in various library code in cases where the
function in question was already getting a "struct repository *"
argument. Let's use that argument instead.
Out of these changes only the changes to "cache-tree.c",
"commit-reach.c", "shallow.c" and "upload-pack.c" would have cleanly
applied before the migration away from the "repo_*()" wrapper macros
in the preceding commits.
The rest aren't new, as we'd previously implicitly refer to
"the_repository", but it's now more obvious that we were doing the
wrong thing all along, and should have used the parameter instead.
The change to change "get_index_format_default(the_repository)" in
"read-cache.c" to use the "r" variable instead should arguably have
been part of [1], or in the subsequent cleanup in [2]. Let's do it
here, as can be seen from the initial code in [3] it's not important
that we use "the_repository" there, but would prefer to always use the
current repository.
This change excludes the "the_repository" use in "upload-pack.c"'s
upload_pack_advertise(), as the in-flight [4] makes that change.
1. ee1f0c242ef (read-cache: add index.skipHash config option,
2023-01-06)
2. 6269f8eaad0 (treewide: always have a valid "index_state.repo"
member, 2023-01-17)
3. 7211b9e7534 (repo-settings: consolidate some config settings,
2019-08-13)
4. <Y/hbUsGPVNAxTdmS@coredump.intra.peff.net>
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-03-28 13:58:58 +00:00
|
|
|
if (repo_parse_commit(r, commit))
|
2011-03-25 09:34:18 +00:00
|
|
|
die("Invalid commit %s in submodule path %s%s",
|
2019-01-15 00:39:44 +00:00
|
|
|
oid_to_hex(&entry.oid),
|
2011-03-25 09:34:18 +00:00
|
|
|
base->buf, entry.path);
|
|
|
|
|
2018-04-06 19:09:38 +00:00
|
|
|
oidcpy(&oid, get_commit_tree_oid(commit));
|
2005-04-22 23:42:37 +00:00
|
|
|
}
|
2011-03-25 09:34:18 +00:00
|
|
|
else
|
|
|
|
continue;
|
|
|
|
|
2011-10-24 06:36:09 +00:00
|
|
|
len = tree_entry_len(&entry);
|
2011-03-25 09:34:18 +00:00
|
|
|
strbuf_add(base, entry.path, len);
|
|
|
|
strbuf_addch(base, '/');
|
2021-03-20 22:37:50 +00:00
|
|
|
retval = read_tree_at(r, lookup_tree(r, &oid),
|
2021-03-20 22:37:51 +00:00
|
|
|
base, pathspec,
|
2021-03-20 22:37:50 +00:00
|
|
|
fn, context);
|
2011-03-25 09:34:18 +00:00
|
|
|
strbuf_setlen(base, oldlen);
|
|
|
|
if (retval)
|
|
|
|
return -1;
|
2005-04-22 23:42:37 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-03-20 22:37:51 +00:00
|
|
|
int read_tree(struct repository *r,
|
|
|
|
struct tree *tree,
|
|
|
|
const struct pathspec *pathspec,
|
|
|
|
read_tree_fn_t fn, void *context)
|
2011-03-25 09:34:18 +00:00
|
|
|
{
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2021-03-20 22:37:51 +00:00
|
|
|
int ret = read_tree_at(r, tree, &sb, pathspec, fn, context);
|
2011-03-25 09:34:18 +00:00
|
|
|
strbuf_release(&sb);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2020-12-13 08:04:25 +00:00
|
|
|
int cmp_cache_name_compare(const void *a_, const void *b_)
|
2007-08-09 20:42:50 +00:00
|
|
|
{
|
|
|
|
const struct cache_entry *ce1, *ce2;
|
|
|
|
|
|
|
|
ce1 = *((const struct cache_entry **)a_);
|
|
|
|
ce2 = *((const struct cache_entry **)b_);
|
2012-07-11 09:22:37 +00:00
|
|
|
return cache_name_stage_compare(ce1->name, ce1->ce_namelen, ce_stage(ce1),
|
|
|
|
ce2->name, ce2->ce_namelen, ce_stage(ce2));
|
2007-08-09 20:42:50 +00:00
|
|
|
}
|
|
|
|
|
2018-06-29 01:22:09 +00:00
|
|
|
struct tree *lookup_tree(struct repository *r, const struct object_id *oid)
|
2005-04-18 18:39:48 +00:00
|
|
|
{
|
2019-06-20 07:41:14 +00:00
|
|
|
struct object *obj = lookup_object(r, oid);
|
2007-04-17 05:11:43 +00:00
|
|
|
if (!obj)
|
2019-06-20 07:41:21 +00:00
|
|
|
return create_object(r, oid, alloc_tree_node(r));
|
2020-06-17 09:14:08 +00:00
|
|
|
return object_as_type(obj, OBJ_TREE, 0);
|
2005-04-18 18:39:48 +00:00
|
|
|
}
|
|
|
|
|
2006-05-29 19:18:33 +00:00
|
|
|
int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size)
|
|
|
|
{
|
2005-04-18 18:39:48 +00:00
|
|
|
if (item->object.parsed)
|
|
|
|
return 0;
|
|
|
|
item->object.parsed = 1;
|
2006-05-29 19:16:12 +00:00
|
|
|
item->buffer = buffer;
|
|
|
|
item->size = size;
|
|
|
|
|
2006-05-29 19:18:33 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
add quieter versions of parse_{tree,commit}
When we call parse_commit, it will complain to stderr if the
object does not exist or cannot be read. This means that we
may produce useless error messages if this situation is
expected (e.g., because the object is marked UNINTERESTING,
or because revs->ignore_missing_links is set).
We can fix this by adding a new "parse_X_gently" form that
takes a flag to suppress the messages. The existing
"parse_X" form is already gentle in the sense that it
returns an error rather than dying, and we could in theory
just add a "quiet" flag to it (with existing callers passing
"0"). But doing it this way means we do not have to disturb
existing callers.
Note also that the new flag is "quiet_on_missing", and not
just "quiet". We could add a flag to suppress _all_ errors,
but besides being a more invasive change (we would have to
pass the flag down to sub-functions, too), there is a good
reason not to: we would never want to use it. Missing a
linked object is expected in some circumstances, but it is
never expected to have a malformed commit, or to get a tree
when we wanted a commit. We should always complain about
these corruptions.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-06-01 09:56:26 +00:00
|
|
|
int parse_tree_gently(struct tree *item, int quiet_on_missing)
|
2005-05-06 17:48:34 +00:00
|
|
|
{
|
2007-02-26 19:55:59 +00:00
|
|
|
enum object_type type;
|
2005-05-06 17:48:34 +00:00
|
|
|
void *buffer;
|
|
|
|
unsigned long size;
|
|
|
|
|
|
|
|
if (item->object.parsed)
|
|
|
|
return 0;
|
2023-03-28 13:58:50 +00:00
|
|
|
buffer = repo_read_object_file(the_repository, &item->object.oid,
|
|
|
|
&type, &size);
|
2005-05-06 17:48:34 +00:00
|
|
|
if (!buffer)
|
add quieter versions of parse_{tree,commit}
When we call parse_commit, it will complain to stderr if the
object does not exist or cannot be read. This means that we
may produce useless error messages if this situation is
expected (e.g., because the object is marked UNINTERESTING,
or because revs->ignore_missing_links is set).
We can fix this by adding a new "parse_X_gently" form that
takes a flag to suppress the messages. The existing
"parse_X" form is already gentle in the sense that it
returns an error rather than dying, and we could in theory
just add a "quiet" flag to it (with existing callers passing
"0"). But doing it this way means we do not have to disturb
existing callers.
Note also that the new flag is "quiet_on_missing", and not
just "quiet". We could add a flag to suppress _all_ errors,
but besides being a more invasive change (we would have to
pass the flag down to sub-functions, too), there is a good
reason not to: we would never want to use it. Missing a
linked object is expected in some circumstances, but it is
never expected to have a malformed commit, or to get a tree
when we wanted a commit. We should always complain about
these corruptions.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-06-01 09:56:26 +00:00
|
|
|
return quiet_on_missing ? -1 :
|
|
|
|
error("Could not read %s",
|
2015-11-10 02:22:28 +00:00
|
|
|
oid_to_hex(&item->object.oid));
|
2007-02-26 19:55:59 +00:00
|
|
|
if (type != OBJ_TREE) {
|
2005-05-06 17:48:34 +00:00
|
|
|
free(buffer);
|
|
|
|
return error("Object %s not a tree",
|
2015-11-10 02:22:28 +00:00
|
|
|
oid_to_hex(&item->object.oid));
|
2005-05-06 17:48:34 +00:00
|
|
|
}
|
2006-05-29 19:16:12 +00:00
|
|
|
return parse_tree_buffer(item, buffer, size);
|
2005-05-06 17:48:34 +00:00
|
|
|
}
|
2005-09-05 06:03:51 +00:00
|
|
|
|
2013-06-05 22:37:39 +00:00
|
|
|
void free_tree_buffer(struct tree *tree)
|
|
|
|
{
|
2017-06-15 23:15:46 +00:00
|
|
|
FREE_AND_NULL(tree->buffer);
|
2013-06-05 22:37:39 +00:00
|
|
|
tree->size = 0;
|
|
|
|
tree->object.parsed = 0;
|
|
|
|
}
|
|
|
|
|
2017-05-06 22:10:37 +00:00
|
|
|
struct tree *parse_tree_indirect(const struct object_id *oid)
|
2005-09-05 06:03:51 +00:00
|
|
|
{
|
2019-08-29 19:06:22 +00:00
|
|
|
struct repository *r = the_repository;
|
|
|
|
struct object *obj = parse_object(r, oid);
|
|
|
|
return (struct tree *)repo_peel_to_type(r, NULL, 0, obj, OBJ_TREE);
|
2005-09-05 06:03:51 +00:00
|
|
|
}
|