Refactoring of ISTextTypeSystem and ISTextTypeInferrer

plugins/org.yakindu.sct.generator.c/src/org/yakindu/sct/generator/c/ExpressionCode.xtend

@@ -34,6 +34,8 @@ import org.yakindu.base.expressions.expressions.PrimitiveValueExpression
 import org.yakindu.base.expressions.expressions.RealLiteral
 import org.yakindu.base.expressions.expressions.ShiftExpression
 import org.yakindu.base.expressions.expressions.StringLiteral
+import org.yakindu.base.types.ITypeSystem
+import org.yakindu.sct.model.sexec.naming.INamingService
 import org.yakindu.sct.model.sgraph.Event
 import org.yakindu.sct.model.stext.stext.ActiveStateReferenceExpression
 import org.yakindu.sct.model.stext.stext.EventRaisingExpression
@@ -41,130 +43,97 @@ import org.yakindu.sct.model.stext.stext.EventValueReferenceExpression
 import org.yakindu.sct.model.stext.stext.OperationDefinition
 import org.yakindu.sct.model.stext.stext.VariableDefinition
 import org.yakindu.sct.model.stext.types.ISTextTypeInferrer
-import org.yakindu.sct.model.stext.types.ISTextTypeSystem
-import org.yakindu.sct.model.sexec.naming.INamingService
 
 class ExpressionCode {
-	 
+
 	@Inject extension Naming
 	@Inject extension Navigation
-	@Inject extension ISTextTypeSystem
+	@Inject extension ITypeSystem
 	@Inject extension ISTextTypeInferrer
 	@Inject extension INamingService
-	
+
 	/* Refering to declared elements */
-	
-	def dispatch CharSequence code (ElementReferenceExpression it) {
+	def dispatch CharSequence code(ElementReferenceExpression it) {
 		it.code(it.definition)
 	}
-		
-	def dispatch CharSequence code (FeatureCall it) {
+
+	def dispatch CharSequence code(FeatureCall it) {
 		it.code(it.definition)
 	}
-		
-	def dispatch CharSequence code (Expression it, Event target) 
-		'''«target.access»'''
-		
-	def dispatch CharSequence code (Expression it, VariableDefinition target) 
-		'''«target.access»'''
-	
-	def dispatch CharSequence code (ElementReferenceExpression it, OperationDefinition target) 
-		'''«target.access»(«FOR arg:args SEPARATOR ', '»«arg.code»«ENDFOR»)'''
-	
-	def dispatch CharSequence code (FeatureCall it, OperationDefinition target) 
-		'''«target.access»(«FOR arg:args SEPARATOR ', '»«arg.code»«ENDFOR»)'''
-	
+
+	def dispatch CharSequence code(Expression it, Event target) '''«target.access»'''
+
+	def dispatch CharSequence code(Expression it, VariableDefinition target) '''«target.access»'''
+
+	def dispatch CharSequence code(ElementReferenceExpression it, OperationDefinition target) '''«target.access»(«FOR arg : args SEPARATOR ', '»«arg.
+		code»«ENDFOR»)'''
+
+	def dispatch CharSequence code(FeatureCall it, OperationDefinition target) '''«target.access»(«FOR arg : args SEPARATOR ', '»«arg.
+		code»«ENDFOR»)'''
+
 	/* HANDLING LITERALS */
-	def dispatch CharSequence code (Literal it)
-		'''#error unknown literal type «getClass().name» '''
-	
-	
-	def dispatch CharSequence code (StringLiteral it) 
-		'''"«value.escaped»"'''	
-		
+	def dispatch CharSequence code(Literal it) '''#error unknown literal type «getClass().name» '''
+
+	def dispatch CharSequence code(StringLiteral it) '''"«value.escaped»"'''
+
 	def String escaped(String it) {
 		return it.replace("\"", "\\\"");
 	}
-	
 
-	def dispatch CharSequence code (BoolLiteral it) 
-		'''«IF value»bool_true«ELSE»bool_false«ENDIF»'''	
+	def dispatch CharSequence code(BoolLiteral it) '''«IF value»bool_true«ELSE»bool_false«ENDIF»'''
+
+	def dispatch CharSequence code(IntLiteral it) '''«value.toString»'''
 
-	def dispatch CharSequence code (IntLiteral it) 
-		'''«value.toString»'''	
+	def dispatch CharSequence code(RealLiteral it) '''«value.toString»'''
 
-	def dispatch CharSequence code (RealLiteral it) 
-		'''«value.toString»'''	
-		
-	def dispatch CharSequence code (HexLiteral it) 
-		'''0x«Integer::toHexString(value)»'''	
+	def dispatch CharSequence code(HexLiteral it) '''0x«Integer::toHexString(value)»'''
 
-	def dispatch CharSequence code (PrimitiveValueExpression it) 
-		'''«value.code»'''	
+	def dispatch CharSequence code(PrimitiveValueExpression it) '''«value.code»'''
 
-		
 	/* Statements */
-	
-	def dispatch CharSequence code (AssignmentExpression it)
-		'''«varRef.code» «operator.literal» «expression.code»'''
-		
-	def dispatch CharSequence code (EventRaisingExpression it)
-		'''
-		«IF value != null»
-			«event.definition.event.valueAccess» = «value.code»;
-		«ENDIF»
-		«event.definition.event.access» = bool_true'''	
+	def dispatch CharSequence code(AssignmentExpression it) '''«varRef.code» «operator.literal» «expression.code»'''
 
+	def dispatch CharSequence code(EventRaisingExpression it) '''
+	«IF value != null»
+		«event.definition.event.valueAccess» = «value.code»;
+	«ENDIF»
+	«event.definition.event.access» = bool_true'''
 
 	/* Logical Expressions */
-	
-	def dispatch CharSequence code (LogicalOrExpression it)
-		'''«leftOperand.code» || «rightOperand.code»'''
-		
-	def dispatch CharSequence code (LogicalAndExpression it)
-		'''«leftOperand.code» && «rightOperand.code»'''
-	 	
-	def dispatch CharSequence code (LogicalNotExpression it)
-		'''! «operand.code»'''
-		
-	def dispatch CharSequence code (LogicalRelationExpression it) '''
-		«IF leftOperand.inferType.type.stringType»
-			(strcmp(«leftOperand.code», «rightOperand.code») «operator.literal» 0)
-		«ELSE»«leftOperand.code» «operator.literal» «rightOperand.code»«ENDIF»'''
-	
+	def dispatch CharSequence code(LogicalOrExpression it) '''«leftOperand.code» || «rightOperand.code»'''
+
+	def dispatch CharSequence code(LogicalAndExpression it) '''«leftOperand.code» && «rightOperand.code»'''
+
+	def dispatch CharSequence code(LogicalNotExpression it) '''! «operand.code»'''
+
+	def dispatch CharSequence code(LogicalRelationExpression it) '''
+	«IF leftOperand.inferType.type.stringType»
+		(strcmp(«leftOperand.code», «rightOperand.code») «operator.literal» 0)
+	«ELSE»«leftOperand.code» «operator.literal» «rightOperand.code»«ENDIF»'''
+
 	/* Bitwise Operations */
-	
-	def dispatch CharSequence code (BitwiseAndExpression it)
-		'''«leftOperand.code» & «rightOperand.code»'''
-	
-	def dispatch CharSequence code (BitwiseOrExpression it)
-		'''«leftOperand.code» | «rightOperand.code»'''
-	
-	def dispatch CharSequence code (BitwiseXorExpression it)
-		'''«leftOperand.code» ^ «rightOperand.code»'''
-	
-	def dispatch CharSequence code (ShiftExpression it)
-		'''«leftOperand.code» «operator.literal» «rightOperand.code»'''
+	def dispatch CharSequence code(BitwiseAndExpression it) '''«leftOperand.code» & «rightOperand.code»'''
+
+	def dispatch CharSequence code(BitwiseOrExpression it) '''«leftOperand.code» | «rightOperand.code»'''
+
+	def dispatch CharSequence code(BitwiseXorExpression it) '''«leftOperand.code» ^ «rightOperand.code»'''
+
+	def dispatch CharSequence code(ShiftExpression it) '''«leftOperand.code» «operator.literal» «rightOperand.code»'''
 
 	/* Numerical operations */
-	
-	def dispatch CharSequence code (NumericalAddSubtractExpression it)
-		'''«leftOperand.code» «operator.literal» «rightOperand.code»'''
-	
-	def dispatch CharSequence code (NumericalMultiplyDivideExpression it)
-		'''«leftOperand.code» «operator.literal» «rightOperand.code»'''
-	
-	def dispatch CharSequence code (NumericalUnaryExpression it)
-		'''«operator.literal» «operand.code»'''
-	
+	def dispatch CharSequence code(NumericalAddSubtractExpression it) '''«leftOperand.code» «operator.literal» «rightOperand.
+		code»'''
+
+	def dispatch CharSequence code(NumericalMultiplyDivideExpression it) '''«leftOperand.code» «operator.literal» «rightOperand.
+		code»'''
+
+	def dispatch CharSequence code(NumericalUnaryExpression it) '''«operator.literal» «operand.code»'''
+
 	/* TODO: check if event is active */
-	def dispatch CharSequence code (EventValueReferenceExpression it)
-		'''«value.definition.event.valueAccess»'''
-	
-	def dispatch CharSequence code (ActiveStateReferenceExpression it)
-		'''«flow.activeFctID»(«scHandle», «value.shortName»)'''
-	
-	def dispatch CharSequence code (ParenthesizedExpression it)
-		'''(«expression.code»)'''
-	
-}
+	def dispatch CharSequence code(EventValueReferenceExpression it) '''«value.definition.event.valueAccess»'''
+
+	def dispatch CharSequence code(ActiveStateReferenceExpression it) '''«flow.activeFctID»(«scHandle», «value.shortName»)'''
+
+	def dispatch CharSequence code(ParenthesizedExpression it) '''(«expression.code»)'''
+
+}

plugins/org.yakindu.sct.generator.c/src/org/yakindu/sct/generator/c/types/CTypeSystemAccess.xtend

@@ -7,31 +7,31 @@
  *
  * Contributors:
  *     committers of YAKINDU - initial API and implementation
- */
+ */
 package org.yakindu.sct.generator.c.types
 
 import com.google.inject.Inject
+import org.yakindu.base.types.ITypeSystem
 import org.yakindu.base.types.Type
 import org.yakindu.sct.generator.core.types.ICodegenTypeSystemAccess
-import org.yakindu.sct.model.stext.types.ISTextTypeSystem
-
+
 /**
  * @author andreas muelder
  * @author Alexander Nyßen - Adopted to type system changes
- */
-class CTypeSystemAccess implements ICodegenTypeSystemAccess {
-	
-	@Inject
-	extension ISTextTypeSystem ts
-	
-	override getTargetLanguageName(Type type) {
-		switch (type) {
-			case type == null || isVoidType(type): 'void'
-			case isIntegerType(type): 'sc_integer'
-			case isRealType(type)	: 'sc_real'
-			case isBooleanType(type): 'sc_boolean'
-			case isStringType(type)	: 'sc_string'
-		}
-	}
-	
-}
+ */
+class CTypeSystemAccess implements ICodegenTypeSystemAccess {
+
+	@Inject
+	extension ITypeSystem ts
+
+	override getTargetLanguageName(Type type) {
+		switch (type) {
+			case type == null || isVoidType(type): 'void'
+			case isIntegerType(type): 'sc_integer'
+			case isRealType(type): 'sc_real'
+			case isBooleanType(type): 'sc_boolean'
+			case isStringType(type): 'sc_string'
+		}
+	}
+
+}

plugins/org.yakindu.sct.generator.cpp/src/org/yakindu/sct/generator/cpp/ExpressionCode.xtend

@@ -24,6 +24,8 @@ import org.yakindu.base.expressions.expressions.PrimitiveValueExpression
 import org.yakindu.base.expressions.expressions.RealLiteral
 import org.yakindu.base.expressions.expressions.ShiftExpression
 import org.yakindu.base.expressions.expressions.StringLiteral
+import org.yakindu.base.types.ITypeSystem
+import org.yakindu.sct.model.sexec.naming.INamingService
 import org.yakindu.sct.model.sgraph.Event
 import org.yakindu.sct.model.stext.stext.ActiveStateReferenceExpression
 import org.yakindu.sct.model.stext.stext.EventRaisingExpression
@@ -31,134 +33,98 @@ import org.yakindu.sct.model.stext.stext.EventValueReferenceExpression
 import org.yakindu.sct.model.stext.stext.OperationDefinition
 import org.yakindu.sct.model.stext.stext.VariableDefinition
 import org.yakindu.sct.model.stext.types.ISTextTypeInferrer
-import org.yakindu.sct.model.stext.types.ISTextTypeSystem
-import org.yakindu.sct.model.sexec.naming.INamingService
 
 class ExpressionCode {
-	
+
 	@Inject extension Naming
 	@Inject extension Navigation
-	@Inject extension ISTextTypeSystem
+	@Inject extension ITypeSystem
 	@Inject extension ISTextTypeInferrer
 	@Inject extension INamingService
-	
+
 	/* Refering to declared elements */
-	
-	def dispatch CharSequence code (ElementReferenceExpression it) {
+	def dispatch CharSequence code(ElementReferenceExpression it) {
 		it.code(it.definition)
 	}
-		
-	def dispatch CharSequence code (FeatureCall it) {
+
+	def dispatch CharSequence code(FeatureCall it) {
 		it.code(it.definition)
 	}
-		
-	def dispatch CharSequence code (Expression it, Event target) 
-		'''«target.access»'''
-		
-	def dispatch CharSequence code (Expression it, VariableDefinition target) 
-		'''«target.access»'''
-	
-	def dispatch CharSequence code (ElementReferenceExpression it, OperationDefinition target) 
-		'''«target.access»(«FOR arg:args SEPARATOR ', '»«arg.code»«ENDFOR»)'''
-	
-	def dispatch CharSequence code (FeatureCall it, OperationDefinition target) 
-		'''«target.access»(«FOR arg:args SEPARATOR ', '»«arg.code»«ENDFOR»)'''
-	
-	
-	def dispatch CharSequence code (Expression it) 
-		'''#error TODO: generate code for «getClass().name»'''
-
-	
+
+	def dispatch CharSequence code(Expression it, Event target) '''«target.access»'''
+
+	def dispatch CharSequence code(Expression it, VariableDefinition target) '''«target.access»'''
+
+	def dispatch CharSequence code(ElementReferenceExpression it, OperationDefinition target) '''«target.access»(«FOR arg : args SEPARATOR ', '»«arg.
+		code»«ENDFOR»)'''
+
+	def dispatch CharSequence code(FeatureCall it, OperationDefinition target) '''«target.access»(«FOR arg : args SEPARATOR ', '»«arg.
+		code»«ENDFOR»)'''
+
+	def dispatch CharSequence code(Expression it) '''#error TODO: generate code for «getClass().name»'''
+
 	/* HANDLING LITERALS */
-	def dispatch CharSequence code (Literal it)
-		'''#error unknown literal type «getClass().name» '''
-	
-	
-	def dispatch CharSequence code (StringLiteral it) 
-		'''"«value.escaped»"'''	
-		
+	def dispatch CharSequence code(Literal it) '''#error unknown literal type «getClass().name» '''
+
+	def dispatch CharSequence code(StringLiteral it) '''"«value.escaped»"'''
+
 	def String escaped(String it) {
 		return it.replace("\"", "\\\"");
 	}
-	
 
-	def dispatch CharSequence code (BoolLiteral it) 
-		'''«IF value»true«ELSE»false«ENDIF»'''	
+	def dispatch CharSequence code(BoolLiteral it) '''«IF value»true«ELSE»false«ENDIF»'''
 
-	def dispatch CharSequence code (IntLiteral it) 
-		'''«value.toString»'''	
+	def dispatch CharSequence code(IntLiteral it) '''«value.toString»'''
 
-	def dispatch CharSequence code (RealLiteral it) 
-		'''«value.toString»'''	
-		
-	def dispatch CharSequence code (HexLiteral it) 
-		'''0x«Integer::toHexString(value)»'''	
+	def dispatch CharSequence code(RealLiteral it) '''«value.toString»'''
 
-	def dispatch CharSequence code (PrimitiveValueExpression it) 
-		'''«value.code»'''	
+	def dispatch CharSequence code(HexLiteral it) '''0x«Integer::toHexString(value)»'''
+
+	def dispatch CharSequence code(PrimitiveValueExpression it) '''«value.code»'''
 
-		
 	/* Statements */
-	
-	def dispatch CharSequence code (AssignmentExpression it)
-		'''«varRef.code» «operator.literal» «expression.code»'''
-		
-	def dispatch CharSequence code (EventRaisingExpression it)
-		'''
-		«IF value != null»
-			«event.definition.event.valueAccess» = «value.code»;
-		«ENDIF»
-		«event.definition.event.access» = true'''	
+	def dispatch CharSequence code(AssignmentExpression it) '''«varRef.code» «operator.literal» «expression.code»'''
 
+	def dispatch CharSequence code(EventRaisingExpression it) '''
+	«IF value != null»
+		«event.definition.event.valueAccess» = «value.code»;
+	«ENDIF»
+	«event.definition.event.access» = true'''
 
 	/* Logical Expressions */
-	
-	def dispatch CharSequence code (LogicalOrExpression it)
-		'''«leftOperand.code» || «rightOperand.code»'''
-		
-	def dispatch CharSequence code (LogicalAndExpression it)
-		'''«leftOperand.code» && «rightOperand.code»'''
-	 	
-	def dispatch CharSequence code (LogicalNotExpression it)
-		'''! «operand.code»'''
-		
-	def dispatch CharSequence code (LogicalRelationExpression it) '''
-		«IF leftOperand.inferType.type.stringType»
-			(«leftOperand.code».compare(«rightOperand.code») «operator.literal» 0)
-		«ELSE»«leftOperand.code» «operator.literal» «rightOperand.code»«ENDIF»'''
-	
+	def dispatch CharSequence code(LogicalOrExpression it) '''«leftOperand.code» || «rightOperand.code»'''
+
+	def dispatch CharSequence code(LogicalAndExpression it) '''«leftOperand.code» && «rightOperand.code»'''
+
+	def dispatch CharSequence code(LogicalNotExpression it) '''! «operand.code»'''
+
+	def dispatch CharSequence code(LogicalRelationExpression it) '''
+	«IF leftOperand.inferType.type.stringType»
+		(«leftOperand.code».compare(«rightOperand.code») «operator.literal» 0)
+	«ELSE»«leftOperand.code» «operator.literal» «rightOperand.code»«ENDIF»'''
+
 	/* Bitwise Operations */
-	
-	def dispatch CharSequence code (BitwiseAndExpression it)
-		'''«leftOperand.code» & «rightOperand.code»'''
-	
-	def dispatch CharSequence code (BitwiseOrExpression it)
-		'''«leftOperand.code» | «rightOperand.code»'''
-	
-	def dispatch CharSequence code (BitwiseXorExpression it)
-		'''«leftOperand.code» ^ «rightOperand.code»'''
-	
-	def dispatch CharSequence code (ShiftExpression it)
-		'''«leftOperand.code» «operator.literal» «rightOperand.code»'''
+	def dispatch CharSequence code(BitwiseAndExpression it) '''«leftOperand.code» & «rightOperand.code»'''
+
+	def dispatch CharSequence code(BitwiseOrExpression it) '''«leftOperand.code» | «rightOperand.code»'''
+
+	def dispatch CharSequence code(BitwiseXorExpression it) '''«leftOperand.code» ^ «rightOperand.code»'''
+
+	def dispatch CharSequence code(ShiftExpression it) '''«leftOperand.code» «operator.literal» «rightOperand.code»'''
 
 	/* Numerical operations */
-	
-	def dispatch CharSequence code (NumericalAddSubtractExpression it)
-		'''«leftOperand.code» «operator.literal» «rightOperand.code»'''
-	
-	def dispatch CharSequence code (NumericalMultiplyDivideExpression it)
-		'''«leftOperand.code» «operator.literal» «rightOperand.code»'''
-	
-	def dispatch CharSequence code (NumericalUnaryExpression it)
-		'''«operator.literal» «operand.code»'''
-	
+	def dispatch CharSequence code(NumericalAddSubtractExpression it) '''«leftOperand.code» «operator.literal» «rightOperand.
+		code»'''
+
+	def dispatch CharSequence code(NumericalMultiplyDivideExpression it) '''«leftOperand.code» «operator.literal» «rightOperand.
+		code»'''
+
+	def dispatch CharSequence code(NumericalUnaryExpression it) '''«operator.literal» «operand.code»'''
+
 	/* TODO: check if event is active */
-	def dispatch CharSequence code (EventValueReferenceExpression it)
-		'''«value.definition.event.valueAccess»'''
-	
-	def dispatch CharSequence code (ActiveStateReferenceExpression it)
-		'''«flow.activeFctID»(«value.shortName»)'''
-	
-	def dispatch CharSequence code (ParenthesizedExpression it)
-		'''(«expression.code»)'''
-}
+	def dispatch CharSequence code(EventValueReferenceExpression it) '''«value.definition.event.valueAccess»'''
+
+	def dispatch CharSequence code(ActiveStateReferenceExpression it) '''«flow.activeFctID»(«value.shortName»)'''
+
+	def dispatch CharSequence code(ParenthesizedExpression it) '''(«expression.code»)'''
+}

plugins/org.yakindu.sct.generator.java/src/org/yakindu/sct/generator/java/ExpressionCode.xtend

@@ -30,6 +30,7 @@ import org.yakindu.base.expressions.expressions.ShiftExpression
 import org.yakindu.base.expressions.expressions.ShiftOperator
 import org.yakindu.base.expressions.expressions.StringLiteral
 import org.yakindu.base.expressions.expressions.UnaryOperator
+import org.yakindu.base.types.ITypeSystem
 import org.yakindu.base.types.Operation
 import org.yakindu.sct.model.sexec.TimeEvent
 import org.yakindu.sct.model.sgraph.Declaration
@@ -40,171 +41,169 @@ import org.yakindu.sct.model.stext.stext.EventRaisingExpression
 import org.yakindu.sct.model.stext.stext.EventValueReferenceExpression
 import org.yakindu.sct.model.stext.stext.OperationDefinition
 import org.yakindu.sct.model.stext.types.ISTextTypeInferrer
-import org.yakindu.sct.model.stext.types.ISTextTypeSystem
 
 class ExpressionCode {
-	
-	@Inject extension Naming 
+
+	@Inject extension Naming
 	@Inject extension Navigation
-	@Inject extension ISTextTypeSystem
+	@Inject extension ITypeSystem
 	@Inject extension ISTextTypeInferrer
-	
+
 	private var List<TimeEvent> timeEvents;
-	
+
 	def private getTimeEvents(TimeEvent it) {
 		if (timeEvents == null) {
 			timeEvents = flow.timeEvents
 		}
 		return timeEvents
 	}
-	
+
 	def dispatch String code(EObject it) '''
 		//ERROR: Template in ExpressionCode.xtend for class '«getClass().name»' not define.
 		//Container: «eContainer?.getClass().name»
 	'''
-	
+
 	def dispatch String code(OperationDefinition it) {
 		return context + "operationCallback." + name.asEscapedIdentifier;
 	}
-	
+
 	def dispatch String code(PrimitiveValueExpression primValue) {
-		primValue.value.code;		
+		primValue.value.code;
 	}
-	
+
 	def dispatch String code(ParenthesizedExpression e) {
-		"(" + e.expression.code + ")";		
+		"(" + e.expression.code + ")";
 	}
-	
+
 	/* Assignment */
 	def dispatch String code(AssignmentExpression it) {
 		varRef.code + operator.code + expression.code
 	}
-			
+
 	/* Literals */
 	def dispatch String code(BoolLiteral expression) {
 		expression.value.toString()
 	}
-	
+
 	def dispatch String code(IntLiteral expression) {
-		expression.value.toString();		
+		expression.value.toString();
 	}
-	
-	def dispatch String code(HexLiteral expression) {		
+
+	def dispatch String code(HexLiteral expression) {
 		expression.value.toString();
 	}
-	
+
 	def dispatch String code(RealLiteral expression) {
 		expression.value.toString();
 	}
-	
+
 	def dispatch String code(StringLiteral expression) {
 		"\"" + expression.value.toString().escaped + "\""
-	}
-	
-	def String escaped(String it) {
-		return it.replace("\"", "\\\"");
 	}
-	
+
+	def String escaped(String it) {
+		return it.replace("\"", "\\\"");
+	}
+
 	/* Logical Expressions */
 	def dispatch String code(LogicalOrExpression expression) {
-	  	expression.leftOperand.code + " || " + expression.rightOperand.code		
+		expression.leftOperand.code + " || " + expression.rightOperand.code
 	}
-	  	
+
 	def dispatch String code(LogicalAndExpression expression) {
 		expression.leftOperand.code + " && " + expression.rightOperand.code
 	}
-	
+
 	def dispatch String code(LogicalNotExpression expression) {
 		" !" + expression.operand.code
 	}
-	
+
 	def dispatch String code(LogicalRelationExpression expression) {
 		if (expression.leftOperand.inferType.type.stringType) {
 			expression.logicalString
-		}
-		else
+		} else
 			expression.leftOperand.code + expression.operator.code + expression.rightOperand.code;
 	}
-	
+
 	def String logicalString(LogicalRelationExpression expression) {
 		if (expression.operator == RelationalOperator::EQUALS) {
-			expression.leftOperand.code + "== null?" + expression.rightOperand.code + " ==null :" + expression.leftOperand.code+".equals("+expression.rightOperand.code+")"
-		}
-		else if(expression.operator == RelationalOperator::NOT_EQUALS) {
-			expression.leftOperand.code + "== null?" + expression.rightOperand.code + " ==null : !" + expression.leftOperand.code+".equals("+expression.rightOperand.code+")"
+			expression.leftOperand.code + "== null?" + expression.rightOperand.code + " ==null :" +
+				expression.leftOperand.code + ".equals(" + expression.rightOperand.code + ")"
+		} else if (expression.operator == RelationalOperator::NOT_EQUALS) {
+			expression.leftOperand.code + "== null?" + expression.rightOperand.code + " ==null : !" +
+				expression.leftOperand.code + ".equals(" + expression.rightOperand.code + ")"
 		}
 	}
-	
+
 	def dispatch String code(BitwiseAndExpression expression) {
 		expression.leftOperand.code + " & " + expression.rightOperand.code
 	}
-	
+
 	def dispatch String code(BitwiseOrExpression expression) {
 		expression.leftOperand.code + " | " + expression.rightOperand.code
 	}
-	
+
 	def dispatch String code(BitwiseXorExpression expression) {
-		expression.leftOperand.code + " ^ " + expression.rightOperand.code		
+		expression.leftOperand.code + " ^ " + expression.rightOperand.code
 	}
-	
+
 	def dispatch String code(ShiftExpression expression) {
-		expression.leftOperand.code + expression.operator.code + expression.rightOperand.code		
+		expression.leftOperand.code + expression.operator.code + expression.rightOperand.code
 	}
-	
+
 	def dispatch String code(NumericalAddSubtractExpression expression) {
-		expression.leftOperand.code + expression.operator.code + expression.rightOperand.code	
+		expression.leftOperand.code + expression.operator.code + expression.rightOperand.code
 	}
-	  	
+
 	def dispatch String code(NumericalMultiplyDivideExpression expression) {
 		expression.leftOperand.code + expression.operator.code + expression.rightOperand.code
-		
+
 	}
-	
+
 	def dispatch String code(NumericalUnaryExpression expression) {
 		expression.operator.code + expression.operand.code
 	}
-	
+
 	def dispatch String code(ActiveStateReferenceExpression it) {
-		"isStateActive(State." + value.stateName.asEscapedIdentifier +")";
+		"isStateActive(State." + value.stateName.asEscapedIdentifier + ")";
 	}
-	
+
 	def dispatch String code(AdditiveOperator operator) {
 		operator.literal
 	}
-	
+
 	def dispatch String code(ShiftOperator operator) {
 		operator.literal
 	}
-	
+
 	def dispatch String code(UnaryOperator operator) {
 		operator.literal
 	}
-	
+
 	def dispatch String code(MultiplicativeOperator operator) {
 		operator.literal
-	} 
-	
+	}
+
 	def dispatch String code(RelationalOperator operator) {
 		operator.literal
 	}
-	
+
 	def dispatch String code(AssignmentOperator operator) {
 		operator.literal
 	}
-	
+
 	def dispatch String code(EventRaisingExpression it) {
 		if (value != null) {
-			event.definition.context+"raise"+event.definition.name.toFirstUpper+"("+value.code+")"			
-		}
-		else {
-			event.definition.context+"raise"+event.definition.name.toFirstUpper+"()"
+			event.definition.context + "raise" + event.definition.name.toFirstUpper + "(" + value.code + ")"
+		} else {
+			event.definition.context + "raise" + event.definition.name.toFirstUpper + "()"
 		}
 	}
-	
+
 	def dispatch String code(EventValueReferenceExpression it) {
 		value.definition.context + value.definition.event.valueIdentifier
 	}
-	
+
 	def dispatch String code(ElementReferenceExpression it) '''
 		«IF operationCall»
 			«reference.code»(«FOR arg : args SEPARATOR ", "»«arg.code»«ENDFOR»)
@@ -212,8 +211,7 @@ class ExpressionCode {
 			«definition.code»
 		«ENDIF»
 	'''
-	
-	
+
 	def dispatch String code(FeatureCall it) '''
 		«IF feature instanceof Operation»
 			«feature.code»(«FOR arg : args SEPARATOR ", "»«arg.code»«ENDFOR»)
@@ -221,37 +219,37 @@ class ExpressionCode {
 			«definition.context + definition.name.asEscapedIdentifier»
 		«ENDIF»
 	'''
-	
+
 	def dispatch String code(Declaration it) {
 		context + name.asEscapedIdentifier
 	}
-	
+
 	def dispatch String code(TimeEvent it) {
 		"timeEvents[" + getTimeEvents.indexOf(it) + "]"
 	}
-	
+
 	def dispatch String getContext(Variable it) {
 		if (scope != null) {
 			return scope.interfaceName.asEscapedIdentifier + "."
 		}
 		return ""
 	}
-	
+
 	def dispatch String getContext(Event it) {
 		if (scope != null) {
 			return scope.interfaceName.asEscapedIdentifier + "."
 		}
 		return ""
 	}
-	
+
 	def dispatch String getContext(OperationDefinition it) {
-		if (scope!=null) {
+		if (scope != null) {
 			return scope.interfaceName.asEscapedIdentifier + "."
 		}
 		return ""
 	}
-	
+
 	def dispatch String getContext(EObject it) {
 		return "//ERROR: No context for " + it
 	}
-}
+}

plugins/org.yakindu.sct.generator.java/src/org/yakindu/sct/generator/java/Statemachine.xtend

@@ -12,6 +12,7 @@ package org.yakindu.sct.generator.java
 import com.google.inject.Inject
 import java.util.List
 import org.eclipse.xtext.generator.IFileSystemAccess
+import org.yakindu.base.types.ITypeSystem
 import org.yakindu.sct.generator.core.types.ICodegenTypeSystemAccess
 import org.yakindu.sct.model.sexec.Check
 import org.yakindu.sct.model.sexec.ExecutionFlow
@@ -20,7 +21,6 @@ import org.yakindu.sct.model.sgen.GeneratorEntry
 import org.yakindu.sct.model.stext.stext.Direction
 import org.yakindu.sct.model.stext.stext.EventDefinition
 import org.yakindu.sct.model.stext.stext.InterfaceScope
-import org.yakindu.sct.model.stext.types.ISTextTypeSystem
 
 class Statemachine {
 	
@@ -28,7 +28,7 @@ class Statemachine {
 	@Inject extension GenmodelEntries
 	@Inject extension Navigation
 	@Inject extension ICodegenTypeSystemAccess
-	@Inject extension ISTextTypeSystem
+	@Inject extension ITypeSystem
 	@Inject extension FlowCode
 	
 	

plugins/org.yakindu.sct.generator.java/src/org/yakindu/sct/generator/java/StatemachineInterface.xtend

@@ -11,163 +11,163 @@ package org.yakindu.sct.generator.java
 
 import com.google.inject.Inject
 import org.eclipse.xtext.generator.IFileSystemAccess
+import org.yakindu.base.types.ITypeSystem
+import org.yakindu.base.types.Parameter
+import org.yakindu.sct.generator.core.types.ICodegenTypeSystemAccess
 import org.yakindu.sct.model.sexec.ExecutionFlow
 import org.yakindu.sct.model.sgen.GeneratorEntry
-import org.yakindu.base.types.Parameter
 import org.yakindu.sct.model.sgraph.Scope
-import org.yakindu.sct.model.stext.types.ISTextTypeSystem
+import org.yakindu.sct.model.stext.stext.Direction
 import org.yakindu.sct.model.stext.stext.InterfaceScope
 import org.yakindu.sct.model.stext.stext.InternalScope
-import org.yakindu.sct.model.stext.stext.Direction
 import org.yakindu.sct.model.stext.stext.OperationDefinition
-import org.yakindu.sct.generator.core.types.ICodegenTypeSystemAccess
 
 class StatemachineInterface {
-	
-	@Inject extension Naming 
+
+	@Inject extension Naming
 	@Inject extension GenmodelEntries
 	@Inject extension Navigation
-	@Inject extension ISTextTypeSystem
+	@Inject extension ITypeSystem
 	@Inject extension ICodegenTypeSystemAccess
 	@Inject Beautifier beautifier
-	
+
 	def generateStatemachineInterface(ExecutionFlow flow, GeneratorEntry entry, IFileSystemAccess fsa) {
 		var filename = flow.getImplementationPackagePath(entry) + '/' + flow.statemachineInterfaceName.java
 		var content = beautifier.format(filename, content(flow, entry))
 		fsa.generateFile(filename, content)
 	}
-	
+
 	def private content(ExecutionFlow flow, GeneratorEntry entry) {
 		'''
-		«entry.licenseText»
-		package «flow.getImplementationPackageName(entry)»;
-		«IF entry.createInterfaceObserver && flow.hasOutgoingEvents»
-		import java.util.List;
-		«ENDIF»
-		import «entry.basePackageName».«iStatemachine»;
-		«IF flow.timed»
-		import «entry.basePackageName».«iTimerCallback»;
-		«ENDIF»
-		
-		public interface «flow.statemachineInterfaceName» extends «flow.statemachineInterfaceExtensions» {
+			«entry.licenseText»
+			package «flow.getImplementationPackageName(entry)»;
+			«IF entry.createInterfaceObserver && flow.hasOutgoingEvents»
+				import java.util.List;
+			«ENDIF»
+			import «entry.basePackageName».«iStatemachine»;
+			«IF flow.timed»
+				import «entry.basePackageName».«iTimerCallback»;
+			«ENDIF»
 			
-			«FOR scope: flow.scopes»
-				«scope.createScope(entry)»
-			«ENDFOR»
-		}
+			public interface «flow.statemachineInterfaceName» extends «flow.statemachineInterfaceExtensions» {
+				
+				«FOR scope : flow.scopes»
+					«scope.createScope(entry)»
+				«ENDFOR»
+			}
 		'''
 	}
-	
+
 	def private createScope(Scope scope, GeneratorEntry entry) {
 		switch scope {
 			InterfaceScope: scope.createScope(entry)
 			InternalScope: scope.createScope
 		}
 	}
-	
+
 	def private createScope(InterfaceScope scope, GeneratorEntry entry) {
 		'''
-		«scope.createInterface(entry)»
-		«scope.createListenerInterface(entry)»
-		«scope.createOperationCallbackInterface»
-		
-		public «scope.interfaceName» get«scope.interfaceName»();
-		
-		'''
-	}
-	
-	def private createScope(InternalScope scope) {
-		'''
-		«IF scope.hasOperations()»
-			public interface «scope.internalOperationCallbackName» {
-				«FOR operation : scope.operations»
-					«operation.operationSignature»
-				«ENDFOR»
-			}
+			«scope.createInterface(entry)»
+			«scope.createListenerInterface(entry)»
+			«scope.createOperationCallbackInterface»
+			
+			public «scope.interfaceName» get«scope.interfaceName»();
 			
-			public void set«scope.internalOperationCallbackName»(«scope.internalOperationCallbackName» operationCallback);
-		«ENDIF»
 		'''
 	}
-	
-	def private createInterface(InterfaceScope scope, GeneratorEntry entry) {
+
+	def private createScope(InternalScope scope) {
 		'''
-		public interface «scope.interfaceName» {
-			«scope.eventAccessors»
-			«scope.variableAccessors»
-			«IF entry.createInterfaceObserver && scope.hasOutgoingEvents»
-				public List<«scope.getInterfaceListenerName()»> getListeners();
-			«ENDIF»
-	
 			«IF scope.hasOperations()»
-				public void set«scope.getInterfaceOperationCallbackName()»(«scope.getInterfaceOperationCallbackName()» operationCallback);
+				public interface «scope.internalOperationCallbackName» {
+					«FOR operation : scope.operations»
+						«operation.operationSignature»
+					«ENDFOR»
+				}
+				
+				public void set«scope.internalOperationCallbackName»(«scope.internalOperationCallbackName» operationCallback);
 			«ENDIF»
-		}
 		'''
 	}
-	
-	def private createListenerInterface(InterfaceScope scope, GeneratorEntry entry) {
+
+	def private createInterface(InterfaceScope scope, GeneratorEntry entry) {
 		'''
-		«IF entry.createInterfaceObserver && scope.hasOutgoingEvents»
+				public interface «scope.interfaceName» {
+				«scope.eventAccessors»
+				«scope.variableAccessors»
+				«IF entry.createInterfaceObserver && scope.hasOutgoingEvents»
+					public List<«scope.getInterfaceListenerName()»> getListeners();
+				«ENDIF»
 			
-			public interface «scope.getInterfaceListenerName()» {
-				«FOR event : scope.eventDefinitions»
-					«IF event.direction ==  Direction::OUT»
-						«IF event.type != null && !event.type.voidType»
-							public void on«event.name.toFirstUpper()»Raised(«event.type.targetLanguageName» value);
-						«ELSE»
-							public void on«event.name.toFirstUpper()»Raised();
-						«ENDIF»	
+					«IF scope.hasOperations()»
+						public void set«scope.getInterfaceOperationCallbackName()»(«scope.getInterfaceOperationCallbackName()» operationCallback);
 					«ENDIF»
-				«ENDFOR»
 				}
-		«ENDIF»
+			'''
+	}
+
+	def private createListenerInterface(InterfaceScope scope, GeneratorEntry entry) {
+		'''
+			«IF entry.createInterfaceObserver && scope.hasOutgoingEvents»
+				
+				public interface «scope.getInterfaceListenerName()» {
+					«FOR event : scope.eventDefinitions»
+						«IF event.direction == Direction::OUT»
+							«IF event.type != null && !event.type.voidType»
+								public void on«event.name.toFirstUpper()»Raised(«event.type.targetLanguageName» value);
+							«ELSE»
+								public void on«event.name.toFirstUpper()»Raised();
+							«ENDIF»	
+						«ENDIF»
+					«ENDFOR»
+					}
+			«ENDIF»
 		'''
 	}
-	
+
 	def createOperationCallbackInterface(InterfaceScope scope) {
 		'''
-		«IF scope.hasOperations»
-			
-			public interface «scope.getInterfaceOperationCallbackName()» {
-			«FOR operation : scope.operations»
-				«operation.operationSignature»
-			«ENDFOR»
-			}
-		«ENDIF»
+			«IF scope.hasOperations»
+				
+				public interface «scope.getInterfaceOperationCallbackName()» {
+				«FOR operation : scope.operations»
+					«operation.operationSignature»
+				«ENDFOR»
+				}
+			«ENDIF»
 		'''
 	}
-	
+
 	def eventAccessors(InterfaceScope scope) {
 		'''
-		«FOR event : scope.eventDefinitions»
-			«IF  event.direction ==  Direction::IN»
-				««« IMPORTANT: An event not specifying a type is regarded to have a void type
+			«FOR event : scope.eventDefinitions»
+				«IF event.direction == Direction::IN»
+					««« IMPORTANT: An event not specifying a type is regarded to have a void type
 				«IF event.type != null && !event.type.voidType»
-					public void raise«event.name.asName»(«event.type.targetLanguageName» value);
-				«ELSE»
-					public void raise«event.name.asName»();
-				«ENDIF»
-			«ELSEIF event.direction ==  Direction::OUT»
-				public boolean isRaised«event.name.asName»();
-				««« IMPORTANT: An event not specifying a type is regarded to have a void type
+						public void raise«event.name.asName»(«event.type.targetLanguageName» value);
+					«ELSE»
+						public void raise«event.name.asName»();
+					«ENDIF»
+				«ELSEIF event.direction == Direction::OUT»
+					public boolean isRaised«event.name.asName»();
+					««« IMPORTANT: An event not specifying a type is regarded to have a void type
 				«IF event.type != null && !event.type.voidType»
-					public «event.type.targetLanguageName» get«event.name.asName»Value();
-				«ENDIF»	
-			«ENDIF»
-		«ENDFOR»
+						public «event.type.targetLanguageName» get«event.name.asName»Value();
+					«ENDIF»	
+				«ENDIF»
+			«ENDFOR»
 		'''
 	}
-	
+
 	def variableAccessors(InterfaceScope scope) '''
 		«FOR variable : scope.variableDefinitions»
-					public «variable.type.targetLanguageName» «variable.getter»;
-					«IF  !variable.readonly»
-						public void «variable.setter»(«variable.type.targetLanguageName» value);	
-					«ENDIF»
+			public «variable.type.targetLanguageName» «variable.getter»;
+			«IF !variable.readonly»
+				public void «variable.setter»(«variable.type.targetLanguageName» value);	
+			«ENDIF»
 		«ENDFOR»
 	'''
-	
+
 	def getStatemachineInterfaceExtensions(ExecutionFlow flow) {
 
 		var String interfaces = "";
@@ -177,22 +177,22 @@ class StatemachineInterface {
 		}
 
 		interfaces = interfaces + iStatemachine
-		
+
 		return interfaces;
 	}
-	
+
 	def private operationSignature(OperationDefinition it) {
 		'''
-		public «type.targetLanguageName» «name.asEscapedIdentifier»(«FOR parameter : parameters SEPARATOR ', '»«parameter.type.targetLanguageName» «parameter.identifier»«ENDFOR»);
+			public «type.targetLanguageName» «name.asEscapedIdentifier»(«FOR parameter : parameters SEPARATOR ', '»«parameter.
+				type.targetLanguageName» «parameter.identifier»«ENDFOR»);
 		'''
 	}
-	
+
 	def private identifier(Parameter parameter) {
 		if (parameter.name.isJavaKeyword()) {
 			return parameter.name + "Arg"
-		}
-		else {
+		} else {
 			parameter.name
 		}
 	}
-}
+}

plugins/org.yakindu.sct.generator.java/src/org/yakindu/sct/generator/java/types/JavaTypeSystemAccess.xtend

@@ -7,32 +7,32 @@
  *
  * Contributors:
  *     committers of YAKINDU - initial API and implementation
- */
+ */
 package org.yakindu.sct.generator.java.types
 
 import com.google.inject.Inject
+import org.yakindu.base.types.ITypeSystem
 import org.yakindu.base.types.Type
 import org.yakindu.sct.generator.core.types.ICodegenTypeSystemAccess
-import org.yakindu.sct.model.stext.types.ISTextTypeSystem
-
+
 /**
  * @author andreas muelder
  * @author Alexander Nyßen - Adopted to type system changes
- */
-class JavaTypeSystemAccess implements ICodegenTypeSystemAccess {
-	
-	@Inject
-	private extension ISTextTypeSystem ts
-	
-	override String getTargetLanguageName(Type type) {
-		switch (type) {
-			case type == null || isVoidType(type): "void"
-			case isRealType(type) : "double"
-			case isIntegerType(type) : "long"
-			case isBooleanType(type) : "boolean"
-			case isStringType(type) : "String"
-			default : "//"+this
-		};
-	}
-	
-}
+ */
+class JavaTypeSystemAccess implements ICodegenTypeSystemAccess {
+
+	@Inject
+	private extension ITypeSystem ts
+
+	override String getTargetLanguageName(Type type) {
+		switch (type) {
+			case type == null || isVoidType(type): "void"
+			case isRealType(type): "double"
+			case isIntegerType(type): "long"
+			case isBooleanType(type): "boolean"
+			case isStringType(type): "String"
+			default: "//" + this
+		};
+	}
+
+}

plugins/org.yakindu.sct.generator.java/src/org/yakindu/sct/generator/java/types/OldJavaTypeSystemAccess.xtend

@@ -7,31 +7,31 @@
  *
  * Contributors:
  *     committers of YAKINDU - initial API and implementation
- */
+ */
 package org.yakindu.sct.generator.java.types
 
 import com.google.inject.Inject
+import org.yakindu.base.types.ITypeSystem
 import org.yakindu.base.types.Type
 import org.yakindu.sct.generator.core.types.ICodegenTypeSystemAccess
-import org.yakindu.sct.model.stext.types.ISTextTypeSystem
-
+
 /**
  * @author andreas muelder
  * @author Alexander Nyßen - Adopted to type system changes
- */
-class OldJavaTypeSystemAccess implements ICodegenTypeSystemAccess {
-	
-	@Inject
-	private extension ISTextTypeSystem ts
-	
-	override String getTargetLanguageName(Type type) {
-		switch (type) {
-			case type == null || isVoidType(type): "void"
-			case isRealType(type) : "double"
-			case isIntegerType(type) : "int"
-			case isBooleanType(type) : "boolean"
-			case isStringType(type) : "String"
-			default : "//"+this
-		};
-	}
-}
+ */
+class OldJavaTypeSystemAccess implements ICodegenTypeSystemAccess {
+
+	@Inject
+	private extension ITypeSystem ts
+
+	override String getTargetLanguageName(Type type) {
+		switch (type) {
+			case type == null || isVoidType(type): "void"
+			case isRealType(type): "double"
+			case isIntegerType(type): "int"
+			case isBooleanType(type): "boolean"
+			case isStringType(type): "String"
+			default: "//" + this
+		};
+	}
+}

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

@@ -5,12 +5,15 @@ import com.google.inject.name.Named
 import java.util.ArrayList
 import org.yakindu.base.expressions.expressions.AssignmentOperator
 import org.yakindu.base.expressions.expressions.BoolLiteral
+import org.yakindu.base.expressions.expressions.Expression
+import org.yakindu.base.expressions.expressions.ExpressionsFactory
 import org.yakindu.base.expressions.expressions.IntLiteral
 import org.yakindu.base.expressions.expressions.MultiplicativeOperator
 import org.yakindu.base.expressions.expressions.NumericalMultiplyDivideExpression
 import org.yakindu.base.expressions.expressions.PrimitiveValueExpression
 import org.yakindu.base.expressions.expressions.RealLiteral
 import org.yakindu.base.expressions.expressions.StringLiteral
+import org.yakindu.base.types.ITypeSystem
 import org.yakindu.sct.model.sexec.ExecutionFlow
 import org.yakindu.sct.model.sexec.ExecutionRegion
 import org.yakindu.sct.model.sexec.ExecutionState
@@ -24,34 +27,31 @@ import org.yakindu.sct.model.sgraph.Vertex
 import org.yakindu.sct.model.stext.stext.TimeEventSpec
 import org.yakindu.sct.model.stext.stext.TimeUnit
 import org.yakindu.sct.model.stext.stext.VariableDefinition
-import org.yakindu.sct.model.stext.types.ISTextTypeSystem
 
 import static extension org.eclipse.emf.ecore.util.EcoreUtil.*
-import org.yakindu.base.expressions.expressions.ExpressionsFactory
-import org.yakindu.base.expressions.expressions.Expression
 
 class SequenceBuilder {
-	
+
 	@Inject extension StatechartExtensions sc
 	@Inject extension SgraphExtensions sgraph
 	@Inject extension StextExtensions stext
 	@Inject extension SexecExtensions sexec
 	@Inject extension SexecElementMapping mapping
 	@Inject extension TraceExtensions trace
-	
-	@Inject extension ISTextTypeSystem ts
-	
-	
-	@Inject @Named("ADD_TRACES") 
-	boolean _addTraceSteps 
-	
-	static String DEFAULT_SEQUENCE_NAME = "default" 
-	
+
+	@Inject extension ITypeSystem ts
+
+	@Inject @Named("ADD_TRACES")
+	boolean _addTraceSteps
+
+	static String DEFAULT_SEQUENCE_NAME = "default"
+
 	def void defineDeepEnterSequences(ExecutionFlow flow, Statechart sc) {
-		for ( r : sc.regions) {
+		for (r : sc.regions) {
 			r.defineDeepEnterSequence
 		}
 	}
+
 	def void defineDeepEnterSequence(State s) {
 		for (r : s.regions) {
 			r.defineDeepEnterSequence
@@ -69,31 +69,33 @@ class SequenceBuilder {
 		val seq = sexec.factory.createSequence
 		seq.name = "deepEnterSequence"
 		seq.comment = "deep enterSequence with history in child " + r.name
-		
+
 		seq.steps += r.defineDeepHistorySwitch
 		execRegion.deepEnterSequence = seq
 	}
 
 	def StateSwitch defineDeepHistorySwitch(Region r) {
 		val execRegion = r.create
-		
+
 		val StateSwitch sSwitch = sexec.factory.createStateSwitch
 		sSwitch.stateConfigurationIdx = execRegion.stateVector.offset
-		sSwitch.comment = "Handle deep history entry of " +r.name
+		sSwitch.comment = "Handle deep history entry of " + r.name
 		sSwitch.historyRegion = execRegion
-		
+
 		for (child : r.vertices.filter(typeof(State))) {
+
 			//TODO consider direct children
-			for (childLeaf : child.collectLeafStates(newArrayList).filter(c|c.create.stateVector.offset == sSwitch.stateConfigurationIdx)) {
+			for (childLeaf : child.collectLeafStates(newArrayList).filter(
+				c|c.create.stateVector.offset == sSwitch.stateConfigurationIdx)) {
 				val execChild = child.create
 				val seq = sexec.factory.createSequence
 				seq.name = DEFAULT_SEQUENCE_NAME
-				seq.comment = "enterSequence with history in child " + child.name+" for leaf "+childLeaf.name
-				if ( execChild.leaf ) {
+				seq.comment = "enterSequence with history in child " + child.name + " for leaf " + childLeaf.name
+				if (execChild.leaf) {
 					seq.steps += execChild.enterSequences.defaultSequence.newCall
 				} else {
-					if (execChild.entryAction != null ) seq.steps += execChild.entryAction.newCall
-					if ( trace.addTraceSteps ) seq.steps += execChild.newTraceStateEntered
+					if(execChild.entryAction != null) seq.steps += execChild.entryAction.newCall
+					if(trace.addTraceSteps) seq.steps += execChild.newTraceStateEntered
 					for (childRegion : child.regions) {
 						seq.steps += childRegion.create.deepEnterSequence.newCall
 					}
@@ -101,185 +103,190 @@ class SequenceBuilder {
 				sSwitch.cases += childLeaf.create.newCase(seq)
 			}
 		}
-		
+
 		return sSwitch
 	}
-	
+
 	def void defineShallowEnterSequences(ExecutionFlow flow, Statechart sc) {
-		val contents =  sc.eAllContents
-		for ( r : contents.filter(typeof(Region)).toIterable) {
+		val contents = sc.eAllContents
+		for (r : contents.filter(typeof(Region)).toIterable) {
 			if (r.requireShallowHistory) {
 				val execRegion = r.create
 				val seq = sexec.factory.createSequence
 				seq.name = "shallowEnterSequence"
 				seq.comment = "shallow enterSequence with history in child " + r.name
-				
+
 				seq.steps += r.defineShallowHistorySwitch
 				execRegion.shallowEnterSequence = seq
 			}
 		}
 	}
-	
+
 	def StateSwitch defineShallowHistorySwitch(Region r) {
 		val execRegion = r.create
-		
+
 		val StateSwitch sSwitch = sexec.factory.createStateSwitch
 		sSwitch.stateConfigurationIdx = execRegion.stateVector.offset
-		sSwitch.comment = "Handle shallow history entry of " +r.name
+		sSwitch.comment = "Handle shallow history entry of " + r.name
 		sSwitch.historyRegion = r.create
-		
+
 		for (child : r.vertices.filter(typeof(State))) {
 			val execChild = child.create
+
 			//TODO consider direct children
-			for (childLeaf : child.collectLeafStates(newArrayList).filter(c|c.create.stateVector.offset == sSwitch.stateConfigurationIdx)) {
+			for (childLeaf : child.collectLeafStates(newArrayList).filter(
+				c|c.create.stateVector.offset == sSwitch.stateConfigurationIdx)) {
 				sSwitch.cases += childLeaf.create.newCase(execChild.enterSequences.defaultSequence.newCall)
 			}
 		}
-		
+
 		return sSwitch
 	}
-	
+
 	/**
 	 * Defines the enter sequences of all states
 	 */
 	def void defineEnterSequences(ExecutionFlow flow, Statechart sc) {
-		
+
 		// iterate over all regions
-		for ( r : sc.regions) defineScopeEnterSequences(r)
+		for (r : sc.regions)
+			defineScopeEnterSequences(r)
 	}
-	
 
 	def dispatch void defineScopeEnterSequences(Region r) {
 		val execRegion = r.create
-		
+
 		// process all vertices of a region
-		for ( s : r.vertices) defineScopeEnterSequences(s)
-		
+		for (s : r.vertices)
+			defineScopeEnterSequences(s)
+
 		// create an enter sequence for each contained entry
-		for ( e : r.collectEntries ) {
+		for (e : r.collectEntries) {
 			val seq = sexec.factory.createSequence
-			seq.name =	if (e.name == null || e.name.trim == "") 
-							DEFAULT_SEQUENCE_NAME
-						else 
-							e.name
+			seq.name = if (e.name == null || e.name.trim == "")
+				DEFAULT_SEQUENCE_NAME
+			else
+				e.name
 			seq.comment = "'" + seq.name + "' enter sequence for region " + r.name
-	
+
 			val entryNode = e.create
 			if (entryNode != null && entryNode.reactSequence != null) {
 				seq.steps.add(entryNode.reactSequence.newCall);
 			}
-			
+
 			execRegion.enterSequences += seq
 		}
 	}
 
-	def dispatch void defineScopeEnterSequences(Vertex v) {}	
-	
-	
+	def dispatch void defineScopeEnterSequences(Vertex v) {
+	}
+
 	def dispatch void defineScopeEnterSequences(FinalState state) {
 		val execState = state.create
 		val seq = sexec.factory.createSequence
 		seq.name = DEFAULT_SEQUENCE_NAME
 		seq.comment = "Default enter sequence for state " + state.name
-		if (execState.entryAction != null) seq.steps.add(execState.entryAction.newCall)
-		
-		if ( _addTraceSteps ) seq.steps += execState.newTraceStateEntered
-		
+		if(execState.entryAction != null) seq.steps.add(execState.entryAction.newCall)
+
+		if(_addTraceSteps) seq.steps += execState.newTraceStateEntered
+
 		seq.steps += execState.newEnterStateStep
 		execState.enterSequences += seq
-	}	
-	
-	
-	
+	}
+
 	def dispatch void defineScopeEnterSequences(State state) {
-		
+
 		val execState = state.create
-		
+
 		// first creates enter sequences for all contained regions
-		state.regions.forEach( r | r.defineScopeEnterSequences )
-		
+		state.regions.forEach(r|r.defineScopeEnterSequences)
+
 		// get all entry point names used by incoming transitions
-		val entryPointNames = state.incomingTransitions.map( t | t.entryPointName ).toSet.toList
-		
+		val entryPointNames = state.incomingTransitions.map(t|t.entryPointName).toSet.toList
+
 		// also include implicit entries by histories
 		if (state.parentRegion.requireHistory) {
-			if (!entryPointNames.contains('default')) entryPointNames.add('default')
-		}   
-		
+			if(!entryPointNames.contains('default')) entryPointNames.add('default')
+		}
+
 		// sort entry points by name ...
 		entryPointNames.sortInplace
-		
+
 		// create an entry sequence for each entry point
-		for ( epName : entryPointNames ) {
+		for (epName : entryPointNames) {
 			val seq = sexec.factory.createSequence
 			seq.name = epName
 			seq.comment = "'" + epName + "' enter sequence for state " + state.name
-			if (execState.entryAction != null) seq.steps.add(execState.entryAction.newCall)
-			
-			if ( _addTraceSteps ) seq.steps += execState.newTraceStateEntered
-			
-			if ( execState.leaf ) {
-				
+			if(execState.entryAction != null) seq.steps.add(execState.entryAction.newCall)
+
+			if(_addTraceSteps) seq.steps += execState.newTraceStateEntered
+
+			if (execState.leaf) {
+
 				seq.steps += execState.newEnterStateStep
-						
+
 			} else {
-		
-				for ( r : state.regions ) {	
+
+				for (r : state.regions) {
 					val execRegion = r.create
 					var regionEnterSeq = execRegion.enterSequences.byName(epName)
-					
-					if (regionEnterSeq == null) { regionEnterSeq = execRegion.enterSequences.defaultSequence }
-					
+
+					if (regionEnterSeq == null) {
+						regionEnterSeq = execRegion.enterSequences.defaultSequence
+					}
+
 					if (regionEnterSeq != null) {
 						seq.steps += regionEnterSeq.newCall
 					}
-				} 
+				}
 			}
-	
+
 			execState.enterSequences += seq
 		}
-		
+
 	}
 
 	/**
 	 * Defines the exit sequences of all states
 	 */
 	def void defineStateExitSequences(ExecutionFlow flow, Statechart sc) {
-		
+
 		// iterate over all regions
-		for ( r : sc.regions) defineStateExitSequence(r)
+		for (r : sc.regions)
+			defineStateExitSequence(r)
 	}
-		
 
 	def dispatch void defineStateExitSequence(Region r) {
 		val execRegion = r.create
 		val seq = sexec.factory.createSequence
 		seq.name = "exitSequence"
-		seq.comment = "Default exit sequence for region "+r.name
-		
+		seq.comment = "Default exit sequence for region " + r.name
+
 		// process all states of a region
-		for ( s : r.vertices ) defineStateExitSequence(s)
-		
+		for (s : r.vertices)
+			defineStateExitSequence(s)
+
 		if (execRegion.historyVector != null) {
 			seq.steps += execRegion.newSaveHistory()
 		}
-		
+
 		// collect leaf states
 		val Iterable<ExecutionState> leafStates = r.collectLeafStates(new ArrayList<RegularState>()).map(rs|rs.create)
 		val sVector = execRegion.stateVector
 
-		for ( i: sVector.offset .. sVector.offset + sVector.size - 1 ) {
-					
+		for (i : sVector.offset .. sVector.offset + sVector.size - 1) {
+
 			// create a state switch for each state configuration vector position
 			val StateSwitch sSwitch = execRegion.defineExitSwitch(leafStates, i)
 			seq.steps.add(sSwitch);
 		}
-		
+
 		execRegion.exitSequence = seq
-	
+
+	}
+
+	def dispatch void defineStateExitSequence(Vertex v) {
 	}
-	
-	def dispatch void defineStateExitSequence(Vertex v) {}
 
 	def dispatch void defineStateExitSequence(FinalState s) {
 		val execState = s.create
@@ -287,27 +294,28 @@ class SequenceBuilder {
 		seq.name = "exitSequence"
 		seq.comment = "Default exit sequence for final state."
 		seq.steps += execState.newExitStateStep
-				
-		if ( _addTraceSteps ) seq.steps += execState.newTraceStateExited
-		
+
+		if(_addTraceSteps) seq.steps += execState.newTraceStateExited
+
 		execState.exitSequence = seq
 	}
-	
+
 	// TODO : refactor
 	def dispatch void defineStateExitSequence(State state) {
-		
+
 		val execState = state.create
 		val seq = sexec.factory.createSequence
 		seq.name = "exitSequence"
 		seq.comment = "Default exit sequence for state " + state.name
 
-		if ( execState.leaf ) {
-			
+		if (execState.leaf) {
+
 			seq.steps += execState.newExitStateStep
-					
+
 		} else {
 
 			for (r : state.regions) {
+
 				// first enforce calculation of all child exit sequences
 				r.defineStateExitSequence
 
@@ -318,10 +326,10 @@ class SequenceBuilder {
 			}
 		}
 
-		if (execState.exitAction != null) seq.steps.add(execState.exitAction.newCall)
-		
-		if ( _addTraceSteps ) seq.steps += execState.newTraceStateExited
-		
+		if(execState.exitAction != null) seq.steps.add(execState.exitAction.newCall)
+
+		if(_addTraceSteps) seq.steps += execState.newTraceStateExited
+
 		execState.exitSequence = seq
 	}
 
@@ -330,12 +338,14 @@ class SequenceBuilder {
 		// create a state switch
 		var StateSwitch sSwitch = sexec.factory.createStateSwitch
 		sSwitch.stateConfigurationIdx = pos
-		sSwitch.comment = "Handle exit of all possible states (of "+region.name+") at position " + sSwitch.stateConfigurationIdx + "..."
-						
-		val Iterable<ExecutionState> posStates = leafStates.filter( rs | rs.stateVector.size == 1 && rs.stateVector.offset == pos)					
-		
+		sSwitch.comment = "Handle exit of all possible states (of " + region.name + ") at position " +
+			sSwitch.stateConfigurationIdx + "..."
+
+		val Iterable<ExecutionState> posStates = leafStates.filter(
+			rs|rs.stateVector.size == 1 && rs.stateVector.offset == pos)
+
 		// create a case for each leaf state
-		for ( s : posStates ) {
+		for (s : posStates) {
 
 			val caseSeq = sexec.factory.createSequence
 
@@ -343,57 +353,58 @@ class SequenceBuilder {
 			val exitScopes = s.parentScopes
 			exitScopes.removeAll(region.parentScopes)
 			exitScopes.remove(s)
-			exitScopes.fold(caseSeq , [ cs, exitScope | {
-				if (exitScope instanceof ExecutionRegion && (exitScope as ExecutionRegion).historyVector != null) {
-					val execRegion = exitScope as ExecutionRegion
-					cs.steps += execRegion.newSaveHistory
-				}
-				cs
-			}]) 
+			exitScopes.fold(caseSeq,
+				[cs, exitScope|
+					{
+						if (exitScope instanceof ExecutionRegion && (exitScope as ExecutionRegion).historyVector != null) {
+							val execRegion = exitScope as ExecutionRegion
+							cs.steps += execRegion.newSaveHistory
+						}
+						cs
+					}])
 
 			//Leave leaf
 			if (s.exitSequence != null) {
 				caseSeq.steps += s.exitSequence.newCall
 			}
-			
+
 			// include exitAction calls up to the direct child level.
-			exitScopes.fold(caseSeq , [ cs, exitScope | {
-				if (exitScope instanceof ExecutionState && s.stateVector.last == exitScope.stateVector.last) {
-					val execState = exitScope as ExecutionState
-					if (execState.exitAction != null) cs.steps.add(execState.exitAction.newCall)
-					if ( _addTraceSteps ) cs.steps.add(execState.newTraceStateExited)
-				}
-				cs
-			}]) 
-			
-			if (!caseSeq.steps.empty) sSwitch.cases.add(s.newCase(caseSeq))
-			
+			exitScopes.fold(caseSeq,
+				[cs, exitScope|
+					{
+						if (exitScope instanceof ExecutionState && s.stateVector.last == exitScope.stateVector.last) {
+							val execState = exitScope as ExecutionState
+							if(execState.exitAction != null) cs.steps.add(execState.exitAction.newCall)
+							if(_addTraceSteps) cs.steps.add(execState.newTraceStateExited)
+						}
+						cs
+					}])
+
+			if(!caseSeq.steps.empty) sSwitch.cases.add(s.newCase(caseSeq))
+
 		}
-		
+
 		return sSwitch
 	}
-	
-	
-	
+
 	def defineStatechartExitSequence(ExecutionFlow flow, Statechart sc) {
 		val exitSequence = sexec.factory.createSequence
 		exitSequence.name = "exit"
 		exitSequence.comment = "Default exit sequence for statechart " + sc.name
-		
-		for ( r : sc.regions) {
+
+		for (r : sc.regions) {
 			val execRegion = r.create
 			if (execRegion.exitSequence != null) {
 				exitSequence.steps.add(execRegion.exitSequence.newCall)
 			}
-		} 
-		
-		if (flow.exitAction != null) exitSequence.steps.add(flow.exitAction.newCall)
-		
+		}
+
+		if(flow.exitAction != null) exitSequence.steps.add(flow.exitAction.newCall)
+
 		flow.exitSequence = exitSequence
 		return exitSequence
 	}
-	
-	 
+
 	/** 
 	 * Defines the execution sequence that will be performed when the statechart will be entered.
 	 */
@@ -402,49 +413,47 @@ class SequenceBuilder {
 		val enterSequence = sexec.factory.createSequence
 		enterSequence.name = DEFAULT_SEQUENCE_NAME
 		enterSequence.comment = "Default enter sequence for statechart " + sc.name
-	    	
-		for (tes : sc.timeEventSpecs ) {
-			val timeEvent = tes.createDerivedEvent    
+
+		for (tes : sc.timeEventSpecs) {
+			val timeEvent = tes.createDerivedEvent
 			val scheduleStep = timeEvent.newScheduleTimeEvent(tes.buildValueExpression)
 			enterSequence.steps.add(scheduleStep)
-		}	
-		
-		if (flow.entryAction != null) enterSequence.steps.add(flow.entryAction.newCall)
-		
-		for ( r : sc.regions) {
+		}
+
+		if(flow.entryAction != null) enterSequence.steps.add(flow.entryAction.newCall)
+
+		for (r : sc.regions) {
 			val execRegion = r.create
 			if (execRegion.enterSequences.defaultSequence != null) {
 				enterSequence.steps.add(execRegion.enterSequences.defaultSequence.newCall)
 			}
-		} 
-		
+		}
+
 		flow.enterSequences += enterSequence
 		return enterSequence
 	}
-	
-	
+
 	/**
 	 * Defines the sequence of initialization steps. 
 	 * 
 	 * These steps basically include the initialization of variables.
 	 */
 	def defineStatechartInitSequence(ExecutionFlow flow, Statechart sc) {
-		
+
 		val initSequence = sexec.factory.createSequence
 		initSequence.name = "init"
 		initSequence.comment = "Default init sequence for statechart " + sc.name
-	    	
+
 		for (VariableDefinition vd : sc.scopes.map(s|s.variables).flatten.filter(typeof(VariableDefinition))) {
 			if (vd.effectiveInitialValue != null) {
-		 		initSequence.steps.add(vd.createInitialization)
+				initSequence.steps.add(vd.createInitialization)
 			}
 		}
-		
+
 		flow.initSequence = initSequence
 		return initSequence
 	}
-	
-	
+
 	def effectiveInitialValue(VariableDefinition vd) {
 		if (vd.initialValue != null) {
 			return vd.initialValue
@@ -454,16 +463,16 @@ class SequenceBuilder {
 				case isIntegerType(vd.type): 0.buildValue
 				case isRealType(vd.type): buildValue(0.0 as float)
 				case isStringType(vd.type): "".buildValue
-				default : null
+				default: null
 			}
 		}
 	}
-	
-	
+
 	var factory = ExpressionsFactory.eINSTANCE
+
 	def createInitialization(VariableDefinition vd) {
 		val execution = sexec.factory.createExecution
-		val assignment = factory.createAssignmentExpression 
+		val assignment = factory.createAssignmentExpression
 		val reference = factory.createElementReferenceExpression
 		reference.reference = vd
 		assignment.varRef = reference
@@ -472,88 +481,86 @@ class SequenceBuilder {
 		execution.statement = assignment
 		return execution
 	}
-		
-	
-	
+
 	def Expression buildValueExpression(TimeEventSpec tes) {
-//		val PrimitiveValueExpression pve = stext.factory.createPrimitiveValueExpression 
-//		val IntLiteral intLit = stext.factory.createIntLiteral
-//		intLit.value = tes.value
-//		pve.value = intLit
+
+		//		val PrimitiveValueExpression pve = stext.factory.createPrimitiveValueExpression 
+		//		val IntLiteral intLit = stext.factory.createIntLiteral
+		//		intLit.value = tes.value
+		//		pve.value = intLit
 		val pve = tes.value.copy
-	
+
 		switch (tes.unit) {
-			case TimeUnit::MILLISECOND : pve
-			case TimeUnit::MICROSECOND : pve.divide(1000)
-			case TimeUnit::NANOSECOND  : pve.divide(1000000)
-			case TimeUnit::SECOND      : pve.multiply(1000)
-			default : pve
-		} 
+			case TimeUnit::MILLISECOND: pve
+			case TimeUnit::MICROSECOND: pve.divide(1000)
+			case TimeUnit::NANOSECOND: pve.divide(1000000)
+			case TimeUnit::SECOND: pve.multiply(1000)
+			default: pve
+		}
 	}
-	
+
 	def Expression divide(Expression stmnt, long divisor) {
 		val NumericalMultiplyDivideExpression div = factory.createNumericalMultiplyDivideExpression
-		val PrimitiveValueExpression pve = factory.createPrimitiveValueExpression 
+		val PrimitiveValueExpression pve = factory.createPrimitiveValueExpression
 		val IntLiteral intLit = factory.createIntLiteral
 		intLit.value = divisor.intValue
 		pve.value = intLit
-		
+
 		div.operator = MultiplicativeOperator::DIV
 		div.leftOperand = stmnt
 		div.rightOperand = pve
-		
+
 		div
 	}
-	 
+
 	def Expression multiply(Expression stmnt, long factor) {
 		val NumericalMultiplyDivideExpression div = factory.createNumericalMultiplyDivideExpression
-		val PrimitiveValueExpression pve = factory.createPrimitiveValueExpression 
+		val PrimitiveValueExpression pve = factory.createPrimitiveValueExpression
 		val IntLiteral intLit = factory.createIntLiteral
 		intLit.value = factor.intValue
 		pve.value = intLit
-		
+
 		div.operator = MultiplicativeOperator::MUL
 		div.leftOperand = stmnt
 		div.rightOperand = pve
-		
+
 		div
 	}
 
-
 	def Expression buildValue(boolean b) {
 		val PrimitiveValueExpression pve = factory.createPrimitiveValueExpression
 		val BoolLiteral lit = factory.createBoolLiteral
 		lit.value = b
 		pve.value = lit
-		
+
 		pve
 	}
-	
+
 	def Expression buildValue(int i) {
 		val PrimitiveValueExpression pve = factory.createPrimitiveValueExpression
 		val IntLiteral lit = factory.createIntLiteral
 		lit.value = i
 		pve.value = lit
-		
+
 		pve
 	}
-	
+
 	def Expression buildValue(float r) {
 		val PrimitiveValueExpression pve = factory.createPrimitiveValueExpression
 		val RealLiteral lit = factory.createRealLiteral
 		lit.value = r
 		pve.value = lit
-		
+
 		pve
 	}
-	
+
 	def Expression buildValue(String i) {
 		val PrimitiveValueExpression pve = factory.createPrimitiveValueExpression
 		val StringLiteral lit = factory.createStringLiteral
 		lit.value = i
 		pve.value = lit
-		
+
 		pve
 	}
-	
-}
+
+}

plugins/org.yakindu.sct.model.sexec/src/org/yakindu/sct/model/sexec/transformation/SequencerModule.java

@@ -7,9 +7,7 @@ import org.yakindu.sct.model.sexec.naming.DefaultNamingService;
 import org.yakindu.sct.model.sexec.naming.INamingService;
 import org.yakindu.sct.model.sgraph.naming.SGraphNameProvider;
 import org.yakindu.sct.model.stext.types.ISTextTypeInferrer;
-import org.yakindu.sct.model.stext.types.ISTextTypeSystem;
 import org.yakindu.sct.model.stext.types.STextDefaultTypeInferrer;
-import org.yakindu.sct.model.stext.types.STextDefaultTypeSystem;
 
 import com.google.inject.Binder;
 import com.google.inject.name.Names;
@@ -40,11 +38,7 @@ public class SequencerModule extends AbstractGenericModule {
 	}
 
 	public Class<? extends ITypeSystem> bindITypeSystem() {
-		return STextDefaultTypeSystem.class;
-	}
-
-	public Class<? extends ISTextTypeSystem> bindISTextTypeSystem() {
-		return STextDefaultTypeSystem.class;
+		return ITypeSystem.class;
 	}
 
 	public Class<? extends ISTextTypeInferrer> bindISTextTypeInferrer() {

test-plugins/org.yakindu.sct.simulation.core.sexec.test/src/org/yakindu/sct/model/sexec/interpreter/test/STextInterpreterTest.java

@@ -19,11 +19,11 @@ import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.yakindu.base.expressions.expressions.Expression;
-import org.yakindu.base.types.ITypeSystem.InferredType;
+import org.yakindu.base.types.ITypeSystem;
+import org.yakindu.base.types.InferredType;
 import org.yakindu.sct.model.sgraph.Scope;
 import org.yakindu.sct.model.stext.test.util.AbstractSTextTest;
 import org.yakindu.sct.model.stext.test.util.STextInjectorProvider;
-import org.yakindu.sct.model.stext.types.ISTextTypeSystem;
 import org.yakindu.sct.simulation.core.sexec.interpreter.IStatementInterpreter;
 import org.yakindu.sct.simulation.core.sruntime.ExecutionContext;
 import org.yakindu.sct.simulation.core.sruntime.ExecutionEvent;
@@ -47,7 +47,7 @@ public class STextInterpreterTest extends AbstractSTextTest {
 	@Inject
 	private IStatementInterpreter interpreter;
 	@Inject
-	private ISTextTypeSystem typeSystem;
+	private ITypeSystem typeSystem;
 
 	@Test
 	public void testIntVariableAssignment() {
@@ -481,28 +481,28 @@ public class STextInterpreterTest extends AbstractSTextTest {
 		intVar.setType(new InferredType(typeSystem.getIntegerType()));
 		intVar.setValue(0);
 		context.getSlots().add(intVar);
-		
+
 		ExecutionVariable boolVar = new ExecutionVariableImpl();
 		boolVar.setName("boolVar");
 		boolVar.setFqName("boolVar");
 		boolVar.setType(new InferredType(typeSystem.getBooleanType()));
 		boolVar.setValue(false);
 		context.getSlots().add(boolVar);
-		
+
 		ExecutionVariable realVar = new ExecutionVariableImpl();
 		realVar.setName("realVar");
 		realVar.setFqName("realVar");
 		realVar.setType(new InferredType(typeSystem.getRealType()));
 		realVar.setValue(0.0f);
 		context.getSlots().add(realVar);
-		
+
 		ExecutionVariable stringVar = new ExecutionVariableImpl();
 		stringVar.setName("stringVar");
 		stringVar.setFqName("stringVar");
 		stringVar.setType(new InferredType(typeSystem.getStringType()));
 		stringVar.setValue("");
 		context.getSlots().add(stringVar);
-		
+
 		ExecutionEvent event = new ExecutionEventImpl();
 		event.setName("abc");
 		event.setFqName("abc");
@@ -528,22 +528,19 @@ public class STextInterpreterTest extends AbstractSTextTest {
 
 	protected Object executeWithDefaultScope(String expression) {
 		Scope defaultScope = internalScope();
-		Expression statement = (Expression) parseExpression(expression,
-				defaultScope, Expression.class.getSimpleName());
+		Expression statement = (Expression) parseExpression(expression, defaultScope, Expression.class.getSimpleName());
 		return interpreter.evaluateStatement(statement, context);
 	}
 
 	protected Object execute(String scope, String expression) {
 		Scope defaultScope = createInternalScope(scope);
-		Expression statement = (Expression) parseExpression(expression,
-				defaultScope, Expression.class.getSimpleName());
+		Expression statement = (Expression) parseExpression(expression, defaultScope, Expression.class.getSimpleName());
 		return interpreter.evaluateStatement(statement, context);
 	}
 
 	protected Object executeExpression(String scope, String expression) {
 		Scope defaultScope = createInternalScope(scope);
-		Expression statement = (Expression) parseExpression(expression,
-				defaultScope, Expression.class.getSimpleName());
+		Expression statement = (Expression) parseExpression(expression, defaultScope, Expression.class.getSimpleName());
 		return interpreter.evaluateStatement(statement, context);
 	}