/*

 * 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 "common.h"

#include "diff.h"

#include "diff_generate.h"

#include "patch_generate.h"

#include "fileops.h"

#include "config.h"

#include "attr_file.h"

#include "filter.h"

#include "pathspec.h"

#include "index.h"

#include "odb.h"

#include "submodule.h"

#define DIFF_FLAG_IS_SET(DIFF,FLAG) \

	(((DIFF)->base.opts.flags & (FLAG)) != 0)

#define DIFF_FLAG_ISNT_SET(DIFF,FLAG) \

	(((DIFF)->base.opts.flags & (FLAG)) == 0)

#define DIFF_FLAG_SET(DIFF,FLAG,VAL) (DIFF)->base.opts.flags = \

	(VAL) ? ((DIFF)->base.opts.flags | (FLAG)) : \

	((DIFF)->base.opts.flags & ~(FLAG))

typedef struct {

	struct git_diff base;

	git_vector pathspec;

	uint32_t diffcaps;

	bool index_updated;

} git_diff_generated;

static git_diff_delta *diff_delta__alloc(

	git_diff_generated *diff,

	git_delta_t status,

	const char *path)

{

	git_diff_delta *delta = git__calloc(1, sizeof(git_diff_delta));

	if (!delta)

		return NULL;

	delta->old_file.path = git_pool_strdup(&diff->base.pool, path);

	if (delta->old_file.path == NULL) {

		git__free(delta);

		return NULL;

	}

	delta->new_file.path = delta->old_file.path;

	if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_REVERSE)) {

		switch (status) {

		case GIT_DELTA_ADDED:   status = GIT_DELTA_DELETED; break;

		case GIT_DELTA_DELETED: status = GIT_DELTA_ADDED; break;

		default: break; /* leave other status values alone */

		}

	}

	delta->status = status;

	return delta;

}

static int diff_insert_delta(

	git_diff_generated *diff,

	git_diff_delta *delta,

	const char *matched_pathspec)

{

	int error = 0;

	if (diff->base.opts.notify_cb) {

		error = diff->base.opts.notify_cb(

			&diff->base, delta, matched_pathspec, diff->base.opts.payload);

		if (error) {

			git__free(delta);

			if (error > 0)	/* positive value means to skip this delta */

				return 0;

			else			/* negative value means to cancel diff */

				return giterr_set_after_callback_function(error, "git_diff");

		}

	}

	if ((error = git_vector_insert(&diff->base.deltas, delta)) < 0)

		git__free(delta);

	return error;

}

static bool diff_pathspec_match(

	const char **matched_pathspec,

	git_diff_generated *diff,

	const git_index_entry *entry)

{

	bool disable_pathspec_match =

		DIFF_FLAG_IS_SET(diff, GIT_DIFF_DISABLE_PATHSPEC_MATCH);

	/* If we're disabling fnmatch, then the iterator has already applied

	 * the filters to the files for us and we don't have to do anything.

	 * However, this only applies to *files* - the iterator will include

	 * directories that we need to recurse into when not autoexpanding,

	 * so we still need to apply the pathspec match to directories.

	 */

	if ((S_ISLNK(entry->mode) || S_ISREG(entry->mode)) &&

		disable_pathspec_match) {

		*matched_pathspec = entry->path;

		return true;

	}

	return git_pathspec__match(

		&diff->pathspec, entry->path, disable_pathspec_match,

		DIFF_FLAG_IS_SET(diff, GIT_DIFF_IGNORE_CASE),

		matched_pathspec, NULL);

}

static int diff_delta__from_one(

	git_diff_generated *diff,

	git_delta_t status,

	const git_index_entry *oitem,

	const git_index_entry *nitem)

{

	const git_index_entry *entry = nitem;

	bool has_old = false;

	git_diff_delta *delta;

	const char *matched_pathspec;

	assert((oitem != NULL) ^ (nitem != NULL));

	if (oitem) {

		entry = oitem;

		has_old = true;

	}

	if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_REVERSE))

		has_old = !has_old;

	if ((entry->flags & GIT_IDXENTRY_VALID) != 0)

		return 0;

	if (status == GIT_DELTA_IGNORED &&

		DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_INCLUDE_IGNORED))

		return 0;

	if (status == GIT_DELTA_UNTRACKED &&

		DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_INCLUDE_UNTRACKED))

		return 0;

	if (status == GIT_DELTA_UNREADABLE &&

		DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_INCLUDE_UNREADABLE))

		return 0;

	if (!diff_pathspec_match(&matched_pathspec, diff, entry))

		return 0;

	delta = diff_delta__alloc(diff, status, entry->path);

	GITERR_CHECK_ALLOC(delta);

	/* This fn is just for single-sided diffs */

	assert(status != GIT_DELTA_MODIFIED);

	delta->nfiles = 1;

	if (has_old) {

		delta->old_file.mode = entry->mode;

		delta->old_file.size = entry->file_size;

		delta->old_file.flags |= GIT_DIFF_FLAG_EXISTS;

		git_oid_cpy(&delta->old_file.id, &entry->id);

		delta->old_file.id_abbrev = GIT_OID_HEXSZ;

	} else /* ADDED, IGNORED, UNTRACKED */ {

		delta->new_file.mode = entry->mode;

		delta->new_file.size = entry->file_size;

		delta->new_file.flags |= GIT_DIFF_FLAG_EXISTS;

		git_oid_cpy(&delta->new_file.id, &entry->id);

		delta->new_file.id_abbrev = GIT_OID_HEXSZ;

	}

	delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID;

	if (has_old || !git_oid_iszero(&delta->new_file.id))

		delta->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;

	return diff_insert_delta(diff, delta, matched_pathspec);

}

static int diff_delta__from_two(

	git_diff_generated *diff,

	git_delta_t status,

	const git_index_entry *old_entry,

	uint32_t old_mode,

	const git_index_entry *new_entry,

	uint32_t new_mode,

	const git_oid *new_id,

	const char *matched_pathspec)

{

	const git_oid *old_id = &old_entry->id;

	git_diff_delta *delta;

	const char *canonical_path = old_entry->path;

	if (status == GIT_DELTA_UNMODIFIED &&

		DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_INCLUDE_UNMODIFIED))

		return 0;

	if (!new_id)

		new_id = &new_entry->id;

	if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_REVERSE)) {

		uint32_t temp_mode = old_mode;

		const git_index_entry *temp_entry = old_entry;

		const git_oid *temp_id = old_id;

		old_entry = new_entry;

		new_entry = temp_entry;

		old_mode = new_mode;

		new_mode = temp_mode;

		old_id = new_id;

		new_id = temp_id;

	}

	delta = diff_delta__alloc(diff, status, canonical_path);

	GITERR_CHECK_ALLOC(delta);

	delta->nfiles = 2;

	if (!git_index_entry_is_conflict(old_entry)) {

		delta->old_file.size = old_entry->file_size;

		delta->old_file.mode = old_mode;

		git_oid_cpy(&delta->old_file.id, old_id);

		delta->old_file.id_abbrev = GIT_OID_HEXSZ;

		delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID |

			GIT_DIFF_FLAG_EXISTS;

	}

	if (!git_index_entry_is_conflict(new_entry)) {

		git_oid_cpy(&delta->new_file.id, new_id);

		delta->new_file.id_abbrev = GIT_OID_HEXSZ;

		delta->new_file.size = new_entry->file_size;

		delta->new_file.mode = new_mode;

		delta->old_file.flags |= GIT_DIFF_FLAG_EXISTS;

		delta->new_file.flags |= GIT_DIFF_FLAG_EXISTS;

		if (!git_oid_iszero(&new_entry->id))

			delta->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;

	}

	return diff_insert_delta(diff, delta, matched_pathspec);

}

static git_diff_delta *diff_delta__last_for_item(

	git_diff_generated *diff,

	const git_index_entry *item)

{

	git_diff_delta *delta = git_vector_last(&diff->base.deltas);

	if (!delta)

		return NULL;

	switch (delta->status) {

	case GIT_DELTA_UNMODIFIED:

	case GIT_DELTA_DELETED:

		if (git_oid__cmp(&delta->old_file.id, &item->id) == 0)

			return delta;

		break;

	case GIT_DELTA_ADDED:

		if (git_oid__cmp(&delta->new_file.id, &item->id) == 0)

			return delta;

		break;

	case GIT_DELTA_UNREADABLE:

	case GIT_DELTA_UNTRACKED:

		if (diff->base.strcomp(delta->new_file.path, item->path) == 0 &&

			git_oid__cmp(&delta->new_file.id, &item->id) == 0)

			return delta;

		break;

	case GIT_DELTA_MODIFIED:

		if (git_oid__cmp(&delta->old_file.id, &item->id) == 0 ||

			git_oid__cmp(&delta->new_file.id, &item->id) == 0)

			return delta;

		break;

	default:

		break;

	}

	return NULL;

}

static char *diff_strdup_prefix(git_pool *pool, const char *prefix)

{

	size_t len = strlen(prefix);

	/* append '/' at end if needed */

	if (len > 0 && prefix[len - 1] != '/')

		return git_pool_strcat(pool, prefix, "/");

	else

		return git_pool_strndup(pool, prefix, len + 1);

}

GIT_INLINE(const char *) diff_delta__i2w_path(const git_diff_delta *delta)

{

	return delta->old_file.path ?

		delta->old_file.path : delta->new_file.path;

}

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

{

	const git_diff_delta *da = a, *db = b;

	int val = strcmp(diff_delta__i2w_path(da), diff_delta__i2w_path(db));

	return val ? val : ((int)da->status - (int)db->status);

}

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

{

	const git_diff_delta *da = a, *db = b;

	int val = strcasecmp(diff_delta__i2w_path(da), diff_delta__i2w_path(db));

	return val ? val : ((int)da->status - (int)db->status);

}

bool git_diff_delta__should_skip(

	const git_diff_options *opts, const git_diff_delta *delta)

{

	uint32_t flags = opts ? opts->flags : 0;

	if (delta->status == GIT_DELTA_UNMODIFIED &&

		(flags & GIT_DIFF_INCLUDE_UNMODIFIED) == 0)

		return true;

	if (delta->status == GIT_DELTA_IGNORED &&

		(flags & GIT_DIFF_INCLUDE_IGNORED) == 0)

		return true;

	if (delta->status == GIT_DELTA_UNTRACKED &&

		(flags & GIT_DIFF_INCLUDE_UNTRACKED) == 0)

		return true;

	if (delta->status == GIT_DELTA_UNREADABLE &&

		(flags & GIT_DIFF_INCLUDE_UNREADABLE) == 0)

		return true;

	return false;

}

static const char *diff_mnemonic_prefix(

	git_iterator_type_t type, bool left_side)

{

	const char *pfx = "";

	switch (type) {

	case GIT_ITERATOR_TYPE_EMPTY:   pfx = "c"; break;

	case GIT_ITERATOR_TYPE_TREE:    pfx = "c"; break;

	case GIT_ITERATOR_TYPE_INDEX:   pfx = "i"; break;

	case GIT_ITERATOR_TYPE_WORKDIR: pfx = "w"; break;

	case GIT_ITERATOR_TYPE_FS:      pfx = left_side ? "1" : "2"; break;

	default: break;

	}

	/* note: without a deeper look at pathspecs, there is no easy way

	 * to get the (o)bject / (w)ork tree mnemonics working...

	 */

	return pfx;

}

void git_diff__set_ignore_case(git_diff *diff, bool ignore_case)

{

	if (!ignore_case) {

		diff->opts.flags &= ~GIT_DIFF_IGNORE_CASE;

		diff->strcomp    = git__strcmp;

		diff->strncomp   = git__strncmp;

		diff->pfxcomp    = git__prefixcmp;

		diff->entrycomp  = git_diff__entry_cmp;

		git_vector_set_cmp(&diff->deltas, git_diff_delta__cmp);

	} else {

		diff->opts.flags |= GIT_DIFF_IGNORE_CASE;

		diff->strcomp    = git__strcasecmp;

		diff->strncomp   = git__strncasecmp;

		diff->pfxcomp    = git__prefixcmp_icase;

		diff->entrycomp  = git_diff__entry_icmp;

		git_vector_set_cmp(&diff->deltas, git_diff_delta__casecmp);

	}

	git_vector_sort(&diff->deltas);

}

static void diff_generated_free(git_diff *d)

{

	git_diff_generated *diff = (git_diff_generated *)d;

	git_vector_free_deep(&diff->base.deltas);

	git_pathspec__vfree(&diff->pathspec);

	git_pool_clear(&diff->base.pool);

	git__memzero(diff, sizeof(*diff));

	git__free(diff);

}

static git_diff_generated *diff_generated_alloc(

	git_repository *repo,

	git_iterator *old_iter,

	git_iterator *new_iter)

{

	git_diff_generated *diff;

	git_diff_options dflt = GIT_DIFF_OPTIONS_INIT;

	assert(repo && old_iter && new_iter);

	if ((diff = git__calloc(1, sizeof(git_diff_generated))) == NULL)

		return NULL;

	GIT_REFCOUNT_INC(diff);

	diff->base.type = GIT_DIFF_TYPE_GENERATED;

	diff->base.repo = repo;

	diff->base.old_src = old_iter->type;

	diff->base.new_src = new_iter->type;

	diff->base.patch_fn = git_patch_generated_from_diff;

	diff->base.free_fn = diff_generated_free;

	memcpy(&diff->base.opts, &dflt, sizeof(git_diff_options));

	git_pool_init(&diff->base.pool, 1);

	if (git_vector_init(&diff->base.deltas, 0, git_diff_delta__cmp) < 0) {

		git_diff_free(&diff->base);

		return NULL;

	}

	/* Use case-insensitive compare if either iterator has

	 * the ignore_case bit set */

	git_diff__set_ignore_case(

		&diff->base,

		git_iterator_ignore_case(old_iter) ||

		git_iterator_ignore_case(new_iter));

	return diff;

}

static int diff_generated_apply_options(

	git_diff_generated *diff,

	const git_diff_options *opts)

{

	git_config *cfg = NULL;

	git_repository *repo = diff->base.repo;

	git_pool *pool = &diff->base.pool;

	int val;

	if (opts) {

		/* copy user options (except case sensitivity info from iterators) */

		bool icase = DIFF_FLAG_IS_SET(diff, GIT_DIFF_IGNORE_CASE);

		memcpy(&diff->base.opts, opts, sizeof(diff->base.opts));

		DIFF_FLAG_SET(diff, GIT_DIFF_IGNORE_CASE, icase);

		/* initialize pathspec from options */

		if (git_pathspec__vinit(&diff->pathspec, &opts->pathspec, pool) < 0)

			return -1;

	}

	/* flag INCLUDE_TYPECHANGE_TREES implies INCLUDE_TYPECHANGE */

	if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_INCLUDE_TYPECHANGE_TREES))

		diff->base.opts.flags |= GIT_DIFF_INCLUDE_TYPECHANGE;

	/* flag INCLUDE_UNTRACKED_CONTENT implies INCLUDE_UNTRACKED */

	if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_SHOW_UNTRACKED_CONTENT))

		diff->base.opts.flags |= GIT_DIFF_INCLUDE_UNTRACKED;

	/* load config values that affect diff behavior */

	if ((val = git_repository_config_snapshot(&cfg, repo)) < 0)

		return val;

	if (!git_config__cvar(&val, cfg, GIT_CVAR_SYMLINKS) && val)

		diff->diffcaps |= GIT_DIFFCAPS_HAS_SYMLINKS;

	if (!git_config__cvar(&val, cfg, GIT_CVAR_IGNORESTAT) && val)

		diff->diffcaps |= GIT_DIFFCAPS_IGNORE_STAT;

	if ((diff->base.opts.flags & GIT_DIFF_IGNORE_FILEMODE) == 0 &&

		!git_config__cvar(&val, cfg, GIT_CVAR_FILEMODE) && val)

		diff->diffcaps |= GIT_DIFFCAPS_TRUST_MODE_BITS;

	if (!git_config__cvar(&val, cfg, GIT_CVAR_TRUSTCTIME) && val)

		diff->diffcaps |= GIT_DIFFCAPS_TRUST_CTIME;

	/* Don't set GIT_DIFFCAPS_USE_DEV - compile time option in core git */

	/* If not given explicit `opts`, check `diff.xyz` configs */

	if (!opts) {

		int context = git_config__get_int_force(cfg, "diff.context", 3);

		diff->base.opts.context_lines = context >= 0 ? (uint32_t)context : 3;

		/* add other defaults here */

	}

	/* Reverse src info if diff is reversed */

	if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_REVERSE)) {

		git_iterator_type_t tmp_src = diff->base.old_src;

		diff->base.old_src = diff->base.new_src;

		diff->base.new_src = tmp_src;

	}

	/* Unset UPDATE_INDEX unless diffing workdir and index */

	if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_UPDATE_INDEX) &&

		(!(diff->base.old_src == GIT_ITERATOR_TYPE_WORKDIR ||

		   diff->base.new_src == GIT_ITERATOR_TYPE_WORKDIR) ||

		 !(diff->base.old_src == GIT_ITERATOR_TYPE_INDEX ||

		   diff->base.new_src == GIT_ITERATOR_TYPE_INDEX)))

		diff->base.opts.flags &= ~GIT_DIFF_UPDATE_INDEX;

	/* if ignore_submodules not explicitly set, check diff config */

	if (diff->base.opts.ignore_submodules <= 0) {

		 git_config_entry *entry;

		git_config__lookup_entry(&entry, cfg, "diff.ignoresubmodules", true);

		if (entry && git_submodule_parse_ignore(

				&diff->base.opts.ignore_submodules, entry->value) < 0)

			giterr_clear();

		git_config_entry_free(entry);

	}

	/* if either prefix is not set, figure out appropriate value */

	if (!diff->base.opts.old_prefix || !diff->base.opts.new_prefix) {

		const char *use_old = DIFF_OLD_PREFIX_DEFAULT;

		const char *use_new = DIFF_NEW_PREFIX_DEFAULT;

		if (git_config__get_bool_force(cfg, "diff.noprefix", 0))

			use_old = use_new = "";

		else if (git_config__get_bool_force(cfg, "diff.mnemonicprefix", 0)) {

			use_old = diff_mnemonic_prefix(diff->base.old_src, true);

			use_new = diff_mnemonic_prefix(diff->base.new_src, false);

		}

		if (!diff->base.opts.old_prefix)

			diff->base.opts.old_prefix = use_old;

		if (!diff->base.opts.new_prefix)

			diff->base.opts.new_prefix = use_new;

	}

	/* strdup prefix from pool so we're not dependent on external data */

	diff->base.opts.old_prefix = diff_strdup_prefix(pool, diff->base.opts.old_prefix);

	diff->base.opts.new_prefix = diff_strdup_prefix(pool, diff->base.opts.new_prefix);

	if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_REVERSE)) {

		const char *tmp_prefix = diff->base.opts.old_prefix;

		diff->base.opts.old_prefix  = diff->base.opts.new_prefix;

		diff->base.opts.new_prefix  = tmp_prefix;

	}

	git_config_free(cfg);

	/* check strdup results for error */

	return (!diff->base.opts.old_prefix || !diff->base.opts.new_prefix) ? -1 : 0;

}

int git_diff__oid_for_file(

	git_oid *out,

	git_diff *diff,

	const char *path,

	uint16_t mode,

	git_off_t size)

{

	git_index_entry entry;

	memset(&entry, 0, sizeof(entry));

	entry.mode = mode;

	entry.file_size = size;

	entry.path = (char *)path;

	return git_diff__oid_for_entry(out, diff, &entry, mode, NULL);

}

int git_diff__oid_for_entry(

	git_oid *out,

	git_diff *d,

	const git_index_entry *src,

	uint16_t mode,

	const git_oid *update_match)

{

	git_diff_generated *diff;

	git_buf full_path = GIT_BUF_INIT;

	git_index_entry entry = *src;

	git_filter_list *fl = NULL;

	int error = 0;

	assert(d->type == GIT_DIFF_TYPE_GENERATED);

	diff = (git_diff_generated *)d;

	memset(out, 0, sizeof(*out));

	if (git_buf_joinpath(&full_path,

		git_repository_workdir(diff->base.repo), entry.path) < 0)

		return -1;

	if (!mode) {

		struct stat st;

		diff->base.perf.stat_calls++;

		if (p_stat(full_path.ptr, &st) < 0) {

			error = git_path_set_error(errno, entry.path, "stat");

			git_buf_free(&full_path);

			return error;

		}

		git_index_entry__init_from_stat(&entry,

			&st, (diff->diffcaps & GIT_DIFFCAPS_TRUST_MODE_BITS) != 0);

	}

	/* calculate OID for file if possible */

	if (S_ISGITLINK(mode)) {

		git_submodule *sm;

		if (!git_submodule_lookup(&sm, diff->base.repo, entry.path)) {

			const git_oid *sm_oid = git_submodule_wd_id(sm);

			if (sm_oid)

				git_oid_cpy(out, sm_oid);

			git_submodule_free(sm);

		} else {

			/* if submodule lookup failed probably just in an intermediate

			 * state where some init hasn't happened, so ignore the error

			 */

			giterr_clear();

		}

	} else if (S_ISLNK(mode)) {

		error = git_odb__hashlink(out, full_path.ptr);

		diff->base.perf.oid_calculations++;

	} else if (!git__is_sizet(entry.file_size)) {

		giterr_set(GITERR_OS, "file size overflow (for 32-bits) on '%s'",

			entry.path);

		error = -1;

	} else if (!(error = git_filter_list_load(&fl,

		diff->base.repo, NULL, entry.path,

		GIT_FILTER_TO_ODB, GIT_FILTER_ALLOW_UNSAFE)))

	{

		int fd = git_futils_open_ro(full_path.ptr);

		if (fd < 0)

			error = fd;

		else {

			error = git_odb__hashfd_filtered(

				out, fd, (size_t)entry.file_size, GIT_OBJ_BLOB, fl);

			p_close(fd);

			diff->base.perf.oid_calculations++;

		}

		git_filter_list_free(fl);

	}

	/* update index for entry if requested */

	if (!error && update_match && git_oid_equal(out, update_match)) {

		git_index *idx;

		git_index_entry updated_entry;

		memcpy(&updated_entry, &entry, sizeof(git_index_entry));

		updated_entry.mode = mode;

		git_oid_cpy(&updated_entry.id, out);

		if (!(error = git_repository_index__weakptr(&idx,

			diff->base.repo))) {

			error = git_index_add(idx, &updated_entry);

			diff->index_updated = true;

		}

 	}

	git_buf_free(&full_path);

	return error;

}

typedef struct {

	git_repository *repo;

	git_iterator *old_iter;

	git_iterator *new_iter;

	const git_index_entry *oitem;

	const git_index_entry *nitem;

} diff_in_progress;

#define MODE_BITS_MASK 0000777

static int maybe_modified_submodule(

	git_delta_t *status,

	git_oid *found_oid,

	git_diff_generated *diff,

	diff_in_progress *info)

{

	int error = 0;

	git_submodule *sub;

	unsigned int sm_status = 0;

	git_submodule_ignore_t ign = diff->base.opts.ignore_submodules;

	*status = GIT_DELTA_UNMODIFIED;

	if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_IGNORE_SUBMODULES) ||

		ign == GIT_SUBMODULE_IGNORE_ALL)

		return 0;

	if ((error = git_submodule_lookup(

			&sub, diff->base.repo, info->nitem->path)) < 0) {

		/* GIT_EEXISTS means dir with .git in it was found - ignore it */

		if (error == GIT_EEXISTS) {

			giterr_clear();

			error = 0;

		}

		return error;

	}

	if (ign <= 0 && git_submodule_ignore(sub) == GIT_SUBMODULE_IGNORE_ALL)

		/* ignore it */;

	else if ((error = git_submodule__status(

			&sm_status, NULL, NULL, found_oid, sub, ign)) < 0)

		/* return error below */;

	/* check IS_WD_UNMODIFIED because this case is only used

	 * when the new side of the diff is the working directory

	 */

	else if (!GIT_SUBMODULE_STATUS_IS_WD_UNMODIFIED(sm_status))

		*status = GIT_DELTA_MODIFIED;

	/* now that we have a HEAD OID, check if HEAD moved */

	else if ((sm_status & GIT_SUBMODULE_STATUS_IN_WD) != 0 &&

		!git_oid_equal(&info->oitem->id, found_oid))

		*status = GIT_DELTA_MODIFIED;

	git_submodule_free(sub);

	return error;

}

static int maybe_modified(

	git_diff_generated *diff,

	diff_in_progress *info)

{

	git_oid noid;

	git_delta_t status = GIT_DELTA_MODIFIED;

	const git_index_entry *oitem = info->oitem;

	const git_index_entry *nitem = info->nitem;

	unsigned int omode = oitem->mode;

	unsigned int nmode = nitem->mode;

	bool new_is_workdir = (info->new_iter->type == GIT_ITERATOR_TYPE_WORKDIR);

	bool modified_uncertain = false;

	const char *matched_pathspec;

	int error = 0;

	if (!diff_pathspec_match(&matched_pathspec, diff, oitem))

		return 0;

	memset(&noid, 0, sizeof(noid));

	/* on platforms with no symlinks, preserve mode of existing symlinks */

	if (S_ISLNK(omode) && S_ISREG(nmode) && new_is_workdir &&

		!(diff->diffcaps & GIT_DIFFCAPS_HAS_SYMLINKS))

		nmode = omode;

	/* on platforms with no execmode, just preserve old mode */

	if (!(diff->diffcaps & GIT_DIFFCAPS_TRUST_MODE_BITS) &&

		(nmode & MODE_BITS_MASK) != (omode & MODE_BITS_MASK) &&

		new_is_workdir)

		nmode = (nmode & ~MODE_BITS_MASK) | (omode & MODE_BITS_MASK);

	/* if one side is a conflict, mark the whole delta as conflicted */

	if (git_index_entry_is_conflict(oitem) ||

			git_index_entry_is_conflict(nitem)) {

		status = GIT_DELTA_CONFLICTED;

	/* support "assume unchanged" (poorly, b/c we still stat everything) */

	} else if ((oitem->flags & GIT_IDXENTRY_VALID) != 0) {

		status = GIT_DELTA_UNMODIFIED;

	/* support "skip worktree" index bit */

	} else if ((oitem->flags_extended & GIT_IDXENTRY_SKIP_WORKTREE) != 0) {

		status = GIT_DELTA_UNMODIFIED;

	/* if basic type of file changed, then split into delete and add */

	} else if (GIT_MODE_TYPE(omode) != GIT_MODE_TYPE(nmode)) {

		if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_INCLUDE_TYPECHANGE)) {

			status = GIT_DELTA_TYPECHANGE;

		}

		else if (nmode == GIT_FILEMODE_UNREADABLE) {

			if (!(error = diff_delta__from_one(diff, GIT_DELTA_DELETED, oitem, NULL)))

				error = diff_delta__from_one(diff, GIT_DELTA_UNREADABLE, NULL, nitem);

			return error;

		}

		else {

			if (!(error = diff_delta__from_one(diff, GIT_DELTA_DELETED, oitem, NULL)))

				error = diff_delta__from_one(diff, GIT_DELTA_ADDED, NULL, nitem);

			return error;

		}

	/* if oids and modes match (and are valid), then file is unmodified */

	} else if (git_oid_equal(&oitem->id, &nitem->id) &&

			 omode == nmode &&

			 !git_oid_iszero(&oitem->id)) {

		status = GIT_DELTA_UNMODIFIED;

	/* if we have an unknown OID and a workdir iterator, then check some

	 * circumstances that can accelerate things or need special handling

	 */

	} else if (git_oid_iszero(&nitem->id) && new_is_workdir) {

		bool use_ctime =

			((diff->diffcaps & GIT_DIFFCAPS_TRUST_CTIME) != 0);

		git_index *index = git_iterator_index(info->new_iter);

		status = GIT_DELTA_UNMODIFIED;

		if (S_ISGITLINK(nmode)) {

			if ((error = maybe_modified_submodule(&status, &noid, diff, info)) < 0)

				return error;

		}

		/* if the stat data looks different, then mark modified - this just

		 * means that the OID will be recalculated below to confirm change

		 */

		else if (omode != nmode || oitem->file_size != nitem->file_size) {

			status = GIT_DELTA_MODIFIED;

			modified_uncertain =

				(oitem->file_size <= 0 && nitem->file_size > 0);

		}

		else if (!git_index_time_eq(&oitem->mtime, &nitem->mtime) ||

			(use_ctime && !git_index_time_eq(&oitem->ctime, &nitem->ctime)) ||

			oitem->ino != nitem->ino ||

			oitem->uid != nitem->uid ||

			oitem->gid != nitem->gid ||

			git_index_entry_newer_than_index(nitem, index))

		{

			status = GIT_DELTA_MODIFIED;

			modified_uncertain = true;

		}

	/* if mode is GITLINK and submodules are ignored, then skip */

	} else if (S_ISGITLINK(nmode) &&

			 DIFF_FLAG_IS_SET(diff, GIT_DIFF_IGNORE_SUBMODULES)) {

		status = GIT_DELTA_UNMODIFIED;

	}

	/* if we got here and decided that the files are modified, but we

	 * haven't calculated the OID of the new item, then calculate it now

	 */

	if (modified_uncertain && git_oid_iszero(&nitem->id)) {

		const git_oid *update_check =

			DIFF_FLAG_IS_SET(diff, GIT_DIFF_UPDATE_INDEX) && omode == nmode ?

			&oitem->id : NULL;

		if ((error = git_diff__oid_for_entry(

				&noid, &diff->base, nitem, nmode, update_check)) < 0)

			return error;

		/* if oid matches, then mark unmodified (except submodules, where

		 * the filesystem content may be modified even if the oid still

		 * matches between the index and the workdir HEAD)

		 */

		if (omode == nmode && !S_ISGITLINK(omode) &&

			git_oid_equal(&oitem->id, &noid))

			status = GIT_DELTA_UNMODIFIED;

	}

	/* If we want case changes, then break this into a delete of the old

	 * and an add of the new so that consumers can act accordingly (eg,

	 * checkout will update the case on disk.)

	 */

	if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_IGNORE_CASE) &&

		DIFF_FLAG_IS_SET(diff, GIT_DIFF_INCLUDE_CASECHANGE) &&

		strcmp(oitem->path, nitem->path) != 0) {

		if (!(error = diff_delta__from_one(diff, GIT_DELTA_DELETED, oitem, NULL)))

			error = diff_delta__from_one(diff, GIT_DELTA_ADDED, NULL, nitem);

		return error;

	}

	return diff_delta__from_two(

		diff, status, oitem, omode, nitem, nmode,

		git_oid_iszero(&noid) ? NULL : &noid, matched_pathspec);

}

static bool entry_is_prefixed(

	git_diff_generated *diff,

	const git_index_entry *item,

	const git_index_entry *prefix_item)

{

	size_t pathlen;