mirror of
https://github.com/git/git
synced 2024-08-25 10:45:59 +00:00
203 lines
4.8 KiB
C
203 lines
4.8 KiB
C
![]() |
#include "cache.h"
|
||
|
#include "dir.h"
|
||
|
#include "iterator.h"
|
||
|
#include "dir-iterator.h"
|
||
|
|
||
|
struct dir_iterator_level {
|
||
|
int initialized;
|
||
|
|
||
|
DIR *dir;
|
||
|
|
||
|
/*
|
||
|
* The length of the directory part of path at this level
|
||
|
* (including a trailing '/'):
|
||
|
*/
|
||
|
size_t prefix_len;
|
||
|
|
||
|
/*
|
||
|
* The last action that has been taken with the current entry
|
||
|
* (needed for directories, which have to be included in the
|
||
|
* iteration and also iterated into):
|
||
|
*/
|
||
|
enum {
|
||
|
DIR_STATE_ITER,
|
||
|
DIR_STATE_RECURSE
|
||
|
} dir_state;
|
||
|
};
|
||
|
|
||
|
/*
|
||
|
* The full data structure used to manage the internal directory
|
||
|
* iteration state. It includes members that are not part of the
|
||
|
* public interface.
|
||
|
*/
|
||
|
struct dir_iterator_int {
|
||
|
struct dir_iterator base;
|
||
|
|
||
|
/*
|
||
|
* The number of levels currently on the stack. This is always
|
||
|
* at least 1, because when it becomes zero the iteration is
|
||
|
* ended and this struct is freed.
|
||
|
*/
|
||
|
size_t levels_nr;
|
||
|
|
||
|
/* The number of levels that have been allocated on the stack */
|
||
|
size_t levels_alloc;
|
||
|
|
||
|
/*
|
||
|
* A stack of levels. levels[0] is the uppermost directory
|
||
|
* that will be included in this iteration.
|
||
|
*/
|
||
|
struct dir_iterator_level *levels;
|
||
|
};
|
||
|
|
||
|
int dir_iterator_advance(struct dir_iterator *dir_iterator)
|
||
|
{
|
||
|
struct dir_iterator_int *iter =
|
||
|
(struct dir_iterator_int *)dir_iterator;
|
||
|
|
||
|
while (1) {
|
||
|
struct dir_iterator_level *level =
|
||
|
&iter->levels[iter->levels_nr - 1];
|
||
|
struct dirent *de;
|
||
|
|
||
|
if (!level->initialized) {
|
||
|
/*
|
||
|
* Note: dir_iterator_begin() ensures that
|
||
|
* path is not the empty string.
|
||
|
*/
|
||
|
if (!is_dir_sep(iter->base.path.buf[iter->base.path.len - 1]))
|
||
|
strbuf_addch(&iter->base.path, '/');
|
||
|
level->prefix_len = iter->base.path.len;
|
||
|
|
||
|
level->dir = opendir(iter->base.path.buf);
|
||
|
if (!level->dir && errno != ENOENT) {
|
||
|
warning("error opening directory %s: %s",
|
||
|
iter->base.path.buf, strerror(errno));
|
||
|
/* Popping the level is handled below */
|
||
|
}
|
||
|
|
||
|
level->initialized = 1;
|
||
|
} else if (S_ISDIR(iter->base.st.st_mode)) {
|
||
|
if (level->dir_state == DIR_STATE_ITER) {
|
||
|
/*
|
||
|
* The directory was just iterated
|
||
|
* over; now prepare to iterate into
|
||
|
* it.
|
||
|
*/
|
||
|
level->dir_state = DIR_STATE_RECURSE;
|
||
|
ALLOC_GROW(iter->levels, iter->levels_nr + 1,
|
||
|
iter->levels_alloc);
|
||
|
level = &iter->levels[iter->levels_nr++];
|
||
|
level->initialized = 0;
|
||
|
continue;
|
||
|
} else {
|
||
|
/*
|
||
|
* The directory has already been
|
||
|
* iterated over and iterated into;
|
||
|
* we're done with it.
|
||
|
*/
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (!level->dir) {
|
||
|
/*
|
||
|
* This level is exhausted (or wasn't opened
|
||
|
* successfully); pop up a level.
|
||
|
*/
|
||
|
if (--iter->levels_nr == 0)
|
||
|
return dir_iterator_abort(dir_iterator);
|
||
|
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Loop until we find an entry that we can give back
|
||
|
* to the caller:
|
||
|
*/
|
||
|
while (1) {
|
||
|
strbuf_setlen(&iter->base.path, level->prefix_len);
|
||
|
errno = 0;
|
||
|
de = readdir(level->dir);
|
||
|
|
||
|
if (!de) {
|
||
|
/* This level is exhausted; pop up a level. */
|
||
|
if (errno) {
|
||
|
warning("error reading directory %s: %s",
|
||
|
iter->base.path.buf, strerror(errno));
|
||
|
} else if (closedir(level->dir))
|
||
|
warning("error closing directory %s: %s",
|
||
|
iter->base.path.buf, strerror(errno));
|
||
|
|
||
|
level->dir = NULL;
|
||
|
if (--iter->levels_nr == 0)
|
||
|
return dir_iterator_abort(dir_iterator);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
if (is_dot_or_dotdot(de->d_name))
|
||
|
continue;
|
||
|
|
||
|
strbuf_addstr(&iter->base.path, de->d_name);
|
||
|
if (lstat(iter->base.path.buf, &iter->base.st) < 0) {
|
||
|
if (errno != ENOENT)
|
||
|
warning("error reading path '%s': %s",
|
||
|
iter->base.path.buf,
|
||
|
strerror(errno));
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* We have to set these each time because
|
||
|
* the path strbuf might have been realloc()ed.
|
||
|
*/
|
||
|
iter->base.relative_path =
|
||
|
iter->base.path.buf + iter->levels[0].prefix_len;
|
||
|
iter->base.basename =
|
||
|
iter->base.path.buf + level->prefix_len;
|
||
|
level->dir_state = DIR_STATE_ITER;
|
||
|
|
||
|
return ITER_OK;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
int dir_iterator_abort(struct dir_iterator *dir_iterator)
|
||
|
{
|
||
|
struct dir_iterator_int *iter = (struct dir_iterator_int *)dir_iterator;
|
||
|
|
||
|
for (; iter->levels_nr; iter->levels_nr--) {
|
||
|
struct dir_iterator_level *level =
|
||
|
&iter->levels[iter->levels_nr - 1];
|
||
|
|
||
|
if (level->dir && closedir(level->dir)) {
|
||
|
strbuf_setlen(&iter->base.path, level->prefix_len);
|
||
|
warning("error closing directory %s: %s",
|
||
|
iter->base.path.buf, strerror(errno));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
free(iter->levels);
|
||
|
strbuf_release(&iter->base.path);
|
||
|
free(iter);
|
||
|
return ITER_DONE;
|
||
|
}
|
||
|
|
||
|
struct dir_iterator *dir_iterator_begin(const char *path)
|
||
|
{
|
||
|
struct dir_iterator_int *iter = xcalloc(1, sizeof(*iter));
|
||
|
struct dir_iterator *dir_iterator = &iter->base;
|
||
|
|
||
|
if (!path || !*path)
|
||
|
die("BUG: empty path passed to dir_iterator_begin()");
|
||
|
|
||
|
strbuf_init(&iter->base.path, PATH_MAX);
|
||
|
strbuf_addstr(&iter->base.path, path);
|
||
|
|
||
|
ALLOC_GROW(iter->levels, 10, iter->levels_alloc);
|
||
|
|
||
|
iter->levels_nr = 1;
|
||
|
iter->levels[0].initialized = 0;
|
||
|
|
||
|
return dir_iterator;
|
||
|
}
|