#include <stddef.h>

#include "common.h"

#include "repository.h"

#include "index.h"

#include "tree.h"

#include "tree-cache.h"

#include "hash.h"

#include "iterator.h"

#include "pathspec.h"

#include "git2/odb.h"

#include "git2/oid.h"

#include "git2/blob.h"

#include "git2/config.h"

#define entry_size(type,len) ((offsetof(type, path) + (len) + 8) & ~7)

#define short_entry_size(len) entry_size(struct entry_short, len)

#define long_entry_size(len) entry_size(struct entry_long, len)

#define minimal_entry_size (offsetof(struct entry_short, path))

static const size_t INDEX_FOOTER_SIZE = GIT_OID_RAWSZ;

static const size_t INDEX_HEADER_SIZE = 12;

static const unsigned int INDEX_VERSION_NUMBER = 2;

static const unsigned int INDEX_VERSION_NUMBER_EXT = 3;

static const unsigned int INDEX_HEADER_SIG = 0x44495243;

static const char INDEX_EXT_TREECACHE_SIG[] = {'T', 'R', 'E', 'E'};

static const char INDEX_EXT_UNMERGED_SIG[] = {'R', 'E', 'U', 'C'};

#define INDEX_OWNER(idx) ((git_repository *)(GIT_REFCOUNT_OWNER(idx)))

struct index_header {

};

struct index_extension {

char signature[4];

uint32_t extension_size;

};

struct entry_time {

uint32_t seconds;

uint32_t nanoseconds;

};

struct entry_short {

};

struct entry_long {

};

struct entry_srch_key {

const char *path;

int stage;

};

static size_t read_extension(git_index *index, const char *buffer, size_t buffer_size);

static size_t read_entry(git_index_entry *dest, const void *buffer, size_t buffer_size);

static int read_header(struct index_header *dest, const void *buffer);

static int parse_index(git_index *index, const char *buffer, size_t buffer_size);

static bool is_index_extended(git_index *index);

static int write_index(git_index *index, git_filebuf *file);

static int index_find(size_t *at_pos, git_index *index, const char *path, int stage);

static void index_entry_free(git_index_entry *entry);

static void index_entry_reuc_free(git_index_reuc_entry *reuc);

GIT_INLINE(int) index_entry_stage(const git_index_entry *entry)

{

return (entry->flags & GIT_IDXENTRY_STAGEMASK) >> GIT_IDXENTRY_STAGESHIFT;

}

static int index_srch(const void *key, const void *array_member)

{

const struct entry_srch_key *srch_key = key;

const git_index_entry *entry = array_member;

int ret;

ret = strcmp(srch_key->path, entry->path);

if (ret == 0)

ret = srch_key->stage - index_entry_stage(entry);

return ret;

}

static int index_isrch(const void *key, const void *array_member)

{

const struct entry_srch_key *srch_key = key;

const git_index_entry *entry = array_member;

int ret;

ret = strcasecmp(srch_key->path, entry->path);

if (ret == 0)

ret = srch_key->stage - index_entry_stage(entry);

return ret;

}

static int index_cmp_path(const void *a, const void *b)

{

return strcmp((const char *)a, (const char *)b);

}

static int index_icmp_path(const void *a, const void *b)

{

return strcasecmp((const char *)a, (const char *)b);

}

static int index_srch_path(const void *path, const void *array_member)

{

const git_index_entry *entry = array_member;

return strcmp((const char *)path, entry->path);

}

static int index_isrch_path(const void *path, const void *array_member)

{

const git_index_entry *entry = array_member;

return strcasecmp((const char *)path, entry->path);

}

static int index_cmp(const void *a, const void *b)

{

int diff;

const git_index_entry *entry_a = a;

const git_index_entry *entry_b = b;

diff = strcmp(entry_a->path, entry_b->path);

if (diff == 0)

diff = (index_entry_stage(entry_a) - index_entry_stage(entry_b));

return diff;

}

static int index_icmp(const void *a, const void *b)

{

int diff;

const git_index_entry *entry_a = a;

const git_index_entry *entry_b = b;

diff = strcasecmp(entry_a->path, entry_b->path);

if (diff == 0)

diff = (index_entry_stage(entry_a) - index_entry_stage(entry_b));

return diff;

}

static int reuc_srch(const void *key, const void *array_member)

{

const git_index_reuc_entry *reuc = array_member;

return strcmp(key, reuc->path);

}

static int reuc_isrch(const void *key, const void *array_member)

{

const git_index_reuc_entry *reuc = array_member;

return strcasecmp(key, reuc->path);

}

static int reuc_cmp(const void *a, const void *b)

{

const git_index_reuc_entry *info_a = a;

const git_index_reuc_entry *info_b = b;

return strcmp(info_a->path, info_b->path);

}

static int reuc_icmp(const void *a, const void *b)

{

const git_index_reuc_entry *info_a = a;

const git_index_reuc_entry *info_b = b;

return strcasecmp(info_a->path, info_b->path);

}

static unsigned int index_create_mode(unsigned int mode)

{

if (S_ISLNK(mode))

return S_IFLNK;

if (S_ISDIR(mode) || (mode & S_IFMT) == (S_IFLNK | S_IFDIR))

return (S_IFLNK | S_IFDIR);

return S_IFREG | ((mode & 0100) ? 0755 : 0644);

}

static unsigned int index_merge_mode(

git_index *index, git_index_entry *existing, unsigned int mode)

{

if (index->no_symlinks && S_ISREG(mode) &&

existing && S_ISLNK(existing->mode))

return existing->mode;

if (index->distrust_filemode && S_ISREG(mode))

return (existing && S_ISREG(existing->mode)) ?

existing->mode : index_create_mode(0666);

return index_create_mode(mode);

}

void git_index__set_ignore_case(git_index *index, bool ignore_case)

{

index->ignore_case = ignore_case;

index->entries._cmp = ignore_case ? index_icmp : index_cmp;

index->entries_cmp_path = ignore_case ? index_icmp_path : index_cmp_path;

index->entries_search = ignore_case ? index_isrch : index_srch;

index->entries_search_path = ignore_case ? index_isrch_path : index_srch_path;

index->entries.sorted = 0;

git_vector_sort(&index->entries);

index->reuc._cmp = ignore_case ? reuc_icmp : reuc_cmp;

index->reuc_search = ignore_case ? reuc_isrch : reuc_srch;

index->reuc.sorted = 0;

git_vector_sort(&index->reuc);

}

int git_index_open(git_index **index_out, const char *index_path)

{

git_index *index;

assert(index_out);

index = git__calloc(1, sizeof(git_index));

GITERR_CHECK_ALLOC(index);

if (index_path != NULL) {

index->index_file_path = git__strdup(index_path);

GITERR_CHECK_ALLOC(index->index_file_path);

/* Check if index file is stored on disk already */

if (git_path_exists(index->index_file_path) == true)

index->on_disk = 1;

}

if (git_vector_init(&index->entries, 32, index_cmp) < 0 ||

git_vector_init(&index->reuc, 32, reuc_cmp) < 0)

return -1;

index->entries_cmp_path = index_cmp_path;

index->entries_search = index_srch;

index->entries_search_path = index_srch_path;

index->reuc_search = reuc_srch;

*index_out = index;

GIT_REFCOUNT_INC(index);

return (index_path != NULL) ? git_index_read(index) : 0;

}

int git_index_new(git_index **out)

{

return git_index_open(out, NULL);

}

static void index_free(git_index *index)

{

git_index_clear(index);

git_vector_free(&index->entries);

git_vector_free(&index->reuc);

git__free(index->index_file_path);

git__free(index);

}

void git_index_free(git_index *index)

{

if (index == NULL)

return;

GIT_REFCOUNT_DEC(index, index_free);

}

void git_index_clear(git_index *index)

{

size_t i;

assert(index);

for (i = 0; i < index->entries.length; ++i) {

git_index_entry *e;

e = git_vector_get(&index->entries, i);

git__free(e->path);

git__free(e);

}

git_vector_clear(&index->entries);

git_index_reuc_clear(index);

git_futils_filestamp_set(&index->stamp, NULL);

git_tree_cache_free(index->tree);

index->tree = NULL;

}

static int create_index_error(int error, const char *msg)

{

giterr_set(GITERR_INDEX, msg);

return error;

}

int git_index_set_caps(git_index *index, unsigned int caps)

{

int old_ignore_case;

assert(index);

old_ignore_case = index->ignore_case;

if (caps == GIT_INDEXCAP_FROM_OWNER) {

git_config *cfg;

int val;

if (INDEX_OWNER(index) == NULL ||

git_repository_config__weakptr(&cfg, INDEX_OWNER(index)) < 0)

return create_index_error(-1,

"Cannot get repository config to set index caps");

if (git_config_get_bool(&val, cfg, "core.ignorecase") == 0)

index->ignore_case = (val != 0);

if (git_config_get_bool(&val, cfg, "core.filemode") == 0)

index->distrust_filemode = (val == 0);

if (git_config_get_bool(&val, cfg, "core.symlinks") == 0)

index->no_symlinks = (val == 0);

}

else {

index->ignore_case = ((caps & GIT_INDEXCAP_IGNORE_CASE) != 0);

index->distrust_filemode = ((caps & GIT_INDEXCAP_NO_FILEMODE) != 0);

index->no_symlinks = ((caps & GIT_INDEXCAP_NO_SYMLINKS) != 0);

}

if (old_ignore_case != index->ignore_case) {

git_index__set_ignore_case(index, index->ignore_case);

}

return 0;

}

unsigned int git_index_caps(const git_index *index)

{

return ((index->ignore_case ? GIT_INDEXCAP_IGNORE_CASE : 0) |

(index->distrust_filemode ? GIT_INDEXCAP_NO_FILEMODE : 0) |

(index->no_symlinks ? GIT_INDEXCAP_NO_SYMLINKS : 0));

}

int git_index_read(git_index *index)

{

int error = 0, updated;

git_buf buffer = GIT_BUF_INIT;

git_futils_filestamp stamp = {0};

if (!index->index_file_path)

return create_index_error(-1,

"Failed to read index: The index is in-memory only");

if (!index->on_disk || git_path_exists(index->index_file_path) == false) {

git_index_clear(index);

index->on_disk = 0;

return 0;

}

updated = git_futils_filestamp_check(&stamp, index->index_file_path);

if (updated <= 0)

return updated;

error = git_futils_readbuffer(&buffer, index->index_file_path);

if (error < 0)

return error;

git_index_clear(index);

error = parse_index(index, buffer.ptr, buffer.size);

if (!error)

git_futils_filestamp_set(&index->stamp, &stamp);

git_buf_free(&buffer);

return error;

}

int git_index_write(git_index *index)

{

git_filebuf file = GIT_FILEBUF_INIT;

int error;

if (!index->index_file_path)

return create_index_error(-1,

"Failed to read index: The index is in-memory only");

git_vector_sort(&index->entries);

git_vector_sort(&index->reuc);

if ((error = git_filebuf_open(

&file, index->index_file_path, GIT_FILEBUF_HASH_CONTENTS)) < 0)

return error;

if ((error = write_index(index, &file)) < 0) {

git_filebuf_cleanup(&file);

return error;

}

if ((error = git_filebuf_commit(&file, GIT_INDEX_FILE_MODE)) < 0)

return error;

error = git_futils_filestamp_check(&index->stamp, index->index_file_path);

if (error < 0)

return error;

index->on_disk = 1;

return 0;

}

int git_index_write_tree(git_oid *oid, git_index *index)

{

git_repository *repo;

assert(oid && index);

repo = INDEX_OWNER(index);

if (repo == NULL)

return create_index_error(-1, "Failed to write tree. "

"The index file is not backed up by an existing repository");

return git_tree__write_index(oid, index, repo);

}

int git_index_write_tree_to(git_oid *oid, git_index *index, git_repository *repo)

{

assert(oid && index && repo);

return git_tree__write_index(oid, index, repo);

}

size_t git_index_entrycount(const git_index *index)

{

assert(index);

return index->entries.length;

}

const git_index_entry *git_index_get_byindex(

git_index *index, size_t n)

{

assert(index);

git_vector_sort(&index->entries);

return git_vector_get(&index->entries, n);

}

const git_index_entry *git_index_get_bypath(

git_index *index, const char *path, int stage)

{

size_t pos;

assert(index);

git_vector_sort(&index->entries);

if (index_find(&pos, index, path, stage) < 0)

return NULL;

return git_index_get_byindex(index, pos);

}

void git_index_entry__init_from_stat(git_index_entry *entry, struct stat *st)

{

entry->ctime.seconds = (git_time_t)st->st_ctime;

entry->mtime.seconds = (git_time_t)st->st_mtime;

/* entry->mtime.nanoseconds = st->st_mtimensec; */

/* entry->ctime.nanoseconds = st->st_ctimensec; */

entry->dev = st->st_rdev;

entry->ino = st->st_ino;

entry->mode = index_create_mode(st->st_mode);

entry->uid = st->st_uid;

entry->gid = st->st_gid;

entry->file_size = st->st_size;

}

int git_index_entry__cmp(const void *a, const void *b)

{

const git_index_entry *entry_a = a;

const git_index_entry *entry_b = b;

return strcmp(entry_a->path, entry_b->path);

}

int git_index_entry__cmp_icase(const void *a, const void *b)

{

const git_index_entry *entry_a = a;

const git_index_entry *entry_b = b;

return strcasecmp(entry_a->path, entry_b->path);

}

static int index_entry_init(git_index_entry **entry_out, git_index *index, const char *rel_path)

{

git_index_entry *entry = NULL;

struct stat st;

git_oid oid;

const char *workdir;

git_buf full_path = GIT_BUF_INIT;

int error;

if (INDEX_OWNER(index) == NULL)

return create_index_error(-1,

"Could not initialize index entry. "

"Index is not backed up by an existing repository.");

workdir = git_repository_workdir(INDEX_OWNER(index));

if (!workdir)

return create_index_error(GIT_EBAREREPO,

"Could not initialize index entry. Repository is bare");

if ((error = git_buf_joinpath(&full_path, workdir, rel_path)) < 0)

return error;

if ((error = git_path_lstat(full_path.ptr, &st)) < 0) {

git_buf_free(&full_path);

return error;

}

git_buf_free(&full_path); /* done with full path */

/* There is no need to validate the rel_path here, since it will be

/* write the blob to disk and get the oid */

if ((error = git_blob_create_fromworkdir(&oid, INDEX_OWNER(index), rel_path)) < 0)

return error;

entry = git__calloc(1, sizeof(git_index_entry));

GITERR_CHECK_ALLOC(entry);

git_index_entry__init_from_stat(entry, &st);

entry->oid = oid;

entry->path = git__strdup(rel_path);

GITERR_CHECK_ALLOC(entry->path);

*entry_out = entry;

return 0;

}

static int index_entry_reuc_init(git_index_reuc_entry **reuc_out,

const char *path,

int ancestor_mode, git_oid *ancestor_oid,

int our_mode, git_oid *our_oid, int their_mode, git_oid *their_oid)

{

git_index_reuc_entry *reuc = NULL;

assert(reuc_out && path);

*reuc_out = NULL;

reuc = git__calloc(1, sizeof(git_index_reuc_entry));

GITERR_CHECK_ALLOC(reuc);

reuc->path = git__strdup(path);

if (reuc->path == NULL)

return -1;

if ((reuc->mode[0] = ancestor_mode) > 0)

git_oid_cpy(&reuc->oid[0], ancestor_oid);

if ((reuc->mode[1] = our_mode) > 0)

git_oid_cpy(&reuc->oid[1], our_oid);

if ((reuc->mode[2] = their_mode) > 0)

git_oid_cpy(&reuc->oid[2], their_oid);

*reuc_out = reuc;

return 0;

}

static void index_entry_reuc_free(git_index_reuc_entry *reuc)

{

if (!reuc)

return;

git__free(reuc->path);

git__free(reuc);

}

static git_index_entry *index_entry_dup(const git_index_entry *source_entry)

{

git_index_entry *entry;

entry = git__malloc(sizeof(git_index_entry));

if (!entry)

return NULL;

memcpy(entry, source_entry, sizeof(git_index_entry));

/* duplicate the path string so we own it */

entry->path = git__strdup(entry->path);

if (!entry->path)

return NULL;

return entry;

}

static void index_entry_free(git_index_entry *entry)

{

if (!entry)

return;

git__free(entry->path);

git__free(entry);

}

static int index_insert(git_index *index, git_index_entry *entry, int replace)

{

size_t path_length, position;

git_index_entry **existing = NULL;

assert(index && entry && entry->path != NULL);

/* make sure that the path length flag is correct */

path_length = strlen(entry->path);

entry->flags &= ~GIT_IDXENTRY_NAMEMASK;

if (path_length < GIT_IDXENTRY_NAMEMASK)

entry->flags |= path_length & GIT_IDXENTRY_NAMEMASK;

else

entry->flags |= GIT_IDXENTRY_NAMEMASK;

/* look if an entry with this path already exists */

if (!index_find(&position, index, entry->path, index_entry_stage(entry))) {

existing = (git_index_entry **)&index->entries.contents[position];

/* update filemode to existing values if stat is not trusted */

entry->mode = index_merge_mode(index, *existing, entry->mode);

}

/* if replacing is not requested or no existing entry exists, just

if (!replace || !existing)

return git_vector_insert(&index->entries, entry);

/* exists, replace it */

git__free((*existing)->path);

git__free(*existing);

*existing = entry;

return 0;

}

static int index_conflict_to_reuc(git_index *index, const char *path)

{

git_index_entry *conflict_entries[3];

int ancestor_mode, our_mode, their_mode;

git_oid *ancestor_oid, *our_oid, *their_oid;

int ret;

if ((ret = git_index_conflict_get(&conflict_entries[0],

&conflict_entries[1], &conflict_entries[2], index, path)) < 0)

return ret;

ancestor_mode = conflict_entries[0] == NULL ? 0 : conflict_entries[0]->mode;

our_mode = conflict_entries[1] == NULL ? 0 : conflict_entries[1]->mode;

their_mode = conflict_entries[2] == NULL ? 0 : conflict_entries[2]->mode;

ancestor_oid = conflict_entries[0] == NULL ? NULL : &conflict_entries[0]->oid;

our_oid = conflict_entries[1] == NULL ? NULL : &conflict_entries[1]->oid;

their_oid = conflict_entries[2] == NULL ? NULL : &conflict_entries[2]->oid;

if ((ret = git_index_reuc_add(index, path, ancestor_mode, ancestor_oid,

our_mode, our_oid, their_mode, their_oid)) >= 0)

ret = git_index_conflict_remove(index, path);

return ret;

}

int git_index_add_bypath(git_index *index, const char *path)

{

git_index_entry *entry = NULL;

int ret;

assert(index && path);

if ((ret = index_entry_init(&entry, index, path)) < 0 ||

(ret = index_insert(index, entry, 1)) < 0)

goto on_error;

/* Adding implies conflict was resolved, move conflict entries to REUC */

if ((ret = index_conflict_to_reuc(index, path)) < 0 && ret != GIT_ENOTFOUND)

goto on_error;

git_tree_cache_invalidate_path(index->tree, entry->path);

return 0;

on_error:

index_entry_free(entry);

return ret;

}

int git_index_remove_bypath(git_index *index, const char *path)

{

int ret;

assert(index && path);

if (((ret = git_index_remove(index, path, 0)) < 0 &&

ret != GIT_ENOTFOUND) ||

((ret = index_conflict_to_reuc(index, path)) < 0 &&

ret != GIT_ENOTFOUND))

return ret;

return 0;

}

int git_index_add(git_index *index, const git_index_entry *source_entry)

{

git_index_entry *entry = NULL;

int ret;

entry = index_entry_dup(source_entry);

if (entry == NULL)

return -1;

if ((ret = index_insert(index, entry, 1)) < 0) {

index_entry_free(entry);

return ret;

}

git_tree_cache_invalidate_path(index->tree, entry->path);

return 0;

}

int git_index_remove(git_index *index, const char *path, int stage)

{

size_t position;

int error;

git_index_entry *entry;

git_vector_sort(&index->entries);

if (index_find(&position, index, path, stage) < 0)

return GIT_ENOTFOUND;

entry = git_vector_get(&index->entries, position);

if (entry != NULL)

git_tree_cache_invalidate_path(index->tree, entry->path);

error = git_vector_remove(&index->entries, position);

if (!error)

index_entry_free(entry);

return error;

}

int git_index_remove_directory(git_index *index, const char *dir, int stage)

{

git_buf pfx = GIT_BUF_INIT;

int error = 0;

size_t pos;

git_index_entry *entry;

if (git_buf_sets(&pfx, dir) < 0 || git_path_to_dir(&pfx) < 0)

return -1;

git_vector_sort(&index->entries);

pos = git_index__prefix_position(index, pfx.ptr);

while (1) {

entry = git_vector_get(&index->entries, pos);

if (!entry || git__prefixcmp(entry->path, pfx.ptr) != 0)

break;

if (index_entry_stage(entry) != stage) {

++pos;

continue;

}

git_tree_cache_invalidate_path(index->tree, entry->path);

if ((error = git_vector_remove(&index->entries, pos)) < 0)

break;

index_entry_free(entry);

/* removed entry at 'pos' so we don't need to increment it */

}

git_buf_free(&pfx);

return error;

}

static int index_find(size_t *at_pos, git_index *index, const char *path, int stage)

{

struct entry_srch_key srch_key;

assert(path);

srch_key.path = path;

srch_key.stage = stage;

return git_vector_bsearch2(at_pos, &index->entries, index->entries_search, &srch_key);

}

int git_index_find(size_t *at_pos, git_index *index, const char *path)

{

size_t pos;

assert(index && path);

if (git_vector_bsearch2(&pos, &index->entries, index->entries_search_path, path) < 0) {

giterr_set(GITERR_INDEX, "Index does not contain %s", path);

return GIT_ENOTFOUND;

}

/* Since our binary search only looked at path, we may be in the

while (pos > 0) {

const git_index_entry *prev = git_vector_get(&index->entries, pos-1);

if (index->entries_cmp_path(prev->path, path) != 0)

break;

--pos;

}

if (at_pos)

*at_pos = pos;

return 0;

}

size_t git_index__prefix_position(git_index *index, const char *path)

{

struct entry_srch_key srch_key;

size_t pos;

srch_key.path = path;

srch_key.stage = 0;

git_vector_sort(&index->entries);

git_vector_bsearch2(

&pos, &index->entries, index->entries_search, &srch_key);

return pos;

}

int git_index_conflict_add(git_index *index,

const git_index_entry *ancestor_entry,

const git_index_entry *our_entry,

const git_index_entry *their_entry)

{

git_index_entry *entries[3] = { 0 };

unsigned short i;

int ret = 0;

assert (index);

if ((ancestor_entry != NULL && (entries[0] = index_entry_dup(ancestor_entry)) == NULL) ||

(our_entry != NULL && (entries[1] = index_entry_dup(our_entry)) == NULL) ||

(their_entry != NULL && (entries[2] = index_entry_dup(their_entry)) == NULL))

return -1;

for (i = 0; i < 3; i++) {

if (entries[i] == NULL)

continue;

/* Make sure stage is correct */

entries[i]->flags = (entries[i]->flags & ~GIT_IDXENTRY_STAGEMASK) |

((i+1) << GIT_IDXENTRY_STAGESHIFT);

if ((ret = index_insert(index, entries[i], 1)) < 0)

goto on_error;

}

return 0;

on_error:

for (i = 0; i < 3; i++) {

if (entries[i] != NULL)

index_entry_free(entries[i]);

}

return ret;

}

int git_index_conflict_get(git_index_entry **ancestor_out,

git_index_entry **our_out,

git_index_entry **their_out,

git_index *index, const char *path)

{

size_t pos, posmax;

int stage;

git_index_entry *conflict_entry;

int error = GIT_ENOTFOUND;

assert(ancestor_out && our_out && their_out && index && path);

*ancestor_out = NULL;

*our_out = NULL;

*their_out = NULL;

if (git_index_find(&pos, index, path) < 0)

return GIT_ENOTFOUND;

for (posmax = git_index_entrycount(index); pos < posmax; ++pos) {

conflict_entry = git_vector_get(&index->entries, pos);

if (index->entries_cmp_path(conflict_entry->path, path) != 0)

break;

stage = index_entry_stage(conflict_entry);

switch (stage) {

case 3:

*their_out = conflict_entry;

error = 0;

break;

case 2:

*our_out = conflict_entry;

error = 0;

break;

case 1:

*ancestor_out = conflict_entry;

error = 0;

break;

default:

break;

};

}

return error;

}

int git_index_conflict_remove(git_index *index, const char *path)

{

size_t pos, posmax;

git_index_entry *conflict_entry;

int error = 0;

assert(index && path);

if (git_index_find(&pos, index, path) < 0)

return GIT_ENOTFOUND;

posmax = git_index_entrycount(index);

while (pos < posmax) {

conflict_entry = git_vector_get(&index->entries, pos);

if (index->entries_cmp_path(conflict_entry->path, path) != 0)

break;

if (index_entry_stage(conflict_entry) == 0) {

pos++;

continue;