use SWAP macro

Apply the semantic patch swap.cocci to convert hand-rolled swaps to use
the macro SWAP.  The resulting code is shorter and easier to read, the
object code is effectively unchanged.

The patch for object.c had to be hand-edited in order to preserve the
comment before the change; Coccinelle tried to eat it for some reason.

Signed-off-by: Rene Scharfe <l.s.r@web.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/diff-tree.c b/builtin/diff-tree.c
index 806dd7a885e9e7b87e19ca8acd2b6d0383b41d85..8ce00480cd484e10b0b46d931c934fcd3ba7b71e 100644 (file)
--- a/builtin/diff-tree.c
+++ b/builtin/diff-tree.c
@@ -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) {
                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,
                }
                diff_tree_sha1(tree1->oid.hash,
                               tree2->oid.hash,

diff --git a/builtin/diff.c b/builtin/diff.c
index 7f91f6d2267db962fb7c25e92983afd4e811d43e..3d64b8533732b5d4af971e6b1cd23ff66123e8e9 100644 (file)
--- a/builtin/diff.c
+++ b/builtin/diff.c
@@ -45,12 +45,9 @@ static void stuff_change(struct diff_options *opt,
                return;
 
        if (DIFF_OPT_TST(opt, REVERSE_DIFF)) {
                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 &&
        }
 
        if (opt->prefix &&

diff --git a/diff-no-index.c b/diff-no-index.c
index f420786039d387d3a943d510c802ecd90c3ddf28..1ae09894d7d11de86b1c0f9238222e7299d11963 100644 (file)
--- a/diff-no-index.c
+++ b/diff-no-index.c
@@ -186,9 +186,8 @@ static int queue_diff(struct diff_options *o,
 
                if (DIFF_OPT_TST(o, REVERSE_DIFF)) {
                        unsigned tmp;
 
                if (DIFF_OPT_TST(o, REVERSE_DIFF)) {
                        unsigned tmp;

-                       const char *tmp_c;

                        tmp = mode1; mode1 = mode2; mode2 = tmp;
                        tmp = mode1; mode1 = mode2; mode2 = tmp;

-                       tmp_c = name1; name1 = name2; name2 = tmp_c;
+                       SWAP(name1, name2);

                }
 
                d1 = noindex_filespec(name1, mode1);
                }
 
                d1 = noindex_filespec(name1, mode1);

diff --git a/diff.c b/diff.c
index f08cd8e033d104253a4b120f70cb188e39ef9aee..9de1ba264fea74aa09565e12fc2f5846856825fb 100644 (file)
--- a/diff.c
+++ b/diff.c
@@ -5118,13 +5118,11 @@ void diff_change(struct diff_options *options,
 
        if (DIFF_OPT_TST(options, REVERSE_DIFF)) {
                unsigned tmp;
 
        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;
+               SWAP(old_mode, new_mode);
+               SWAP(old_sha1, new_sha1);

                tmp = old_sha1_valid; old_sha1_valid = new_sha1_valid;
                        new_sha1_valid = tmp;
                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_dirty_submodule, new_dirty_submodule);

        }
 
        if (options->prefix &&
        }
 
        if (options->prefix &&

diff --git a/graph.c b/graph.c
index d4e8519c904df6e18869de527f7fe6d57adf2a26..4c722303d2d2218d26d729520cd179cb9f748674 100644 (file)
--- a/graph.c
+++ b/graph.c
@@ -997,7 +997,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;
 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;
        short used_horizontal = 0;
        int horizontal_edge = -1;
        int horizontal_edge_target = -1;


@@ -1132,9 +1131,7 @@ static void graph_output_collapsing_line(struct git_graph *graph, struct strbuf
        /*
         * Swap mapping and new_mapping
         */
        /*
         * 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
 
        /*
         * If graph->mapping indicates that all of the branch lines

diff --git a/line-range.c b/line-range.c
index de4e32f9424fbc0770756c3f61751fc69bfeb17e..323399d16cfa828adce913c9ff994e860ce2e7a5 100644 (file)
--- a/line-range.c
+++ b/line-range.c
@@ -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) {
                return -1;
 
        if (*begin && *end && *end < *begin) {

-               long tmp;
-               tmp = *end; *end = *begin; *begin = tmp;
+               SWAP(*end, *begin);

        }
 
        return 0;
        }
 
        return 0;

diff --git a/merge-recursive.c b/merge-recursive.c
index d3272094430ccd3914c8214df73ba8e11363cfa7..b7ff1ada3c350dce75ff09709395e97a60c96b96 100644 (file)
--- a/merge-recursive.c
+++ b/merge-recursive.c
@@ -1390,14 +1390,11 @@ static int process_renames(struct merge_options *o,
                        branch1 = o->branch1;
                        branch2 = o->branch2;
                } else {
                        branch1 = o->branch1;
                        branch2 = o->branch2;
                } else {

-                       struct rename *tmp;

                        renames1 = b_renames;
                        renames2Dst = &a_by_dst;
                        branch1 = o->branch2;
                        branch2 = o->branch1;
                        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)
                }
 
                if (ren1->processed)

diff --git a/object.c b/object.c
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.
                 */
                 * 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;
 }
        }
        return obj;
 }

diff --git a/pack-revindex.c b/pack-revindex.c
index 6bc7c940335cdf2d31cb38c2db6f8f6c985d3c3b..1b7ebd8d7eefbcc646867db3e52536b4aac42208 100644 (file)
--- a/pack-revindex.c
+++ b/pack-revindex.c
@@ -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) {
         * 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));
                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.
                 */
                 * 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);

        }
 
        /*
        }
 
        /*

diff --git a/prio-queue.c b/prio-queue.c
index e4365b00d6c3366e6753fc6da3fe1a165ab1222d..17252d231b31f2b8d82d7160d7b95709e14779ff 100644 (file)
--- a/prio-queue.c
+++ b/prio-queue.c
@@ -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)
 {
 
 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)
 }
 
 void prio_queue_reverse(struct prio_queue *queue)

diff --git a/strbuf.h b/strbuf.h
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)
 {
  */
 static inline void strbuf_swap(struct strbuf *a, struct strbuf *b)
 {

-       struct strbuf tmp = *a;
-       *a = *b;
-       *b = tmp;
+       SWAP(*a, *b);

 }
 
 
 }