improve for syntax

Author: ailrst

src/main/scala/ir/dsl/DSL.scala

@@ -372,6 +372,17 @@ case class EventuallyProgram(
   def cloneable = this.copy(mainProcedure = mainProcedure.cloneable, otherProcedures = otherProcedures.map(_.cloneable))
 }
 
+/**
+ * Construction of basil IR programs from high level while langauge. 
+ *
+ * These functions uniformly return a list of eventually block, where the first block 
+ * is the entry point and the last block is the exit point. 
+ * These lists are then concatenated  by the functions [[sequence]] and [[blocks]]. 
+ * The function  [[blocks]] is essentially list.concat, but it connects each sublist 
+ * with jumps.
+ *
+ */
+
 object Counter {
   var count = 1
   def next() = {
@@ -421,11 +432,16 @@ def setSuccIfUndef(first: List[EventuallyBlock], rest: EventuallyBlock*) = {
   first
 }
 
-//def While(cond: Expr, body: EventuallyBlock*): List[EventuallyBlock] = {
-//  While(cond, body.toList)
-//}
+case class For(init: List[EventuallyBlock], cond: Expr, after: List[EventuallyBlock]) {
+  def Do(body: Iterable[EventuallyBlock]) = mkFor(init, cond, after, (body.toList))
+  @targetName("doBlocks")
+  def Do(body: EventuallyBlock*) = mkFor(init, cond, after, (body.toList))
+  @targetName("doStatements")
+  def Do(sl: (EventuallyCall | NonCallStatement | EventuallyStatement | EventuallyJump)*) =
+    mkFor(init, cond, after, (List(stmts(sl: _*))))
+}
 
-def For(
+private def mkFor(
   init: List[EventuallyBlock],
   cond: Expr,
   after: List[EventuallyBlock],
@@ -438,23 +454,6 @@ def For(
   sequence(init, loop)
 }
 
-//def For(init: EventuallyBlock, cond: Expr, after: EventuallyBlock, body: EventuallyBlock*): List[EventuallyBlock] = {
-//  For(List(init), cond, List(after), body.toList)
-//}
-//
-//def For(init: NonCallStatement, cond: Expr, after: NonCallStatement, body: EventuallyBlock*): List[EventuallyBlock] = {
-//  require(body.nonEmpty)
-//  For(List(stmts(init)), cond, List(stmts(after)), body.toList)
-//}
-//def For(
-//  init: NonCallStatement,
-//  cond: Expr,
-//  after: NonCallStatement,
-//  body: List[EventuallyBlock]
-//): List[EventuallyBlock] = {
-//  For(List(stmts(init)), cond, List(stmts(after)), body.toList)
-//}
-
 case class WhileDo(cond: Expr) {
   def Do(body: Iterable[EventuallyBlock]) = While(cond, (body.toList))
   @targetName("doBlocks")
@@ -555,9 +554,12 @@ def progUnresolved(
 ): EventuallyProgram =
   EventuallyProgram(mainProc, procedures, initialMemory)
 
-  /**
-   * Expr construction
-   */
+/**
+ * Expr and statement construction; this defined infix operators which construct
+ * BASIL IR statements and expressions.
+ *
+ * Typically with binops we default to signed ops, and provide named unsigned alternatives.
+ */
 
 extension (lvar: Variable)
   infix def :=(j: Expr) = LocalAssign(lvar, j)

src/test/scala/ir/InterpreterTests.scala

@@ -101,10 +101,13 @@ class InterpreterTests extends AnyFunSuite with BeforeAndAfter {
         "is_prime",
         Seq("n" -> bv64),
         Seq("ans" -> bv1),
-        (If(n <= 1.bv64)
-          Then (ret("ans" -> (0.bv1)))
-          Else (For(i := (2.bv64), i < n, i := i + (1.bv64), If(n % i === (0.bv64)) Then (ret("ans" -> (0.bv1))))))
-          `;` stmts(ret("ans" -> (1.bv1)))
+        blocks(
+          If(n <= 1.bv64)
+            Then (ret("ans" -> (0.bv1)))
+            Else (For(i := (2.bv64), i < n, i := i + (1.bv64))
+              Do (If(n % i === (0.bv64)) Then (ret("ans" -> (0.bv1))))),
+          ret("ans" -> (1.bv1))
+        )
       )
     )