Fix non-if-else test cases. Clean up debug output

1 files changed, 15 insertions, 27 deletions

diff --git a/src/async/library/scala/async/Async.scala b/src/async/library/scala/async/Async.scala
index c4970a4..903ee67 100644
--- a/src/async/library/scala/async/Async.scala
+++ b/src/async/library/scala/async/Async.scala
@@ -404,7 +404,7 @@ class ExprBuilder[C <: Context with Singleton](val c: C) extends AsyncUtils {
       case If(cond, thenp, elsep) =>
         val ifBudget: Int = remainingBudget / 2
         remainingBudget -= ifBudget //TODO test if budget > 0
-        println(s"ASYNC IF: ifBudget = $ifBudget")
+        vprintln(s"ASYNC IF: ifBudget = $ifBudget")
         // state that we continue with after if-else: currState + ifBudget
         
         val thenBudget: Int = ifBudget / 2
@@ -420,10 +420,10 @@ class ExprBuilder[C <: Context with Singleton](val c: C) extends AsyncUtils {
           case _ =>
             new AsyncBlockBuilder(List(thenp), Literal(Constant(())), currState + 1, currState + ifBudget, thenBudget)
         }
-        println("ASYNC IF: thenBuilder: "+thenBuilder)
-        println("ASYNC IF: states of thenp:")
+        vprintln("ASYNC IF: thenBuilder: "+thenBuilder)
+        vprintln("ASYNC IF: states of thenp:")
         for (s <- thenBuilder.asyncStates)
-          println(s.toString)
+          vprintln(s.toString)
         
         // insert states of thenBuilder into asyncStates
         asyncStates ++= thenBuilder.asyncStates
@@ -434,10 +434,10 @@ class ExprBuilder[C <: Context with Singleton](val c: C) extends AsyncUtils {
           case _ =>
             new AsyncBlockBuilder(List(elsep), Literal(Constant(())), currState + thenBudget, currState + ifBudget, elseBudget)
         }
-        println("ASYNC IF: elseBuilder: "+elseBuilder)
-        println("ASYNC IF: states of elsep:")
+        vprintln("ASYNC IF: elseBuilder: "+elseBuilder)
+        vprintln("ASYNC IF: states of elsep:")
         for (s <- elseBuilder.asyncStates)
-          println(s.toString)
+          vprintln(s.toString)
         
         // insert states of elseBuilder into asyncStates
         asyncStates ++= elseBuilder.asyncStates
@@ -452,8 +452,8 @@ class ExprBuilder[C <: Context with Singleton](val c: C) extends AsyncUtils {
     // complete last state builder (representing the expressions after the last await)
     stateBuilder += expr
     val lastState = stateBuilder.complete(endState).result
-    println("ASYNC: last state of current AsyncBlockBuilder "+this+":")
-    println("ASYNC: "+lastState)
+    vprintln("ASYNC: last state of current AsyncBlockBuilder "+this+":")
+    vprintln("ASYNC: "+lastState)
     asyncStates += lastState
     
     /* Builds the handler expression for a sequence of async states.
@@ -461,12 +461,12 @@ class ExprBuilder[C <: Context with Singleton](val c: C) extends AsyncUtils {
     def mkHandlerExpr(): c.Expr[PartialFunction[Int, Unit]] = {
       assert(asyncStates.size > 1)
       
-      println(s"!!ASYNC mkHandlerExpr: asyncStates.size = ${asyncStates.size}")
-      println(s"!!ASYNC state 0: ${asyncStates(0)}")
+      vprintln(s"!!ASYNC mkHandlerExpr: asyncStates.size = ${asyncStates.size}")
+      vprintln(s"!!ASYNC state 0: ${asyncStates(0)}")
       
       var handlerTree =
         if (asyncStates.size > 2) asyncStates(0).mkHandlerTreeForState()
-        else asyncStates(0).mkHandlerTreeForState(endState)
+        else asyncStates(0).mkHandlerTreeForState()
       var handlerExpr =
         c.Expr(handlerTree).asInstanceOf[c.Expr[PartialFunction[Int, Unit]]]
       
@@ -474,19 +474,18 @@ class ExprBuilder[C <: Context with Singleton](val c: C) extends AsyncUtils {
         handlerExpr
       else if (asyncStates.size == 3) {
         // asyncStates(1) must continue with endState
-        val handlerTreeForLastState = asyncStates(1).mkHandlerTreeForState(endState)
+        val handlerTreeForLastState = asyncStates(1).mkHandlerTreeForState()
         val currentHandlerTreeNaked = c.resetAllAttrs(handlerExpr.tree.duplicate)
         c.Expr(
           Apply(Select(currentHandlerTreeNaked, newTermName("orElse")),
                 List(handlerTreeForLastState))).asInstanceOf[c.Expr[PartialFunction[Int, Unit]]]
       } else { // asyncStates.size > 3
-        println("!!ASYNC start for loop")
+        vprintln("!!ASYNC start for loop")
         
         // do not traverse first state: asyncStates.tail
         // do not traverse last state:  asyncStates.tail.init
-        // handle second to last state specially: asyncStates.tail.init.init
         for (asyncState <- asyncStates.tail.init) {
-          println(s"!!ASYNC current asyncState: $asyncState")
+          vprintln(s"!!ASYNC current asyncState: $asyncState")
           val handlerTreeForNextState = asyncState.mkHandlerTreeForState()
           val currentHandlerTreeNaked = c.resetAllAttrs(handlerExpr.tree.duplicate)
           handlerExpr = c.Expr(
@@ -494,16 +493,6 @@ class ExprBuilder[C <: Context with Singleton](val c: C) extends AsyncUtils {
                   List(handlerTreeForNextState))).asInstanceOf[c.Expr[PartialFunction[Int, Unit]]]
         }
         handlerExpr
-/*        
-        val lastState = asyncStates.tail.init.last
-        println(s"!!ASYNC current asyncState (forced to $endState): $lastState")
-        val handlerTreeForLastState = lastState.mkHandlerTreeForState(endState)
-        val currentHandlerTreeNaked = c.resetAllAttrs(handlerExpr.tree.duplicate)
-        c.Expr(
-          Apply(Select(currentHandlerTreeNaked, newTermName("orElse")),
-                List(handlerTreeForLastState))).asInstanceOf[c.Expr[PartialFunction[Int, Unit]]]
-
-*/ 
       }
     }
 
@@ -549,7 +538,6 @@ object Async extends AsyncUtils {
         val handlerForLastState: c.Expr[PartialFunction[Int, Unit]] = {
           val tree = Apply(Select(Ident("result"), c.universe.newTermName("success")),
                            List(asyncBlockBuilder.asyncStates.last.body))
-          //builder.mkHandler(indexOfLastState + 1, c.Expr[Unit](tree))
           builder.mkHandler(asyncBlockBuilder.asyncStates.last.state, c.Expr[Unit](tree))
         }