[libgit2.git] / src / diff_print.c

/*
 * 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_patch.h"
#include "fileops.h"

typedef struct {
	git_diff *diff;
	git_diff_format_t format;
	git_diff_line_cb print_cb;
	void *payload;
	git_buf *buf;
	uint32_t flags;
	int oid_strlen;
	git_diff_line line;
} diff_print_info;

static int diff_print_info_init(
	diff_print_info *pi,
	git_buf *out,
	git_diff *diff,
	git_diff_format_t format,
	git_diff_line_cb cb,
	void *payload)
{
	pi->diff     = diff;
	pi->format   = format;
	pi->print_cb = cb;
	pi->payload  = payload;
	pi->buf      = out;

	if (diff)
		pi->flags = diff->opts.flags;

	if (diff && diff->opts.oid_abbrev != 0)
		pi->oid_strlen = diff->opts.oid_abbrev;
	else if (!diff || !diff->repo)
		pi->oid_strlen = GIT_ABBREV_DEFAULT;
	else if (git_repository__cvar(
		&pi->oid_strlen, diff->repo, GIT_CVAR_ABBREV) < 0)
		return -1;

	pi->oid_strlen += 1; /* for NUL byte */

	if (pi->oid_strlen < 2)
		pi->oid_strlen = 2;
	else if (pi->oid_strlen > GIT_OID_HEXSZ + 1)
		pi->oid_strlen = GIT_OID_HEXSZ + 1;

	memset(&pi->line, 0, sizeof(pi->line));
	pi->line.old_lineno = -1;
	pi->line.new_lineno = -1;
	pi->line.num_lines  = 1;

	return 0;
}

static char diff_pick_suffix(int mode)
{
	if (S_ISDIR(mode))
		return '/';
	else if (GIT_PERMS_IS_EXEC(mode)) /* -V536 */
		/* in git, modes are very regular, so we must have 0100755 mode */
		return '*';
	else
		return ' ';
}

char git_diff_status_char(git_delta_t status)
{
	char code;

	switch (status) {
	case GIT_DELTA_ADDED:     code = 'A'; break;
	case GIT_DELTA_DELETED:   code = 'D'; break;
	case GIT_DELTA_MODIFIED:  code = 'M'; break;
	case GIT_DELTA_RENAMED:   code = 'R'; break;
	case GIT_DELTA_COPIED:    code = 'C'; break;
	case GIT_DELTA_IGNORED:   code = 'I'; break;
	case GIT_DELTA_UNTRACKED: code = '?'; break;
	default:                  code = ' '; break;
	}

	return code;
}

static int callback_error(void)
{
	giterr_clear();
	return GIT_EUSER;
}

static int diff_print_one_name_only(
	const git_diff_delta *delta, float progress, void *data)
{
	diff_print_info *pi = data;
	git_buf *out = pi->buf;

	GIT_UNUSED(progress);

	if ((pi->flags & GIT_DIFF_SHOW_UNMODIFIED) == 0 &&
		delta->status == GIT_DELTA_UNMODIFIED)
		return 0;

	git_buf_clear(out);

	if (git_buf_puts(out, delta->new_file.path) < 0 ||
		git_buf_putc(out, '\n'))
		return -1;

	pi->line.origin      = GIT_DIFF_LINE_FILE_HDR;
	pi->line.content     = git_buf_cstr(out);
	pi->line.content_len = git_buf_len(out);

	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
		return callback_error();

	return 0;
}

static int diff_print_one_name_status(
	const git_diff_delta *delta, float progress, void *data)
{
	diff_print_info *pi = data;
	git_buf *out = pi->buf;
	char old_suffix, new_suffix, code = git_diff_status_char(delta->status);
	int (*strcomp)(const char *, const char *) =
		pi->diff ? pi->diff->strcomp : git__strcmp;

	GIT_UNUSED(progress);

	if ((pi->flags & GIT_DIFF_SHOW_UNMODIFIED) == 0 && code == ' ')
		return 0;

	old_suffix = diff_pick_suffix(delta->old_file.mode);
	new_suffix = diff_pick_suffix(delta->new_file.mode);

	git_buf_clear(out);

	if (delta->old_file.path != delta->new_file.path &&
		strcomp(delta->old_file.path,delta->new_file.path) != 0)
		git_buf_printf(out, "%c\t%s%c %s%c\n", code,
			delta->old_file.path, old_suffix, delta->new_file.path, new_suffix);
	else if (delta->old_file.mode != delta->new_file.mode &&
		delta->old_file.mode != 0 && delta->new_file.mode != 0)
		git_buf_printf(out, "%c\t%s%c %s%c\n", code,
			delta->old_file.path, old_suffix, delta->new_file.path, new_suffix);
	else if (old_suffix != ' ')
		git_buf_printf(out, "%c\t%s%c\n", code, delta->old_file.path, old_suffix);
	else
		git_buf_printf(out, "%c\t%s\n", code, delta->old_file.path);

	if (git_buf_oom(out))
		return -1;

	pi->line.origin      = GIT_DIFF_LINE_FILE_HDR;
	pi->line.content     = git_buf_cstr(out);
	pi->line.content_len = git_buf_len(out);

	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
		return callback_error();

	return 0;
}

static int diff_print_one_raw(
	const git_diff_delta *delta, float progress, void *data)
{
	diff_print_info *pi = data;
	git_buf *out = pi->buf;
	char code = git_diff_status_char(delta->status);
	char start_oid[GIT_OID_HEXSZ+1], end_oid[GIT_OID_HEXSZ+1];

	GIT_UNUSED(progress);

	if ((pi->flags & GIT_DIFF_SHOW_UNMODIFIED) == 0 && code == ' ')
		return 0;

	git_buf_clear(out);

	git_oid_tostr(start_oid, pi->oid_strlen, &delta->old_file.oid);
	git_oid_tostr(end_oid, pi->oid_strlen, &delta->new_file.oid);

	git_buf_printf(
		out, ":%06o %06o %s... %s... %c",
		delta->old_file.mode, delta->new_file.mode, start_oid, end_oid, code);

	if (delta->similarity > 0)
		git_buf_printf(out, "%03u", delta->similarity);

	if (delta->old_file.path != delta->new_file.path)
		git_buf_printf(
			out, "\t%s %s\n", delta->old_file.path, delta->new_file.path);
	else
		git_buf_printf(
			out, "\t%s\n", delta->old_file.path ?
			delta->old_file.path : delta->new_file.path);

	if (git_buf_oom(out))
		return -1;

	pi->line.origin      = GIT_DIFF_LINE_FILE_HDR;
	pi->line.content     = git_buf_cstr(out);
	pi->line.content_len = git_buf_len(out);

	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
		return callback_error();

	return 0;
}

static int diff_print_oid_range(
	git_buf *out, const git_diff_delta *delta, int oid_strlen)
{
	char start_oid[GIT_OID_HEXSZ+1], end_oid[GIT_OID_HEXSZ+1];

	git_oid_tostr(start_oid, oid_strlen, &delta->old_file.oid);
	git_oid_tostr(end_oid, oid_strlen, &delta->new_file.oid);

	/* TODO: Match git diff more closely */
	if (delta->old_file.mode == delta->new_file.mode) {
		git_buf_printf(out, "index %s..%s %o\n",
			start_oid, end_oid, delta->old_file.mode);
	} else {
		if (delta->old_file.mode == 0) {
			git_buf_printf(out, "new file mode %o\n", delta->new_file.mode);
		} else if (delta->new_file.mode == 0) {
			git_buf_printf(out, "deleted file mode %o\n", delta->old_file.mode);
		} else {
			git_buf_printf(out, "old mode %o\n", delta->old_file.mode);
			git_buf_printf(out, "new mode %o\n", delta->new_file.mode);
		}
		git_buf_printf(out, "index %s..%s\n", start_oid, end_oid);
	}

	if (git_buf_oom(out))
		return -1;

	return 0;
}

static int diff_delta_format_with_paths(
	git_buf *out,
	const git_diff_delta *delta,
	const char *oldpfx,
	const char *newpfx,
	const char *template)
{
	const char *oldpath = delta->old_file.path;
	const char *newpath = delta->new_file.path;

	if (git_oid_iszero(&delta->old_file.oid)) {
		oldpfx = "";
		oldpath = "/dev/null";
	}
	if (git_oid_iszero(&delta->new_file.oid)) {
		newpfx = "";
		newpath = "/dev/null";
	}

	return git_buf_printf(out, template, oldpfx, oldpath, newpfx, newpath);
}

int git_diff_delta__format_file_header(
	git_buf *out,
	const git_diff_delta *delta,
	const char *oldpfx,
	const char *newpfx,
	int oid_strlen)
{
	if (!oldpfx)
		oldpfx = DIFF_OLD_PREFIX_DEFAULT;
	if (!newpfx)
		newpfx = DIFF_NEW_PREFIX_DEFAULT;
	if (!oid_strlen)
		oid_strlen = GIT_ABBREV_DEFAULT + 1;

	git_buf_clear(out);

	git_buf_printf(out, "diff --git %s%s %s%s\n",
		oldpfx, delta->old_file.path, newpfx, delta->new_file.path);

	if (diff_print_oid_range(out, delta, oid_strlen) < 0)
		return -1;

	if ((delta->flags & GIT_DIFF_FLAG_BINARY) == 0)
		diff_delta_format_with_paths(
			out, delta, oldpfx, newpfx, "--- %s%s\n+++ %s%s\n");

	return git_buf_oom(out) ? -1 : 0;
}

static int diff_print_patch_file(
	const git_diff_delta *delta, float progress, void *data)
{
	diff_print_info *pi = data;
	const char *oldpfx =
		pi->diff ? pi->diff->opts.old_prefix : DIFF_OLD_PREFIX_DEFAULT;
	const char *newpfx =
		pi->diff ? pi->diff->opts.new_prefix : DIFF_NEW_PREFIX_DEFAULT;

	GIT_UNUSED(progress);

	if (S_ISDIR(delta->new_file.mode) ||
		delta->status == GIT_DELTA_UNMODIFIED ||
		delta->status == GIT_DELTA_IGNORED ||
		(delta->status == GIT_DELTA_UNTRACKED &&
		 (pi->flags & GIT_DIFF_SHOW_UNTRACKED_CONTENT) == 0))
		return 0;

	if (git_diff_delta__format_file_header(
			pi->buf, delta, oldpfx, newpfx, pi->oid_strlen) < 0)
		return -1;

	pi->line.origin      = GIT_DIFF_LINE_FILE_HDR;
	pi->line.content     = git_buf_cstr(pi->buf);
	pi->line.content_len = git_buf_len(pi->buf);

	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
		return callback_error();

	if ((delta->flags & GIT_DIFF_FLAG_BINARY) == 0)
		return 0;

	git_buf_clear(pi->buf);

	if (diff_delta_format_with_paths(
			pi->buf, delta, oldpfx, newpfx,
			"Binary files %s%s and %s%s differ\n") < 0)
		return -1;

	pi->line.origin      = GIT_DIFF_LINE_BINARY;
	pi->line.content     = git_buf_cstr(pi->buf);
	pi->line.content_len = git_buf_len(pi->buf);
	pi->line.num_lines   = 1;

	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
		return callback_error();

	return 0;
}

static int diff_print_patch_hunk(
	const git_diff_delta *d,
	const git_diff_hunk *h,
	void *data)
{
	diff_print_info *pi = data;

	if (S_ISDIR(d->new_file.mode))
		return 0;

	pi->line.origin      = GIT_DIFF_LINE_HUNK_HDR;
	pi->line.content     = h->header;
	pi->line.content_len = h->header_len;

	if (pi->print_cb(d, h, &pi->line, pi->payload))
		return callback_error();

	return 0;
}

static int diff_print_patch_line(
	const git_diff_delta *delta,
	const git_diff_hunk *hunk,
	const git_diff_line *line,
	void *data)
{
	diff_print_info *pi = data;

	if (S_ISDIR(delta->new_file.mode))
		return 0;

	if (pi->print_cb(delta, hunk, line, pi->payload))
		return callback_error();

	return 0;
}

/* print a git_diff to an output callback */
int git_diff_print(
	git_diff *diff,
	git_diff_format_t format,
	git_diff_line_cb print_cb,
	void *payload)
{
	int error;
	git_buf buf = GIT_BUF_INIT;
	diff_print_info pi;
	git_diff_file_cb print_file = NULL;
	git_diff_hunk_cb print_hunk = NULL;
	git_diff_line_cb print_line = NULL;

	switch (format) {
	case GIT_DIFF_FORMAT_PATCH:
		print_file = diff_print_patch_file;
		print_hunk = diff_print_patch_hunk;
		print_line = diff_print_patch_line;
		break;
	case GIT_DIFF_FORMAT_PATCH_HEADER:
		print_file = diff_print_patch_file;
		break;
	case GIT_DIFF_FORMAT_RAW:
		print_file = diff_print_one_raw;
		break;
	case GIT_DIFF_FORMAT_NAME_ONLY:
		print_file = diff_print_one_name_only;
		break;
	case GIT_DIFF_FORMAT_NAME_STATUS:
		print_file = diff_print_one_name_status;
		break;
	default:
		giterr_set(GITERR_INVALID, "Unknown diff output format (%d)", format);
		return -1;
	}

	if (!(error = diff_print_info_init(
			&pi, &buf, diff, format, print_cb, payload)))
		error = git_diff_foreach(
			diff, print_file, print_hunk, print_line, &pi);

	git_buf_free(&buf);

	return error;
}

/* print a git_patch to an output callback */
int git_patch_print(
	git_patch *patch,
	git_diff_line_cb print_cb,
	void *payload)
{
	int error;
	git_buf temp = GIT_BUF_INIT;
	diff_print_info pi;

	assert(patch && print_cb);

	if (!(error = diff_print_info_init(
			&pi, &temp, git_patch__diff(patch),
			GIT_DIFF_FORMAT_PATCH, print_cb, payload)))
		error = git_patch__invoke_callbacks(
			patch, diff_print_patch_file, diff_print_patch_hunk,
			diff_print_patch_line, &pi);

	git_buf_free(&temp);

	return error;
}

static int diff_print_to_buffer_cb(
	const git_diff_delta *delta,
	const git_diff_hunk *hunk,
	const git_diff_line *line,
	void *payload)
{
	git_buf *output = payload;
	GIT_UNUSED(delta); GIT_UNUSED(hunk);

	if (line->origin == GIT_DIFF_LINE_ADDITION ||
		line->origin == GIT_DIFF_LINE_DELETION ||
		line->origin == GIT_DIFF_LINE_CONTEXT)
		git_buf_putc(output, line->origin);

	return git_buf_put(output, line->content, line->content_len);
}

/* print a git_patch to a string buffer */
int git_patch_to_str(
	char **string,
	git_patch *patch)
{
	int error;
	git_buf output = GIT_BUF_INIT;

	error = git_patch_print(patch, diff_print_to_buffer_cb, &output);

	/* GIT_EUSER means git_buf_put in print_to_buffer_cb returned -1,
	 * meaning a memory allocation failure, so just map to -1...
	 */
	if (error == GIT_EUSER)
		error = -1;

	*string = git_buf_detach(&output);

	return error;
}
Commit	Line	Data
7000f3fa RB	1	/*
	2	* Copyright (C) the libgit2 contributors. All rights reserved.
	3	*
	4	* This file is part of libgit2, distributed under the GNU GPL v2 with
	5	* a Linking Exception. For full terms see the included COPYING file.
	6	*/
	7	#include "common.h"
	8	#include "diff.h"
114f5a6c	9	#include "diff_patch.h"
f240acce	10	#include "fileops.h"
7000f3fa RB	11
7000f3fa RB	12	typedef struct {
3ff1d123	13	git_diff *diff;
10672e3e	14	git_diff_format_t format;
3ff1d123	15	git_diff_line_cb print_cb;
7000f3fa RB	16	void *payload;
7000f3fa RB	17	git_buf *buf;
10672e3e	18	uint32_t flags;
7000f3fa	19	int oid_strlen;
3b5f7954	20	git_diff_line line;
7000f3fa RB	21	} diff_print_info;
	22
	23	static int diff_print_info_init(
	24	diff_print_info *pi,
10672e3e RB	25	git_buf *out,
	26	git_diff *diff,
	27	git_diff_format_t format,
	28	git_diff_line_cb cb,
	29	void *payload)
7000f3fa	30	{
7000f3fa	31	pi->diff = diff;
10672e3e	32	pi->format = format;
7000f3fa RB	33	pi->print_cb = cb;
	34	pi->payload = payload;
	35	pi->buf = out;
	36
10672e3e RB	37	if (diff)
	38	pi->flags = diff->opts.flags;
	39
	40	if (diff && diff->opts.oid_abbrev != 0)
	41	pi->oid_strlen = diff->opts.oid_abbrev;
	42	else if (!diff \|\| !diff->repo)
74ded024 RB	43	pi->oid_strlen = GIT_ABBREV_DEFAULT;
	44	else if (git_repository__cvar(
	45	&pi->oid_strlen, diff->repo, GIT_CVAR_ABBREV) < 0)
7000f3fa RB	46	return -1;
	47
	48	pi->oid_strlen += 1; /* for NUL byte */
	49
	50	if (pi->oid_strlen < 2)
	51	pi->oid_strlen = 2;
	52	else if (pi->oid_strlen > GIT_OID_HEXSZ + 1)
	53	pi->oid_strlen = GIT_OID_HEXSZ + 1;
	54
3b5f7954 RB	55	memset(&pi->line, 0, sizeof(pi->line));
	56	pi->line.old_lineno = -1;
	57	pi->line.new_lineno = -1;
	58	pi->line.num_lines = 1;
	59
7000f3fa RB	60	return 0;
	61	}
	62
a1683f28	63	static char diff_pick_suffix(int mode)
7000f3fa RB	64	{
	65	if (S_ISDIR(mode))
	66	return '/';
a7fcc44d	67	else if (GIT_PERMS_IS_EXEC(mode)) /* -V536 */
7000f3fa RB	68	/* in git, modes are very regular, so we must have 0100755 mode */
	69	return '*';
	70	else
	71	return ' ';
	72	}
	73
	74	char git_diff_status_char(git_delta_t status)
	75	{
	76	char code;
	77
	78	switch (status) {
	79	case GIT_DELTA_ADDED: code = 'A'; break;
	80	case GIT_DELTA_DELETED: code = 'D'; break;
	81	case GIT_DELTA_MODIFIED: code = 'M'; break;
	82	case GIT_DELTA_RENAMED: code = 'R'; break;
	83	case GIT_DELTA_COPIED: code = 'C'; break;
	84	case GIT_DELTA_IGNORED: code = 'I'; break;
	85	case GIT_DELTA_UNTRACKED: code = '?'; break;
	86	default: code = ' '; break;
	87	}
	88
	89	return code;
	90	}
	91
	92	static int callback_error(void)
	93	{
	94	giterr_clear();
	95	return GIT_EUSER;
	96	}
	97
10672e3e RB	98	static int diff_print_one_name_only(
	99	const git_diff_delta delta, float progress, void data)
	100	{
	101	diff_print_info *pi = data;
	102	git_buf *out = pi->buf;
	103
	104	GIT_UNUSED(progress);
	105
	106	if ((pi->flags & GIT_DIFF_SHOW_UNMODIFIED) == 0 &&
	107	delta->status == GIT_DELTA_UNMODIFIED)
	108	return 0;
	109
	110	git_buf_clear(out);
	111
	112	if (git_buf_puts(out, delta->new_file.path) < 0 \|\|
	113	git_buf_putc(out, '\n'))
	114	return -1;
	115
3b5f7954 RB	116	pi->line.origin = GIT_DIFF_LINE_FILE_HDR;
	117	pi->line.content = git_buf_cstr(out);
	118	pi->line.content_len = git_buf_len(out);
	119
	120	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
10672e3e RB	121	return callback_error();
	122
	123	return 0;
	124	}
	125
	126	static int diff_print_one_name_status(
7000f3fa RB	127	const git_diff_delta delta, float progress, void data)
	128	{
	129	diff_print_info *pi = data;
a1683f28	130	git_buf *out = pi->buf;
7000f3fa	131	char old_suffix, new_suffix, code = git_diff_status_char(delta->status);
74ded024 RB	132	int (strcomp)(const char , const char *) =
74ded024 RB	133	pi->diff ? pi->diff->strcomp : git__strcmp;
7000f3fa RB	134
	135	GIT_UNUSED(progress);
	136
10672e3e	137	if ((pi->flags & GIT_DIFF_SHOW_UNMODIFIED) == 0 && code == ' ')
7000f3fa RB	138	return 0;
7000f3fa RB	139
a1683f28 RB	140	old_suffix = diff_pick_suffix(delta->old_file.mode);
a1683f28 RB	141	new_suffix = diff_pick_suffix(delta->new_file.mode);
7000f3fa	142
a1683f28	143	git_buf_clear(out);
7000f3fa RB	144
7000f3fa RB	145	if (delta->old_file.path != delta->new_file.path &&
74ded024	146	strcomp(delta->old_file.path,delta->new_file.path) != 0)
df40f398	147	git_buf_printf(out, "%c\t%s%c %s%c\n", code,
7000f3fa RB	148	delta->old_file.path, old_suffix, delta->new_file.path, new_suffix);
	149	else if (delta->old_file.mode != delta->new_file.mode &&
	150	delta->old_file.mode != 0 && delta->new_file.mode != 0)
df40f398 RB	151	git_buf_printf(out, "%c\t%s%c %s%c\n", code,
df40f398 RB	152	delta->old_file.path, old_suffix, delta->new_file.path, new_suffix);
7000f3fa	153	else if (old_suffix != ' ')
a1683f28	154	git_buf_printf(out, "%c\t%s%c\n", code, delta->old_file.path, old_suffix);
7000f3fa	155	else
a1683f28	156	git_buf_printf(out, "%c\t%s\n", code, delta->old_file.path);
7000f3fa	157
a1683f28	158	if (git_buf_oom(out))
7000f3fa RB	159	return -1;
7000f3fa RB	160
3b5f7954 RB	161	pi->line.origin = GIT_DIFF_LINE_FILE_HDR;
	162	pi->line.content = git_buf_cstr(out);
	163	pi->line.content_len = git_buf_len(out);
	164
	165	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
7000f3fa RB	166	return callback_error();
	167
	168	return 0;
	169	}
	170
a1683f28	171	static int diff_print_one_raw(
7000f3fa RB	172	const git_diff_delta delta, float progress, void data)
	173	{
	174	diff_print_info *pi = data;
a1683f28	175	git_buf *out = pi->buf;
7000f3fa RB	176	char code = git_diff_status_char(delta->status);
	177	char start_oid[GIT_OID_HEXSZ+1], end_oid[GIT_OID_HEXSZ+1];
	178
	179	GIT_UNUSED(progress);
	180
10672e3e	181	if ((pi->flags & GIT_DIFF_SHOW_UNMODIFIED) == 0 && code == ' ')
7000f3fa RB	182	return 0;
7000f3fa RB	183
a1683f28	184	git_buf_clear(out);
7000f3fa RB	185
	186	git_oid_tostr(start_oid, pi->oid_strlen, &delta->old_file.oid);
	187	git_oid_tostr(end_oid, pi->oid_strlen, &delta->new_file.oid);
	188
	189	git_buf_printf(
a1683f28	190	out, ":%06o %06o %s... %s... %c",
7000f3fa RB	191	delta->old_file.mode, delta->new_file.mode, start_oid, end_oid, code);
	192
	193	if (delta->similarity > 0)
a1683f28	194	git_buf_printf(out, "%03u", delta->similarity);
7000f3fa	195
e4acc3ba	196	if (delta->old_file.path != delta->new_file.path)
7000f3fa	197	git_buf_printf(
a1683f28	198	out, "\t%s %s\n", delta->old_file.path, delta->new_file.path);
7000f3fa RB	199	else
7000f3fa RB	200	git_buf_printf(
a1683f28	201	out, "\t%s\n", delta->old_file.path ?
7000f3fa RB	202	delta->old_file.path : delta->new_file.path);
7000f3fa RB	203
a1683f28	204	if (git_buf_oom(out))
7000f3fa RB	205	return -1;
7000f3fa RB	206
3b5f7954 RB	207	pi->line.origin = GIT_DIFF_LINE_FILE_HDR;
	208	pi->line.content = git_buf_cstr(out);
	209	pi->line.content_len = git_buf_len(out);
	210
	211	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
7000f3fa RB	212	return callback_error();
	213
	214	return 0;
	215	}
	216
197b8966 RB	217	static int diff_print_oid_range(
197b8966 RB	218	git_buf out, const git_diff_delta delta, int oid_strlen)
7000f3fa RB	219	{
	220	char start_oid[GIT_OID_HEXSZ+1], end_oid[GIT_OID_HEXSZ+1];
	221
197b8966 RB	222	git_oid_tostr(start_oid, oid_strlen, &delta->old_file.oid);
197b8966 RB	223	git_oid_tostr(end_oid, oid_strlen, &delta->new_file.oid);
7000f3fa RB	224
	225	/* TODO: Match git diff more closely */
	226	if (delta->old_file.mode == delta->new_file.mode) {
a1683f28	227	git_buf_printf(out, "index %s..%s %o\n",
7000f3fa RB	228	start_oid, end_oid, delta->old_file.mode);
	229	} else {
	230	if (delta->old_file.mode == 0) {
a1683f28	231	git_buf_printf(out, "new file mode %o\n", delta->new_file.mode);
7000f3fa	232	} else if (delta->new_file.mode == 0) {
a1683f28	233	git_buf_printf(out, "deleted file mode %o\n", delta->old_file.mode);
7000f3fa	234	} else {
a1683f28 RB	235	git_buf_printf(out, "old mode %o\n", delta->old_file.mode);
a1683f28 RB	236	git_buf_printf(out, "new mode %o\n", delta->new_file.mode);
7000f3fa	237	}
a1683f28	238	git_buf_printf(out, "index %s..%s\n", start_oid, end_oid);
7000f3fa RB	239	}
7000f3fa RB	240
a1683f28	241	if (git_buf_oom(out))
7000f3fa RB	242	return -1;
	243
	244	return 0;
	245	}
	246
eb1c1707	247	static int diff_delta_format_with_paths(
197b8966 RB	248	git_buf *out,
	249	const git_diff_delta *delta,
	250	const char *oldpfx,
	251	const char *newpfx,
eb1c1707	252	const char *template)
7000f3fa	253	{
7000f3fa	254	const char *oldpath = delta->old_file.path;
7000f3fa	255	const char *newpath = delta->new_file.path;
7000f3fa	256
eb1c1707 RB	257	if (git_oid_iszero(&delta->old_file.oid)) {
	258	oldpfx = "";
	259	oldpath = "/dev/null";
	260	}
	261	if (git_oid_iszero(&delta->new_file.oid)) {
	262	newpfx = "";
	263	newpath = "/dev/null";
	264	}
	265
	266	return git_buf_printf(out, template, oldpfx, oldpath, newpfx, newpath);
	267	}
	268
	269	int git_diff_delta__format_file_header(
	270	git_buf *out,
	271	const git_diff_delta *delta,
	272	const char *oldpfx,
	273	const char *newpfx,
	274	int oid_strlen)
	275	{
7000f3fa RB	276	if (!oldpfx)
7000f3fa RB	277	oldpfx = DIFF_OLD_PREFIX_DEFAULT;
7000f3fa RB	278	if (!newpfx)
7000f3fa RB	279	newpfx = DIFF_NEW_PREFIX_DEFAULT;
197b8966 RB	280	if (!oid_strlen)
197b8966 RB	281	oid_strlen = GIT_ABBREV_DEFAULT + 1;
7000f3fa	282
197b8966 RB	283	git_buf_clear(out);
	284
	285	git_buf_printf(out, "diff --git %s%s %s%s\n",
eb1c1707	286	oldpfx, delta->old_file.path, newpfx, delta->new_file.path);
7000f3fa	287
197b8966	288	if (diff_print_oid_range(out, delta, oid_strlen) < 0)
7000f3fa RB	289	return -1;
7000f3fa RB	290
eb1c1707 RB	291	if ((delta->flags & GIT_DIFF_FLAG_BINARY) == 0)
	292	diff_delta_format_with_paths(
	293	out, delta, oldpfx, newpfx, "--- %s%s\n+++ %s%s\n");
7000f3fa	294
197b8966 RB	295	return git_buf_oom(out) ? -1 : 0;
197b8966 RB	296	}
7000f3fa	297
197b8966 RB	298	static int diff_print_patch_file(
	299	const git_diff_delta delta, float progress, void data)
	300	{
	301	diff_print_info *pi = data;
eb1c1707 RB	302	const char *oldpfx =
	303	pi->diff ? pi->diff->opts.old_prefix : DIFF_OLD_PREFIX_DEFAULT;
	304	const char *newpfx =
	305	pi->diff ? pi->diff->opts.new_prefix : DIFF_NEW_PREFIX_DEFAULT;
197b8966 RB	306
197b8966 RB	307	GIT_UNUSED(progress);
7000f3fa	308
197b8966 RB	309	if (S_ISDIR(delta->new_file.mode) \|\|
	310	delta->status == GIT_DELTA_UNMODIFIED \|\|
	311	delta->status == GIT_DELTA_IGNORED \|\|
	312	(delta->status == GIT_DELTA_UNTRACKED &&
10672e3e	313	(pi->flags & GIT_DIFF_SHOW_UNTRACKED_CONTENT) == 0))
7000f3fa RB	314	return 0;
7000f3fa RB	315
197b8966 RB	316	if (git_diff_delta__format_file_header(
197b8966 RB	317	pi->buf, delta, oldpfx, newpfx, pi->oid_strlen) < 0)
7000f3fa RB	318	return -1;
7000f3fa RB	319
3b5f7954 RB	320	pi->line.origin = GIT_DIFF_LINE_FILE_HDR;
	321	pi->line.content = git_buf_cstr(pi->buf);
	322	pi->line.content_len = git_buf_len(pi->buf);
	323
	324	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
eb1c1707 RB	325	return callback_error();
	326
	327	if ((delta->flags & GIT_DIFF_FLAG_BINARY) == 0)
	328	return 0;
	329
	330	git_buf_clear(pi->buf);
	331
	332	if (diff_delta_format_with_paths(
	333	pi->buf, delta, oldpfx, newpfx,
	334	"Binary files %s%s and %s%s differ\n") < 0)
	335	return -1;
	336
3b5f7954 RB	337	pi->line.origin = GIT_DIFF_LINE_BINARY;
	338	pi->line.content = git_buf_cstr(pi->buf);
	339	pi->line.content_len = git_buf_len(pi->buf);
	340	pi->line.num_lines = 1;
	341
	342	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
7000f3fa RB	343	return callback_error();
	344
	345	return 0;
	346	}
	347
a1683f28	348	static int diff_print_patch_hunk(
7000f3fa	349	const git_diff_delta *d,
3b5f7954	350	const git_diff_hunk *h,
7000f3fa RB	351	void *data)
	352	{
	353	diff_print_info *pi = data;
	354
	355	if (S_ISDIR(d->new_file.mode))
	356	return 0;
	357
3b5f7954 RB	358	pi->line.origin = GIT_DIFF_LINE_HUNK_HDR;
	359	pi->line.content = h->header;
	360	pi->line.content_len = h->header_len;
7000f3fa	361
3b5f7954	362	if (pi->print_cb(d, h, &pi->line, pi->payload))
7000f3fa RB	363	return callback_error();
	364
	365	return 0;
	366	}
	367
a1683f28	368	static int diff_print_patch_line(
7000f3fa	369	const git_diff_delta *delta,
3b5f7954 RB	370	const git_diff_hunk *hunk,
3b5f7954 RB	371	const git_diff_line *line,
7000f3fa RB	372	void *data)
	373	{
	374	diff_print_info *pi = data;
	375
	376	if (S_ISDIR(delta->new_file.mode))
	377	return 0;
	378
3b5f7954	379	if (pi->print_cb(delta, hunk, line, pi->payload))
7000f3fa RB	380	return callback_error();
	381
	382	return 0;
	383	}
	384
10672e3e RB	385	/* print a git_diff to an output callback */
10672e3e RB	386	int git_diff_print(
3ff1d123	387	git_diff *diff,
10672e3e	388	git_diff_format_t format,
3ff1d123	389	git_diff_line_cb print_cb,
7000f3fa RB	390	void *payload)
	391	{
	392	int error;
	393	git_buf buf = GIT_BUF_INIT;
	394	diff_print_info pi;
10672e3e RB	395	git_diff_file_cb print_file = NULL;
	396	git_diff_hunk_cb print_hunk = NULL;
	397	git_diff_line_cb print_line = NULL;
	398
	399	switch (format) {
	400	case GIT_DIFF_FORMAT_PATCH:
	401	print_file = diff_print_patch_file;
	402	print_hunk = diff_print_patch_hunk;
	403	print_line = diff_print_patch_line;
	404	break;
	405	case GIT_DIFF_FORMAT_PATCH_HEADER:
	406	print_file = diff_print_patch_file;
	407	break;
	408	case GIT_DIFF_FORMAT_RAW:
	409	print_file = diff_print_one_raw;
	410	break;
	411	case GIT_DIFF_FORMAT_NAME_ONLY:
	412	print_file = diff_print_one_name_only;
	413	break;
	414	case GIT_DIFF_FORMAT_NAME_STATUS:
	415	print_file = diff_print_one_name_status;
	416	break;
	417	default:
	418	giterr_set(GITERR_INVALID, "Unknown diff output format (%d)", format);
	419	return -1;
	420	}
7000f3fa	421
10672e3e RB	422	if (!(error = diff_print_info_init(
10672e3e RB	423	&pi, &buf, diff, format, print_cb, payload)))
7000f3fa	424	error = git_diff_foreach(
10672e3e	425	diff, print_file, print_hunk, print_line, &pi);
7000f3fa RB	426
	427	git_buf_free(&buf);
	428
	429	return error;
	430	}
	431
3ff1d123 RB	432	/* print a git_patch to an output callback */
	433	int git_patch_print(
	434	git_patch *patch,
	435	git_diff_line_cb print_cb,
7000f3fa RB	436	void *payload)
	437	{
	438	int error;
	439	git_buf temp = GIT_BUF_INIT;
	440	diff_print_info pi;
7000f3fa RB	441
	442	assert(patch && print_cb);
	443
	444	if (!(error = diff_print_info_init(
10672e3e RB	445	&pi, &temp, git_patch__diff(patch),
10672e3e RB	446	GIT_DIFF_FORMAT_PATCH, print_cb, payload)))
3ff1d123	447	error = git_patch__invoke_callbacks(
a1683f28 RB	448	patch, diff_print_patch_file, diff_print_patch_hunk,
a1683f28 RB	449	diff_print_patch_line, &pi);
7000f3fa RB	450
	451	git_buf_free(&temp);
	452
	453	return error;
	454	}
	455
a1683f28 RB	456	static int diff_print_to_buffer_cb(
a1683f28 RB	457	const git_diff_delta *delta,
3b5f7954 RB	458	const git_diff_hunk *hunk,
3b5f7954 RB	459	const git_diff_line *line,
a1683f28 RB	460	void *payload)
	461	{
	462	git_buf *output = payload;
3b5f7954 RB	463	GIT_UNUSED(delta); GIT_UNUSED(hunk);
	464
	465	if (line->origin == GIT_DIFF_LINE_ADDITION \|\|
	466	line->origin == GIT_DIFF_LINE_DELETION \|\|
	467	line->origin == GIT_DIFF_LINE_CONTEXT)
	468	git_buf_putc(output, line->origin);
	469
	470	return git_buf_put(output, line->content, line->content_len);
a1683f28 RB	471	}
a1683f28 RB	472
3ff1d123 RB	473	/* print a git_patch to a string buffer */
3ff1d123 RB	474	int git_patch_to_str(
7000f3fa	475	char **string,
3ff1d123	476	git_patch *patch)
7000f3fa RB	477	{
	478	int error;
	479	git_buf output = GIT_BUF_INIT;
	480
3ff1d123	481	error = git_patch_print(patch, diff_print_to_buffer_cb, &output);
7000f3fa RB	482
	483	/* GIT_EUSER means git_buf_put in print_to_buffer_cb returned -1,
	484	* meaning a memory allocation failure, so just map to -1...
	485	*/
	486	if (error == GIT_EUSER)
	487	error = -1;
	488
	489	*string = git_buf_detach(&output);
	490
	491	return error;
	492	}