Removed old scripts and updated public API

9 files changed, 409 insertions, 141 deletions

diff --git a/utils/convert.c b/utils/convert.c
new file mode 100644
index 0000000..4f4bb8c
--- /dev/null
+++ b/utils/convert.c
@@ -0,0 +1,409 @@
+/*
+This file contains code related to cube format conversion that used to
+be in src/core.  It is to be adapted into a standalone tool for cube
+format conversion.
+*/
+
+STATIC cube_t readcube(const char *, const 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 *);
+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 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);
+STATIC char edgetob32(uint8_t);
+STATIC char cornertob32(uint8_t);
+
+STATIC struct {
+        const char *name;
+        cube_t (*read)(const char *);
+        int64_t (*write)(cube_t, size_t n, char [n]);
+} 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 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);
+
+        LOG("Cannot read cube: unknown format '%s'\n", format);
+        log_available_formats();
+        return ZERO_CUBE;
+}
+
+STATIC int64_t
+writecube(const char *format, cube_t cube, size_t buf_size, char buf[buf_size])
+{
+        int i;
+
+        for (i = 0; ioformat[i].write != NULL; i++)
+                if (!strcmp(format, ioformat[i].name))
+                        return ioformat[i].write(cube, buf_size, buf);
+
+        LOG("Cannot write cube: unknown format '%s'\n", format);
+        log_available_formats();
+        return NISSY_ERROR_INVALID_FORMAT;
+}
+
+STATIC void
+log_available_formats(void)
+{
+        int i;
+
+        LOG("Available formats: ");
+        for (i = 0; ioformat[i].read != NULL; i++)
+                LOG("'%s' ", ioformat[i].name);
+        LOG("\n");
+}
+
+STATIC uint8_t
+readco(const char *str)
+{
+        if (*str == '0')
+                return 0;
+        if (*str == '1')
+                return CTWIST_CW;
+        if (*str == '2')
+                return CTWIST_CCW;
+
+        LOG("Error reading CO\n");
+        return UINT8_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;
+
+        LOG("Error reading CP\n");
+        return UINT8_ERROR;
+}
+
+STATIC uint8_t
+readeo(const char *str)
+{
+        if (*str == '0')
+                return 0;
+        if (*str == '1')
+                return EFLIP;
+
+        LOG("Error reading EO\n");
+        return UINT8_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;
+
+        LOG("Error reading EP\n");
+        return UINT8_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]);
+                if (c[i] == UINT8_ERROR) {
+                        LOG("Error reading B32 corner %d ", i);
+                        if (buf[i] == 0) {
+                                LOG("(string terminated early)\n");
+                        } else {
+                                LOG("(char '%c')\n", buf[i]);
+                        }
+                        return ZERO_CUBE;
+                }
+        }
+
+        if (buf[8] != '=') {
+                LOG("Error reading B32 separator: a single '=' "
+                    "must be used to separate edges and corners\n");
+                return ZERO_CUBE;
+        }
+
+        for (i = 0; i < 12; i++) {
+                e[i] = b32toedge(buf[i+9]);
+                if (e[i] == UINT8_ERROR) {
+                        LOG("Error reading B32 edge %d ", i);
+                        if (buf[i+9] == 0) {
+                                LOG("(string terminated early)\n");
+                        } else {
+                                LOG("(char '%c')\n", buf[i+9]);
+                        }
+                        return ZERO_CUBE;
+                }
+        }
+
+        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)) == UINT8_ERROR)
+                        return ZERO_CUBE;
+                b += 2;
+                if ((orient = readeo(b)) == UINT8_ERROR)
+                        return ZERO_CUBE;
+                b++;
+                e[i] = piece | orient;
+        }
+        for (i = 0; i < 8; i++) {
+                while (*b == ' ' || *b == '\t' || *b == '\n')
+                        b++;
+                if ((piece = readcp(b)) == UINT8_ERROR)
+                        return ZERO_CUBE;
+                b += 3;
+                if ((orient = readco(b)) == UINT8_ERROR)
+                        return ZERO_CUBE;
+                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 : UINT8_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 int64_t
+writepiece_LST(uint8_t piece, size_t buf_size, char buf[buf_size])
+{
+        char digits[3];
+        size_t i, len;
+
+        if (piece > 99 || buf_size < 3)
+                return 0;
+
+        len = 0;
+        while (piece != 0) {
+                digits[len++] = (piece % 10) + '0';
+                piece /= 10;
+        }
+
+        if (buf_size < len+2)
+                return 0;
+
+        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 int64_t
+writecube_B32(cube_t cube, size_t buf_size, char buf[buf_size])
+{
+        int i;
+        uint8_t corner[8], edge[12];
+
+        if (buf_size < NISSY_SIZE_B32) {
+                LOG("Cannot write cube in B32 format: buffer size must be at "
+                    "least %u bytes, but the provided one is %zu bytes.\n",
+                    NISSY_SIZE_B32, buf_size);
+                return NISSY_ERROR_BUFFER_SIZE;
+        }
+
+        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';
+
+        return NISSY_OK;
+}
+
+STATIC int64_t
+writecube_H48(cube_t cube, size_t buf_size, char buf[buf_size])
+{
+        uint8_t piece, perm, orient, corner[8], edge[12];
+        int i;
+
+        if (buf_size < NISSY_SIZE_H48) {
+                LOG("Cannot write cube in H48 format: buffer size must be "
+                    "at least %u bytes, but the provided one is %zu bytes.\n",
+                    NISSY_SIZE_H48, buf_size);
+                return NISSY_ERROR_BUFFER_SIZE;
+        }
+
+        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';
+
+        return NISSY_OK;
+}
+
+STATIC int64_t
+writecube_LST(cube_t cube, size_t buf_size, char buf[buf_size])
+{
+        int i;
+        uint64_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_size - ptr, buf + ptr);
+                if (ptr == 0)
+                        goto writecube_LST_error;
+        }
+
+        for (i = 0; i < 12; i++) {
+                piece = edge[i];
+                ptr += writepiece_LST(piece, buf_size - ptr, buf + ptr);
+                if (ptr == 0)
+                        goto writecube_LST_error;
+        }
+
+        *(buf+ptr-2) = '\0';
+
+        return NISSY_OK;
+
+writecube_LST_error:
+        LOG("Cannot write cube in LST: buffer is too small (%" PRIu64
+            " bytes given). The LST format has a variable size, try a "
+            "larger buffer.\n", buf_size);
+        return NISSY_ERROR_BUFFER_SIZE;
+}
+
+STATIC uint8_t
+b32toedge(char c)
+{
+        if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'f')))
+                return UINT8_ERROR;
+
+        return c <= 'Z' ? (uint8_t)(c - 'A') : (uint8_t)(c - 'a') + 26;
+}
+
+STATIC uint8_t
+b32tocorner(char c) {
+        uint8_t val;
+
+        if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'f')))
+                return UINT8_ERROR;
+
+        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);
+}
diff --git a/utils/genmovecode.sh b/utils/genmovecode.sh
deleted file mode 100755
index cf13441..0000000
--- a/utils/genmovecode.sh
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/bin/sh
-
-cc -DDEBUG h48_to_lst.c ../src/nissy.c -o h48_to_lst
-
-gen() {
-        for f in cubes/move_??_*.txt; do
-                move="$(echo "$f" | sed 's/.*_// ; s/\.txt//')"
-                printf '#define _move_cube_%s fastcube( \\\n    ' "$move"
-                ./h48_to_lst <"$f"
-                printf ')\n'
-        done
-}
-
-gen
-rm -f h48_to_lst invert
diff --git a/utils/genmoveswitch.sh b/utils/genmoveswitch.sh
deleted file mode 100755
index 3b2a74b..0000000
--- a/utils/genmoveswitch.sh
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/bin/sh
-
-printf '\tswitch (m) {\n'
-for f in cubes/move_??_*.txt; do
-        t="$(echo "$f" | sed 's/.*_// ; s/\.txt//')"
-        printf '\tcase %s:\n\t\treturn _move(%s, c);\n' "$t" "$t"
-done
-printf '\t}\n'
diff --git a/utils/gentranscode.sh b/utils/gentranscode.sh
deleted file mode 100755
index 9a1de2c..0000000
--- a/utils/gentranscode.sh
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/bin/sh
-
-cc -DDEBUG h48_to_lst.c ../src/nissy.c -o h48_to_lst
-cc -DDEBUG invert.c ../src/nissy.c -o invert
-
-lineavx() { printf '#define _trans_cube_%s ' "$1"; }
-linesrc() { printf '_static cube_fast_t _trans_cube_%s = ' "$1"; }
-sedavx() { sed '1,2s/$/ \\/ ; 3s/$/)/ ; 3q'; }
-sedsrc() { sed '3s/$/ };/ ; 3q'; }
-
-gen() {
-        for f in cubes/transform_??_???.txt; do
-                trans="$(echo "$f" | sed 's/.*_// ; s/\.txt//')"
-                printf '#define _trans_cube_%s fastcube( \\\n    ' "$trans"
-                ./h48_to_lst <"$f"
-                printf ')\n'
-                printf '#define _trans_cube_%s_inverse fastcube( \\\n    ' \
-                        "$trans"
-                ./invert <"$f" | ./h48_to_lst
-                printf ')\n'
-        done
-}
-
-gen
-rm -f h48_to_lst invert
diff --git a/utils/gentransswitch.sh b/utils/gentransswitch.sh
deleted file mode 100755
index 20e2bfb..0000000
--- a/utils/gentransswitch.sh
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/sh
-
-printf '\tswitch (t) {\n'
-for f in cubes/transform_??_???.txt; do
-        t="$(echo "$f" | sed 's/.*_// ; s/\.txt//')"
-        mirror_or_rotation="$(echo "$t" | grep m)"
-        if [ -z "$mirror_or_rotation" ]; then
-                m="rotation"
-        else
-                m="mirrored"
-        fi
-        printf '\tcase %s:\n\t\treturn _trans_%s(%s, c);\n' "$t" "$m" "$t"
-done
-printf '\t}\n'
diff --git a/utils/gentranstests.sh b/utils/gentranstests.sh
deleted file mode 100755
index a257a0a..0000000
--- a/utils/gentranstests.sh
+++ /dev/null
@@ -1,35 +0,0 @@
-#!/bin/sh
-
-outdir="./generated_trans_tests"
-
-mkdir -p "$outdir"
-i=100
-
-while read -r line; do
-        [ -z "$line" ] && continue
-
-        trans_piece="$(echo "$line" | awk '{print $1}' | tr -d 'rm')"
-        move1="$(echo "$line" | awk '{print $2}')"
-        move2="$(echo "$line" | awk '{print $3}')"
-
-        rotation="rotation $trans_piece"
-
-        file1="$(ls cubes | grep "move_.*_${move1}.txt")"
-        file2="$(ls cubes | grep "move_.*_${move2}.txt")"
-        echo "$rotation" >"$outdir/${i}_${trans_piece}r_${move1}.in"
-        cat "cubes/$file1" >>"$outdir/${i}_${trans_piece}r_${move1}.in"
-        cp "cubes/$file2" "$outdir/${i}_${trans_piece}r_${move1}.out"
-
-        i=$((i+1))
-
-        mirrored="mirrored $trans_piece"
-        move2m="$(echo "${move2}" | tr 'LR' 'RL')3"
-
-        file1="$(ls cubes | grep "move_.*_${move1}.txt")"
-        file2="$(ls cubes | grep "move_.*_${move2m}.txt")"
-        echo "$mirrored" >"$outdir/${i}_${trans_piece}m_${move1}.in"
-        cat "cubes/$file1" >>"$outdir/${i}_${trans_piece}m_${move1}.in"
-        cp "cubes/$file2" "$outdir/${i}_${trans_piece}m_${move1}.out"
-
-        i=$((i+1))
-done <transform_moves.txt
diff --git a/utils/h48_to_lst.c b/utils/h48_to_lst.c
deleted file mode 100644
index 03265b7..0000000
--- a/utils/h48_to_lst.c
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <stdio.h>
-#include <inttypes.h>
-#include <stdbool.h>
-
-#include "../src/nissy.h"
-
-#define STRLENMAX 1000
-
-int main(void) {
-        char strin[STRLENMAX], strout[STRLENMAX];
-        int result;
-
-        fgets(strin, STRLENMAX, stdin);
-
-        result = nissy_convertcube("H48", "LST", strin, strout);
-        if (result)
-                fprintf(stderr, "Error converting cube: code %d\n", result);
-
-        fputs(strout, stdout);
-
-        return 0;
-}
diff --git a/utils/invert.c b/utils/invert.c
deleted file mode 100644
index 41580c0..0000000
--- a/utils/invert.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdio.h>
-#include <inttypes.h>
-#include <stdbool.h>
-
-#include "../src/nissy.h"
-
-#define STRLENMAX 1000
-
-int main(void) {
-        char str[STRLENMAX], cube[22], inv[22];
-
-        fgets(str, STRLENMAX, stdin);
-        nissy_readcube("H48", str, cube);
-        nissy_inverse(cube, inv);
-        nissy_writecube("H48", inv, str);
-        fputs(str, stdout);
-
-        return 0;
-}
diff --git a/utils/mirror.sh b/utils/mirror.sh
deleted file mode 100755
index 41a434f..0000000
--- a/utils/mirror.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/bin/sh
-
-tr 'LR' 'RL'