diff --git a/statemachine.base/src/main/jastadd/Analysis.jrag b/statemachine.base/src/main/jastadd/Analysis.jrag
index 19eb8945fd237ed1fca5a1102179c9cde5182f8d..6bbcf6a8b935f93575a52d5d5509ac94df130161 100644
--- a/statemachine.base/src/main/jastadd/Analysis.jrag
+++ b/statemachine.base/src/main/jastadd/Analysis.jrag
@@ -1,16 +1,4 @@
aspect Analysis {
- syn Set<State> State.reachableWithin(int n) {
- if (n == 0) {
- return new HashSet<>();
- }
- Set<State> result = new HashSet<>();
- for (State succ : successors()) {
- result.add(succ);
- result.addAll(succ.reachableWithin(n - 1));
- }
- return result;
- }
-
syn Set<State> State.reachable() circular [new HashSet<State>()] {
Set<State> result = new HashSet<>();
result.addAll(successors());
@@ -22,34 +10,22 @@ aspect Analysis {
public void StateMachine.printSomeAnalysis() {
Set<Set<State>> sccs = this.SCC();
- System.out.println("SCCs found:");
+ System.out.print("SCCs found: ");
for (Set<State> scc : sccs) {
- System.out.println(scc);
+ System.out.print(scc + " ");
}
+ System.out.println();
for (State s : this.states()) {
System.out.println(s + ": successors() = " + s.successors() + ", reachable() = " + s.reachable());
}
- Set<State> current;
- int lastSize = 0;
- for (int i = 1; i < this.states().size() + 1; i++) {
- current = this.getInitial().reachableWithin(i);
- if (current.size() == lastSize) {
- break;
- }
- System.out.println(this.getInitial() + ".reachableWithin(" + i + ") = " + current);
- lastSize = current.size();
- }
-
for (State finalState : this.getFinalList()) {
- System.out.println("initial state "+ this.getInitial() + " can reach " + finalState + " = " +
- this.getInitial().reachableWithin(this.states().size()).contains(finalState));
+ System.out.println("initial state "+ this.getInitial() + " to " + finalState + " in " +
+ this.getInitial().minDistTo(finalState) + " step(s)");
}
}
- // --- new ---
-
syn int State.minDistTo(State other) circular [-1] {
if (this == other) {
return 0;
diff --git a/statemachine.base/src/main/jastadd/NameAnalysis.jrag b/statemachine.base/src/main/jastadd/NameAnalysis.jrag
index 41cc7f687924158b825faaf6823b611a2cf9822b..a381d9cbbc6a9d273ff019983b88ae79dd40bad7 100644
--- a/statemachine.base/src/main/jastadd/NameAnalysis.jrag
+++ b/statemachine.base/src/main/jastadd/NameAnalysis.jrag
@@ -1,25 +1,25 @@
aspect NameAnalysis {
- syn Map<String, State> StateMachine.stateMap() {
- Map<String, State> map = new HashMap<>();
+ syn State StateMachine.resolveState(String id) {
for (State s : states()) {
- map.put(s.getLabel(), s);
+ if (s.getLabel().equals(id)) {
+ return s;
+ }
}
- return map;
+ return null;
}
- syn Map<String, Transition> StateMachine.transitionMap() {
- Map<String, Transition> map = new HashMap<>();
+ syn Transition StateMachine.resolveTransition(String id) {
for (Transition t : transitions()) {
- map.put(t.getLabel(), t);
+ if (t.getLabel().equals(id)) {
+ return t;
+ }
}
- return map;
+ return null;
}
- refine RefResolverStubs eq ASTNode.globallyResolveStateByToken(String id) {
- return root().stateMap().get(id);
- }
+ eq StateMachine.globallyResolveStateByToken(String id) = resolveState(id);
+ eq Element.globallyResolveStateByToken(String id) = containingStateMachine().resolveState(id);
- refine RefResolverStubs eq ASTNode.globallyResolveTransitionByToken(String id) {
- return root().transitionMap().get(id);
- }
+ eq StateMachine.globallyResolveTransitionByToken(String id) = resolveTransition(id);
+ eq Element.globallyResolveTransitionByToken(String id) = containingStateMachine().resolveTransition(id);
}
diff --git a/statemachine.base/src/main/jastadd/Navigation.jrag b/statemachine.base/src/main/jastadd/Navigation.jrag
index 8aa18c02438c38ae7e821cff5de792b10fb36204..f06ecb8dcdf0d7682223ae92deb96b5cfe530696 100644
--- a/statemachine.base/src/main/jastadd/Navigation.jrag
+++ b/statemachine.base/src/main/jastadd/Navigation.jrag
@@ -37,12 +37,11 @@ aspect Navigation {
return transitions;
}
- syn StateMachine ASTNode.root();
- eq StateMachine.root() = this;
- eq ASTNode.root() = getParent().root();
+ inh StateMachine Element.containingStateMachine();
+ eq StateMachine.getElement().containingStateMachine() = this;
- syn boolean State.isInitial() = root().getInitial().equals(this);
- syn boolean State.isFinal() = root().getFinalList().contains(this);
+ syn boolean State.isInitial() = containingStateMachine().getInitial().equals(this);
+ syn boolean State.isFinal() = containingStateMachine().getFinalList().contains(this);
syn Collection<State> State.successors() = getOutgoingList().stream().map(Transition::getTo).collect(Collectors.toList());
}
diff --git a/statemachine.base/src/main/java/de/tudresden/inf/st/statemachine/Main.java b/statemachine.base/src/main/java/de/tudresden/inf/st/statemachine/Main.java
index ab27666ea8434cb8b6fca20ca1acfe163eae1e46..d38b8acab43c87957d3b705824934a3f2cfd4444 100644
--- a/statemachine.base/src/main/java/de/tudresden/inf/st/statemachine/Main.java
+++ b/statemachine.base/src/main/java/de/tudresden/inf/st/statemachine/Main.java
@@ -7,62 +7,89 @@ import de.tudresden.inf.st.statemachine.jastadd.model.Transition;
import java.io.IOException;
import java.nio.file.Paths;
+import java.util.Set;
public class Main {
@SuppressWarnings("WeakerAccess")
public static Object DrAST_root_node;
- public static void main(String[] args) {
+ public static void main(String[] args) throws IOException, Parser.Exception {
+ StateMachine stateMachine;
if (args.length == 0) {
- // manual construction of a simple statemachine
- // (S) -- 1 --> (B) -- 3 --> (E)
- // ^ |
- // \ /
- // `---- 2 ----*
- StateMachine stateMachine = new StateMachine();
- State start = new State();
- start.setLabel("S");
- State stateB = new State();
- stateB.setLabel("B");
- State end = new State();
- end.setLabel("E");
- Transition t1 = new Transition();
- t1.setLabel("1");
- Transition t2 = new Transition();
- t2.setLabel("2");
- Transition t3 = new Transition();
- t3.setLabel("3");
- t1.setFrom(start);
- t1.setTo(stateB);
- t2.setFrom(stateB);
- t2.setTo(start);
- t3.setFrom(stateB);
- t3.setTo(end);
- stateMachine.addElement(start);
- stateMachine.addElement(stateB);
- stateMachine.addElement(end);
- stateMachine.addElement(t1);
- stateMachine.addElement(t2);
- stateMachine.addElement(t3);
- stateMachine.setInitial(start);
- stateMachine.addFinal(end);
-
- System.out.println(stateMachine.prettyPrint());
- stateMachine.printSomeAnalysis();
- DrAST_root_node = stateMachine;
+ stateMachine = createExample();
} else {
// load the file given as first argument
- try {
- StateMachine stateMachine = ParserUtils.load(Paths.get(args[0]));
- stateMachine.treeResolveAll();
- stateMachine.printSomeAnalysis();
- System.out.println("> toDotGraph():");
- System.out.println(stateMachine.toDot());
- DrAST_root_node = stateMachine;
- } catch (IOException | Parser.Exception e) {
- e.printStackTrace();
- }
+ stateMachine = ParserUtils.load(Paths.get(args[0]));
+ }
+ printHeading("Initial statemachine");
+ System.out.println(stateMachine.prettyPrint());
+
+ stateMachine.printSomeAnalysis();
+
+ Set<Transition> epsilons = stateMachine.epsilonTransitions();
+
+ for (Transition eps : epsilons) {
+ printHeading("Removing epsilon transition " + eps.prettyPrint().trim());
+ System.out.println("Minimal distances before:");
+ initialToFinalDistances(stateMachine);
+ stateMachine.removeEpsilonTransition(eps);
+ System.out.println("Minimal distances after:");
+ initialToFinalDistances(stateMachine);
+ printHeading("StateMachine after");
+ System.out.println(stateMachine.prettyPrint());
+ }
+ printHeading("DotGraph");
+ System.out.println(stateMachine.toDot());
+ DrAST_root_node = stateMachine;
+ }
+
+ private static void printHeading(String s) {
+ System.out.println();
+ System.out.println("========================================");
+ System.out.println("== " + s);
+ System.out.println("========================================");
+ }
+
+ private static StateMachine createExample() {
+ // manual construction of a simple statemachine
+ // (S) -- e --> (B) -- 1 --> (E)
+ // ^ |
+ // \ /
+ // `---- 2 ----*
+ StateMachine stateMachine = new StateMachine();
+ State start = new State();
+ start.setLabel("S");
+ State stateB = new State();
+ stateB.setLabel("B");
+ State end = new State();
+ end.setLabel("E");
+ Transition eps = new Transition();
+ Transition t2 = new Transition();
+ t2.setLabel("2");
+ Transition t1 = new Transition();
+ t1.setLabel("1");
+ eps.setFrom(start);
+ eps.setTo(stateB);
+ t2.setFrom(stateB);
+ t2.setTo(start);
+ t1.setFrom(stateB);
+ t1.setTo(end);
+ stateMachine.addElement(start);
+ stateMachine.addElement(stateB);
+ stateMachine.addElement(end);
+ stateMachine.addElement(eps);
+ stateMachine.addElement(t2);
+ stateMachine.addElement(t1);
+ stateMachine.setInitial(start);
+ stateMachine.addFinal(end);
+ return stateMachine;
+ }
+
+ private static void initialToFinalDistances(StateMachine stateMachine) {
+ for (State finalState : stateMachine.getFinalList()) {
+ System.out.println("initial state "+ stateMachine.getInitial() + " to " + finalState + " in " +
+ stateMachine.getInitial().minDistTo(finalState) + " step(s)");
}
}