diff options
Diffstat (limited to 'src/iterator.c')
| -rw-r--r-- | src/iterator.c | 2431 |
1 files changed, 0 insertions, 2431 deletions
diff --git a/src/iterator.c b/src/iterator.c deleted file mode 100644 index ce9f305ef..000000000 --- a/src/iterator.c +++ /dev/null @@ -1,2431 +0,0 @@ -/* - * 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" - -#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_buf 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_buf) 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_buf 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_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_buf *out, - tree_iterator_entry *entry) -{ - git_buf_clear(out); - - if (entry->parent_path) - git_buf_joinpath(out, entry->parent_path, entry->tree_entry->filename); - else - git_buf_puts(out, entry->tree_entry->filename); - - if (git_tree_entry__is_tree(entry->tree_entry)) - git_buf_putc(out, '/'); - - if (git_buf_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_buf *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_buf)); - - 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_buf *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_buf_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_buf_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_buf_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_buf_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_buf current_path; - int current_is_ignored; - - /* temporary buffer for advance_over */ - git_buf 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_buf fullpath = GIT_BUF_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_buf_joinpath(&fullpath, iter->root, entry->path)) && - !(error = git_path_validate_workdir_buf(iter->base.repo, &fullpath))) - error = git_odb_hashfile(&entry->id, fullpath.ptr, GIT_OBJECT_BLOB); - - git_buf_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_path_diriter diriter = GIT_PATH_DIRITER_INIT; - git_buf root = GIT_BUF_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_buf_joinpath(&root, iter->root, frame_entry->path); - else - git_buf_puts(&root, iter->root); - - if (git_buf_oom(&root) || - git_path_validate_workdir_buf(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_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_path_diriter_next(&diriter)) == 0) { - iterator_pathlist_search_t pathlist_match = ITERATOR_PATHLIST_FULL; - bool dir_expected = false; - - if ((error = git_path_diriter_fullpath(&path, &path_len, &diriter)) < 0 || - (error = git_path_validate_workdir_with_len(iter->base.repo, path, path_len)) < 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_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_buf_dispose(&root); - git_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_buf fullpath = GIT_BUF_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_buf_joinpath(&fullpath, iter->root, entry->path)) < 0 || - (error = git_path_validate_workdir_buf(iter->base.repo, &fullpath)) < 0 || - (error = p_stat(fullpath.ptr, &st)) < 0) - goto done; - - *is_dir = S_ISDIR(st.st_mode); - -done: - git_buf_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_buf **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_buf_truncate(&iter->current_path, iter->root_len); - - if (git_iterator_current(&entry, i) < 0 || - git_buf_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_buf_clear(&iter->tmp_buf); - if ((error = git_buf_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_buf_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_buf_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_buf_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_PATH_DIR_IGNORE_CASE : 0) | - (iterator__flag(&iter->base, PRECOMPOSE_UNICODE) ? - GIT_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_buf 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_path_common_dirlen(prev_path, path); - relative_path = path + common_len; - - if ((dirsep = strchr(relative_path, '/')) == NULL) - return false; - - git_buf_clear(&iter->tree_buf); - git_buf_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_buf_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; -} |