diff options
author | Edward Thomson <ethomson@microsoft.com> | 2015-11-24 15:19:59 -0500 |
---|---|---|
committer | Edward Thomson <ethomson@github.com> | 2016-05-26 13:01:08 -0500 |
commit | 8d44f8b78f7929c86b9e37acfe40fe707815bca6 (patch) | |
tree | 3cc10ccde05acd66e67a9d196bcc105e1190cdfe /src | |
parent | 53571f2f0c5cbb30e86aa0b8095f51c09c85761e (diff) | |
download | libgit2-8d44f8b78f7929c86b9e37acfe40fe707815bca6.tar.gz |
patch: `patch_diff` -> `patch_generated`
Diffstat (limited to 'src')
-rw-r--r-- | src/diff_print.c | 2 | ||||
-rw-r--r-- | src/diff_stats.c | 2 | ||||
-rw-r--r-- | src/diff_xdiff.c | 16 | ||||
-rw-r--r-- | src/diff_xdiff.h | 10 | ||||
-rw-r--r-- | src/patch_generate.c (renamed from src/patch_diff.c) | 166 | ||||
-rw-r--r-- | src/patch_generate.h (renamed from src/patch_diff.h) | 35 |
6 files changed, 119 insertions, 112 deletions
diff --git a/src/diff_print.c b/src/diff_print.c index e52386991..5bcb5d016 100644 --- a/src/diff_print.c +++ b/src/diff_print.c @@ -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" diff --git a/src/diff_stats.c b/src/diff_stats.c index f2eb69680..9c186d793 100644 --- a/src/diff_stats.c +++ b/src/diff_stats.c @@ -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 diff --git a/src/diff_xdiff.c b/src/diff_xdiff.c index 8017c9541..5bd6381b5 100644 --- a/src/diff_xdiff.c +++ b/src/diff_xdiff.c @@ -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) { diff --git a/src/diff_xdiff.h b/src/diff_xdiff.h index e1c58a229..88375986b 100644 --- a/src/diff_xdiff.h +++ b/src/diff_xdiff.h @@ -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; diff --git a/src/patch_diff.c b/src/patch_generate.c index bae0bd227..80a5a552a 100644 --- a/src/patch_diff.c +++ b/src/patch_generate.c @@ -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); } diff --git a/src/patch_diff.h b/src/patch_generate.h index 076acdf43..bb26a76e5 100644 --- a/src/patch_diff.h +++ b/src/patch_generate.h @@ -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 |