Merge branch 'rs/swap'
authorJunio C Hamano <gitster@pobox.com>
Wed, 15 Feb 2017 20:54:19 +0000 (12:54 -0800)
committerJunio C Hamano <gitster@pobox.com>
Wed, 15 Feb 2017 20:54:19 +0000 (12:54 -0800)
Code clean-up.

* rs/swap:
graph: use SWAP macro
diff: use SWAP macro
use SWAP macro
apply: use SWAP macro
add SWAP macro

14 files changed:
apply.c
builtin/diff-tree.c
builtin/diff.c
contrib/coccinelle/swap.cocci [new file with mode: 0644]
diff-no-index.c
diff.c
git-compat-util.h
graph.c
line-range.c
merge-recursive.c
object.c
pack-revindex.c
prio-queue.c
strbuf.h
diff --git a/apply.c b/apply.c
index 2ed808d429969ff9516ba1bf166c3fdfa6d63ed5..0e2caeab9cc523364e0cfbb8cbbb5aba1a0a58ee 100644 (file)
--- a/apply.c
+++ b/apply.c
@@ -2187,29 +2187,20 @@ static int parse_chunk(struct apply_state *state, char *buffer, unsigned long si
        return offset + hdrsize + patchsize;
 }
 
-#define swap(a,b) myswap((a),(b),sizeof(a))
-
-#define myswap(a, b, size) do {                \
-       unsigned char mytmp[size];      \
-       memcpy(mytmp, &a, size);                \
-       memcpy(&a, &b, size);           \
-       memcpy(&b, mytmp, size);                \
-} while (0)
-
 static void reverse_patches(struct patch *p)
 {
        for (; p; p = p->next) {
                struct fragment *frag = p->fragments;
 
-               swap(p->new_name, p->old_name);
-               swap(p->new_mode, p->old_mode);
-               swap(p->is_new, p->is_delete);
-               swap(p->lines_added, p->lines_deleted);
-               swap(p->old_sha1_prefix, p->new_sha1_prefix);
+               SWAP(p->new_name, p->old_name);
+               SWAP(p->new_mode, p->old_mode);
+               SWAP(p->is_new, p->is_delete);
+               SWAP(p->lines_added, p->lines_deleted);
+               SWAP(p->old_sha1_prefix, p->new_sha1_prefix);
 
                for (; frag; frag = frag->next) {
-                       swap(frag->newpos, frag->oldpos);
-                       swap(frag->newlines, frag->oldlines);
+                       SWAP(frag->newpos, frag->oldpos);
+                       SWAP(frag->newlines, frag->oldlines);
                }
        }
 }
index 806dd7a885e9e7b87e19ca8acd2b6d0383b41d85..8ce00480cd484e10b0b46d931c934fcd3ba7b71e 100644 (file)
@@ -147,9 +147,7 @@ int cmd_diff_tree(int argc, const char **argv, const char *prefix)
                tree1 = opt->pending.objects[0].item;
                tree2 = opt->pending.objects[1].item;
                if (tree2->flags & UNINTERESTING) {
-                       struct object *tmp = tree2;
-                       tree2 = tree1;
-                       tree1 = tmp;
+                       SWAP(tree2, tree1);
                }
                diff_tree_sha1(tree1->oid.hash,
                               tree2->oid.hash,
index 7f91f6d2267db962fb7c25e92983afd4e811d43e..3d64b8533732b5d4af971e6b1cd23ff66123e8e9 100644 (file)
@@ -45,12 +45,9 @@ static void stuff_change(struct diff_options *opt,
                return;
 
        if (DIFF_OPT_TST(opt, REVERSE_DIFF)) {
-               unsigned tmp;
-               const unsigned char *tmp_u;
-               const char *tmp_c;
-               tmp = old_mode; old_mode = new_mode; new_mode = tmp;
-               tmp_u = old_sha1; old_sha1 = new_sha1; new_sha1 = tmp_u;
-               tmp_c = old_name; old_name = new_name; new_name = tmp_c;
+               SWAP(old_mode, new_mode);
+               SWAP(old_sha1, new_sha1);
+               SWAP(old_name, new_name);
        }
 
        if (opt->prefix &&
diff --git a/contrib/coccinelle/swap.cocci b/contrib/coccinelle/swap.cocci
new file mode 100644 (file)
index 0000000..a0934d1
--- /dev/null
@@ -0,0 +1,28 @@
+@ swap_with_declaration @
+type T;
+identifier tmp;
+T a, b;
+@@
+- T tmp = a;
++ T tmp;
++ tmp = a;
+  a = b;
+  b = tmp;
+
+@ swap @
+type T;
+T tmp, a, b;
+@@
+- tmp = a;
+- a = b;
+- b = tmp;
++ SWAP(a, b);
+
+@ extends swap @
+identifier unused;
+@@
+  {
+  ...
+- T unused;
+  ... when != unused
+  }
index f420786039d387d3a943d510c802ecd90c3ddf28..df762fd0f7d1ec74175a42de07b064107d3a601a 100644 (file)
@@ -185,10 +185,8 @@ static int queue_diff(struct diff_options *o,
                struct diff_filespec *d1, *d2;
 
                if (DIFF_OPT_TST(o, REVERSE_DIFF)) {
-                       unsigned tmp;
-                       const char *tmp_c;
-                       tmp = mode1; mode1 = mode2; mode2 = tmp;
-                       tmp_c = name1; name1 = name2; name2 = tmp_c;
+                       SWAP(mode1, mode2);
+                       SWAP(name1, name2);
                }
 
                d1 = noindex_filespec(name1, mode1);
diff --git a/diff.c b/diff.c
index a79f3408da44a085f97d5cc1b29c200a2e1defbf..051761be405ece65423d43830f08ed7b7dec9756 100644 (file)
--- a/diff.c
+++ b/diff.c
@@ -5118,14 +5118,10 @@ void diff_change(struct diff_options *options,
                return;
 
        if (DIFF_OPT_TST(options, REVERSE_DIFF)) {
-               unsigned tmp;
-               const unsigned char *tmp_c;
-               tmp = old_mode; old_mode = new_mode; new_mode = tmp;
-               tmp_c = old_sha1; old_sha1 = new_sha1; new_sha1 = tmp_c;
-               tmp = old_sha1_valid; old_sha1_valid = new_sha1_valid;
-                       new_sha1_valid = tmp;
-               tmp = old_dirty_submodule; old_dirty_submodule = new_dirty_submodule;
-                       new_dirty_submodule = tmp;
+               SWAP(old_mode, new_mode);
+               SWAP(old_sha1, new_sha1);
+               SWAP(old_sha1_valid, new_sha1_valid);
+               SWAP(old_dirty_submodule, new_dirty_submodule);
        }
 
        if (options->prefix &&
index f46d40e4a475c9bd35ff02373101e8431e722b7d..ef6d560e156c0adefd897e04377b09d5c32edf08 100644 (file)
@@ -527,6 +527,16 @@ static inline int ends_with(const char *str, const char *suffix)
        return strip_suffix(str, suffix, &len);
 }
 
+#define SWAP(a, b) do {                                                \
+       void *_swap_a_ptr = &(a);                               \
+       void *_swap_b_ptr = &(b);                               \
+       unsigned char _swap_buffer[sizeof(a)];                  \
+       memcpy(_swap_buffer, _swap_a_ptr, sizeof(a));           \
+       memcpy(_swap_a_ptr, _swap_b_ptr, sizeof(a) +            \
+              BUILD_ASSERT_OR_ZERO(sizeof(a) == sizeof(b)));   \
+       memcpy(_swap_b_ptr, _swap_buffer, sizeof(a));           \
+} while (0)
+
 #if defined(NO_MMAP) || defined(USE_WIN32_MMAP)
 
 #ifndef PROT_READ
diff --git a/graph.c b/graph.c
index 0649007704ac635af163a4e1016121744a951d1c..8b9049dd2c725f58314042deebfb69030e4321d3 100644 (file)
--- a/graph.c
+++ b/graph.c
@@ -497,7 +497,6 @@ static void graph_update_width(struct git_graph *graph,
 static void graph_update_columns(struct git_graph *graph)
 {
        struct commit_list *parent;
-       struct column *tmp_columns;
        int max_new_columns;
        int mapping_idx;
        int i, seen_this, is_commit_in_columns;
@@ -510,11 +509,8 @@ static void graph_update_columns(struct git_graph *graph)
         * We'll re-use the old columns array as storage to compute the new
         * columns list for the commit after this one.
         */
-       tmp_columns = graph->columns;
-       graph->columns = graph->new_columns;
+       SWAP(graph->columns, graph->new_columns);
        graph->num_columns = graph->num_new_columns;
-
-       graph->new_columns = tmp_columns;
        graph->num_new_columns = 0;
 
        /*
@@ -1031,7 +1027,6 @@ static void graph_output_post_merge_line(struct git_graph *graph, struct strbuf
 static void graph_output_collapsing_line(struct git_graph *graph, struct strbuf *sb)
 {
        int i;
-       int *tmp_mapping;
        short used_horizontal = 0;
        int horizontal_edge = -1;
        int horizontal_edge_target = -1;
@@ -1166,9 +1161,7 @@ static void graph_output_collapsing_line(struct git_graph *graph, struct strbuf
        /*
         * Swap mapping and new_mapping
         */
-       tmp_mapping = graph->mapping;
-       graph->mapping = graph->new_mapping;
-       graph->new_mapping = tmp_mapping;
+       SWAP(graph->mapping, graph->new_mapping);
 
        /*
         * If graph->mapping indicates that all of the branch lines
index de4e32f9424fbc0770756c3f61751fc69bfeb17e..323399d16cfa828adce913c9ff994e860ce2e7a5 100644 (file)
@@ -269,8 +269,7 @@ int parse_range_arg(const char *arg, nth_line_fn_t nth_line_cb,
                return -1;
 
        if (*begin && *end && *end < *begin) {
-               long tmp;
-               tmp = *end; *end = *begin; *begin = tmp;
+               SWAP(*end, *begin);
        }
 
        return 0;
index d3272094430ccd3914c8214df73ba8e11363cfa7..b7ff1ada3c350dce75ff09709395e97a60c96b96 100644 (file)
@@ -1390,14 +1390,11 @@ static int process_renames(struct merge_options *o,
                        branch1 = o->branch1;
                        branch2 = o->branch2;
                } else {
-                       struct rename *tmp;
                        renames1 = b_renames;
                        renames2Dst = &a_by_dst;
                        branch1 = o->branch2;
                        branch2 = o->branch1;
-                       tmp = ren2;
-                       ren2 = ren1;
-                       ren1 = tmp;
+                       SWAP(ren2, ren1);
                }
 
                if (ren1->processed)
index 67d9a9e2211fc2f6ab5772bfe58e42a2a95e469d..e680d881a45756eb234a80a9909c24a7b146c1f7 100644 (file)
--- a/object.c
+++ b/object.c
@@ -104,9 +104,7 @@ struct object *lookup_object(const unsigned char *sha1)
                 * that we do not need to walk the hash table the next
                 * time we look for it.
                 */
-               struct object *tmp = obj_hash[i];
-               obj_hash[i] = obj_hash[first];
-               obj_hash[first] = tmp;
+               SWAP(obj_hash[i], obj_hash[first]);
        }
        return obj;
 }
index 6bc7c940335cdf2d31cb38c2db6f8f6c985d3c3b..1b7ebd8d7eefbcc646867db3e52536b4aac42208 100644 (file)
@@ -59,7 +59,6 @@ static void sort_revindex(struct revindex_entry *entries, unsigned n, off_t max)
         * be a no-op, as everybody lands in the same zero-th bucket.
         */
        for (bits = 0; max >> bits; bits += DIGIT_SIZE) {
-               struct revindex_entry *swap;
                unsigned i;
 
                memset(pos, 0, BUCKETS * sizeof(*pos));
@@ -97,9 +96,7 @@ static void sort_revindex(struct revindex_entry *entries, unsigned n, off_t max)
                 * Now "to" contains the most sorted list, so we swap "from" and
                 * "to" for the next iteration.
                 */
-               swap = from;
-               from = to;
-               to = swap;
+               SWAP(from, to);
        }
 
        /*
index e4365b00d6c3366e6753fc6da3fe1a165ab1222d..17252d231b31f2b8d82d7160d7b95709e14779ff 100644 (file)
@@ -12,9 +12,7 @@ static inline int compare(struct prio_queue *queue, int i, int j)
 
 static inline void swap(struct prio_queue *queue, int i, int j)
 {
-       struct prio_queue_entry tmp = queue->array[i];
-       queue->array[i] = queue->array[j];
-       queue->array[j] = tmp;
+       SWAP(queue->array[i], queue->array[j]);
 }
 
 void prio_queue_reverse(struct prio_queue *queue)
index 2262b12683b5d91d536baa0b71094098872200d1..cf1b5409e7c39eba4981a0a23e8250249a9202f1 100644 (file)
--- a/strbuf.h
+++ b/strbuf.h
@@ -109,9 +109,7 @@ extern void strbuf_attach(struct strbuf *, void *, size_t, size_t);
  */
 static inline void strbuf_swap(struct strbuf *a, struct strbuf *b)
 {
-       struct strbuf tmp = *a;
-       *a = *b;
-       *b = tmp;
+       SWAP(*a, *b);
 }