2006-03-30 10:55:43 +04:00
|
|
|
#include "cache.h"
|
|
|
|
#include "tree-walk.h"
|
2006-04-02 16:44:09 +04:00
|
|
|
#include "tree.h"
|
2006-03-30 10:55:43 +04:00
|
|
|
|
2007-03-21 20:09:56 +03:00
|
|
|
static const char *get_mode(const char *str, unsigned int *modep)
|
|
|
|
{
|
|
|
|
unsigned char c;
|
|
|
|
unsigned int mode = 0;
|
|
|
|
|
|
|
|
while ((c = *str++) != ' ') {
|
|
|
|
if (c < '0' || c > '7')
|
|
|
|
return NULL;
|
|
|
|
mode = (mode << 3) + (c - '0');
|
|
|
|
}
|
|
|
|
*modep = mode;
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void decode_tree_entry(struct tree_desc *desc, const void *buf, unsigned long size)
|
|
|
|
{
|
|
|
|
const char *path;
|
|
|
|
unsigned int mode, len;
|
|
|
|
|
|
|
|
path = get_mode(buf, &mode);
|
|
|
|
if (!path)
|
|
|
|
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 20:08:25 +03:00
|
|
|
void init_tree_desc(struct tree_desc *desc, const void *buffer, unsigned long size)
|
|
|
|
{
|
|
|
|
desc->buffer = buffer;
|
|
|
|
desc->size = size;
|
2007-03-21 20:09:56 +03:00
|
|
|
if (size)
|
|
|
|
decode_tree_entry(desc, buffer, size);
|
2007-03-21 20:08:25 +03:00
|
|
|
}
|
|
|
|
|
2006-03-30 10:55:43 +04: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 16:44:09 +04:00
|
|
|
buf = read_object_with_reference(sha1, tree_type, &size, NULL);
|
2006-03-30 10:55:43 +04:00
|
|
|
if (!buf)
|
|
|
|
die("unable to read tree %s", sha1_to_hex(sha1));
|
|
|
|
}
|
2007-03-21 20:08:25 +03:00
|
|
|
init_tree_desc(desc, buf, size);
|
2006-03-30 10:55:43 +04:00
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int entry_compare(struct name_entry *a, struct name_entry *b)
|
|
|
|
{
|
|
|
|
return base_name_compare(
|
2007-03-21 20:07:46 +03:00
|
|
|
a->path, tree_entry_len(a->path, a->sha1), a->mode,
|
|
|
|
b->path, tree_entry_len(b->path, b->sha1), b->mode);
|
2006-03-30 10:55:43 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
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 20:09:56 +03:00
|
|
|
*a = t->entry;
|
2006-03-30 10:55:43 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void update_tree_entry(struct tree_desc *desc)
|
|
|
|
{
|
2007-03-21 20:08:25 +03:00
|
|
|
const void *buf = desc->buffer;
|
2007-03-21 20:09:56 +03:00
|
|
|
const unsigned char *end = desc->entry.sha1 + 20;
|
2006-03-30 10:55:43 +04:00
|
|
|
unsigned long size = desc->size;
|
2007-03-21 20:09:56 +03:00
|
|
|
unsigned long len = end - (const unsigned char *)buf;
|
2006-03-30 10:55:43 +04:00
|
|
|
|
|
|
|
if (size < len)
|
|
|
|
die("corrupt tree file");
|
2007-03-21 20:09:56 +03:00
|
|
|
buf = end;
|
|
|
|
size -= len;
|
|
|
|
desc->buffer = buf;
|
|
|
|
desc->size = size;
|
|
|
|
if (size)
|
|
|
|
decode_tree_entry(desc, buf, size);
|
2006-03-30 10:55:43 +04: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 20:45:45 +04:00
|
|
|
int tree_entry(struct tree_desc *desc, struct name_entry *entry)
|
|
|
|
{
|
2007-03-21 20:09:56 +03: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 20:45:45 +04:00
|
|
|
return 0;
|
|
|
|
|
2007-03-21 20:09:56 +03: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 20:45:45 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2006-03-30 10:55:43 +04:00
|
|
|
void traverse_trees(int n, struct tree_desc *t, const char *base, traverse_callback_t callback)
|
|
|
|
{
|
|
|
|
struct name_entry *entry = xmalloc(n*sizeof(*entry));
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
unsigned long mask = 0;
|
|
|
|
int i, last;
|
|
|
|
|
|
|
|
last = -1;
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
if (!t[i].size)
|
|
|
|
continue;
|
|
|
|
entry_extract(t+i, entry+i);
|
|
|
|
if (last >= 0) {
|
|
|
|
int cmp = entry_compare(entry+i, entry+last);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Is the new name bigger than the old one?
|
|
|
|
* Ignore it
|
|
|
|
*/
|
|
|
|
if (cmp > 0)
|
|
|
|
continue;
|
|
|
|
/*
|
|
|
|
* Is the new name smaller than the old one?
|
|
|
|
* Ignore all old ones
|
|
|
|
*/
|
|
|
|
if (cmp < 0)
|
|
|
|
mask = 0;
|
|
|
|
}
|
|
|
|
mask |= 1ul << i;
|
|
|
|
last = i;
|
|
|
|
}
|
|
|
|
if (!mask)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Update the tree entries we've walked, and clear
|
|
|
|
* all the unused name-entries.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
if (mask & (1ul << i)) {
|
|
|
|
update_tree_entry(t+i);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
entry_clear(entry + i);
|
|
|
|
}
|
|
|
|
callback(n, mask, entry, base);
|
|
|
|
}
|
|
|
|
free(entry);
|
|
|
|
}
|
|
|
|
|
2006-04-20 01:05:47 +04: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 06:06:24 +03:00
|
|
|
entrylen = tree_entry_len(entry, sha1);
|
2006-04-20 01:05:47 +04:00
|
|
|
if (entrylen > namelen)
|
|
|
|
continue;
|
|
|
|
cmp = memcmp(name, entry, entrylen);
|
|
|
|
if (cmp > 0)
|
|
|
|
continue;
|
|
|
|
if (cmp < 0)
|
|
|
|
break;
|
|
|
|
if (entrylen == namelen) {
|
2006-08-23 10:49:00 +04:00
|
|
|
hashcpy(result, sha1);
|
2006-04-20 01:05:47 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (name[entrylen] != '/')
|
|
|
|
continue;
|
|
|
|
if (!S_ISDIR(*mode))
|
|
|
|
break;
|
|
|
|
if (++entrylen == namelen) {
|
2006-08-23 10:49:00 +04:00
|
|
|
hashcpy(result, sha1);
|
2006-04-20 01:05:47 +04: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 20:08:25 +03:00
|
|
|
unsigned long size;
|
2006-04-20 01:05:47 +04:00
|
|
|
struct tree_desc t;
|
2007-01-09 19:11:47 +03:00
|
|
|
unsigned char root[20];
|
2006-04-20 01:05:47 +04:00
|
|
|
|
2007-03-21 20:08:25 +03:00
|
|
|
tree = read_object_with_reference(tree_sha1, tree_type, &size, root);
|
2006-04-20 01:05:47 +04:00
|
|
|
if (!tree)
|
|
|
|
return -1;
|
2007-01-09 19:11:47 +03:00
|
|
|
|
|
|
|
if (name[0] == '\0') {
|
|
|
|
hashcpy(sha1, root);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-03-21 20:08:25 +03:00
|
|
|
init_tree_desc(&t, tree, size);
|
2006-04-20 01:05:47 +04:00
|
|
|
retval = find_tree_entry(&t, name, sha1, mode);
|
|
|
|
free(tree);
|
|
|
|
return retval;
|
|
|
|
}
|