user input, file IO, and mycorand test

Author: FalsePattern

README.MD

@@ -24,5 +24,5 @@ A standard-conforming Funge-98 interpreter.
 - [ROMA](https://catseye.tc/view/funge-98/library/ROMA.markdown)
 
 ### Additional goals
-- [ ] File IO
+- [x] File IO
 - [x] Concurrency

src/main/java/com/falsepattern/jfunge/Main.java

@@ -67,6 +67,6 @@ public static void main(String[] args) throws IOException {
         } else {
             program = Files.readAllBytes(Paths.get(file));
         }
-        System.exit(Interpreter.executeProgram(trefunge, args, program, maxIter, System.in, System.out));
+        System.exit(Interpreter.executeProgram(trefunge, args, program, maxIter, System.in, System.out, Interpreter.DEFAULT_FILE_IO_SUPPLIER));
     }
 }

src/main/java/com/falsepattern/jfunge/interpreter/ExecutionContext.java

@@ -3,10 +3,10 @@
 import com.falsepattern.jfunge.ip.InstructionPointer;
 import com.falsepattern.jfunge.storage.FungeSpace;
 
-import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.List;
 import java.util.Map;
+import java.util.Scanner;
 
 public interface ExecutionContext {
     InstructionPointer[] allIPs();
@@ -22,6 +22,8 @@ public interface ExecutionContext {
     List<String> args();
     Map<String, String> env();
     int paradigm();
-    InputStream input();
+    int input(boolean stagger);
     OutputStream output();
+    byte[] readFile(String file);
+    boolean writeFile(String file, byte[] data);
 }

src/main/java/com/falsepattern/jfunge/interpreter/Interpreter.java

@@ -8,26 +8,42 @@
 import lombok.Getter;
 import lombok.experimental.Accessors;
 import lombok.val;
+import lombok.var;
 
-import java.io.InputStream;
-import java.io.OutputStream;
+import java.io.*;
+import java.nio.file.Files;
+import java.nio.file.Paths;
 import java.util.*;
 
 @Accessors(fluent = true)
 public class Interpreter implements ExecutionContext {
+    public static final FileIOSupplier DEFAULT_FILE_IO_SUPPLIER = new FileIOSupplier() {
+        @Override
+        public byte[] readFile(String file) throws IOException {
+            return Files.readAllBytes(Paths.get(file));
+        }
+
+        @Override
+        public boolean writeFile(String file, byte[] data) throws IOException {
+            Files.write(Paths.get(file), data);
+            return true;
+        }
+    };
     @Getter
     private final FungeSpace fungeSpace = new FungeSpace(' ');
 
     private final List<InstructionPointer> IPs = new ArrayList<>();
 
     private final InstructionManager baseInstructionManager = new InstructionManager();
 
-    @Getter
     private final InputStream input;
 
+
     @Getter
     private final OutputStream output;
 
+    private final FileIOSupplier fileIOSupplier;
+
     @Getter
     private final List<String> args;
 
@@ -42,8 +58,11 @@ public class Interpreter implements ExecutionContext {
 
     private int nextUUID = 0;
 
-    public static int executeProgram(boolean trefunge, String[] args, byte[] program, long iterLimit, InputStream input, OutputStream output) {
-        val interpreter = new Interpreter(trefunge, args, input, output);
+    private int inputStagger;
+
+
+    public static int executeProgram(boolean trefunge, String[] args, byte[] program, long iterLimit, InputStream input, OutputStream output, FileIOSupplier fileIOSupplier) {
+        val interpreter = new Interpreter(trefunge, args, input, output, fileIOSupplier);
         interpreter.fungeSpace().loadFileAt(0, 0, 0, program, trefunge);
         if (iterLimit > 0) {
             long step = 0;
@@ -60,12 +79,13 @@ public static int executeProgram(boolean trefunge, String[] args, byte[] program
         return interpreter.exitCode();
     }
 
-    public Interpreter(boolean trefunge, String[] args, InputStream input, OutputStream output) {
+    public Interpreter(boolean trefunge, String[] args, InputStream input, OutputStream output, FileIOSupplier fileIOSupplier) {
         this.args = Arrays.asList(args);
         dimensions = trefunge ? 3 : 2;
         baseInstructionManager.loadInstructionSet(Funge98.INSTANCE);
         this.input = input;
         this.output = output;
+        this.fileIOSupplier = fileIOSupplier;
         val ip = new InstructionPointer();
         ip.UUID = nextUUID++;
         IPs.add(ip);
@@ -176,6 +196,48 @@ public int paradigm() {
         return 0;
     }
 
+    @Override
+    public int input(boolean stagger) {
+        var value = -1;
+        if (inputStagger > 0) {
+            value = inputStagger;
+            inputStagger = -1;
+        } else {
+            try {
+                value = input.read();
+            } catch (IOException e) {
+                value = -1;
+            }
+        }
+        if (stagger) {
+            inputStagger = value;
+        }
+        return value;
+    }
+
+    @Override
+    public byte[] readFile(String file) {
+        try {
+            return fileIOSupplier.readFile(file);
+        } catch (IOException e) {
+            return null;
+        }
+    }
+
+    @Override
+    public boolean writeFile(String file, byte[] data) {
+        try {
+            return fileIOSupplier.writeFile(file, data);
+        } catch (IOException e) {
+            return false;
+        }
+    }
+
+    public interface FileIOSupplier {
+        byte[] readFile(String file) throws IOException;
+        boolean writeFile(String file, byte[] data) throws IOException;
+    }
+
     public void tick() {
         currentIP = null;
         for (int i = 0; i < IPs.size(); i++) {

src/main/java/com/falsepattern/jfunge/interpreter/instructions/Funge98.java

@@ -463,7 +463,7 @@ public static void sysInfo(ExecutionContext ctx) {
         //2 bpc
         s.push(4);
         //1 flags
-        s.push(0b00000001);
+        s.push(0b00000111);
         if (n > 0) {
             int curr = s.pick(n - 1);
             for (int i = s.size(); i >= tossSize; i--) {
@@ -485,6 +485,93 @@ public static void split(ExecutionContext ctx) {
         clone.delta.mul(-1);
     }
 
+    @Instr('i')
+    public static void input(ExecutionContext ctx) {
+        val s = ctx.IP().stackStack.TOSS();
+        val filename = s.popString();
+        val flags = s.pop();
+        val pos = new Vector3i();
+        if (ctx.dimensions() == 3) {
+            s.pop3(pos);
+        } else {
+            pos.set(s.pop2(), 0);
+        }
+        pos.add(ctx.IP().storageOffset);
+        val file = ctx.readFile(filename);
+        if (file == null) {
+            ctx.interpret('r');
+            return;
+        }
+        val delta = ((flags & 1) == 1) ? ctx.fungeSpace().loadBinaryFileAt(pos.x, pos.y, pos.z, file) : ctx.fungeSpace().loadFileAt(pos.x, pos.y, pos.z, file, ctx.dimensions() == 3);
+        pos.sub(ctx.IP().storageOffset);
+        if (ctx.dimensions() == 3) {
+            s.push3(delta);
+            s.push3(pos);
+        } else {
+            s.push2(new Vector2i(delta.x, delta.y));
+            s.push2(new Vector2i(pos.x, pos.y));
+        }
+    }
+
+    @Instr('o')
+    public static void output(ExecutionContext ctx) {
+        val s = ctx.IP().stackStack.TOSS();
+        val filename = s.popString();
+        val flags = s.pop();
+        val pos = new Vector3i();
+        val delta = new Vector3i();
+        if (ctx.dimensions() == 3) {
+            s.pop3(pos);
+            s.pop3(delta);
+        } else {
+            pos.set(s.pop2(), 0);
+            delta.set(s.pop2(), 1);
+        }
+        pos.add(ctx.IP().storageOffset);
+        val data = ctx.fungeSpace().readDataAt(pos.x, pos.y, pos.z, delta.x, delta.y, delta.z, (flags & 1) == 1);
+        if (!ctx.writeFile(filename, data)) {
+            ctx.interpret('r');
+        }
+    }
+
+    @Instr('&')
+    @SneakyThrows
+    public static void readInt(ExecutionContext ctx) {
+        ctx.output().flush();
+        var counter = 0;
+        var found = false;
+        var next = 0;
+        while ((next = ctx.input(true)) < '0' || next > '9') {
+            ctx.input(false);
+        }
+        while (true) {
+            next = ctx.input(true);
+            if (next >= '0' && next <= '9' && (counter * 10 >= counter)) {
+                found = true;
+                counter *= 10;
+                counter += next - '0';
+                ctx.input(false);
+            } else {
+                if (next == '\n') {
+                    ctx.input(false);
+                }
+                break;
+            }
+        }
+        if (found) {
+            ctx.IP().stackStack.TOSS().push(counter);
+        } else {
+            ctx.interpret('r');
+        }
+    }
+
+    @Instr('~')
+    @SneakyThrows
+    public static void readChar(ExecutionContext ctx) {
+        ctx.output().flush();
+        ctx.IP().stackStack.TOSS().push(ctx.input(false));
+    }
+
     @Override
     public void load(ObjIntConsumer<Instruction> instructionSet) {
         InstructionSet.super.load(instructionSet);

src/main/java/com/falsepattern/jfunge/storage/FungeSpace.java

@@ -7,6 +7,8 @@
 import org.joml.Vector3i;
 import org.joml.Vector3ic;
 
+import java.io.ByteArrayOutputStream;
+
 import static com.falsepattern.jfunge.storage.Chunk.*;
 
 @RequiredArgsConstructor
@@ -128,10 +130,18 @@ public void gc() {
         }
     }
 
-    public void loadFileAt(int x, int y, int z, byte[] data, boolean trefunge) {
+    public Vector3i loadBinaryFileAt(int x, int y, int z, byte[] data) {
+        for (int i = 0; i < data.length; i++) {
+            set(x + i, y, z, Byte.toUnsignedInt(data[i]));
+        }
+        return new Vector3i(x + data.length - 1, y, z);
+    }
+
+    public Vector3i loadFileAt(int x, int y, int z, byte[] data, boolean trefunge) {
         int X = x;
         int Y = y;
         int Z = z;
+        val ret = new Vector3i(x, y, z);
         for (int i = 0; i < data.length; i++) {
             int c = Byte.toUnsignedInt(data[i]);
             switch (c) {
@@ -149,9 +159,48 @@ public void loadFileAt(int x, int y, int z, byte[] data, boolean trefunge) {
                     }
                     continue;
             }
-            set(X, Y, Z, c);
+            ret.x = Math.max(ret.x, X);
+            ret.y = Math.max(ret.y, Y);
+            ret.z = Math.max(ret.z, Z);
+            if (c != defaultValue) {
+                set(X, Y, Z, c);
+            }
             X++;
         }
+        return ret.sub(x - 1, y - 1, z - 1);
+    }
+
+    public byte[] readDataAt(int x, int y, int z, int dX, int dY, int dZ, boolean textFile) {
+        val out = new ByteArrayOutputStream();
+        for (int accumulatedFormFeeds = 0, Z = z; Z < z + dZ; Z++, accumulatedFormFeeds++) {
+            if (!textFile && accumulatedFormFeeds > 0) {
+                out.write('\t');
+            }
+            for (int accumulatedLineFeeds = 0, Y = y; Y < y + dY; Y++, accumulatedLineFeeds++) {
+                if (!textFile && accumulatedLineFeeds > 0) {
+                    out.write('\n');
+                }
+                for (int accumulatedSpaces = 0, X = x; X < x + dX; X++) {
+                    val c = get(X, Y, Z);
+                    if (textFile) {
+                        if (c == defaultValue) {
+                            accumulatedSpaces++;
+                        } else {
+                            for (; accumulatedFormFeeds > 0; accumulatedFormFeeds--)
+                                out.write('\f');
+                            for (; accumulatedLineFeeds > 0; accumulatedLineFeeds--)
+                                out.write('\n');
+                            for (; accumulatedSpaces > 0; accumulatedSpaces--)
+                                out.write(defaultValue);
+                            out.write(c);
+                        }
+                    } else {
+                        out.write(c);
+                    }
+                }
+            }
+        }
+        return out.toByteArray();
     }
 
     public void wipe() {