1 files changed, 299 insertions, 344 deletions

diff --git a/cube.c b/cube.c
index ba65580..f44a7df 100644
--- a/cube.c
+++ b/cube.c
@@ -43,11 +43,265 @@ _static void write_H48(cube_t, char *);
 _static void write_LST(cube_t, char *);
 _static uint8_t readmove(char);
 _static uint8_t readmodifier(char);
-_static uint8_t readtrans(char *);
-_static int writemoves(uint8_t *, int, char *);
-_static void writetrans(uint8_t, char *);
-_static cube_t move(cube_t, move_t);
-_static cube_t transform(cube_t, trans_t);
+
+_static uint8_t
+readco(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(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(char *str)
+{
+        if (*str == '0')
+                return 0;
+        if (*str == '1')
+                return _eflip;
+
+        DBG_LOG("Error reading EO\n");
+        return _error;
+}
+
+_static uint8_t
+readep(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
+read_H48(char *buf)
+{
+        int i;
+        uint8_t piece, orient;
+        cube_t ret = {0};
+        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++;
+                ret.edge[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++;
+                ret.corner[i] = piece | orient;
+        }
+
+        return ret;
+}
+
+_static uint8_t
+readpiece_LST(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
+read_LST(char *buf)
+{
+        int i;
+        cube_t ret = {0};
+
+        for (i = 0; i < 8; i++)
+                ret.corner[i] = readpiece_LST(&buf);
+
+        for (i = 0; i < 12; i++)
+                ret.edge[i] = readpiece_LST(&buf);
+
+        return ret;
+}
+
+_static int
+writepiece_LST(uint8_t piece, char *buf)
+{
+        char digits[3];
+        int i, 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
+write_H48(cube_t cube, char *buf)
+{
+        uint8_t piece, perm, orient;
+        int i;
+
+        for (i = 0; i < 12; i++) {
+                piece = cube.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 = cube.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
+write_LST(cube_t cube, char *buf)
+{
+        int i, ptr;
+        uint8_t piece;
+
+        ptr = 0;
+
+        for (i = 0; i < 8; i++) {
+                piece = cube.corner[i];
+                ptr += writepiece_LST(piece, buf + ptr);
+        }
+
+        for (i = 0; i < 12; i++) {
+                piece = cube.edge[i];
+                ptr += writepiece_LST(piece, buf + ptr);
+        }
+
+        *(buf+ptr-2) = 0;
+}
+
+_static uint8_t
+readmove(char c)
+{
+        switch (c) {
+        case 'U':
+                return U;
+        case 'D':
+                return D;
+        case 'R':
+                return R;
+        case 'L':
+                return L;
+        case 'F':
+                return F;
+        case 'B':
+                return 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_inline cube_t
+invertco(cube_t c)
+{
+        uint8_t i, piece, orien;
+        cube_t ret;
+
+        ret = c;
+        for (i = 0; i < 8; i++) {
+                piece = c.corner[i];
+                orien = ((piece << 1) | (piece >> 1)) & _cobits2;
+                ret.corner[i] = (piece & _pbits) | orien;
+        }
+
+        return ret;
+}
+
+_static int
+permsign(uint8_t *a, int n)
+{
+        int i, j;
+        uint8_t ret = 0;
+
+        for (i = 0; i < n; i++)
+                for (j = i+1; j < n; j++)
+                        ret += a[i] > a[j] ? 1 : 0;
+
+        return ret % 2;
+}
 
 cube_t
 cube_new(void)
@@ -250,51 +504,22 @@ cube_inverse(cube_t cube)
 }
 
 cube_t
-applymoves(cube_t cube, char *buf)
+cube_move(cube_t c, move_t m)
 {
-        cube_t ret;
-        uint8_t r, m;
-        char *b;
-
-        DBG_ASSERT(cube_consistent(cube), zero,
-            "move error: inconsistent cube\n");
-
-        ret = cube_clone(cube);
-
-        for (b = buf; *b != '\0'; b++) {
-                while (*b == ' ' || *b == '\t' || *b == '\n')
-                        b++;
-                if (*b == '\0')
-                        goto applymoves_finish;
-                if ((r = readmove(*b)) == _error)
-                        goto applymoves_error;
-                if ((m = readmodifier(*(b+1))) != 0)
-                        b++;
-                ret = move(ret, r + m);
-        }
-
-applymoves_finish:
-        return ret;
-
-applymoves_error:
-        DBG_LOG("applymoves error\n");
-        return zero;
+        return cube_compose(c, move_table[m]);
 }
 
 cube_t
-applytrans(cube_t cube, char *buf)
+cube_transform(cube_t c, trans_t t)
 {
-        cube_t ret;
-        uint8_t t;
-
-        DBG_ASSERT(cube_consistent(cube), zero,
-            "transformation error: inconsistent cube\n");
+        cube_t tcube, tinv;
 
-        t = readtrans(buf);
-        ret = cube_clone(cube);
-        ret = transform(ret, t);
+        tcube = trans_table[t][NORMAL];
+        tinv = trans_table[t][INVERSE];
 
-        return cube_clone(ret);
+        return t < 24 ?
+            cube_compose(cube_compose(tcube, c), tinv) :
+            invertco(cube_compose(cube_compose(tcube, c), tinv));
 }
 
 int64_t
@@ -368,335 +593,65 @@ write_error:
         buf[len+1] = '\0';
 }
 
-_static int
-permsign(uint8_t *a, int n)
-{
-        int i, j;
-        uint8_t ret = 0;
-
-        for (i = 0; i < n; i++)
-                for (j = i+1; j < n; j++)
-                        ret += a[i] > a[j] ? 1 : 0;
-
-        return ret % 2;
-}
-
-_static uint8_t
-readco(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(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(char *str)
-{
-        if (*str == '0')
-                return 0;
-        if (*str == '1')
-                return _eflip;
-
-        DBG_LOG("Error reading EO\n");
-        return _error;
-}
-
-_static uint8_t
-readep(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
-read_H48(char *buf)
+int
+cube_readmoves(char *buf, move_t *ret)
 {
-        int i;
-        uint8_t piece, orient;
-        cube_t ret = {0};
+        int n;
+        move_t r, m;
         char *b;
-        
-        b = buf;
 
-        for (i = 0; i < 12; i++) {
+        for (n = 0, b = buf; *b != '\0'; b++) {
                 while (*b == ' ' || *b == '\t' || *b == '\n')
                         b++;
-                if ((piece = readep(b)) == _error)
-                        return zero;
-                b += 2;
-                if ((orient = readeo(b)) == _error)
-                        return zero;
-                b++;
-                ret.edge[i] = piece | orient;
-        }
-        for (i = 0; i < 8; i++) {
-                while (*b == ' ' || *b == '\t' || *b == '\n')
+                if (*b == '\0')
+                        goto applymoves_finish;
+                if ((r = readmove(*b)) == _error)
+                        goto applymoves_error;
+                if ((m = readmodifier(*(b+1))) != 0)
                         b++;
-                if ((piece = readcp(b)) == _error)
-                        return zero;
-                b += 3;
-                if ((orient = readco(b)) == _error)
-                        return zero;
-                b++;
-                ret.corner[i] = piece | orient;
-        }
-
-        return ret;
-}
-
-_static uint8_t
-readpiece_LST(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
-read_LST(char *buf)
-{
-        int i;
-        cube_t ret = {0};
-
-        for (i = 0; i < 8; i++)
-                ret.corner[i] = readpiece_LST(&buf);
-
-        for (i = 0; i < 12; i++)
-                ret.edge[i] = readpiece_LST(&buf);
-
-        return ret;
-}
-
-_static int
-writepiece_LST(uint8_t piece, char *buf)
-{
-        char digits[3];
-        int i, 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
-write_H48(cube_t cube, char *buf)
-{
-        uint8_t piece, perm, orient;
-        int i;
-
-        for (i = 0; i < 12; i++) {
-                piece = cube.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 = cube.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
-write_LST(cube_t cube, char *buf)
-{
-        int i, ptr;
-        uint8_t piece;
-
-        ptr = 0;
-
-        for (i = 0; i < 8; i++) {
-                piece = cube.corner[i];
-                ptr += writepiece_LST(piece, buf + ptr);
+                ret[n++] = m + r;
         }
 
-        for (i = 0; i < 12; i++) {
-                piece = cube.edge[i];
-                ptr += writepiece_LST(piece, buf + ptr);
-        }
-
-        *(buf+ptr-2) = 0;
-}
-
-_static uint8_t
-readmove(char c)
-{
-        switch (c) {
-        case 'U':
-                return U;
-        case 'D':
-                return D;
-        case 'R':
-                return R;
-        case 'L':
-                return L;
-        case 'F':
-                return F;
-        case 'B':
-                return B;
-        default:
-                return _error;
-        }
-}
+applymoves_finish:
+        return n;
 
-_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;
-        }
+applymoves_error:
+        DBG_LOG("applymoves error\n");
+        return -1;
 }
 
-_static uint8_t
-readtrans(char *buf)
+trans_t
+cube_readtrans(char *buf)
 {
-        uint8_t t;
+        trans_t t;
 
         for (t = 0; t < 48; t++)
                 if (!strncmp(buf, transstr[t], 11))
                         return t;
 
-        DBG_LOG("readtrans error\n");
-        return _error;
+        return -1;
 }
 
-_static int
-writemoves(uint8_t *m, int n, char *buf)
+char *
+cube_movestr(move_t m)
 {
-        int i;
-        size_t len;
-        char *b, *s;
-
-        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;
+        return movestr[m];
 }
 
-_static void
-writetrans(uint8_t t, char *buf)
+char *
+cube_transstr(trans_t t)
 {
-        if (t >= 48)
-                memcpy(buf, "error trans", 11);
-        else
-                memcpy(buf, transstr[t], 11);
-        buf[11] = '\0';
+        return transstr[t];
 }
 
-_static cube_t
-move(cube_t c, move_t m)
+move_t
+cube_inversemove(move_t m)
 {
-        return cube_compose(c, move_table[m]);
+        return m - 2*(m%3) + 2;
 }
 
-_static_inline cube_t
-invertco(cube_t c)
-{
-        uint8_t i, piece, orien;
-        cube_t ret;
-
-        ret = c;
-        for (i = 0; i < 8; i++) {
-                piece = c.corner[i];
-                orien = ((piece << 1) | (piece >> 1)) & _cobits2;
-                ret.corner[i] = (piece & _pbits) | orien;
-        }
-
-        return ret;
-}
-
-
-_static cube_t
-transform(cube_t c, trans_t t)
-{
-        cube_t tcube, tinv;
-
-        tcube = trans_table[t][NORMAL];
-        tinv = trans_table[t][INVERSE];
-
-        return t < 24 ?
-            cube_compose(cube_compose(tcube, c), tinv) :
-            invertco(cube_compose(cube_compose(tcube, c), tinv));
-}
-
-/* TODO: expose or remove, maybe add inverse move */
-_static_inline uint8_t inverse_trans(uint8_t);
-
-_static_inline uint8_t
-inverse_trans(uint8_t t)
+trans_t
+cube_inversetrans(trans_t t)
 {
         return inverse_trans_table[t];
 }