#include "iterator.h"

#include "tree.h"

#include "index.h"

#include "ignore.h"

#include "buffer.h"

#include "submodule.h"

#include <ctype.h>

#define ITERATOR_SET_CB(P,NAME_LC) do { \

(P)->cb.current = NAME_LC ## _iterator__current; \

(P)->cb.advance = NAME_LC ## _iterator__advance; \

(P)->cb.advance_into = NAME_LC ## _iterator__advance_into; \

(P)->cb.seek = NAME_LC ## _iterator__seek; \

(P)->cb.reset = NAME_LC ## _iterator__reset; \

(P)->cb.at_end = NAME_LC ## _iterator__at_end; \

(P)->cb.free = NAME_LC ## _iterator__free; \

} while (0)

#define ITERATOR_CASE_FLAGS \

(GIT_ITERATOR_IGNORE_CASE | GIT_ITERATOR_DONT_IGNORE_CASE)

#define ITERATOR_BASE_INIT(P,NAME_LC,NAME_UC,REPO) do { \

(P)->base.type = GIT_ITERATOR_TYPE_ ## NAME_UC; \

(P)->base.cb = &(P)->cb; \

ITERATOR_SET_CB(P,NAME_LC); \

(P)->base.repo = (REPO); \

(P)->base.start = options && options->start ? \

git__strdup(options->start) : NULL; \

(P)->base.end = options && options->end ? \

git__strdup(options->end) : NULL; \

if ((options && options->start && !(P)->base.start) || \

(options && options->end && !(P)->base.end)) { \

git__free(P); return -1; } \

(P)->base.strcomp = git__strcmp; \

(P)->base.strncomp = git__strncmp; \

(P)->base.prefixcomp = git__prefixcmp; \

(P)->base.flags = options ? options->flags & ~ITERATOR_CASE_FLAGS : 0; \

if ((P)->base.flags & GIT_ITERATOR_DONT_AUTOEXPAND) \

(P)->base.flags |= GIT_ITERATOR_INCLUDE_TREES; \

if (options && options->pathlist.count && \

iterator_pathlist__init(&P->base, &options->pathlist) < 0) { \

git__free(P); return -1; } \

} while (0)

#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 GIT_ITERATOR_FIRST_ACCESS (1 << 15)

#define iterator__has_been_accessed(I) iterator__flag(I,FIRST_ACCESS)

#define iterator__end(I) ((git_iterator *)(I))->end

#define iterator__past_end(I,PATH) \

(iterator__end(I) && ((git_iterator *)(I))->prefixcomp((PATH),iterator__end(I)) > 0)

typedef enum {

ITERATOR_PATHLIST_NONE = 0,

ITERATOR_PATHLIST_MATCH = 1,

ITERATOR_PATHLIST_MATCH_DIRECTORY = 2,

ITERATOR_PATHLIST_MATCH_CHILD = 3,

} iterator_pathlist__match_t;

static int iterator_pathlist__init(git_iterator *iter, git_strarray *pathspec)

{

size_t i;

if (git_vector_init(&iter->pathlist, pathspec->count,

(git_vector_cmp)iter->strcomp) < 0)

return -1;

for (i = 0; i < pathspec->count; i++) {

if (!pathspec->strings[i])

continue;

if (git_vector_insert(&iter->pathlist, pathspec->strings[i]) < 0)

return -1;

}

git_vector_sort(&iter->pathlist);

return 0;

}

static iterator_pathlist__match_t iterator_pathlist__match(

git_iterator *iter, const char *path, size_t path_len)

{

const char *p;

size_t idx;

int error;

error = git_vector_bsearch2(&idx, &iter->pathlist,

(git_vector_cmp)iter->strcomp, path);

if (error == 0)

return ITERATOR_PATHLIST_MATCH;

/* at this point, the path we're examining may be a directory (though we

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 */

assert(p[path_len]);

/* is this a literal directory entry (eg `foo/`) or a file beneath */

if (p[path_len] == '/') {

return (p[path_len+1] == '\0') ?

ITERATOR_PATHLIST_MATCH_DIRECTORY :

ITERATOR_PATHLIST_MATCH_CHILD;

}

if (p[path_len] > '/')

break;

idx++;

}

return ITERATOR_PATHLIST_NONE;

}

static void iterator_pathlist_walk__reset(git_iterator *iter)

{

iter->pathlist_walk_idx = 0;

}

static bool iterator_pathlist_walk__contains(git_iterator *iter, const char *path)

{

size_t i;

char *p;

size_t p_len;

int cmp;

for (i = iter->pathlist_walk_idx; i < iter->pathlist.length; i++) {

p = iter->pathlist.contents[i];

p_len = strlen(p);

/* see if the pathlist entry is a prefix of this path */

cmp = iter->strncomp(p, path, p_len);

/* this pathlist entry sorts before the given path, try the next */

if (!p_len || cmp < 0)

iter->pathlist_walk_idx++;

/* this pathlist sorts after the given path, no match. */

else if (cmp > 0)

return false;

/* match! an exact match (`foo` vs `foo`), the path is a child of an

else if (path[p_len] == '\0' || p[p_len - 1] == '/' || path[p_len] == '/')

return true;

/* only advance the start index for future callers if we know that we

else if (path[p_len] > '/')

iter->pathlist_walk_idx++;

}

return false;

}

static void iterator_pathlist__update_ignore_case(git_iterator *iter)

{

git_vector_set_cmp(&iter->pathlist, (git_vector_cmp)iter->strcomp);

git_vector_sort(&iter->pathlist);

iter->pathlist_walk_idx = 0;

}

static int iterator__reset_range(

git_iterator *iter, const char *start, const char *end)

{

if (start) {

if (iter->start)

git__free(iter->start);

iter->start = git__strdup(start);

GITERR_CHECK_ALLOC(iter->start);

}

if (end) {

if (iter->end)

git__free(iter->end);

iter->end = git__strdup(end);

GITERR_CHECK_ALLOC(iter->end);

}

iter->flags &= ~GIT_ITERATOR_FIRST_ACCESS;

return 0;

}

static int iterator__update_ignore_case(

git_iterator *iter,

git_iterator_flag_t flags)

{

bool ignore_case;

int error;

if ((flags & GIT_ITERATOR_IGNORE_CASE) != 0)

ignore_case = true;

else if ((flags & GIT_ITERATOR_DONT_IGNORE_CASE) != 0)

ignore_case = false;

else {

git_index *index;

if ((error = git_repository_index__weakptr(&index, iter->repo)) < 0)

return error;

ignore_case = (index->ignore_case == 1);

}

if (ignore_case) {

iter->flags = (iter->flags | GIT_ITERATOR_IGNORE_CASE);

iter->strcomp = git__strcasecmp;

iter->strncomp = git__strncasecmp;

iter->prefixcomp = git__prefixcmp_icase;

} else {

iter->flags = (iter->flags & ~GIT_ITERATOR_IGNORE_CASE);

iter->strcomp = git__strcmp;

iter->strncomp = git__strncmp;

iter->prefixcomp = git__prefixcmp;

}

iterator_pathlist__update_ignore_case(iter);

return 0;

}

GIT_INLINE(void) iterator__clear_entry(const git_index_entry **entry)

{

if (entry) *entry = NULL;

}

static int empty_iterator__noop(const git_index_entry **e, git_iterator *i)

{

GIT_UNUSED(i);

iterator__clear_entry(e);

return GIT_ITEROVER;

}

static int empty_iterator__seek(git_iterator *i, const char *p)

{

GIT_UNUSED(i); GIT_UNUSED(p);

return -1;

}

static int empty_iterator__reset(git_iterator *i, const char *s, const char *e)

{

GIT_UNUSED(i); GIT_UNUSED(s); GIT_UNUSED(e);

return 0;

}

static int empty_iterator__at_end(git_iterator *i)

{

GIT_UNUSED(i);

return 1;

}

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 **iter,

git_iterator_options *options)

{

empty_iterator *i = git__calloc(1, sizeof(empty_iterator));

GITERR_CHECK_ALLOC(i);

#define empty_iterator__current empty_iterator__noop

#define empty_iterator__advance empty_iterator__noop

#define empty_iterator__advance_into empty_iterator__noop

ITERATOR_BASE_INIT(i, empty, EMPTY, NULL);

if (options && (options->flags & GIT_ITERATOR_IGNORE_CASE) != 0)

i->base.flags |= GIT_ITERATOR_IGNORE_CASE;

*iter = (git_iterator *)i;

return 0;

}

typedef struct tree_iterator_entry tree_iterator_entry;

struct tree_iterator_entry {

};

typedef struct tree_iterator_frame tree_iterator_frame;

struct tree_iterator_frame {

};

typedef struct {

git_iterator base;

git_iterator_callbacks cb;

tree_iterator_frame *head, *root;

git_pool pool;

git_index_entry entry;

git_buf path;

int path_ambiguities;

bool path_has_filename;

bool entry_is_current;

} tree_iterator;

static char *tree_iterator__current_filename(

tree_iterator *ti, const git_tree_entry *te)

{

if (!ti->path_has_filename) {

if (git_buf_joinpath(&ti->path, ti->path.ptr, te->filename) < 0)

return NULL;

if (git_tree_entry__is_tree(te) && git_buf_putc(&ti->path, '/') < 0)

return NULL;

ti->path_has_filename = true;

}

return ti->path.ptr;

}

static void tree_iterator__rewrite_filename(tree_iterator *ti)

{

tree_iterator_entry *scan = ti->head->entries[ti->head->current];

ssize_t strpos = ti->path.size;

const git_tree_entry *te;

if (strpos && ti->path.ptr[strpos - 1] == '/')

strpos--;

for (; scan && (te = scan->te); scan = scan->parent) {

strpos -= te->filename_len;

memcpy(&ti->path.ptr[strpos], te->filename, te->filename_len);

strpos -= 1; /* separator */

}

}

static int tree_iterator__te_cmp(

const git_tree_entry *a,

const git_tree_entry *b,

int (*compare)(const char *, const char *, size_t))

{

return git_path_cmp(

a->filename, a->filename_len, a->attr == GIT_FILEMODE_TREE,

b->filename, b->filename_len, b->attr == GIT_FILEMODE_TREE,

compare);

}

static int tree_iterator__ci_cmp(const void *a, const void *b, void *p)

{

const tree_iterator_entry *ae = a, *be = b;

int cmp = tree_iterator__te_cmp(ae->te, be->te, git__strncasecmp);

if (!cmp) {

/* stabilize sort order among equivalent names */

if (!ae->parent->te || !be->parent->te)

cmp = tree_iterator__te_cmp(ae->te, be->te, git__strncmp);

else

cmp = tree_iterator__ci_cmp(ae->parent, be->parent, p);

}

return cmp;

}

static int tree_iterator__search_cmp(const void *key, const void *val, void *p)

{

const tree_iterator_frame *tf = key;

const git_tree_entry *te = ((tree_iterator_entry *)val)->te;

return git_path_cmp(

tf->start, tf->startlen, false,

te->filename, te->filename_len, te->attr == GIT_FILEMODE_TREE,

((git_iterator *)p)->strncomp);

}

static bool tree_iterator__move_to_next(

tree_iterator *ti, tree_iterator_frame *tf)

{

if (tf->next > tf->current + 1)

ti->path_ambiguities--;

if (!tf->up) { /* at root */

tf->current = tf->next;

return false;

}

for (; tf->current < tf->next; tf->current++) {

git_tree_free(tf->entries[tf->current]->tree);

tf->entries[tf->current]->tree = NULL;

}

return (tf->current < tf->n_entries);

}

static int tree_iterator__set_next(tree_iterator *ti, tree_iterator_frame *tf)

{

int error = 0;

const git_tree_entry *te, *last = NULL;

tf->next = tf->current;

for (; tf->next < tf->n_entries; tf->next++, last = te) {

te = tf->entries[tf->next]->te;

if (last && tree_iterator__te_cmp(last, te, ti->base.strncomp))

break;

/* try to load trees for items in [current,next) range */

if (!error && git_tree_entry__is_tree(te))

error = git_tree_lookup(

&tf->entries[tf->next]->tree, ti->base.repo, &te->oid);

}

if (tf->next > tf->current + 1)

ti->path_ambiguities++;

/* if a tree lookup failed, advance over this span and return failure */

if (error < 0) {

tree_iterator__move_to_next(ti, tf);

return error;

}

if (last && !tree_iterator__current_filename(ti, last))

return -1; /* must have been allocation failure */

return 0;

}

GIT_INLINE(bool) tree_iterator__at_tree(tree_iterator *ti)

{

return (ti->head->current < ti->head->n_entries &&

ti->head->entries[ti->head->current]->tree != NULL);

}

static int tree_iterator__push_frame(tree_iterator *ti)

{

int error = 0;

tree_iterator_frame *head = ti->head, *tf = NULL;

size_t i, n_entries = 0, alloclen;

if (head->current >= head->n_entries || !head->entries[head->current]->tree)

return GIT_ITEROVER;

for (i = head->current; i < head->next; ++i)

n_entries += git_tree_entrycount(head->entries[i]->tree);

GITERR_CHECK_ALLOC_MULTIPLY(&alloclen, sizeof(tree_iterator_entry *), n_entries);

GITERR_CHECK_ALLOC_ADD(&alloclen, alloclen, sizeof(tree_iterator_frame));

tf = git__calloc(1, alloclen);

GITERR_CHECK_ALLOC(tf);

tf->n_entries = n_entries;

tf->up = head;

head->down = tf;

ti->head = tf;

for (i = head->current, n_entries = 0; i < head->next; ++i) {

git_tree *tree = head->entries[i]->tree;

size_t j, max_j = git_tree_entrycount(tree);

for (j = 0; j < max_j; ++j) {

tree_iterator_entry *entry = git_pool_malloc(&ti->pool, 1);

GITERR_CHECK_ALLOC(entry);

entry->parent = head->entries[i];

entry->te = git_tree_entry_byindex(tree, j);

entry->tree = NULL;

tf->entries[n_entries++] = entry;

}

}

/* if ignore_case, sort entries case insensitively */

if (iterator__ignore_case(ti))

git__tsort_r(

(void **)tf->entries, tf->n_entries, tree_iterator__ci_cmp, tf);

/* pick tf->current based on "start" (or start at zero) */

if (head->startlen > 0) {

git__bsearch_r((void **)tf->entries, tf->n_entries, head,

tree_iterator__search_cmp, ti, &tf->current);

while (tf->current &&

!tree_iterator__search_cmp(head, tf->entries[tf->current-1], ti))

tf->current--;

if ((tf->start = strchr(head->start, '/')) != NULL) {

tf->start++;

tf->startlen = strlen(tf->start);

}

}

ti->path_has_filename = ti->entry_is_current = false;

if ((error = tree_iterator__set_next(ti, tf)) < 0)

return error;

/* autoexpand as needed */

if (!iterator__include_trees(ti) && tree_iterator__at_tree(ti))

return tree_iterator__push_frame(ti);

return 0;

}

static bool tree_iterator__pop_frame(tree_iterator *ti, bool final)

{

tree_iterator_frame *tf = ti->head;

if (!tf->up)

return false;

ti->head = tf->up;

ti->head->down = NULL;

tree_iterator__move_to_next(ti, tf);

if (!final) { /* if final, don't bother to clean up */

// TODO: maybe free the pool so far?

git_buf_rtruncate_at_char(&ti->path, '/');

}

git__free(tf);

return true;

}

static void tree_iterator__pop_all(tree_iterator *ti, bool to_end, bool final)

{

while (tree_iterator__pop_frame(ti, final)) /* pop to root */;

if (!final) {

ti->head->current = to_end ? ti->head->n_entries : 0;

ti->path_ambiguities = 0;

git_buf_clear(&ti->path);

}

}

static int tree_iterator__update_entry(tree_iterator *ti)

{

tree_iterator_frame *tf;

const git_tree_entry *te;

if (ti->entry_is_current)

return 0;

tf = ti->head;

te = tf->entries[tf->current]->te;

ti->entry.mode = te->attr;

git_oid_cpy(&ti->entry.id, &te->oid);

ti->entry.path = tree_iterator__current_filename(ti, te);

GITERR_CHECK_ALLOC(ti->entry.path);

if (ti->path_ambiguities > 0)

tree_iterator__rewrite_filename(ti);

if (iterator__past_end(ti, ti->entry.path)) {

tree_iterator__pop_all(ti, true, false);

return GIT_ITEROVER;

}

ti->entry_is_current = true;

return 0;

}

static int tree_iterator__current_internal(

const git_index_entry **entry, git_iterator *self)

{

int error;

tree_iterator *ti = (tree_iterator *)self;

tree_iterator_frame *tf = ti->head;

iterator__clear_entry(entry);

if (tf->current >= tf->n_entries)

return GIT_ITEROVER;

if ((error = tree_iterator__update_entry(ti)) < 0)

return error;

if (entry)

*entry = &ti->entry;

ti->base.flags |= GIT_ITERATOR_FIRST_ACCESS;

return 0;

}

static int tree_iterator__advance_into_internal(git_iterator *self)

{

int error = 0;

tree_iterator *ti = (tree_iterator *)self;

if (tree_iterator__at_tree(ti))

error = tree_iterator__push_frame(ti);

return error;

}

static int tree_iterator__advance_internal(git_iterator *self)

{

int error;

tree_iterator *ti = (tree_iterator *)self;

tree_iterator_frame *tf = ti->head;

if (tf->current >= tf->n_entries)

return GIT_ITEROVER;

if (!iterator__has_been_accessed(ti))

return 0;

if (iterator__do_autoexpand(ti) && iterator__include_trees(ti) &&

tree_iterator__at_tree(ti))

return tree_iterator__advance_into_internal(self);

if (ti->path_has_filename) {

git_buf_rtruncate_at_char(&ti->path, '/');

ti->path_has_filename = ti->entry_is_current = false;

}

/* scan forward and up, advancing in frame or popping frame when done */

while (!tree_iterator__move_to_next(ti, tf) &&

tree_iterator__pop_frame(ti, false))

tf = ti->head;

/* find next and load trees */

if ((error = tree_iterator__set_next(ti, tf)) < 0)

return error;

/* deal with include_trees / auto_expand as needed */

if (!iterator__include_trees(ti) && tree_iterator__at_tree(ti))

return tree_iterator__advance_into_internal(self);

return 0;

}

static int tree_iterator__current(

const git_index_entry **out, git_iterator *self)

{

const git_index_entry *entry = NULL;

iterator_pathlist__match_t m;

int error;

do {

if ((error = tree_iterator__current_internal(&entry, self)) < 0)

return error;

if (self->pathlist.length) {

m = iterator_pathlist__match(

self, entry->path, strlen(entry->path));

if (m != ITERATOR_PATHLIST_MATCH) {

if ((error = tree_iterator__advance_internal(self)) < 0)

return error;

entry = NULL;

}

}

} while (!entry);

if (out)

*out = entry;

return error;

}

static int tree_iterator__advance(

const git_index_entry **entry, git_iterator *self)

{

int error = tree_iterator__advance_internal(self);

iterator__clear_entry(entry);

if (error < 0)

return error;

return tree_iterator__current(entry, self);

}

static int tree_iterator__advance_into(

const git_index_entry **entry, git_iterator *self)

{

int error = tree_iterator__advance_into_internal(self);

iterator__clear_entry(entry);

if (error < 0)

return error;

return tree_iterator__current(entry, self);

}

static int tree_iterator__seek(git_iterator *self, const char *prefix)

{

GIT_UNUSED(self); GIT_UNUSED(prefix);

return -1;

}

static int tree_iterator__reset(

git_iterator *self, const char *start, const char *end)

{

tree_iterator *ti = (tree_iterator *)self;

tree_iterator__pop_all(ti, false, false);

if (iterator__reset_range(self, start, end) < 0)

return -1;

return tree_iterator__push_frame(ti); /* re-expand root tree */

}

static int tree_iterator__at_end(git_iterator *self)

{

tree_iterator *ti = (tree_iterator *)self;

return (ti->head->current >= ti->head->n_entries);

}

static void tree_iterator__free(git_iterator *self)

{

tree_iterator *ti = (tree_iterator *)self;

tree_iterator__pop_all(ti, true, false);

git_tree_free(ti->head->entries[0]->tree);

git__free(ti->head);

git_pool_clear(&ti->pool);

git_buf_free(&ti->path);

}

static int tree_iterator__create_root_frame(tree_iterator *ti, git_tree *tree)

{

size_t sz = sizeof(tree_iterator_frame) + sizeof(tree_iterator_entry);

tree_iterator_frame *root = git__calloc(sz, sizeof(char));

GITERR_CHECK_ALLOC(root);

root->n_entries = 1;

root->next = 1;

root->start = ti->base.start;

root->startlen = root->start ? strlen(root->start) : 0;

root->entries[0] = git_pool_mallocz(&ti->pool, 1);

GITERR_CHECK_ALLOC(root->entries[0]);

root->entries[0]->tree = tree;

ti->head = ti->root = root;

return 0;

}

int git_iterator_for_tree(

git_iterator **iter,

git_tree *tree,

git_iterator_options *options)

{

int error;

tree_iterator *ti;

if (tree == NULL)

return git_iterator_for_nothing(iter, options);

if ((error = git_object_dup((git_object **)&tree, (git_object *)tree)) < 0)

return error;

ti = git__calloc(1, sizeof(tree_iterator));

GITERR_CHECK_ALLOC(ti);

ITERATOR_BASE_INIT(ti, tree, TREE, git_tree_owner(tree));

if ((error = iterator__update_ignore_case((git_iterator *)ti, options ? options->flags : 0)) < 0)

goto fail;

git_pool_init(&ti->pool, sizeof(tree_iterator_entry));

if ((error = tree_iterator__create_root_frame(ti, tree)) < 0 ||

(error = tree_iterator__push_frame(ti)) < 0) /* expand root now */

goto fail;

*iter = (git_iterator *)ti;

return 0;

fail:

git_iterator_free((git_iterator *)ti);

return error;

}

typedef struct {

git_iterator base;

git_iterator_callbacks cb;

git_index *index;

git_vector entries;

git_vector_cmp entry_srch;

size_t current;

/* when limiting with a pathlist, this is the current index into it */

size_t pathlist_idx;

/* when not in autoexpand mode, use these to represent "tree" state */

git_buf partial;

size_t partial_pos;

char restore_terminator;

git_index_entry tree_entry;

} index_iterator;

static const git_index_entry *index_iterator__index_entry(index_iterator *ii)

{

const git_index_entry *ie = git_vector_get(&ii->entries, ii->current);

if (ie != NULL && iterator__past_end(ii, ie->path)) {

ii->current = git_vector_length(&ii->entries);

ie = NULL;

}

return ie;

}

static const git_index_entry *index_iterator__advance_over_unwanted(

index_iterator *ii)

{

const git_index_entry *ie = index_iterator__index_entry(ii);

bool match;

while (ie) {

if (!iterator__include_conflicts(ii) &&

git_index_entry_is_conflict(ie)) {

ii->current++;

ie = index_iterator__index_entry(ii);

continue;

}

/* if we have a pathlist, this entry's path must be in it to be

if (ii->base.pathlist.length) {

match = iterator_pathlist_walk__contains(&ii->base, ie->path);

if (!match) {

ii->current++;

ie = index_iterator__index_entry(ii);

continue;

}

}

break;

}

return ie;

}

static void index_iterator__next_prefix_tree(index_iterator *ii)

{

const char *slash;

if (!iterator__include_trees(ii))

return;

slash = strchr(&ii->partial.ptr[ii->partial_pos], '/');

if (slash != NULL) {

ii->partial_pos = (slash - ii->partial.ptr) + 1;

ii->restore_terminator = ii->partial.ptr[ii->partial_pos];

ii->partial.ptr[ii->partial_pos] = '\0';

} else {

ii->partial_pos = ii->partial.size;

}

if (index_iterator__index_entry(ii) == NULL)

ii->partial_pos = ii->partial.size;

}

static int index_iterator__first_prefix_tree(index_iterator *ii)

{

const git_index_entry *ie = index_iterator__advance_over_unwanted(ii);

const char *scan, *prior, *slash;

if (!ie || !iterator__include_trees(ii))

return 0;

/* find longest common prefix with prior index entry */

for (scan = slash = ie->path, prior = ii->partial.ptr;

*scan && *scan == *prior; ++scan, ++prior)

if (*scan == '/')

slash = scan;

if (git_buf_sets(&ii->partial, ie->path) < 0)

return -1;

ii->partial_pos = (slash - ie->path) + 1;

index_iterator__next_prefix_tree(ii);

return 0;

}

#define index_iterator__at_tree(I) \

(iterator__include_trees(I) && (I)->partial_pos < (I)->partial.size)

static int index_iterator__current(

const git_index_entry **entry, git_iterator *self)

{

index_iterator *ii = (index_iterator *)self;

const git_index_entry *ie = git_vector_get(&ii->entries, ii->current);

if (ie != NULL && index_iterator__at_tree(ii)) {

ii->tree_entry.path = ii->partial.ptr;

ie = &ii->tree_entry;

}

if (entry)

*entry = ie;

ii->base.flags |= GIT_ITERATOR_FIRST_ACCESS;

return (ie != NULL) ? 0 : GIT_ITEROVER;

}

static int index_iterator__at_end(git_iterator *self)

{

index_iterator *ii = (index_iterator *)self;

return (ii->current >= git_vector_length(&ii->entries));

}

static int index_iterator__advance(

const git_index_entry **entry, git_iterator *self)

{

index_iterator *ii = (index_iterator *)self;

size_t entrycount = git_vector_length(&ii->entries);

const git_index_entry *ie;

if (!iterator__has_been_accessed(ii))

return index_iterator__current(entry, self);

if (index_iterator__at_tree(ii)) {

if (iterator__do_autoexpand(ii)) {

ii->partial.ptr[ii->partial_pos] = ii->restore_terminator;

index_iterator__next_prefix_tree(ii);

} else {

/* advance to sibling tree (i.e. find entry with new prefix) */

while (ii->current < entrycount) {

ii->current++;

if (!(ie = git_vector_get(&ii->entries, ii->current)) ||

ii->base.prefixcomp(ie->path, ii->partial.ptr) != 0)

break;

}

if (index_iterator__first_prefix_tree(ii) < 0)

return -1;

}