shithub: puzzles

Info  •  Files  •  Log  •  Branches

Use a dedicated copy function to copy dsfs.

Previously we were duplicating the contents of a dsf using straight-up
memcpy. Now there's a dsf_copy function wrapping the same memcpy.

For the moment, this still has to take a size parameter, because the
size isn't stored inside the dsf itself. But once we make a proper
data type, it will be.

--- a/bridges.c

+++ b/bridges.c

@@ -1551,7 +1551,7 @@

         maxb = -1;

         /* We have to squirrel the dsf away and restore it afterwards;

          * it is additive only, and can't be removed from. */

-        memcpy(ss->tmpdsf, ss->dsf, wh*sizeof(int));

+        dsf_copy(ss->tmpdsf, ss->dsf, wh);

         for (n = curr+1; n <= curr+spc; n++) {

             solve_join(is, i, n, false);

             map_update_possibles(is->state);

@@ -1567,7 +1567,7 @@

             }

         }

         solve_join(is, i, curr, false); /* put back to before. */

-        memcpy(ss->dsf, ss->tmpdsf, wh*sizeof(int));

+        dsf_copy(ss->dsf, ss->tmpdsf, wh);

         if (maxb != -1) {

             /*debug_state(is->state);*/

@@ -1636,7 +1636,7 @@

                                   is->adj.points[j].dx ? G_LINEH : G_LINEV);

         if (before[i] != 0) continue;  /* this idea is pointless otherwise */

-        memcpy(ss->tmpdsf, ss->dsf, wh*sizeof(int));

+        dsf_copy(ss->tmpdsf, ss->dsf, wh);

         for (j = 0; j < is->adj.npoints; j++) {

             spc = island_adjspace(is, true, missing, j);

@@ -1651,7 +1651,7 @@

         for (j = 0; j < is->adj.npoints; j++)

             solve_join(is, j, before[j], false);

-        memcpy(ss->dsf, ss->tmpdsf, wh*sizeof(int));

+        dsf_copy(ss->dsf, ss->tmpdsf, wh);

         if (got) {

             debug(("island at (%d,%d) must connect in direction (%d,%d) to"

--- a/dsf.c

+++ b/dsf.c

@@ -74,6 +74,11 @@

      * bits are the number of elements in the tree.  */

 }

+void dsf_copy(int *to, int *from, int size)

+{

+    memcpy(to, from, size * sizeof(int));

+}

+

 int *snew_dsf(int size)

 {

     int *ret;

--- a/loopy.c

+++ b/loopy.c

@@ -457,8 +457,7 @@

     ret->dotdsf = snewn(num_dots, int);

     ret->looplen = snewn(num_dots, int);

-    memcpy(ret->dotdsf, sstate->dotdsf,

-           num_dots * sizeof(int));

+    dsf_copy(ret->dotdsf, sstate->dotdsf, num_dots);

     memcpy(ret->looplen, sstate->looplen,

            num_dots * sizeof(int));

@@ -487,8 +486,7 @@

     if (sstate->linedsf) {

         ret->linedsf = snewn(num_edges, int);

-        memcpy(ret->linedsf, sstate->linedsf,

-               num_edges * sizeof(int));

+        dsf_copy(ret->linedsf, sstate->linedsf, num_edges);

     } else {

         ret->linedsf = NULL;

     }

--- a/puzzles.h

+++ b/puzzles.h

@@ -431,6 +431,8 @@

 void print_dsf(int *dsf, int size);

+void dsf_copy(int *to, int *from, int size);

+

 /* Return the canonical element of the equivalence class containing element

  * val.  If 'inverse' is non-NULL, this function will put into it a flag

  * indicating whether the canonical element is inverse to val. */

--- a/signpost.c

+++ b/signpost.c

@@ -482,7 +482,7 @@

     memcpy(to->next, from->next, to->n*sizeof(int));

     memcpy(to->prev, from->prev, to->n*sizeof(int));

-    memcpy(to->dsf, from->dsf, to->n*sizeof(int));

+    dsf_copy(to->dsf, from->dsf, to->n);

     memcpy(to->numsi, from->numsi, (to->n+1)*sizeof(int));

 }