commit 61a7b57805472a03ad39d7bf4ef6d705eb0ccac2 from: Neels Hofmeyr date: Wed May 06 22:03:59 2020 UTC KNF: function declaration return types on separate line commit - 760fe30eb1f6351170157beaae12a0ca0c2698a9 commit + 61a7b57805472a03ad39d7bf4ef6d705eb0ccac2 blob - 0716796d2d5147368425b3edd6cc0e00d8ddc9ea blob + 570d5c58f2fda7b886d942ae92961bfddb6c1664 --- include/diff/diff_main.h +++ include/diff/diff_main.h @@ -37,17 +37,20 @@ struct range { 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), @@ -55,7 +58,8 @@ static inline void ranges_merge(struct range *a, const }; } -static inline int range_len(const struct range *r) +static inline int +range_len(const struct range *r) { if (!r) return 0; @@ -90,7 +94,8 @@ struct diff_atom { } 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 @@ -26,7 +26,8 @@ #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"); @@ -52,7 +53,8 @@ static inline void dump_atom(const struct diff_data *l 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); @@ -67,7 +69,8 @@ static inline void dump_atoms(const struct diff_data * } } -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); } @@ -75,8 +78,9 @@ static inline void dump(struct diff_data *d) /* 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" @@ -179,8 +183,9 @@ static inline void dump_myers_graph(const struct diff_ } } -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 @@ -17,7 +17,8 @@ #include -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; @@ -64,7 +65,8 @@ static int diff_data_atomize_text_lines(struct diff_da 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 @@ -33,9 +33,10 @@ /* 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; @@ -64,7 +65,8 @@ struct diff_chunk *diff_state_add_chunk(struct diff_st 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, @@ -73,8 +75,9 @@ void diff_data_init_root(struct diff_data *d, const ui }; } -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){ @@ -89,7 +92,8 @@ void diff_data_init_subsection(struct diff_data *d, st 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; @@ -97,7 +101,8 @@ void diff_data_free(struct diff_data *diff_data) 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"); @@ -138,7 +143,8 @@ enum diff_rc diff_algo_none(const struct diff_algo_con 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); @@ -202,9 +208,10 @@ return_rc: 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) @@ -235,7 +242,8 @@ struct diff_result *diff_main(const struct diff_config 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 @@ -185,9 +185,10 @@ struct diff_box { * 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; @@ -428,9 +429,10 @@ static bool diff_divide_myers_forward(struct diff_data * 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; @@ -645,7 +647,8 @@ static bool diff_divide_myers_backward(struct diff_dat /* 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; @@ -783,7 +786,8 @@ return_rc: /* 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 @@ -17,7 +17,8 @@ #include -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 @@ -17,8 +17,9 @@ #include -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 @@ -27,7 +27,8 @@ enum chunk_type { 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; @@ -47,13 +48,15 @@ struct chunk_context { 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); @@ -75,22 +78,25 @@ static void chunk_context_get(struct chunk_context *cc }; } -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; @@ -136,8 +142,9 @@ static void diff_output_unidiff_chunk(FILE *dest, bool 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 @@ -22,7 +22,8 @@ #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; @@ -55,8 +56,9 @@ static void diff_atoms_mark_unique(struct diff_data *d } /* 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. */ @@ -118,8 +120,9 @@ static void diff_atoms_mark_unique_in_both(struct diff *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"); @@ -189,7 +192,8 @@ static void diff_atoms_swallow_identical_neighbors(str * 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;