|
|
|
|
#ifndef TREE_WALK_H
|
|
|
|
|
#define TREE_WALK_H
|
|
|
|
|
|
|
|
|
|
struct name_entry {
|
|
|
|
|
const unsigned char *sha1;
|
|
|
|
|
const char *path;
|
|
|
|
|
unsigned int mode;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct tree_desc {
|
|
|
|
|
const void *buffer;
|
|
|
|
|
struct name_entry entry;
|
|
|
|
|
unsigned int size;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static inline const unsigned char *tree_entry_extract(struct tree_desc *desc, const char **pathp, unsigned int *modep)
|
|
|
|
|
{
|
|
|
|
|
*pathp = desc->entry.path;
|
|
|
|
|
*modep = canon_mode(desc->entry.mode);
|
|
|
|
|
return desc->entry.sha1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int tree_entry_len(const struct name_entry *ne)
|
|
|
|
|
{
|
|
|
|
|
return (const char *)ne->sha1 - ne->path - 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void update_tree_entry(struct tree_desc *);
|
|
|
|
|
void init_tree_desc(struct tree_desc *desc, const void *buf, unsigned long size);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Helper function that does both tree_entry_extract() and update_tree_entry()
|
|
|
|
|
* and returns true for success
|
|
|
|
|
*/
|
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>
19 years ago
|
|
|
int tree_entry(struct tree_desc *, struct name_entry *);
|
|
|
|
|
|
|
|
|
|
void *fill_tree_descriptor(struct tree_desc *desc, const unsigned char *sha1);
|
|
|
|
|
|
|
|
|
|
struct traverse_info;
|
|
|
|
|
typedef int (*traverse_callback_t)(int n, unsigned long mask, unsigned long dirmask, struct name_entry *entry, struct traverse_info *);
|
|
|
|
|
int traverse_trees(int n, struct tree_desc *t, struct traverse_info *info);
|
|
|
|
|
|
|
|
|
|
struct traverse_info {
|
|
|
|
|
struct traverse_info *prev;
|
|
|
|
|
struct name_entry name;
|
|
|
|
|
int pathlen;
|
|
|
|
|
struct pathspec *pathspec;
|
|
|
|
|
|
|
|
|
|
unsigned long conflicts;
|
|
|
|
|
traverse_callback_t fn;
|
|
|
|
|
void *data;
|
|
|
|
|
int show_all_errors;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
int get_tree_entry(const unsigned char *, const char *, unsigned char *, unsigned *);
|
|
|
|
|
extern char *make_traverse_path(char *path, const struct traverse_info *info, const struct name_entry *n);
|
|
|
|
|
extern void setup_traverse_info(struct traverse_info *info, const char *base);
|
|
|
|
|
|
|
|
|
|
static inline int traverse_path_len(const struct traverse_info *info, const struct name_entry *n)
|
|
|
|
|
{
|
|
|
|
|
return info->pathlen + tree_entry_len(n);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* in general, positive means "kind of interesting" */
|
|
|
|
|
enum interesting {
|
|
|
|
|
all_entries_not_interesting = -1, /* no, and no subsequent entries will be either */
|
|
|
|
|
entry_not_interesting = 0,
|
|
|
|
|
entry_interesting = 1,
|
|
|
|
|
all_entries_interesting = 2 /* yes, and all subsequent entries will be */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
extern enum interesting tree_entry_interesting(const struct name_entry *,
|
|
|
|
|
struct strbuf *, int,
|
|
|
|
|
const struct pathspec *ps);
|
|
|
|
|
|
|
|
|
|
#endif
|
