Some safety with move arrays, small refactor appendchar

4 files changed, 40 insertions, 38 deletions

diff --git a/src/core/cube.h b/src/core/cube.h
index 49d868c..ab5f181 100644
--- a/src/core/cube.h
+++ b/src/core/cube.h
@@ -87,7 +87,7 @@ issolvable(cube_t cube)
         for (i = 0; i < 8; i++)
                 cp[i] = corner[i] & PBITS;
 
-        if (permsign(ep, 12) != permsign(cp, 8))
+        if (permsign(12, ep) != permsign(8, cp))
                 goto issolvable_parity;
 
         eo = 0;
@@ -139,13 +139,13 @@ getcube_fix(long long *ep, long long *eo, long long *cp, long long *co)
 
         indextoperm(*ep, 12, e);
         indextoperm(*cp, 8, c);
-        if (permsign(e, 12) != permsign(c, 8)) {
+        if (permsign(12, e) != permsign(8, c)) {
                 SWAP(c[0], c[1]);
-                *cp = permtoindex(c, 8);
+                *cp = permtoindex(8, c);
 
                 sumzerotodigits(*co, 8, 3, coarr);
                 SWAP(coarr[0], coarr[1]);
-                *co = digitstosumzero(coarr, 8, 3);
+                *co = digitstosumzero(8, coarr, 3);
         }
 }
 
diff --git a/src/core/io_cube.h b/src/core/io_cube.h
index 0c18f34..39f3545 100644
--- a/src/core/io_cube.h
+++ b/src/core/io_cube.h
@@ -1,5 +1,5 @@
 STATIC cube_t readcube(const char *, const char *);
-STATIC int64_t writecube(const char *, cube_t, uint64_t, char *);
+STATIC int64_t writecube(const char *, cube_t, size_t n, char [n]);
 STATIC void log_available_formats(void);
 STATIC uint8_t readco(const char *);
 STATIC uint8_t readcp(const char *);
@@ -10,10 +10,10 @@ STATIC cube_t readcube_H48(const char *);
 STATIC uint8_t readpiece_LST(const char **);
 STATIC cube_t readcube_LST(const char *);
 
-STATIC int64_t writepiece_LST(uint8_t, uint64_t, char *);
-STATIC int64_t writecube_B32(cube_t, uint64_t, char *);
-STATIC int64_t writecube_H48(cube_t, uint64_t, char *);
-STATIC int64_t writecube_LST(cube_t, uint64_t, char *);
+STATIC int64_t writepiece_LST(uint8_t, size_t n, char [n]);
+STATIC int64_t writecube_B32(cube_t, size_t n, char [n]);
+STATIC int64_t writecube_H48(cube_t, size_t n, char [n]);
+STATIC int64_t writecube_LST(cube_t, size_t n, char [n]);
 
 STATIC uint8_t b32toedge(char);
 STATIC uint8_t b32tocorner(char);
@@ -23,7 +23,7 @@ STATIC char cornertob32(uint8_t);
 STATIC struct {
         const char *name;
         cube_t (*read)(const char *);
-        int64_t (*write)(cube_t, uint64_t, char *);
+        int64_t (*write)(cube_t, size_t n, char [n]);
 } ioformat[] =
 {
         { .name = "B32", .read = readcube_B32, .write = writecube_B32 },
@@ -47,7 +47,7 @@ readcube(const char *format, const char *buf)
 }
 
 STATIC int64_t
-writecube(const char *format, cube_t cube, uint64_t buf_size, char *buf)
+writecube(const char *format, cube_t cube, size_t buf_size, char buf[buf_size])
 {
         int i;
 
@@ -233,10 +233,10 @@ readcube_LST(const char *buf)
 }
 
 STATIC int64_t
-writepiece_LST(uint8_t piece, uint64_t buf_size, char *buf)
+writepiece_LST(uint8_t piece, size_t buf_size, char buf[buf_size])
 {
         char digits[3];
-        uint64_t i, len;
+        size_t i, len;
 
         if (piece > 99 || buf_size < 3)
                 return 0;
@@ -263,7 +263,7 @@ writepiece_LST(uint8_t piece, uint64_t buf_size, char *buf)
 }
 
 STATIC int64_t
-writecube_B32(cube_t cube, uint64_t buf_size, char *buf)
+writecube_B32(cube_t cube, size_t buf_size, char buf[buf_size])
 {
         int i;
         uint8_t corner[8], edge[12];
@@ -291,7 +291,7 @@ writecube_B32(cube_t cube, uint64_t buf_size, char *buf)
 }
 
 STATIC int64_t
-writecube_H48(cube_t cube, uint64_t buf_size, char *buf)
+writecube_H48(cube_t cube, size_t buf_size, char buf[buf_size])
 {
         uint8_t piece, perm, orient, corner[8], edge[12];
         int i;
@@ -331,7 +331,7 @@ writecube_H48(cube_t cube, uint64_t buf_size, char *buf)
 }
 
 STATIC int64_t
-writecube_LST(cube_t cube, uint64_t buf_size, char *buf)
+writecube_LST(cube_t cube, size_t buf_size, char buf[buf_size])
 {
         int i;
         uint64_t ptr;
diff --git a/src/core/io_moves.h b/src/core/io_moves.h
index 806887b..fa91e8b 100644
--- a/src/core/io_moves.h
+++ b/src/core/io_moves.h
@@ -1,6 +1,6 @@
 STATIC uint8_t readmove(char);
 STATIC uint8_t readmodifier(char);
-STATIC int64_t writemoves(uint8_t *, int, uint64_t, char *);
+STATIC int64_t writemoves(size_t n, uint8_t [n], size_t m, char [m]);
 
 STATIC uint8_t
 readmove(char c)
@@ -39,11 +39,14 @@ readmodifier(char c)
 }
 
 STATIC int64_t
-writemoves(uint8_t *m, int n, uint64_t buf_size, char *buf)
+writemoves(
+        size_t nmoves,
+        uint8_t m[nmoves],
+        size_t buf_size,
+        char buf[buf_size]
+)
 {
-        int i;
-        uint64_t len;
-        int64_t written;
+        size_t i, len, written;
         const char *s;
         char *b;
 
@@ -52,7 +55,7 @@ writemoves(uint8_t *m, int n, uint64_t buf_size, char *buf)
                 return NISSY_ERROR_BUFFER_SIZE;
         }
 
-        for (i = 0, b = buf, written = 0; i < n; i++, b++, written++) {
+        for (i = 0, b = buf, written = 0; i < nmoves; i++, b++, written++) {
                 s = movestr[m[i]];
                 len = strlen(s);
                 if (len + written >= buf_size) {
@@ -70,7 +73,7 @@ writemoves(uint8_t *m, int n, uint64_t buf_size, char *buf)
                 b--; /* Remove last space */
         *b = '\0';
 
-        return written;
+        return (int64_t)written;
 
 writemoves_error:
         *buf = '\0';
diff --git a/src/core/moves.h b/src/core/moves.h
index a45bc05..820406b 100644
--- a/src/core/moves.h
+++ b/src/core/moves.h
@@ -1,8 +1,8 @@
 #define MOVE(M, c) compose(c, MOVE_CUBE_ ## M)
 #define PREMOVE(M, c) compose(MOVE_CUBE_ ## M, c)
 
-STATIC_INLINE bool allowednextmove(uint8_t *, uint8_t);
-STATIC_INLINE uint32_t allowednextmove_mask(uint8_t *, uint8_t);
+STATIC_INLINE bool allowednextmove(size_t n, const uint8_t [n]);
+STATIC_INLINE uint32_t allowednextmove_mask(size_t n, const uint8_t [n]);
 
 STATIC_INLINE uint8_t movebase(uint8_t);
 STATIC_INLINE uint8_t moveaxis(uint8_t);
@@ -13,9 +13,9 @@ STATIC_INLINE uint32_t disable_moves(uint32_t, uint8_t);
 STATIC cube_t move(cube_t, uint8_t);
 STATIC cube_t premove(cube_t, uint8_t);
 STATIC uint8_t inverse_move(uint8_t);
-STATIC void invertmoves(uint8_t *, uint8_t, uint8_t *);
-STATIC void sortparallel(uint8_t *, uint8_t);
-STATIC bool are_lastmoves_singlecw(int n, uint8_t [n]);
+STATIC void invertmoves(size_t n, const uint8_t [n], uint8_t [n]);
+STATIC void sortparallel(size_t n, uint8_t [n]);
+STATIC bool are_lastmoves_singlecw(size_t n, uint8_t [n]);
 
 STATIC int readmoves(const char *, int, uint8_t *);
 STATIC cube_t applymoves(cube_t, const char *);
@@ -40,14 +40,13 @@ STATIC cube_t applymoves(cube_t, const char *);
         }
 
 STATIC bool
-allowednextmove(uint8_t *moves, uint8_t n)
+allowednextmove(size_t n, const uint8_t moves[n])
 {
-        return n == 0 ? true :
-            allowednextmove_mask(moves, n-1) & (1 << moves[n-1]);
+        return n == 0 || allowednextmove_mask(n-1, moves) & (1 << moves[n-1]);
 }
 
 STATIC uint32_t
-allowednextmove_mask(uint8_t *moves, uint8_t n)
+allowednextmove_mask(size_t n, const uint8_t moves[n])
 {
         uint32_t result;
         uint8_t base1, base2, axis1, axis2;
@@ -79,7 +78,7 @@ allowednextmove_mask(uint8_t *moves, uint8_t n)
 STATIC_INLINE uint32_t 
 disable_moves(uint32_t current_result, uint8_t base_index)
 {
-        return current_result & ~(7 << base_index);
+        return current_result & ~MM_SIDE(base_index);
 }
 
 STATIC_INLINE uint8_t
@@ -236,17 +235,17 @@ TODO check if the issue is resolved
 #pragma GCC push_options
 #pragma GCC optimize ("O2")
 STATIC void
-invertmoves(uint8_t *moves, uint8_t nmoves, uint8_t *ret)
+invertmoves(size_t n, const uint8_t moves[n], uint8_t ret[n])
 {
         uint8_t i;
 
-        for (i = 0; i < nmoves; i++)
-                ret[i] = inverse_move(moves[nmoves - i - 1]);
+        for (i = 0; i < n; i++)
+                ret[i] = inverse_move(moves[n - i - 1]);
 }
 #pragma GCC pop_options
 
 STATIC void
-sortparallel(uint8_t *moves, uint8_t n)
+sortparallel(size_t n, uint8_t moves[n])
 {
         uint8_t i;
 
@@ -257,7 +256,7 @@ sortparallel(uint8_t *moves, uint8_t n)
 }
 
 STATIC bool
-are_lastmoves_singlecw(int n, uint8_t moves[n])
+are_lastmoves_singlecw(size_t n, uint8_t moves[n])
 {
         bool two;