Added EntryNodes to ExecutionFlow, so they are contained in the flow

plugins/org.yakindu.sct.model.sexec/src/org/yakindu/sct/model/sexec/transformation/BehaviorMapping.xtend

@@ -1,28 +1,36 @@
 package org.yakindu.sct.model.sexec.transformation
 
 import com.google.inject.Inject
+import java.util.HashSet
 import java.util.List
+import java.util.Set
 import org.eclipse.emf.ecore.util.EcoreUtil
 import org.yakindu.sct.model.sexec.Check
 import org.yakindu.sct.model.sexec.Execution
 import org.yakindu.sct.model.sexec.ExecutionChoice
+import org.yakindu.sct.model.sexec.ExecutionEntry
 import org.yakindu.sct.model.sexec.ExecutionFlow
+import org.yakindu.sct.model.sexec.ExecutionNode
 import org.yakindu.sct.model.sexec.ExecutionRegion
 import org.yakindu.sct.model.sexec.ExecutionScope
 import org.yakindu.sct.model.sexec.ExecutionState
+import org.yakindu.sct.model.sexec.ExecutionSynchronization
 import org.yakindu.sct.model.sexec.Reaction
 import org.yakindu.sct.model.sexec.Sequence
 import org.yakindu.sct.model.sexec.Step
 import org.yakindu.sct.model.sgraph.Choice
 import org.yakindu.sct.model.sgraph.Effect
 import org.yakindu.sct.model.sgraph.Entry
+import org.yakindu.sct.model.sgraph.Pseudostate
 import org.yakindu.sct.model.sgraph.Region
 import org.yakindu.sct.model.sgraph.RegularState
 import org.yakindu.sct.model.sgraph.State
 import org.yakindu.sct.model.sgraph.Statechart
 import org.yakindu.sct.model.sgraph.Statement
+import org.yakindu.sct.model.sgraph.Synchronization
 import org.yakindu.sct.model.sgraph.Transition
 import org.yakindu.sct.model.sgraph.Trigger
+import org.yakindu.sct.model.sgraph.Vertex
 import org.yakindu.sct.model.stext.stext.AlwaysEvent
 import org.yakindu.sct.model.stext.stext.Expression
 import org.yakindu.sct.model.stext.stext.LocalReaction
@@ -30,18 +38,7 @@ import org.yakindu.sct.model.stext.stext.OnCycleEvent
 import org.yakindu.sct.model.stext.stext.ReactionEffect
 import org.yakindu.sct.model.stext.stext.ReactionTrigger
 import org.yakindu.sct.model.stext.stext.RegularEventSpec
-import org.yakindu.sct.model.stext.stext.TimeEventSpec
-import org.yakindu.sct.model.sgraph.Vertex
-import org.yakindu.sct.model.sgraph.Pseudostate
-import org.yakindu.sct.model.sgraph.Synchronization
-import org.yakindu.sct.model.sexec.ExecutionSynchronization
-import apple.awt.CRenderer$Tracer
-import org.yakindu.sct.model.sexec.ExecutionNode
-import org.yakindu.sct.model.sgraph.FinalState
-import org.yakindu.sct.model.sexec.ExecutionEntry
-import java.util.ArrayList
-import java.util.HashSet
-import java.util.Set
+import org.yakindu.sct.model.stext.stext.TimeEventSpec
 
  
 
@@ -290,6 +287,10 @@ class BehaviorMapping {
 		return r
 	}
 	
+	def ExecutionFlow mapEntries(Statechart statechart, ExecutionFlow r) {
+		r.nodes.addAll(statechart.eAllContents.filter(typeof(Entry)).map(e|e.create).toList)
+		r
+	}
 	
 	def Statement conjunct(Statement c1, Statement c2) {
 		if (c1 != null && c2 != null ) stext.and(c1 as Expression, c2 as Expression)

plugins/org.yakindu.sct.model.sexec/src/org/yakindu/sct/model/sexec/transformation/ModelSequencer.xtend

@@ -60,6 +60,7 @@ class ModelSequencer {
 		ef.defineStatechartExitSequence(sc)
 		
 		sc.mapTransitions(ef)
+		sc.mapEntries(ef)
 		sc.mapLocalReactions(ef)
 		sc.mapChoiceTransitions(ef)
 		sc.mapSyncTransitions(ef)

plugins/org.yakindu.sct.model.sexec/src/org/yakindu/sct/model/sexec/transformation/SexecElementMapping.xtend

@@ -1,58 +1,58 @@
-package org.yakindu.sct.model.sexec.transformation
-
-import com.google.inject.Inject
-import com.google.inject.Singleton
-import org.eclipse.emf.ecore.util.EcoreUtil
-import org.eclipse.xtext.naming.IQualifiedNameProvider
-import org.eclipse.xtext.util.Strings
-import org.yakindu.base.base.NamedElement
-import org.yakindu.sct.model.sexec.Call
-import org.yakindu.sct.model.sexec.Check
-import org.yakindu.sct.model.sexec.CheckRef
-import org.yakindu.sct.model.sexec.ExecutionChoice
-import org.yakindu.sct.model.sexec.ExecutionEntry
-import org.yakindu.sct.model.sexec.ExecutionFlow
-import org.yakindu.sct.model.sexec.ExecutionRegion
-import org.yakindu.sct.model.sexec.ExecutionState
-import org.yakindu.sct.model.sexec.Reaction
-import org.yakindu.sct.model.sexec.ScheduleTimeEvent
-import org.yakindu.sct.model.sexec.SexecFactory
-import org.yakindu.sct.model.sexec.Step
-import org.yakindu.sct.model.sexec.TimeEvent
-import org.yakindu.sct.model.sexec.UnscheduleTimeEvent
-import org.yakindu.sct.model.sgraph.Choice
-import org.yakindu.sct.model.sgraph.CompositeElement
-import org.yakindu.sct.model.sgraph.Entry
-import org.yakindu.sct.model.sgraph.EntryKind
-import org.yakindu.sct.model.sgraph.FinalState
-import org.yakindu.sct.model.sgraph.Region
-import org.yakindu.sct.model.sgraph.RegularState
-import org.yakindu.sct.model.sgraph.Scope
-import org.yakindu.sct.model.sgraph.State
-import org.yakindu.sct.model.sgraph.Statechart
-import org.yakindu.sct.model.sgraph.Statement
-import org.yakindu.sct.model.sgraph.Transition
-import org.yakindu.sct.model.stext.stext.AlwaysEvent
-import org.yakindu.sct.model.stext.stext.BoolLiteral
-import org.yakindu.sct.model.stext.stext.DefaultEvent
-import org.yakindu.sct.model.stext.stext.ElementReferenceExpression
-import org.yakindu.sct.model.stext.stext.EventDefinition
-import org.yakindu.sct.model.stext.stext.EventSpec
-import org.yakindu.sct.model.stext.stext.Expression
-import org.yakindu.sct.model.stext.stext.FeatureCall
-import org.yakindu.sct.model.stext.stext.InterfaceScope
-import org.yakindu.sct.model.stext.stext.LocalReaction
-import org.yakindu.sct.model.stext.stext.OnCycleEvent
-import org.yakindu.sct.model.stext.stext.OperationDefinition
-import org.yakindu.sct.model.stext.stext.ReactionTrigger
-import org.yakindu.sct.model.stext.stext.RegularEventSpec
-import org.yakindu.sct.model.stext.stext.StextFactory
-import org.yakindu.sct.model.stext.stext.TimeEventSpec
-import org.yakindu.sct.model.stext.stext.TimeEventType
+package org.yakindu.sct.model.sexec.transformation
+
+import com.google.inject.Inject
+import com.google.inject.Singleton
+import org.eclipse.emf.ecore.util.EcoreUtil
+import org.eclipse.xtext.naming.IQualifiedNameProvider
+import org.eclipse.xtext.util.Strings
+import org.yakindu.base.base.NamedElement
+import org.yakindu.sct.model.sexec.Call
+import org.yakindu.sct.model.sexec.Check
+import org.yakindu.sct.model.sexec.CheckRef
+import org.yakindu.sct.model.sexec.ExecutionChoice
+import org.yakindu.sct.model.sexec.ExecutionEntry
+import org.yakindu.sct.model.sexec.ExecutionFlow
+import org.yakindu.sct.model.sexec.ExecutionNode
+import org.yakindu.sct.model.sexec.ExecutionRegion
+import org.yakindu.sct.model.sexec.ExecutionState
+import org.yakindu.sct.model.sexec.ExecutionSynchronization
+import org.yakindu.sct.model.sexec.Reaction
+import org.yakindu.sct.model.sexec.ScheduleTimeEvent
+import org.yakindu.sct.model.sexec.SexecFactory
+import org.yakindu.sct.model.sexec.Step
+import org.yakindu.sct.model.sexec.TimeEvent
+import org.yakindu.sct.model.sexec.UnscheduleTimeEvent
+import org.yakindu.sct.model.sgraph.Choice
+import org.yakindu.sct.model.sgraph.CompositeElement
+import org.yakindu.sct.model.sgraph.Entry
+import org.yakindu.sct.model.sgraph.EntryKind
+import org.yakindu.sct.model.sgraph.FinalState
+import org.yakindu.sct.model.sgraph.Region
+import org.yakindu.sct.model.sgraph.RegularState
+import org.yakindu.sct.model.sgraph.Scope
+import org.yakindu.sct.model.sgraph.State
+import org.yakindu.sct.model.sgraph.Statechart
+import org.yakindu.sct.model.sgraph.Statement
+import org.yakindu.sct.model.sgraph.Synchronization
+import org.yakindu.sct.model.sgraph.Transition
+import org.yakindu.sct.model.stext.stext.AlwaysEvent
+import org.yakindu.sct.model.stext.stext.BoolLiteral
+import org.yakindu.sct.model.stext.stext.DefaultEvent
+import org.yakindu.sct.model.stext.stext.ElementReferenceExpression
+import org.yakindu.sct.model.stext.stext.EventDefinition
+import org.yakindu.sct.model.stext.stext.EventSpec
+import org.yakindu.sct.model.stext.stext.Expression
+import org.yakindu.sct.model.stext.stext.FeatureCall
+import org.yakindu.sct.model.stext.stext.InterfaceScope
+import org.yakindu.sct.model.stext.stext.LocalReaction
+import org.yakindu.sct.model.stext.stext.OnCycleEvent
+import org.yakindu.sct.model.stext.stext.OperationDefinition
+import org.yakindu.sct.model.stext.stext.ReactionTrigger
+import org.yakindu.sct.model.stext.stext.RegularEventSpec
+import org.yakindu.sct.model.stext.stext.StextFactory
+import org.yakindu.sct.model.stext.stext.TimeEventSpec
+import org.yakindu.sct.model.stext.stext.TimeEventType
 import org.yakindu.sct.model.stext.stext.VariableDefinition
-import org.yakindu.sct.model.sexec.ExecutionSynchronization
-import org.yakindu.sct.model.sgraph.Synchronization
-import org.yakindu.sct.model.sexec.ExecutionNode
  
 
 
@@ -129,7 +129,6 @@ import org.yakindu.sct.model.sexec.ExecutionNode
 		}
 	}
 
-
 	def ExecutionEntry create r : sexecFactory.createExecutionEntry create(Entry entry){
 		if (entry != null) {
 			val region = entry.eContainer as Region
@@ -149,6 +148,7 @@ import org.yakindu.sct.model.sexec.ExecutionNode
 				}+"entry " + entry.name
 
 			r.reactSequence = seq
+			entry.outgoingTransitions.forEach(t | r.reactions+=t.create)
 		}
 	}
 	

plugins/org.yakindu.sct.model.sexec/xtend-gen/org/yakindu/sct/model/sexec/transformation/BehaviorMapping.java

@@ -4,13 +4,17 @@ import com.google.common.base.Objects;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Iterators;
 import com.google.inject.Inject;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Set;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.common.util.TreeIterator;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
 import org.eclipse.xtext.xbase.lib.Functions.Function1;
 import org.eclipse.xtext.xbase.lib.Functions.Function2;
 import org.eclipse.xtext.xbase.lib.IterableExtensions;
@@ -23,6 +27,7 @@ import org.yakindu.sct.model.sexec.Execution;
 import org.yakindu.sct.model.sexec.ExecutionChoice;
 import org.yakindu.sct.model.sexec.ExecutionEntry;
 import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.model.sexec.ExecutionNode;
 import org.yakindu.sct.model.sexec.ExecutionRegion;
 import org.yakindu.sct.model.sexec.ExecutionScope;
 import org.yakindu.sct.model.sexec.ExecutionState;
@@ -32,6 +37,7 @@ import org.yakindu.sct.model.sexec.ReactionFired;
 import org.yakindu.sct.model.sexec.ScheduleTimeEvent;
 import org.yakindu.sct.model.sexec.Sequence;
 import org.yakindu.sct.model.sexec.SexecFactory;
+import org.yakindu.sct.model.sexec.StateVector;
 import org.yakindu.sct.model.sexec.Step;
 import org.yakindu.sct.model.sexec.TimeEvent;
 import org.yakindu.sct.model.sexec.TraceStateEntered;
@@ -252,16 +258,13 @@ public class BehaviorMapping {
   
   public ExecutionSynchronization mapSyncTransition(final Synchronization sync) {
     final ExecutionSynchronization _sync = this.factory.create(sync);
+    final EList<Transition> transitions = sync.getOutgoingTransitions();
+    Transition _head = IterableExtensions.<Transition>head(transitions);
+    final Reaction r = this.factory.create(_head);
     EList<Reaction> _reactions = _sync.getReactions();
-    EList<Transition> _outgoingTransitions = sync.getOutgoingTransitions();
-    final Function1<Transition,Reaction> _function = new Function1<Transition,Reaction>() {
-        public Reaction apply(final Transition t) {
-          Reaction _mapTransition = BehaviorMapping.this.mapTransition(t);
-          return _mapTransition;
-        }
-      };
-    List<Reaction> _map = ListExtensions.<Transition, Reaction>map(_outgoingTransitions, _function);
-    _reactions.addAll(_map);
+    _reactions.add(r);
+    Sequence _mapToEffect = this.mapToEffect(transitions, r);
+    r.setEffect(_mapToEffect);
     return _sync;
   }
   
@@ -468,7 +471,8 @@ public class BehaviorMapping {
       Check _mapToCheck = this.mapToCheck(_trigger_1);
       r.setCheck(_mapToCheck);
     }
-    Sequence _mapToEffect = this.mapToEffect(t, r);
+    ArrayList<Transition> _newArrayList = CollectionLiterals.<Transition>newArrayList(t);
+    Sequence _mapToEffect = this.mapToEffect(_newArrayList, r);
     r.setEffect(_mapToEffect);
     return r;
   }
@@ -507,13 +511,30 @@ public class BehaviorMapping {
     Statement condition = _check_1.getCondition();
     EList<Transition> _incomingTransitions = target.getIncomingTransitions();
     final Function1<Transition,Boolean> _function = new Function1<Transition,Boolean>() {
+        public Boolean apply(final Transition jt) {
+          Vertex _source = jt.getSource();
+          return Boolean.valueOf((_source instanceof State));
+        }
+      };
+    Iterable<Transition> _filter = IterableExtensions.<Transition>filter(_incomingTransitions, _function);
+    final Function1<Transition,Integer> _function_1 = new Function1<Transition,Integer>() {
+        public Integer apply(final Transition jt) {
+          Vertex _source = jt.getSource();
+          ExecutionState _create = BehaviorMapping.this.factory.create(((State) _source));
+          StateVector _stateVector = _create.getStateVector();
+          int _offset = _stateVector.getOffset();
+          return Integer.valueOf(_offset);
+        }
+      };
+    final List<Transition> joinTransitions = IterableExtensions.<Transition, Integer>sortBy(_filter, _function_1);
+    final Function1<Transition,Boolean> _function_2 = new Function1<Transition,Boolean>() {
         public Boolean apply(final Transition trans) {
           boolean _notEquals = (!Objects.equal(trans, t));
           return Boolean.valueOf(_notEquals);
         }
       };
-    Iterable<Transition> _filter = IterableExtensions.<Transition>filter(_incomingTransitions, _function);
-    for (final Transition trans : _filter) {
+    Iterable<Transition> _filter_1 = IterableExtensions.<Transition>filter(joinTransitions, _function_2);
+    for (final Transition trans : _filter_1) {
       Vertex _source = trans.getSource();
       if ((_source instanceof State)) {
         Vertex _source_1 = trans.getSource();
@@ -532,11 +553,31 @@ public class BehaviorMapping {
     }
     Check _check_2 = r.getCheck();
     _check_2.setCondition(condition);
-    Sequence _mapToEffect = this.mapToEffect(t, r);
+    Sequence _mapToEffect = this.mapToEffect(joinTransitions, r);
     r.setEffect(_mapToEffect);
     return r;
   }
   
+  public ExecutionFlow mapEntries(final Statechart statechart, final ExecutionFlow r) {
+    ExecutionFlow _xblockexpression = null;
+    {
+      EList<ExecutionNode> _nodes = r.getNodes();
+      TreeIterator<EObject> _eAllContents = statechart.eAllContents();
+      Iterator<Entry> _filter = Iterators.<Entry>filter(_eAllContents, Entry.class);
+      final Function1<Entry,ExecutionEntry> _function = new Function1<Entry,ExecutionEntry>() {
+          public ExecutionEntry apply(final Entry e) {
+            ExecutionEntry _create = BehaviorMapping.this.factory.create(e);
+            return _create;
+          }
+        };
+      Iterator<ExecutionEntry> _map = IteratorExtensions.<Entry, ExecutionEntry>map(_filter, _function);
+      List<ExecutionEntry> _list = IteratorExtensions.<ExecutionEntry>toList(_map);
+      _nodes.addAll(_list);
+      _xblockexpression = (r);
+    }
+    return _xblockexpression;
+  }
+  
   public Statement conjunct(final Statement c1, final Statement c2) {
     Statement _xifexpression = null;
     boolean _and = false;
@@ -756,125 +797,229 @@ public class BehaviorMapping {
       ReactionFired _newTraceReactionFired = this.trace.newTraceReactionFired(r);
       _steps_2.add(_newTraceReactionFired);
     }
-    List<ExecutionScope> _entryScopes = this.entryScopes(t);
+    EList<Step> _steps_3 = sequence.getSteps();
+    ArrayList<Transition> _newArrayList = CollectionLiterals.<Transition>newArrayList(t);
+    Sequence _mapToStateConfigurationEnterSequence = this.mapToStateConfigurationEnterSequence(_newArrayList);
+    EList<Step> _steps_4 = _mapToStateConfigurationEnterSequence.getSteps();
+    _steps_3.addAll(_steps_4);
+    return sequence;
+  }
+  
+  /**
+   * Creates a compound effect that can consist of multiple transitions.
+   */
+  public Sequence mapToEffect(final List<Transition> transitions, final Reaction r) {
+    SexecFactory _factory = this.sexec.factory();
+    final Sequence sequence = _factory.createSequence();
+    Transition _get = transitions.get(0);
+    Iterable<State> _exitStates = this.exitStates(_get);
+    final List<State> exitStates = IterableExtensions.<State>toList(_exitStates);
+    for (final Transition t : transitions) {
+      Iterable<State> _exitStates_1 = this.exitStates(t);
+      List<State> _list = IterableExtensions.<State>toList(_exitStates_1);
+      exitStates.retainAll(_list);
+    }
+    final State topExitState = IterableExtensions.<State>last(exitStates);
+    boolean _notEquals = (!Objects.equal(topExitState, null));
+    if (_notEquals) {
+      ExecutionState _create = this.factory.create(topExitState);
+      final Sequence exitSequence = _create.getExitSequence();
+      boolean _notEquals_1 = (!Objects.equal(exitSequence, null));
+      if (_notEquals_1) {
+        EList<Step> _steps = sequence.getSteps();
+        Call _newCall = this.factory.newCall(exitSequence);
+        _steps.add(_newCall);
+      }
+    }
+    for (final Transition t_1 : transitions) {
+      {
+        Effect _effect = t_1.getEffect();
+        boolean _notEquals_2 = (!Objects.equal(_effect, null));
+        if (_notEquals_2) {
+          EList<Step> _steps_1 = sequence.getSteps();
+          Effect _effect_1 = t_1.getEffect();
+          Sequence _mapEffect = this.mapEffect(_effect_1);
+          _steps_1.add(_mapEffect);
+        }
+        boolean _isAddTraceSteps = this.trace.isAddTraceSteps();
+        if (_isAddTraceSteps) {
+          EList<Step> _steps_2 = sequence.getSteps();
+          Reaction _create_1 = this.factory.create(t_1);
+          ReactionFired _newTraceReactionFired = this.trace.newTraceReactionFired(_create_1);
+          _steps_2.add(_newTraceReactionFired);
+        }
+      }
+    }
+    EList<Step> _steps_1 = sequence.getSteps();
+    Sequence _mapToStateConfigurationEnterSequence = this.mapToStateConfigurationEnterSequence(transitions);
+    EList<Step> _steps_2 = _mapToStateConfigurationEnterSequence.getSteps();
+    _steps_1.addAll(_steps_2);
+    return sequence;
+  }
+  
+  /**
+   * Calcuates a sequence to enter one or more states. Entering multiple states is required for fork, where parts of a state
+   * configuration is specified.
+   */
+  public Sequence mapToStateConfigurationEnterSequence(final List<Transition> transitions) {
+    SexecFactory _factory = this.sexec.factory();
+    final Sequence sequence = _factory.createSequence();
+    Transition _get = transitions.get(0);
+    List<ExecutionScope> _entryScopes = this.entryScopes(_get);
     Iterable<ExecutionScope> _drop = IterableExtensions.<ExecutionScope>drop(_entryScopes, 1);
     List<ExecutionScope> _list = IterableExtensions.<ExecutionScope>toList(_drop);
-    List<ExecutionScope> _reverse = ListExtensions.<ExecutionScope>reverse(_list);
-    final Function2<Sequence,ExecutionScope,Sequence> _function = new Function2<Sequence,ExecutionScope,Sequence>() {
-        public Sequence apply(final Sequence seq, final ExecutionScope scope) {
-          Sequence _xblockexpression = null;
-          {
-            if ((scope instanceof ExecutionRegion)) {
-              ExecutionScope _superScope = scope.getSuperScope();
-              final EList<ExecutionScope> siblingRegions = _superScope.getSubScopes();
-              int _indexOf = siblingRegions.indexOf(scope);
-              Iterable<ExecutionScope> _take = IterableExtensions.<ExecutionScope>take(siblingRegions, _indexOf);
-              for (final ExecutionScope region : _take) {
-                Sequence _enterSequence = region.getEnterSequence();
-                boolean _notEquals = (!Objects.equal(_enterSequence, null));
-                if (_notEquals) {
-                  EList<Step> _steps = seq.getSteps();
-                  Sequence _enterSequence_1 = region.getEnterSequence();
-                  Call _newCall = BehaviorMapping.this.factory.newCall(_enterSequence_1);
-                  _steps.add(_newCall);
-                }
-              }
-            }
-            if ((scope instanceof ExecutionState)) {
-              Step _entryAction = ((ExecutionState) scope).getEntryAction();
-              boolean _notEquals_1 = (!Objects.equal(_entryAction, null));
-              if (_notEquals_1) {
-                EList<Step> _steps_1 = seq.getSteps();
-                Step _entryAction_1 = ((ExecutionState) scope).getEntryAction();
-                Call _newCall_1 = BehaviorMapping.this.factory.newCall(_entryAction_1);
-                _steps_1.add(_newCall_1);
-              }
-              boolean _isAddTraceSteps = BehaviorMapping.this.trace.isAddTraceSteps();
-              if (_isAddTraceSteps) {
-                EList<Step> _steps_2 = seq.getSteps();
-                TraceStateEntered _newTraceStateEntered = BehaviorMapping.this.trace.newTraceStateEntered(((ExecutionState) scope));
-                _steps_2.add(_newTraceStateEntered);
-              }
-            }
-            _xblockexpression = (seq);
-          }
-          return _xblockexpression;
+    final List<ExecutionScope> entryScopes = ListExtensions.<ExecutionScope>reverse(_list);
+    for (final Transition t : transitions) {
+      List<ExecutionScope> _entryScopes_1 = this.entryScopes(t);
+      entryScopes.retainAll(_entryScopes_1);
+    }
+    final ExecutionScope entryScope = IterableExtensions.<ExecutionScope>head(entryScopes);
+    final Function1<Transition,ExecutionNode> _function = new Function1<Transition,ExecutionNode>() {
+        public ExecutionNode apply(final Transition t) {
+          Vertex _target = t.getTarget();
+          ExecutionNode _mapped = BehaviorMapping.this.factory.mapped(_target);
+          return _mapped;
         }
       };
-    IterableExtensions.<ExecutionScope, Sequence>fold(_reverse, sequence, _function);
-    Vertex _target = t.getTarget();
-    boolean _notEquals_3 = (!Objects.equal(_target, null));
-    if (_notEquals_3) {
-      Vertex _target_1 = t.getTarget();
-      if ((_target_1 instanceof RegularState)) {
-        EList<Step> _steps_3 = sequence.getSteps();
-        Vertex _target_2 = t.getTarget();
-        ExecutionState _create_1 = this.factory.create(((RegularState) _target_2));
-        Sequence _enterSequence = _create_1.getEnterSequence();
-        Call _newCall_1 = this.factory.newCall(_enterSequence);
-        _steps_3.add(_newCall_1);
-      } else {
-        Vertex _target_3 = t.getTarget();
-        if ((_target_3 instanceof Choice)) {
-          EList<Step> _steps_4 = sequence.getSteps();
-          Vertex _target_4 = t.getTarget();
-          ExecutionChoice _create_2 = this.factory.create(((Choice) _target_4));
-          Sequence _reactSequence = _create_2.getReactSequence();
-          Call _newCall_2 = this.factory.newCall(_reactSequence);
-          _steps_4.add(_newCall_2);
-        } else {
-          Vertex _target_5 = t.getTarget();
-          if ((_target_5 instanceof Entry)) {
-            EList<Step> _steps_5 = sequence.getSteps();
-            Vertex _target_6 = t.getTarget();
-            ExecutionEntry _create_3 = this.factory.create(((Entry) _target_6));
-            Sequence _reactSequence_1 = _create_3.getReactSequence();
-            Call _newCall_3 = this.factory.newCall(_reactSequence_1);
-            _steps_5.add(_newCall_3);
-          } else {
-            Vertex _target_7 = t.getTarget();
-            if ((_target_7 instanceof Synchronization)) {
-              EList<Step> _steps_6 = sequence.getSteps();
-              Vertex _target_8 = t.getTarget();
-              ExecutionSynchronization _create_4 = this.factory.create(((Synchronization) _target_8));
-              Sequence _reactSequence_2 = _create_4.getReactSequence();
-              Call _newCall_4 = this.factory.newCall(_reactSequence_2);
-              _steps_6.add(_newCall_4);
-            }
-          }
-        }
+    final List<ExecutionNode> targets = ListExtensions.<Transition, ExecutionNode>map(transitions, _function);
+    boolean _notEquals = (!Objects.equal(entryScope, null));
+    if (_notEquals) {
+      this.addEnterStepsForTargetsToSequence(entryScope, targets, sequence);
+    } else {
+      for (final ExecutionNode t_1 : targets) {
+        this.addEnterStepsForTargetsToSequence(t_1, targets, sequence);
       }
     }
-    List<ExecutionScope> _entryScopes_1 = this.entryScopes(t);
-    Iterable<ExecutionScope> _drop_1 = IterableExtensions.<ExecutionScope>drop(_entryScopes_1, 1);
-    final Function2<Sequence,ExecutionScope,Sequence> _function_1 = new Function2<Sequence,ExecutionScope,Sequence>() {
-        public Sequence apply(final Sequence seq, final ExecutionScope scope) {
-          Sequence _xblockexpression = null;
-          {
-            if ((scope instanceof ExecutionRegion)) {
-              ExecutionScope _superScope = scope.getSuperScope();
-              final EList<ExecutionScope> siblingRegions = _superScope.getSubScopes();
-              int _indexOf = siblingRegions.indexOf(scope);
-              int _plus = (_indexOf + 1);
-              Iterable<ExecutionScope> _drop = IterableExtensions.<ExecutionScope>drop(siblingRegions, _plus);
-              for (final ExecutionScope region : _drop) {
-                Sequence _enterSequence = region.getEnterSequence();
-                boolean _notEquals = (!Objects.equal(_enterSequence, null));
-                if (_notEquals) {
-                  EList<Step> _steps = seq.getSteps();
-                  Sequence _enterSequence_1 = region.getEnterSequence();
-                  Call _newCall = BehaviorMapping.this.factory.newCall(_enterSequence_1);
-                  _steps.add(_newCall);
-                }
-              }
-            }
-            _xblockexpression = (seq);
-          }
-          return _xblockexpression;
+    return sequence;
+  }
+  
+  protected void _addEnterStepsForTargetsToSequence(final ExecutionState it, final List<ExecutionNode> targets, final Sequence seq) {
+    boolean _contains = targets.contains(it);
+    if (_contains) {
+      EList<Step> _steps = seq.getSteps();
+      Sequence _enterSequence = it.getEnterSequence();
+      Call _newCall = this.factory.newCall(_enterSequence);
+      _steps.add(_newCall);
+    } else {
+      Step _entryAction = it.getEntryAction();
+      boolean _notEquals = (!Objects.equal(_entryAction, null));
+      if (_notEquals) {
+        EList<Step> _steps_1 = seq.getSteps();
+        Step _entryAction_1 = it.getEntryAction();
+        Call _newCall_1 = this.factory.newCall(_entryAction_1);
+        _steps_1.add(_newCall_1);
+      }
+      boolean _isAddTraceSteps = this.trace.isAddTraceSteps();
+      if (_isAddTraceSteps) {
+        EList<Step> _steps_2 = seq.getSteps();
+        TraceStateEntered _newTraceStateEntered = this.trace.newTraceStateEntered(it);
+        _steps_2.add(_newTraceStateEntered);
+      }
+      EList<ExecutionScope> _subScopes = it.getSubScopes();
+      for (final ExecutionScope subScope : _subScopes) {
+        this.addEnterStepsForTargetsToSequence(subScope, targets, seq);
+      }
+    }
+  }
+  
+  protected void _addEnterStepsForTargetsToSequence(final ExecutionRegion it, final List<ExecutionNode> targets, final Sequence seq) {
+    final Function1<ExecutionNode,Boolean> _function = new Function1<ExecutionNode,Boolean>() {
+        public Boolean apply(final ExecutionNode t) {
+          EList<ExecutionNode> _nodes = it.getNodes();
+          boolean _contains = _nodes.contains(t);
+          return Boolean.valueOf(_contains);
         }
       };
-    IterableExtensions.<ExecutionScope, Sequence>fold(_drop_1, sequence, _function_1);
-    return sequence;
+    Iterable<ExecutionNode> _filter = IterableExtensions.<ExecutionNode>filter(targets, _function);
+    final ExecutionNode target = IterableExtensions.<ExecutionNode>head(_filter);
+    boolean _notEquals = (!Objects.equal(target, null));
+    if (_notEquals) {
+      this.addEnterStepsForTargetsToSequence(target, targets, seq);
+      return;
+    }
+    Set<ExecutionNode> _allNodes = this.allNodes(it);
+    final Function1<ExecutionNode,Boolean> _function_1 = new Function1<ExecutionNode,Boolean>() {
+        public Boolean apply(final ExecutionNode n) {
+          boolean _contains = targets.contains(n);
+          return Boolean.valueOf(_contains);
+        }
+      };
+    boolean _exists = IterableExtensions.<ExecutionNode>exists(_allNodes, _function_1);
+    if (_exists) {
+      EList<ExecutionScope> _subScopes = it.getSubScopes();
+      for (final ExecutionScope s : _subScopes) {
+        Set<ExecutionNode> _allNodes_1 = this.allNodes(s);
+        final Function1<ExecutionNode,Boolean> _function_2 = new Function1<ExecutionNode,Boolean>() {
+            public Boolean apply(final ExecutionNode n) {
+              boolean _contains = targets.contains(n);
+              return Boolean.valueOf(_contains);
+            }
+          };
+        boolean _exists_1 = IterableExtensions.<ExecutionNode>exists(_allNodes_1, _function_2);
+        if (_exists_1) {
+          this.addEnterStepsForTargetsToSequence(s, targets, seq);
+        }
+      }
+    } else {
+      EList<Step> _steps = seq.getSteps();
+      Sequence _enterSequence = it.getEnterSequence();
+      Call _newCall = this.factory.newCall(_enterSequence);
+      _steps.add(_newCall);
+    }
+  }
+  
+  protected Set<ExecutionNode> _allNodes(final ExecutionRegion it) {
+    HashSet<ExecutionNode> _xblockexpression = null;
+    {
+      HashSet<ExecutionNode> _hashSet = new HashSet<ExecutionNode>();
+      final HashSet<ExecutionNode> allNodes = _hashSet;
+      EList<ExecutionNode> _nodes = it.getNodes();
+      Iterables.<ExecutionNode>addAll(allNodes, _nodes);
+      EList<ExecutionScope> _subScopes = it.getSubScopes();
+      for (final ExecutionScope s : _subScopes) {
+        Set<ExecutionNode> _allNodes = this.allNodes(s);
+        Iterables.<ExecutionNode>addAll(allNodes, _allNodes);
+      }
+      _xblockexpression = (allNodes);
+    }
+    return _xblockexpression;
+  }
+  
+  protected Set<ExecutionNode> _allNodes(final ExecutionState it) {
+    HashSet<ExecutionNode> _xblockexpression = null;
+    {
+      HashSet<ExecutionNode> _hashSet = new HashSet<ExecutionNode>();
+      final HashSet<ExecutionNode> allNodes = _hashSet;
+      allNodes.add(it);
+      EList<ExecutionScope> _subScopes = it.getSubScopes();
+      for (final ExecutionScope s : _subScopes) {
+        Set<ExecutionNode> _allNodes = this.allNodes(s);
+        Iterables.<ExecutionNode>addAll(allNodes, _allNodes);
+      }
+      _xblockexpression = (allNodes);
+    }
+    return _xblockexpression;
+  }
+  
+  protected void _addEnterStepsForTargetsToSequence(final ExecutionChoice it, final List<ExecutionNode> targets, final Sequence seq) {
+    EList<Step> _steps = seq.getSteps();
+    Sequence _reactSequence = it.getReactSequence();
+    Call _newCall = this.factory.newCall(_reactSequence);
+    _steps.add(_newCall);
+  }
+  
+  protected void _addEnterStepsForTargetsToSequence(final ExecutionEntry it, final List<ExecutionNode> targets, final Sequence seq) {
+    EList<Step> _steps = seq.getSteps();
+    Sequence _reactSequence = it.getReactSequence();
+    Call _newCall = this.factory.newCall(_reactSequence);
+    _steps.add(_newCall);
+  }
+  
+  protected void _addEnterStepsForTargetsToSequence(final ExecutionSynchronization it, final List<ExecutionNode> targets, final Sequence seq) {
+    EList<Step> _steps = seq.getSteps();
+    Sequence _reactSequence = it.getReactSequence();
+    Call _newCall = this.factory.newCall(_reactSequence);
+    _steps.add(_newCall);
   }
   
   public List<ExecutionScope> entryScopes(final Transition t) {
@@ -1099,6 +1244,39 @@ public class BehaviorMapping {
     }
   }
   
+  public void addEnterStepsForTargetsToSequence(final EObject it, final List<ExecutionNode> targets, final Sequence seq) {
+    if (it instanceof ExecutionChoice) {
+      _addEnterStepsForTargetsToSequence((ExecutionChoice)it, targets, seq);
+      return;
+    } else if (it instanceof ExecutionEntry) {
+      _addEnterStepsForTargetsToSequence((ExecutionEntry)it, targets, seq);
+      return;
+    } else if (it instanceof ExecutionRegion) {
+      _addEnterStepsForTargetsToSequence((ExecutionRegion)it, targets, seq);
+      return;
+    } else if (it instanceof ExecutionState) {
+      _addEnterStepsForTargetsToSequence((ExecutionState)it, targets, seq);
+      return;
+    } else if (it instanceof ExecutionSynchronization) {
+      _addEnterStepsForTargetsToSequence((ExecutionSynchronization)it, targets, seq);
+      return;
+    } else {
+      throw new IllegalArgumentException("Unhandled parameter types: " +
+        Arrays.<Object>asList(it, targets, seq).toString());
+    }
+  }
+  
+  public Set<ExecutionNode> allNodes(final ExecutionScope it) {
+    if (it instanceof ExecutionRegion) {
+      return _allNodes((ExecutionRegion)it);
+    } else if (it instanceof ExecutionState) {
+      return _allNodes((ExecutionState)it);
+    } else {
+      throw new IllegalArgumentException("Unhandled parameter types: " +
+        Arrays.<Object>asList(it).toString());
+    }
+  }
+  
   public Statement buildCondition(final Trigger t) {
     if (t instanceof ReactionTrigger) {
       return _buildCondition((ReactionTrigger)t);

plugins/org.yakindu.sct.model.sexec/xtend-gen/org/yakindu/sct/model/sexec/transformation/ModelSequencer.java

@@ -67,8 +67,8 @@ public class ModelSequencer {
     final ExecutionFlow ef = this.mapping.create(sc);
     this.structureMapping.mapScopes(sc, ef);
     this.structureMapping.mapRegularStates(sc, ef);
-    this.structureMapping.mapRegions(sc, ef);
     this.structureMapping.mapPseudoStates(sc, ef);
+    this.structureMapping.mapRegions(sc, ef);
     this.structureMapping.mapTimeEvents(sc, ef);
     this.svBuilder.defineStateVector(ef, sc);
     this.svBuilder.defineHistoryVector(ef, sc);
@@ -81,6 +81,7 @@ public class ModelSequencer {
     this.seqBuilder.defineStatechartEnterSequence(ef, sc);
     this.seqBuilder.defineStatechartExitSequence(ef, sc);
     this.behaviorMapping.mapTransitions(sc, ef);
+    this.behaviorMapping.mapEntries(sc, ef);
     this.behaviorMapping.mapLocalReactions(sc, ef);
     this.behaviorMapping.mapChoiceTransitions(sc, ef);
     this.behaviorMapping.mapSyncTransitions(sc, ef);

plugins/org.yakindu.sct.model.sexec/xtend-gen/org/yakindu/sct/model/sexec/transformation/SexecElementMapping.java

@@ -17,6 +17,7 @@ import org.eclipse.xtext.util.Strings;
 import org.eclipse.xtext.xbase.lib.CollectionLiterals;
 import org.eclipse.xtext.xbase.lib.Functions.Function0;
 import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
 import org.eclipse.xtext.xbase.lib.StringExtensions;
 import org.yakindu.base.base.NamedElement;
 import org.yakindu.sct.model.sexec.Call;
@@ -25,9 +26,11 @@ import org.yakindu.sct.model.sexec.CheckRef;
 import org.yakindu.sct.model.sexec.ExecutionChoice;
 import org.yakindu.sct.model.sexec.ExecutionEntry;
 import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.model.sexec.ExecutionNode;
 import org.yakindu.sct.model.sexec.ExecutionRegion;
 import org.yakindu.sct.model.sexec.ExecutionState;
 import org.yakindu.sct.model.sexec.ExecutionSynchronization;
+import org.yakindu.sct.model.sexec.Reaction;
 import org.yakindu.sct.model.sexec.ScheduleTimeEvent;
 import org.yakindu.sct.model.sexec.Sequence;
 import org.yakindu.sct.model.sexec.SexecFactory;
@@ -43,7 +46,6 @@ import org.yakindu.sct.model.sgraph.CompositeElement;
 import org.yakindu.sct.model.sgraph.Entry;
 import org.yakindu.sct.model.sgraph.EntryKind;
 import org.yakindu.sct.model.sgraph.FinalState;
-import org.yakindu.sct.model.sgraph.Reaction;
 import org.yakindu.sct.model.sgraph.Region;
 import org.yakindu.sct.model.sgraph.RegularState;
 import org.yakindu.sct.model.sgraph.SGraphFactory;
@@ -471,6 +473,15 @@ public class SexecElementMapping {
       String _plus_6 = (_plus_5 + _name_4);
       seq.setComment(_plus_6);
       r.setReactSequence(seq);
+      EList<Transition> _outgoingTransitions = entry.getOutgoingTransitions();
+      final Procedure1<Transition> _function = new Procedure1<Transition>() {
+          public void apply(final Transition t) {
+            EList<Reaction> _reactions = r.getReactions();
+            Reaction _create = SexecElementMapping.this.create(t);
+            _reactions.add(_create);
+          }
+        };
+      IterableExtensions.<Transition>forEach(_outgoingTransitions, _function);
     }
   }
   
@@ -571,20 +582,20 @@ public class SexecElementMapping {
   private final HashMap<ArrayList<? extends Object>,Check> _createCache_createCheck = CollectionLiterals.newHashMap();
   
   private void _init_createCheck(final Check r, final ReactionTrigger tr) {
-    Reaction _reaction = this.sce.reaction(tr);
+    org.yakindu.sct.model.sgraph.Reaction _reaction = this.sce.reaction(tr);
     String _id = this.sce.id(_reaction);
     r.setName(_id);
   }
   
-  public org.yakindu.sct.model.sexec.Reaction create(final Transition tr) {
+  public Reaction create(final Transition tr) {
     final ArrayList<?>_cacheKey = CollectionLiterals.newArrayList(tr);
-    final org.yakindu.sct.model.sexec.Reaction _result;
+    final Reaction _result;
     synchronized (_createCache_create_11) {
       if (_createCache_create_11.containsKey(_cacheKey)) {
         return _createCache_create_11.get(_cacheKey);
       }
       SexecFactory _sexecFactory = this.sexecFactory();
-      org.yakindu.sct.model.sexec.Reaction _createReaction = _sexecFactory.createReaction();
+      Reaction _createReaction = _sexecFactory.createReaction();
       _result = _createReaction;
       _createCache_create_11.put(_cacheKey, _result);
     }
@@ -592,24 +603,24 @@ public class SexecElementMapping {
     return _result;
   }
   
-  private final HashMap<ArrayList<? extends Object>,org.yakindu.sct.model.sexec.Reaction> _createCache_create_11 = CollectionLiterals.newHashMap();
+  private final HashMap<ArrayList<? extends Object>,Reaction> _createCache_create_11 = CollectionLiterals.newHashMap();
   
-  private void _init_create_11(final org.yakindu.sct.model.sexec.Reaction r, final Transition tr) {
+  private void _init_create_11(final Reaction r, final Transition tr) {
     String _id = this.sce.id(tr);
     r.setName(_id);
     r.setTransition(true);
     r.setSourceElement(tr);
   }
   
-  public org.yakindu.sct.model.sexec.Reaction create(final LocalReaction lr) {
+  public Reaction create(final LocalReaction lr) {
     final ArrayList<?>_cacheKey = CollectionLiterals.newArrayList(lr);
-    final org.yakindu.sct.model.sexec.Reaction _result;
+    final Reaction _result;
     synchronized (_createCache_create_12) {
       if (_createCache_create_12.containsKey(_cacheKey)) {
         return _createCache_create_12.get(_cacheKey);
       }
       SexecFactory _sexecFactory = this.sexecFactory();
-      org.yakindu.sct.model.sexec.Reaction _createReaction = _sexecFactory.createReaction();
+      Reaction _createReaction = _sexecFactory.createReaction();
       _result = _createReaction;
       _createCache_create_12.put(_cacheKey, _result);
     }
@@ -617,9 +628,9 @@ public class SexecElementMapping {
     return _result;
   }
   
-  private final HashMap<ArrayList<? extends Object>,org.yakindu.sct.model.sexec.Reaction> _createCache_create_12 = CollectionLiterals.newHashMap();
+  private final HashMap<ArrayList<? extends Object>,Reaction> _createCache_create_12 = CollectionLiterals.newHashMap();
   
-  private void _init_create_12(final org.yakindu.sct.model.sexec.Reaction r, final LocalReaction lr) {
+  private void _init_create_12(final Reaction r, final LocalReaction lr) {
     String _id = this.sce.id(lr);
     r.setName(_id);
     r.setTransition(false);
@@ -790,6 +801,31 @@ public class SexecElementMapping {
     return r;
   }
   
+  protected ExecutionNode _mapped(final State s) {
+    ExecutionState _create = this.create(s);
+    return _create;
+  }
+  
+  protected ExecutionNode _mapped(final FinalState s) {
+    ExecutionState _create = this.create(s);
+    return _create;
+  }
+  
+  protected ExecutionNode _mapped(final Choice s) {
+    ExecutionChoice _create = this.create(s);
+    return _create;
+  }
+  
+  protected ExecutionNode _mapped(final Entry s) {
+    ExecutionEntry _create = this.create(s);
+    return _create;
+  }
+  
+  protected ExecutionNode _mapped(final Synchronization s) {
+    ExecutionSynchronization _create = this.create(s);
+    return _create;
+  }
+  
   public SexecFactory sexecFactory() {
     return SexecFactory.eINSTANCE;
   }
@@ -844,4 +880,21 @@ public class SexecElementMapping {
         Arrays.<Object>asList(ed, context).toString());
     }
   }
+  
+  public ExecutionNode mapped(final Vertex s) {
+    if (s instanceof Choice) {
+      return _mapped((Choice)s);
+    } else if (s instanceof Entry) {
+      return _mapped((Entry)s);
+    } else if (s instanceof FinalState) {
+      return _mapped((FinalState)s);
+    } else if (s instanceof State) {
+      return _mapped((State)s);
+    } else if (s instanceof Synchronization) {
+      return _mapped((Synchronization)s);
+    } else {
+      throw new IllegalArgumentException("Unhandled parameter types: " +
+        Arrays.<Object>asList(s).toString());
+    }
+  }
 }

plugins/org.yakindu.sct.model.sexec/xtend-gen/org/yakindu/sct/model/sexec/transformation/StructureMapping.java

@@ -182,6 +182,17 @@ public class StructureMapping {
       };
     Iterable<ExecutionScope> _map = IterableExtensions.<RegularState, ExecutionScope>map(_filter, _function);
     Iterables.<ExecutionScope>addAll(_subScopes, _map);
+    EList<ExecutionNode> _nodes = _region.getNodes();
+    EList<Vertex> _vertices_1 = region.getVertices();
+    Iterable<Vertex> _filter_1 = Iterables.<Vertex>filter(_vertices_1, Vertex.class);
+    final Function1<Vertex,ExecutionNode> _function_1 = new Function1<Vertex,ExecutionNode>() {
+        public ExecutionNode apply(final Vertex v) {
+          ExecutionNode _mapped = StructureMapping.this.mapping.mapped(v);
+          return _mapped;
+        }
+      };
+    Iterable<ExecutionNode> _map_1 = IterableExtensions.<Vertex, ExecutionNode>map(_filter_1, _function_1);
+    Iterables.<ExecutionNode>addAll(_nodes, _map_1);
     return _region;
   }