fixed Bank

statemachine.solution/src/main/jastadd/Analysis.jadd

 aspect Analysis {
-
+  /*
   public void StateMachine.printSomeAnalysis() {
     Set<Set<State>> sccs = this.SCC();
     System.out.print("SCCs found: ");
@@ -17,5 +17,5 @@ aspect Analysis {
           this.getInitial().minDistTo(finalState) + " step(s)");
     }
   }
-
+  */
 }

statemachine.solution/src/main/jastadd/Analysis.jrag

 aspect Analysis {
 
   /** Compute all states reachable from the current state */
+  /*
   syn Set<State> State.reachable() circular [new HashSet<State>()] {
     Set<State> result = new HashSet<>();
     result.addAll(successors());
@@ -9,8 +10,10 @@ aspect Analysis {
     }
     return result;
   }
+  */
 
   /** Compute the minimum number of transitions to the other state, ignoring states with empty labels */
+  /*
   syn int State.minDistTo(State other) circular [-1] {
     if (this == other) {
       return 0;
@@ -25,12 +28,13 @@ aspect Analysis {
     }
     return result;
   }
+  */
 
   /** A transition is an epsilon transition if the label is empty */
-  syn boolean Transition.isEpsilon() = getLabel().isEmpty();
+  //syn boolean Transition.isEpsilon() = getLabel().isEmpty();
 
   /** Collect all epsilon transitions */
-  coll Set<Transition> StateMachine.epsilonTransitions() [new HashSet<>()];
-  Transition contributes this when isEpsilon() to StateMachine.epsilonTransitions();
+  //coll Set<Transition> StateMachine.epsilonTransitions() [new HashSet<>()];
+  //Transition contributes this when isEpsilon() to StateMachine.epsilonTransitions();
 
 }

statemachine.solution/src/main/jastadd/BankParser.parser

@@ -8,8 +8,8 @@ import java.util.*;
 
 %embed {:
  // this code is inlined in the generated parser class
- State initial;
- List<State> finals = new ArrayList<>();
+ //State initial;
+ //List<State> finals = new ArrayList<>();
 :};
 
 %goal goal;

statemachine.solution/src/main/jastadd/BankScanner.flex

@@ -35,12 +35,5 @@ Identifier = [:jletter:][:jletterdigit:]*
 {WhiteSpace}  { }
 
 // token definitions
-"initial"     { return sym(Terminals.INITIAL); }
-"final"       { return sym(Terminals.FINAL); }
-"state"       { return sym(Terminals.STATE); }
-"trans"       { return sym(Terminals.TRANS); }
 {Identifier}  { return sym(Terminals.NAME); }
-";"           { return sym(Terminals.SEMI); }
-":"           { return sym(Terminals.COLON); }
-"->"          { return sym(Terminals.ARROW); }
 <<EOF>>       { return sym(Terminals.EOF); }

statemachine.solution/src/main/jastadd/ConnectedComponents.jrag

@@ -3,6 +3,7 @@ aspect ConnectedComponents {
   /**
    * Kosaraju's algorithm
    */
+  /*
   syn Set<Set<State>> StateMachine.SCC() {
     Map<State, Set> visited = new HashMap<>();
     LinkedList<State> locked = new LinkedList<>();
@@ -33,5 +34,5 @@ aspect ConnectedComponents {
       if (visited.get(t.getFrom()) == null)
         t.getFrom().assign(visited, root);
   }
-
+  */
 }

statemachine.solution/src/main/jastadd/NameAnalysis.jrag

 aspect NameAnalysis {
 
   /** resolve a state using its name */
+  /*
   syn State StateMachine.resolveState(String id) {
     for (State s : states()) {
       if (s.getLabel().equals(id)) {
@@ -9,8 +10,10 @@ aspect NameAnalysis {
     }
     return null;
   }
+  */
 
   /** resolve a transition using its name */
+  /*
   syn Transition StateMachine.resolveTransition(String id) {
     for (Transition t : transitions()) {
       if (t.getLabel().equals(id)) {
@@ -19,11 +22,12 @@ aspect NameAnalysis {
     }
     return null;
   }
+  */
 
   // required interface implementation for name analysis in parser
-  eq StateMachine.globallyResolveStateByToken(String id) = resolveState(id);
-  eq Element.globallyResolveStateByToken(String id) = containingStateMachine().resolveState(id);
+  //eq StateMachine.globallyResolveStateByToken(String id) = resolveState(id);
+  //eq Element.globallyResolveStateByToken(String id) = containingStateMachine().resolveState(id);
 
-  eq StateMachine.globallyResolveTransitionByToken(String id) = resolveTransition(id);
-  eq Element.globallyResolveTransitionByToken(String id) = containingStateMachine().resolveTransition(id);
+  //eq StateMachine.globallyResolveTransitionByToken(String id) = resolveTransition(id);
+  //eq Element.globallyResolveTransitionByToken(String id) = containingStateMachine().resolveTransition(id);
 }

statemachine.solution/src/main/jastadd/Navigation.jrag

@@ -5,22 +5,23 @@ aspect Navigation {
   // ======================================================
 
   /** Check, whether an this element is a state */
-  syn boolean Element.isState() = false;
-  eq State.isState() = true;
+  //syn boolean Element.isState() = false;
+  //eq State.isState() = true;
 
   /** View this element as a state */
-  syn State Element.asState() = null;
-  eq State.asState() = this;
+  //syn State Element.asState() = null;
+  //eq State.asState() = this;
 
   /** Check, whether an this element is a transition */
-  syn boolean Element.isTransition() = false;
-  eq Transition.isTransition() = true;
+  //syn boolean Element.isTransition() = false;
+  //eq Transition.isTransition() = true;
 
   /** View this element as a transition */
-  syn Transition Element.asTransition() = null;
-  eq Transition.asTransition() = this;
+  //syn Transition Element.asTransition() = null;
+  //eq Transition.asTransition() = this;
 
   /** Get all states */
+  /*
   syn List<State> StateMachine.states() {
     List<State> states = new ArrayList<>();
     for (Element element: getElementList()) {
@@ -30,8 +31,10 @@ aspect Navigation {
     }
     return states;
   }
+  */
 
   /** Get all transitions */
+  /*
   syn List<Transition> StateMachine.transitions() {
     List<Transition> transitions = new ArrayList<>();
     for (Element element: getElementList()) {
@@ -41,18 +44,19 @@ aspect Navigation {
     }
     return transitions;
   }
+  */
 
   /** Get the state machine the element is contained in */
-  inh StateMachine Element.containingStateMachine();
-  eq StateMachine.getElement().containingStateMachine() = this;
+  //inh StateMachine Element.containingStateMachine();
+  //eq StateMachine.getElement().containingStateMachine() = this;
 
   /** Determine whether the State is final */
-  syn boolean State.isInitial() = containingStateMachine().getInitial().equals(this);
+  //syn boolean State.isInitial() = containingStateMachine().getInitial().equals(this);
 
   /** Determine whether the State is final */
-  syn boolean State.isFinal() = containingStateMachine().getFinalList().contains(this);
+  //syn boolean State.isFinal() = containingStateMachine().getFinalList().contains(this);
 
   /** Get all successor states */
-  syn Collection<State> State.successors() = getOutgoingList().stream().map(Transition::getTo).collect(Collectors.toList());
+  //syn Collection<State> State.successors() = getOutgoingList().stream().map(Transition::getTo).collect(Collectors.toList());
 
 }

statemachine.solution/src/main/jastadd/Printing.jrag

 aspect Printing {
 
   /** Return a textual representation of the state machine */
+  /*
   syn String StateMachine.prettyPrint() {
     StringBuilder sb = new StringBuilder();
     states().forEach(s -> sb.append(s.prettyPrint()));
     transitions().forEach(t -> sb.append(t.prettyPrint()));
     return sb.toString();
   }
+  */
 
   /** Return a textual representation of the state machine */
-  syn String Element.prettyPrint();
-  eq State.prettyPrint() = (isInitial() ? "initial " : "") + (isFinal() ? "final " : "") + "state " + getLabel() + ";\n";
-  eq Transition.prettyPrint() = "trans " + getFrom().getLabel() + " -> " + getTo().getLabel() + (isEpsilon() ? "" : " : " + getLabel()) + ";\n";
+  //syn String Element.prettyPrint();
+  //eq State.prettyPrint() = (isInitial() ? "initial " : "") + (isFinal() ? "final " : "") + "state " + getLabel() + ";\n";
+  //eq Transition.prettyPrint() = "trans " + getFrom().getLabel() + " -> " + getTo().getLabel() + (isEpsilon() ? "" : " : " + getLabel()) + ";\n";
 }

statemachine.solution/src/main/jastadd/SMtoDotG.jrag

 aspect StateMachinetoDotG {
+  /*
   syn String StateMachine.toDot() {
     StringBuilder b = new StringBuilder();
     b.append("strict digraph cycles {\n");
@@ -15,4 +16,5 @@ aspect StateMachinetoDotG {
     b.append("}\n");
     return b.toString();
   }
+  */
 }

statemachine.solution/src/main/jastadd/Transformation.jadd

 aspect Transformation {
 
   /** remove transformations with empty labels */
+  /*
   public void StateMachine.removeEpsilonTransition(Transition t) {
     if (t.isEpsilon()) {
       State oldFrom = t.getFrom();
@@ -29,4 +30,5 @@ aspect Transformation {
       System.err.println("Won't remove non-epsilon transition " + t.getLabel());
     }
   }
+  */
 }

statemachine.solution/src/main/jastadd/Util.jadd

@@ -28,7 +28,7 @@ aspect JastAddAPIExtension {
     }
     throw new RuntimeException("unable to remove child, because it was not contained in its parent!");
   }
-
+  /*
   public String Element.customID() {
     return getLabel();
   }
@@ -36,4 +36,5 @@ aspect JastAddAPIExtension {
   public String Element.toString() {
     return getLabel();
   }
+  */
 }

statemachine.solution/src/main/java/de/tudresden/inf/st/statemachine/Main.java

@@ -2,9 +2,9 @@ package de.tudresden.inf.st.statemachine;
 
 import beaver.Parser;
 import de.tudresden.inf.st.jastadd.dumpAst.ast.Dumper;
-import de.tudresden.inf.st.statemachine.jastadd.model.State;
-import de.tudresden.inf.st.statemachine.jastadd.model.StateMachine;
-import de.tudresden.inf.st.statemachine.jastadd.model.Transition;
+//import de.tudresden.inf.st.statemachine.jastadd.model.State;
+//import de.tudresden.inf.st.statemachine.jastadd.model.StateMachine;
+//import de.tudresden.inf.st.statemachine.jastadd.model.Transition;
 
 import java.io.IOException;
 import java.nio.file.Paths;
@@ -16,6 +16,7 @@ public class Main {
   public static Object DrAST_root_node;
 
   public static void main(String[] args) throws IOException, Parser.Exception {
+    /*
     StateMachine stateMachine;
     if (args.length == 0) {
       stateMachine = createExample();
@@ -45,8 +46,10 @@ public class Main {
     System.out.println(stateMachine.toDot());
     Dumper.read(stateMachine).dumpAsPNG(Paths.get("02-transformed.png"));
     DrAST_root_node = stateMachine;
+    */
   }
 
+  /*
   private static void printHeading(String s) {
     System.out.println();
     System.out.println("========================================");
@@ -95,5 +98,5 @@ public class Main {
           stateMachine.getInitial().minDistTo(finalState) + " step(s)");
     }
   }
-
+  */
 }

statemachine.solution/src/main/java/de/tudresden/inf/st/statemachine/ParserUtils.java

 package de.tudresden.inf.st.statemachine;
 
 import beaver.Parser;
-import de.tudresden.inf.st.statemachine.jastadd.model.StateMachine;
-import de.tudresden.inf.st.statemachine.jastadd.parser.StateMachineParser;
-import de.tudresden.inf.st.statemachine.jastadd.scanner.StateMachineScanner;
+import de.tudresden.inf.st.statemachine.jastadd.model.Bank;
+import de.tudresden.inf.st.statemachine.jastadd.parser.BankParser;
+import de.tudresden.inf.st.statemachine.jastadd.scanner.BankScanner;
 
 import java.io.IOException;
 import java.io.Reader;
@@ -16,11 +16,11 @@ import java.nio.file.Path;
  * @author rschoene - Initial contribution
  */
 public class ParserUtils {
-  static StateMachine load(Path path) throws IOException, Parser.Exception {
+  static Bank load(Path path) throws IOException, Parser.Exception {
     Reader reader = Files.newBufferedReader(path);
-    StateMachineScanner scanner = new StateMachineScanner(reader);
-    StateMachineParser parser = new StateMachineParser();
-    StateMachine result = (StateMachine) parser.parse(scanner);
+    BankScanner scanner = new BankScanner(reader);
+    BankParser parser = new BankParser();
+    Bank result = (Bank) parser.parse(scanner);
     reader.close();
     return result;
   }