commit - 760fe30eb1f6351170157beaae12a0ca0c2698a9
commit + 61a7b57805472a03ad39d7bf4ef6d705eb0ccac2
blob - 0716796d2d5147368425b3edd6cc0e00d8ddc9ea
blob + 570d5c58f2fda7b886d942ae92961bfddb6c1664
--- include/diff/diff_main.h
+++ include/diff/diff_main.h
int end;
};
-static inline bool range_empty(const struct range *r)
+static inline bool
+range_empty(const struct range *r)
{
return r->start == r->end;
}
-static inline bool ranges_touch(const struct range *a, const struct range *b)
+static inline bool
+ranges_touch(const struct range *a, const struct range *b)
{
return (a->end >= b->start) && (a->start <= b->end);
}
-static inline void ranges_merge(struct range *a, const struct range *b)
+static inline void
+ranges_merge(struct range *a, const struct range *b)
{
*a = (struct range){
.start = MIN(a->start, b->start),
};
}
-static inline int range_len(const struct range *r)
+static inline int
+range_len(const struct range *r)
{
if (!r)
return 0;
} patience;
};
-static inline bool diff_atom_same(const struct diff_atom *left, const struct diff_atom *right)
+static inline bool
+diff_atom_same(const struct diff_atom *left, const struct diff_atom *right)
{
return left->hash == right->hash
&& left->len == right->len
blob - d3a560ca65443972ce10f241d3345d036bf04e7f
blob + 4e13a9434d0d167686e127df728bf257d02d1f0c
--- lib/debug.h
+++ lib/debug.h
#define debug_dump_atom dump_atom
#define debug_dump_atoms dump_atoms
-static inline void dump_atom(const struct diff_data *left, const struct diff_data *right, const struct diff_atom *atom)
+static inline void
+dump_atom(const struct diff_data *left, const struct diff_data *right, const struct diff_atom *atom)
{
if (!atom) {
print("NULL atom\n");
print("'\n");
}
-static inline void dump_atoms(const struct diff_data *d, struct diff_atom *atom, unsigned int count)
+static inline void
+dump_atoms(const struct diff_data *d, struct diff_atom *atom, unsigned int count)
{
if (count > 42) {
dump_atoms(d, atom, 20);
}
}
-static inline void dump(struct diff_data *d)
+static inline void
+dump(struct diff_data *d)
{
dump_atoms(d, d->atoms.head, d->atoms.len);
}
/* kd is a quadratic space myers matrix from the original Myers algorithm.
* kd_forward and kd_backward are linear slices of a myers matrix from the Myers Divide algorithm.
*/
-static inline void dump_myers_graph(const struct diff_data *l, const struct diff_data *r,
- int *kd, int *kd_forward, int kd_forward_d, int *kd_backward, int kd_backward_d)
+static inline void
+dump_myers_graph(const struct diff_data *l, const struct diff_data *r,
+ int *kd, int *kd_forward, int kd_forward_d, int *kd_backward, int kd_backward_d)
{
#define COLOR_YELLOW "\033[1;33m"
#define COLOR_GREEN "\033[1;32m"
}
}
-static inline void debug_dump_myers_graph(const struct diff_data *l, const struct diff_data *r,
- int *kd, int *kd_forward, int kd_forward_d, int *kd_backward, int kd_backward_d)
+static inline void
+debug_dump_myers_graph(const struct diff_data *l, const struct diff_data *r,
+ int *kd, int *kd_forward, int kd_forward_d, int *kd_backward, int kd_backward_d)
{
if (l->atoms.len > 99 || r->atoms.len > 99)
return;
blob - 0b88a3cedf38d100921a49d211e059e7ebdc11d5
blob + fbeb6164469b907b7e572d24ec0f8c6310a47eeb
--- lib/diff_atomize_text.c
+++ lib/diff_atomize_text.c
#include <diff/diff_main.h>
-static int diff_data_atomize_text_lines(struct diff_data *d)
+static int
+diff_data_atomize_text_lines(struct diff_data *d)
{
const uint8_t *pos = d->data;
const uint8_t *end = pos + d->len;
return DIFF_RC_OK;
}
-enum diff_rc diff_atomize_text_by_line(void *func_data, struct diff_data *left, struct diff_data *right)
+enum diff_rc
+diff_atomize_text_by_line(void *func_data, struct diff_data *left, struct diff_data *right)
{
enum diff_rc rc;
rc = diff_data_atomize_text_lines(left);
blob - 46c7fc63654f51755c1bde729244e679a0fa7c6c
blob + 8858013c493332f472d8fb36c12f51e62f1c19d4
--- lib/diff_main.c
+++ lib/diff_main.c
/* Even if a left or right side is empty, diff output may need to know the position in that file.
* So left_start or right_start must never be NULL -- pass left_count or right_count as zero to indicate staying at that
* position without consuming any lines. */
-struct diff_chunk *diff_state_add_chunk(struct diff_state *state, bool solved,
- struct diff_atom *left_start, unsigned int left_count,
- struct diff_atom *right_start, unsigned int right_count)
+struct diff_chunk *
+diff_state_add_chunk(struct diff_state *state, bool solved,
+ struct diff_atom *left_start, unsigned int left_count,
+ struct diff_atom *right_start, unsigned int right_count)
{
struct diff_chunk *chunk;
diff_chunk_arraylist_t *result;
return chunk;
}
-void diff_data_init_root(struct diff_data *d, const uint8_t *data, size_t len)
+void
+diff_data_init_root(struct diff_data *d, const uint8_t *data, size_t len)
{
*d = (struct diff_data){
.data = data,
};
}
-void diff_data_init_subsection(struct diff_data *d, struct diff_data *parent,
- struct diff_atom *from_atom, unsigned int atoms_count)
+void
+diff_data_init_subsection(struct diff_data *d, struct diff_data *parent,
+ struct diff_atom *from_atom, unsigned int atoms_count)
{
struct diff_atom *last_atom = from_atom + atoms_count - 1;
*d = (struct diff_data){
debug_dump(d);
}
-void diff_data_free(struct diff_data *diff_data)
+void
+diff_data_free(struct diff_data *diff_data)
{
if (!diff_data)
return;
ARRAYLIST_FREE(diff_data->atoms);
}
-enum diff_rc diff_algo_none(const struct diff_algo_config *algo_config, struct diff_state *state)
+enum diff_rc
+diff_algo_none(const struct diff_algo_config *algo_config, struct diff_state *state)
{
debug("\n** %s\n", __func__);
debug("left:\n");
return DIFF_RC_OK;
}
-enum diff_rc diff_run_algo(const struct diff_algo_config *algo_config, struct diff_state *state)
+enum diff_rc
+diff_run_algo(const struct diff_algo_config *algo_config, struct diff_state *state)
{
enum diff_rc rc;
ARRAYLIST_FREE(state->temp_result);
return rc;
}
-struct diff_result *diff_main(const struct diff_config *config,
- const uint8_t *left_data, size_t left_len,
- const uint8_t *right_data, size_t right_len)
+struct diff_result *
+diff_main(const struct diff_config *config,
+ const uint8_t *left_data, size_t left_len,
+ const uint8_t *right_data, size_t right_len)
{
struct diff_result *result = malloc(sizeof(struct diff_result));
if (!result)
return result;
}
-void diff_result_free(struct diff_result *result)
+void
+diff_result_free(struct diff_result *result)
{
if (!result)
return;
blob - 7a7f5de552270024ae0e6d69c930aa56b5e0a24e
blob + c14e542b7962f990a43c57c58bb31670d56d76f9
--- lib/diff_myers.c
+++ lib/diff_myers.c
* For d == 0, kd_forward[0] is initialized, i.e. the first invocation should be for d == 0.
* meeting_snake: resulting meeting point, if any.
*/
-static bool diff_divide_myers_forward(struct diff_data *left, struct diff_data *right,
- int *kd_forward, int *kd_backward, int d,
- struct diff_box *meeting_snake)
+static bool
+diff_divide_myers_forward(struct diff_data *left, struct diff_data *right,
+ int *kd_forward, int *kd_backward, int d,
+ struct diff_box *meeting_snake)
{
int delta = (int)right->atoms.len - (int)left->atoms.len;
int k;
* The first invocation will be for d == 1.
* meeting_snake: resulting meeting point, if any.
*/
-static bool diff_divide_myers_backward(struct diff_data *left, struct diff_data *right,
- int *kd_forward, int *kd_backward, int d,
- struct diff_box *meeting_snake)
+static bool
+diff_divide_myers_backward(struct diff_data *left, struct diff_data *right,
+ int *kd_forward, int *kd_backward, int d,
+ struct diff_box *meeting_snake)
{
int delta = (int)right->atoms.len - (int)left->atoms.len;
int c;
/* Myers "Divide et Impera": tracing forwards from the start and backwards from the end to find a midpoint that divides
* the problem into smaller chunks. Requires only linear amounts of memory. */
-enum diff_rc diff_algo_myers_divide(const struct diff_algo_config *algo_config, struct diff_state *state)
+enum diff_rc
+diff_algo_myers_divide(const struct diff_algo_config *algo_config, struct diff_state *state)
{
enum diff_rc rc = DIFF_RC_ENOMEM;
struct diff_data *left = &state->left;
/* Myers Diff tracing from the start all the way through to the end, requiring quadratic amounts of memory. This can
* fail if the required space surpasses algo_config->permitted_state_size. */
-enum diff_rc diff_algo_myers(const struct diff_algo_config *algo_config, struct diff_state *state)
+enum diff_rc
+diff_algo_myers(const struct diff_algo_config *algo_config, struct diff_state *state)
{
/* do a diff_divide_myers_forward() without a _backward(), so that it walks forward across the entire
* files to reach the end. Keep each run's state, and do a final backtrace. */
blob - c7fe3adc5f0ce38b80665f0f7703d3d608ba0047
blob + cdc0e9bd029917c5bf84ef03f748cd13965f386c
--- lib/diff_output.c
+++ lib/diff_output.c
#include <diff/diff_output.h>
-void diff_output_lines(FILE *dest, const char *prefix, struct diff_atom *start_atom, unsigned int count)
+void
+diff_output_lines(FILE *dest, const char *prefix, struct diff_atom *start_atom, unsigned int count)
{
struct diff_atom *atom;
foreach_diff_atom(atom, start_atom, count) {
blob - 55564fe485f024584b4094a4d203cd057b93ea1b
blob + 4195b51f8a5f76a61aff4d614ce64a923c8ecc71
--- lib/diff_output_plain.c
+++ lib/diff_output_plain.c
#include <diff/diff_output.h>
-enum diff_rc diff_output_plain(FILE *dest, const struct diff_input_info *info,
- const struct diff_result *result)
+enum diff_rc
+diff_output_plain(FILE *dest, const struct diff_input_info *info,
+ const struct diff_result *result)
{
if (!result)
return DIFF_RC_EINVAL;
blob - 40cc34ebd59e457c7dd39671b0abd49f24937a19
blob + 8e537ca9fd7a8c27f7af66f3592eaac6043a3b2e
--- lib/diff_output_unidiff.c
+++ lib/diff_output_unidiff.c
CHUNK_WEIRD,
};
-static inline enum chunk_type chunk_type(const struct diff_chunk *chunk)
+static inline enum chunk_type
+chunk_type(const struct diff_chunk *chunk)
{
if (!chunk->left_count && !chunk->right_count)
return CHUNK_EMPTY;
struct range left, right;
};
-static bool chunk_context_empty(const struct chunk_context *cc)
+static bool
+chunk_context_empty(const struct chunk_context *cc)
{
return range_empty(&cc->chunk);
}
-static void chunk_context_get(struct chunk_context *cc, const struct diff_result *r, int chunk_idx,
- int context_lines)
+static void
+chunk_context_get(struct chunk_context *cc, const struct diff_result *r, int chunk_idx,
+ int context_lines)
{
const struct diff_chunk *c = &r->chunks.head[chunk_idx];
int left_start = diff_atom_root_idx(&r->left, c->left_start);
};
}
-static bool chunk_contexts_touch(const struct chunk_context *cc, const struct chunk_context *other)
+static bool
+chunk_contexts_touch(const struct chunk_context *cc, const struct chunk_context *other)
{
return ranges_touch(&cc->chunk, &other->chunk)
|| ranges_touch(&cc->left, &other->left)
|| ranges_touch(&cc->right, &other->right);
}
-static void chunk_contexts_merge(struct chunk_context *cc, const struct chunk_context *other)
+static void
+chunk_contexts_merge(struct chunk_context *cc, const struct chunk_context *other)
{
ranges_merge(&cc->chunk, &other->chunk);
ranges_merge(&cc->left, &other->left);
ranges_merge(&cc->right, &other->right);
}
-static void diff_output_unidiff_chunk(FILE *dest, bool *header_printed, const struct diff_input_info *info,
- const struct diff_result *result, const struct chunk_context *cc)
+static void
+diff_output_unidiff_chunk(FILE *dest, bool *header_printed, const struct diff_input_info *info,
+ const struct diff_result *result, const struct chunk_context *cc)
{
if (range_empty(&cc->left) && range_empty(&cc->right))
return;
cc->left.end - chunk_end_line);
}
-enum diff_rc diff_output_unidiff(FILE *dest, const struct diff_input_info *info,
- const struct diff_result *result, unsigned int context_lines)
+enum diff_rc
+diff_output_unidiff(FILE *dest, const struct diff_input_info *info,
+ const struct diff_result *result, unsigned int context_lines)
{
if (!result)
return DIFF_RC_EINVAL;
blob - 17fcf075be5314b830bd4d85873c98c68516487f
blob + 9688701396a6430dba17305759f33a0b93832d9a
--- lib/diff_patience.c
+++ lib/diff_patience.c
#include "debug.h"
/* Set unique_here = true for all atoms that exist exactly once in this list. */
-static void diff_atoms_mark_unique(struct diff_data *d, unsigned int *unique_count)
+static void
+diff_atoms_mark_unique(struct diff_data *d, unsigned int *unique_count)
{
struct diff_atom *i;
unsigned int count = 0;
}
/* Mark those lines as atom->patience.unique_in_both = true that appear exactly once in each side. */
-static void diff_atoms_mark_unique_in_both(struct diff_data *left, struct diff_data *right,
- unsigned int *unique_in_both_count)
+static void
+diff_atoms_mark_unique_in_both(struct diff_data *left, struct diff_data *right,
+ unsigned int *unique_in_both_count)
{
/* Derive the final unique_in_both count without needing an explicit iteration. So this is just some
* optimiziation to save one iteration in the end. */
*unique_in_both_count = unique_in_both;
}
-static void diff_atoms_swallow_identical_neighbors(struct diff_data *left, struct diff_data *right,
- unsigned int *unique_in_both_count)
+static void
+diff_atoms_swallow_identical_neighbors(struct diff_data *left, struct diff_data *right,
+ unsigned int *unique_in_both_count)
{
debug("trivially combine identical lines arount unique_in_both lines\n");
* order (with other stuff allowed to interleave). Use patience sort for that, as in the Patience Diff algorithm.
* See https://bramcohen.livejournal.com/73318.html and, for a much more detailed explanation,
* https://blog.jcoglan.com/2017/09/19/the-patience-diff-algorithm/ */
-enum diff_rc diff_algo_patience(const struct diff_algo_config *algo_config, struct diff_state *state)
+enum diff_rc
+diff_algo_patience(const struct diff_algo_config *algo_config, struct diff_state *state)
{
enum diff_rc rc = DIFF_RC_ENOMEM;
