text: /*
   * 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 "git2/blob.h"
  #include "diff.h"
  #include "diff_file.h"
  #include "diff_driver.h"
  #include "diff_patch.h"
  #include "diff_xdiff.h"
  #include "delta.h"
  #include "zstream.h"
  #include "fileops.h"
  
  static void diff_output_init(
  	git_diff_output*, const git_diff_options*, git_diff_file_cb,
  	git_diff_binary_cb, git_diff_hunk_cb, git_diff_line_cb, void*);
  
  static void diff_output_to_patch(git_diff_output *, git_patch *);
  
  static void diff_patch_update_binary(git_patch *patch)
  {
  	if ((patch->delta->flags & DIFF_FLAGS_KNOWN_BINARY) != 0)
  		return;
  
  	if ((patch->ofile.file->flags & GIT_DIFF_FLAG_BINARY) != 0 ||
  		(patch->nfile.file->flags & GIT_DIFF_FLAG_BINARY) != 0)
  		patch->delta->flags |= GIT_DIFF_FLAG_BINARY;
  
  	else if ((patch->ofile.file->flags & DIFF_FLAGS_NOT_BINARY) != 0 &&
  			 (patch->nfile.file->flags & DIFF_FLAGS_NOT_BINARY) != 0)
  		patch->delta->flags |= GIT_DIFF_FLAG_NOT_BINARY;
  }
  
  static void diff_patch_init_common(git_patch *patch)
  {
  	diff_patch_update_binary(patch);
  
  	patch->flags |= GIT_DIFF_PATCH_INITIALIZED;
  
  	if (patch->diff)
  		git_diff_addref(patch->diff);
  }
  
  static int diff_patch_normalize_options(
  	git_diff_options *out,
  	const git_diff_options *opts)
  {
  	if (opts) {
  		GITERR_CHECK_VERSION(opts, GIT_DIFF_OPTIONS_VERSION, "git_diff_options");
  		memcpy(out, opts, sizeof(git_diff_options));
  	} else {
  		git_diff_options default_opts = GIT_DIFF_OPTIONS_INIT;
  		memcpy(out, &default_opts, sizeof(git_diff_options));
  	}
  
  	out->old_prefix = opts && opts->old_prefix ?
  		git__strdup(opts->old_prefix) :
  		git__strdup(DIFF_OLD_PREFIX_DEFAULT);
  
  	out->new_prefix = opts && opts->new_prefix ?
  		git__strdup(opts->new_prefix) :
  		git__strdup(DIFF_NEW_PREFIX_DEFAULT);
  
  	GITERR_CHECK_ALLOC(out->old_prefix);
  	GITERR_CHECK_ALLOC(out->new_prefix);
  
  	return 0;
  }
  
  static int diff_patch_init_from_diff(
  	git_patch *patch, git_diff *diff, size_t delta_index)
  {
  	int error = 0;
  
  	memset(patch, 0, sizeof(*patch));
  	patch->diff  = diff;
  	patch->delta = git_vector_get(&diff->deltas, delta_index);
  	patch->delta_index = delta_index;
  
  	if ((error = diff_patch_normalize_options(
  			&patch->diff_opts, &diff->opts)) < 0 ||
  		(error = git_diff_file_content__init_from_diff(
  			&patch->ofile, diff, patch->delta, true)) < 0 ||
  		(error = git_diff_file_content__init_from_diff(
  			&patch->nfile, diff, patch->delta, false)) < 0)
  		return error;
  
  	diff_patch_init_common(patch);
  
  	return 0;
  }
  
  static int diff_patch_alloc_from_diff(
  	git_patch **out, git_diff *diff, size_t delta_index)
  {
  	int error;
  	git_patch *patch = git__calloc(1, sizeof(git_patch));
  	GITERR_CHECK_ALLOC(patch);
  
  	if (!(error = diff_patch_init_from_diff(patch, diff, delta_index))) {
  		patch->flags |= GIT_DIFF_PATCH_ALLOCATED;
  		GIT_REFCOUNT_INC(patch);
  	} else {
  		git__free(patch);
  		patch = NULL;
  	}
  
  	*out = patch;
  	return error;
  }
  
  GIT_INLINE(bool) should_skip_binary(git_patch *patch, git_diff_file *file)
  {
  	if ((patch->diff_opts.flags & GIT_DIFF_SHOW_BINARY) != 0)
  		return false;
  
  	return (file->flags & GIT_DIFF_FLAG_BINARY) != 0;
  }
  
  static bool diff_patch_diffable(git_patch *patch)
  {
  	size_t olen, nlen;
  
  	if (patch->delta->status == GIT_DELTA_UNMODIFIED)
  		return false;
  
  	/* if we've determined this to be binary (and we are not showing binary
  	 * data) then we have skipped loading the map data.  instead, query the
  	 * file data itself.
  	 */
  	if ((patch->delta->flags & GIT_DIFF_FLAG_BINARY) != 0 &&
  		(patch->diff_opts.flags & GIT_DIFF_SHOW_BINARY) == 0) {
  		olen = (size_t)patch->ofile.file->size;
  		nlen = (size_t)patch->nfile.file->size;
  	} else {
  		olen = patch->ofile.map.len;
  		nlen = patch->nfile.map.len;
  	}
  
  	/* if both sides are empty, files are identical */
  	if (!olen && !nlen)
  		return false;
  
  	/* otherwise, check the file sizes and the oid */
  	return (olen != nlen ||
  		!git_oid_equal(&patch->ofile.file->id, &patch->nfile.file->id));
  }
  
  static int diff_patch_load(git_patch *patch, git_diff_output *output)
  {
  	int error = 0;
  	bool incomplete_data;
  
  	if ((patch->flags & GIT_DIFF_PATCH_LOADED) != 0)
  		return 0;
  
  	/* if no hunk and data callbacks and user doesn't care if data looks
  	 * binary, then there is no need to actually load the data
  	 */
  	if ((patch->ofile.opts_flags & GIT_DIFF_SKIP_BINARY_CHECK) != 0 &&
  		output && !output->binary_cb && !output->hunk_cb && !output->data_cb)
  		return 0;
  
  	incomplete_data =
  		(((patch->ofile.flags & GIT_DIFF_FLAG__NO_DATA) != 0 ||
  		  (patch->ofile.file->flags & GIT_DIFF_FLAG_VALID_ID) != 0) &&
  		 ((patch->nfile.flags & GIT_DIFF_FLAG__NO_DATA) != 0 ||
  		  (patch->nfile.file->flags & GIT_DIFF_FLAG_VALID_ID) != 0));
  
  	/* always try to load workdir content first because filtering may
  	 * need 2x data size and this minimizes peak memory footprint
  	 */
  	if (patch->ofile.src == GIT_ITERATOR_TYPE_WORKDIR) {
  		if ((error = git_diff_file_content__load(
  				&patch->ofile, &patch->diff_opts)) < 0 ||
  			should_skip_binary(patch, patch->ofile.file))
  			goto cleanup;
  	}
  	if (patch->nfile.src == GIT_ITERATOR_TYPE_WORKDIR) {
  		if ((error = git_diff_file_content__load(
  				&patch->nfile, &patch->diff_opts)) < 0 ||
  			should_skip_binary(patch, patch->nfile.file))
  			goto cleanup;
  	}
  
  	/* once workdir has been tried, load other data as needed */
  	if (patch->ofile.src != GIT_ITERATOR_TYPE_WORKDIR) {
  		if ((error = git_diff_file_content__load(
  				&patch->ofile, &patch->diff_opts)) < 0 ||
  			should_skip_binary(patch, patch->ofile.file))
  			goto cleanup;
  	}
  	if (patch->nfile.src != GIT_ITERATOR_TYPE_WORKDIR) {
  		if ((error = git_diff_file_content__load(
  				&patch->nfile, &patch->diff_opts)) < 0 ||
  			should_skip_binary(patch, patch->nfile.file))
  			goto cleanup;
  	}
  
  	/* if previously missing an oid, and now that we have it the two sides
  	 * are the same (and not submodules), update MODIFIED -> UNMODIFIED
  	 */
  	if (incomplete_data &&
  		patch->ofile.file->mode == patch->nfile.file->mode &&
  		patch->ofile.file->mode != GIT_FILEMODE_COMMIT &&
  		git_oid_equal(&patch->ofile.file->id, &patch->nfile.file->id) &&
  		patch->delta->status == GIT_DELTA_MODIFIED) /* not RENAMED/COPIED! */
  		patch->delta->status = GIT_DELTA_UNMODIFIED;
  
  cleanup:
  	diff_patch_update_binary(patch);
  
  	if (!error) {
  		if (diff_patch_diffable(patch))
  			patch->flags |= GIT_DIFF_PATCH_DIFFABLE;
  
  		patch->flags |= GIT_DIFF_PATCH_LOADED;
  	}
  
  	return error;
  }
  
  static int diff_patch_invoke_file_callback(
  	git_patch *patch, git_diff_output *output)
  {
  	float progress = patch->diff ?
  		((float)patch->delta_index / patch->diff->deltas.length) : 1.0f;
  
  	if (!output->file_cb)
  		return 0;
  
  	return giterr_set_after_callback_function(
  		output->file_cb(patch->delta, progress, output->payload),
  		"git_patch");
  }
  
  static int create_binary(
  	git_diff_binary_t *out_type,
  	char **out_data,
  	size_t *out_datalen,
  	size_t *out_inflatedlen,
  	const char *a_data,
  	size_t a_datalen,
  	const char *b_data,
  	size_t b_datalen)
  {
  	git_buf deflate = GIT_BUF_INIT, delta = GIT_BUF_INIT;
  	unsigned long delta_data_len;
  	int error;
  
  	/* The git_delta function accepts unsigned long only */
  	if (!git__is_ulong(a_datalen) || !git__is_ulong(b_datalen))
  		return GIT_EBUFS;
  
  	if ((error = git_zstream_deflatebuf(&deflate, b_data, b_datalen)) < 0)
  		goto done;
  
  	/* The git_delta function accepts unsigned long only */
  	if (!git__is_ulong(deflate.size)) {
  		error = GIT_EBUFS;
  		goto done;
  	}
  
  	if (a_datalen && b_datalen) {
  		void *delta_data = git_delta(
  			a_data, (unsigned long)a_datalen,
  			b_data, (unsigned long)b_datalen,
  			&delta_data_len, (unsigned long)deflate.size);
  
  		if (delta_data) {
  			error = git_zstream_deflatebuf(
  				&delta, delta_data, (size_t)delta_data_len);
  
  			git__free(delta_data);
  
  			if (error < 0)
  				goto done;
  		}
  	}
  
  	if (delta.size && delta.size < deflate.size) {
  		*out_type = GIT_DIFF_BINARY_DELTA;
  		*out_datalen = delta.size;
  		*out_data = git_buf_detach(&delta);
  		*out_inflatedlen = delta_data_len;
  	} else {
  		*out_type = GIT_DIFF_BINARY_LITERAL;
  		*out_datalen = deflate.size;
  		*out_data = git_buf_detach(&deflate);
  		*out_inflatedlen = b_datalen;
  	}
  
  done:
  	git_buf_free(&deflate);
  	git_buf_free(&delta);
  
  	return error;
  }
  
  static int diff_binary(git_diff_output *output, git_patch *patch)
  {
  	git_diff_binary binary = {{0}};
  	const char *old_data = patch->ofile.map.data;
  	const char *new_data = patch->nfile.map.data;
  	size_t old_len = patch->ofile.map.len,
  		new_len = patch->nfile.map.len;
  	int error;
  
  	/* Create the old->new delta (as the "new" side of the patch),
  	 * and the new->old delta (as the "old" side)
  	 */
  	if ((error = create_binary(&binary.old_file.type,
  			(char **)&binary.old_file.data,
  			&binary.old_file.datalen,
  			&binary.old_file.inflatedlen,
  			new_data, new_len, old_data, old_len)) < 0 ||
  		(error = create_binary(&binary.new_file.type,
  			(char **)&binary.new_file.data,
  			&binary.new_file.datalen,
  			&binary.new_file.inflatedlen,
  			old_data, old_len, new_data, new_len)) < 0)
  		return error;
  
  	error = giterr_set_after_callback_function(
  		output->binary_cb(patch->delta, &binary, output->payload),
  		"git_patch");
  
  	git__free((char *) binary.old_file.data);
  	git__free((char *) binary.new_file.data);
  
  	return error;
  }
  
  static int diff_patch_generate(git_patch *patch, git_diff_output *output)
  {
  	int error = 0;
  
  	if ((patch->flags & GIT_DIFF_PATCH_DIFFED) != 0)
  		return 0;
  
  	/* if we are not looking at the binary or text data, don't do the diff */
  	if (!output->binary_cb && !output->hunk_cb && !output->data_cb)
  		return 0;
  
  	if ((patch->flags & GIT_DIFF_PATCH_LOADED) == 0 &&
  		(error = diff_patch_load(patch, output)) < 0)
  		return error;
  
  	if ((patch->flags & GIT_DIFF_PATCH_DIFFABLE) == 0)
  		return 0;
  
  	if ((patch->delta->flags & GIT_DIFF_FLAG_BINARY) != 0) {
  		if (output->binary_cb)
  			error = diff_binary(output, patch);
  	}
  	else {
  		if (output->diff_cb)
  			error = output->diff_cb(output, patch);
  	}
  
  	patch->flags |= GIT_DIFF_PATCH_DIFFED;
  	return error;
  }
  
  static void diff_patch_free(git_patch *patch)
  {
  	git_diff_file_content__clear(&patch->ofile);
  	git_diff_file_content__clear(&patch->nfile);
  
  	git_array_clear(patch->lines);
  	git_array_clear(patch->hunks);
  
  	git_diff_free(patch->diff); /* decrements refcount */
  	patch->diff = NULL;
  
  	git_pool_clear(&patch->flattened);
  
  	git__free((char *)patch->diff_opts.old_prefix);
  	git__free((char *)patch->diff_opts.new_prefix);
  
  	git__free((char *)patch->binary.old_file.data);
  	git__free((char *)patch->binary.new_file.data);
  
  	if (patch->flags & GIT_DIFF_PATCH_ALLOCATED)
  		git__free(patch);
  }
  
  static int diff_required(git_diff *diff, const char *action)
  {
  	if (diff)
  		return 0;
  	giterr_set(GITERR_INVALID, "Must provide valid diff to %s", action);
  	return -1;
  }
  
  int git_diff_foreach(
  	git_diff *diff,
  	git_diff_file_cb file_cb,
  	git_diff_binary_cb binary_cb,
  	git_diff_hunk_cb hunk_cb,
  	git_diff_line_cb data_cb,
  	void *payload)
  {
  	int error = 0;
  	git_xdiff_output xo;
  	size_t idx;
  	git_patch patch;
  
  	if ((error = diff_required(diff, "git_diff_foreach")) < 0)
  		return error;
  
  	memset(&xo, 0, sizeof(xo));
  	memset(&patch, 0, sizeof(patch));
  	diff_output_init(
  		&xo.output, &diff->opts, file_cb, binary_cb, hunk_cb, data_cb, payload);
  	git_xdiff_init(&xo, &diff->opts);
  
  	git_vector_foreach(&diff->deltas, idx, patch.delta) {
  
  		/* check flags against patch status */
  		if (git_diff_delta__should_skip(&diff->opts, patch.delta))
  			continue;
  
  		if (binary_cb || hunk_cb || data_cb) {
  			if ((error = diff_patch_init_from_diff(&patch, diff, idx)) != 0 ||
  				(error = diff_patch_load(&patch, &xo.output)) != 0)
  				return error;
  		}
  
  		if ((error = diff_patch_invoke_file_callback(&patch, &xo.output)) == 0) {
  			if (binary_cb || hunk_cb || data_cb)
  					error = diff_patch_generate(&patch, &xo.output);
  		}
  
  		git_patch_free(&patch);
  
  		if (error)
  			break;
  	}
  
  	return error;
  }
  
  typedef struct {
  	git_patch patch;
  	git_diff_delta delta;
  	char paths[GIT_FLEX_ARRAY];
  } diff_patch_with_delta;
  
  static int diff_single_generate(diff_patch_with_delta *pd, git_xdiff_output *xo)
  {
  	int error = 0;
  	git_patch *patch = &pd->patch;
  	bool has_old = ((patch->ofile.flags & GIT_DIFF_FLAG__NO_DATA) == 0);
  	bool has_new = ((patch->nfile.flags & GIT_DIFF_FLAG__NO_DATA) == 0);
  
  	pd->delta.status = has_new ?
  		(has_old ? GIT_DELTA_MODIFIED : GIT_DELTA_ADDED) :
  		(has_old ? GIT_DELTA_DELETED : GIT_DELTA_UNTRACKED);
  
  	if (git_oid_equal(&patch->nfile.file->id, &patch->ofile.file->id))
  		pd->delta.status = GIT_DELTA_UNMODIFIED;
  
  	patch->delta = &pd->delta;
  
  	diff_patch_init_common(patch);
  
  	if (pd->delta.status == GIT_DELTA_UNMODIFIED &&
  		!(patch->ofile.opts_flags & GIT_DIFF_INCLUDE_UNMODIFIED))
  		return error;
  
  	error = diff_patch_invoke_file_callback(patch, (git_diff_output *)xo);
  
  	if (!error)
  		error = diff_patch_generate(patch, (git_diff_output *)xo);
  
  	return error;
  }
  
  static int diff_patch_from_sources(
  	diff_patch_with_delta *pd,
  	git_xdiff_output *xo,
  	git_diff_file_content_src *oldsrc,
  	git_diff_file_content_src *newsrc,
  	const git_diff_options *opts)
  {
  	int error = 0;
  	git_repository *repo =
  		oldsrc->blob ? git_blob_owner(oldsrc->blob) :
  		newsrc->blob ? git_blob_owner(newsrc->blob) : NULL;
  	git_diff_file *lfile = &pd->delta.old_file, *rfile = &pd->delta.new_file;
  	git_diff_file_content *ldata = &pd->patch.ofile, *rdata = &pd->patch.nfile;
  
  	if ((error = diff_patch_normalize_options(&pd->patch.diff_opts, opts)) < 0)
  		return error;
  
  	if (opts && (opts->flags & GIT_DIFF_REVERSE) != 0) {
  		void *tmp = lfile; lfile = rfile; rfile = tmp;
  		tmp = ldata; ldata = rdata; rdata = tmp;
  	}
  
  	pd->patch.delta = &pd->delta;
  
  	if (!oldsrc->as_path) {
  		if (newsrc->as_path)
  			oldsrc->as_path = newsrc->as_path;
  		else
  			oldsrc->as_path = newsrc->as_path = "file";
  	}
  	else if (!newsrc->as_path)
  		newsrc->as_path = oldsrc->as_path;
  
  	lfile->path = oldsrc->as_path;
  	rfile->path = newsrc->as_path;
  
  	if ((error = git_diff_file_content__init_from_src(
  			ldata, repo, opts, oldsrc, lfile)) < 0 ||
  		(error = git_diff_file_content__init_from_src(
  			rdata, repo, opts, newsrc, rfile)) < 0)
  		return error;
  
  	return diff_single_generate(pd, xo);
  }
  
  static int diff_patch_with_delta_alloc(
  	diff_patch_with_delta **out,
  	const char **old_path,
  	const char **new_path)
  {
  	diff_patch_with_delta *pd;
  	size_t old_len = *old_path ? strlen(*old_path) : 0;
  	size_t new_len = *new_path ? strlen(*new_path) : 0;
  	size_t alloc_len;
  
  	GITERR_CHECK_ALLOC_ADD(&alloc_len, sizeof(*pd), old_len);
  	GITERR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, new_len);
  	GITERR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, 2);
  
  	*out = pd = git__calloc(1, alloc_len);
  	GITERR_CHECK_ALLOC(pd);
  
  	pd->patch.flags = GIT_DIFF_PATCH_ALLOCATED;
  
  	if (*old_path) {
  		memcpy(&pd->paths[0], *old_path, old_len);
  		*old_path = &pd->paths[0];
  	} else if (*new_path)
  		*old_path = &pd->paths[old_len + 1];
  
  	if (*new_path) {
  		memcpy(&pd->paths[old_len + 1], *new_path, new_len);
  		*new_path = &pd->paths[old_len + 1];
  	} else if (*old_path)
  		*new_path = &pd->paths[0];
  
  	return 0;
  }
  
  static int diff_from_sources(
  	git_diff_file_content_src *oldsrc,
  	git_diff_file_content_src *newsrc,
  	const git_diff_options *opts,
  	git_diff_file_cb file_cb,
  	git_diff_binary_cb binary_cb,
  	git_diff_hunk_cb hunk_cb,
  	git_diff_line_cb data_cb,
  	void *payload)
  {
  	int error = 0;
  	diff_patch_with_delta pd;
  	git_xdiff_output xo;
  
  	memset(&xo, 0, sizeof(xo));
  	diff_output_init(
  		&xo.output, opts, file_cb, binary_cb, hunk_cb, data_cb, payload);
  	git_xdiff_init(&xo, opts);
  
  	memset(&pd, 0, sizeof(pd));
  
  	error = diff_patch_from_sources(&pd, &xo, oldsrc, newsrc, opts);
  
  	git_patch_free(&pd.patch);
  
  	return error;
  }
  
  static int patch_from_sources(
  	git_patch **out,
  	git_diff_file_content_src *oldsrc,
  	git_diff_file_content_src *newsrc,
  	const git_diff_options *opts)
  {
  	int error = 0;
  	diff_patch_with_delta *pd;
  	git_xdiff_output xo;
  
  	assert(out);
  	*out = NULL;
  
  	if ((error = diff_patch_with_delta_alloc(
  			&pd, &oldsrc->as_path, &newsrc->as_path)) < 0)
  		return error;
  
  	memset(&xo, 0, sizeof(xo));
  	diff_output_to_patch(&xo.output, &pd->patch);
  	git_xdiff_init(&xo, opts);
  
  	if (!(error = diff_patch_from_sources(pd, &xo, oldsrc, newsrc, opts)))
  		*out = (git_patch *)pd;
  	else
  		git_patch_free((git_patch *)pd);
  
  	return error;
  }
  
  int git_diff_blobs(
  	const git_blob *old_blob,
  	const char *old_path,
  	const git_blob *new_blob,
  	const char *new_path,
  	const git_diff_options *opts,
  	git_diff_file_cb file_cb,
  	git_diff_binary_cb binary_cb,
  	git_diff_hunk_cb hunk_cb,
  	git_diff_line_cb data_cb,
  	void *payload)
  {
  	git_diff_file_content_src osrc =
  		GIT_DIFF_FILE_CONTENT_SRC__BLOB(old_blob, old_path);
  	git_diff_file_content_src nsrc =
  		GIT_DIFF_FILE_CONTENT_SRC__BLOB(new_blob, new_path);
  	return diff_from_sources(
  		&osrc, &nsrc, opts, file_cb, binary_cb, hunk_cb, data_cb, payload);
  }
  
  int git_patch_from_blobs(
  	git_patch **out,
  	const git_blob *old_blob,
  	const char *old_path,
  	const git_blob *new_blob,
  	const char *new_path,
  	const git_diff_options *opts)
  {
  	git_diff_file_content_src osrc =
  		GIT_DIFF_FILE_CONTENT_SRC__BLOB(old_blob, old_path);
  	git_diff_file_content_src nsrc =
  		GIT_DIFF_FILE_CONTENT_SRC__BLOB(new_blob, new_path);
  	return patch_from_sources(out, &osrc, &nsrc, opts);
  }
  
  int git_diff_blob_to_buffer(
  	const git_blob *old_blob,
  	const char *old_path,
  	const char *buf,
  	size_t buflen,
  	const char *buf_path,
  	const git_diff_options *opts,
  	git_diff_file_cb file_cb,
  	git_diff_binary_cb binary_cb,
  	git_diff_hunk_cb hunk_cb,
  	git_diff_line_cb data_cb,
  	void *payload)
  {
  	git_diff_file_content_src osrc =
  		GIT_DIFF_FILE_CONTENT_SRC__BLOB(old_blob, old_path);
  	git_diff_file_content_src nsrc =
  		GIT_DIFF_FILE_CONTENT_SRC__BUF(buf, buflen, buf_path);
  	return diff_from_sources(
  		&osrc, &nsrc, opts, file_cb, binary_cb, hunk_cb, data_cb, payload);
  }
  
  int git_patch_from_blob_and_buffer(
  	git_patch **out,
  	const git_blob *old_blob,
  	const char *old_path,
  	const char *buf,
  	size_t buflen,
  	const char *buf_path,
  	const git_diff_options *opts)
  {
  	git_diff_file_content_src osrc =
  		GIT_DIFF_FILE_CONTENT_SRC__BLOB(old_blob, old_path);
  	git_diff_file_content_src nsrc =
  		GIT_DIFF_FILE_CONTENT_SRC__BUF(buf, buflen, buf_path);
  	return patch_from_sources(out, &osrc, &nsrc, opts);
  }
  
  int git_diff_buffers(
  	const void *old_buf,
  	size_t old_len,
  	const char *old_path,
  	const void *new_buf,
  	size_t new_len,
  	const char *new_path,
  	const git_diff_options *opts,
  	git_diff_file_cb file_cb,
  	git_diff_binary_cb binary_cb,
  	git_diff_hunk_cb hunk_cb,
  	git_diff_line_cb data_cb,
  	void *payload)
  {
  	git_diff_file_content_src osrc =
  		GIT_DIFF_FILE_CONTENT_SRC__BUF(old_buf, old_len, old_path);
  	git_diff_file_content_src nsrc =
  		GIT_DIFF_FILE_CONTENT_SRC__BUF(new_buf, new_len, new_path);
  	return diff_from_sources(
  		&osrc, &nsrc, opts, file_cb, binary_cb, hunk_cb, data_cb, payload);
  }
  
  int git_patch_from_buffers(
  	git_patch **out,
  	const void *old_buf,
  	size_t old_len,
  	const char *old_path,
  	const char *new_buf,
  	size_t new_len,
  	const char *new_path,
  	const git_diff_options *opts)
  {
  	git_diff_file_content_src osrc =
  		GIT_DIFF_FILE_CONTENT_SRC__BUF(old_buf, old_len, old_path);
  	git_diff_file_content_src nsrc =
  		GIT_DIFF_FILE_CONTENT_SRC__BUF(new_buf, new_len, new_path);
  	return patch_from_sources(out, &osrc, &nsrc, opts);
  }
  
  int git_patch_from_diff(
  	git_patch **patch_ptr, git_diff *diff, size_t idx)
  {
  	int error = 0;
  	git_xdiff_output xo;
  	git_diff_delta *delta = NULL;
  	git_patch *patch = NULL;
  
  	if (patch_ptr) *patch_ptr = NULL;
  
  	if (diff_required(diff, "git_patch_from_diff") < 0)
  		return -1;
  
  	delta = git_vector_get(&diff->deltas, idx);
  	if (!delta) {
  		giterr_set(GITERR_INVALID, "Index out of range for delta in diff");
  		return GIT_ENOTFOUND;
  	}
  
  	if (git_diff_delta__should_skip(&diff->opts, delta))
  		return 0;
  
  	/* don't load the patch data unless we need it for binary check */
  	if (!patch_ptr &&
  		((delta->flags & DIFF_FLAGS_KNOWN_BINARY) != 0 ||
  		 (diff->opts.flags & GIT_DIFF_SKIP_BINARY_CHECK) != 0))
  		return 0;
  
  	if ((error = diff_patch_alloc_from_diff(&patch, diff, idx)) < 0)
  		return error;
  
  	memset(&xo, 0, sizeof(xo));
  	diff_output_to_patch(&xo.output, patch);
  	git_xdiff_init(&xo, &diff->opts);
  
  	error = diff_patch_invoke_file_callback(patch, &xo.output);
  
  	if (!error)
  		error = diff_patch_generate(patch, &xo.output);
  
  	if (!error) {
  		/* TODO: if cumulative diff size is < 0.5 total size, flatten patch */
  		/* TODO: and unload the file content */
  	}
  
  	if (error || !patch_ptr)
  		git_patch_free(patch);
  	else
  		*patch_ptr = patch;
  
  	return error;
  }
  
  void git_patch_free(git_patch *patch)
  {
  	if (patch)
  		GIT_REFCOUNT_DEC(patch, diff_patch_free);
  }
  
  const git_diff_delta *git_patch_get_delta(const git_patch *patch)
  {
  	assert(patch);
  	return patch->delta;
  }
  
  size_t git_patch_num_hunks(const git_patch *patch)
  {
  	assert(patch);
  	return git_array_size(patch->hunks);
  }
  
  int git_patch_line_stats(
  	size_t *total_ctxt,
  	size_t *total_adds,
  	size_t *total_dels,
  	const git_patch *patch)
  {
  	size_t totals[3], idx;
  
  	memset(totals, 0, sizeof(totals));
  
  	for (idx = 0; idx < git_array_size(patch->lines); ++idx) {
  		git_diff_line *line = git_array_get(patch->lines, idx);
  		if (!line)
  			continue;
  
  		switch (line->origin) {
  		case GIT_DIFF_LINE_CONTEXT:  totals[0]++; break;
  		case GIT_DIFF_LINE_ADDITION: totals[1]++; break;
  		case GIT_DIFF_LINE_DELETION: totals[2]++; break;
  		default:
  			/* diff --stat and --numstat don't count EOFNL marks because
  			 * they will always be paired with a ADDITION or DELETION line.
  			 */
  			break;
  		}
  	}
  
  	if (total_ctxt)
  		*total_ctxt = totals[0];
  	if (total_adds)
  		*total_adds = totals[1];
  	if (total_dels)
  		*total_dels = totals[2];
  
  	return 0;
  }
  
  static int diff_error_outofrange(const char *thing)
  {
  	giterr_set(GITERR_INVALID, "Diff patch %s index out of range", thing);
  	return GIT_ENOTFOUND;
  }
  
  int git_patch_get_hunk(
  	const git_diff_hunk **out,
  	size_t *lines_in_hunk,
  	git_patch *patch,
  	size_t hunk_idx)
  {
  	diff_patch_hunk *hunk;
  	assert(patch);
  
  	hunk = git_array_get(patch->hunks, hunk_idx);
  
  	if (!hunk) {
  		if (out) *out = NULL;
  		if (lines_in_hunk) *lines_in_hunk = 0;
  		return diff_error_outofrange("hunk");
  	}
  
  	if (out) *out = &hunk->hunk;
  	if (lines_in_hunk) *lines_in_hunk = hunk->line_count;
  	return 0;
  }
  
  int git_patch_num_lines_in_hunk(const git_patch *patch, size_t hunk_idx)
  {
  	diff_patch_hunk *hunk;
  	assert(patch);
  
  	if (!(hunk = git_array_get(patch->hunks, hunk_idx)))
  		return diff_error_outofrange("hunk");
  	return (int)hunk->line_count;
  }
  
  int git_patch_get_line_in_hunk(
  	const git_diff_line **out,
  	git_patch *patch,
  	size_t hunk_idx,
  	size_t line_of_hunk)
  {
  	diff_patch_hunk *hunk;
  	git_diff_line *line;
  
  	assert(patch);
  
  	if (!(hunk = git_array_get(patch->hunks, hunk_idx))) {
  		if (out) *out = NULL;
  		return diff_error_outofrange("hunk");
  	}
  
  	if (line_of_hunk >= hunk->line_count ||
  		!(line = git_array_get(
  			patch->lines, hunk->line_start + line_of_hunk))) {
  		if (out) *out = NULL;
  		return diff_error_outofrange("line");
  	}
  
  	if (out) *out = line;
  	return 0;
  }
  
  size_t git_patch_size(
  	git_patch *patch,
  	int include_context,
  	int include_hunk_headers,
  	int include_file_headers)
  {
  	size_t out;
  
  	assert(patch);
  
  	out = patch->content_size;
  
  	if (!include_context)
  		out -= patch->context_size;
  
  	if (include_hunk_headers)
  		out += patch->header_size;
  
  	if (include_file_headers) {
  		git_buf file_header = GIT_BUF_INIT;
  
  		if (git_diff_delta__format_file_header(
  				&file_header, patch->delta, NULL, NULL, 0) < 0)
  			giterr_clear();
  		else
  			out += git_buf_len(&file_header);
  
  		git_buf_free(&file_header);
  	}
  
  	return out;
  }
  
  git_diff *git_patch__diff(git_patch *patch)
  {
  	return patch->diff;
  }
  
  git_diff_driver *git_patch__driver(git_patch *patch)
  {
  	/* ofile driver is representative for whole patch */
  	return patch->ofile.driver;
  }
  
  void git_patch__old_data(
  	char **ptr, size_t *len, git_patch *patch)
  {
  	*ptr = patch->ofile.map.data;
  	*len = patch->ofile.map.len;
  }
  
  void git_patch__new_data(
  	char **ptr, size_t *len, git_patch *patch)
  {
  	*ptr = patch->nfile.map.data;
  	*len = patch->nfile.map.len;
  }
  
  int git_patch__invoke_callbacks(
  	git_patch *patch,
  	git_diff_file_cb file_cb,
  	git_diff_binary_cb binary_cb,
  	git_diff_hunk_cb hunk_cb,
  	git_diff_line_cb line_cb,
  	void *payload)
  {
  	int error = 0;
  	uint32_t i, j;
  
  	if (file_cb)
  		error = file_cb(patch->delta, 0, payload);
  
  	if ((patch->delta->flags & GIT_DIFF_FLAG_BINARY) != 0) {
  		if (binary_cb)
  			error = binary_cb(patch->delta, &patch->binary, payload);
  
  		return error;
  	}
  
  	if (!hunk_cb && !line_cb)
  		return error;
  
  	for (i = 0; !error && i < git_array_size(patch->hunks); ++i) {
  		diff_patch_hunk *h = git_array_get(patch->hunks, i);
  
  		if (hunk_cb)
  			error = hunk_cb(patch->delta, &h->hunk, payload);
  
  		if (!line_cb)
  			continue;
  
  		for (j = 0; !error && j < h->line_count; ++j) {
  			git_diff_line *l =
  				git_array_get(patch->lines, h->line_start + j);
  
  			error = line_cb(patch->delta, &h->hunk, l, payload);
  		}
  	}
  
  	return error;
  }
  
  
  static int diff_patch_file_cb(
  	const git_diff_delta *delta,
  	float progress,
  	void *payload)
  {
  	GIT_UNUSED(delta); GIT_UNUSED(progress); GIT_UNUSED(payload);
  	return 0;
  }
  
  static int diff_patch_binary_cb(
  	const git_diff_delta *delta,
  	const git_diff_binary *binary,
  	void *payload)
  {
  	git_patch *patch = payload;
  
  	GIT_UNUSED(delta);
  
  	memcpy(&patch->binary, binary, sizeof(git_diff_binary));
  
  	if (binary->old_file.data) {
  		patch->binary.old_file.data = git__malloc(binary->old_file.datalen);
  		GITERR_CHECK_ALLOC(patch->binary.old_file.data);
  
  		memcpy((char *)patch->binary.old_file.data,
  			binary->old_file.data, binary->old_file.datalen);
  	}
  
  	if (binary->new_file.data) {
  		patch->binary.new_file.data = git__malloc(binary->new_file.datalen);
  		GITERR_CHECK_ALLOC(patch->binary.new_file.data);
  
  		memcpy((char *)patch->binary.new_file.data,
  			binary->new_file.data, binary->new_file.datalen);
  	}
  
  	return 0;
  }
  
  static int diff_patch_hunk_cb(
  	const git_diff_delta *delta,
  	const git_diff_hunk *hunk_,
  	void *payload)
  {
  	git_patch *patch = payload;
  	diff_patch_hunk *hunk;
  
  	GIT_UNUSED(delta);
  
  	hunk = git_array_alloc(patch->hunks);
  	GITERR_CHECK_ALLOC(hunk);
  
  	memcpy(&hunk->hunk, hunk_, sizeof(hunk->hunk));
  
  	patch->header_size += hunk_->header_len;
  
  	hunk->line_start = git_array_size(patch->lines);
  	hunk->line_count = 0;
  
  	return 0;
  }
  
  static int diff_patch_line_cb(
  	const git_diff_delta *delta,
  	const git_diff_hunk *hunk_,
  	const git_diff_line *line_,
  	void *payload)
  {
  	git_patch *patch = payload;
  	diff_patch_hunk *hunk;
  	git_diff_line   *line;
  
  	GIT_UNUSED(delta);
  	GIT_UNUSED(hunk_);
  
  	hunk = git_array_last(patch->hunks);
  	assert(hunk); /* programmer error if no hunk is available */
  
  	line = git_array_alloc(patch->lines);
  	GITERR_CHECK_ALLOC(line);
  
  	memcpy(line, line_, sizeof(*line));
  
  	/* do some bookkeeping so we can provide old/new line numbers */
  
  	patch->content_size += line->content_len;
  
  	if (line->origin == GIT_DIFF_LINE_ADDITION ||
  		line->origin == GIT_DIFF_LINE_DELETION)
  		patch->content_size += 1;
  	else if (line->origin == GIT_DIFF_LINE_CONTEXT) {
  		patch->content_size += 1;
  		patch->context_size += line->content_len + 1;
  	} else if (line->origin == GIT_DIFF_LINE_CONTEXT_EOFNL)
  		patch->context_size += line->content_len;
  
  	hunk->line_count++;
  
  	return 0;
  }
  
  static void diff_output_init(
  	git_diff_output *out,
  	const git_diff_options *opts,
  	git_diff_file_cb file_cb,
  	git_diff_binary_cb binary_cb,
  	git_diff_hunk_cb hunk_cb,
  	git_diff_line_cb data_cb,
  	void *payload)
  {
  	GIT_UNUSED(opts);
  
  	memset(out, 0, sizeof(*out));
  
  	out->file_cb = file_cb;
  	out->binary_cb = binary_cb;
  	out->hunk_cb = hunk_cb;
  	out->data_cb = data_cb;
  	out->payload = payload;
  }
  
  static void diff_output_to_patch(git_diff_output *out, git_patch *patch)
  {
  	diff_output_init(
  		out,
  		NULL,
  		diff_patch_file_cb,
  		diff_patch_binary_cb,
  		diff_patch_hunk_cb,
  		diff_patch_line_cb,
  		patch);
  }
  