1 files changed, 78 insertions, 78 deletions

diff --git a/src/diff_patch.c b/src/diff_patch.c
index cc45b6ddb..a106944c7 100644
--- a/src/diff_patch.c
+++ b/src/diff_patch.c
@@ -24,16 +24,16 @@ struct diff_patch_line {
 /* cached information about a hunk in a diff */
 typedef struct diff_patch_hunk diff_patch_hunk;
 struct diff_patch_hunk {
-	git_diff_range range;
+	git_diff_hunk hunk;
 	char   header[128];
 	size_t header_len;
 	size_t line_start;
 	size_t line_count;
 };
 
-struct git_diff_patch {
+struct git_patch {
 	git_refcount rc;
-	git_diff_list *diff; /* for refcount purposes, maybe NULL for blob diffs */
+	git_diff *diff; /* for refcount purposes, maybe NULL for blob diffs */
 	git_diff_delta *delta;
 	size_t delta_index;
 	git_diff_file_content ofile;
@@ -56,11 +56,11 @@ enum {
 };
 
 static void diff_output_init(git_diff_output*, const git_diff_options*,
-	git_diff_file_cb, git_diff_hunk_cb, git_diff_data_cb, void*);
+	git_diff_file_cb, git_diff_hunk_cb, git_diff_line_cb, void*);
 
-static void diff_output_to_patch(git_diff_output *, git_diff_patch *);
+static void diff_output_to_patch(git_diff_output *, git_patch *);
 
-static void diff_patch_update_binary(git_diff_patch *patch)
+static void diff_patch_update_binary(git_patch *patch)
 {
 	if ((patch->delta->flags & DIFF_FLAGS_KNOWN_BINARY) != 0)
 		return;
@@ -74,7 +74,7 @@ static void diff_patch_update_binary(git_diff_patch *patch)
 		patch->delta->flags |= GIT_DIFF_FLAG_NOT_BINARY;
 }
 
-static void diff_patch_init_common(git_diff_patch *patch)
+static void diff_patch_init_common(git_patch *patch)
 {
 	diff_patch_update_binary(patch);
 
@@ -84,11 +84,11 @@ static void diff_patch_init_common(git_diff_patch *patch)
 	patch->flags |= GIT_DIFF_PATCH_INITIALIZED;
 
 	if (patch->diff)
-		git_diff_list_addref(patch->diff);
+		git_diff_addref(patch->diff);
 }
 
 static int diff_patch_init_from_diff(
-	git_diff_patch *patch, git_diff_list *diff, size_t delta_index)
+	git_patch *patch, git_diff *diff, size_t delta_index)
 {
 	int error = 0;
 
@@ -109,12 +109,12 @@ static int diff_patch_init_from_diff(
 }
 
 static int diff_patch_alloc_from_diff(
-	git_diff_patch **out,
-	git_diff_list *diff,
+	git_patch **out,
+	git_diff *diff,
 	size_t delta_index)
 {
 	int error;
-	git_diff_patch *patch = git__calloc(1, sizeof(git_diff_patch));
+	git_patch *patch = git__calloc(1, sizeof(git_patch));
 	GITERR_CHECK_ALLOC(patch);
 
 	if (!(error = diff_patch_init_from_diff(patch, diff, delta_index))) {
@@ -129,7 +129,7 @@ static int diff_patch_alloc_from_diff(
 	return error;
 }
 
-static int diff_patch_load(git_diff_patch *patch, git_diff_output *output)
+static int diff_patch_load(git_patch *patch, git_diff_output *output)
 {
 	int error = 0;
 	bool incomplete_data;
@@ -207,7 +207,7 @@ cleanup:
 }
 
 static int diff_patch_file_callback(
-	git_diff_patch *patch, git_diff_output *output)
+	git_patch *patch, git_diff_output *output)
 {
 	float progress;
 
@@ -223,7 +223,7 @@ static int diff_patch_file_callback(
 	return output->error;
 }
 
-static int diff_patch_generate(git_diff_patch *patch, git_diff_output *output)
+static int diff_patch_generate(git_patch *patch, git_diff_output *output)
 {
 	int error = 0;
 
@@ -248,7 +248,7 @@ static int diff_patch_generate(git_diff_patch *patch, git_diff_output *output)
 	return error;
 }
 
-static void diff_patch_free(git_diff_patch *patch)
+static void diff_patch_free(git_patch *patch)
 {
 	git_diff_file_content__clear(&patch->ofile);
 	git_diff_file_content__clear(&patch->nfile);
@@ -256,7 +256,7 @@ static void diff_patch_free(git_diff_patch *patch)
 	git_array_clear(patch->lines);
 	git_array_clear(patch->hunks);
 
-	git_diff_list_free(patch->diff); /* decrements refcount */
+	git_diff_free(patch->diff); /* decrements refcount */
 	patch->diff = NULL;
 
 	git_pool_clear(&patch->flattened);
@@ -265,7 +265,7 @@ static void diff_patch_free(git_diff_patch *patch)
 		git__free(patch);
 }
 
-static int diff_required(git_diff_list *diff, const char *action)
+static int diff_required(git_diff *diff, const char *action)
 {
 	if (diff)
 		return 0;
@@ -274,16 +274,16 @@ static int diff_required(git_diff_list *diff, const char *action)
 }
 
 int git_diff_foreach(
-	git_diff_list *diff,
+	git_diff *diff,
 	git_diff_file_cb file_cb,
 	git_diff_hunk_cb hunk_cb,
-	git_diff_data_cb data_cb,
+	git_diff_line_cb data_cb,
 	void *payload)
 {
 	int error = 0;
 	git_xdiff_output xo;
 	size_t idx;
-	git_diff_patch patch;
+	git_patch patch;
 
 	if (diff_required(diff, "git_diff_foreach") < 0)
 		return -1;
@@ -305,7 +305,7 @@ int git_diff_foreach(
 			if (!error)
 				error = diff_patch_generate(&patch, &xo.output);
 
-			git_diff_patch_free(&patch);
+			git_patch_free(&patch);
 		}
 
 		if (error < 0)
@@ -318,7 +318,7 @@ int git_diff_foreach(
 }
 
 typedef struct {
-	git_diff_patch patch;
+	git_patch patch;
 	git_diff_delta delta;
 	char paths[GIT_FLEX_ARRAY];
 } diff_patch_with_delta;
@@ -326,7 +326,7 @@ typedef struct {
 static int diff_single_generate(diff_patch_with_delta *pd, git_xdiff_output *xo)
 {
 	int error = 0;
-	git_diff_patch *patch = &pd->patch;
+	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);
 
@@ -430,7 +430,7 @@ int git_diff_blobs(
 	const git_diff_options *opts,
 	git_diff_file_cb file_cb,
 	git_diff_hunk_cb hunk_cb,
-	git_diff_data_cb data_cb,
+	git_diff_line_cb data_cb,
 	void *payload)
 {
 	int error = 0;
@@ -452,13 +452,13 @@ int git_diff_blobs(
 	error = diff_patch_from_blobs(
 		&pd, &xo, old_blob, old_path, new_blob, new_path, opts);
 
-	git_diff_patch_free(&pd.patch);
+	git_patch_free(&pd.patch);
 
 	return error;
 }
 
-int git_diff_patch_from_blobs(
-	git_diff_patch **out,
+int git_patch_from_blobs(
+	git_patch **out,
 	const git_blob *old_blob,
 	const char *old_path,
 	const git_blob *new_blob,
@@ -484,9 +484,9 @@ int git_diff_patch_from_blobs(
 		pd, &xo, old_blob, old_path, new_blob, new_path, opts);
 
 	if (!error)
-		*out = (git_diff_patch *)pd;
+		*out = (git_patch *)pd;
 	else
-		git_diff_patch_free((git_diff_patch *)pd);
+		git_patch_free((git_patch *)pd);
 
 	return error;
 }
@@ -542,7 +542,7 @@ int git_diff_blob_to_buffer(
 	const git_diff_options *opts,
 	git_diff_file_cb file_cb,
 	git_diff_hunk_cb hunk_cb,
-	git_diff_data_cb data_cb,
+	git_diff_line_cb data_cb,
 	void *payload)
 {
 	int error = 0;
@@ -564,13 +564,13 @@ int git_diff_blob_to_buffer(
 	error = diff_patch_from_blob_and_buffer(
 		&pd, &xo, old_blob, old_path, buf, buflen, buf_path, opts);
 
-	git_diff_patch_free(&pd.patch);
+	git_patch_free(&pd.patch);
 
 	return error;
 }
 
-int git_diff_patch_from_blob_and_buffer(
-	git_diff_patch **out,
+int git_patch_from_blob_and_buffer(
+	git_patch **out,
 	const git_blob *old_blob,
 	const char *old_path,
 	const char *buf,
@@ -597,28 +597,28 @@ int git_diff_patch_from_blob_and_buffer(
 		pd, &xo, old_blob, old_path, buf, buflen, buf_path, opts);
 
 	if (!error)
-		*out = (git_diff_patch *)pd;
+		*out = (git_patch *)pd;
 	else
-		git_diff_patch_free((git_diff_patch *)pd);
+		git_patch_free((git_patch *)pd);
 
 	return error;
 }
 
-int git_diff_get_patch(
-	git_diff_patch **patch_ptr,
+int git_patch_from_diff(
+	git_patch **patch_ptr,
 	const git_diff_delta **delta_ptr,
-	git_diff_list *diff,
+	git_diff *diff,
 	size_t idx)
 {
 	int error = 0;
 	git_xdiff_output xo;
 	git_diff_delta *delta = NULL;
-	git_diff_patch *patch = NULL;
+	git_patch *patch = NULL;
 
 	if (patch_ptr) *patch_ptr = NULL;
 	if (delta_ptr) *delta_ptr = NULL;
 
-	if (diff_required(diff, "git_diff_get_patch") < 0)
+	if (diff_required(diff, "git_patch_from_diff") < 0)
 		return -1;
 
 	delta = git_vector_get(&diff->deltas, idx);
@@ -656,7 +656,7 @@ int git_diff_get_patch(
 	}
 
 	if (error || !patch_ptr)
-		git_diff_patch_free(patch);
+		git_patch_free(patch);
 	else
 		*patch_ptr = patch;
 
@@ -665,29 +665,29 @@ int git_diff_get_patch(
 	return error;
 }
 
-void git_diff_patch_free(git_diff_patch *patch)
+void git_patch_free(git_patch *patch)
 {
 	if (patch)
 		GIT_REFCOUNT_DEC(patch, diff_patch_free);
 }
 
-const git_diff_delta *git_diff_patch_delta(git_diff_patch *patch)
+const git_diff_delta *git_patch_delta(git_patch *patch)
 {
 	assert(patch);
 	return patch->delta;
 }
 
-size_t git_diff_patch_num_hunks(git_diff_patch *patch)
+size_t git_patch_num_hunks(git_patch *patch)
 {
 	assert(patch);
 	return git_array_size(patch->hunks);
 }
 
-int git_diff_patch_line_stats(
+int git_patch_line_stats(
 	size_t *total_ctxt,
 	size_t *total_adds,
 	size_t *total_dels,
-	const git_diff_patch *patch)
+	const git_patch *patch)
 {
 	size_t totals[3], idx;
 
@@ -726,12 +726,12 @@ static int diff_error_outofrange(const char *thing)
 	return GIT_ENOTFOUND;
 }
 
-int git_diff_patch_get_hunk(
-	const git_diff_range **range,
+int git_patch_get_hunk(
+	const git_diff_hunk **out,
 	const char **header,
 	size_t *header_len,
 	size_t *lines_in_hunk,
-	git_diff_patch *patch,
+	git_patch *patch,
 	size_t hunk_idx)
 {
 	diff_patch_hunk *hunk;
@@ -740,21 +740,21 @@ int git_diff_patch_get_hunk(
 	hunk = git_array_get(patch->hunks, hunk_idx);
 
 	if (!hunk) {
-		if (range) *range = NULL;
+		if (out) *out = NULL;
 		if (header) *header = NULL;
 		if (header_len) *header_len = 0;
 		if (lines_in_hunk) *lines_in_hunk = 0;
 		return diff_error_outofrange("hunk");
 	}
 
-	if (range) *range = &hunk->range;
+	if (out) *out = &hunk->hunk;
 	if (header) *header = hunk->header;
 	if (header_len) *header_len = hunk->header_len;
 	if (lines_in_hunk) *lines_in_hunk = hunk->line_count;
 	return 0;
 }
 
-int git_diff_patch_num_lines_in_hunk(git_diff_patch *patch, size_t hunk_idx)
+int git_patch_num_lines_in_hunk(git_patch *patch, size_t hunk_idx)
 {
 	diff_patch_hunk *hunk;
 	assert(patch);
@@ -764,13 +764,13 @@ int git_diff_patch_num_lines_in_hunk(git_diff_patch *patch, size_t hunk_idx)
 	return (int)hunk->line_count;
 }
 
-int git_diff_patch_get_line_in_hunk(
+int git_patch_get_line_in_hunk(
 	char *line_origin,
 	const char **content,
 	size_t *content_len,
 	int *old_lineno,
 	int *new_lineno,
-	git_diff_patch *patch,
+	git_patch *patch,
 	size_t hunk_idx,
 	size_t line_of_hunk)
 {
@@ -810,8 +810,8 @@ notfound:
 	return diff_error_outofrange(thing);
 }
 
-size_t git_diff_patch_size(
-	git_diff_patch *patch,
+size_t git_patch_size(
+	git_patch *patch,
 	int include_context,
 	int include_hunk_headers,
 	int include_file_headers)
@@ -843,36 +843,36 @@ size_t git_diff_patch_size(
 	return out;
 }
 
-git_diff_list *git_diff_patch__diff(git_diff_patch *patch)
+git_diff *git_patch__diff(git_patch *patch)
 {
 	return patch->diff;
 }
 
-git_diff_driver *git_diff_patch__driver(git_diff_patch *patch)
+git_diff_driver *git_patch__driver(git_patch *patch)
 {
 	/* ofile driver is representative for whole patch */
 	return patch->ofile.driver;
 }
 
-void git_diff_patch__old_data(
-	char **ptr, size_t *len, git_diff_patch *patch)
+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_diff_patch__new_data(
-	char **ptr, size_t *len, git_diff_patch *patch)
+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_diff_patch__invoke_callbacks(
-	git_diff_patch *patch,
+int git_patch__invoke_callbacks(
+	git_patch *patch,
 	git_diff_file_cb file_cb,
 	git_diff_hunk_cb hunk_cb,
-	git_diff_data_cb line_cb,
+	git_diff_line_cb line_cb,
 	void *payload)
 {
 	int error = 0;
@@ -888,7 +888,7 @@ int git_diff_patch__invoke_callbacks(
 		diff_patch_hunk *h = git_array_get(patch->hunks, i);
 
 		error = hunk_cb(
-			patch->delta, &h->range, h->header, h->header_len, payload);
+			patch->delta, &h->hunk, h->header, h->header_len, payload);
 
 		if (!line_cb)
 			continue;
@@ -898,7 +898,7 @@ int git_diff_patch__invoke_callbacks(
 				git_array_get(patch->lines, h->line_start + j);
 
 			error = line_cb(
-				patch->delta, &h->range, l->origin, l->ptr, l->len, payload);
+				patch->delta, &h->hunk, l->origin, l->ptr, l->len, payload);
 		}
 	}
 
@@ -917,12 +917,12 @@ static int diff_patch_file_cb(
 
 static int diff_patch_hunk_cb(
 	const git_diff_delta *delta,
-	const git_diff_range *range,
+	const git_diff_hunk *hunk_,
 	const char *header,
 	size_t header_len,
 	void *payload)
 {
-	git_diff_patch *patch = payload;
+	git_patch *patch = payload;
 	diff_patch_hunk *hunk;
 
 	GIT_UNUSED(delta);
@@ -930,7 +930,7 @@ static int diff_patch_hunk_cb(
 	hunk = git_array_alloc(patch->hunks);
 	GITERR_CHECK_ALLOC(hunk);
 
-	memcpy(&hunk->range, range, sizeof(hunk->range));
+	memcpy(&hunk->hunk, hunk_, sizeof(hunk->hunk));
 
 	assert(header_len + 1 < sizeof(hunk->header));
 	memcpy(&hunk->header, header, header_len);
@@ -942,27 +942,27 @@ static int diff_patch_hunk_cb(
 	hunk->line_start = git_array_size(patch->lines);
 	hunk->line_count = 0;
 
-	patch->oldno = range->old_start;
-	patch->newno = range->new_start;
+	patch->oldno = hunk_->old_start;
+	patch->newno = hunk_->new_start;
 
 	return 0;
 }
 
 static int diff_patch_line_cb(
 	const git_diff_delta *delta,
-	const git_diff_range *range,
+	const git_diff_hunk *hunk_,
 	char line_origin,
 	const char *content,
 	size_t content_len,
 	void *payload)
 {
-	git_diff_patch *patch = payload;
+	git_patch *patch = payload;
 	diff_patch_hunk *hunk;
 	diff_patch_line *line;
 	const char *content_end = content + content_len;
 
 	GIT_UNUSED(delta);
-	GIT_UNUSED(range);
+	GIT_UNUSED(hunk_);
 
 	hunk = git_array_last(patch->hunks);
 	GITERR_CHECK_ALLOC(hunk);
@@ -1023,7 +1023,7 @@ static void diff_output_init(
 	const git_diff_options *opts,
 	git_diff_file_cb file_cb,
 	git_diff_hunk_cb hunk_cb,
-	git_diff_data_cb data_cb,
+	git_diff_line_cb data_cb,
 	void *payload)
 {
 	GIT_UNUSED(opts);
@@ -1036,7 +1036,7 @@ static void diff_output_init(
 	out->payload = payload;
 }
 
-static void diff_output_to_patch(git_diff_output *out, git_diff_patch *patch)
+static void diff_output_to_patch(git_diff_output *out, git_patch *patch)
 {
 	diff_output_init(
 		out, NULL,