From 5bde3e22746c411ca255dac368e22cf16b69ff63 Mon Sep 17 00:00:00 2001 From: marciocg Date: Sun, 15 Aug 2021 11:59:16 -0300 Subject: [PATCH 1/3] Adiciona .gitignore --- .gitignore | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..4fb68e9 --- /dev/null +++ b/.gitignore @@ -0,0 +1,10 @@ +*.class +*.log +.bloop/ +.metals/ +.vscode/ +target/ +project/ + +# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml +hs_err_pid* From 7c1724a92397931c37cc3ba1702a7adc34ddf659 Mon Sep 17 00:00:00 2001 From: marciocg Date: Sun, 15 Aug 2021 14:18:36 -0300 Subject: [PATCH 2/3] Comments the 'ReachDefinition' with questions that need clarification; Creates draft for the 'AvailableExpression' algorithm. --- .gitignore | 14 +++++- .../unb/cic/wlang/AvailableExpression.scala | 46 +++++++++++++++++++ .../br/unb/cic/wlang/ReachDefinition.scala | 18 ++++---- .../cic/wlang/AvailableExpressionTest.scala | 22 +++++++++ 4 files changed, 90 insertions(+), 10 deletions(-) create mode 100644 src/main/scala/br/unb/cic/wlang/AvailableExpression.scala create mode 100644 src/test/scala/br/unb/cic/wlang/AvailableExpressionTest.scala diff --git a/.gitignore b/.gitignore index 4fb68e9..98e59e0 100644 --- a/.gitignore +++ b/.gitignore @@ -1,10 +1,22 @@ +# .gitignore padrão Scala, SBT no VSCode com plugin Scala Metals *.class *.log .bloop/ .metals/ .vscode/ -target/ +.scalafmt.conf project/ # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml hs_err_pid* + +# Simple Build Tool +# http://www.scala-sbt.org/release/docs/Getting-Started/Directories.html#configuring-version-control + +dist/* +target/ +lib_managed/ +src_managed/ +.history +.cache +.lib/ diff --git a/src/main/scala/br/unb/cic/wlang/AvailableExpression.scala b/src/main/scala/br/unb/cic/wlang/AvailableExpression.scala new file mode 100644 index 0000000..5eebe91 --- /dev/null +++ b/src/main/scala/br/unb/cic/wlang/AvailableExpression.scala @@ -0,0 +1,46 @@ +package br.unb.cic.wlang + +/** Implementation of the Available Expression algorithm. + */ + +object AvailableExpression { +// TODO getNonTrivialExpressionSet +// TODO setInitialValues = Emptyset +// TODO Naive Chaotic Iteration on AvailableExpression.execute + type Abstraction = Set[(String, Stmt)] + type DS = mutable.HashMap[Stmt, Abstraction] + + val empty: Abstraction = Set.empty + + def execute(program: WhileProgram): (DS, DS) = { + val cfg = CFGBuilder.build(program) + val stmts = CFGBuilder.stmts(program) + + // initialization + val universalSet = initUniversalSet(program.stmt) + val out = initOutSet(stmts) + val in = new DS() + + var fixedPoint = false + + while (!fixedPoint) {//TODO} + } + def initUniversalSet(stmt: Stmt): Abstraction = stmt match { + case Assignment(v, _, _) => Set((v, stmt)) + case Skip(_) => Set.empty + case IfThenElse(_, s1, s2, _) => initUniversalSet(s1) union initUniversalSet(s2) + case While(_, s, _) => initUniversalSet(s) + case Sequence(s1, s2) => initUniversalSet(s1) union initUniversalSet(s2) + } + + def kill(stmt: Stmt, universalSet: Abstraction): Abstraction = stmt match { + case Assignment(v, _, _) => universalSet.filter(t => v == t._1) + case _ => Set.empty + } + + def gen(stmt: Stmt): Abstraction = stmt match { + case Assignment(v, _, _) => Set((v, stmt)) + case _ => Set.empty + } + +} diff --git a/src/main/scala/br/unb/cic/wlang/ReachDefinition.scala b/src/main/scala/br/unb/cic/wlang/ReachDefinition.scala index 282e52f..1e257af 100644 --- a/src/main/scala/br/unb/cic/wlang/ReachDefinition.scala +++ b/src/main/scala/br/unb/cic/wlang/ReachDefinition.scala @@ -27,25 +27,25 @@ object ReachDefinition { while(!fixedPoint) { val (oldIn, oldOut) = (in.clone(), out.clone()) for(s <- stmts) { - //IN[S] = U {OUT[from] | (from, to) in cfg, S == to} + //IN[S] = U {OUT[from] | (from, to) in cfg, S == to} //OK conforme definição do livro para o RDEntry(to) //This is not so beautiful in Scala =( - in(s) = (for { (from,to) <- cfg if to == s } yield out(from)).foldLeft(empty)(_ union _) + in(s) = (for { (from,to) <- cfg if to == s } yield out(from)).foldLeft(empty)(_ union _) //não consegui ler esse trecho - //OUT[S] = GEN(S) U (IN[S] - KILL[S]) - out(s) = gen(s) union (in.getOrElse(s, empty) diff kill(s, universalSet)) + //OUT[S] = GEN(S) U (IN[S] - KILL[S]) //OK conforme definição do livro para o RDexit(to) + out(s) = gen(s) union (in.getOrElse(s, empty) diff kill(s, universalSet)) //não consegui ler esse trecho } - fixedPoint = (oldIn, oldOut) == (in, out) + fixedPoint = (oldIn, oldOut) == (in, out) //Se não há mais alterações nos conjuntos entre RDentry(from), RDexit(from) e RDentry(to), RDexit(to) então chegou no fixed point e sai do laço } (in, out) } - def initOutSet(stmts: Set[Stmt]): DS = { + def initOutSet(stmts: Set[Stmt]): DS = { //inicializa os sets dos stmts como vazio? ok! val out = new DS() stmts.foreach(s => out += s -> empty) out } - def initUniversalSet(stmt: Stmt): Abstraction = stmt match { + def initUniversalSet(stmt: Stmt): Abstraction = stmt match { //não entendi a necessidade desse inituniversal case Assignment(v, _, _) => Set((v, stmt)) case Skip(_) => Set.empty case IfThenElse(_, s1, s2, _) => initUniversalSet(s1) union initUniversalSet(s2) @@ -54,12 +54,12 @@ object ReachDefinition { } def kill(stmt: Stmt, universalSet: Abstraction): Abstraction = stmt match { - case Assignment(v, _, _) => universalSet.filter(t => v == t._1) + case Assignment(v, _, _) => universalSet.filter(t => v == t._1) //filtra true/false mas não entendi como o 't._1' é true somente p/ assignments a 'v' case _ => Set.empty } def gen(stmt: Stmt): Abstraction = stmt match { - case Assignment(v, _, _) => Set((v,stmt)) + case Assignment(v, _, _) => Set((v,stmt)) //v = nome da variável que está sendo definida no Assignment case _ => Set.empty } diff --git a/src/test/scala/br/unb/cic/wlang/AvailableExpressionTest.scala b/src/test/scala/br/unb/cic/wlang/AvailableExpressionTest.scala new file mode 100644 index 0000000..17d6f26 --- /dev/null +++ b/src/test/scala/br/unb/cic/wlang/AvailableExpressionTest.scala @@ -0,0 +1,22 @@ +package br.unb.cic.wlang + +import org.scalatest.funsuite.AnyFunSuite + +class AvailableExpressionTest extends AnyFunSuite { + + /* + * x := a+b; + * y := a*b; + * while y > a+b do + * a := a+l; + * x := a+b; +*/ + + val s1 = Assignment("x", Add(Var("a"), Var("b")), 1) + val s2 = Assignment("y", Mult(Var("a"), Var("b")), 2) + val s4 = Assignment("a", Add("a", Const(1)), 4) + val s5 = Assignment("x", Add("a", "b"), 5) + val s3 = While(GT(Var("y"), Add("a", "b")), s2, 4) + val p = WhileProgram(Sequence(s1, Sequence(s2, Sequence(s3, Sequence(s4, s5))) + +} From bb4bef4538c67cf7082fcda10247fa5c2f6a9d6f Mon Sep 17 00:00:00 2001 From: marciocg Date: Sun, 15 Aug 2021 14:29:48 -0300 Subject: [PATCH 3/3] =?UTF-8?q?Ajusta=20erros=20de=20compila=C3=A7=C3=A3o?= =?UTF-8?q?=20dos=20drafts,=20mas=20o=20c=C3=B3digo=20ainda=20est=C3=A1=20?= =?UTF-8?q?incompleto?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../br/unb/cic/wlang/AvailableExpression.scala | 18 ++++++++++++++---- .../cic/wlang/AvailableExpressionTest.scala | 8 ++++---- 2 files changed, 18 insertions(+), 8 deletions(-) diff --git a/src/main/scala/br/unb/cic/wlang/AvailableExpression.scala b/src/main/scala/br/unb/cic/wlang/AvailableExpression.scala index 5eebe91..45cfbae 100644 --- a/src/main/scala/br/unb/cic/wlang/AvailableExpression.scala +++ b/src/main/scala/br/unb/cic/wlang/AvailableExpression.scala @@ -1,4 +1,5 @@ package br.unb.cic.wlang +import scala.collection.mutable /** Implementation of the Available Expression algorithm. */ @@ -6,7 +7,7 @@ package br.unb.cic.wlang object AvailableExpression { // TODO getNonTrivialExpressionSet // TODO setInitialValues = Emptyset -// TODO Naive Chaotic Iteration on AvailableExpression.execute +// TODO Naive Chaotic Iteration on AvailableExpression.execute type Abstraction = Set[(String, Stmt)] type DS = mutable.HashMap[Stmt, Abstraction] @@ -23,18 +24,27 @@ object AvailableExpression { var fixedPoint = false - while (!fixedPoint) {//TODO} + // while (!fixedPoint) {} //TODO + (in, out) //é o return (DS, DS) } + + def initOutSet(stmts: Set[Stmt]): DS = { //inicializa os sets dos stmts como vazio? ok! + val out = new DS() + stmts.foreach(s => out += s -> empty) + out + } + def initUniversalSet(stmt: Stmt): Abstraction = stmt match { case Assignment(v, _, _) => Set((v, stmt)) case Skip(_) => Set.empty - case IfThenElse(_, s1, s2, _) => initUniversalSet(s1) union initUniversalSet(s2) + case IfThenElse(_, s1, s2, _) => + initUniversalSet(s1) union initUniversalSet(s2) case While(_, s, _) => initUniversalSet(s) case Sequence(s1, s2) => initUniversalSet(s1) union initUniversalSet(s2) } def kill(stmt: Stmt, universalSet: Abstraction): Abstraction = stmt match { - case Assignment(v, _, _) => universalSet.filter(t => v == t._1) + case Assignment(v, _, _) => universalSet.filter(t => v == t._1) case _ => Set.empty } diff --git a/src/test/scala/br/unb/cic/wlang/AvailableExpressionTest.scala b/src/test/scala/br/unb/cic/wlang/AvailableExpressionTest.scala index 17d6f26..12bdd17 100644 --- a/src/test/scala/br/unb/cic/wlang/AvailableExpressionTest.scala +++ b/src/test/scala/br/unb/cic/wlang/AvailableExpressionTest.scala @@ -14,9 +14,9 @@ class AvailableExpressionTest extends AnyFunSuite { val s1 = Assignment("x", Add(Var("a"), Var("b")), 1) val s2 = Assignment("y", Mult(Var("a"), Var("b")), 2) - val s4 = Assignment("a", Add("a", Const(1)), 4) - val s5 = Assignment("x", Add("a", "b"), 5) - val s3 = While(GT(Var("y"), Add("a", "b")), s2, 4) - val p = WhileProgram(Sequence(s1, Sequence(s2, Sequence(s3, Sequence(s4, s5))) + val s4 = Assignment("a", Add(Var("a"), Const(1)), 4) + val s5 = Assignment("x", Add(Var("a"), Var("b")), 5) + val s3 = While(GT(Var("y"), Add(Var("a"), Var("b"))), s2, 4) + val p = WhileProgram(Sequence(s1, Sequence(s2, Sequence(s3, Sequence(s4, s5))))) }