Fix interpreter entrypoint for other interpreters

src/main/scala/ir/eval/InterpretBasilIR.scala

@@ -293,7 +293,7 @@ enum InterpretReturn {
 }
 
 class BASILInterpreter[S](f: Effects[S, InterpreterError])
-    extends Interpreter[S, InterpretReturn, InterpreterError](f) {
+/*extends Interpreter[S, InterpretReturn, InterpreterError](f) */ {
 
   def interpretOne: util.functional.State[S, Next[InterpretReturn], InterpreterError] =
     InterpFuns.interpretContinuation(f)
@@ -724,8 +724,6 @@ object InterpFuns {
     }.toMap
   }
 
-  def interpretEvalProcExc(program: IRContext | Program, functionName: String, params: Map[String, Literal]) = {}
-
   /* Intialise from ELF and Interpret program */
   def interpretEvalProg[S, T <: Effects[S, InterpreterError]](
     f: T
@@ -735,6 +733,13 @@ object InterpFuns {
     callProcedure(f)(main, mainDefaultFunctionArguments(main)).f(begin)
   }
 
+  def interpretEvalProgSkipInit[S, T <: Effects[S, InterpreterError]](
+    f: T
+  )(p: Program, begin: S): (S, Either[InterpreterError, Map[LocalVar, Literal]]) = {
+    val main = p.mainProcedure
+    callProcedure(f)(main, mainDefaultFunctionArguments(main)).f(begin)
+  }
+
   /* Interpret IR program */
   def interpretEvalProg[S, T <: Effects[S, InterpreterError]](
     f: T

src/main/scala/ir/eval/InterpretRLimit.scala

@@ -50,7 +50,7 @@ def interpretWithRLimit[I](
   val rlimitInterpreter = LayerInterpreter(innerInterpreter, EffectsRLimit(instructionLimit))
   val begin = InterpFuns.initProgState(rlimitInterpreter)(p, (innerInitialState, 0))
   // throw away initialisation trace
-  BASILInterpreter(rlimitInterpreter).run((begin._1, 0))
+  InterpFuns.interpretEvalProgSkipInit(rlimitInterpreter)(p.program, (begin._1, 0))._1
 }
 
 def interpretRLimit(p: Program, instructionLimit: Int): (InterpreterState, Int) = {

src/main/scala/ir/eval/InterpretTrace.scala

@@ -75,7 +75,7 @@ def interpretWithTrace[I](
   val tracingInterpreter = ProductInterpreter(innerInterpreter, TraceGen())
   val begin = InterpFuns.initProgState(tracingInterpreter)(p, (innerInitialState, Trace.empty))
   // throw away initialisation trace
-  BASILInterpreter(tracingInterpreter).run((begin._1, Trace.empty))
+  InterpFuns.interpretEvalProgSkipInit(tracingInterpreter)(p.program, (begin._1, Trace.empty))._1
 }
 
 def interpretTrace(p: Program) = {

src/main/scala/ir/eval/Interpreter.scala

@@ -673,14 +673,3 @@ def evalInterpreter[S, V, E](f: Effects[S, E], doStep: State[S, Next[V], E]): St
 
   State(begin => runEval(begin))
 }
-
-trait Interpreter[S, V, E](val f: Effects[S, E]) {
-
-  /*
-   * Returns value deciding whether to continue.
-   */
-  def interpretOne: State[S, Next[V], E]
-
-  final def run(begin: S): S = State.execute(begin, (evalInterpreter(f, interpretOne)))
-
-}

src/test/scala/DifferentialAnalysisTest.scala

@@ -40,11 +40,14 @@ class DifferentialTest extends AnyFunSuite {
 
     def interp(p: IRContext): (InterpreterState, Trace) = {
       val interpreter = LayerInterpreter(tracingInterpreter(NormalInterpreter), EffectsRLimit(instructionLimit))
-      val initialState = InterpFuns.initProgState(NormalInterpreter)(p, InterpreterState())
+      val initialState = ((InterpFuns.initProgState(NormalInterpreter)(p, InterpreterState()), Trace.empty), 0)
       // Logger.setLevel(LogLevel.DEBUG)
-      val r = BASILInterpreter(interpreter).run((initialState, Trace.empty), 0)._1
-      // Logger.setLevel(LogLevel.WARN)
-      r
+
+      val main = p.program.mainProcedure
+      val r = InterpFuns
+        .callProcedure(interpreter)(main, InterpFuns.mainDefaultFunctionArguments(main))
+        .f(initialState)
+      r._1._1
     }
 
     val (initialRes, traceInit) = interp(initial)
@@ -62,11 +65,13 @@ class DifferentialTest extends AnyFunSuite {
     val initstdout =
       initialRes.memoryState.getMem("stdout").toList.sortBy(_._1.value).map(_._2.value.toChar).mkString("")
     val comparstdout = result.memoryState.getMem("stdout").toList.sortBy(_._1.value).map(_._2.value.toChar).mkString("")
-    info("STDOUT: \"" + initstdout + "\"")
+    if (initstdout.nonEmpty) {
+      info("STDOUT: \"" + initstdout + "\"")
+    }
     // Logger.info(initialRes.memoryState.getMem("stderr").toList.sortBy(_._1.value).map(_._2).mkString(""))
     assert(initstdout == comparstdout)
-    assert(initialRes.nextCmd == Stopped())
-    assert(result.nextCmd == Stopped())
+    assert(normalTermination(initialRes.nextCmd), initialRes.nextCmd)
+    assert(normalTermination(result.nextCmd), initialRes.nextCmd)
     assert(Set.empty == initialRes.memoryState.getMem("mem").toSet.diff(result.memoryState.getMem("mem").toSet))
     assert(traceInit.t.nonEmpty)
     assert(traceRes.t.nonEmpty)

src/test/scala/ir/InterpreterTests.scala

@@ -301,6 +301,7 @@ class InterpreterTests extends AnyFunSuite with BeforeAndAfter {
     val r = interpretTrace(fib)
 
     assert(normalTermination(r._1.nextCmd), r._1.nextCmd)
+    assert(r._2.t.nonEmpty, "Trace was empty")
 
   }