2006-03-30 06:55:43 +00:00
|
|
|
#include "cache.h"
|
|
|
|
#include "tree-walk.h"
|
2010-08-11 08:38:07 +00:00
|
|
|
#include "unpack-trees.h"
|
2006-04-02 12:44:09 +00:00
|
|
|
#include "tree.h"
|
2006-03-30 06:55:43 +00:00
|
|
|
|
2007-03-21 17:09:56 +00:00
|
|
|
static const char *get_mode(const char *str, unsigned int *modep)
|
|
|
|
{
|
|
|
|
unsigned char c;
|
|
|
|
unsigned int mode = 0;
|
|
|
|
|
2008-01-06 17:21:10 +00:00
|
|
|
if (*str == ' ')
|
|
|
|
return NULL;
|
|
|
|
|
2007-03-21 17:09:56 +00:00
|
|
|
while ((c = *str++) != ' ') {
|
|
|
|
if (c < '0' || c > '7')
|
|
|
|
return NULL;
|
|
|
|
mode = (mode << 3) + (c - '0');
|
|
|
|
}
|
|
|
|
*modep = mode;
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
2008-01-06 17:21:10 +00:00
|
|
|
static void decode_tree_entry(struct tree_desc *desc, const char *buf, unsigned long size)
|
2007-03-21 17:09:56 +00:00
|
|
|
{
|
|
|
|
const char *path;
|
|
|
|
unsigned int mode, len;
|
|
|
|
|
2008-01-06 17:21:10 +00:00
|
|
|
if (size < 24 || buf[size - 21])
|
|
|
|
die("corrupt tree file");
|
|
|
|
|
2007-03-21 17:09:56 +00:00
|
|
|
path = get_mode(buf, &mode);
|
2008-01-06 17:21:10 +00:00
|
|
|
if (!path || !*path)
|
2007-03-21 17:09:56 +00:00
|
|
|
die("corrupt tree file");
|
|
|
|
len = strlen(path) + 1;
|
|
|
|
|
|
|
|
/* Initialize the descriptor entry */
|
|
|
|
desc->entry.path = path;
|
|
|
|
desc->entry.mode = mode;
|
|
|
|
desc->entry.sha1 = (const unsigned char *)(path + len);
|
|
|
|
}
|
|
|
|
|
2007-03-21 17:08:25 +00:00
|
|
|
void init_tree_desc(struct tree_desc *desc, const void *buffer, unsigned long size)
|
|
|
|
{
|
|
|
|
desc->buffer = buffer;
|
|
|
|
desc->size = size;
|
2007-03-21 17:09:56 +00:00
|
|
|
if (size)
|
|
|
|
decode_tree_entry(desc, buffer, size);
|
2007-03-21 17:08:25 +00:00
|
|
|
}
|
|
|
|
|
2006-03-30 06:55:43 +00:00
|
|
|
void *fill_tree_descriptor(struct tree_desc *desc, const unsigned char *sha1)
|
|
|
|
{
|
|
|
|
unsigned long size = 0;
|
|
|
|
void *buf = NULL;
|
|
|
|
|
|
|
|
if (sha1) {
|
2006-04-02 12:44:09 +00:00
|
|
|
buf = read_object_with_reference(sha1, tree_type, &size, NULL);
|
2006-03-30 06:55:43 +00:00
|
|
|
if (!buf)
|
|
|
|
die("unable to read tree %s", sha1_to_hex(sha1));
|
|
|
|
}
|
2007-03-21 17:08:25 +00:00
|
|
|
init_tree_desc(desc, buf, size);
|
2006-03-30 06:55:43 +00:00
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void entry_clear(struct name_entry *a)
|
|
|
|
{
|
|
|
|
memset(a, 0, sizeof(*a));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void entry_extract(struct tree_desc *t, struct name_entry *a)
|
|
|
|
{
|
2007-03-21 17:09:56 +00:00
|
|
|
*a = t->entry;
|
2006-03-30 06:55:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void update_tree_entry(struct tree_desc *desc)
|
|
|
|
{
|
2007-03-21 17:08:25 +00:00
|
|
|
const void *buf = desc->buffer;
|
2007-03-21 17:09:56 +00:00
|
|
|
const unsigned char *end = desc->entry.sha1 + 20;
|
2006-03-30 06:55:43 +00:00
|
|
|
unsigned long size = desc->size;
|
2007-03-21 17:09:56 +00:00
|
|
|
unsigned long len = end - (const unsigned char *)buf;
|
2006-03-30 06:55:43 +00:00
|
|
|
|
|
|
|
if (size < len)
|
|
|
|
die("corrupt tree file");
|
2007-03-21 17:09:56 +00:00
|
|
|
buf = end;
|
|
|
|
size -= len;
|
|
|
|
desc->buffer = buf;
|
|
|
|
desc->size = size;
|
|
|
|
if (size)
|
|
|
|
decode_tree_entry(desc, buf, size);
|
2006-03-30 06:55:43 +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
|
|
|
int tree_entry(struct tree_desc *desc, struct name_entry *entry)
|
|
|
|
{
|
2007-03-21 17:09:56 +00:00
|
|
|
if (!desc->size)
|
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
|
|
|
return 0;
|
|
|
|
|
2007-03-21 17:09:56 +00:00
|
|
|
*entry = desc->entry;
|
|
|
|
update_tree_entry(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
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-03-06 02:59:29 +00:00
|
|
|
void setup_traverse_info(struct traverse_info *info, const char *base)
|
|
|
|
{
|
|
|
|
int pathlen = strlen(base);
|
2008-03-06 23:44:48 +00:00
|
|
|
static struct traverse_info dummy;
|
2008-03-06 02:59:29 +00:00
|
|
|
|
|
|
|
memset(info, 0, sizeof(*info));
|
|
|
|
if (pathlen && base[pathlen-1] == '/')
|
|
|
|
pathlen--;
|
|
|
|
info->pathlen = pathlen ? pathlen + 1 : 0;
|
|
|
|
info->name.path = base;
|
|
|
|
info->name.sha1 = (void *)(base + pathlen + 1);
|
2008-03-06 23:44:48 +00:00
|
|
|
if (pathlen)
|
|
|
|
info->prev = &dummy;
|
2008-03-06 02:59:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
char *make_traverse_path(char *path, const struct traverse_info *info, const struct name_entry *n)
|
|
|
|
{
|
|
|
|
int len = tree_entry_len(n->path, n->sha1);
|
|
|
|
int pathlen = info->pathlen;
|
|
|
|
|
|
|
|
path[pathlen + len] = 0;
|
|
|
|
for (;;) {
|
|
|
|
memcpy(path + pathlen, n->path, len);
|
|
|
|
if (!pathlen)
|
|
|
|
break;
|
|
|
|
path[--pathlen] = '/';
|
|
|
|
n = &info->name;
|
|
|
|
len = tree_entry_len(n->path, n->sha1);
|
|
|
|
info = info->prev;
|
|
|
|
pathlen -= len;
|
|
|
|
}
|
|
|
|
return path;
|
|
|
|
}
|
|
|
|
|
traverse_trees(): handle D/F conflict case sanely
traverse_trees() is supposed to call its callback with all the matching
entries from the given trees. The current algorithm keeps a pointer to
each of the tree being traversed, and feeds the entry with the earliest
name to the callback.
This breaks down if the trees being traversed looks like this:
A B
t-1 t
t-2 u
t/a v
When we are currently looking at an entry "t-1" in tree A, and tree B has
returned "t", feeding "t" from the B and not feeding anything from A, only
because "t-1" sorts later than "t", will miss an entry for a subtree "t"
behind the current entry in tree A.
This introduces extended_entry_extract() helper function that gives what
name is expected from the tree, and implements a mechanism to look-ahead
in the tree object using it, to make sure such a case is handled sanely.
Traversal in tree A in the above example will first return "t" to match
that of B, and then the next request for an entry to A then returns "t-1".
This roughly corresponds to what Linus's "prepare for one-entry lookahead"
wanted to do, but because this does implement look ahead, t6035 and one more
test in t1012 reveal that the approach would not work without adjusting the
side that walks the index in unpack_trees() as well.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-09-19 21:07:14 +00:00
|
|
|
struct tree_desc_skip {
|
|
|
|
struct tree_desc_skip *prev;
|
|
|
|
const void *ptr;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct tree_desc_x {
|
|
|
|
struct tree_desc d;
|
|
|
|
struct tree_desc_skip *skip;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int name_compare(const char *a, int a_len,
|
|
|
|
const char *b, int b_len)
|
|
|
|
{
|
|
|
|
int len = (a_len < b_len) ? a_len : b_len;
|
|
|
|
int cmp = memcmp(a, b, len);
|
|
|
|
if (cmp)
|
|
|
|
return cmp;
|
|
|
|
return (a_len - b_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int check_entry_match(const char *a, int a_len, const char *b, int b_len)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* The caller wants to pick *a* from a tree or nothing.
|
|
|
|
* We are looking at *b* in a tree.
|
|
|
|
*
|
|
|
|
* (0) If a and b are the same name, we are trivially happy.
|
|
|
|
*
|
|
|
|
* There are three possibilities where *a* could be hiding
|
|
|
|
* behind *b*.
|
|
|
|
*
|
|
|
|
* (1) *a* == "t", *b* == "ab" i.e. *b* sorts earlier than *a* no
|
|
|
|
* matter what.
|
|
|
|
* (2) *a* == "t", *b* == "t-2" and "t" is a subtree in the tree;
|
|
|
|
* (3) *a* == "t-2", *b* == "t" and "t-2" is a blob in the tree.
|
|
|
|
*
|
|
|
|
* Otherwise we know *a* won't appear in the tree without
|
|
|
|
* scanning further.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int cmp = name_compare(a, a_len, b, b_len);
|
|
|
|
|
|
|
|
/* Most common case first -- reading sync'd trees */
|
|
|
|
if (!cmp)
|
|
|
|
return cmp;
|
|
|
|
|
|
|
|
if (0 < cmp) {
|
|
|
|
/* a comes after b; it does not matter if it is case (3)
|
|
|
|
if (b_len < a_len && !memcmp(a, b, b_len) && a[b_len] < '/')
|
|
|
|
return 1;
|
|
|
|
*/
|
|
|
|
return 1; /* keep looking */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* b comes after a; are we looking at case (2)? */
|
|
|
|
if (a_len < b_len && !memcmp(a, b, a_len) && b[a_len] < '/')
|
|
|
|
return 1; /* keep looking */
|
|
|
|
|
|
|
|
return -1; /* a cannot appear in the tree */
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* From the extended tree_desc, extract the first name entry, while
|
|
|
|
* paying attention to the candidate "first" name. Most importantly,
|
|
|
|
* when looking for an entry, if there are entries that sorts earlier
|
|
|
|
* in the tree object representation than that name, skip them and
|
|
|
|
* process the named entry first. We will remember that we haven't
|
|
|
|
* processed the first entry yet, and in the later call skip the
|
|
|
|
* entry we processed early when update_extended_entry() is called.
|
|
|
|
*
|
|
|
|
* E.g. if the underlying tree object has these entries:
|
|
|
|
*
|
|
|
|
* blob "t-1"
|
|
|
|
* blob "t-2"
|
|
|
|
* tree "t"
|
|
|
|
* blob "t=1"
|
|
|
|
*
|
|
|
|
* and the "first" asks for "t", remember that we still need to
|
|
|
|
* process "t-1" and "t-2" but extract "t". After processing the
|
|
|
|
* entry "t" from this call, the caller will let us know by calling
|
|
|
|
* update_extended_entry() that we can remember "t" has been processed
|
|
|
|
* already.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void extended_entry_extract(struct tree_desc_x *t,
|
|
|
|
struct name_entry *a,
|
|
|
|
const char *first,
|
|
|
|
int first_len)
|
|
|
|
{
|
|
|
|
const char *path;
|
|
|
|
int len;
|
|
|
|
struct tree_desc probe;
|
|
|
|
struct tree_desc_skip *skip;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Extract the first entry from the tree_desc, but skip the
|
|
|
|
* ones that we already returned in earlier rounds.
|
|
|
|
*/
|
|
|
|
while (1) {
|
|
|
|
if (!t->d.size) {
|
|
|
|
entry_clear(a);
|
|
|
|
break; /* not found */
|
|
|
|
}
|
|
|
|
entry_extract(&t->d, a);
|
|
|
|
for (skip = t->skip; skip; skip = skip->prev)
|
|
|
|
if (a->path == skip->ptr)
|
|
|
|
break; /* found */
|
|
|
|
if (!skip)
|
|
|
|
break;
|
|
|
|
/* We have processed this entry already. */
|
|
|
|
update_tree_entry(&t->d);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!first || !a->path)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The caller wants "first" from this tree, or nothing.
|
|
|
|
*/
|
|
|
|
path = a->path;
|
|
|
|
len = tree_entry_len(a->path, a->sha1);
|
|
|
|
switch (check_entry_match(first, first_len, path, len)) {
|
|
|
|
case -1:
|
|
|
|
entry_clear(a);
|
|
|
|
case 0:
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to look-ahead -- we suspect that a subtree whose
|
|
|
|
* name is "first" may be hiding behind the current entry "path".
|
|
|
|
*/
|
|
|
|
probe = t->d;
|
|
|
|
while (probe.size) {
|
|
|
|
entry_extract(&probe, a);
|
|
|
|
path = a->path;
|
|
|
|
len = tree_entry_len(a->path, a->sha1);
|
|
|
|
switch (check_entry_match(first, first_len, path, len)) {
|
|
|
|
case -1:
|
|
|
|
entry_clear(a);
|
|
|
|
case 0:
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
update_tree_entry(&probe);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* keep looking */
|
|
|
|
}
|
|
|
|
entry_clear(a);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void update_extended_entry(struct tree_desc_x *t, struct name_entry *a)
|
|
|
|
{
|
|
|
|
if (t->d.entry.path == a->path) {
|
|
|
|
update_tree_entry(&t->d);
|
|
|
|
} else {
|
|
|
|
/* we have returned this entry early */
|
|
|
|
struct tree_desc_skip *skip = xmalloc(sizeof(*skip));
|
|
|
|
skip->ptr = a->path;
|
|
|
|
skip->prev = t->skip;
|
|
|
|
t->skip = skip;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_extended_entry(struct tree_desc_x *t)
|
|
|
|
{
|
|
|
|
struct tree_desc_skip *p, *s;
|
|
|
|
|
|
|
|
for (s = t->skip; s; s = p) {
|
|
|
|
p = s->prev;
|
|
|
|
free(s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-03-06 03:44:06 +00:00
|
|
|
int traverse_trees(int n, struct tree_desc *t, struct traverse_info *info)
|
2006-03-30 06:55:43 +00:00
|
|
|
{
|
2008-03-06 03:44:06 +00:00
|
|
|
int ret = 0;
|
2010-08-11 08:38:07 +00:00
|
|
|
int error = 0;
|
2006-03-30 06:55:43 +00:00
|
|
|
struct name_entry *entry = xmalloc(n*sizeof(*entry));
|
traverse_trees(): handle D/F conflict case sanely
traverse_trees() is supposed to call its callback with all the matching
entries from the given trees. The current algorithm keeps a pointer to
each of the tree being traversed, and feeds the entry with the earliest
name to the callback.
This breaks down if the trees being traversed looks like this:
A B
t-1 t
t-2 u
t/a v
When we are currently looking at an entry "t-1" in tree A, and tree B has
returned "t", feeding "t" from the B and not feeding anything from A, only
because "t-1" sorts later than "t", will miss an entry for a subtree "t"
behind the current entry in tree A.
This introduces extended_entry_extract() helper function that gives what
name is expected from the tree, and implements a mechanism to look-ahead
in the tree object using it, to make sure such a case is handled sanely.
Traversal in tree A in the above example will first return "t" to match
that of B, and then the next request for an entry to A then returns "t-1".
This roughly corresponds to what Linus's "prepare for one-entry lookahead"
wanted to do, but because this does implement look ahead, t6035 and one more
test in t1012 reveal that the approach would not work without adjusting the
side that walks the index in unpack_trees() as well.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-09-19 21:07:14 +00:00
|
|
|
int i;
|
|
|
|
struct tree_desc_x *tx = xcalloc(n, sizeof(*tx));
|
|
|
|
|
|
|
|
for (i = 0; i < n; i++)
|
|
|
|
tx[i].d = t[i];
|
2006-03-30 06:55:43 +00:00
|
|
|
|
|
|
|
for (;;) {
|
traverse_trees(): handle D/F conflict case sanely
traverse_trees() is supposed to call its callback with all the matching
entries from the given trees. The current algorithm keeps a pointer to
each of the tree being traversed, and feeds the entry with the earliest
name to the callback.
This breaks down if the trees being traversed looks like this:
A B
t-1 t
t-2 u
t/a v
When we are currently looking at an entry "t-1" in tree A, and tree B has
returned "t", feeding "t" from the B and not feeding anything from A, only
because "t-1" sorts later than "t", will miss an entry for a subtree "t"
behind the current entry in tree A.
This introduces extended_entry_extract() helper function that gives what
name is expected from the tree, and implements a mechanism to look-ahead
in the tree object using it, to make sure such a case is handled sanely.
Traversal in tree A in the above example will first return "t" to match
that of B, and then the next request for an entry to A then returns "t-1".
This roughly corresponds to what Linus's "prepare for one-entry lookahead"
wanted to do, but because this does implement look ahead, t6035 and one more
test in t1012 reveal that the approach would not work without adjusting the
side that walks the index in unpack_trees() as well.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-09-19 21:07:14 +00:00
|
|
|
unsigned long mask, dirmask;
|
|
|
|
const char *first = NULL;
|
|
|
|
int first_len = 0;
|
|
|
|
struct name_entry *e;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
e = entry + i;
|
|
|
|
extended_entry_extract(tx + i, e, NULL, 0);
|
|
|
|
}
|
2006-03-30 06:55:43 +00:00
|
|
|
|
traverse_trees(): handle D/F conflict case sanely
traverse_trees() is supposed to call its callback with all the matching
entries from the given trees. The current algorithm keeps a pointer to
each of the tree being traversed, and feeds the entry with the earliest
name to the callback.
This breaks down if the trees being traversed looks like this:
A B
t-1 t
t-2 u
t/a v
When we are currently looking at an entry "t-1" in tree A, and tree B has
returned "t", feeding "t" from the B and not feeding anything from A, only
because "t-1" sorts later than "t", will miss an entry for a subtree "t"
behind the current entry in tree A.
This introduces extended_entry_extract() helper function that gives what
name is expected from the tree, and implements a mechanism to look-ahead
in the tree object using it, to make sure such a case is handled sanely.
Traversal in tree A in the above example will first return "t" to match
that of B, and then the next request for an entry to A then returns "t-1".
This roughly corresponds to what Linus's "prepare for one-entry lookahead"
wanted to do, but because this does implement look ahead, t6035 and one more
test in t1012 reveal that the approach would not work without adjusting the
side that walks the index in unpack_trees() as well.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-09-19 21:07:14 +00:00
|
|
|
/*
|
|
|
|
* A tree may have "t-2" at the current location even
|
|
|
|
* though it may have "t" that is a subtree behind it,
|
|
|
|
* and another tree may return "t". We want to grab
|
|
|
|
* all "t" from all trees to match in such a case.
|
|
|
|
*/
|
2006-03-30 06:55:43 +00:00
|
|
|
for (i = 0; i < n; i++) {
|
traverse_trees(): handle D/F conflict case sanely
traverse_trees() is supposed to call its callback with all the matching
entries from the given trees. The current algorithm keeps a pointer to
each of the tree being traversed, and feeds the entry with the earliest
name to the callback.
This breaks down if the trees being traversed looks like this:
A B
t-1 t
t-2 u
t/a v
When we are currently looking at an entry "t-1" in tree A, and tree B has
returned "t", feeding "t" from the B and not feeding anything from A, only
because "t-1" sorts later than "t", will miss an entry for a subtree "t"
behind the current entry in tree A.
This introduces extended_entry_extract() helper function that gives what
name is expected from the tree, and implements a mechanism to look-ahead
in the tree object using it, to make sure such a case is handled sanely.
Traversal in tree A in the above example will first return "t" to match
that of B, and then the next request for an entry to A then returns "t-1".
This roughly corresponds to what Linus's "prepare for one-entry lookahead"
wanted to do, but because this does implement look ahead, t6035 and one more
test in t1012 reveal that the approach would not work without adjusting the
side that walks the index in unpack_trees() as well.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-09-19 21:07:14 +00:00
|
|
|
e = entry + i;
|
|
|
|
if (!e->path)
|
2006-03-30 06:55:43 +00:00
|
|
|
continue;
|
traverse_trees(): handle D/F conflict case sanely
traverse_trees() is supposed to call its callback with all the matching
entries from the given trees. The current algorithm keeps a pointer to
each of the tree being traversed, and feeds the entry with the earliest
name to the callback.
This breaks down if the trees being traversed looks like this:
A B
t-1 t
t-2 u
t/a v
When we are currently looking at an entry "t-1" in tree A, and tree B has
returned "t", feeding "t" from the B and not feeding anything from A, only
because "t-1" sorts later than "t", will miss an entry for a subtree "t"
behind the current entry in tree A.
This introduces extended_entry_extract() helper function that gives what
name is expected from the tree, and implements a mechanism to look-ahead
in the tree object using it, to make sure such a case is handled sanely.
Traversal in tree A in the above example will first return "t" to match
that of B, and then the next request for an entry to A then returns "t-1".
This roughly corresponds to what Linus's "prepare for one-entry lookahead"
wanted to do, but because this does implement look ahead, t6035 and one more
test in t1012 reveal that the approach would not work without adjusting the
side that walks the index in unpack_trees() as well.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-09-19 21:07:14 +00:00
|
|
|
len = tree_entry_len(e->path, e->sha1);
|
|
|
|
if (!first) {
|
|
|
|
first = e->path;
|
|
|
|
first_len = len;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (name_compare(e->path, len, first, first_len) < 0) {
|
|
|
|
first = e->path;
|
|
|
|
first_len = len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (first) {
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
e = entry + i;
|
|
|
|
extended_entry_extract(tx + i, e, first, first_len);
|
|
|
|
/* Cull the ones that are not the earliest */
|
|
|
|
if (!e->path)
|
2006-03-30 06:55:43 +00:00
|
|
|
continue;
|
traverse_trees(): handle D/F conflict case sanely
traverse_trees() is supposed to call its callback with all the matching
entries from the given trees. The current algorithm keeps a pointer to
each of the tree being traversed, and feeds the entry with the earliest
name to the callback.
This breaks down if the trees being traversed looks like this:
A B
t-1 t
t-2 u
t/a v
When we are currently looking at an entry "t-1" in tree A, and tree B has
returned "t", feeding "t" from the B and not feeding anything from A, only
because "t-1" sorts later than "t", will miss an entry for a subtree "t"
behind the current entry in tree A.
This introduces extended_entry_extract() helper function that gives what
name is expected from the tree, and implements a mechanism to look-ahead
in the tree object using it, to make sure such a case is handled sanely.
Traversal in tree A in the above example will first return "t" to match
that of B, and then the next request for an entry to A then returns "t-1".
This roughly corresponds to what Linus's "prepare for one-entry lookahead"
wanted to do, but because this does implement look ahead, t6035 and one more
test in t1012 reveal that the approach would not work without adjusting the
side that walks the index in unpack_trees() as well.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-09-19 21:07:14 +00:00
|
|
|
len = tree_entry_len(e->path, e->sha1);
|
|
|
|
if (name_compare(e->path, len, first, first_len))
|
|
|
|
entry_clear(e);
|
2006-03-30 06:55:43 +00:00
|
|
|
}
|
traverse_trees(): handle D/F conflict case sanely
traverse_trees() is supposed to call its callback with all the matching
entries from the given trees. The current algorithm keeps a pointer to
each of the tree being traversed, and feeds the entry with the earliest
name to the callback.
This breaks down if the trees being traversed looks like this:
A B
t-1 t
t-2 u
t/a v
When we are currently looking at an entry "t-1" in tree A, and tree B has
returned "t", feeding "t" from the B and not feeding anything from A, only
because "t-1" sorts later than "t", will miss an entry for a subtree "t"
behind the current entry in tree A.
This introduces extended_entry_extract() helper function that gives what
name is expected from the tree, and implements a mechanism to look-ahead
in the tree object using it, to make sure such a case is handled sanely.
Traversal in tree A in the above example will first return "t" to match
that of B, and then the next request for an entry to A then returns "t-1".
This roughly corresponds to what Linus's "prepare for one-entry lookahead"
wanted to do, but because this does implement look ahead, t6035 and one more
test in t1012 reveal that the approach would not work without adjusting the
side that walks the index in unpack_trees() as well.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-09-19 21:07:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Now we have in entry[i] the earliest name from the trees */
|
|
|
|
mask = 0;
|
|
|
|
dirmask = 0;
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
if (!entry[i].path)
|
|
|
|
continue;
|
2006-03-30 06:55:43 +00:00
|
|
|
mask |= 1ul << i;
|
2008-03-06 04:06:18 +00:00
|
|
|
if (S_ISDIR(entry[i].mode))
|
|
|
|
dirmask |= 1ul << i;
|
2006-03-30 06:55:43 +00:00
|
|
|
}
|
|
|
|
if (!mask)
|
|
|
|
break;
|
2008-03-06 04:06:18 +00:00
|
|
|
ret = info->fn(n, mask, dirmask, entry, info);
|
2010-08-11 08:38:07 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
error = ret;
|
|
|
|
if (!info->show_all_errors)
|
|
|
|
break;
|
|
|
|
}
|
traverse_trees(): handle D/F conflict case sanely
traverse_trees() is supposed to call its callback with all the matching
entries from the given trees. The current algorithm keeps a pointer to
each of the tree being traversed, and feeds the entry with the earliest
name to the callback.
This breaks down if the trees being traversed looks like this:
A B
t-1 t
t-2 u
t/a v
When we are currently looking at an entry "t-1" in tree A, and tree B has
returned "t", feeding "t" from the B and not feeding anything from A, only
because "t-1" sorts later than "t", will miss an entry for a subtree "t"
behind the current entry in tree A.
This introduces extended_entry_extract() helper function that gives what
name is expected from the tree, and implements a mechanism to look-ahead
in the tree object using it, to make sure such a case is handled sanely.
Traversal in tree A in the above example will first return "t" to match
that of B, and then the next request for an entry to A then returns "t-1".
This roughly corresponds to what Linus's "prepare for one-entry lookahead"
wanted to do, but because this does implement look ahead, t6035 and one more
test in t1012 reveal that the approach would not work without adjusting the
side that walks the index in unpack_trees() as well.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-09-19 21:07:14 +00:00
|
|
|
mask &= ret;
|
2008-03-06 03:44:06 +00:00
|
|
|
ret = 0;
|
traverse_trees(): handle D/F conflict case sanely
traverse_trees() is supposed to call its callback with all the matching
entries from the given trees. The current algorithm keeps a pointer to
each of the tree being traversed, and feeds the entry with the earliest
name to the callback.
This breaks down if the trees being traversed looks like this:
A B
t-1 t
t-2 u
t/a v
When we are currently looking at an entry "t-1" in tree A, and tree B has
returned "t", feeding "t" from the B and not feeding anything from A, only
because "t-1" sorts later than "t", will miss an entry for a subtree "t"
behind the current entry in tree A.
This introduces extended_entry_extract() helper function that gives what
name is expected from the tree, and implements a mechanism to look-ahead
in the tree object using it, to make sure such a case is handled sanely.
Traversal in tree A in the above example will first return "t" to match
that of B, and then the next request for an entry to A then returns "t-1".
This roughly corresponds to what Linus's "prepare for one-entry lookahead"
wanted to do, but because this does implement look ahead, t6035 and one more
test in t1012 reveal that the approach would not work without adjusting the
side that walks the index in unpack_trees() as well.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-09-19 21:07:14 +00:00
|
|
|
for (i = 0; i < n; i++)
|
2008-03-06 03:44:06 +00:00
|
|
|
if (mask & (1ul << i))
|
traverse_trees(): handle D/F conflict case sanely
traverse_trees() is supposed to call its callback with all the matching
entries from the given trees. The current algorithm keeps a pointer to
each of the tree being traversed, and feeds the entry with the earliest
name to the callback.
This breaks down if the trees being traversed looks like this:
A B
t-1 t
t-2 u
t/a v
When we are currently looking at an entry "t-1" in tree A, and tree B has
returned "t", feeding "t" from the B and not feeding anything from A, only
because "t-1" sorts later than "t", will miss an entry for a subtree "t"
behind the current entry in tree A.
This introduces extended_entry_extract() helper function that gives what
name is expected from the tree, and implements a mechanism to look-ahead
in the tree object using it, to make sure such a case is handled sanely.
Traversal in tree A in the above example will first return "t" to match
that of B, and then the next request for an entry to A then returns "t-1".
This roughly corresponds to what Linus's "prepare for one-entry lookahead"
wanted to do, but because this does implement look ahead, t6035 and one more
test in t1012 reveal that the approach would not work without adjusting the
side that walks the index in unpack_trees() as well.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-09-19 21:07:14 +00:00
|
|
|
update_extended_entry(tx + i, entry + i);
|
2006-03-30 06:55:43 +00:00
|
|
|
}
|
|
|
|
free(entry);
|
traverse_trees(): handle D/F conflict case sanely
traverse_trees() is supposed to call its callback with all the matching
entries from the given trees. The current algorithm keeps a pointer to
each of the tree being traversed, and feeds the entry with the earliest
name to the callback.
This breaks down if the trees being traversed looks like this:
A B
t-1 t
t-2 u
t/a v
When we are currently looking at an entry "t-1" in tree A, and tree B has
returned "t", feeding "t" from the B and not feeding anything from A, only
because "t-1" sorts later than "t", will miss an entry for a subtree "t"
behind the current entry in tree A.
This introduces extended_entry_extract() helper function that gives what
name is expected from the tree, and implements a mechanism to look-ahead
in the tree object using it, to make sure such a case is handled sanely.
Traversal in tree A in the above example will first return "t" to match
that of B, and then the next request for an entry to A then returns "t-1".
This roughly corresponds to what Linus's "prepare for one-entry lookahead"
wanted to do, but because this does implement look ahead, t6035 and one more
test in t1012 reveal that the approach would not work without adjusting the
side that walks the index in unpack_trees() as well.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-09-19 21:07:14 +00:00
|
|
|
for (i = 0; i < n; i++)
|
|
|
|
free_extended_entry(tx + i);
|
|
|
|
free(tx);
|
2010-08-11 08:38:07 +00:00
|
|
|
return error;
|
2006-03-30 06:55:43 +00:00
|
|
|
}
|
|
|
|
|
2006-04-19 21:05:47 +00:00
|
|
|
static int find_tree_entry(struct tree_desc *t, const char *name, unsigned char *result, unsigned *mode)
|
|
|
|
{
|
|
|
|
int namelen = strlen(name);
|
|
|
|
while (t->size) {
|
|
|
|
const char *entry;
|
|
|
|
const unsigned char *sha1;
|
|
|
|
int entrylen, cmp;
|
|
|
|
|
|
|
|
sha1 = tree_entry_extract(t, &entry, mode);
|
|
|
|
update_tree_entry(t);
|
2007-03-18 03:06:24 +00:00
|
|
|
entrylen = tree_entry_len(entry, sha1);
|
2006-04-19 21:05:47 +00:00
|
|
|
if (entrylen > namelen)
|
|
|
|
continue;
|
|
|
|
cmp = memcmp(name, entry, entrylen);
|
|
|
|
if (cmp > 0)
|
|
|
|
continue;
|
|
|
|
if (cmp < 0)
|
|
|
|
break;
|
|
|
|
if (entrylen == namelen) {
|
2006-08-23 06:49:00 +00:00
|
|
|
hashcpy(result, sha1);
|
2006-04-19 21:05:47 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (name[entrylen] != '/')
|
|
|
|
continue;
|
|
|
|
if (!S_ISDIR(*mode))
|
|
|
|
break;
|
|
|
|
if (++entrylen == namelen) {
|
2006-08-23 06:49:00 +00:00
|
|
|
hashcpy(result, sha1);
|
2006-04-19 21:05:47 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return get_tree_entry(sha1, name + entrylen, result, mode);
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int get_tree_entry(const unsigned char *tree_sha1, const char *name, unsigned char *sha1, unsigned *mode)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
void *tree;
|
2007-03-21 17:08:25 +00:00
|
|
|
unsigned long size;
|
2006-04-19 21:05:47 +00:00
|
|
|
struct tree_desc t;
|
2007-01-09 16:11:47 +00:00
|
|
|
unsigned char root[20];
|
2006-04-19 21:05:47 +00:00
|
|
|
|
2007-03-21 17:08:25 +00:00
|
|
|
tree = read_object_with_reference(tree_sha1, tree_type, &size, root);
|
2006-04-19 21:05:47 +00:00
|
|
|
if (!tree)
|
|
|
|
return -1;
|
2007-01-09 16:11:47 +00:00
|
|
|
|
|
|
|
if (name[0] == '\0') {
|
|
|
|
hashcpy(sha1, root);
|
2010-02-14 09:56:46 +00:00
|
|
|
free(tree);
|
2007-01-09 16:11:47 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-03-21 17:08:25 +00:00
|
|
|
init_tree_desc(&t, tree, size);
|
2006-04-19 21:05:47 +00:00
|
|
|
retval = find_tree_entry(&t, name, sha1, mode);
|
|
|
|
free(tree);
|
|
|
|
return retval;
|
|
|
|
}
|