4 files changed, 41 insertions, 51 deletions

diff --git a/src/solvers/coord/common.h b/src/solvers/coord/common.h
index d570b6d..8553658 100644
--- a/src/solvers/coord/common.h
+++ b/src/solvers/coord/common.h
@@ -4,9 +4,9 @@ coord_t *all_coordinates[] = {
 };
 
 STATIC void append_coord_name(const coord_t *, char *);
-STATIC coord_t *parse_coord(const char *, int);
-STATIC uint8_t parse_axis(const char *, int);
-STATIC void parse_coord_and_axis(const char *, int, coord_t **, uint8_t *);
+STATIC coord_t *parse_coord(size_t n, const char [n]);
+STATIC uint8_t parse_axis(size_t n, const char [n]);
+STATIC void parse_coord_and_axis(size_t n, const char [n], coord_t **, uint8_t *);
 STATIC int64_t dataid_coord(const char *, char [static NISSY_DATAID_SIZE]);
 
 STATIC void
@@ -22,7 +22,7 @@ append_coord_name(const coord_t *coord, char *str)
 }
 
 STATIC coord_t *
-parse_coord(const char *coord, int n)
+parse_coord(size_t n, const char coord[n])
 {
         int i;
 
@@ -34,7 +34,7 @@ parse_coord(const char *coord, int n)
 }
 
 STATIC uint8_t
-parse_axis(const char *axis, int n)
+parse_axis(size_t n, const char axis[n])
 {
         if (!strncmp(axis, "UD", n) || !strncmp(axis, "DU", n)) {
                 return AXIS_UD;
@@ -48,19 +48,24 @@ parse_axis(const char *axis, int n)
 }
 
 STATIC void
-parse_coord_and_axis(const char *str, int n, coord_t **coord, uint8_t *axis)
+parse_coord_and_axis(
+        size_t n,
+        const char str[n],
+        coord_t **coord,
+        uint8_t *axis
+)
 {
-        int i;
+        size_t i;
 
         for (i = 0; i < n; i++)
                 if (str[i] == '_')
                         break;
 
         if (coord != NULL)
-                *coord = parse_coord(str, i);
+                *coord = parse_coord(i, str);
 
         if (axis != NULL)
-                *axis = i == n ? UINT8_ERROR : parse_axis(str+i+1, n-i-1);
+                *axis = i == n ? UINT8_ERROR : parse_axis(n-i-1, str+i+1);
 }
 
 STATIC int64_t
@@ -68,7 +73,7 @@ dataid_coord(const char *ca, char dataid[static NISSY_DATAID_SIZE])
 {
         coord_t *c;
 
-        parse_coord_and_axis(ca, strlen(ca), &c, NULL);
+        parse_coord_and_axis(strlen(ca), ca, &c, NULL);
 
         if (c == NULL) {
                 LOG("dataid_coord: cannot parse coordinate from '%s'\n", ca);
diff --git a/src/solvers/coord/gendata.h b/src/solvers/coord/gendata.h
index 93ffc65..5819608 100644
--- a/src/solvers/coord/gendata.h
+++ b/src/solvers/coord/gendata.h
@@ -11,7 +11,7 @@ gendata_coord_dispatch(const char *coordstr, void *buf)
 {
         coord_t *coord;
 
-        parse_coord_and_axis(coordstr, strlen(coordstr), &coord, NULL);
+        parse_coord_and_axis(strlen(coordstr), coordstr, &coord, NULL);
 
         if (coord == NULL) {
                 LOG("Could not parse coordinate '%s'\n", coord);
@@ -137,7 +137,7 @@ getdistribution_coord(
 
         memset(distr, 0, INFO_DISTRIBUTION_LEN * sizeof(uint64_t));
 
-        if((c = parse_coord(coord, strlen(coord))) == NULL)
+        if((c = parse_coord(strlen(coord), coord)) == NULL)
                 return;
 
         for (i = 0; i < c->max; i++) {
diff --git a/src/solvers/coord/solve.h b/src/solvers/coord/solve.h
index 6903d1e..fa160f8 100644
--- a/src/solvers/coord/solve.h
+++ b/src/solvers/coord/solve.h
@@ -1,10 +1,8 @@
-#define MAXLEN_COORDSOL 20
-
 typedef struct {
         cube_t cube;
         uint8_t depth;
         uint8_t nmoves;
-        uint8_t moves[MAXLEN_COORDSOL];
+        uint8_t moves[MAXLEN];
         coord_t *coord;
         const void *coord_data;
         const uint8_t *ptable;
@@ -13,23 +11,22 @@ typedef struct {
         int64_t maxsolutions;
         int optimal;
         uint8_t *shortest_sol;
-        uint64_t solutions_size;
-        uint64_t *solutions_used;
+        size_t solutions_size;
+        size_t *solutions_used;
         char **solutions;
 } dfsarg_solve_coord_t;
 
 STATIC int64_t solve_coord(cube_t, coord_t *, uint8_t, uint8_t, uint8_t,
-    uint8_t, uint64_t, int, int, uint64_t, const void *, uint64_t, char *);
+    uint8_t, uint64_t, int, int, uint64_t, const void *, size_t, char *);
 STATIC int64_t solve_coord_dispatch(cube_t, const char *, uint8_t, uint8_t,
-     uint8_t, uint64_t, int, int, uint64_t, const void *, uint64_t, char *);
-STATIC bool solve_coord_appendchar(char *, uint64_t, uint64_t *, char);
+     uint8_t, uint64_t, int, int, uint64_t, const void *, size_t, char *);
 STATIC int64_t solve_coord_appendsolution(dfsarg_solve_coord_t *);
 STATIC int64_t solve_coord_dfs(dfsarg_solve_coord_t *);
 
 STATIC int64_t
 solve_coord_appendsolution(dfsarg_solve_coord_t *arg)
 {
-        uint8_t i, t, tmoves[MAXLEN_COORDSOL];
+        uint8_t i, t, tmoves[MAXLEN];
         int64_t strl;
         uint64_t l;
         char *m;
@@ -44,18 +41,18 @@ solve_coord_appendsolution(dfsarg_solve_coord_t *arg)
         for (i = 0; i < arg->nmoves; i++)
                 tmoves[i] = transform_move(arg->moves[i], t);
 
-        sortparallel(tmoves, arg->nmoves);
+        sortparallel(arg->nmoves, tmoves);
 
         l = arg->solutions_size - *arg->solutions_used;
         m = *arg->solutions + *arg->solutions_used;
-        strl = writemoves(tmoves, arg->nmoves, l, m);
+        strl = writemoves(arg->nmoves, tmoves, l, m);
         if (strl < 0)
                 goto solve_coord_appendsolution_error;
 
         *arg->solutions_used += MAX(0, strl-1);
 
-        if (!solve_coord_appendchar(
-            *arg->solutions, arg->solutions_size, arg->solutions_used, '\n'))
+        if (!appendchar(
+            arg->solutions_size, *arg->solutions, arg->solutions_used, '\n'))
                 goto solve_coord_appendsolution_error;
 
         (*arg->nsols)++;
@@ -68,18 +65,6 @@ solve_coord_appendsolution_error:
         return NISSY_ERROR_BUFFER_SIZE;
 }
 
-STATIC bool
-solve_coord_appendchar(char *s, uint64_t s_size, uint64_t *s_used, char c)
-{
-        if (s_size == *s_used)
-                return false;
-
-        s[*s_used] = c;
-        (*s_used)++;
-
-        return true;
-}
-
 STATIC int64_t
 solve_coord_dfs(dfsarg_solve_coord_t *arg)
 {
@@ -104,7 +89,7 @@ solve_coord_dfs(dfsarg_solve_coord_t *arg)
         backup_cube = arg->cube;
 
         ret = 0;
-        mm = allowednextmove_mask(arg->moves, arg->nmoves);
+        mm = allowednextmove_mask(arg->nmoves, arg->moves);
         arg->nmoves++;
         for (m = 0; m < 18; m++) {
                 if (!(mm & (1 << m)))
@@ -135,7 +120,7 @@ solve_coord_dispatch(
         int threads,
         uint64_t data_size,
         const void *data,
-        uint64_t sols_size,
+        size_t solutions_size,
         char *sols
 )
 {
@@ -143,7 +128,7 @@ solve_coord_dispatch(
         uint8_t axis;
 
         parse_coord_and_axis(
-            coord_and_axis, strlen(coord_and_axis), &coord, &axis);
+            strlen(coord_and_axis), coord_and_axis, &coord, &axis);
 
         if (coord == NULL) {
                 LOG("Could not parse coordinate from '%s'\n", coord_and_axis);
@@ -156,7 +141,8 @@ solve_coord_dispatch(
         }
 
         return solve_coord(cube, coord, axis, nissflag, minmoves, maxmoves,
-            maxsolutions, optimal, threads, data_size, data, sols_size, sols);
+            maxsolutions, optimal, threads, data_size, data,
+            solutions_size, sols);
 }
 
 STATIC int64_t
@@ -172,14 +158,14 @@ solve_coord(
         int threads,
         uint64_t data_size,
         const void *data,
-        uint64_t sols_size,
+        size_t solutions_size,
         char *sols
 )
 {
         int8_t d;
         uint8_t t, shortest_sol;
         int64_t nsols, ndepth;
-        uint64_t sols_used;
+        size_t solutions_used;
         cube_t c;
         const void *coord_data;
         const uint8_t *ptable;
@@ -200,8 +186,8 @@ solve_coord(
         }
 
         nsols = 0;
-        sols_used = 0;
-        shortest_sol = MAXLEN_COORDSOL + 1;
+        solutions_used = 0;
+        shortest_sol = MAXLEN + 1;
         t = coord->axistrans[axis];
         c = transform(cube, t);
 
@@ -215,16 +201,15 @@ solve_coord(
                 .maxsolutions = (int64_t)maxsolutions,
                 .optimal = optimal,
                 .shortest_sol = &shortest_sol,
-                .solutions_size = sols_size,
-                .solutions_used = &sols_used,
+                .solutions_size = solutions_size,
+                .solutions_used = &solutions_used,
                 .solutions = &sols,
         };
 
         if (coord->coord(c, coord_data) == 0) {
                 if (minmoves == 0) {
                         nsols = 1;
-                        if (!solve_coord_appendchar(
-                            sols, sols_size, &sols_used, '\n'))
+                        if (!appendchar(solutions_size, sols, &solutions_used, '\n'))
                                 goto solve_coord_error_buffer;
                 }
                 goto solve_coord_done;
@@ -254,7 +239,7 @@ solve_coord(
         }
 
 solve_coord_done:
-        if (!solve_coord_appendchar(sols, sols_size, &sols_used, '\0'))
+        if (!appendchar(solutions_size, sols, &solutions_used, '\0'))
                 goto solve_coord_error_buffer;
 
         return nsols;
diff --git a/src/solvers/coord/types_macros.h b/src/solvers/coord/types_macros.h
index 2309efc..f2d436c 100644
--- a/src/solvers/coord/types_macros.h
+++ b/src/solvers/coord/types_macros.h
@@ -11,5 +11,5 @@ typedef struct {
         uint32_t moves_mask;
         uint64_t trans_mask;
         uint8_t axistrans[3];
-        bool (*is_admissible)(int n, uint8_t [n]);
+        bool (*is_admissible)(size_t n, uint8_t [n]);
 } coord_t;