add a little interpreter for affine expressions

it lowk kinda slow tho

Author: rhysdh540

src/commonMain/kotlin/dev/rdh/bf/affine.kt

@@ -6,7 +6,7 @@ package dev.rdh.bf
  * This IR has explicit block semantics:
  * - offsets are normalized relative to a block base shift
  * - writes are grouped into batches with entry-state references
- * - [BFAffinePrint]/[BFAffineInput] act as ordering barriers between write batches
+ * - [BFAffineOutput]/[BFAffineInput] act as ordering barriers between write batches
  */
 sealed interface BFAffineOp
 
@@ -48,7 +48,7 @@ sealed interface BFAffineSegment
 data class BFAffineWriteBatch(val writes: List<BFAffineWrite>) : BFAffineSegment
 
 /** Print the byte at [offset] relative to the block-shifted pointer. */
-data class BFAffinePrint(val offset: Int) : BFAffineSegment
+data class BFAffineOutput(val offset: Int) : BFAffineSegment
 
 /** Read one byte into [offset] relative to the block-shifted pointer. */
 data class BFAffineInput(val offset: Int) : BFAffineSegment
@@ -62,7 +62,7 @@ data class BFAffineWrite(
 /**
  * Affine expression over referenced cell values.
  *
- * `constant + sum(terms[i].coefficient * ref(terms[i].offset))`
+ * `constant + sum(terms[i].coefficient * tape[ptr + terms[i].offset])`
  */
 data class BFAffineExpr(
     val constant: Int = 0,
@@ -82,6 +82,36 @@ private data class MutableExpr(
         terms = terms.toMutableMap(),
         constant = constant,
     )
+
+    operator fun plus(other: MutableExpr): MutableExpr {
+        val out = copyExpr()
+        out.constant += other.constant
+        for ((ref, coeff) in other.terms) {
+            val next = (out.terms[ref] ?: 0) + coeff
+            if (next == 0) {
+                out.terms.remove(ref)
+            } else {
+                out.terms[ref] = next
+            }
+        }
+        return out
+    }
+
+    operator fun times(multiplier: Int): MutableExpr {
+        if (multiplier == 0) return constExpr(0)
+        val out = copyExpr()
+        out.constant *= multiplier
+        val refs = out.terms.keys.toList()
+        for (ref in refs) {
+            val next = (out.terms[ref] ?: 0) * multiplier
+            if (next == 0) {
+                out.terms.remove(ref)
+            } else {
+                out.terms[ref] = next
+            }
+        }
+        return out
+    }
 }
 
 private sealed interface LoweringStep
@@ -94,36 +124,6 @@ private data class StepCopy(val sourceOffset: Int, val targetOffset: Int, val mu
 private fun refExpr(offset: Int): MutableExpr = MutableExpr(terms = mutableMapOf(offset to 1))
 private fun constExpr(value: Int): MutableExpr = MutableExpr(constant = value)
 
-private operator fun MutableExpr.plus(other: MutableExpr): MutableExpr {
-    val out = copyExpr()
-    out.constant += other.constant
-    for ((ref, coeff) in other.terms) {
-        val next = (out.terms[ref] ?: 0) + coeff
-        if (next == 0) {
-            out.terms.remove(ref)
-        } else {
-            out.terms[ref] = next
-        }
-    }
-    return out
-}
-
-private operator fun MutableExpr.times(multiplier: Int): MutableExpr {
-    if (multiplier == 0) return constExpr(0)
-    val out = copyExpr()
-    out.constant *= multiplier
-    val refs = out.terms.keys.toList()
-    for (ref in refs) {
-        val next = (out.terms[ref] ?: 0) * multiplier
-        if (next == 0) {
-            out.terms.remove(ref)
-        } else {
-            out.terms[ref] = next
-        }
-    }
-    return out
-}
-
 /**
  * Lowers a loop-free basic block to affine form.
  *
@@ -222,7 +222,7 @@ private fun lowerLinearBlock(block: List<BFOperation>): BFAffineBlock? {
             }
             is StepPrint -> {
                 flushState()
-                segments += BFAffinePrint(offset = eff(step.offset))
+                segments += BFAffineOutput(offset = eff(step.offset))
             }
             is StepInput -> {
                 flushState()

src/commonMain/kotlin/dev/rdh/bf/affineinterpreter.kt

@@ -0,0 +1,61 @@
+package dev.rdh.bf
+
+object AffineInterpreterRunner : BfRunner {
+    override fun compile(program: Iterable<BFOperation>): BfExecutable {
+        val lowered = bfLowerAffine(program.toList())
+        return BfExecutable { i, o -> bfRunAffine(lowered, i, o) }
+    }
+}
+
+@OptIn(ExperimentalUnsignedTypes::class)
+fun bfRunAffine(program: List<BFAffineOp>, stdin: BfInput, stdout: BfOutput) {
+    runAffineImpl(UByteArray(TAPE_SIZE), 0, program, stdin, stdout)
+    stdout.flush()
+}
+
+@OptIn(ExperimentalUnsignedTypes::class)
+private fun runAffineImpl(tape: UByteArray, pointer: Int,
+                          program: List<BFAffineOp>,
+                          stdin: BfInput, stdout: BfOutput): Int {
+    var pointer = pointer
+
+    for (op in program) {
+        when (op) {
+            is BFAffineBlock -> {
+                pointer += op.baseShift
+                for (seg in op.segments) {
+                    when (seg) {
+                        is BFAffineInput -> {
+                            tape[pointer] = stdin.readByte().toUByte()
+                        }
+                        is BFAffineOutput -> {
+                            stdout.writeByte(tape[pointer].toInt())
+                        }
+                        is BFAffineWriteBatch -> {
+                            val values = seg.writes
+                                .flatMap { write -> write.expr.terms.map { it.offset } }
+                                .distinct()
+                                .associateWith { offset ->
+                                    tape[pointer.wrappingAdd(offset, TAPE_SIZE)].toInt()
+                                }
+                            for (write in seg.writes) {
+                                val expr = write.expr.constant + write.expr.terms.sumOf { term ->
+                                    values[term.offset]!! * term.coefficient
+                                }
+                                tape[pointer.wrappingAdd(write.offset, TAPE_SIZE)] = expr.toUByte()
+                            }
+                        }
+                    }
+                }
+                pointer += op.pointerDelta - op.baseShift
+            }
+            is BFAffineLoop -> {
+                while (tape[pointer].toInt() != 0) {
+                    pointer = runAffineImpl(tape, pointer, op, stdin, stdout)
+                }
+            }
+        }
+    }
+
+    return pointer
+}

src/commonMain/kotlin/dev/rdh/bf/interpreter.kt

@@ -1,10 +1,13 @@
 package dev.rdh.bf
 
+object InterpreterRunner : BfRunner {
+    override fun compile(program: Iterable<BFOperation>): BfExecutable {
+        return BfExecutable { i, o -> bfRun(program, i, o) }
+    }
+}
+
 @OptIn(ExperimentalUnsignedTypes::class)
-fun bfRun(program: Iterable<BFOperation>,
-          stdin: BfInput,
-          stdout: BfOutput,
-) {
+fun bfRun(program: Iterable<BFOperation>, stdin: BfInput, stdout: BfOutput) {
     runImpl(UByteArray(TAPE_SIZE), 0, program.toList(), stdin, stdout)
     stdout.flush()
 }

src/commonMain/kotlin/dev/rdh/bf/runner.kt

@@ -12,12 +12,6 @@ interface BfRunner {
     }
 }
 
-object InterpreterRunner : BfRunner {
-    override fun compile(program: Iterable<BFOperation>): BfExecutable {
-        return BfExecutable { i, o -> bfRun(program, i, o) }
-    }
-}
-
 /**
  * Options for the system runner, which may be used to enable or disable certain features of the runner.
  * Not all of these options may be supported on all platforms, and may be ignored if the runner does not support them.

src/jvmMain/kotlin/dev/rdh/bf/jit.kt

@@ -201,7 +201,7 @@ fun bfCompile(program: Iterable<BFAffineOp>, opts: SystemRunnerOptions): (Reader
             }
         }
 
-        is BFAffinePrint -> {
+        is BFAffineOutput -> {
             load(output)
             loadCell(segment.offset)
             int(0xFF)

src/jvmTest/kotlin/AffineLoweringTest.kt

@@ -1,7 +1,7 @@
 import dev.rdh.bf.BFAffineBlock
 import dev.rdh.bf.BFAffineInput
 import dev.rdh.bf.BFAffineLoop
-import dev.rdh.bf.BFAffinePrint
+import dev.rdh.bf.BFAffineOutput
 import dev.rdh.bf.BFAffineWrite
 import dev.rdh.bf.BFAffineWriteBatch
 import dev.rdh.bf.Copy
@@ -54,7 +54,7 @@ class AffineLoweringTest {
         assertEquals(0, block.pointerDelta)
         assertEquals(5, block.segments.size)
         assertIs<BFAffineWriteBatch>(block.segments[0])
-        assertIs<BFAffinePrint>(block.segments[1])
+        assertIs<BFAffineOutput>(block.segments[1])
         assertIs<BFAffineWriteBatch>(block.segments[2])
         assertIs<BFAffineInput>(block.segments[3])
         assertIs<BFAffineWriteBatch>(block.segments[4])

src/wasmJsMain/kotlin/dev/rdh/bf/jit.kt

@@ -196,7 +196,7 @@ private fun makeProgram(ns: BinaryenNamespace, m: BinaryenModule, program: List<
 
         for (segment in block.segments) {
             when (segment) {
-                is BFAffinePrint -> {
+                is BFAffineOutput -> {
                     result += m.call(
                         "write",
                         listOf(load(segment.offset)),