proxmox-mirrors/libgit2
1
0
Fork 0
mirror of https://git.proxmox.com/git/libgit2 synced 2025-06-22 21:00:02 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

patch: patch_diff -> patch_generated

Browse Source
This commit is contained in:
Edward Thomson 2015-11-24 15:19:59 -05:00 committed by Edward Thomson
parent 53571f2f0c
commit 8d44f8b78f
6 changed files with 119 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/diff_print.c
View File

@ -7,7 +7,7 @@
#include "common.h"
#include "diff.h"
#include "diff_file.h"
#include "patch_diff.h"
#include "patch_generate.h"
#include "fileops.h"
#include "zstream.h"
#include "blob.h"

2
src/diff_stats.c
View File

@ -7,7 +7,7 @@
#include "common.h"
#include "vector.h"
#include "diff.h"
#include "patch_diff.h"
#include "patch_generate.h"
#define DIFF_RENAME_FILE_SEPARATOR " => "
#define STATS_FULL_MIN_SCALE 7

16
src/diff_xdiff.c
View File

@ -9,7 +9,7 @@
#include "diff.h"
#include "diff_driver.h"
#include "diff_xdiff.h"
#include "patch_diff.h"
#include "patch_generate.h"
static int git_xdiff_scan_int(const char **str, int *value)
{
@ -56,7 +56,7 @@ fail:
typedef struct {
git_xdiff_output *xo;
git_patch_diff *patch;
git_patch_generated *patch;
git_diff_hunk hunk;
int old_lineno, new_lineno;
mmfile_t xd_old_data, xd_new_data;
@ -110,9 +110,9 @@ static int diff_update_lines(
static int git_xdiff_cb(void *priv, mmbuffer_t *bufs, int len)
{
git_xdiff_info *info = priv;
git_patch_diff *patch = info->patch;
git_patch_generated *patch = info->patch;
const git_diff_delta *delta = patch->base.delta;
git_patch_diff_output *output = &info->xo->output;
git_patch_generated_output *output = &info->xo->output;
git_diff_line line;
if (len == 1) {
@ -181,7 +181,7 @@ static int git_xdiff_cb(void *priv, mmbuffer_t *bufs, int len)
return output->error;
}
static int git_xdiff(git_patch_diff_output *output, git_patch_diff *patch)
static int git_xdiff(git_patch_generated_output *output, git_patch_generated *patch)
{
git_xdiff_output *xo = (git_xdiff_output *)output;
git_xdiff_info info;
@ -194,7 +194,7 @@ static int git_xdiff(git_patch_diff_output *output, git_patch_diff *patch)
xo->callback.priv = &info;
git_diff_find_context_init(
&xo->config.find_func, &findctxt, git_patch_diff_driver(patch));
&xo->config.find_func, &findctxt, git_patch_generated_driver(patch));
xo->config.find_func_priv = &findctxt;
if (xo->config.find_func != NULL)
@ -206,8 +206,8 @@ static int git_xdiff(git_patch_diff_output *output, git_patch_diff *patch)
* updates are needed to xo->params.flags
*/
git_patch_diff_old_data(&info.xd_old_data.ptr, &info.xd_old_data.size, patch);
git_patch_diff_new_data(&info.xd_new_data.ptr, &info.xd_new_data.size, patch);
git_patch_generated_old_data(&info.xd_old_data.ptr, &info.xd_old_data.size, patch);
git_patch_generated_new_data(&info.xd_new_data.ptr, &info.xd_new_data.size, patch);
if (info.xd_old_data.size > GIT_XDIFF_MAX_SIZE ||
info.xd_new_data.size > GIT_XDIFF_MAX_SIZE) {

10
src/diff_xdiff.h
View File

@ -9,19 +9,19 @@
#include "diff.h"
#include "xdiff/xdiff.h"
#include "patch_diff.h"
#include "patch_generate.h"
/* xdiff cannot cope with large files. these files should not be passed to
* xdiff. callers should treat these large files as binary.
*/
#define GIT_XDIFF_MAX_SIZE (1024LL * 1024 * 1023)
/* A git_xdiff_output is a git_patch_diff_output with extra fields necessary
* to use libxdiff. Calling git_xdiff_init() will set the diff_cb field
* of the output to use xdiff to generate the diffs.
/* A git_xdiff_output is a git_patch_generate_output with extra fields
* necessary to use libxdiff. Calling git_xdiff_init() will set the diff_cb
* field of the output to use xdiff to generate the diffs.
*/
typedef struct {
git_patch_diff_output output;
git_patch_generated_output output;
xdemitconf_t config;
xpparam_t params;

166
src/patch_diff.c → src/patch_generate.c
View File

@ -9,21 +9,22 @@
#include "diff.h"
#include "diff_file.h"
#include "diff_driver.h"
#include "patch_diff.h"
#include "patch_generate.h"
#include "diff_xdiff.h"
#include "delta.h"
#include "zstream.h"
#include "fileops.h"
static void diff_output_init(
git_patch_diff_output *, const git_diff_options *, git_diff_file_cb,
git_patch_generated_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_patch_diff_output *, git_patch_diff *);
static void diff_output_to_patch(
git_patch_generated_output *, git_patch_generated *);
static void patch_diff_free(git_patch *p)
static void patch_generated_free(git_patch *p)
{
git_patch_diff *patch = (git_patch_diff *)p;
git_patch_generated *patch = (git_patch_generated *)p;
git_array_clear(patch->base.lines);
git_array_clear(patch->base.hunks);
@ -42,11 +43,11 @@ static void patch_diff_free(git_patch *p)
git__free((char *)patch->base.diff_opts.old_prefix);
git__free((char *)patch->base.diff_opts.new_prefix);
if (patch->flags & GIT_PATCH_DIFF_ALLOCATED)
if (patch->flags & GIT_PATCH_GENERATED_ALLOCATED)
git__free(patch);
}
static void patch_diff_update_binary(git_patch_diff *patch)
static void patch_generated_update_binary(git_patch_generated *patch)
{
if ((patch->base.delta->flags & DIFF_FLAGS_KNOWN_BINARY) != 0)
return;
@ -64,19 +65,19 @@ static void patch_diff_update_binary(git_patch_diff *patch)
patch->base.delta->flags |= GIT_DIFF_FLAG_NOT_BINARY;
}
static void patch_diff_init_common(git_patch_diff *patch)
static void patch_generated_init_common(git_patch_generated *patch)
{
patch->base.free_fn = patch_diff_free;
patch->base.free_fn = patch_generated_free;
patch_diff_update_binary(patch);
patch_generated_update_binary(patch);
patch->flags |= GIT_PATCH_DIFF_INITIALIZED;
patch->flags |= GIT_PATCH_GENERATED_INITIALIZED;
if (patch->diff)
git_diff_addref(patch->diff);
}
static int patch_diff_normalize_options(
static int patch_generated_normalize_options(
git_diff_options *out,
const git_diff_options *opts)
{
@ -102,8 +103,8 @@ static int patch_diff_normalize_options(
return 0;
}
static int patch_diff_init(
git_patch_diff *patch, git_diff *diff, size_t delta_index)
static int patch_generated_init(
git_patch_generated *patch, git_diff *diff, size_t delta_index)
{
int error = 0;
@ -114,7 +115,7 @@ static int patch_diff_init(
patch->base.delta = git_vector_get(&diff->deltas, delta_index);
patch->delta_index = delta_index;
if ((error = patch_diff_normalize_options(
if ((error = patch_generated_normalize_options(
&patch->base.diff_opts, &diff->opts)) < 0 ||
(error = git_diff_file_content__init_from_diff(
&patch->ofile, diff, patch->base.delta, true)) < 0 ||
@ -122,20 +123,20 @@ static int patch_diff_init(
&patch->nfile, diff, patch->base.delta, false)) < 0)
return error;
patch_diff_init_common(patch);
patch_generated_init_common(patch);
return 0;
}
static int patch_diff_alloc_from_diff(
git_patch_diff **out, git_diff *diff, size_t delta_index)
static int patch_generated_alloc_from_diff(
git_patch_generated **out, git_diff *diff, size_t delta_index)
{
int error;
git_patch_diff *patch = git__calloc(1, sizeof(git_patch_diff));
git_patch_generated *patch = git__calloc(1, sizeof(git_patch_generated));
GITERR_CHECK_ALLOC(patch);
if (!(error = patch_diff_init(patch, diff, delta_index))) {
patch->flags |= GIT_PATCH_DIFF_ALLOCATED;
if (!(error = patch_generated_init(patch, diff, delta_index))) {
patch->flags |= GIT_PATCH_GENERATED_ALLOCATED;
GIT_REFCOUNT_INC(patch);
} else {
git__free(patch);
@ -146,7 +147,7 @@ static int patch_diff_alloc_from_diff(
return error;
}
GIT_INLINE(bool) should_skip_binary(git_patch_diff *patch, git_diff_file *file)
GIT_INLINE(bool) should_skip_binary(git_patch_generated *patch, git_diff_file *file)
{
if ((patch->base.diff_opts.flags & GIT_DIFF_SHOW_BINARY) != 0)
return false;
@ -154,7 +155,7 @@ GIT_INLINE(bool) should_skip_binary(git_patch_diff *patch, git_diff_file *file)
return (file->flags & GIT_DIFF_FLAG_BINARY) != 0;
}
static bool patch_diff_diffable(git_patch_diff *patch)
static bool patch_generated_diffable(git_patch_generated *patch)
{
size_t olen, nlen;
@ -183,12 +184,12 @@ static bool patch_diff_diffable(git_patch_diff *patch)
!git_oid_equal(&patch->ofile.file->id, &patch->nfile.file->id));
}
static int patch_diff_load(git_patch_diff *patch, git_patch_diff_output *output)
static int patch_generated_load(git_patch_generated *patch, git_patch_generated_output *output)
{
int error = 0;
bool incomplete_data;
if ((patch->flags & GIT_PATCH_DIFF_LOADED) != 0)
if ((patch->flags & GIT_PATCH_GENERATED_LOADED) != 0)
return 0;
/* if no hunk and data callbacks and user doesn't care if data looks
@ -245,20 +246,20 @@ static int patch_diff_load(git_patch_diff *patch, git_patch_diff_output *output)
patch->base.delta->status = GIT_DELTA_UNMODIFIED;
cleanup:
patch_diff_update_binary(patch);
patch_generated_update_binary(patch);
if (!error) {
if (patch_diff_diffable(patch))
patch->flags |= GIT_PATCH_DIFF_DIFFABLE;
if (patch_generated_diffable(patch))
patch->flags |= GIT_PATCH_GENERATED_DIFFABLE;
patch->flags |= GIT_PATCH_DIFF_LOADED;
patch->flags |= GIT_PATCH_GENERATED_LOADED;
}
return error;
}
static int patch_diff_invoke_file_callback(
git_patch_diff *patch, git_patch_diff_output *output)
static int patch_generated_invoke_file_callback(
git_patch_generated *patch, git_patch_generated_output *output)
{
float progress = patch->diff ?
((float)patch->delta_index / patch->diff->deltas.length) : 1.0f;
@ -338,7 +339,7 @@ done:
return error;
}
static int diff_binary(git_patch_diff_output *output, git_patch_diff *patch)
static int diff_binary(git_patch_generated_output *output, git_patch_generated *patch)
{
git_diff_binary binary = {{0}};
const char *old_data = patch->ofile.map.data;
@ -372,22 +373,24 @@ static int diff_binary(git_patch_diff_output *output, git_patch_diff *patch)
return error;
}
static int patch_diff_generate(git_patch_diff *patch, git_patch_diff_output *output)
static int patch_generated_create(
git_patch_generated *patch,
git_patch_generated_output *output)
{
int error = 0;
if ((patch->flags & GIT_PATCH_DIFF_DIFFED) != 0)
if ((patch->flags & GIT_PATCH_GENERATED_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_PATCH_DIFF_LOADED) == 0 &&
(error = patch_diff_load(patch, output)) < 0)
if ((patch->flags & GIT_PATCH_GENERATED_LOADED) == 0 &&
(error = patch_generated_load(patch, output)) < 0)
return error;
if ((patch->flags & GIT_PATCH_DIFF_DIFFABLE) == 0)
if ((patch->flags & GIT_PATCH_GENERATED_DIFFABLE) == 0)
return 0;
if ((patch->base.delta->flags & GIT_DIFF_FLAG_BINARY) != 0) {
@ -399,7 +402,7 @@ static int patch_diff_generate(git_patch_diff *patch, git_patch_diff_output *out
error = output->diff_cb(output, patch);
}
patch->flags |= GIT_PATCH_DIFF_DIFFED;
patch->flags |= GIT_PATCH_GENERATED_DIFFED;
return error;
}
@ -422,7 +425,7 @@ int git_diff_foreach(
int error = 0;
git_xdiff_output xo;
size_t idx;
git_patch_diff patch;
git_patch_generated patch;
if ((error = diff_required(diff, "git_diff_foreach")) < 0)
return error;
@ -440,14 +443,14 @@ int git_diff_foreach(
continue;
if (binary_cb || hunk_cb || data_cb) {
if ((error = patch_diff_init(&patch, diff, idx)) != 0 ||
(error = patch_diff_load(&patch, &xo.output)) != 0)
if ((error = patch_generated_init(&patch, diff, idx)) != 0 ||
(error = patch_generated_load(&patch, &xo.output)) != 0)
return error;
}
if ((error = patch_diff_invoke_file_callback(&patch, &xo.output)) == 0) {
if ((error = patch_generated_invoke_file_callback(&patch, &xo.output)) == 0) {
if (binary_cb || hunk_cb || data_cb)
error = patch_diff_generate(&patch, &xo.output);
error = patch_generated_create(&patch, &xo.output);
}
git_patch_free(&patch.base);
@ -460,15 +463,15 @@ int git_diff_foreach(
}
typedef struct {
git_patch_diff patch;
git_patch_generated patch;
git_diff_delta delta;
char paths[GIT_FLEX_ARRAY];
} patch_diff_with_delta;
} patch_generated_with_delta;
static int diff_single_generate(patch_diff_with_delta *pd, git_xdiff_output *xo)
static int diff_single_generate(patch_generated_with_delta *pd, git_xdiff_output *xo)
{
int error = 0;
git_patch_diff *patch = &pd->patch;
git_patch_generated *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);
@ -481,22 +484,22 @@ static int diff_single_generate(patch_diff_with_delta *pd, git_xdiff_output *xo)
patch->base.delta = &pd->delta;
patch_diff_init_common(patch);
patch_generated_init_common(patch);
if (pd->delta.status == GIT_DELTA_UNMODIFIED &&
!(patch->ofile.opts_flags & GIT_DIFF_INCLUDE_UNMODIFIED))
return error;
error = patch_diff_invoke_file_callback(patch, (git_patch_diff_output *)xo);
error = patch_generated_invoke_file_callback(patch, (git_patch_generated_output *)xo);
if (!error)
error = patch_diff_generate(patch, (git_patch_diff_output *)xo);
error = patch_generated_create(patch, (git_patch_generated_output *)xo);
return error;
}
static int patch_diff_from_sources(
patch_diff_with_delta *pd,
static int patch_generated_from_sources(
patch_generated_with_delta *pd,
git_xdiff_output *xo,
git_diff_file_content_src *oldsrc,
git_diff_file_content_src *newsrc,
@ -509,7 +512,7 @@ static int patch_diff_from_sources(
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 = patch_diff_normalize_options(&pd->patch.base.diff_opts, opts)) < 0)
if ((error = patch_generated_normalize_options(&pd->patch.base.diff_opts, opts)) < 0)
return error;
if (opts && (opts->flags & GIT_DIFF_REVERSE) != 0) {
@ -540,12 +543,12 @@ static int patch_diff_from_sources(
return diff_single_generate(pd, xo);
}
static int patch_diff_with_delta_alloc(
patch_diff_with_delta **out,
static int patch_generated_with_delta_alloc(
patch_generated_with_delta **out,
const char **old_path,
const char **new_path)
{
patch_diff_with_delta *pd;
patch_generated_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;
@ -557,7 +560,7 @@ static int patch_diff_with_delta_alloc(
*out = pd = git__calloc(1, alloc_len);
GITERR_CHECK_ALLOC(pd);
pd->patch.flags = GIT_PATCH_DIFF_ALLOCATED;
pd->patch.flags = GIT_PATCH_GENERATED_ALLOCATED;
if (*old_path) {
memcpy(&pd->paths[0], *old_path, old_len);
@ -585,7 +588,7 @@ static int diff_from_sources(
void *payload)
{
int error = 0;
patch_diff_with_delta pd;
patch_generated_with_delta pd;
git_xdiff_output xo;
memset(&xo, 0, sizeof(xo));
@ -595,7 +598,7 @@ static int diff_from_sources(
memset(&pd, 0, sizeof(pd));
error = patch_diff_from_sources(&pd, &xo, oldsrc, newsrc, opts);
error = patch_generated_from_sources(&pd, &xo, oldsrc, newsrc, opts);
git_patch_free(&pd.patch.base);
@ -609,13 +612,13 @@ static int patch_from_sources(
const git_diff_options *opts)
{
int error = 0;
patch_diff_with_delta *pd;
patch_generated_with_delta *pd;
git_xdiff_output xo;
assert(out);
*out = NULL;
if ((error = patch_diff_with_delta_alloc(
if ((error = patch_generated_with_delta_alloc(
&pd, &oldsrc->as_path, &newsrc->as_path)) < 0)
return error;
@ -623,7 +626,7 @@ static int patch_from_sources(
diff_output_to_patch(&xo.output, &pd->patch);
git_xdiff_init(&xo, opts);
if (!(error = patch_diff_from_sources(pd, &xo, oldsrc, newsrc, opts)))
if (!(error = patch_generated_from_sources(pd, &xo, oldsrc, newsrc, opts)))
*out = (git_patch *)pd;
else
git_patch_free((git_patch *)pd);
@ -748,7 +751,7 @@ int git_patch_from_diff(
int error = 0;
git_xdiff_output xo;
git_diff_delta *delta = NULL;
git_patch_diff *patch = NULL;
git_patch_generated *patch = NULL;
if (patch_ptr) *patch_ptr = NULL;
@ -770,17 +773,17 @@ int git_patch_from_diff(
(diff->opts.flags & GIT_DIFF_SKIP_BINARY_CHECK) != 0))
return 0;
if ((error = patch_diff_alloc_from_diff(&patch, diff, idx)) < 0)
if ((error = patch_generated_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 = patch_diff_invoke_file_callback(patch, &xo.output);
error = patch_generated_invoke_file_callback(patch, &xo.output);
if (!error)
error = patch_diff_generate(patch, &xo.output);
error = patch_generated_create(patch, &xo.output);
if (!error) {
/* TODO: if cumulative diff size is < 0.5 total size, flatten patch */
@ -795,27 +798,27 @@ int git_patch_from_diff(
return error;
}
git_diff_driver *git_patch_diff_driver(git_patch_diff *patch)
git_diff_driver *git_patch_generated_driver(git_patch_generated *patch)
{
/* ofile driver is representative for whole patch */
return patch->ofile.driver;
}
void git_patch_diff_old_data(
char **ptr, size_t *len, git_patch_diff *patch)
void git_patch_generated_old_data(
char **ptr, size_t *len, git_patch_generated *patch)
{
*ptr = patch->ofile.map.data;
*len = patch->ofile.map.len;
}
void git_patch_diff_new_data(
char **ptr, size_t *len, git_patch_diff *patch)
void git_patch_generated_new_data(
char **ptr, size_t *len, git_patch_generated *patch)
{
*ptr = patch->nfile.map.data;
*len = patch->nfile.map.len;
}
static int patch_diff_file_cb(
static int patch_generated_file_cb(
const git_diff_delta *delta,
float progress,
void *payload)
@ -824,7 +827,7 @@ static int patch_diff_file_cb(
return 0;
}
static int patch_diff_binary_cb(
static int patch_generated_binary_cb(
const git_diff_delta *delta,
const git_diff_binary *binary,
void *payload)
@ -859,7 +862,7 @@ static int git_patch_hunk_cb(
const git_diff_hunk *hunk_,
void *payload)
{
git_patch_diff *patch = payload;
git_patch_generated *patch = payload;
git_patch_hunk *hunk;
GIT_UNUSED(delta);
@ -877,13 +880,13 @@ static int git_patch_hunk_cb(
return 0;
}
static int patch_diff_line_cb(
static int patch_generated_line_cb(
const git_diff_delta *delta,
const git_diff_hunk *hunk_,
const git_diff_line *line_,
void *payload)
{
git_patch_diff *patch = payload;
git_patch_generated *patch = payload;
git_patch_hunk *hunk;
git_diff_line *line;
@ -917,7 +920,7 @@ static int patch_diff_line_cb(
}
static void diff_output_init(
git_patch_diff_output *out,
git_patch_generated_output *out,
const git_diff_options *opts,
git_diff_file_cb file_cb,
git_diff_binary_cb binary_cb,
@ -936,14 +939,15 @@ static void diff_output_init(
out->payload = payload;
}
static void diff_output_to_patch(git_patch_diff_output *out, git_patch_diff *patch)
static void diff_output_to_patch(
git_patch_generated_output *out, git_patch_generated *patch)
{
diff_output_init(
out,
NULL,
patch_diff_file_cb,
patch_diff_binary_cb,
patch_generated_file_cb,
patch_generated_binary_cb,
git_patch_hunk_cb,
patch_diff_line_cb,
patch_generated_line_cb,
patch);
}

35
src/patch_diff.h → src/patch_generate.h
View File

@ -4,8 +4,8 @@
* This file is part of libgit2, distributed under the GNU GPL v2 with
* a Linking Exception. For full terms see the included COPYING file.
*/
#ifndef INCLUDE_diff_patch_h__
#define INCLUDE_diff_patch_h__
#ifndef INCLUDE_patch_generate_h__
#define INCLUDE_patch_generate_h__
#include "common.h"
#include "diff.h"
@ -13,17 +13,17 @@
#include "patch.h"
enum {
GIT_PATCH_DIFF_ALLOCATED = (1 << 0),
GIT_PATCH_DIFF_INITIALIZED = (1 << 1),
GIT_PATCH_DIFF_LOADED = (1 << 2),
GIT_PATCH_GENERATED_ALLOCATED = (1 << 0),
GIT_PATCH_GENERATED_INITIALIZED = (1 << 1),
GIT_PATCH_GENERATED_LOADED = (1 << 2),
/* the two sides are different */
GIT_PATCH_DIFF_DIFFABLE = (1 << 3),
GIT_PATCH_GENERATED_DIFFABLE = (1 << 3),
/* the difference between the two sides has been computed */
GIT_PATCH_DIFF_DIFFED = (1 << 4),
GIT_PATCH_DIFF_FLATTENED = (1 << 5),
GIT_PATCH_GENERATED_DIFFED = (1 << 4),
GIT_PATCH_GENERATED_FLATTENED = (1 << 5),
};
struct git_patch_diff {
struct git_patch_generated {
struct git_patch base;
git_diff *diff; /* for refcount purposes, maybe NULL for blob diffs */
@ -34,16 +34,18 @@ struct git_patch_diff {
git_pool flattened;
};
typedef struct git_patch_diff git_patch_diff;
typedef struct git_patch_generated git_patch_generated;
extern git_diff_driver *git_patch_diff_driver(git_patch_diff *);
extern git_diff_driver *git_patch_generated_driver(git_patch_generated *);
extern void git_patch_diff_old_data(char **, size_t *, git_patch_diff *);
extern void git_patch_diff_new_data(char **, size_t *, git_patch_diff *);
extern void git_patch_generated_old_data(
char **, size_t *, git_patch_generated *);
extern void git_patch_generated_new_data(
char **, size_t *, git_patch_generated *);
typedef struct git_patch_diff_output git_patch_diff_output;
typedef struct git_patch_generated_output git_patch_generated_output;
struct git_patch_diff_output {
struct git_patch_generated_output {
/* these callbacks are issued with the diff data */
git_diff_file_cb file_cb;
git_diff_binary_cb binary_cb;
@ -57,7 +59,8 @@ struct git_patch_diff_output {
/* this callback is used to do the diff and drive the other callbacks.
* see diff_xdiff.h for how to use this in practice for now.
*/
int (*diff_cb)(git_patch_diff_output *output, git_patch_diff *patch);
int (*diff_cb)(git_patch_generated_output *output,
git_patch_generated *patch);
};
#endif