Added rudimentary shell to run commands (ugly)

7 files changed, 615 insertions, 65 deletions

diff --git a/.gitignore b/.gitignore
index 7d0c78a..ce4229b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,7 +5,7 @@ gen
 debuggen
 perf.data
 perf.data.old
-tables/data/*
+tables/*
 test/*/runtest
 test/run
 test/last.*
diff --git a/Makefile b/Makefile
index 8004637..5859eca 100644
--- a/Makefile
+++ b/Makefile
@@ -12,7 +12,7 @@ debugcube.o: clean
         ${CC} -D${CUBETYPE} ${DBGFLAGS} -c -o debugcube.o src/cube.c
 
 clean:
-        rm -rf *.o gen debuggen
+        rm -rf *.o run
 
 test: debugcube.o
         CUBETYPE=${CUBETYPE} TEST=${TEST} ./test/test.sh
@@ -20,10 +20,8 @@ test: debugcube.o
 benchmark: cube.o
         CUBETYPE=${CUBETYPE} ./benchmark/benchmark.sh
 
-gen: cube.o
-        ${CC} ${CFLAGS} -o gen cube.o tables/tables.c
+shell: cube.o
+        mkdir -p tables
+        ${CC} ${CFLAGS} -o run cube.o shell.c
 
-debuggen: debugcube.o
-        ${CC} ${DBGFLAGS} -o debuggen debugcube.o tables/tables.c
-
-.PHONY: all clean test benchmark gen debuggen
+.PHONY: all clean test benchmark shell
diff --git a/TODO.txt b/TODO.txt
index d9a40f2..f6d71fa 100644
--- a/TODO.txt
+++ b/TODO.txt
@@ -1,3 +1,8 @@
+Shell and nissy_run
+  x done shell.c, but it is ugly (as expected)
+  - move stuff from solve_generic to cube_public
+  - make shell a bit nicer?
+
 Fixes
   - tables/tables.c: fix, use new nissy_gendata and nissy_datasize
 
@@ -15,6 +20,8 @@ Goal: find out which k value is best
   - write table generation and solver for k2 and k1
   - benchmark for different sizes!
 
+Read / write: replace by convertcube only?
+
 ## H48 optimal solver (some has already been implemented)
 
 First compute co + csep. Use csep as a binary number (2^7 instead of 70,
@@ -90,13 +97,14 @@ switch. Here NISS may be useful.
 
 ## "Front-end"
 
+* nissy shell: make more usable, meaningful error messages etc
+  for example, it should check that the solver is valid
 * Write adapter code for other languages:
   python
   hare (see blog post 2023-12-01 for ffi)
   rust, go
   dart ffi, js
   java
-* add also example code (e.g. an optimal solver) in examples/
 
 ## More documentation?
 
diff --git a/shell.c b/shell.c
new file mode 100644
index 0000000..1b8b70e
--- /dev/null
+++ b/shell.c
@@ -0,0 +1,578 @@
+#include <inttypes.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "src/cube.h"
+
+#define PRINTCUBE_BUFFER_SIZE 1024 /* Should be enough */
+#define SOLUTIONS_BUFFER_SIZE 500000 /* Should be enough */
+#define MAX_PATH_LENGTH 10000 /* Should be enough */
+
+typedef struct {
+        int command_index;
+        char cube[22];
+        char cube_perm[22];
+        char *str_cube;
+        char *str_format;
+        char *str_format_in;
+        char *str_format_out;
+        char *str_moves;
+        char *str_trans;
+        char *str_solver;
+        char *str_options; /* TODO: remove, use only solver */
+        char *str_nisstype; /* TODO: remove, use flags */
+        int8_t minmoves;
+        int8_t maxmoves;
+        int8_t optimal;
+        int64_t maxsolutions;
+        int64_t datasize; /* Option for gendata + solve, TODO change? */
+} args_t;
+
+static void print_cube_result(int64_t, char [static 22]);
+static void print_str_result(int64_t, char *);
+
+static int64_t compose_exec(args_t *);
+static int64_t inverse_exec(args_t *);
+static int64_t applymoves_exec(args_t *);
+static int64_t applytrans_exec(args_t *);
+static int64_t frommoves_exec(args_t *);
+static int64_t readcube_exec(args_t *);
+static int64_t writecube_exec(args_t *);
+static int64_t convertcube_exec(args_t *);
+static int64_t datasize_exec(args_t *);
+static int64_t gendata_exec(args_t *);
+static int64_t solve_exec(args_t *);
+
+static int parse_args(int, char **, args_t *);
+static bool parse_int8(char *, int8_t *);
+static bool parse_int64(char *, int64_t *);
+
+static bool set_cube(int, char **, args_t *);
+static bool set_cube_perm(int, char **, args_t *);
+static bool set_str_cube(int, char **, args_t *);
+static bool set_str_format(int, char **, args_t *);
+static bool set_str_format_in(int, char **, args_t *);
+static bool set_str_format_out(int, char **, args_t *);
+static bool set_str_moves(int, char **, args_t *);
+static bool set_str_trans(int, char **, args_t *);
+static bool set_str_solver(int, char **, args_t *);
+static bool set_str_options(int, char **, args_t *);
+static bool set_str_nisstype(int, char **, args_t *);
+static bool set_minmoves(int, char **, args_t *);
+static bool set_maxmoves(int, char **, args_t *);
+static bool set_optimal(int, char **, args_t *);
+static bool set_maxsolutions(int, char **, args_t *);
+ 
+#define COMMAND(N, E) { .name = N, .exec = E }
+struct {
+        char *name;
+        int64_t (*exec)(args_t *);
+} commands[] = {
+        COMMAND("compose", compose_exec),
+        COMMAND("inverse", inverse_exec),
+        COMMAND("applymoves", applymoves_exec),
+        COMMAND("applytrans", applytrans_exec),
+        COMMAND("frommoves", frommoves_exec),
+        COMMAND("readcube", readcube_exec),
+        COMMAND("writecube", writecube_exec),
+        COMMAND("convertcube", convertcube_exec),
+        COMMAND("datasize", datasize_exec),
+        COMMAND("gendata", gendata_exec),
+        COMMAND("solve", solve_exec),
+        COMMAND(NULL, NULL)
+};
+
+#define OPTION(N, A, S) { .name = N, .nargs = A, .set = S }
+struct {
+        char *name;
+        int nargs;
+        bool (*set)(int, char **, args_t *);
+} options[] = {
+        OPTION("-cube", 1, set_cube),
+        OPTION("-perm", 1, set_cube_perm),
+        OPTION("-cubestr", 1, set_str_cube),
+        OPTION("-format", 1, set_str_format),
+        OPTION("-fin", 1, set_str_format_in),
+        OPTION("-fout", 1, set_str_format_out),
+        OPTION("-moves", 1, set_str_moves),
+        OPTION("-trans", 1, set_str_trans),
+        OPTION("-solver", 1, set_str_solver),
+        OPTION("-options", 1, set_str_options), /* TODO: remove, use only solver */
+        OPTION("-nisstype", 1, set_str_nisstype), /* TODO: remove, use flags */
+        OPTION("-m", 1, set_minmoves),
+        OPTION("-M", 1, set_maxmoves),
+        OPTION("-O", 1, set_optimal),
+        OPTION("-n", 1, set_maxsolutions),
+        OPTION(NULL, 0, NULL)
+};
+
+char *tablepaths[] = {
+        "tables/",
+        "",
+        NULL
+};
+
+static void
+print_cube_result(int64_t ret, char result[static 22])
+{
+        switch (ret) {
+        case 0:
+                break;
+        case 1:
+                fprintf(stderr, "Warning: resulting cube not solvable\n");
+                break;
+        case 2: /* Fallthrough */
+        default:
+                fprintf(stderr, "Unknown error (result is inconsistent)\n");
+        }
+
+        printf("%s\n", result);
+}
+
+static void
+print_str_result(int64_t ret, char *result)
+{
+        switch (ret) {
+        case 0:
+                break;
+        default:
+                fprintf(stderr, "Unknown error\n");
+        }
+
+        printf("%s\n", result);
+}
+
+static int64_t
+compose_exec(args_t *args)
+{
+        char result[22];
+        int64_t ret;
+
+        ret = nissy_compose(args->cube, args->cube_perm, result);
+        print_cube_result(ret, result);
+
+        return ret;
+}
+
+static int64_t
+inverse_exec(args_t *args)
+{
+        char result[22];
+        int64_t ret;
+
+        ret = nissy_inverse(args->cube, result);
+        print_cube_result(ret, result);
+
+        return ret;
+}
+
+static int64_t
+applymoves_exec(args_t *args)
+{
+        char result[22];
+        int64_t ret;
+
+        ret = nissy_applymoves(args->cube, args->str_moves, result);
+        print_cube_result(ret, result);
+
+        return ret;
+}
+
+static int64_t
+applytrans_exec(args_t *args)
+{
+        char result[22];
+        int64_t ret;
+
+        ret = nissy_applytrans(args->cube, args->str_trans, result);
+        print_cube_result(ret, result);
+
+        return ret;
+}
+
+static int64_t
+frommoves_exec(args_t *args)
+{
+        char result[22];
+        int64_t ret;
+
+        ret = nissy_frommoves(args->str_trans, result);
+        print_cube_result(ret, result);
+
+        return ret;
+}
+
+static int64_t
+readcube_exec(args_t *args)
+{
+        char result[22];
+        int64_t ret;
+
+        ret = nissy_readcube(args->str_format, args->str_cube, result);
+        print_cube_result(ret, result);
+
+        return ret;
+}
+
+static int64_t
+writecube_exec(args_t *args)
+{
+        char result[PRINTCUBE_BUFFER_SIZE];
+        int64_t ret;
+
+        ret = nissy_writecube(args->str_format, args->str_cube, result);
+        print_str_result(ret, result);
+
+        return ret;
+}
+
+static int64_t
+convertcube_exec(args_t *args)
+{
+        char result[PRINTCUBE_BUFFER_SIZE];
+        int64_t ret;
+
+        ret = nissy_convertcube(
+            args->str_format_in, args->str_format_out, args->str_cube, result);
+        print_str_result(ret, result);
+
+        return ret;
+}
+
+static int64_t
+datasize_exec(args_t *args)
+{
+        int64_t ret;
+
+        ret = nissy_datasize(args->str_solver, args->str_options);
+        if (ret < 0)
+                fprintf(stderr, "Unknown error (make sure solver is valid)\n");
+        printf("%" PRId64 "\n", ret);
+
+        return ret;
+}
+
+static int64_t
+gendata_exec(args_t *args)
+{
+        int i;
+        FILE *file;
+        char *buf, path[MAX_PATH_LENGTH];
+        int64_t ret, size;
+        size_t written;
+
+        /* TODO: should give warning if overwriting existing file */
+        for (i = 0; tablepaths[i] != NULL; i++) {
+                strcpy(path, tablepaths[i]);
+                strcat(path, args->str_solver);
+                file = fopen(path, "wb");
+                if (file != NULL)
+                        break;
+        }
+
+        if (tablepaths[i] == NULL) {
+                fprintf(stderr, "Cannot write data to file\n");
+                return -2;
+        }
+
+        size = nissy_datasize(args->str_solver, args->str_options);
+        if (size < 0) {
+                fprintf(stderr,
+                    "Unknown error in retrieving data size"
+                    "(make sure solver is valid)\n");
+                return -3;
+        }
+
+        buf = malloc(size);
+
+        ret = nissy_gendata(args->str_solver, args->str_options, buf);
+        if (ret < 0) {
+                fprintf(stderr, "Unknown error in generating data\n");
+                free(buf);
+                return -4;
+        }
+        if (ret != size) {
+                fprintf(stderr, "Unknown error: unexpected data size\n");
+                free(buf);
+                return -5;
+        }
+
+        written = fwrite(buf, size, 1, file);
+        free(buf);
+
+        if (written != (int64_t)size) {
+                fprintf(stderr,
+                    "Error: data was generated correctly, but could not be "
+                    "written to file (generated %" PRId64 " bytes, written "
+                    "%zu)\n", written, size);
+                return -6;
+        }
+
+        args->datasize = size;
+        fprintf(stderr, "Data written to %s\n", path);
+
+        return 0;
+}
+
+static int64_t
+solve_exec(args_t *args)
+{
+        int i;
+        FILE *file;
+        char *buf, solutions[SOLUTIONS_BUFFER_SIZE], path[MAX_PATH_LENGTH];
+        int64_t ret, gendata_ret;
+        size_t read;
+
+        for (i = 0; tablepaths[i] != NULL; i++) {
+                strcpy(path, tablepaths[i]);
+                strcat(path, args->str_solver);
+                file = fopen(path, "rb");
+                if (file != NULL)
+                        break;
+        }
+
+        if (tablepaths[i] == NULL) {
+                fprintf(stderr,
+                    "Cannot read data file, "
+                    "generating it (this can take a while)\n");
+                gendata_ret = gendata_exec(args);
+                if (gendata_ret)
+                        return gendata_ret;
+        }
+
+        /* Ugh, this is not elegant TODO */
+        for (i = 0; tablepaths[i] != NULL; i++) {
+                strcpy(path, tablepaths[i]);
+                strcat(path, args->str_solver);
+                file = fopen(path, "rb");
+                if (file != NULL)
+                        break;
+        }
+
+        if (tablepaths[i] == NULL) {
+                fprintf(stderr, "Error: data file not found\n");
+                return -1;
+        }
+
+        buf = malloc(args->datasize);
+        read = fread(buf, args->datasize, 1, file);
+        if (read != args->datasize) {
+                fprintf(stderr, "Error reading data from file\n");
+                return -2;
+        }
+
+        ret = nissy_solve(
+            args->cube, args->str_solver, args->str_options, args->str_nisstype,
+            args->minmoves, args->maxmoves, args->maxsolutions, args->optimal,
+            buf, solutions);
+
+        free(buf);
+
+        if (ret == 0)
+                fprintf(stderr, "No solutions found\n");
+        else
+                printf("%s", solutions);
+
+        return 0;
+}
+
+static int
+parse_args(int argc, char **argv, args_t *args)
+{
+/* TODO: this function should set sensible defaults for all options */
+        int i, j, n;
+
+        if (argc == 0) {
+                printf("No command given\n");
+                return 1;
+        }
+
+        for (i = 0; commands[i].name != NULL; i++) {
+                if (!strcmp(argv[0], commands[i].name)) {
+                        args->command_index = i;
+                        break;
+                }
+        }
+
+        if (commands[i].name == NULL) {
+                fprintf(stderr, "Unknown command %s\n", argv[0]);
+                return 1;
+        }
+
+        for (i = 1; i < argc; i++) {
+                for (j = 0; options[j].name != NULL; j++) {
+                        n = argc - i - 1;
+                        if (strcmp(argv[i], options[j].name))
+                                continue;
+                        if (n < options[j].nargs) {
+                                fprintf(stderr,
+                                    "Too few arguments for option %s\n",
+                                    options[j].name);
+                                return 1;
+                        }
+                        if (!options[j].set(n, argv+i, args)) {
+                                fprintf(stderr,
+                                    "Error parsing arguments for option %s\n",
+                                    options[j].name);
+                                return 1;
+                        }
+                        i += options[j].nargs;
+                        break;
+                }
+                if (options[j].name == NULL) {
+                        fprintf(stderr, "Unknown option %s\n", argv[i]);
+                        return 1;
+                }
+        }
+
+        return 0;
+}
+
+bool
+parse_int8(char *argv, int8_t *result)
+{
+        bool noerror;
+        int64_t n;
+
+        noerror = parse_int64(argv, &n);
+        *result = (int8_t)n;
+
+        return noerror && n >= INT8_MIN && n <= INT8_MAX;
+}
+
+bool
+parse_int64(char *argv, int64_t *result)
+{
+        *result = strtoll(argv, NULL, 10);
+
+        return errno != 0;
+}
+
+static bool
+set_cube(int argc, char **argv, args_t *args)
+{
+        memcpy(args->cube, argv[0], 22);
+        args->cube[21] = 0;
+
+        return true;
+}
+
+static bool
+set_cube_perm(int argc, char **argv, args_t *args)
+{
+        memcpy(args->cube_perm, argv[0], 22);
+        args->cube_perm[21] = 0;
+
+        return true;
+}
+
+static bool
+set_str_cube(int argc, char **argv, args_t *args)
+{
+        args->str_cube = argv[0];
+
+        return true;
+}
+
+static bool
+set_str_format(int argc, char **argv, args_t *args)
+{
+        args->str_format = argv[0];
+
+        return true;
+}
+
+static bool
+set_str_format_in(int argc, char **argv, args_t *args)
+{
+        args->str_format_in = argv[0];
+
+        return true;
+}
+
+static bool
+set_str_format_out(int argc, char **argv, args_t *args)
+{
+        args->str_format_out = argv[0];
+
+        return true;
+}
+
+static bool
+set_str_moves(int argc, char **argv, args_t *args)
+{
+        args->str_moves = argv[0];
+
+        return true;
+}
+
+static bool
+set_str_trans(int argc, char **argv, args_t *args)
+{
+        args->str_trans = argv[0];
+
+        return true;
+}
+
+static bool
+set_str_solver(int argc, char **argv, args_t *args)
+{
+        args->str_solver = argv[0];
+
+        return true;
+}
+
+static bool
+set_str_options(int argc, char **argv, args_t *args)
+{
+        args->str_options = argv[0];
+
+        return true;
+}
+
+static bool
+set_str_nisstype(int argc, char **argv, args_t *args)
+{
+        args->str_nisstype = argv[0];
+
+        return true;
+}
+
+static bool
+set_minmoves(int argc, char **argv, args_t *args)
+{
+        return parse_int8(argv[0], &args->minmoves);
+}
+
+static bool
+set_maxmoves(int argc, char **argv, args_t *args)
+{
+        return parse_int8(argv[0], &args->maxmoves);
+}
+
+static bool
+set_optimal(int argc, char **argv, args_t *args)
+{
+        return parse_int8(argv[0], &args->optimal);
+}
+
+static bool
+set_maxsolutions(int argc, char **argv, args_t *args)
+{
+        return parse_int64(argv[0], &args->maxsolutions);
+}
+
+int main(int argc, char **argv)
+{
+        int parse_error;
+        args_t args;
+
+        parse_error = parse_args(argc-1, argv+1, &args);
+        if (parse_error)
+                return parse_error;
+
+        return (int)commands[args.command_index].exec(&args);
+}
diff --git a/src/cube.h b/src/cube.h
index 0eedfec..fb96823 100644
--- a/src/cube.h
+++ b/src/cube.h
@@ -4,47 +4,47 @@ number in case of error, unless otherwise specified. See (TODO:
 documentation) for details.
 */
 
-int nissy_compose(
+int64_t nissy_compose(
         const char cube[static 22],
         const char permutation[static 22],
         char result[static 22]
 );
 
-int nissy_inverse(
+int64_t nissy_inverse(
         const char cube[static 22],
         char result[static 22]
 );
 
-int nissy_applyoves(
+int64_t nissy_applymoves(
         const char cube[static 22],
         const char *moves,
         char result[static 22]
 );
 
-int nissy_applytrans(
+int64_t nissy_applytrans(
         const char cube[static 22],
         const char *transformation,
         char result[static 22]
 );
 
-int nissy_frommoves(
+int64_t nissy_frommoves(
         const char *moves,
         char result[static 22]
 );
 
-int nissy_readcube(
+int64_t nissy_readcube(
         const char *format,
         const char *cube_string,
         char result[static 22]
 );
 
-int nissy_writecube(
+int64_t nissy_writecube(
         const char *format,
         const char cube[static 22],
         char *result
 );
 
-int nissy_convertcube(
+int64_t nissy_convertcube(
         const char *format_in,
         const char *format_out,
         const char *cube_string,
@@ -58,13 +58,13 @@ slightly larger than the actual table size.
 */
 int64_t nissy_datasize(
         const char *solver,
-        const char *options
+        const char *options /* TODO: remove options, use only solver name */
 );
 
 /* Returns the number of bytes written, or -1 in case of error */
 int64_t nissy_gendata(
         const char *solver,
-        const char *options,
+        const char *options, /* TODO: remove options, use only solver name */
         void *generated_data
 );
 
@@ -72,8 +72,8 @@ int64_t nissy_gendata(
 int64_t nissy_solve(
         const char cube[static 22],
         const char *solver, 
-        const char *options,
-        const char *nisstype,
+        const char *options, /* TODO: remove options, use only solver name */
+        const char *nisstype, /* TODO: remove, use flags */
         int8_t minmoves,
         int8_t maxmoves,
         int64_t maxsolutions,
diff --git a/src/cube_public.h b/src/cube_public.h
index 01b6dac..65d5d54 100644
--- a/src/cube_public.h
+++ b/src/cube_public.h
@@ -1,8 +1,8 @@
 #include "cube.h"
 
-int write_result(cube_t, char [static 22]);
+_static int64_t write_result(cube_t, char [static 22]);
 
-int
+_static int64_t
 write_result(cube_t cube, char result[static 22])
 {
         if (!isconsistent(cube)) {
@@ -15,7 +15,7 @@ write_result(cube_t cube, char result[static 22])
         return issolvable(cube) ? 0 : 1;
 }
 
-int
+int64_t
 nissy_compose(
         const char cube[static 22],
         const char permutation[static 22],
@@ -31,7 +31,7 @@ nissy_compose(
         return write_result(res, result);
 }
 
-int
+int64_t
 nissy_inverse(
         const char cube[static 22],
         char result[static 22]
@@ -45,7 +45,7 @@ nissy_inverse(
         return write_result(res, result);
 }
 
-int
+int64_t
 nissy_applymoves(
         const char cube[static 22],
         const char *moves,
@@ -60,7 +60,7 @@ nissy_applymoves(
         return write_result(res, result);
 }
 
-int
+int64_t
 nissy_applytrans(
         const char cube[static 22],
         const char *transformation,
@@ -75,7 +75,7 @@ nissy_applytrans(
         return write_result(res, result);
 }
 
-int
+int64_t
 nissy_frommoves(
         const char *moves,
         char result[static 22]
@@ -88,7 +88,7 @@ nissy_frommoves(
         return write_result(res, result);
 }
 
-int
+int64_t
 nissy_readcube(
         const char *format,
         const char *cube_string,
@@ -102,7 +102,7 @@ nissy_readcube(
         return write_result(res, result);
 }
 
-int
+int64_t
 nissy_convertcube(
         const char *format_in,
         const char *format_out,
@@ -118,7 +118,7 @@ nissy_convertcube(
         return isconsistent(c) ? 0 : 2;
 }
 
-int
+int64_t
 nissy_writecube(
         const char *format,
         const char cube[static 22],
diff --git a/tables/tables.c b/tables/tables.c
deleted file mode 100644
index bd37831..0000000
--- a/tables/tables.c
+++ /dev/null
@@ -1,34 +0,0 @@
-#define _POSIX_C_SOURCE 200809L /* Required to use clock_gettime */
-
-#include <inttypes.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <time.h>
-
-#include "../src/cube.h"
-
-#define SIZE_H1 118687270
-
-char buf[SIZE_H1];
-
-int main(int argc, char *argv[]) {
-        FILE *f;
-        struct timespec t0, t1;
-        double s;
-
-        clock_gettime(CLOCK_MONOTONIC, &t0);
-        gendata("H48", argc > 1 ? argv[1] : "4", buf);
-        clock_gettime(CLOCK_MONOTONIC, &t1);
-
-        if ((f = fopen("tables/data/h48_test", "wb")) == NULL) {
-                printf("Could not open file!\n");
-                return 1;
-        }
-        fwrite(buf, SIZE_H1, 1, f);
-
-        s = t1.tv_sec - t0.tv_sec + (t1.tv_nsec - t0.tv_nsec) / 1000000000.0;
-        printf("Data generated in %lfs\n", s);
-
-        return 0;
-}