Make the project build with Microsoft's broken C compiler.

MSVC is not fully C11-compliant, even when compiling with /std:c11.
Some changes were needed to make the codebase compatible. Notably, the
notation a[static N] and a[n] for function parameters of array type is
not supported, so that had to be hidden behind a macro.  Atomic types
are also an experimental feature, apparently, but at least they work
with the correct compiler flag.

One thing that MSVC does well, however, is warning on integer conversions
on /W4 level. I am not sure if Clang and GCC have something similar,
so I took this chance to fix some of these.

7 files changed, 89 insertions, 84 deletions

diff --git a/src/solvers/coord/common.h b/src/solvers/coord/common.h
index d154636..3a62e85 100644
--- a/src/solvers/coord/common.h
+++ b/src/solvers/coord/common.h
@@ -1,16 +1,16 @@
 STATIC uint64_t coord_coord_generic(
-    const coord_t [static 1], cube_t, const unsigned char *);
+    const coord_t [NON_NULL], cube_t, const unsigned char *);
 STATIC cube_t coord_cube_generic(
-    const coord_t [static 1], uint64_t, const unsigned char *);
+    const coord_t [NON_NULL], uint64_t, const unsigned char *);
 STATIC bool coord_isnasty_generic(
-    const coord_t [static 1], uint64_t, const unsigned char *);
-STATIC size_t coord_gendata_generic(const coord_t [static 1], unsigned char *);
+    const coord_t [NON_NULL], uint64_t, const unsigned char *);
+STATIC size_t coord_gendata_generic(const coord_t [NON_NULL], unsigned char *);
 
-STATIC bool solution_lastqt_cw(const solution_moves_t [static 1]);
-STATIC bool coord_can_switch(const coord_t [static 1], const unsigned char *,
+STATIC bool solution_lastqt_cw(const solution_moves_t [NON_NULL]);
+STATIC bool coord_can_switch(const coord_t [NON_NULL], const unsigned char *,
     size_t, const uint8_t *);
 STATIC bool coord_is_solved(
-    const coord_t [static 1], uint64_t, const unsigned char *);
+    const coord_t [NON_NULL], uint64_t, const unsigned char *);
 
 STATIC cube_t coordinate_merge_ce(cube_t, cube_t);
 STATIC cube_t coordinate_merge_ec(cube_t, cube_t);
@@ -18,7 +18,7 @@ STATIC cube_t coordinate_merge_cpco(cube_t, cube_t);
 
 STATIC uint64_t
 coord_coord_generic(
-        const coord_t coord[static 1],
+        const coord_t coord[NON_NULL],
         cube_t c,
         const unsigned char *data
 )
@@ -36,7 +36,7 @@ coord_coord_generic(
 
 STATIC cube_t
 coord_cube_generic(
-        const coord_t coord[static 1],
+        const coord_t coord[NON_NULL],
         uint64_t i,
         const unsigned char *data
 )
@@ -54,7 +54,7 @@ coord_cube_generic(
 
 STATIC bool
 coord_isnasty_generic(
-        const coord_t coord[static 1],
+        const coord_t coord[NON_NULL],
         uint64_t i,
         const unsigned char *data
 )
@@ -73,11 +73,12 @@ coord_isnasty_generic(
 
 STATIC size_t
 coord_gendata_generic(
-        const coord_t coord[static 1],
+        const coord_t coord[NON_NULL],
         unsigned char *data
 )
 {
-        uint64_t i, j, n, t, nasty;
+        uint64_t i, j, n, nasty;
+        uint8_t t;
         unsigned char *datanoinfo;
         uint32_t *classttrep, *rep;
         size_t coord_datasize;
@@ -122,16 +123,17 @@ coord_gendata_generic(
                 }
 
                 for (t = 0; t < NTRANS; t++) {
-                        if (!((UINT64_C(1) << t) & coord->trans_mask))
+                        if (!((UINT64_C(1) << (uint64_t)t) & coord->trans_mask))
                                 continue;
 
                         j = coord->sym.coord(transform(c, t));
-                        classttrep[j] =
+                        classttrep[j] = (uint32_t)(
                             (n << COORD_CLASS_SHIFT) |
                             (nasty << COORD_ISNASTY_SHIFT) |
-                            (inverse_trans(t) << COORD_TTREP_SHIFT);
+                            (inverse_trans(t) << COORD_TTREP_SHIFT)
+                        );
                 }
-                rep[n++] = i;
+                rep[n++] = (uint32_t)i;
         }
 
         writetableinfo(&info, coord_datasize, data);
@@ -144,21 +146,21 @@ coord_gendata_generic(
 }
 
 STATIC bool
-solution_lastqt_cw(const solution_moves_t s[static 1])
+solution_lastqt_cw(const solution_moves_t s[NON_NULL])
 {
         return are_lastmoves_singlecw(s->nmoves, s->moves) &&
             are_lastmoves_singlecw(s->npremoves, s->premoves);
 }
 
 STATIC bool
-solution_always_valid(const solution_moves_t s[static 1])
+solution_always_valid(const solution_moves_t s[NON_NULL])
 {
         return true;
 }
 
 STATIC bool
 coord_can_switch(
-        const coord_t coord[static 1],
+        const coord_t coord[NON_NULL],
         const unsigned char *data,
         size_t n,
         const uint8_t *moves
@@ -192,7 +194,7 @@ coord_can_switch(
 
 STATIC bool
 coord_is_solved(
-        const coord_t coord[static 1],
+        const coord_t coord[NON_NULL],
         uint64_t i,
         const unsigned char *data
 )
diff --git a/src/solvers/coord/gendata.h b/src/solvers/coord/gendata.h
index cbc8774..edf6ce6 100644
--- a/src/solvers/coord/gendata.h
+++ b/src/solvers/coord/gendata.h
@@ -1,21 +1,21 @@
-STATIC size_t gendata_coord(const coord_t [static 1], unsigned char *);
+STATIC size_t gendata_coord(const coord_t [NON_NULL], unsigned char *);
 STATIC size_t gendata_multicoord(
-    const multicoord_t [static 1], unsigned char *);
+    const multicoord_t [NON_NULL], unsigned char *);
 STATIC long long gendata_coord_dispatch(const char *, unsigned long long,
     unsigned char *);
 STATIC tableinfo_t genptable_coord(
-    const coord_t [static 1], const unsigned char *, unsigned char *);
+    const coord_t [NON_NULL], const unsigned char *, unsigned char *);
 STATIC uint64_t genptable_coord_init_solved(
-    const coord_t [static 1], const unsigned char *, unsigned char *);
+    const coord_t [NON_NULL], const unsigned char *, unsigned char *);
 STATIC bool switch_to_fromnew(uint64_t, uint64_t, uint64_t);
-STATIC uint64_t genptable_coord_fillneighbors(const coord_t [static 1],
+STATIC uint64_t genptable_coord_fillneighbors(const coord_t [NON_NULL],
     const unsigned char *, uint64_t, uint8_t, unsigned char *);
-STATIC uint64_t genptable_coord_fillfromnew(const coord_t [static 1],
+STATIC uint64_t genptable_coord_fillfromnew(const coord_t [NON_NULL],
     const unsigned char *, uint64_t, uint8_t, unsigned char *);
 STATIC uint8_t get_coord_pval(
-    const coord_t [static 1], const unsigned char *, uint64_t);
+    const coord_t [NON_NULL], const unsigned char *, uint64_t);
 STATIC void set_coord_pval(
-    const coord_t [static 1], unsigned char *, uint64_t, uint8_t);
+    const coord_t [NON_NULL], unsigned char *, uint64_t, uint8_t);
 
 STATIC long long
 gendata_coord_dispatch(
@@ -40,7 +40,7 @@ gendata_coord_dispatch(
 }
 
 STATIC size_t
-gendata_coord(const coord_t coord[static 1], unsigned char *buf)
+gendata_coord(const coord_t coord[NON_NULL], unsigned char *buf)
 {
         uint64_t coord_dsize, tablesize, ninfo;
         unsigned char *pruningbuf, *coord_data;
@@ -96,7 +96,7 @@ gendata_coord_error:
 }
 
 STATIC size_t
-gendata_multicoord(const multicoord_t mcoord[static 1], unsigned char *buf)
+gendata_multicoord(const multicoord_t mcoord[NON_NULL], unsigned char *buf)
 {
         unsigned char *b;
         size_t i, s, ret;
@@ -141,12 +141,13 @@ gendata_multicoord(const multicoord_t mcoord[static 1], unsigned char *buf)
 
 STATIC tableinfo_t
 genptable_coord(
-        const coord_t coord[static 1],
+        const coord_t coord[NON_NULL],
         const unsigned char *data,
         unsigned char *table
 )
 {
-        uint64_t tablesize, i, d, tot, t, nm;
+        uint64_t tablesize, i, tot, t, nm;
+        uint8_t d;
         tableinfo_t info;
 
         tablesize = DIV_ROUND_UP(coord->max, 2);
@@ -170,7 +171,7 @@ genptable_coord(
 
         tot = info.distribution[0] =
             genptable_coord_init_solved(coord, data, table);
-        nm = popcount_u32(coord->moves_mask_gendata);
+        nm = popcount_u64(coord->moves_mask_gendata);
         for (d = 1; tot < coord->max && d < 15; d++) {
                 t = 0;
                 if (switch_to_fromnew(tot, coord->max, nm)) {
@@ -204,7 +205,7 @@ genptable_coord(
 
 STATIC uint64_t
 genptable_coord_init_solved(
-        const coord_t coord[static 1],
+        const coord_t coord[NON_NULL],
         const unsigned char *coord_data,
         unsigned char *table
 )
@@ -238,7 +239,7 @@ switch_to_fromnew(uint64_t done, uint64_t max, uint64_t nm)
 
 STATIC uint64_t
 genptable_coord_fillneighbors(
-        const coord_t coord[static 1],
+        const coord_t coord[NON_NULL],
         const unsigned char *data,
         uint64_t i, 
         uint8_t d,
@@ -247,20 +248,21 @@ genptable_coord_fillneighbors(
 {
         bool isnasty;
         uint8_t m;
-        uint64_t ii, j, t, tot;
+        uint64_t ii, j, tot;
+        uint8_t t;
         cube_t c, moved;
 
         c = coord->cube(i, data);
         tot = 0;
         for (m = 0; m < NMOVES; m++) {
-                if (!((UINT32_C(1) << (uint32_t)m) &
+                if (!((UINT64_C(1) << (uint64_t)m) &
                     coord->moves_mask_gendata))
                         continue;
                 moved = move(c, m);
                 ii = coord->coord(moved, data);
                 isnasty = coord->isnasty(ii, data);
                 for (t = 0; t < NTRANS && (t == 0 || isnasty); t++) {
-                        if (!((UINT64_C(1) << t) & coord->trans_mask))
+                        if (!((UINT64_C(1) << (uint64_t)t) & coord->trans_mask))
                                 continue;
 
                         j = coord->coord(transform(moved, t), data);
@@ -276,7 +278,7 @@ genptable_coord_fillneighbors(
 
 STATIC uint64_t
 genptable_coord_fillfromnew(
-        const coord_t coord[static 1],
+        const coord_t coord[NON_NULL],
         const unsigned char *data,
         uint64_t i,
         uint8_t d,
@@ -285,14 +287,15 @@ genptable_coord_fillfromnew(
 {
         bool found;
         uint8_t m;
-        uint64_t tot, t, ii, j, nsim, sim[NTRANS];
+        uint64_t tot, j, ii, nsim, sim[NTRANS];
+        uint8_t t;
         cube_t c;
 
         tot = 0;
         c = coord->cube(i, data);
 
         for (t = 0, nsim = 0; t < NTRANS; t++) {
-                if (!((UINT64_C(1) << t) & coord->trans_mask))
+                if (!((UINT64_C(1) << (uint64_t)t) & coord->trans_mask))
                         continue;
 
                 ii = coord->coord(transform(c, t), data);
@@ -305,7 +308,7 @@ genptable_coord_fillfromnew(
         for (j = 0, found = false; j < nsim && !found; j++) {
                 c = coord->cube(sim[j], data);
                 for (m = 0; m < NMOVES; m++) {
-                        if (!((UINT32_C(1) << (uint32_t)m) &
+                        if (!((UINT64_C(1) << (uint64_t)m) &
                             coord->moves_mask_gendata))
                                 continue;
                         ii = coord->coord(move(c, m), data);
@@ -331,7 +334,7 @@ genptable_coord_fillfromnew(
 
 STATIC uint8_t
 get_coord_pval(
-        const coord_t coord[static 1],
+        const coord_t coord[NON_NULL],
         const unsigned char *table,
         uint64_t i
 )
@@ -341,7 +344,7 @@ get_coord_pval(
 
 STATIC void
 set_coord_pval(
-        const coord_t coord[static 1],
+        const coord_t coord[NON_NULL],
         unsigned char *table,
         uint64_t i,
         uint8_t val
diff --git a/src/solvers/coord/htr.h b/src/solvers/coord/htr.h
index cfd451b..602625b 100644
--- a/src/solvers/coord/htr.h
+++ b/src/solvers/coord/htr.h
@@ -4,7 +4,7 @@ STATIC bool coordinate_htr_isnasty(uint64_t, const unsigned char *);
 STATIC size_t coordinate_htr_gendata(unsigned char *);
 
 STATIC bool htr_checkmoves(bool *, uint8_t, const uint8_t *);
-STATIC bool htr_solution_prune(const solution_moves_t [static 1]);
+STATIC bool htr_solution_prune(const solution_moves_t [NON_NULL]);
 STATIC bool is_cp_htr(uint64_t, const unsigned char *);
 
 STATIC coord_t coordinate_htr = {
@@ -97,7 +97,7 @@ htr_checkmoves(bool *f, uint8_t n, const uint8_t *moves)
 }
 
 STATIC bool
-htr_solution_prune(const solution_moves_t s[static 1])
+htr_solution_prune(const solution_moves_t s[NON_NULL])
 {
         bool f;
 
diff --git a/src/solvers/coord/multisolve.h b/src/solvers/coord/multisolve.h
index a45bd6a..efd287d 100644
--- a/src/solvers/coord/multisolve.h
+++ b/src/solvers/coord/multisolve.h
@@ -16,20 +16,20 @@ typedef struct {
         const unsigned char *ptable[MAX_MULTICOORD_NCOORDS];
 } dfsarg_solve_multicoord_t;
 
-STATIC int64_t solve_multicoord(oriented_cube_t, multicoord_t [static 1],
+STATIC int64_t solve_multicoord(oriented_cube_t, multicoord_t [NON_NULL],
     uint8_t, uint8_t, uint8_t, uint64_t, uint8_t, uint8_t, uint64_t,
     const unsigned char *, size_t, char *, int (*)(void *), void *);
 STATIC long long solve_multicoord_dispatch(oriented_cube_t, const char *,
     unsigned, unsigned, unsigned, unsigned, unsigned, unsigned,
     unsigned long long, const unsigned char *, unsigned, char *,
-    long long [static NISSY_SIZE_SOLVE_STATS], int (*)(void *), void *);
+    long long [SIZE(NISSY_SIZE_SOLVE_STATS)], int (*)(void *), void *);
 STATIC bool multicoord_solution_admissible(
-    const dfsarg_solve_multicoord_t [static 1]);
-STATIC bool multicoord_dfs_stop(const dfsarg_solve_multicoord_t [static 1]);
-STATIC int64_t solve_multicoord_dfs(dfsarg_solve_multicoord_t [static 1]);
+    const dfsarg_solve_multicoord_t [NON_NULL]);
+STATIC bool multicoord_dfs_stop(const dfsarg_solve_multicoord_t [NON_NULL]);
+STATIC int64_t solve_multicoord_dfs(dfsarg_solve_multicoord_t [NON_NULL]);
 
 STATIC bool
-multicoord_solution_admissible(const dfsarg_solve_multicoord_t arg[static 1])
+multicoord_solution_admissible(const dfsarg_solve_multicoord_t arg[NON_NULL])
 {
         uint8_t n, i;
         const coord_t *c;
@@ -49,7 +49,7 @@ multicoord_solution_admissible(const dfsarg_solve_multicoord_t arg[static 1])
 }
 
 STATIC bool
-multicoord_dfs_stop(const dfsarg_solve_multicoord_t arg[static 1])
+multicoord_dfs_stop(const dfsarg_solve_multicoord_t arg[NON_NULL])
 {
         uint8_t pval, i;
         uint64_t cval;
@@ -69,11 +69,10 @@ multicoord_dfs_stop(const dfsarg_solve_multicoord_t arg[static 1])
 }
 
 STATIC int64_t
-solve_multicoord_dfs(dfsarg_solve_multicoord_t arg[static 1])
+solve_multicoord_dfs(dfsarg_solve_multicoord_t arg[NON_NULL])
 {
         uint8_t m, l, i;
-        uint32_t mm;
-        uint64_t coord;
+        uint64_t mm, coord;
         int64_t n, ret;
         const coord_t *c;
         cube_t backup_cube, backup_inverse;
@@ -108,7 +107,7 @@ solve_multicoord_dfs_notsolved:
         arg->solution_moves->nmoves++;
 
         for (m = 0; m < NMOVES; m++) {
-                if (!(mm & (UINT32_C(1) << (uint32_t)m)))
+                if (!(mm & (UINT64_C(1) << (uint64_t)m)))
                         continue;
 
                 arg->solution_moves->moves[l] = m;
@@ -141,7 +140,7 @@ solve_multicoord_dispatch(
         const unsigned char *data,
         unsigned solutions_size,
         char *sols,
-        long long stats[static NISSY_SIZE_SOLVE_STATS],
+        long long stats[SIZE(NISSY_SIZE_SOLVE_STATS)],
         int (*poll_status)(void *),
         void *poll_status_data
 )
@@ -163,15 +162,16 @@ solve_multicoord_dispatch(
                 return NISSY_ERROR_INVALID_SOLVER;
         }
 
-        return solve_multicoord(oc, mcoord, trans, minmoves,
-            maxmoves, maxsolutions, optimal, threads, data_size, data,
-            solutions_size, sols, poll_status, poll_status_data);
+        return solve_multicoord(oc, mcoord, trans, (uint8_t)minmoves,
+            (uint8_t)maxmoves, (uint8_t)maxsolutions, (uint8_t)optimal,
+                (uint8_t)threads, data_size, data, solutions_size, sols,
+                poll_status, poll_status_data);
 }
 
 STATIC int64_t
 solve_multicoord(
         oriented_cube_t oc,
-        multicoord_t mcoord [static 1],
+        multicoord_t mcoord [NON_NULL],
         uint8_t trans,
         uint8_t minmoves,
         uint8_t maxmoves,
diff --git a/src/solvers/coord/solve.h b/src/solvers/coord/solve.h
index 9ea6d1a..6bb9af2 100644
--- a/src/solvers/coord/solve.h
+++ b/src/solvers/coord/solve.h
@@ -13,20 +13,20 @@ typedef struct {
         const unsigned char *ptable;
 } dfsarg_solve_coord_t;
 
-STATIC int64_t solve_coord(oriented_cube_t, coord_t [static 1], uint8_t,
+STATIC int64_t solve_coord(oriented_cube_t, coord_t [NON_NULL], uint8_t,
     uint8_t, uint8_t, uint8_t, uint64_t, uint8_t, uint8_t, uint64_t,
     const unsigned char *, size_t, char *, int (*)(void *), void *);
 STATIC long long solve_coord_dispatch(oriented_cube_t, const char *, unsigned,
     unsigned, unsigned, unsigned, unsigned, unsigned, unsigned long long,
     const unsigned char *, unsigned, char *,
-    long long [static NISSY_SIZE_SOLVE_STATS], int (*)(void *), void *);
-STATIC bool coord_solution_admissible(const dfsarg_solve_coord_t [static 1]);
-STATIC bool coord_continue_onnormal(const dfsarg_solve_coord_t [static 1]);
-STATIC bool coord_continue_oninverse(const dfsarg_solve_coord_t [static 1]);
-STATIC int64_t solve_coord_dfs(dfsarg_solve_coord_t [static 1]);
+    long long [SIZE(NISSY_SIZE_SOLVE_STATS)], int (*)(void *), void *);
+STATIC bool coord_solution_admissible(const dfsarg_solve_coord_t [NON_NULL]);
+STATIC bool coord_continue_onnormal(const dfsarg_solve_coord_t [NON_NULL]);
+STATIC bool coord_continue_oninverse(const dfsarg_solve_coord_t [NON_NULL]);
+STATIC int64_t solve_coord_dfs(dfsarg_solve_coord_t [NON_NULL]);
 
 STATIC bool
-coord_solution_admissible(const dfsarg_solve_coord_t arg[static 1])
+coord_solution_admissible(const dfsarg_solve_coord_t arg[NON_NULL])
 {
         uint8_t n;
 
@@ -39,7 +39,7 @@ coord_solution_admissible(const dfsarg_solve_coord_t arg[static 1])
 }
 
 STATIC bool
-coord_continue_onnormal(const dfsarg_solve_coord_t arg[static 1])
+coord_continue_onnormal(const dfsarg_solve_coord_t arg[NON_NULL])
 {
         uint8_t flag, nn, ni, swbound_n, swbound_i, pval;
         uint64_t coord;
@@ -93,7 +93,7 @@ coord_continue_onnormal(const dfsarg_solve_coord_t arg[static 1])
 }
 
 STATIC bool
-coord_continue_oninverse(const dfsarg_solve_coord_t arg[static 1])
+coord_continue_oninverse(const dfsarg_solve_coord_t arg[NON_NULL])
 {
         uint8_t flag, nn, ni, swbound_n, swbound_i, pval;
         uint64_t coord;
@@ -147,12 +147,11 @@ coord_continue_oninverse(const dfsarg_solve_coord_t arg[static 1])
 }
 
 STATIC int64_t
-solve_coord_dfs(dfsarg_solve_coord_t arg[static 1])
+solve_coord_dfs(dfsarg_solve_coord_t arg[NON_NULL])
 {
         bool lastbackup;
         uint8_t m, l, nnbackup, nibackup, nmoves;
-        uint32_t mm;
-        uint64_t coord;
+        uint64_t mm, coord;
         int64_t n, ret;
         cube_t backup_cube, backup_inverse;
 
@@ -190,7 +189,7 @@ solve_coord_dfs(dfsarg_solve_coord_t arg[static 1])
                 arg->lastisnormal = true;
 
                 for (m = 0; m < NMOVES; m++) {
-                        if (!(mm & (UINT32_C(1) << (uint32_t)m)))
+                        if (!(mm & (UINT64_C(1) << (uint64_t)m)))
                                 continue;
 
                         arg->solution_moves->moves[l] = m;
@@ -221,7 +220,7 @@ solve_coord_dfs(dfsarg_solve_coord_t arg[static 1])
                 arg->lastisnormal = false;
                 
                 for (m = 0; m < NMOVES; m++) {
-                        if (!(mm & (UINT32_C(1) << (uint32_t)m)))
+                        if (!(mm & (UINT64_C(1) << (uint64_t)m)))
                                 continue;
 
                         arg->solution_moves->premoves[l] = m;
@@ -258,7 +257,7 @@ solve_coord_dispatch(
         const unsigned char *data,
         unsigned solutions_size,
         char *sols,
-        long long stats[static NISSY_SIZE_SOLVE_STATS],
+        long long stats[SIZE(NISSY_SIZE_SOLVE_STATS)],
         int (*poll_status)(void *),
         void *poll_status_data
 )
@@ -280,15 +279,16 @@ solve_coord_dispatch(
                 return NISSY_ERROR_INVALID_SOLVER;
         }
 
-        return solve_coord(oc, coord, trans, nissflag, minmoves, maxmoves,
-            maxsolutions, optimal, threads, data_size, data,
+        return solve_coord(oc, coord, trans, (uint8_t)nissflag,
+            (uint8_t)minmoves, (uint8_t)maxmoves, (uint8_t)maxsolutions,
+                (uint8_t)optimal, (uint8_t)threads, data_size, data,
             solutions_size, sols, poll_status, poll_status_data);
 }
 
 STATIC int64_t
 solve_coord(
         oriented_cube_t oc,
-        coord_t coord [static 1],
+        coord_t coord [NON_NULL],
         uint8_t trans,
         uint8_t nissflag,
         uint8_t minmoves,
diff --git a/src/solvers/coord/types_macros.h b/src/solvers/coord/types_macros.h
index b75fab8..81db9d4 100644
--- a/src/solvers/coord/types_macros.h
+++ b/src/solvers/coord/types_macros.h
@@ -27,8 +27,8 @@ typedef struct {
         uint64_t moves_mask_gendata;
         uint64_t moves_mask_solve;
         uint64_t trans_mask;
-        bool (*is_admissible)(const solution_moves_t[static 1]);
-        bool (*solution_prune)(const solution_moves_t[static 1]);
+        bool (*is_admissible)(const solution_moves_t[NON_NULL]);
+        bool (*solution_prune)(const solution_moves_t[NON_NULL]);
         bool (*is_solvable)(cube_t);
         /* if is_solved is null, coord == 0 is used */
         bool (*is_solved)(uint64_t, const unsigned char *);
diff --git a/src/solvers/coord/utils.h b/src/solvers/coord/utils.h
index c8a9338..0062587 100644
--- a/src/solvers/coord/utils.h
+++ b/src/solvers/coord/utils.h
@@ -2,7 +2,7 @@ STATIC coord_t *parse_coord(size_t, const char *);
 STATIC multicoord_t *parse_multicoord(size_t, const char *);
 STATIC void parse_coord_and_trans(
     const char *, coord_t **, multicoord_t **, uint8_t *);
-STATIC long long dataid_coord(const char *, char [static NISSY_SIZE_DATAID]);
+STATIC long long dataid_coord(const char *, char [SIZE(NISSY_SIZE_DATAID)]);
 
 STATIC coord_t *
 parse_coord(size_t n, const char *coord)
@@ -60,7 +60,7 @@ parse_coord_and_trans(
 }
 
 STATIC long long
-dataid_coord(const char *ca, char dataid[static NISSY_SIZE_DATAID])
+dataid_coord(const char *ca, char dataid[SIZE(NISSY_SIZE_DATAID)])
 {
         coord_t *c;
         multicoord_t *mc;