From 30bd39df864596153a21ae31175558db38dd29ef Mon Sep 17 00:00:00 2001 From: phaller Date: Mon, 29 Oct 2012 17:54:41 +0100 Subject: Fix non-if-else test cases. Clean up debug output --- src/async/library/scala/async/Async.scala | 42 +++++++++++-------------------- 1 file changed, 15 insertions(+), 27 deletions(-) (limited to 'src') 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)) } -- cgit v1.2.3