--- /dev/null
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "iterator.h"
+
+#include "tree.h"
+#include "index.h"
+#include "path.h"
+
+#define GIT_ITERATOR_FIRST_ACCESS (1 << 15)
+#define GIT_ITERATOR_HONOR_IGNORES (1 << 16)
+#define GIT_ITERATOR_IGNORE_DOT_GIT (1 << 17)
+
+#define iterator__flag(I,F) ((((git_iterator *)(I))->flags & GIT_ITERATOR_ ## F) != 0)
+#define iterator__ignore_case(I) iterator__flag(I,IGNORE_CASE)
+#define iterator__include_trees(I) iterator__flag(I,INCLUDE_TREES)
+#define iterator__dont_autoexpand(I) iterator__flag(I,DONT_AUTOEXPAND)
+#define iterator__do_autoexpand(I) !iterator__flag(I,DONT_AUTOEXPAND)
+#define iterator__include_conflicts(I) iterator__flag(I,INCLUDE_CONFLICTS)
+#define iterator__has_been_accessed(I) iterator__flag(I,FIRST_ACCESS)
+#define iterator__honor_ignores(I) iterator__flag(I,HONOR_IGNORES)
+#define iterator__ignore_dot_git(I) iterator__flag(I,IGNORE_DOT_GIT)
+#define iterator__descend_symlinks(I) iterator__flag(I,DESCEND_SYMLINKS)
+
+
+static void iterator_set_ignore_case(git_iterator *iter, bool ignore_case)
+{
+ if (ignore_case)
+ iter->flags |= GIT_ITERATOR_IGNORE_CASE;
+ else
+ iter->flags &= ~GIT_ITERATOR_IGNORE_CASE;
+
+ iter->strcomp = ignore_case ? git__strcasecmp : git__strcmp;
+ iter->strncomp = ignore_case ? git__strncasecmp : git__strncmp;
+ iter->prefixcomp = ignore_case ? git__prefixcmp_icase : git__prefixcmp;
+ iter->entry_srch = ignore_case ? git_index_entry_isrch : git_index_entry_srch;
+
+ git_vector_set_cmp(&iter->pathlist, (git_vector_cmp)iter->strcomp);
+}
+
+static int iterator_range_init(
+ git_iterator *iter, const char *start, const char *end)
+{
+ if (start && *start) {
+ iter->start = git__strdup(start);
+ GIT_ERROR_CHECK_ALLOC(iter->start);
+
+ iter->start_len = strlen(iter->start);
+ }
+
+ if (end && *end) {
+ iter->end = git__strdup(end);
+ GIT_ERROR_CHECK_ALLOC(iter->end);
+
+ iter->end_len = strlen(iter->end);
+ }
+
+ iter->started = (iter->start == NULL);
+ iter->ended = false;
+
+ return 0;
+}
+
+static void iterator_range_free(git_iterator *iter)
+{
+ if (iter->start) {
+ git__free(iter->start);
+ iter->start = NULL;
+ iter->start_len = 0;
+ }
+
+ if (iter->end) {
+ git__free(iter->end);
+ iter->end = NULL;
+ iter->end_len = 0;
+ }
+}
+
+static int iterator_reset_range(
+ git_iterator *iter, const char *start, const char *end)
+{
+ iterator_range_free(iter);
+ return iterator_range_init(iter, start, end);
+}
+
+static int iterator_pathlist_init(git_iterator *iter, git_strarray *pathlist)
+{
+ size_t i;
+
+ if (git_vector_init(&iter->pathlist, pathlist->count, NULL) < 0)
+ return -1;
+
+ for (i = 0; i < pathlist->count; i++) {
+ if (!pathlist->strings[i])
+ continue;
+
+ if (git_vector_insert(&iter->pathlist, pathlist->strings[i]) < 0)
+ return -1;
+ }
+
+ return 0;
+}
+
+static int iterator_init_common(
+ git_iterator *iter,
+ git_repository *repo,
+ git_index *index,
+ git_iterator_options *given_opts)
+{
+ static git_iterator_options default_opts = GIT_ITERATOR_OPTIONS_INIT;
+ git_iterator_options *options = given_opts ? given_opts : &default_opts;
+ bool ignore_case;
+ int precompose;
+ int error;
+
+ iter->repo = repo;
+ iter->index = index;
+ iter->flags = options->flags;
+
+ if ((iter->flags & GIT_ITERATOR_IGNORE_CASE) != 0) {
+ ignore_case = true;
+ } else if ((iter->flags & GIT_ITERATOR_DONT_IGNORE_CASE) != 0) {
+ ignore_case = false;
+ } else if (repo) {
+ git_index *index;
+
+ if ((error = git_repository_index__weakptr(&index, iter->repo)) < 0)
+ return error;
+
+ ignore_case = !!index->ignore_case;
+
+ if (ignore_case == 1)
+ iter->flags |= GIT_ITERATOR_IGNORE_CASE;
+ else
+ iter->flags |= GIT_ITERATOR_DONT_IGNORE_CASE;
+ } else {
+ ignore_case = false;
+ }
+
+ /* try to look up precompose and set flag if appropriate */
+ if (repo &&
+ (iter->flags & GIT_ITERATOR_PRECOMPOSE_UNICODE) == 0 &&
+ (iter->flags & GIT_ITERATOR_DONT_PRECOMPOSE_UNICODE) == 0) {
+
+ if (git_repository__configmap_lookup(&precompose, repo, GIT_CONFIGMAP_PRECOMPOSE) < 0)
+ git_error_clear();
+ else if (precompose)
+ iter->flags |= GIT_ITERATOR_PRECOMPOSE_UNICODE;
+ }
+
+ if ((iter->flags & GIT_ITERATOR_DONT_AUTOEXPAND))
+ iter->flags |= GIT_ITERATOR_INCLUDE_TREES;
+
+ if ((error = iterator_range_init(iter, options->start, options->end)) < 0 ||
+ (error = iterator_pathlist_init(iter, &options->pathlist)) < 0)
+ return error;
+
+ iterator_set_ignore_case(iter, ignore_case);
+ return 0;
+}
+
+static void iterator_clear(git_iterator *iter)
+{
+ iter->started = false;
+ iter->ended = false;
+ iter->stat_calls = 0;
+ iter->pathlist_walk_idx = 0;
+ iter->flags &= ~GIT_ITERATOR_FIRST_ACCESS;
+}
+
+GIT_INLINE(bool) iterator_has_started(
+ git_iterator *iter, const char *path, bool is_submodule)
+{
+ size_t path_len;
+
+ if (iter->start == NULL || iter->started == true)
+ return true;
+
+ /* the starting path is generally a prefix - we have started once we
+ * are prefixed by this path
+ */
+ iter->started = (iter->prefixcomp(path, iter->start) >= 0);
+
+ if (iter->started)
+ return true;
+
+ path_len = strlen(path);
+
+ /* if, however, we are a submodule, then we support `start` being
+ * suffixed with a `/` for crazy legacy reasons. match `submod`
+ * with a start path of `submod/`.
+ */
+ if (is_submodule && iter->start_len && path_len == iter->start_len - 1 &&
+ iter->start[iter->start_len-1] == '/')
+ return true;
+
+ /* if, however, our current path is a directory, and our starting path
+ * is _beneath_ that directory, then recurse into the directory (even
+ * though we have not yet "started")
+ */
+ if (path_len > 0 && path[path_len-1] == '/' &&
+ iter->strncomp(path, iter->start, path_len) == 0)
+ return true;
+
+ return false;
+}
+
+GIT_INLINE(bool) iterator_has_ended(git_iterator *iter, const char *path)
+{
+ if (iter->end == NULL)
+ return false;
+ else if (iter->ended)
+ return true;
+
+ iter->ended = (iter->prefixcomp(path, iter->end) > 0);
+ return iter->ended;
+}
+
+/* walker for the index and tree iterator that allows it to walk the sorted
+ * pathlist entries alongside sorted iterator entries.
+ */
+static bool iterator_pathlist_next_is(git_iterator *iter, const char *path)
+{
+ char *p;
+ size_t path_len, p_len, cmp_len, i;
+ int cmp;
+
+ if (iter->pathlist.length == 0)
+ return true;
+
+ git_vector_sort(&iter->pathlist);
+
+ path_len = strlen(path);
+
+ /* for comparison, drop the trailing slash on the current '/' */
+ if (path_len && path[path_len-1] == '/')
+ path_len--;
+
+ for (i = iter->pathlist_walk_idx; i < iter->pathlist.length; i++) {
+ p = iter->pathlist.contents[i];
+ p_len = strlen(p);
+
+ if (p_len && p[p_len-1] == '/')
+ p_len--;
+
+ cmp_len = min(path_len, p_len);
+
+ /* see if the pathlist entry is a prefix of this path */
+ cmp = iter->strncomp(p, path, cmp_len);
+
+ /* prefix match - see if there's an exact match, or if we were
+ * given a path that matches the directory
+ */
+ if (cmp == 0) {
+ /* if this pathlist entry is not suffixed with a '/' then
+ * it matches a path that is a file or a directory.
+ * (eg, pathlist = "foo" and path is "foo" or "foo/" or
+ * "foo/something")
+ */
+ if (p[cmp_len] == '\0' &&
+ (path[cmp_len] == '\0' || path[cmp_len] == '/'))
+ return true;
+
+ /* if this pathlist entry _is_ suffixed with a '/' then
+ * it matches only paths that are directories.
+ * (eg, pathlist = "foo/" and path is "foo/" or "foo/something")
+ */
+ if (p[cmp_len] == '/' && path[cmp_len] == '/')
+ return true;
+ }
+
+ /* this pathlist entry sorts before the given path, try the next */
+ else if (cmp < 0) {
+ iter->pathlist_walk_idx++;
+ continue;
+ }
+
+ /* this pathlist sorts after the given path, no match. */
+ else if (cmp > 0) {
+ break;
+ }
+ }
+
+ return false;
+}
+
+typedef enum {
+ ITERATOR_PATHLIST_NONE = 0,
+ ITERATOR_PATHLIST_IS_FILE = 1,
+ ITERATOR_PATHLIST_IS_DIR = 2,
+ ITERATOR_PATHLIST_IS_PARENT = 3,
+ ITERATOR_PATHLIST_FULL = 4
+} iterator_pathlist_search_t;
+
+static iterator_pathlist_search_t iterator_pathlist_search(
+ git_iterator *iter, const char *path, size_t path_len)
+{
+ const char *p;
+ size_t idx;
+ int error;
+
+ if (iter->pathlist.length == 0)
+ return ITERATOR_PATHLIST_FULL;
+
+ git_vector_sort(&iter->pathlist);
+
+ error = git_vector_bsearch2(&idx, &iter->pathlist,
+ (git_vector_cmp)iter->strcomp, path);
+
+ /* the given path was found in the pathlist. since the pathlist only
+ * matches directories when they're suffixed with a '/', analyze the
+ * path string to determine whether it's a directory or not.
+ */
+ if (error == 0) {
+ if (path_len && path[path_len-1] == '/')
+ return ITERATOR_PATHLIST_IS_DIR;
+
+ return ITERATOR_PATHLIST_IS_FILE;
+ }
+
+ /* at this point, the path we're examining may be a directory (though we
+ * don't know that yet, since we're avoiding a stat unless it's necessary)
+ * so walk the pathlist looking for the given path with a '/' after it,
+ */
+ while ((p = git_vector_get(&iter->pathlist, idx)) != NULL) {
+ if (iter->prefixcomp(p, path) != 0)
+ break;
+
+ /* an exact match would have been matched by the bsearch above */
+ GIT_ASSERT_WITH_RETVAL(p[path_len], ITERATOR_PATHLIST_NONE);
+
+ /* is this a literal directory entry (eg `foo/`) or a file beneath */
+ if (p[path_len] == '/') {
+ return (p[path_len+1] == '\0') ?
+ ITERATOR_PATHLIST_IS_DIR :
+ ITERATOR_PATHLIST_IS_PARENT;
+ }
+
+ if (p[path_len] > '/')
+ break;
+
+ idx++;
+ }
+
+ return ITERATOR_PATHLIST_NONE;
+}
+
+/* Empty iterator */
+
+static int empty_iterator_noop(const git_index_entry **e, git_iterator *i)
+{
+ GIT_UNUSED(i);
+
+ if (e)
+ *e = NULL;
+
+ return GIT_ITEROVER;
+}
+
+static int empty_iterator_advance_over(
+ const git_index_entry **e,
+ git_iterator_status_t *s,
+ git_iterator *i)
+{
+ *s = GIT_ITERATOR_STATUS_EMPTY;
+ return empty_iterator_noop(e, i);
+}
+
+static int empty_iterator_reset(git_iterator *i)
+{
+ GIT_UNUSED(i);
+ return 0;
+}
+
+static void empty_iterator_free(git_iterator *i)
+{
+ GIT_UNUSED(i);
+}
+
+typedef struct {
+ git_iterator base;
+ git_iterator_callbacks cb;
+} empty_iterator;
+
+int git_iterator_for_nothing(
+ git_iterator **out,
+ git_iterator_options *options)
+{
+ empty_iterator *iter;
+
+ static git_iterator_callbacks callbacks = {
+ empty_iterator_noop,
+ empty_iterator_noop,
+ empty_iterator_noop,
+ empty_iterator_advance_over,
+ empty_iterator_reset,
+ empty_iterator_free
+ };
+
+ *out = NULL;
+
+ iter = git__calloc(1, sizeof(empty_iterator));
+ GIT_ERROR_CHECK_ALLOC(iter);
+
+ iter->base.type = GIT_ITERATOR_EMPTY;
+ iter->base.cb = &callbacks;
+ iter->base.flags = options->flags;
+
+ *out = &iter->base;
+ return 0;
+}
+
+/* Tree iterator */
+
+typedef struct {
+ git_tree_entry *tree_entry;
+ const char *parent_path;
+} tree_iterator_entry;
+
+typedef struct {
+ git_tree *tree;
+
+ /* path to this particular frame (folder) */
+ git_str path;
+
+ /* a sorted list of the entries for this frame (folder), these are
+ * actually pointers to the iterator's entry pool.
+ */
+ git_vector entries;
+ tree_iterator_entry *current;
+
+ size_t next_idx;
+
+ /* on case insensitive iterations, we also have an array of other
+ * paths that were case insensitively equal to this one, and their
+ * tree objects. we have coalesced the tree entries into this frame.
+ * a child `tree_iterator_entry` will contain a pointer to its actual
+ * parent path.
+ */
+ git_vector similar_trees;
+ git_array_t(git_str) similar_paths;
+} tree_iterator_frame;
+
+typedef struct {
+ git_iterator base;
+ git_tree *root;
+ git_array_t(tree_iterator_frame) frames;
+
+ git_index_entry entry;
+ git_str entry_path;
+
+ /* a pool of entries to reduce the number of allocations */
+ git_pool entry_pool;
+} tree_iterator;
+
+GIT_INLINE(tree_iterator_frame *) tree_iterator_parent_frame(
+ tree_iterator *iter)
+{
+ return iter->frames.size > 1 ?
+ &iter->frames.ptr[iter->frames.size-2] : NULL;
+}
+
+GIT_INLINE(tree_iterator_frame *) tree_iterator_current_frame(
+ tree_iterator *iter)
+{
+ return iter->frames.size ? &iter->frames.ptr[iter->frames.size-1] : NULL;
+}
+
+GIT_INLINE(int) tree_entry_cmp(
+ const git_tree_entry *a, const git_tree_entry *b, bool icase)
+{
+ return git_fs_path_cmp(
+ a->filename, a->filename_len, a->attr == GIT_FILEMODE_TREE,
+ b->filename, b->filename_len, b->attr == GIT_FILEMODE_TREE,
+ icase ? git__strncasecmp : git__strncmp);
+}
+
+GIT_INLINE(int) tree_iterator_entry_cmp_icase(
+ const void *ptr_a, const void *ptr_b)
+{
+ const tree_iterator_entry *a = (const tree_iterator_entry *)ptr_a;
+ const tree_iterator_entry *b = (const tree_iterator_entry *)ptr_b;
+
+ return tree_entry_cmp(a->tree_entry, b->tree_entry, true);
+}
+
+static int tree_iterator_entry_sort_icase(const void *ptr_a, const void *ptr_b)
+{
+ const tree_iterator_entry *a = (const tree_iterator_entry *)ptr_a;
+ const tree_iterator_entry *b = (const tree_iterator_entry *)ptr_b;
+
+ int c = tree_entry_cmp(a->tree_entry, b->tree_entry, true);
+
+ /* stabilize the sort order for filenames that are (case insensitively)
+ * the same by examining the parent path (case sensitively) before
+ * falling back to a case sensitive sort of the filename.
+ */
+ if (!c && a->parent_path != b->parent_path)
+ c = git__strcmp(a->parent_path, b->parent_path);
+
+ if (!c)
+ c = tree_entry_cmp(a->tree_entry, b->tree_entry, false);
+
+ return c;
+}
+
+static int tree_iterator_compute_path(
+ git_str *out,
+ tree_iterator_entry *entry)
+{
+ git_str_clear(out);
+
+ if (entry->parent_path)
+ git_str_joinpath(out, entry->parent_path, entry->tree_entry->filename);
+ else
+ git_str_puts(out, entry->tree_entry->filename);
+
+ if (git_tree_entry__is_tree(entry->tree_entry))
+ git_str_putc(out, '/');
+
+ if (git_str_oom(out))
+ return -1;
+
+ return 0;
+}
+
+static int tree_iterator_frame_init(
+ tree_iterator *iter,
+ git_tree *tree,
+ tree_iterator_entry *frame_entry)
+{
+ tree_iterator_frame *new_frame = NULL;
+ tree_iterator_entry *new_entry;
+ git_tree *dup = NULL;
+ git_tree_entry *tree_entry;
+ git_vector_cmp cmp;
+ size_t i;
+ int error = 0;
+
+ new_frame = git_array_alloc(iter->frames);
+ GIT_ERROR_CHECK_ALLOC(new_frame);
+
+ if ((error = git_tree_dup(&dup, tree)) < 0)
+ goto done;
+
+ memset(new_frame, 0x0, sizeof(tree_iterator_frame));
+ new_frame->tree = dup;
+
+ if (frame_entry &&
+ (error = tree_iterator_compute_path(&new_frame->path, frame_entry)) < 0)
+ goto done;
+
+ cmp = iterator__ignore_case(&iter->base) ?
+ tree_iterator_entry_sort_icase : NULL;
+
+ if ((error = git_vector_init(&new_frame->entries,
+ dup->entries.size, cmp)) < 0)
+ goto done;
+
+ git_array_foreach(dup->entries, i, tree_entry) {
+ if ((new_entry = git_pool_malloc(&iter->entry_pool, 1)) == NULL) {
+ git_error_set_oom();
+ error = -1;
+ goto done;
+ }
+
+ new_entry->tree_entry = tree_entry;
+ new_entry->parent_path = new_frame->path.ptr;
+
+ if ((error = git_vector_insert(&new_frame->entries, new_entry)) < 0)
+ goto done;
+ }
+
+ git_vector_set_sorted(&new_frame->entries,
+ !iterator__ignore_case(&iter->base));
+
+done:
+ if (error < 0) {
+ git_tree_free(dup);
+ git_array_pop(iter->frames);
+ }
+
+ return error;
+}
+
+GIT_INLINE(tree_iterator_entry *) tree_iterator_current_entry(
+ tree_iterator_frame *frame)
+{
+ return frame->current;
+}
+
+GIT_INLINE(int) tree_iterator_frame_push_neighbors(
+ tree_iterator *iter,
+ tree_iterator_frame *parent_frame,
+ tree_iterator_frame *frame,
+ const char *filename)
+{
+ tree_iterator_entry *entry, *new_entry;
+ git_tree *tree = NULL;
+ git_tree_entry *tree_entry;
+ git_str *path;
+ size_t new_size, i;
+ int error = 0;
+
+ while (parent_frame->next_idx < parent_frame->entries.length) {
+ entry = parent_frame->entries.contents[parent_frame->next_idx];
+
+ if (strcasecmp(filename, entry->tree_entry->filename) != 0)
+ break;
+
+ if ((error = git_tree_lookup(&tree,
+ iter->base.repo, &entry->tree_entry->oid)) < 0)
+ break;
+
+ if (git_vector_insert(&parent_frame->similar_trees, tree) < 0)
+ break;
+
+ path = git_array_alloc(parent_frame->similar_paths);
+ GIT_ERROR_CHECK_ALLOC(path);
+
+ memset(path, 0, sizeof(git_str));
+
+ if ((error = tree_iterator_compute_path(path, entry)) < 0)
+ break;
+
+ GIT_ERROR_CHECK_ALLOC_ADD(&new_size,
+ frame->entries.length, tree->entries.size);
+ git_vector_size_hint(&frame->entries, new_size);
+
+ git_array_foreach(tree->entries, i, tree_entry) {
+ new_entry = git_pool_malloc(&iter->entry_pool, 1);
+ GIT_ERROR_CHECK_ALLOC(new_entry);
+
+ new_entry->tree_entry = tree_entry;
+ new_entry->parent_path = path->ptr;
+
+ if ((error = git_vector_insert(&frame->entries, new_entry)) < 0)
+ break;
+ }
+
+ if (error)
+ break;
+
+ parent_frame->next_idx++;
+ }
+
+ return error;
+}
+
+GIT_INLINE(int) tree_iterator_frame_push(
+ tree_iterator *iter, tree_iterator_entry *entry)
+{
+ tree_iterator_frame *parent_frame, *frame;
+ git_tree *tree = NULL;
+ int error;
+
+ if ((error = git_tree_lookup(&tree,
+ iter->base.repo, &entry->tree_entry->oid)) < 0 ||
+ (error = tree_iterator_frame_init(iter, tree, entry)) < 0)
+ goto done;
+
+ parent_frame = tree_iterator_parent_frame(iter);
+ frame = tree_iterator_current_frame(iter);
+
+ /* if we're case insensitive, then we may have another directory that
+ * is (case insensitively) equal to this one. coalesce those children
+ * into this tree.
+ */
+ if (iterator__ignore_case(&iter->base))
+ error = tree_iterator_frame_push_neighbors(iter,
+ parent_frame, frame, entry->tree_entry->filename);
+
+done:
+ git_tree_free(tree);
+ return error;
+}
+
+static int tree_iterator_frame_pop(tree_iterator *iter)
+{
+ tree_iterator_frame *frame;
+ git_str *buf = NULL;
+ git_tree *tree;
+ size_t i;
+
+ GIT_ASSERT(iter->frames.size);
+
+ frame = git_array_pop(iter->frames);
+
+ git_vector_free(&frame->entries);
+ git_tree_free(frame->tree);
+
+ do {
+ buf = git_array_pop(frame->similar_paths);
+ git_str_dispose(buf);
+ } while (buf != NULL);
+
+ git_array_clear(frame->similar_paths);
+
+ git_vector_foreach(&frame->similar_trees, i, tree)
+ git_tree_free(tree);
+
+ git_vector_free(&frame->similar_trees);
+
+ git_str_dispose(&frame->path);
+
+ return 0;
+}
+
+static int tree_iterator_current(
+ const git_index_entry **out, git_iterator *i)
+{
+ tree_iterator *iter = (tree_iterator *)i;
+
+ if (!iterator__has_been_accessed(i))
+ return iter->base.cb->advance(out, i);
+
+ if (!iter->frames.size) {
+ *out = NULL;
+ return GIT_ITEROVER;
+ }
+
+ *out = &iter->entry;
+ return 0;
+}
+
+static void tree_iterator_set_current(
+ tree_iterator *iter,
+ tree_iterator_frame *frame,
+ tree_iterator_entry *entry)
+{
+ git_tree_entry *tree_entry = entry->tree_entry;
+
+ frame->current = entry;
+
+ memset(&iter->entry, 0x0, sizeof(git_index_entry));
+
+ iter->entry.mode = tree_entry->attr;
+ iter->entry.path = iter->entry_path.ptr;
+ git_oid_cpy(&iter->entry.id, &tree_entry->oid);
+}
+
+static int tree_iterator_advance(const git_index_entry **out, git_iterator *i)
+{
+ tree_iterator *iter = (tree_iterator *)i;
+ int error = 0;
+
+ iter->base.flags |= GIT_ITERATOR_FIRST_ACCESS;
+
+ /* examine tree entries until we find the next one to return */
+ while (true) {
+ tree_iterator_entry *prev_entry, *entry;
+ tree_iterator_frame *frame;
+ bool is_tree;
+
+ if ((frame = tree_iterator_current_frame(iter)) == NULL) {
+ error = GIT_ITEROVER;
+ break;
+ }
+
+ /* no more entries in this frame. pop the frame out */
+ if (frame->next_idx == frame->entries.length) {
+ if ((error = tree_iterator_frame_pop(iter)) < 0)
+ break;
+
+ continue;
+ }
+
+ /* we may have coalesced the contents of case-insensitively same-named
+ * directories, so do the sort now.
+ */
+ if (frame->next_idx == 0 && !git_vector_is_sorted(&frame->entries))
+ git_vector_sort(&frame->entries);
+
+ /* we have more entries in the current frame, that's our next entry */
+ prev_entry = tree_iterator_current_entry(frame);
+ entry = frame->entries.contents[frame->next_idx];
+ frame->next_idx++;
+
+ /* we can have collisions when iterating case insensitively. (eg,
+ * 'A/a' and 'a/A'). squash this one if it's already been seen.
+ */
+ if (iterator__ignore_case(&iter->base) &&
+ prev_entry &&
+ tree_iterator_entry_cmp_icase(prev_entry, entry) == 0)
+ continue;
+
+ if ((error = tree_iterator_compute_path(&iter->entry_path, entry)) < 0)
+ break;
+
+ /* if this path is before our start, advance over this entry */
+ if (!iterator_has_started(&iter->base, iter->entry_path.ptr, false))
+ continue;
+
+ /* if this path is after our end, stop */
+ if (iterator_has_ended(&iter->base, iter->entry_path.ptr)) {
+ error = GIT_ITEROVER;
+ break;
+ }
+
+ /* if we have a list of paths we're interested in, examine it */
+ if (!iterator_pathlist_next_is(&iter->base, iter->entry_path.ptr))
+ continue;
+
+ is_tree = git_tree_entry__is_tree(entry->tree_entry);
+
+ /* if we are *not* including trees then advance over this entry */
+ if (is_tree && !iterator__include_trees(iter)) {
+
+ /* if we've found a tree (and are not returning it to the caller)
+ * and we are autoexpanding, then we want to return the first
+ * child. push the new directory and advance.
+ */
+ if (iterator__do_autoexpand(iter)) {
+ if ((error = tree_iterator_frame_push(iter, entry)) < 0)
+ break;
+ }
+
+ continue;
+ }
+
+ tree_iterator_set_current(iter, frame, entry);
+
+ /* if we are autoexpanding, then push this as a new frame, so that
+ * the next call to `advance` will dive into this directory.
+ */
+ if (is_tree && iterator__do_autoexpand(iter))
+ error = tree_iterator_frame_push(iter, entry);
+
+ break;
+ }
+
+ if (out)
+ *out = (error == 0) ? &iter->entry : NULL;
+
+ return error;
+}
+
+static int tree_iterator_advance_into(
+ const git_index_entry **out, git_iterator *i)
+{
+ tree_iterator *iter = (tree_iterator *)i;
+ tree_iterator_frame *frame;
+ tree_iterator_entry *prev_entry;
+ int error;
+
+ if (out)
+ *out = NULL;
+
+ if ((frame = tree_iterator_current_frame(iter)) == NULL)
+ return GIT_ITEROVER;
+
+ /* get the last seen entry */
+ prev_entry = tree_iterator_current_entry(frame);
+
+ /* it's legal to call advance_into when auto-expand is on. in this case,
+ * we will have pushed a new (empty) frame on to the stack for this
+ * new directory. since it's empty, its current_entry should be null.
+ */
+ GIT_ASSERT(iterator__do_autoexpand(i) ^ (prev_entry != NULL));
+
+ if (prev_entry) {
+ if (!git_tree_entry__is_tree(prev_entry->tree_entry))
+ return 0;
+
+ if ((error = tree_iterator_frame_push(iter, prev_entry)) < 0)
+ return error;
+ }
+
+ /* we've advanced into the directory in question, let advance
+ * find the first entry
+ */
+ return tree_iterator_advance(out, i);
+}
+
+static int tree_iterator_advance_over(
+ const git_index_entry **out,
+ git_iterator_status_t *status,
+ git_iterator *i)
+{
+ *status = GIT_ITERATOR_STATUS_NORMAL;
+ return git_iterator_advance(out, i);
+}
+
+static void tree_iterator_clear(tree_iterator *iter)
+{
+ while (iter->frames.size)
+ tree_iterator_frame_pop(iter);
+
+ git_array_clear(iter->frames);
+
+ git_pool_clear(&iter->entry_pool);
+ git_str_clear(&iter->entry_path);
+
+ iterator_clear(&iter->base);
+}
+
+static int tree_iterator_init(tree_iterator *iter)
+{
+ int error;
+
+ if ((error = git_pool_init(&iter->entry_pool, sizeof(tree_iterator_entry))) < 0 ||
+ (error = tree_iterator_frame_init(iter, iter->root, NULL)) < 0)
+ return error;
+
+ iter->base.flags &= ~GIT_ITERATOR_FIRST_ACCESS;
+
+ return 0;
+}
+
+static int tree_iterator_reset(git_iterator *i)
+{
+ tree_iterator *iter = (tree_iterator *)i;
+
+ tree_iterator_clear(iter);
+ return tree_iterator_init(iter);
+}
+
+static void tree_iterator_free(git_iterator *i)
+{
+ tree_iterator *iter = (tree_iterator *)i;
+
+ tree_iterator_clear(iter);
+
+ git_tree_free(iter->root);
+ git_str_dispose(&iter->entry_path);
+}
+
+int git_iterator_for_tree(
+ git_iterator **out,
+ git_tree *tree,
+ git_iterator_options *options)
+{
+ tree_iterator *iter;
+ int error;
+
+ static git_iterator_callbacks callbacks = {
+ tree_iterator_current,
+ tree_iterator_advance,
+ tree_iterator_advance_into,
+ tree_iterator_advance_over,
+ tree_iterator_reset,
+ tree_iterator_free
+ };
+
+ *out = NULL;
+
+ if (tree == NULL)
+ return git_iterator_for_nothing(out, options);
+
+ iter = git__calloc(1, sizeof(tree_iterator));
+ GIT_ERROR_CHECK_ALLOC(iter);
+
+ iter->base.type = GIT_ITERATOR_TREE;
+ iter->base.cb = &callbacks;
+
+ if ((error = iterator_init_common(&iter->base,
+ git_tree_owner(tree), NULL, options)) < 0 ||
+ (error = git_tree_dup(&iter->root, tree)) < 0 ||
+ (error = tree_iterator_init(iter)) < 0)
+ goto on_error;
+
+ *out = &iter->base;
+ return 0;
+
+on_error:
+ git_iterator_free(&iter->base);
+ return error;
+}
+
+int git_iterator_current_tree_entry(
+ const git_tree_entry **tree_entry, git_iterator *i)
+{
+ tree_iterator *iter;
+ tree_iterator_frame *frame;
+ tree_iterator_entry *entry;
+
+ GIT_ASSERT(i->type == GIT_ITERATOR_TREE);
+
+ iter = (tree_iterator *)i;
+
+ frame = tree_iterator_current_frame(iter);
+ entry = tree_iterator_current_entry(frame);
+
+ *tree_entry = entry->tree_entry;
+ return 0;
+}
+
+int git_iterator_current_parent_tree(
+ const git_tree **parent_tree, git_iterator *i, size_t depth)
+{
+ tree_iterator *iter;
+ tree_iterator_frame *frame;
+
+ GIT_ASSERT(i->type == GIT_ITERATOR_TREE);
+
+ iter = (tree_iterator *)i;
+
+ GIT_ASSERT(depth < iter->frames.size);
+ frame = &iter->frames.ptr[iter->frames.size-depth-1];
+
+ *parent_tree = frame->tree;
+ return 0;
+}
+
+/* Filesystem iterator */
+
+typedef struct {
+ struct stat st;
+ size_t path_len;
+ iterator_pathlist_search_t match;
+ git_oid id;
+ char path[GIT_FLEX_ARRAY];
+} filesystem_iterator_entry;
+
+typedef struct {
+ git_vector entries;
+ git_pool entry_pool;
+ size_t next_idx;
+
+ size_t path_len;
+ int is_ignored;
+} filesystem_iterator_frame;
+
+typedef struct {
+ git_iterator base;
+ char *root;
+ size_t root_len;
+
+ unsigned int dirload_flags;
+
+ git_tree *tree;
+ git_index *index;
+ git_vector index_snapshot;
+
+ git_array_t(filesystem_iterator_frame) frames;
+ git_ignores ignores;
+
+ /* info about the current entry */
+ git_index_entry entry;
+ git_str current_path;
+ int current_is_ignored;
+
+ /* temporary buffer for advance_over */
+ git_str tmp_buf;
+} filesystem_iterator;
+
+
+GIT_INLINE(filesystem_iterator_frame *) filesystem_iterator_parent_frame(
+ filesystem_iterator *iter)
+{
+ return iter->frames.size > 1 ?
+ &iter->frames.ptr[iter->frames.size-2] : NULL;
+}
+
+GIT_INLINE(filesystem_iterator_frame *) filesystem_iterator_current_frame(
+ filesystem_iterator *iter)
+{
+ return iter->frames.size ? &iter->frames.ptr[iter->frames.size-1] : NULL;
+}
+
+GIT_INLINE(filesystem_iterator_entry *) filesystem_iterator_current_entry(
+ filesystem_iterator_frame *frame)
+{
+ return frame->next_idx == 0 ?
+ NULL : frame->entries.contents[frame->next_idx-1];
+}
+
+static int filesystem_iterator_entry_cmp(const void *_a, const void *_b)
+{
+ const filesystem_iterator_entry *a = (const filesystem_iterator_entry *)_a;
+ const filesystem_iterator_entry *b = (const filesystem_iterator_entry *)_b;
+
+ return git__strcmp(a->path, b->path);
+}
+
+static int filesystem_iterator_entry_cmp_icase(const void *_a, const void *_b)
+{
+ const filesystem_iterator_entry *a = (const filesystem_iterator_entry *)_a;
+ const filesystem_iterator_entry *b = (const filesystem_iterator_entry *)_b;
+
+ return git__strcasecmp(a->path, b->path);
+}
+
+#define FILESYSTEM_MAX_DEPTH 100
+
+/**
+ * Figure out if an entry is a submodule.
+ *
+ * We consider it a submodule if the path is listed as a submodule in
+ * either the tree or the index.
+ */
+static int filesystem_iterator_is_submodule(
+ bool *out, filesystem_iterator *iter, const char *path, size_t path_len)
+{
+ bool is_submodule = false;
+ int error;
+
+ *out = false;
+
+ /* first see if this path is a submodule in HEAD */
+ if (iter->tree) {
+ git_tree_entry *entry;
+
+ error = git_tree_entry_bypath(&entry, iter->tree, path);
+
+ if (error < 0 && error != GIT_ENOTFOUND)
+ return error;
+
+ if (!error) {
+ is_submodule = (entry->attr == GIT_FILEMODE_COMMIT);
+ git_tree_entry_free(entry);
+ }
+ }
+
+ if (!is_submodule && iter->base.index) {
+ size_t pos;
+
+ error = git_index_snapshot_find(&pos,
+ &iter->index_snapshot, iter->base.entry_srch, path, path_len, 0);
+
+ if (error < 0 && error != GIT_ENOTFOUND)
+ return error;
+
+ if (!error) {
+ git_index_entry *e = git_vector_get(&iter->index_snapshot, pos);
+ is_submodule = (e->mode == GIT_FILEMODE_COMMIT);
+ }
+ }
+
+ *out = is_submodule;
+ return 0;
+}
+
+static void filesystem_iterator_frame_push_ignores(
+ filesystem_iterator *iter,
+ filesystem_iterator_entry *frame_entry,
+ filesystem_iterator_frame *new_frame)
+{
+ filesystem_iterator_frame *previous_frame;
+ const char *path = frame_entry ? frame_entry->path : "";
+
+ if (!iterator__honor_ignores(&iter->base))
+ return;
+
+ if (git_ignore__lookup(&new_frame->is_ignored,
+ &iter->ignores, path, GIT_DIR_FLAG_TRUE) < 0) {
+ git_error_clear();
+ new_frame->is_ignored = GIT_IGNORE_NOTFOUND;
+ }
+
+ /* if this is not the top level directory... */
+ if (frame_entry) {
+ const char *relative_path;
+
+ previous_frame = filesystem_iterator_parent_frame(iter);
+
+ /* push new ignores for files in this directory */
+ relative_path = frame_entry->path + previous_frame->path_len;
+
+ /* inherit ignored from parent if no rule specified */
+ if (new_frame->is_ignored <= GIT_IGNORE_NOTFOUND)
+ new_frame->is_ignored = previous_frame->is_ignored;
+
+ git_ignore__push_dir(&iter->ignores, relative_path);
+ }
+}
+
+static void filesystem_iterator_frame_pop_ignores(
+ filesystem_iterator *iter)
+{
+ if (iterator__honor_ignores(&iter->base))
+ git_ignore__pop_dir(&iter->ignores);
+}
+
+GIT_INLINE(bool) filesystem_iterator_examine_path(
+ bool *is_dir_out,
+ iterator_pathlist_search_t *match_out,
+ filesystem_iterator *iter,
+ filesystem_iterator_entry *frame_entry,
+ const char *path,
+ size_t path_len)
+{
+ bool is_dir = 0;
+ iterator_pathlist_search_t match = ITERATOR_PATHLIST_FULL;
+
+ *is_dir_out = false;
+ *match_out = ITERATOR_PATHLIST_NONE;
+
+ if (iter->base.start_len) {
+ int cmp = iter->base.strncomp(path, iter->base.start, path_len);
+
+ /* we haven't stat'ed `path` yet, so we don't yet know if it's a
+ * directory or not. special case if the current path may be a
+ * directory that matches the start prefix.
+ */
+ if (cmp == 0) {
+ if (iter->base.start[path_len] == '/')
+ is_dir = true;
+
+ else if (iter->base.start[path_len] != '\0')
+ cmp = -1;
+ }
+
+ if (cmp < 0)
+ return false;
+ }
+
+ if (iter->base.end_len) {
+ int cmp = iter->base.strncomp(path, iter->base.end, iter->base.end_len);
+
+ if (cmp > 0)
+ return false;
+ }
+
+ /* if we have a pathlist that we're limiting to, examine this path now
+ * to avoid a `stat` if we're not interested in the path.
+ */
+ if (iter->base.pathlist.length) {
+ /* if our parent was explicitly included, so too are we */
+ if (frame_entry && frame_entry->match != ITERATOR_PATHLIST_IS_PARENT)
+ match = ITERATOR_PATHLIST_FULL;
+ else
+ match = iterator_pathlist_search(&iter->base, path, path_len);
+
+ if (match == ITERATOR_PATHLIST_NONE)
+ return false;
+
+ /* Ensure that the pathlist entry lines up with what we expected */
+ if (match == ITERATOR_PATHLIST_IS_DIR ||
+ match == ITERATOR_PATHLIST_IS_PARENT)
+ is_dir = true;
+ }
+
+ *is_dir_out = is_dir;
+ *match_out = match;
+ return true;
+}
+
+GIT_INLINE(bool) filesystem_iterator_is_dot_git(
+ filesystem_iterator *iter, const char *path, size_t path_len)
+{
+ size_t len;
+
+ if (!iterator__ignore_dot_git(&iter->base))
+ return false;
+
+ if ((len = path_len) < 4)
+ return false;
+
+ if (path[len - 1] == '/')
+ len--;
+
+ if (git__tolower(path[len - 1]) != 't' ||
+ git__tolower(path[len - 2]) != 'i' ||
+ git__tolower(path[len - 3]) != 'g' ||
+ git__tolower(path[len - 4]) != '.')
+ return false;
+
+ return (len == 4 || path[len - 5] == '/');
+}
+
+static int filesystem_iterator_entry_hash(
+ filesystem_iterator *iter,
+ filesystem_iterator_entry *entry)
+{
+ git_str fullpath = GIT_STR_INIT;
+ int error;
+
+ if (S_ISDIR(entry->st.st_mode)) {
+ memset(&entry->id, 0, GIT_OID_RAWSZ);
+ return 0;
+ }
+
+ if (iter->base.type == GIT_ITERATOR_WORKDIR)
+ return git_repository_hashfile(&entry->id,
+ iter->base.repo, entry->path, GIT_OBJECT_BLOB, NULL);
+
+ if (!(error = git_str_joinpath(&fullpath, iter->root, entry->path)) &&
+ !(error = git_path_validate_str_length(iter->base.repo, &fullpath)))
+ error = git_odb_hashfile(&entry->id, fullpath.ptr, GIT_OBJECT_BLOB);
+
+ git_str_dispose(&fullpath);
+ return error;
+}
+
+static int filesystem_iterator_entry_init(
+ filesystem_iterator_entry **out,
+ filesystem_iterator *iter,
+ filesystem_iterator_frame *frame,
+ const char *path,
+ size_t path_len,
+ struct stat *statbuf,
+ iterator_pathlist_search_t pathlist_match)
+{
+ filesystem_iterator_entry *entry;
+ size_t entry_size;
+ int error = 0;
+
+ *out = NULL;
+
+ /* Make sure to append two bytes, one for the path's null
+ * termination, one for a possible trailing '/' for folders.
+ */
+ GIT_ERROR_CHECK_ALLOC_ADD(&entry_size,
+ sizeof(filesystem_iterator_entry), path_len);
+ GIT_ERROR_CHECK_ALLOC_ADD(&entry_size, entry_size, 2);
+
+ entry = git_pool_malloc(&frame->entry_pool, entry_size);
+ GIT_ERROR_CHECK_ALLOC(entry);
+
+ entry->path_len = path_len;
+ entry->match = pathlist_match;
+ memcpy(entry->path, path, path_len);
+ memcpy(&entry->st, statbuf, sizeof(struct stat));
+
+ /* Suffix directory paths with a '/' */
+ if (S_ISDIR(entry->st.st_mode))
+ entry->path[entry->path_len++] = '/';
+
+ entry->path[entry->path_len] = '\0';
+
+ if (iter->base.flags & GIT_ITERATOR_INCLUDE_HASH)
+ error = filesystem_iterator_entry_hash(iter, entry);
+
+ if (!error)
+ *out = entry;
+
+ return error;
+}
+
+static int filesystem_iterator_frame_push(
+ filesystem_iterator *iter,
+ filesystem_iterator_entry *frame_entry)
+{
+ filesystem_iterator_frame *new_frame = NULL;
+ git_fs_path_diriter diriter = GIT_FS_PATH_DIRITER_INIT;
+ git_str root = GIT_STR_INIT;
+ const char *path;
+ filesystem_iterator_entry *entry;
+ struct stat statbuf;
+ size_t path_len;
+ int error;
+
+ if (iter->frames.size == FILESYSTEM_MAX_DEPTH) {
+ git_error_set(GIT_ERROR_REPOSITORY,
+ "directory nesting too deep (%"PRIuZ")", iter->frames.size);
+ return -1;
+ }
+
+ new_frame = git_array_alloc(iter->frames);
+ GIT_ERROR_CHECK_ALLOC(new_frame);
+
+ memset(new_frame, 0, sizeof(filesystem_iterator_frame));
+
+ if (frame_entry)
+ git_str_joinpath(&root, iter->root, frame_entry->path);
+ else
+ git_str_puts(&root, iter->root);
+
+ if (git_str_oom(&root) ||
+ git_path_validate_str_length(iter->base.repo, &root) < 0) {
+ error = -1;
+ goto done;
+ }
+
+ new_frame->path_len = frame_entry ? frame_entry->path_len : 0;
+
+ /* Any error here is equivalent to the dir not existing, skip over it */
+ if ((error = git_fs_path_diriter_init(
+ &diriter, root.ptr, iter->dirload_flags)) < 0) {
+ error = GIT_ENOTFOUND;
+ goto done;
+ }
+
+ if ((error = git_vector_init(&new_frame->entries, 64,
+ iterator__ignore_case(&iter->base) ?
+ filesystem_iterator_entry_cmp_icase :
+ filesystem_iterator_entry_cmp)) < 0)
+ goto done;
+
+ if ((error = git_pool_init(&new_frame->entry_pool, 1)) < 0)
+ goto done;
+
+ /* check if this directory is ignored */
+ filesystem_iterator_frame_push_ignores(iter, frame_entry, new_frame);
+
+ while ((error = git_fs_path_diriter_next(&diriter)) == 0) {
+ iterator_pathlist_search_t pathlist_match = ITERATOR_PATHLIST_FULL;
+ git_str path_str = GIT_STR_INIT;
+ bool dir_expected = false;
+
+ if ((error = git_fs_path_diriter_fullpath(&path, &path_len, &diriter)) < 0)
+ goto done;
+
+ path_str.ptr = (char *)path;
+ path_str.size = path_len;
+
+ if ((error = git_path_validate_str_length(iter->base.repo, &path_str)) < 0)
+ goto done;
+
+ GIT_ASSERT(path_len > iter->root_len);
+
+ /* remove the prefix if requested */
+ path += iter->root_len;
+ path_len -= iter->root_len;
+
+ /* examine start / end and the pathlist to see if this path is in it.
+ * note that since we haven't yet stat'ed the path, we cannot know
+ * whether it's a directory yet or not, so this can give us an
+ * expected type (S_IFDIR or S_IFREG) that we should examine)
+ */
+ if (!filesystem_iterator_examine_path(&dir_expected, &pathlist_match,
+ iter, frame_entry, path, path_len))
+ continue;
+
+ /* TODO: don't need to stat if assume unchanged for this path and
+ * we have an index, we can just copy the data out of it.
+ */
+
+ if ((error = git_fs_path_diriter_stat(&statbuf, &diriter)) < 0) {
+ /* file was removed between readdir and lstat */
+ if (error == GIT_ENOTFOUND)
+ continue;
+
+ /* treat the file as unreadable */
+ memset(&statbuf, 0, sizeof(statbuf));
+ statbuf.st_mode = GIT_FILEMODE_UNREADABLE;
+
+ error = 0;
+ }
+
+ iter->base.stat_calls++;
+
+ /* Ignore wacky things in the filesystem */
+ if (!S_ISDIR(statbuf.st_mode) &&
+ !S_ISREG(statbuf.st_mode) &&
+ !S_ISLNK(statbuf.st_mode) &&
+ statbuf.st_mode != GIT_FILEMODE_UNREADABLE)
+ continue;
+
+ if (filesystem_iterator_is_dot_git(iter, path, path_len))
+ continue;
+
+ /* convert submodules to GITLINK and remove trailing slashes */
+ if (S_ISDIR(statbuf.st_mode)) {
+ bool submodule = false;
+
+ if ((error = filesystem_iterator_is_submodule(&submodule,
+ iter, path, path_len)) < 0)
+ goto done;
+
+ if (submodule)
+ statbuf.st_mode = GIT_FILEMODE_COMMIT;
+ }
+
+ /* Ensure that the pathlist entry lines up with what we expected */
+ else if (dir_expected)
+ continue;
+
+ if ((error = filesystem_iterator_entry_init(&entry,
+ iter, new_frame, path, path_len, &statbuf, pathlist_match)) < 0)
+ goto done;
+
+ git_vector_insert(&new_frame->entries, entry);
+ }
+
+ if (error == GIT_ITEROVER)
+ error = 0;
+
+ /* sort now that directory suffix is added */
+ git_vector_sort(&new_frame->entries);
+
+done:
+ if (error < 0)
+ git_array_pop(iter->frames);
+
+ git_str_dispose(&root);
+ git_fs_path_diriter_free(&diriter);
+ return error;
+}
+
+GIT_INLINE(int) filesystem_iterator_frame_pop(filesystem_iterator *iter)
+{
+ filesystem_iterator_frame *frame;
+
+ GIT_ASSERT(iter->frames.size);
+
+ frame = git_array_pop(iter->frames);
+ filesystem_iterator_frame_pop_ignores(iter);
+
+ git_pool_clear(&frame->entry_pool);
+ git_vector_free(&frame->entries);
+
+ return 0;
+}
+
+static void filesystem_iterator_set_current(
+ filesystem_iterator *iter,
+ filesystem_iterator_entry *entry)
+{
+ /*
+ * Index entries are limited to 32 bit timestamps. We can safely
+ * cast this since workdir times are only used in the cache; any
+ * mismatch will cause a hash recomputation which is unfortunate
+ * but affects only people who set their filetimes to 2038.
+ * (Same with the file size.)
+ */
+ iter->entry.ctime.seconds = (int32_t)entry->st.st_ctime;
+ iter->entry.mtime.seconds = (int32_t)entry->st.st_mtime;
+
+#if defined(GIT_USE_NSEC)
+ iter->entry.ctime.nanoseconds = entry->st.st_ctime_nsec;
+ iter->entry.mtime.nanoseconds = entry->st.st_mtime_nsec;
+#else
+ iter->entry.ctime.nanoseconds = 0;
+ iter->entry.mtime.nanoseconds = 0;
+#endif
+
+ iter->entry.dev = entry->st.st_dev;
+ iter->entry.ino = entry->st.st_ino;
+ iter->entry.mode = git_futils_canonical_mode(entry->st.st_mode);
+ iter->entry.uid = entry->st.st_uid;
+ iter->entry.gid = entry->st.st_gid;
+ iter->entry.file_size = (uint32_t)entry->st.st_size;
+
+ if (iter->base.flags & GIT_ITERATOR_INCLUDE_HASH)
+ git_oid_cpy(&iter->entry.id, &entry->id);
+
+ iter->entry.path = entry->path;
+
+ iter->current_is_ignored = GIT_IGNORE_UNCHECKED;
+}
+
+static int filesystem_iterator_current(
+ const git_index_entry **out, git_iterator *i)
+{
+ filesystem_iterator *iter = GIT_CONTAINER_OF(i, filesystem_iterator, base);
+
+ if (!iterator__has_been_accessed(i))
+ return iter->base.cb->advance(out, i);
+
+ if (!iter->frames.size) {
+ *out = NULL;
+ return GIT_ITEROVER;
+ }
+
+ *out = &iter->entry;
+ return 0;
+}
+
+static int filesystem_iterator_is_dir(
+ bool *is_dir,
+ const filesystem_iterator *iter,
+ const filesystem_iterator_entry *entry)
+{
+ struct stat st;
+ git_str fullpath = GIT_STR_INIT;
+ int error = 0;
+
+ if (S_ISDIR(entry->st.st_mode)) {
+ *is_dir = 1;
+ goto done;
+ }
+
+ if (!iterator__descend_symlinks(iter) || !S_ISLNK(entry->st.st_mode)) {
+ *is_dir = 0;
+ goto done;
+ }
+
+ if ((error = git_str_joinpath(&fullpath, iter->root, entry->path)) < 0 ||
+ (error = git_path_validate_str_length(iter->base.repo, &fullpath)) < 0 ||
+ (error = p_stat(fullpath.ptr, &st)) < 0)
+ goto done;
+
+ *is_dir = S_ISDIR(st.st_mode);
+
+done:
+ git_str_dispose(&fullpath);
+ return error;
+}
+
+static int filesystem_iterator_advance(
+ const git_index_entry **out, git_iterator *i)
+{
+ filesystem_iterator *iter = GIT_CONTAINER_OF(i, filesystem_iterator, base);
+ bool is_dir;
+ int error = 0;
+
+ iter->base.flags |= GIT_ITERATOR_FIRST_ACCESS;
+
+ /* examine filesystem entries until we find the next one to return */
+ while (true) {
+ filesystem_iterator_frame *frame;
+ filesystem_iterator_entry *entry;
+
+ if ((frame = filesystem_iterator_current_frame(iter)) == NULL) {
+ error = GIT_ITEROVER;
+ break;
+ }
+
+ /* no more entries in this frame. pop the frame out */
+ if (frame->next_idx == frame->entries.length) {
+ filesystem_iterator_frame_pop(iter);
+ continue;
+ }
+
+ /* we have more entries in the current frame, that's our next entry */
+ entry = frame->entries.contents[frame->next_idx];
+ frame->next_idx++;
+
+ if ((error = filesystem_iterator_is_dir(&is_dir, iter, entry)) < 0)
+ break;
+
+ if (is_dir) {
+ if (iterator__do_autoexpand(iter)) {
+ error = filesystem_iterator_frame_push(iter, entry);
+
+ /* may get GIT_ENOTFOUND due to races or permission problems
+ * that we want to quietly swallow
+ */
+ if (error == GIT_ENOTFOUND)
+ continue;
+ else if (error < 0)
+ break;
+ }
+
+ if (!iterator__include_trees(iter))
+ continue;
+ }
+
+ filesystem_iterator_set_current(iter, entry);
+ break;
+ }
+
+ if (out)
+ *out = (error == 0) ? &iter->entry : NULL;
+
+ return error;
+}
+
+static int filesystem_iterator_advance_into(
+ const git_index_entry **out, git_iterator *i)
+{
+ filesystem_iterator *iter = GIT_CONTAINER_OF(i, filesystem_iterator, base);
+ filesystem_iterator_frame *frame;
+ filesystem_iterator_entry *prev_entry;
+ int error;
+
+ if (out)
+ *out = NULL;
+
+ if ((frame = filesystem_iterator_current_frame(iter)) == NULL)
+ return GIT_ITEROVER;
+
+ /* get the last seen entry */
+ prev_entry = filesystem_iterator_current_entry(frame);
+
+ /* it's legal to call advance_into when auto-expand is on. in this case,
+ * we will have pushed a new (empty) frame on to the stack for this
+ * new directory. since it's empty, its current_entry should be null.
+ */
+ GIT_ASSERT(iterator__do_autoexpand(i) ^ (prev_entry != NULL));
+
+ if (prev_entry) {
+ if (prev_entry->st.st_mode != GIT_FILEMODE_COMMIT &&
+ !S_ISDIR(prev_entry->st.st_mode))
+ return 0;
+
+ if ((error = filesystem_iterator_frame_push(iter, prev_entry)) < 0)
+ return error;
+ }
+
+ /* we've advanced into the directory in question, let advance
+ * find the first entry
+ */
+ return filesystem_iterator_advance(out, i);
+}
+
+int git_iterator_current_workdir_path(git_str **out, git_iterator *i)
+{
+ filesystem_iterator *iter = GIT_CONTAINER_OF(i, filesystem_iterator, base);
+ const git_index_entry *entry;
+
+ if (i->type != GIT_ITERATOR_FS &&
+ i->type != GIT_ITERATOR_WORKDIR) {
+ *out = NULL;
+ return 0;
+ }
+
+ git_str_truncate(&iter->current_path, iter->root_len);
+
+ if (git_iterator_current(&entry, i) < 0 ||
+ git_str_puts(&iter->current_path, entry->path) < 0)
+ return -1;
+
+ *out = &iter->current_path;
+ return 0;
+}
+
+GIT_INLINE(git_dir_flag) entry_dir_flag(git_index_entry *entry)
+{
+#if defined(GIT_WIN32) && !defined(__MINGW32__)
+ return (entry && entry->mode) ?
+ (S_ISDIR(entry->mode) ? GIT_DIR_FLAG_TRUE : GIT_DIR_FLAG_FALSE) :
+ GIT_DIR_FLAG_UNKNOWN;
+#else
+ GIT_UNUSED(entry);
+ return GIT_DIR_FLAG_UNKNOWN;
+#endif
+}
+
+static void filesystem_iterator_update_ignored(filesystem_iterator *iter)
+{
+ filesystem_iterator_frame *frame;
+ git_dir_flag dir_flag = entry_dir_flag(&iter->entry);
+
+ if (git_ignore__lookup(&iter->current_is_ignored,
+ &iter->ignores, iter->entry.path, dir_flag) < 0) {
+ git_error_clear();
+ iter->current_is_ignored = GIT_IGNORE_NOTFOUND;
+ }
+
+ /* use ignore from containing frame stack */
+ if (iter->current_is_ignored <= GIT_IGNORE_NOTFOUND) {
+ frame = filesystem_iterator_current_frame(iter);
+ iter->current_is_ignored = frame->is_ignored;
+ }
+}
+
+GIT_INLINE(bool) filesystem_iterator_current_is_ignored(
+ filesystem_iterator *iter)
+{
+ if (iter->current_is_ignored == GIT_IGNORE_UNCHECKED)
+ filesystem_iterator_update_ignored(iter);
+
+ return (iter->current_is_ignored == GIT_IGNORE_TRUE);
+}
+
+bool git_iterator_current_is_ignored(git_iterator *i)
+{
+ filesystem_iterator *iter = NULL;
+
+ if (i->type != GIT_ITERATOR_WORKDIR)
+ return false;
+
+ iter = GIT_CONTAINER_OF(i, filesystem_iterator, base);
+
+ return filesystem_iterator_current_is_ignored(iter);
+}
+
+bool git_iterator_current_tree_is_ignored(git_iterator *i)
+{
+ filesystem_iterator *iter = GIT_CONTAINER_OF(i, filesystem_iterator, base);
+ filesystem_iterator_frame *frame;
+
+ if (i->type != GIT_ITERATOR_WORKDIR)
+ return false;
+
+ frame = filesystem_iterator_current_frame(iter);
+ return (frame->is_ignored == GIT_IGNORE_TRUE);
+}
+
+static int filesystem_iterator_advance_over(
+ const git_index_entry **out,
+ git_iterator_status_t *status,
+ git_iterator *i)
+{
+ filesystem_iterator *iter = GIT_CONTAINER_OF(i, filesystem_iterator, base);
+ filesystem_iterator_frame *current_frame;
+ filesystem_iterator_entry *current_entry;
+ const git_index_entry *entry = NULL;
+ const char *base;
+ int error = 0;
+
+ *out = NULL;
+ *status = GIT_ITERATOR_STATUS_NORMAL;
+
+ GIT_ASSERT(iterator__has_been_accessed(i));
+
+ current_frame = filesystem_iterator_current_frame(iter);
+ GIT_ASSERT(current_frame);
+
+ current_entry = filesystem_iterator_current_entry(current_frame);
+ GIT_ASSERT(current_entry);
+
+ if ((error = git_iterator_current(&entry, i)) < 0)
+ return error;
+
+ if (!S_ISDIR(entry->mode)) {
+ if (filesystem_iterator_current_is_ignored(iter))
+ *status = GIT_ITERATOR_STATUS_IGNORED;
+
+ return filesystem_iterator_advance(out, i);
+ }
+
+ git_str_clear(&iter->tmp_buf);
+ if ((error = git_str_puts(&iter->tmp_buf, entry->path)) < 0)
+ return error;
+
+ base = iter->tmp_buf.ptr;
+
+ /* scan inside the directory looking for files. if we find nothing,
+ * we will remain EMPTY. if we find any ignored item, upgrade EMPTY to
+ * IGNORED. if we find a real actual item, upgrade all the way to NORMAL
+ * and then stop.
+ *
+ * however, if we're here looking for a pathlist item (but are not
+ * actually in the pathlist ourselves) then start at FILTERED instead of
+ * EMPTY. callers then know that this path was not something they asked
+ * about.
+ */
+ *status = current_entry->match == ITERATOR_PATHLIST_IS_PARENT ?
+ GIT_ITERATOR_STATUS_FILTERED : GIT_ITERATOR_STATUS_EMPTY;
+
+ while (entry && !iter->base.prefixcomp(entry->path, base)) {
+ if (filesystem_iterator_current_is_ignored(iter)) {
+ /* if we found an explicitly ignored item, then update from
+ * EMPTY to IGNORED
+ */
+ *status = GIT_ITERATOR_STATUS_IGNORED;
+ } else if (S_ISDIR(entry->mode)) {
+ error = filesystem_iterator_advance_into(&entry, i);
+
+ if (!error)
+ continue;
+
+ /* this directory disappeared, ignore it */
+ else if (error == GIT_ENOTFOUND)
+ error = 0;
+
+ /* a real error occurred */
+ else
+ break;
+ } else {
+ /* we found a non-ignored item, treat parent as untracked */
+ *status = GIT_ITERATOR_STATUS_NORMAL;
+ break;
+ }
+
+ if ((error = git_iterator_advance(&entry, i)) < 0)
+ break;
+ }
+
+ /* wrap up scan back to base directory */
+ while (entry && !iter->base.prefixcomp(entry->path, base)) {
+ if ((error = git_iterator_advance(&entry, i)) < 0)
+ break;
+ }
+
+ if (!error)
+ *out = entry;
+
+ return error;
+}
+
+static void filesystem_iterator_clear(filesystem_iterator *iter)
+{
+ while (iter->frames.size)
+ filesystem_iterator_frame_pop(iter);
+
+ git_array_clear(iter->frames);
+ git_ignore__free(&iter->ignores);
+
+ git_str_dispose(&iter->tmp_buf);
+
+ iterator_clear(&iter->base);
+}
+
+static int filesystem_iterator_init(filesystem_iterator *iter)
+{
+ int error;
+
+ if (iterator__honor_ignores(&iter->base) &&
+ (error = git_ignore__for_path(iter->base.repo,
+ ".gitignore", &iter->ignores)) < 0)
+ return error;
+
+ if ((error = filesystem_iterator_frame_push(iter, NULL)) < 0)
+ return error;
+
+ iter->base.flags &= ~GIT_ITERATOR_FIRST_ACCESS;
+
+ return 0;
+}
+
+static int filesystem_iterator_reset(git_iterator *i)
+{
+ filesystem_iterator *iter = GIT_CONTAINER_OF(i, filesystem_iterator, base);
+
+ filesystem_iterator_clear(iter);
+ return filesystem_iterator_init(iter);
+}
+
+static void filesystem_iterator_free(git_iterator *i)
+{
+ filesystem_iterator *iter = GIT_CONTAINER_OF(i, filesystem_iterator, base);
+ git__free(iter->root);
+ git_str_dispose(&iter->current_path);
+ git_tree_free(iter->tree);
+ if (iter->index)
+ git_index_snapshot_release(&iter->index_snapshot, iter->index);
+ filesystem_iterator_clear(iter);
+}
+
+static int iterator_for_filesystem(
+ git_iterator **out,
+ git_repository *repo,
+ const char *root,
+ git_index *index,
+ git_tree *tree,
+ git_iterator_t type,
+ git_iterator_options *options)
+{
+ filesystem_iterator *iter;
+ size_t root_len;
+ int error;
+
+ static git_iterator_callbacks callbacks = {
+ filesystem_iterator_current,
+ filesystem_iterator_advance,
+ filesystem_iterator_advance_into,
+ filesystem_iterator_advance_over,
+ filesystem_iterator_reset,
+ filesystem_iterator_free
+ };
+
+ *out = NULL;
+
+ if (root == NULL)
+ return git_iterator_for_nothing(out, options);
+
+ iter = git__calloc(1, sizeof(filesystem_iterator));
+ GIT_ERROR_CHECK_ALLOC(iter);
+
+ iter->base.type = type;
+ iter->base.cb = &callbacks;
+
+ root_len = strlen(root);
+
+ iter->root = git__malloc(root_len+2);
+ GIT_ERROR_CHECK_ALLOC(iter->root);
+
+ memcpy(iter->root, root, root_len);
+
+ if (root_len == 0 || root[root_len-1] != '/') {
+ iter->root[root_len] = '/';
+ root_len++;
+ }
+ iter->root[root_len] = '\0';
+ iter->root_len = root_len;
+
+ if ((error = git_str_puts(&iter->current_path, iter->root)) < 0)
+ goto on_error;
+
+ if ((error = iterator_init_common(&iter->base, repo, index, options)) < 0)
+ goto on_error;
+
+ if (tree && (error = git_tree_dup(&iter->tree, tree)) < 0)
+ goto on_error;
+
+ if (index &&
+ (error = git_index_snapshot_new(&iter->index_snapshot, index)) < 0)
+ goto on_error;
+
+ iter->index = index;
+ iter->dirload_flags =
+ (iterator__ignore_case(&iter->base) ?
+ GIT_FS_PATH_DIR_IGNORE_CASE : 0) |
+ (iterator__flag(&iter->base, PRECOMPOSE_UNICODE) ?
+ GIT_FS_PATH_DIR_PRECOMPOSE_UNICODE : 0);
+
+ if ((error = filesystem_iterator_init(iter)) < 0)
+ goto on_error;
+
+ *out = &iter->base;
+ return 0;
+
+on_error:
+ git_iterator_free(&iter->base);
+ return error;
+}
+
+int git_iterator_for_filesystem(
+ git_iterator **out,
+ const char *root,
+ git_iterator_options *options)
+{
+ return iterator_for_filesystem(out,
+ NULL, root, NULL, NULL, GIT_ITERATOR_FS, options);
+}
+
+int git_iterator_for_workdir_ext(
+ git_iterator **out,
+ git_repository *repo,
+ const char *repo_workdir,
+ git_index *index,
+ git_tree *tree,
+ git_iterator_options *given_opts)
+{
+ git_iterator_options options = GIT_ITERATOR_OPTIONS_INIT;
+
+ if (!repo_workdir) {
+ if (git_repository__ensure_not_bare(repo, "scan working directory") < 0)
+ return GIT_EBAREREPO;
+
+ repo_workdir = git_repository_workdir(repo);
+ }
+
+ /* upgrade to a workdir iterator, adding necessary internal flags */
+ if (given_opts)
+ memcpy(&options, given_opts, sizeof(git_iterator_options));
+
+ options.flags |= GIT_ITERATOR_HONOR_IGNORES |
+ GIT_ITERATOR_IGNORE_DOT_GIT;
+
+ return iterator_for_filesystem(out,
+ repo, repo_workdir, index, tree, GIT_ITERATOR_WORKDIR, &options);
+}
+
+
+/* Index iterator */
+
+
+typedef struct {
+ git_iterator base;
+ git_vector entries;
+ size_t next_idx;
+
+ /* the pseudotree entry */
+ git_index_entry tree_entry;
+ git_str tree_buf;
+ bool skip_tree;
+
+ const git_index_entry *entry;
+} index_iterator;
+
+static int index_iterator_current(
+ const git_index_entry **out, git_iterator *i)
+{
+ index_iterator *iter = (index_iterator *)i;
+
+ if (!iterator__has_been_accessed(i))
+ return iter->base.cb->advance(out, i);
+
+ if (iter->entry == NULL) {
+ *out = NULL;
+ return GIT_ITEROVER;
+ }
+
+ *out = iter->entry;
+ return 0;
+}
+
+static bool index_iterator_create_pseudotree(
+ const git_index_entry **out,
+ index_iterator *iter,
+ const char *path)
+{
+ const char *prev_path, *relative_path, *dirsep;
+ size_t common_len;
+
+ prev_path = iter->entry ? iter->entry->path : "";
+
+ /* determine if the new path is in a different directory from the old */
+ common_len = git_fs_path_common_dirlen(prev_path, path);
+ relative_path = path + common_len;
+
+ if ((dirsep = strchr(relative_path, '/')) == NULL)
+ return false;
+
+ git_str_clear(&iter->tree_buf);
+ git_str_put(&iter->tree_buf, path, (dirsep - path) + 1);
+
+ iter->tree_entry.mode = GIT_FILEMODE_TREE;
+ iter->tree_entry.path = iter->tree_buf.ptr;
+
+ *out = &iter->tree_entry;
+ return true;
+}
+
+static int index_iterator_skip_pseudotree(index_iterator *iter)
+{
+ GIT_ASSERT(iterator__has_been_accessed(&iter->base));
+ GIT_ASSERT(S_ISDIR(iter->entry->mode));
+
+ while (true) {
+ const git_index_entry *next_entry = NULL;
+
+ if (++iter->next_idx >= iter->entries.length)
+ return GIT_ITEROVER;
+
+ next_entry = iter->entries.contents[iter->next_idx];
+
+ if (iter->base.strncomp(iter->tree_buf.ptr, next_entry->path,
+ iter->tree_buf.size) != 0)
+ break;
+ }
+
+ iter->skip_tree = false;
+ return 0;
+}
+
+static int index_iterator_advance(
+ const git_index_entry **out, git_iterator *i)
+{
+ index_iterator *iter = GIT_CONTAINER_OF(i, index_iterator, base);
+ const git_index_entry *entry = NULL;
+ bool is_submodule;
+ int error = 0;
+
+ iter->base.flags |= GIT_ITERATOR_FIRST_ACCESS;
+
+ while (true) {
+ if (iter->next_idx >= iter->entries.length) {
+ error = GIT_ITEROVER;
+ break;
+ }
+
+ /* we were not asked to expand this pseudotree. advance over it. */
+ if (iter->skip_tree) {
+ index_iterator_skip_pseudotree(iter);
+ continue;
+ }
+
+ entry = iter->entries.contents[iter->next_idx];
+ is_submodule = S_ISGITLINK(entry->mode);
+
+ if (!iterator_has_started(&iter->base, entry->path, is_submodule)) {
+ iter->next_idx++;
+ continue;
+ }
+
+ if (iterator_has_ended(&iter->base, entry->path)) {
+ error = GIT_ITEROVER;
+ break;
+ }
+
+ /* if we have a list of paths we're interested in, examine it */
+ if (!iterator_pathlist_next_is(&iter->base, entry->path)) {
+ iter->next_idx++;
+ continue;
+ }
+
+ /* if this is a conflict, skip it unless we're including conflicts */
+ if (git_index_entry_is_conflict(entry) &&
+ !iterator__include_conflicts(&iter->base)) {
+ iter->next_idx++;
+ continue;
+ }
+
+ /* we've found what will be our next _file_ entry. but if we are
+ * returning trees entries, we may need to return a pseudotree
+ * entry that will contain this. don't advance over this entry,
+ * though, we still need to return it on the next `advance`.
+ */
+ if (iterator__include_trees(&iter->base) &&
+ index_iterator_create_pseudotree(&entry, iter, entry->path)) {
+
+ /* Note whether this pseudo tree should be expanded or not */
+ iter->skip_tree = iterator__dont_autoexpand(&iter->base);
+ break;
+ }
+
+ iter->next_idx++;
+ break;
+ }
+
+ iter->entry = (error == 0) ? entry : NULL;
+
+ if (out)
+ *out = iter->entry;
+
+ return error;
+}
+
+static int index_iterator_advance_into(
+ const git_index_entry **out, git_iterator *i)
+{
+ index_iterator *iter = GIT_CONTAINER_OF(i, index_iterator, base);
+
+ if (! S_ISDIR(iter->tree_entry.mode)) {
+ if (out)
+ *out = NULL;
+
+ return 0;
+ }
+
+ iter->skip_tree = false;
+ return index_iterator_advance(out, i);
+}
+
+static int index_iterator_advance_over(
+ const git_index_entry **out,
+ git_iterator_status_t *status,
+ git_iterator *i)
+{
+ index_iterator *iter = GIT_CONTAINER_OF(i, index_iterator, base);
+ const git_index_entry *entry;
+ int error;
+
+ if ((error = index_iterator_current(&entry, i)) < 0)
+ return error;
+
+ if (S_ISDIR(entry->mode))
+ index_iterator_skip_pseudotree(iter);
+
+ *status = GIT_ITERATOR_STATUS_NORMAL;
+ return index_iterator_advance(out, i);
+}
+
+static void index_iterator_clear(index_iterator *iter)
+{
+ iterator_clear(&iter->base);
+}
+
+static int index_iterator_init(index_iterator *iter)
+{
+ iter->base.flags &= ~GIT_ITERATOR_FIRST_ACCESS;
+ iter->next_idx = 0;
+ iter->skip_tree = false;
+ return 0;
+}
+
+static int index_iterator_reset(git_iterator *i)
+{
+ index_iterator *iter = GIT_CONTAINER_OF(i, index_iterator, base);
+
+ index_iterator_clear(iter);
+ return index_iterator_init(iter);
+}
+
+static void index_iterator_free(git_iterator *i)
+{
+ index_iterator *iter = GIT_CONTAINER_OF(i, index_iterator, base);
+
+ git_index_snapshot_release(&iter->entries, iter->base.index);
+ git_str_dispose(&iter->tree_buf);
+}
+
+int git_iterator_for_index(
+ git_iterator **out,
+ git_repository *repo,
+ git_index *index,
+ git_iterator_options *options)
+{
+ index_iterator *iter;
+ int error;
+
+ static git_iterator_callbacks callbacks = {
+ index_iterator_current,
+ index_iterator_advance,
+ index_iterator_advance_into,
+ index_iterator_advance_over,
+ index_iterator_reset,
+ index_iterator_free
+ };
+
+ *out = NULL;
+
+ if (index == NULL)
+ return git_iterator_for_nothing(out, options);
+
+ iter = git__calloc(1, sizeof(index_iterator));
+ GIT_ERROR_CHECK_ALLOC(iter);
+
+ iter->base.type = GIT_ITERATOR_INDEX;
+ iter->base.cb = &callbacks;
+
+ if ((error = iterator_init_common(&iter->base, repo, index, options)) < 0 ||
+ (error = git_index_snapshot_new(&iter->entries, index)) < 0 ||
+ (error = index_iterator_init(iter)) < 0)
+ goto on_error;
+
+ git_vector_set_cmp(&iter->entries, iterator__ignore_case(&iter->base) ?
+ git_index_entry_icmp : git_index_entry_cmp);
+ git_vector_sort(&iter->entries);
+
+ *out = &iter->base;
+ return 0;
+
+on_error:
+ git_iterator_free(&iter->base);
+ return error;
+}
+
+
+/* Iterator API */
+
+int git_iterator_reset_range(
+ git_iterator *i, const char *start, const char *end)
+{
+ if (iterator_reset_range(i, start, end) < 0)
+ return -1;
+
+ return i->cb->reset(i);
+}
+
+int git_iterator_set_ignore_case(git_iterator *i, bool ignore_case)
+{
+ GIT_ASSERT(!iterator__has_been_accessed(i));
+ iterator_set_ignore_case(i, ignore_case);
+ return 0;
+}
+
+void git_iterator_free(git_iterator *iter)
+{
+ if (iter == NULL)
+ return;
+
+ iter->cb->free(iter);
+
+ git_vector_free(&iter->pathlist);
+ git__free(iter->start);
+ git__free(iter->end);
+
+ memset(iter, 0, sizeof(*iter));
+
+ git__free(iter);
+}
+
+int git_iterator_foreach(
+ git_iterator *iterator,
+ git_iterator_foreach_cb cb,
+ void *data)
+{
+ const git_index_entry *iterator_item;
+ int error = 0;
+
+ if ((error = git_iterator_current(&iterator_item, iterator)) < 0)
+ goto done;
+
+ if ((error = cb(iterator_item, data)) != 0)
+ goto done;
+
+ while (true) {
+ if ((error = git_iterator_advance(&iterator_item, iterator)) < 0)
+ goto done;
+
+ if ((error = cb(iterator_item, data)) != 0)
+ goto done;
+ }
+
+done:
+ if (error == GIT_ITEROVER)
+ error = 0;
+
+ return error;
+}
+
+int git_iterator_walk(
+ git_iterator **iterators,
+ size_t cnt,
+ git_iterator_walk_cb cb,
+ void *data)
+{
+ const git_index_entry **iterator_item; /* next in each iterator */
+ const git_index_entry **cur_items; /* current path in each iter */
+ const git_index_entry *first_match;
+ size_t i, j;
+ int error = 0;
+
+ iterator_item = git__calloc(cnt, sizeof(git_index_entry *));
+ cur_items = git__calloc(cnt, sizeof(git_index_entry *));
+
+ GIT_ERROR_CHECK_ALLOC(iterator_item);
+ GIT_ERROR_CHECK_ALLOC(cur_items);
+
+ /* Set up the iterators */
+ for (i = 0; i < cnt; i++) {
+ error = git_iterator_current(&iterator_item[i], iterators[i]);
+
+ if (error < 0 && error != GIT_ITEROVER)
+ goto done;
+ }
+
+ while (true) {
+ for (i = 0; i < cnt; i++)
+ cur_items[i] = NULL;
+
+ first_match = NULL;
+
+ /* Find the next path(s) to consume from each iterator */
+ for (i = 0; i < cnt; i++) {
+ if (iterator_item[i] == NULL)
+ continue;
+
+ if (first_match == NULL) {
+ first_match = iterator_item[i];
+ cur_items[i] = iterator_item[i];
+ } else {
+ int path_diff = git_index_entry_cmp(iterator_item[i], first_match);
+
+ if (path_diff < 0) {
+ /* Found an index entry that sorts before the one we're
+ * looking at. Forget that we've seen the other and
+ * look at the other iterators for this path.
+ */
+ for (j = 0; j < i; j++)
+ cur_items[j] = NULL;
+
+ first_match = iterator_item[i];
+ cur_items[i] = iterator_item[i];
+ } else if (path_diff == 0) {
+ cur_items[i] = iterator_item[i];
+ }
+ }
+ }
+
+ if (first_match == NULL)
+ break;
+
+ if ((error = cb(cur_items, data)) != 0)
+ goto done;
+
+ /* Advance each iterator that participated */
+ for (i = 0; i < cnt; i++) {
+ if (cur_items[i] == NULL)
+ continue;
+
+ error = git_iterator_advance(&iterator_item[i], iterators[i]);
+
+ if (error < 0 && error != GIT_ITEROVER)
+ goto done;
+ }
+ }
+
+done:
+ git__free((git_index_entry **)iterator_item);
+ git__free((git_index_entry **)cur_items);
+
+ if (error == GIT_ITEROVER)
+ error = 0;
+
+ return error;
+}
projects / libgit2.git / blobdiff