further refactor

Author: Guannan Wei

src/main/scala/Memory.scala

@@ -8,84 +8,66 @@ case class RTMemoryType(min: Int, max: Option[Int])
 case class RTMemory(var memType: RTMemoryType, data: ArrayBuffer[Byte]) {
   def size: Int = (data.size / RTMemory.pageSize).toInt
 
-  def grow(delta: Int): Option[RTMemoryException] = {
+  def grow(delta: Int): Option[RTMemoryException] =
     val oldSize = memType.min
     val newSize = oldSize + delta
-    if (newSize < oldSize) {
+    if (newSize < oldSize)
       Some(RTMemoryException("SizeOverflow"))
-    } else {
+    else
       memType = RTMemoryType(newSize, memType.max)
       data ++= Array.fill[Byte](delta * RTMemory.pageSize.toInt)(0)
       None
-    }
-  }
 
-  def loadByte(a: Long): Byte = {
+  def loadByte(a: Long): Byte =
     if (a >= data.size) throw new RTMemoryException("Bounds")
     data(a.toInt)
-  }
 
-  def storeByte(a: Long, b: Byte): Unit = {
+  def storeByte(a: Long, b: Byte): Unit =
     if (a >= data.size) throw new RTMemoryException("Bounds")
     data(a.toInt) = b
-  }
 
-  def loadn(a: Long, o: Int, n: Int): Long = {
+  def loadn(a: Long, o: Int, n: Int): Long =
     assert(n > 0 && n <= 8)
     var result: Long = 0
-    for (i <- (n - 1) to 0 by -1) { // Little-endian: start from least significant byte
+    for (i <- (n - 1) to 0 by -1) // Little-endian: start from least significant byte
       result = (result << 8) | (loadByte(a + i) & 0xff)
-    }
     result
-  }
 
-  def storen(a: Long, o: Int, n: Int, x: Long): Unit = {
+  def storen(a: Long, o: Int, n: Int, x: Long): Unit =
     assert(n > 0 && n <= 8)
     var temp = x
-    for (i <- 0 until n) {
+    for (i <- 0 until n)
       storeByte(a + i, (temp & 0xff).toByte) // Little-endian: store least significant byte first
       temp = temp >> 8
-    }
-  }
 
   // TODO: store/load different types
-  def loadInt(addr: Long): Int = {
+  def loadInt(addr: Long): Int =
     val result: Long = loadn(addr, 0, 4)
     result.toInt
-  }
 
-  def storeInt(addr: Long, num: Int): Unit = {
+  def storeInt(addr: Long, num: Int): Unit =
     storen(addr, 0, 4, num)
-  }
 
-  def fill(offset: Long, size: Long, value: Byte): Unit = {
+  def fill(offset: Long, size: Long, value: Byte): Unit =
     // TODO: instead of using storeByte and loadByte, check
     // bounds up front so we can avoid the checks in load/storeByte
-    for (i <- offset until offset + size) {
+    for (i <- offset until offset + size)
       storeByte(i, value)
-    }
-  }
 
-  def copy(src: Long, dst: Long, size: Long): Unit = {
+  def copy(src: Long, dst: Long, size: Long): Unit =
     // TODO: instead of using storeByte and loadByte, check
     // bounds up front so we can avoid the checks in load/storeByte
-    if (src < dst) {
-      for (i <- size - 1 to 0 by -1) {
+    if (src < dst)
+      for (i <- size - 1 to 0 by -1)
         storeByte(dst + i, loadByte(src + i))
-      }
-    } else {
-      for (i <- 0 until size.toInt) {
+    else
+      for (i <- 0 until size.toInt)
         storeByte(dst + i, loadByte(src + i))
-      }
-    }
-  }
 }
 
-object RTMemory {
+object RTMemory:
   val pageSize = 65536 // https://www.w3.org/TR/wasm-core-2/exec/runtime.html#memory-instances
   def apply(): RTMemory = this.apply(1024)
   def apply(size: Int): RTMemory = this.apply(size, None)
-  def apply(size: Int, maxSize: Option[Int]): RTMemory = {
+  def apply(size: Int, maxSize: Option[Int]): RTMemory =
     new RTMemory(RTMemoryType(size, maxSize), ArrayBuffer.fill[Byte](size * pageSize.toInt)(0))
-  }
-}

src/main/scala/MiniWasm.scala

@@ -26,15 +26,9 @@ case class Evaluator(module: ModuleInstance) {
         val newStack = stack.drop(ty.inps.size)
         val frameLocals = args ++ locals.map(zero(_))
         val newFrame = Frame(ArrayBuffer(frameLocals: _*))
-        if (isTail)
-          // when tail call, share the continuation for returning with the callee
-          eval(body, List(), newFrame, kont, List(kont))
-        else
-          val restK: Cont[Ans] = (retStack) =>
-            eval(rest, retStack.take(ty.out.size) ++ newStack, frame, kont, trail)
-          // We make a new trail by `restK`, since function creates a new block to escape
-          // (more or less like `return`)
-          eval(body, List(), newFrame, restK, List(restK))
+        val restK: Cont[Ans] = (retStack) =>
+          eval(rest, retStack.take(ty.out.size) ++ newStack, frame, kont, trail)
+        eval(body, List(), newFrame, restK, List(restK))
       case Import("console", "log", _) =>
         val I32V(v) :: newStack = stack
         println(v)
@@ -166,9 +160,7 @@ case class Evaluator(module: ModuleInstance) {
         trail(goto)(newStack)
       case Return        => trail.last(stack)
       case Call(f)       => evalCall(rest, stack, frame, kont, trail, f, false)
-      case _ =>
-        println(inst)
-        throw new Exception(s"instruction $inst not implemented")
+      case _             => throw new Exception(s"instruction $inst not implemented")
 
   // If `main` is given, then we use that function as the entry point of the program;
   // otherwise, we look up the top-level `start` instruction to locate the entry point.