Added write to SRC format

2 files changed, 104 insertions, 25 deletions

diff --git a/src/cube.h b/src/cube.h
index 3319b1e..129062d 100644
--- a/src/cube.h
+++ b/src/cube.h
@@ -7,12 +7,11 @@ typedef uint8_t trans_t;
 
 extern cube_t solvedcube;
 
-/* For the textual representation of the cube, see utils/FORMAT.txt */
-cube_t readcube(char *);
-void writecube(cube_t, char *);
-
-/* Writes a cube in C source code format */
-void writecubesrc(cube_t, char *);
+/* Not all formats are supported for both read and write. */
+/* See utils/FORMAT.txt for details. */
+typedef enum {H48, SRC} format_t;
+cube_t readcube(format_t, char *);
+void writecube(format_t, cube_t, char *);
 
 bool issolvable(cube_t);
 bool equal(cube_t, cube_t);
diff --git a/src/cube_array.c b/src/cube_array.c
index a9b9709..1d2da86 100644
--- a/src/cube_array.c
+++ b/src/cube_array.c
@@ -156,6 +156,10 @@ static uint8_t readeo(char *);
 static uint8_t readep(char *);
 static uint8_t readmove(char);
 static uint8_t readmodifier(char);
+static cube_t readcube_H48(char *);
+static void writecube_H48(cube_t, char *);
+static int writepiece_SRC(uint8_t, char *);
+static void writecube_SRC(cube_t, char *);
 static int permsign(uint8_t *, int);
 
 static uint8_t
@@ -219,8 +223,8 @@ readep(char *str)
         return _error;
 }
 
-cube_t
-readcube(char *buf)
+static cube_t
+readcube_H48(char *buf)
 {
         int i;
         uint8_t piece, orient;
@@ -231,10 +235,10 @@ readcube(char *buf)
                 while (*b == ' ' || *b == '\t' || *b == '\n')
                         b++;
                 if ((piece = readep(b)) == _error)
-                        goto readcube_error;
+                        return errorcube;
                 b += 2;
                 if ((orient = readeo(b)) == _error)
-                        goto readcube_error;
+                        return errorcube;
                 b++;
                 ret.e[i] = piece | orient;
         }
@@ -242,36 +246,46 @@ readcube(char *buf)
                 while (*b == ' ' || *b == '\t' || *b == '\n')
                         b++;
                 if ((piece = readcp(b)) == _error)
-                        goto readcube_error;
+                        return errorcube;
                 b += 3;
                 if ((orient = readco(b)) == _error)
-                        goto readcube_error;
+                        return errorcube;
                 b++;
                 ret.c[i] = piece | orient;
         }
 
         return ret;
+}
+
+cube_t
+readcube(format_t format, char *buf)
+{
+        cube_t ret;
+
+        switch (format) {
+        case H48:
+                ret = readcube_H48(buf);
+                break;
+        default:
+        #ifdef DEBUG
+                fprintf(stderr, "Cannot read cube in the given format\n");
+        #endif
+                ret = errorcube;
+        }
 
-readcube_error:
 #ifdef DEBUG
-        fprintf(stderr, "readcube error\n");
+        if (iserror(ret))
+                fprintf(stderr, "readcube error\n");
 #endif
-        return errorcube;
+        return ret;
 }
 
-void
-writecube(cube_t cube, char *buf)
+static void
+writecube_H48(cube_t cube, char *buf)
 {
-        char *errormsg;
         uint8_t piece, orient;
-        size_t len;
         int i;
 
-        if (!isconsistent(cube)) {
-                errormsg = "ERROR: cannot write inconsistent cube";
-                goto writecube_error;
-        }
-
         for (i = 0; i < 12; i++) {
                 piece = cube.e[i] & _pbits;
                 orient = (cube.e[i] & _eobit) >> _eoshift;
@@ -291,6 +305,73 @@ writecube(cube_t cube, char *buf)
         }
 
         buf[48+39] = '\0';
+}
+
+static int
+writepiece_SRC(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
+writecube_SRC(cube_t cube, char *buf)
+{
+        int i, ptr;
+
+        memcpy(buf, "{\n\t.c = {", 9);
+        ptr = 9;
+
+        for (i = 0; i < 8; i++)
+                ptr += writepiece_SRC(cube.c[i], buf + ptr);
+
+        memcpy(buf+ptr-2, "},\n\t.e = {", 10);
+        ptr += 8;
+
+        for (i = 0; i < 12; i++)
+                ptr += writepiece_SRC(cube.e[i], buf + ptr);
+
+        memcpy(buf+ptr-2, "}\n}\0", 4);
+}
+
+void
+writecube(format_t format, cube_t cube, char *buf)
+{
+        char *errormsg;
+        size_t len;
+
+        if (!isconsistent(cube)) {
+                errormsg = "ERROR: cannot write inconsistent cube";
+                goto writecube_error;
+        }
+
+        switch (format) {
+        case H48:
+                writecube_H48(cube, buf);
+                break;
+        case SRC:
+                writecube_SRC(cube, buf);
+                break;
+        default:
+                errormsg = "ERROR: cannot write cube in the given format";
+                goto writecube_error;
+        }
 
         return;
 
@@ -304,7 +385,6 @@ writecube_error:
         buf[len+1] = '\0';
 }
 
-
 static uint8_t
 readmove(char c)
 {