More cleanup

1 files changed, 14 insertions, 474 deletions

diff --git a/src/cube_generic.h b/src/cube_generic.h
index a90aa17..844b328 100644
--- a/src/cube_generic.h
+++ b/src/cube_generic.h
@@ -1,62 +1,27 @@
 #define _move(M, c) compose(c, _move_cube_ ## M)
 #define _premove(M, c) compose(_move_cube_ ## M, c)
 
-_static cube_t cubefromarray(uint8_t [static 8], uint8_t [static 12]);
+_static cube_t solvedcube();
+_static bool isconsistent(cube_t);
+_static bool issolvable(cube_t);
+_static bool issolved(cube_t);
+_static bool iserror(cube_t);
+_static cube_t applymoves(cube_t, const char *);
+_static cube_t applytrans(cube_t, const char *);
+
 _static int permsign(uint8_t *, int);
-_static uint8_t readco(const char *);
-_static uint8_t readcp(const char *);
-_static uint8_t readeo(const char *);
-_static uint8_t readep(const char *);
-_static cube_t readcube_B32(const char *);
-_static cube_t readcube_H48(const char *);
-_static uint8_t readpiece_LST(const char **);
-_static cube_t readcube_LST(const char *);
-_static int writepiece_LST(uint8_t, char *);
-_static void writecube_B32(cube_t, char *);
-_static void writecube_H48(cube_t, char *);
-_static void writecube_LST(cube_t, char *);
-_static uint8_t b32toedge(char);
-_static uint8_t b32tocorner(char);
-_static char edgetob32(uint8_t);
-_static char cornertob32(uint8_t);
-_static uint8_t readmove(char);
-_static uint8_t readmodifier(char);
-_static uint8_t readtrans(const char *);
-_static int writemoves(uint8_t *, int, char *);
-_static void writetrans(uint8_t, char *);
 _static cube_t move(cube_t, uint8_t);
 _static cube_t transform_edges(cube_t, uint8_t);
 _static cube_t transform_corners(cube_t, uint8_t);
 _static cube_t transform(cube_t, uint8_t);
 
-_static struct {
-        const char *name;
-        cube_t (*read)(const char *);
-        void (*write)(cube_t, char *);
-} ioformat[] =
-{
-        { .name = "B32", .read = readcube_B32, .write = writecube_B32 },
-        { .name = "LST", .read = readcube_LST, .write = writecube_LST },
-        { .name = "H48", .read = readcube_H48, .write = writecube_H48 },
-        { .name = "NONE", .read = NULL, .write = NULL },
-};
-
-_static_inline cube_t
-cubefromarray(uint8_t c[static 8], uint8_t e[static 12])
-{
-        return static_cube(
-            c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7],
-            e[0], e[1], e[2], e[3], e[4], e[5], e[6], e[7],
-            e[8], e[9], e[10], e[11]);
-}
-
-cube_t
-solvedcube(void)
+_static cube_t
+solvedcube()
 {
         return solved;
 }
 
-bool
+_static bool
 isconsistent(cube_t cube)
 {
         uint8_t i, p, e, piece, corner[8], edge[12];
@@ -112,7 +77,7 @@ inconsistent_co:
         return false;
 }
 
-bool
+_static bool
 issolvable(cube_t cube)
 {
         uint8_t i, eo, co, piece, edge[12], corner[8], ep[12], cp[8];
@@ -170,32 +135,7 @@ iserror(cube_t cube)
         return equal(cube, zero);
 }
 
-cube_t
-inverse(cube_t cube)
-{
-        uint8_t i, piece, orien, e[12], c[8], edge[12], corner[8];
-
-        DBG_ASSERT(isconsistent(cube), zero,
-            "inverse error: inconsistent cube\n");
-
-        pieces(&cube, corner, edge);
-        
-        for (i = 0; i < 12; i++) {
-                piece = edge[i];
-                orien = piece & _eobit;
-                e[piece & _pbits] = i | orien;
-        }
-
-        for (i = 0; i < 8; i++) {
-                piece = corner[i];
-                orien = ((piece << 1) | (piece >> 1)) & _cobits2;
-                c[piece & _pbits] = i | orien;
-        }
-
-        return cubefromarray(c, e);
-}
-
-cube_t
+_static cube_t
 applymoves(cube_t cube, const char *buf)
 {
         uint8_t r, m;
@@ -224,7 +164,7 @@ applymoves_error:
         return zero;
 }
 
-cube_t
+_static cube_t
 applytrans(cube_t cube, const char *buf)
 {
         uint8_t t;
@@ -237,49 +177,6 @@ applytrans(cube_t cube, const char *buf)
         return transform(cube, t);
 }
 
-cube_t
-readcube(const char *format, const char *buf)
-{
-        int i;
-
-        for (i = 0; ioformat[i].read != NULL; i++)
-                if (!strcmp(format, ioformat[i].name))
-                        return ioformat[i].read(buf);
-
-        DBG_LOG("Cannot read cube in the given format\n");
-        return zero;
-}
-
-void
-writecube(const char *format, cube_t cube, char *buf)
-{
-        char *errormsg;
-        size_t len;
-
-        if (!isconsistent(cube)) {
-                errormsg = "ERROR: cannot write inconsistent cube";
-                goto writecube_error;
-        }
-
-        int i;
-
-        for (i = 0; ioformat[i].write != NULL; i++) {
-                if (!strcmp(format, ioformat[i].name)) {
-                        ioformat[i].write(cube, buf);
-                        return;
-                }
-        }
-
-        errormsg = "ERROR: cannot write cube in the given format";
-
-writecube_error:
-        DBG_LOG("writecube error, see stdout for details\n");
-        len = strlen(errormsg);
-        memcpy(buf, errormsg, len);
-        buf[len] = '\n';
-        buf[len+1] = '\0';
-}
-
 _static int
 permsign(uint8_t *a, int n)
 {
@@ -293,363 +190,6 @@ permsign(uint8_t *a, int n)
         return ret % 2;
 }
 
-_static uint8_t
-readco(const char *str)
-{
-        if (*str == '0')
-                return 0;
-        if (*str == '1')
-                return _ctwist_cw;
-        if (*str == '2')
-                return _ctwist_ccw;
-
-        DBG_LOG("Error reading CO\n");
-        return _error;
-}
-
-_static uint8_t
-readcp(const char *str)
-{
-        uint8_t c;
-
-        for (c = 0; c < 8; c++)
-                if (!strncmp(str, cornerstr[c], 3) ||
-                    !strncmp(str, cornerstralt[c], 3))
-                        return c;
-
-        DBG_LOG("Error reading CP\n");
-        return _error;
-}
-
-_static uint8_t
-readeo(const char *str)
-{
-        if (*str == '0')
-                return 0;
-        if (*str == '1')
-                return _eflip;
-
-        DBG_LOG("Error reading EO\n");
-        return _error;
-}
-
-_static uint8_t
-readep(const char *str)
-{
-        uint8_t e;
-
-        for (e = 0; e < 12; e++)
-                if (!strncmp(str, edgestr[e], 2))
-                        return e;
-
-        DBG_LOG("Error reading EP\n");
-        return _error;
-}
-
-_static cube_t
-readcube_B32(const char *buf)
-{
-        int i;
-        uint8_t c[8], e[12];
-
-        for (i = 0; i < 8; i++) {
-                c[i] = b32tocorner(buf[i]);
-                DBG_ASSERT(c[i] < 255, zero,
-                    "Error reading B32 corner %d (char %d)\n", i, i);
-        }
-
-        for (i = 0; i < 12; i++) {
-                e[i] = b32toedge(buf[i+9]);
-                DBG_ASSERT(e[i] < 255, zero,
-                    "Error reading B32 edge %d (char %d)\n", i, i+9);
-        }
-
-        return cubefromarray(c, e);
-}
-
-_static cube_t
-readcube_H48(const char *buf)
-{
-        int i;
-        uint8_t piece, orient, c[8], e[12];
-        const char *b;
-        
-        b = buf;
-
-        for (i = 0; i < 12; i++) {
-                while (*b == ' ' || *b == '\t' || *b == '\n')
-                        b++;
-                if ((piece = readep(b)) == _error)
-                        return zero;
-                b += 2;
-                if ((orient = readeo(b)) == _error)
-                        return zero;
-                b++;
-                e[i] = piece | orient;
-        }
-        for (i = 0; i < 8; i++) {
-                while (*b == ' ' || *b == '\t' || *b == '\n')
-                        b++;
-                if ((piece = readcp(b)) == _error)
-                        return zero;
-                b += 3;
-                if ((orient = readco(b)) == _error)
-                        return zero;
-                b++;
-                c[i] = piece | orient;
-        }
-
-        return cubefromarray(c, e);
-}
-
-_static uint8_t
-readpiece_LST(const char **b)
-{
-        uint8_t ret;
-        bool read;
-
-        while (**b == ',' || **b == ' ' || **b == '\t' || **b == '\n')
-                (*b)++;
-
-        for (ret = 0, read = false; **b >= '0' && **b <= '9'; (*b)++) {
-                read = true;
-                ret = ret * 10 + (**b) - '0';
-        }
-
-        return read ? ret : _error;
-}
-
-_static cube_t
-readcube_LST(const char *buf)
-{
-        int i;
-        uint8_t c[8], e[12];
-
-        for (i = 0; i < 8; i++)
-                c[i] = readpiece_LST(&buf);
-
-        for (i = 0; i < 12; i++)
-                e[i] = readpiece_LST(&buf);
-
-        return cubefromarray(c, e);
-}
-
-_static int
-writepiece_LST(uint8_t piece, char *buf)
-{
-        char digits[3];
-        int i, len;
-
-        len = 0;
-        while (piece != 0) {
-                digits[len++] = (piece % 10) + '0';
-                piece /= 10;
-        }
-
-        if (len == 0)
-                digits[len++] = '0';
-
-        for (i = 0; i < len; i++)
-                buf[i] = digits[len-i-1];
-
-        buf[len] = ',';
-        buf[len+1] = ' ';
-
-        return len+2;
-}
-
-_static void
-writecube_B32(cube_t cube, char *buf)
-{
-        int i;
-        uint8_t corner[8], edge[12];
-
-        pieces(&cube, corner, edge);
-
-        for (i = 0; i < 8; i++)
-                buf[i] = cornertob32(corner[i]);
-
-        buf[8] = '=';
-
-        for (i = 0; i < 12; i++)
-                buf[i+9] = edgetob32(edge[i]);
-
-        buf[21] = '\0';
-}
-
-_static void
-writecube_H48(cube_t cube, char *buf)
-{
-        uint8_t piece, perm, orient, corner[8], edge[12];
-        int i;
-
-        pieces(&cube, corner, edge);
-
-        for (i = 0; i < 12; i++) {
-                piece = edge[i];
-                perm = piece & _pbits;
-                orient = (piece & _eobit) >> _eoshift;
-                buf[4*i    ] = edgestr[perm][0];
-                buf[4*i + 1] = edgestr[perm][1];
-                buf[4*i + 2] = orient + '0';
-                buf[4*i + 3] = ' ';
-        }
-        for (i = 0; i < 8; i++) {
-                piece = corner[i];
-                perm = piece & _pbits;
-                orient = (piece & _cobits) >> _coshift;
-                buf[48 + 5*i    ] = cornerstr[perm][0];
-                buf[48 + 5*i + 1] = cornerstr[perm][1];
-                buf[48 + 5*i + 2] = cornerstr[perm][2];
-                buf[48 + 5*i + 3] = orient + '0';
-                buf[48 + 5*i + 4] = ' ';
-        }
-
-        buf[48+39] = '\0';
-}
-
-_static void
-writecube_LST(cube_t cube, char *buf)
-{
-        int i;
-        size_t ptr;
-        uint8_t piece, corner[8], edge[12];
-
-        ptr = 0;
-        pieces(&cube, corner, edge);
-
-        for (i = 0; i < 8; i++) {
-                piece = corner[i];
-                ptr += writepiece_LST(piece, buf + ptr);
-        }
-
-        for (i = 0; i < 12; i++) {
-                piece = edge[i];
-                ptr += writepiece_LST(piece, buf + ptr);
-        }
-
-        *(buf+ptr-2) = 0;
-}
-
-_static uint8_t
-b32toedge(char c)
-{
-        if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'g'))
-                return 255;
-
-        return c <= 'Z' ? (uint8_t)(c - 'A') : (uint8_t)(c - 'a');
-}
-
-_static uint8_t
-b32tocorner(char c) {
-        uint8_t val;
-
-        if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'g'))
-                return 255;
-
-        val = c <= 'Z' ? (uint8_t)(c - 'A') : (uint8_t)(c - 'a') + 26;
-
-        return (val & 7) | ((val & 24) << 2);
-}
-
-_static char
-edgetob32(uint8_t edge)
-{
-        return edge <= 26 ? 'A' + (char)edge : 'a' + (char)(edge - 26);
-}
-
-_static char
-cornertob32(uint8_t corner)
-{
-        uint8_t val;
-
-        val = (corner & 7) | ((corner & 96) >> 2);
-
-        return val <= 26 ? 'A' + (char)val : 'a' + (char)(val - 26);
-}
-
-_static uint8_t
-readmove(char c)
-{
-        switch (c) {
-        case 'U':
-                return _move_U;
-        case 'D':
-                return _move_D;
-        case 'R':
-                return _move_R;
-        case 'L':
-                return _move_L;
-        case 'F':
-                return _move_F;
-        case 'B':
-                return _move_B;
-        default:
-                return _error;
-        }
-}
-
-_static uint8_t
-readmodifier(char c)
-{
-        switch (c) {
-        case '1': /* Fallthrough */
-        case '2': /* Fallthrough */
-        case '3':
-                return c - '0' - 1;
-        case '\'':
-                return 2;
-        default:
-                return 0;
-        }
-}
-
-_static uint8_t
-readtrans(const char *buf)
-{
-        uint8_t t;
-
-        for (t = 0; t < 48; t++)
-                if (!strncmp(buf, transstr[t], 11))
-                        return t;
-
-        DBG_LOG("readtrans error\n");
-        return _error;
-}
-
-_static int
-writemoves(uint8_t *m, int n, char *buf)
-{
-        int i;
-        size_t len;
-        const char *s;
-        char *b;
-
-        for (i = 0, b = buf; i < n; i++, b++) {
-                s = movestr[m[i]];
-                len = strlen(s);
-                memcpy(b, s, len);
-                b += len;       
-                *b = ' ';
-        }
-
-        if (b != buf)
-                b--; /* Remove last space */
-        *b = '\0';
-
-        return b - buf;
-}
-
-_static void
-writetrans(uint8_t t, char *buf)
-{
-        if (t >= 48)
-                memcpy(buf, "error trans", 11);
-        else
-                memcpy(buf, transstr[t], 11);
-        buf[11] = '\0';
-}
-
 _static cube_t
 move(cube_t c, uint8_t m)
 {