use generator.base expressions (#1100)

* use generator.base expressions

* use generator.base expressions

plugins/org.yakindu.sct.generator.core/src/org/yakindu/sct/generator/core/templates/Expressions.xtend

@@ -22,7 +22,7 @@ import org.yakindu.base.expressions.expressions.UnaryExpression
 class Expressions {
 	
 	def dispatch CharSequence code(BinaryExpression expression) {
-		expression.leftOperand.code + " " + expression.operator.literal + " " + expression.rightOperand.code
+		expression.leftOperand.code.toString.trim + " " + expression.operator.literal.toString.trim + " " + expression.rightOperand.code
 	}
 
 	def dispatch CharSequence code(UnaryExpression expression) {

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

@@ -3,12 +3,7 @@ package org.yakindu.sct.generator.csharp
 import com.google.inject.Inject
 import java.util.List
 import org.eclipse.emf.ecore.EObject
-import org.yakindu.base.expressions.expressions.AdditiveOperator
 import org.yakindu.base.expressions.expressions.AssignmentExpression
-import org.yakindu.base.expressions.expressions.AssignmentOperator
-import org.yakindu.base.expressions.expressions.BitwiseAndExpression
-import org.yakindu.base.expressions.expressions.BitwiseOrExpression
-import org.yakindu.base.expressions.expressions.BitwiseXorExpression
 import org.yakindu.base.expressions.expressions.BoolLiteral
 import org.yakindu.base.expressions.expressions.ConditionalExpression
 import org.yakindu.base.expressions.expressions.DoubleLiteral
@@ -17,23 +12,13 @@ import org.yakindu.base.expressions.expressions.FeatureCall
 import org.yakindu.base.expressions.expressions.FloatLiteral
 import org.yakindu.base.expressions.expressions.HexLiteral
 import org.yakindu.base.expressions.expressions.IntLiteral
-import org.yakindu.base.expressions.expressions.LogicalAndExpression
-import org.yakindu.base.expressions.expressions.LogicalNotExpression
-import org.yakindu.base.expressions.expressions.LogicalOrExpression
 import org.yakindu.base.expressions.expressions.LogicalRelationExpression
-import org.yakindu.base.expressions.expressions.MultiplicativeOperator
 import org.yakindu.base.expressions.expressions.NullLiteral
-import org.yakindu.base.expressions.expressions.NumericalAddSubtractExpression
-import org.yakindu.base.expressions.expressions.NumericalMultiplyDivideExpression
-import org.yakindu.base.expressions.expressions.NumericalUnaryExpression
 import org.yakindu.base.expressions.expressions.ParenthesizedExpression
 import org.yakindu.base.expressions.expressions.PrimitiveValueExpression
 import org.yakindu.base.expressions.expressions.RelationalOperator
-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.TypeCastExpression
-import org.yakindu.base.expressions.expressions.UnaryOperator
 import org.yakindu.base.types.Declaration
 import org.yakindu.base.types.Event
 import org.yakindu.base.types.Operation
@@ -41,6 +26,7 @@ import org.yakindu.base.types.Property
 import org.yakindu.base.types.inferrer.ITypeSystemInferrer
 import org.yakindu.base.types.typesystem.GenericTypeSystem
 import org.yakindu.base.types.typesystem.ITypeSystem
+import org.yakindu.sct.generator.core.templates.Expressions
 import org.yakindu.sct.generator.core.types.ICodegenTypeSystemAccess
 import org.yakindu.sct.model.sexec.TimeEvent
 import org.yakindu.sct.model.stext.stext.ActiveStateReferenceExpression
@@ -48,7 +34,7 @@ import org.yakindu.sct.model.stext.stext.EventRaisingExpression
 import org.yakindu.sct.model.stext.stext.EventValueReferenceExpression
 import org.yakindu.sct.model.stext.stext.OperationDefinition
 
-class ExpressionCode {
+class ExpressionCode extends Expressions {
 
 	@Inject extension Naming
 	@Inject extension Navigation
@@ -65,86 +51,68 @@ class ExpressionCode {
 		return timeEvents
 	}
 
-	def dispatch String code(EObject it) '''
-		//ERROR: Template in ExpressionCode.xtend for class '«getClass().name»' not defined.
-		//Container: «eContainer?.getClass().name»
-	'''
-
-	def dispatch String code(OperationDefinition it) {
+	def dispatch CharSequence code(OperationDefinition it) {
 		return context + "operationCallback." + name.asEscapedIdentifier;
 	}
 
-	def dispatch String code(PrimitiveValueExpression primValue) {
+	def dispatch CharSequence code(PrimitiveValueExpression primValue) {
 		primValue.value.code;
 	}
 
-	def dispatch String code(ParenthesizedExpression e) {
+	def dispatch CharSequence code(ParenthesizedExpression e) {
 		"(" + e.expression.code.toString.trim + ")";
 	}
 
 	/* Assignment */
-	def dispatch String code(AssignmentExpression it) {
-		varRef.code.toString.trim  + " " +  operator.code.toString.trim  + " " + expression.code.toString.trim
+	def dispatch CharSequence code(AssignmentExpression it) {
+		varRef.code.toString.trim  + " " +  operator.literal + " " + expression.code.toString.trim
 	}
 
 	/* Literals */
-	def dispatch String code(BoolLiteral expression) {
+	def dispatch CharSequence code(BoolLiteral expression) {
 		expression.value.toString()
 	}
 
-	def dispatch String code(IntLiteral expression) {
+	def dispatch CharSequence code(IntLiteral expression) {
 		expression.value.toString();
 	}
 
-	def dispatch String code(HexLiteral expression) {
+	def dispatch CharSequence code(HexLiteral expression) {
 		expression.value.toString();
 	}
 
-	def dispatch String code(DoubleLiteral expression) {
+	def dispatch CharSequence code(DoubleLiteral expression) {
 		expression.value.toString();
 	}
 
-	def dispatch String code(FloatLiteral expression) {
+	def dispatch CharSequence code(FloatLiteral expression) {
 		expression.value.toString();
 	}
 
-	def dispatch String code(NullLiteral expression) {
+	def dispatch CharSequence code(NullLiteral expression) {
 		'null'
 	}
 
-	def dispatch String code(StringLiteral expression) {
+	def dispatch CharSequence code(StringLiteral expression) {
 		"\"" + expression.value.toString().escaped + "\""
 	}
 
-	def String escaped(String it) {
+	def CharSequence escaped(String it) {
 		return it.replace("\"", "\\\"");
 	}
 
-	/* Logical Expressions */
-	def dispatch String code(LogicalOrExpression expression) {
-		expression.leftOperand.code + " || " + expression.rightOperand.code
-	}
-
-	def dispatch String code(ConditionalExpression expression) {
+	def dispatch CharSequence code(ConditionalExpression expression) {
 		expression.condition.code.toString.trim + ' ? ' + expression.trueCase.code + ' : ' + expression.falseCase.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) {
+	def dispatch CharSequence code(LogicalRelationExpression expression) {
 		if (isSame(expression.leftOperand.infer.type, getType(GenericTypeSystem.STRING))) {
 			expression.logicalString
 		} else
-			expression.leftOperand.code.toString.trim + expression.operator.code + expression.rightOperand.code;
+			expression.leftOperand.code.toString.trim + expression.operator.value + expression.rightOperand.code;
 	}
 
-	def String logicalString(LogicalRelationExpression expression) {
+	def CharSequence logicalString(LogicalRelationExpression expression) {
 		if (expression.operator == RelationalOperator::EQUALS) {
 			"(" + expression.leftOperand.code + "== null?" + expression.rightOperand.code + " ==null :" +
 				expression.leftOperand.code + ".Equals(" + expression.rightOperand.code + "))"
@@ -154,63 +122,11 @@ class ExpressionCode {
 		}
 	}
 
-	def dispatch String code(BitwiseAndExpression expression) {
-		expression.leftOperand.code.toString.trim + " & " + expression.rightOperand.code
-	}
-
-	def dispatch String code(BitwiseOrExpression expression) {
-		expression.leftOperand.code.toString.trim + " | " + expression.rightOperand.code
-	}
-
-	def dispatch String code(BitwiseXorExpression expression) {
-		expression.leftOperand.code.toString.trim + " ^ " + expression.rightOperand.code
-	}
-
-	def dispatch String code(ShiftExpression expression) {
-		expression.leftOperand.code.toString.trim + " " + expression.operator.code + " " + expression.rightOperand.code
-	}
-
-	def dispatch String code(NumericalAddSubtractExpression expression) {
-		expression.leftOperand.code.toString.trim + " " + expression.operator.code + " " + expression.rightOperand.code
-	}
-
-	def dispatch String code(NumericalMultiplyDivideExpression expression) {
-		expression.leftOperand.code.toString.trim + " " + expression.operator.code + " " + expression.rightOperand.code
-	}
-
-	def dispatch String code(NumericalUnaryExpression expression) {
-		expression.operator.code + " " + expression.operand.code
-	}
-
-	def dispatch String code(ActiveStateReferenceExpression it) {
+	def dispatch CharSequence code(ActiveStateReferenceExpression it) {
 		"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) {
+	def dispatch CharSequence code(EventRaisingExpression it) {
 		if (value != null) {
 			event.definition.context + "raise" + event.definition.name.toFirstUpper + "(" + value.code + ")"
 		} else {
@@ -218,18 +134,18 @@ class ExpressionCode {
 		}
 	}
 
-	def dispatch String code(EventValueReferenceExpression it) {
+	def dispatch CharSequence code(EventValueReferenceExpression it) {
 		value.definition.context + value.definition.event.valueIdentifier
 	}
 
-	def dispatch String code(ElementReferenceExpression it) '''
+	def dispatch CharSequence code(ElementReferenceExpression it) '''
 		«IF it.reference instanceof OperationDefinition»
 			«reference.code»(«FOR arg : args SEPARATOR ", "»«arg.code»«ENDFOR»)
 		«ELSE»
 			«definition.code»«ENDIF»
 	'''
 
-	def dispatch String code(FeatureCall it) '''
+	def dispatch CharSequence code(FeatureCall it) '''
 		«IF feature instanceof Operation»
 			«feature.code»(«FOR arg : args SEPARATOR ", "»«arg.code»«ENDFOR»)
 		«ELSE»
@@ -237,19 +153,19 @@ class ExpressionCode {
 		«ENDIF»
 	'''
 
-	def dispatch String code(Declaration it) {
+	def dispatch CharSequence code(Declaration it) {
 		context + name.asEscapedIdentifier
 		}
 
-	def dispatch String code(TimeEvent it) {
+	def dispatch CharSequence code(TimeEvent it) {
 		"timeEvents[" + getTimeEvents.indexOf(it) + "]"
 	}
 
-	def dispatch String code(TypeCastExpression it) {
+	def dispatch CharSequence code(TypeCastExpression it) {
 		'''((«type.getTargetLanguageName») «operand.code»)'''
 	}
 
-	def dispatch String getContext(Property it) {
+	def dispatch CharSequence getContext(Property it) {
 		if (it.const) {
 			return getConstContext(it)
 		}
@@ -267,21 +183,21 @@ class ExpressionCode {
 		}
 	}
 
-	def dispatch String getContext(Event it) {
+	def dispatch CharSequence getContext(Event it) {
 		if (scope != null) {
 			return scope.interfaceName.asEscapedIdentifier + "."
 		}
 		return ""
 	}
 
-	def dispatch String getContext(OperationDefinition it) {
+	def dispatch CharSequence getContext(OperationDefinition it) {
 		if (scope != null) {
 			return scope.interfaceName.asEscapedIdentifier + "."
 		}
 		return ""
 	}
 
-	def dispatch String getContext(EObject it) {
+	def dispatch CharSequence getContext(EObject it) {
 		return "//ERROR: No context for " + it
 	}