Update 03/09/2018 - Code splitting

plugins/org.yakindu.sct.generator.sccd/src/org/yakindu/sct/generator/sccd/Argument.xtend

@@ -0,0 +1,74 @@
+package org.yakindu.sct.generator.sccd
+
+import org.yakindu.base.expressions.expressions.FeatureCall
+import org.yakindu.sct.model.stext.stext.EventDefinition
+import org.yakindu.sct.model.stext.stext.VariableDefinition
+import org.yakindu.sct.model.stext.stext.OperationDefinition
+import org.yakindu.base.expressions.expressions.ElementReferenceExpression
+import org.yakindu.sct.model.stext.stext.InterfaceScope
+import org.yakindu.sct.model.stext.stext.InternalScope
+//import org.eclipse.emf.ecore.EObject
+
+class Argument {
+
+	def static dispatch CharSequence generate(FeatureCall it){
+		// Used when you called one attribute of a interface
+		// Owner refers to Scopes
+		// Feature refers to definition (Variable, Event, Operation)
+		var ownerString = Expressions.generate(it.owner)
+		//val featureString = feature.generate
+		val featureString = Expressions.generate(it.feature)
+		if(ownerString.length <= 0){ownerString = Names.DEFAULT_INTERFACE_NAME}
+		// TODO :find a cleaner way to deal with the FeatureCall and ElementReferenceExpression objects
+		'''«IF operationCall»«ownerString».«featureString»«Functions.generateListArgs(it.arguments)»«ELSEIF feature instanceof EventDefinition»«featureString»«ELSE»self.«Names.VARIABLES_DICT_NAME»['«ownerString.toString().replaceAll("self.", "")»']['«featureString»']«ENDIF»'''
+	}
+	
+	def static dispatch CharSequence generate(ElementReferenceExpression it){
+		// TODO : find what "it.arrayAccess" refers to !
+		// TODO : find another way because it uses the string 'id'
+		var CharSequence result;
+		result = it.reference.generateForEltRefExpr
+		'''«result»«IF operationCall»«Functions.generateListArgs(it.arguments)»«ENDIF»'''
+	}
+	
+	// ###########
+	
+	def static dispatch CharSequence generateForEltRefExpr(OperationDefinition it){
+		// TODO : find another way which doesn't use the string 'id'
+		val split = it.id.split("[.]")
+		var nameInterface = Names.INTERNAL_SCOPE_NAME
+		if(split.length == 2){nameInterface = Names.DEFAULT_INTERFACE_NAME}
+		'''self.«nameInterface».«it.name»'''
+	}
+	
+	def static dispatch CharSequence generateForEltRefExpr(VariableDefinition it){
+		// TODO : find another way which doesn't use the string 'id'
+		val split = it.id.split("[.]")
+		var nameInterface = Names.INTERNAL_SCOPE_NAME
+		if(split.length == 2){nameInterface = Names.DEFAULT_INTERFACE_NAME}
+		'''self.«Names.VARIABLES_DICT_NAME»['«nameInterface»']['«it.name»']'''
+		
+	}
+	
+	def static dispatch CharSequence generateForEltRefExpr(EventDefinition it){
+		if(it.type !== null){
+		'''«it.name»_value'''
+		}
+	}
+	
+	def static dispatch CharSequence generateForEltRefExpr(InterfaceScope it){
+		var Interfacename = it.name
+		if(Interfacename.length <= 0){Interfacename = Names.DEFAULT_INTERFACE_NAME}
+		'''self.«Interfacename»'''
+		
+	}
+	
+	def static dispatch CharSequence generateForEltRefExpr(InternalScope it){
+		'''self.«Names.INTERNAL_SCOPE_NAME»'''
+		
+	}
+	
+	/*def static dispatch CharSequence generateForEltRefExpr(EObject it){
+		'''«Expressions.generate(it)»'''
+	}*/
+}

plugins/org.yakindu.sct.generator.sccd/src/org/yakindu/sct/generator/sccd/Binary.xtend

@@ -0,0 +1,90 @@
+package org.yakindu.sct.generator.sccd
+
+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.LogicalAndExpression
+import org.yakindu.base.expressions.expressions.LogicalOrExpression
+import org.yakindu.base.expressions.expressions.LogicalRelationExpression
+import org.yakindu.base.expressions.expressions.RelationalOperator
+import org.yakindu.base.expressions.expressions.NumericalAddSubtractExpression
+import org.yakindu.base.expressions.expressions.AdditiveOperator
+import org.yakindu.base.expressions.expressions.NumericalMultiplyDivideExpression
+import org.yakindu.base.expressions.expressions.MultiplicativeOperator
+import org.yakindu.base.expressions.expressions.ShiftExpression
+import org.yakindu.base.expressions.expressions.ShiftOperator
+
+class Binary {
+	
+	//def static dispatch CharSequence generate(BinaryExpression it){}
+	
+	def static dispatch CharSequence generate(BitwiseAndExpression it){
+		'''«Expressions.generate(leftOperand)» & «Expressions.generate(rightOperand)»'''
+	}
+	
+	def static dispatch CharSequence generate(BitwiseOrExpression it){
+		'''«Expressions.generate(leftOperand)» | «Expressions.generate(rightOperand)»'''
+	}
+	
+	def static dispatch CharSequence generate(BitwiseXorExpression it){
+		'''«Expressions.generate(leftOperand)» ^ «Expressions.generate(rightOperand)»'''
+	}
+	
+	def static dispatch CharSequence generate(LogicalAndExpression it){
+		'''«Expressions.generate(leftOperand)» and «Expressions.generate(rightOperand)»''' 
+	}
+	
+	def static dispatch CharSequence generate(LogicalOrExpression it){
+		'''«Expressions.generate(leftOperand)» or «Expressions.generate(rightOperand)»'''
+	}
+	
+	def static dispatch CharSequence generate(LogicalRelationExpression it){
+		var String operator;
+		switch it.operator {
+			// Relational Operator
+			case RelationalOperator.EQUALS: operator 		= "=="
+			case RelationalOperator.GREATER: operator 		= ">"
+			case RelationalOperator.GREATER_EQUAL: operator = ">="
+			case RelationalOperator.NOT_EQUALS: operator 	= "!="
+			case RelationalOperator.SMALLER: operator 		= "<"
+			case RelationalOperator.SMALLER_EQUAL: operator = "<="
+			default: operator = "##"
+		}
+		'''«Expressions.generate(leftOperand)» «operator» «Expressions.generate(rightOperand)»'''
+	}
+	
+	def static dispatch CharSequence generate(NumericalAddSubtractExpression it){
+		var String operator;
+		switch it.operator{
+			// Additive Operator
+			case AdditiveOperator.MINUS: operator 	= "-"
+			case AdditiveOperator.PLUS: operator 	= "+"
+			default: operator = "##"
+		}
+		'''«Expressions.generate(leftOperand)» «operator» «Expressions.generate(rightOperand)»'''
+	}
+	
+	def static dispatch CharSequence generate(NumericalMultiplyDivideExpression it){
+		var String operator;
+		switch it.operator{
+			// Multiplicative Operator
+			case MultiplicativeOperator.DIV: operator = "/"
+			case MultiplicativeOperator.MOD: operator = "%"
+			case MultiplicativeOperator.MUL: operator = "*"
+			default: operator = "##"
+		}
+		'''«Expressions.generate(leftOperand)» «operator» «Expressions.generate(rightOperand)»'''
+	}
+	
+	def static dispatch CharSequence generate(ShiftExpression it){
+		var String operator;
+		switch it.operator{
+			// Shift Operator
+			case ShiftOperator.LEFT: operator 	= "<<"
+			case ShiftOperator.RIGHT: operator 	= ">>"
+			default: operator = "##"
+		}
+		'''«Expressions.generate(leftOperand)» «operator» «Expressions.generate(rightOperand)»'''
+	}
+	
+}

plugins/org.yakindu.sct.generator.sccd/src/org/yakindu/sct/generator/sccd/DefaultCallback.xtend

@@ -0,0 +1,77 @@
+package org.yakindu.sct.generator.sccd
+
+import org.yakindu.sct.model.sgraph.Statechart
+import org.yakindu.sct.model.stext.stext.InterfaceScope
+import org.yakindu.sct.model.stext.stext.OperationDefinition
+import org.yakindu.base.types.Parameter
+import java.util.List
+import org.yakindu.sct.model.stext.stext.InternalScope
+
+class DefaultCallback {	
+	def static String generateDefaultCallback(Statechart it){
+		'''
+		from abc import ABC, abstractmethod
+		"""
+		This is the default callback for the operations defined inside the interfaces.
+		Please implement the correct behaviour of the operations.
+		"""
+		
+		«FOR scope : scopes.filter(InterfaceScope) SEPARATOR "\n"»
+		«IF scope.declarations.filter(OperationDefinition).length > 0»
+		«IF scope.name !== null»
+		class «scope.name»(ABC):
+		"""
+		This class represents the interface «scope.name»
+		"""
+		«ELSE»
+		class «Names.DEFAULT_INTERFACE_NAME»(ABC):
+		"""
+		This represents the interface «Names.DEFAULT_INTERFACE_NAME»
+		"""
+		«ENDIF»
+		
+			«FOR operation : scope.declarations.filter(OperationDefinition) SEPARATOR "\n"»
+			@abstractmethod
+			def «operation.name»(«operation.parameters.genereteListParameter»):
+				«operation.generateDocString»
+				raise NotImplementedError("The function '«operation.name»' is not implemented")
+			«ENDFOR»
+			«ENDIF»
+		«ENDFOR»
+
+		«FOR scope : scopes.filter(InternalScope)»
+		«IF scope.declarations.filter(OperationDefinition).length > 0»
+		class «Names.INTERNAL_SCOPE_NAME»(ABC):
+		"""
+		This class represents the interface «Names.INTERNAL_SCOPE_NAME»
+		"""
+		
+			«FOR operation : scope.declarations.filter(OperationDefinition) SEPARATOR "\n"»
+			@abstractmethod
+			def «operation.name»(«operation.parameters.genereteListParameter»):
+				«operation.generateDocString»
+				raise NotImplementedError("The function '«operation.name»' is not implemented")
+			«ENDFOR»
+			«ENDIF»
+		«ENDFOR»
+		'''
+	}
+	
+	def static CharSequence generateDocString(OperationDefinition it){
+		'''
+		«IF it.parameters.length > 0 || it.type !== null»
+		"""
+		«FOR para : it.parameters»
+		«IF para.type !== null»«para.name» should be a '«para.type.name»'.«ENDIF»
+		«ENDFOR»
+		«IF it.type !== null»This function should return a '«it.type.name»'.«ENDIF»
+		"""
+		«ENDIF»
+		'''
+	}
+	
+	def static CharSequence genereteListParameter(List<Parameter> it){
+		'''«FOR para : it SEPARATOR ", "»«para.name»«ENDFOR»'''
+	}
+	
+}

plugins/org.yakindu.sct.generator.sccd/src/org/yakindu/sct/generator/sccd/Definitions.xtend

@@ -0,0 +1,46 @@
+package org.yakindu.sct.generator.sccd
+
+import org.yakindu.sct.model.stext.stext.VariableDefinition
+import org.yakindu.sct.model.stext.stext.EventDefinition
+import org.yakindu.sct.model.stext.stext.OperationDefinition
+import org.yakindu.sct.model.sgen.PropertyDefinition
+import org.eclipse.emf.ecore.EObject
+
+class Definitions {
+	
+	def static dispatch CharSequence generate(EObject it){
+		'''NOT HANDLED DEF : «it.class.toString()»'''
+	}
+	
+	def static dispatch CharSequence generate(VariableDefinition it){
+		'''«name»'''
+	}
+	
+	def static dispatch CharSequence generate(EventDefinition it){
+		'''«name»'''
+	}
+	
+	def static dispatch CharSequence generate(OperationDefinition it){ 
+		'''«name»'''
+	}
+	
+	def static dispatch CharSequence generateOperationDef(Object it){
+		//'''«it.generate»'''
+		''''''
+	}
+	def static dispatch CharSequence generate(PropertyDefinition it){
+		'''«name»'''
+	}
+	
+	def static dispatch CharSequence generateOperationDef(OperationDefinition it){
+		// TODO : find a workaround because it's using the string 'id'
+		val myId = it.id
+		val split = myId.split("[.]")
+		var nameInterface = Names.INTERNAL_SCOPE_NAME
+		if(split.size() == 2){
+			nameInterface = Names.DEFAULT_INTERFACE_NAME
+		}
+		'''self.«nameInterface».«it.name»'''
+	}
+	
+}

plugins/org.yakindu.sct.generator.sccd/src/org/yakindu/sct/generator/sccd/Effects.xtend

@@ -0,0 +1,49 @@
+package org.yakindu.sct.generator.sccd
+
+import org.yakindu.base.expressions.expressions.FeatureCall
+import org.yakindu.base.expressions.expressions.Expression
+import org.yakindu.base.expressions.expressions.ElementReferenceExpression
+import org.yakindu.sct.model.stext.stext.ReactionEffect
+import org.yakindu.sct.model.stext.stext.EventRaisingExpression
+import org.yakindu.sct.model.sgraph.Effect
+
+class Effects {
+	
+	def static CharSequence generate(ReactionEffect it){
+		val listRaising = it.actions.filter([action | action !== null && action instanceof EventRaisingExpression])
+		val listOtherActions = it.actions.filter([action | action !== null && !(action instanceof EventRaisingExpression)])
+		'''
+		«FOR raise : listRaising»
+		«Expressions.generate(raise)»
+		«ENDFOR»
+		«IF listOtherActions.length > 0»
+		<script>
+			«Names.OPEN_CDATA»
+				«FOR action : listOtherActions»
+				«generateForReactionEffect(action)»
+				«ENDFOR»
+			«Names.CLOSE_CDATA»
+		</script>
+		«ENDIF»'''
+	}
+	
+	/*def static CharSequence generate(Effect it){
+		''''''
+	}*/
+	
+	def static dispatch generateForReactionEffect(FeatureCall it){
+		var ownerString = Expressions.generate(it.owner)
+		if(ownerString.length <= 0){ownerString = Names.DEFAULT_INTERFACE_NAME}
+		val featureString = Expressions.generate(it.feature)
+		'''«IF operationCall»«ownerString».«featureString»«Functions.generateListArgs(it.arguments)»«ELSE»self.«Names.VARIABLES_DICT_NAME»['«ownerString»']['«featureString»']«ENDIF»'''
+	}
+	
+	def static dispatch CharSequence generateForReactionEffect(Expression it){
+		'''«Expressions.generate(it)»'''
+	}
+	
+	def static dispatch CharSequence generateForReactionEffect(ElementReferenceExpression it){
+		'''«Definitions.generateOperationDef(it.reference)»«Functions.generateListArgs(it.arguments)»'''
+	}
+	
+}

plugins/org.yakindu.sct.generator.sccd/src/org/yakindu/sct/generator/sccd/ExitEntry.xtend

@@ -0,0 +1,92 @@
+package org.yakindu.sct.generator.sccd
+
+import java.util.List
+import org.yakindu.sct.model.sgraph.Reaction
+import java.util.ArrayList
+import org.yakindu.base.expressions.expressions.Expression
+import org.yakindu.sct.model.stext.stext.ReactionTrigger
+import org.yakindu.sct.model.stext.stext.EntryEvent
+import org.yakindu.sct.model.stext.stext.ExitEvent
+import org.yakindu.sct.model.stext.stext.ReactionEffect
+import org.yakindu.sct.model.stext.stext.EventRaisingExpression
+
+class ExitEntry {
+	
+	def static CharSequence generateOneExitEntry(List<Reaction> localReact){
+		val entry = localReact.getEntries
+		val exit = localReact.getExit
+		'''
+		«IF entry.get(0).length > 0 || entry.get(1).length > 0»
+		<onentry>
+			«FOR raise : entry.get(0)»
+			«Expressions.generate(raise)»
+			«ENDFOR»
+			«IF entry.get(1).length > 0»
+			<script>
+				«Names.OPEN_CDATA»
+					«FOR action : entry.get(1)»
+					«Expressions.generate(action)»
+					«ENDFOR»
+				«Names.CLOSE_CDATA»
+			</script>
+			«ENDIF»
+		</onentry>«ENDIF»«IF exit.get(0).length > 0 || exit.get(1).length > 0»
+		<onexit>
+			«FOR raise : exit.get(0)»
+			«Expressions.generate(raise)»
+			«ENDFOR»
+			«IF exit.get(1).length > 0»
+			<script>
+				«Names.OPEN_CDATA»
+					«FOR action : exit.get(1)»
+					«Expressions.generate(action)»
+					«ENDFOR»
+				«Names.CLOSE_CDATA»
+			</script>
+			«ENDIF»
+		</onexit>«ENDIF»'''	
+	}
+	
+	def static ArrayList<ArrayList<Expression>> getRaiseAndActions(List<Expression> it){
+		val raiseExpr = newArrayList()
+		val otherActionExpr = newArrayList()
+		for(Expression expr : it){
+			if(expr instanceof EventRaisingExpression){
+				raiseExpr.add(expr as Expression)
+			}
+			else{
+				otherActionExpr.add(expr)
+			}
+		}
+		val result = newArrayList()
+		result.add(raiseExpr)
+		result.add(otherActionExpr)
+		return result
+	}
+	
+	def static ArrayList<ArrayList<Expression>> getEntries(List<Reaction> it){
+		// TODO : find a way to pass the type as a parameter
+		var listEntry = it.filter([reaction | (reaction.trigger as ReactionTrigger).triggers.head instanceof EntryEvent]).toList()
+		var listEntryActions = listEntry.getActions
+		val entry = listEntryActions.raiseAndActions
+		return entry
+	}
+	
+	def static ArrayList<ArrayList<Expression>> getExit(List<Reaction> it){
+		var listExit = it.filter([reaction | (reaction.trigger as ReactionTrigger).triggers.head instanceof ExitEvent]).toList()
+		var listExitActions = listExit.getActions
+		val exit = listExitActions.raiseAndActions
+		return exit
+	}
+	
+	def static List<Expression> getActions(List<Reaction> it){
+		val result = newArrayList()
+		for(Reaction react : it){
+			if(react.effect instanceof ReactionEffect){
+				result.addAll((react.effect as ReactionEffect).actions)
+			}
+		}
+		return result
+	}
+	
+}

plugins/org.yakindu.sct.generator.sccd/src/org/yakindu/sct/generator/sccd/Expressions.xtend

@@ -0,0 +1,162 @@
+package org.yakindu.sct.generator.sccd
+
+import org.yakindu.sct.model.stext.stext.EventValueReferenceExpression
+import org.yakindu.base.expressions.expressions.ParenthesizedExpression
+import org.yakindu.base.expressions.expressions.AssignmentExpression
+import org.yakindu.base.expressions.expressions.AssignmentOperator
+import org.yakindu.sct.model.stext.stext.EventDefinition
+import org.yakindu.sct.model.stext.stext.ActiveStateReferenceExpression
+import org.yakindu.base.expressions.expressions.ConditionalExpression
+import org.yakindu.base.expressions.expressions.Expression
+import org.yakindu.base.expressions.expressions.PrimitiveValueExpression
+
+import org.yakindu.base.expressions.expressions.UnaryExpression
+import org.yakindu.base.expressions.expressions.BinaryExpression
+import org.yakindu.base.expressions.expressions.ArgumentExpression
+import org.yakindu.sct.model.stext.stext.EventRaisingExpression
+import org.yakindu.base.expressions.expressions.FeatureCall
+import org.yakindu.base.expressions.expressions.ElementReferenceExpression
+import org.yakindu.base.types.Direction
+import org.yakindu.base.base.NamedElement
+import org.eclipse.emf.ecore.EObject
+import org.yakindu.sct.model.stext.stext.VariableDefinition
+import org.yakindu.sct.model.stext.stext.OperationDefinition
+import org.yakindu.base.types.Declaration
+
+class Expressions {
+	
+	def static dispatch CharSequence generate(PrimitiveValueExpression it){
+		'''«Literals.generate(value)»'''
+	}
+	
+	def static dispatch CharSequence generate(BinaryExpression it){
+		'''«Binary.generate(it)»'''
+		
+	}
+	
+	def static dispatch CharSequence generate(UnaryExpression it){
+		'''«Unary.generate(it)»'''
+	}
+	
+	def static dispatch CharSequence generate(ArgumentExpression it){
+		'''«Argument.generate(it)»'''
+	}
+	
+	def static dispatch CharSequence generate(Declaration it){
+		'''«Definitions.generate(it)»'''
+	}
+	
+	def static dispatch CharSequence generate(EventRaisingExpression it){
+		val CharSequence nameEvent = event.generateEventForRaising
+		'''
+		«IF value === null»
+		<raise event="«nameEvent»" «generateScopeForRaising(it.event, nameEvent)»/>
+		«ELSE»
+		<raise event="«nameEvent»" «generateScopeForRaising(it.event, nameEvent)»>
+			<parameter expr="«GenerateForRaising.generateForRaising(value)»"/>
+		</raise>
+		«ENDIF»'''
+		
+	}
+	// ########################
+	def static dispatch CharSequence generateEventForRaising(Expression it){
+		'''«it.generate»'''
+	}
+	
+	def static dispatch CharSequence generateEventForRaising(ElementReferenceExpression it){
+		var nameRef = "noName"
+		if(it.reference instanceof NamedElement){
+			nameRef = (it.reference as NamedElement).name
+		}
+		'''«nameRef»'''
+	}
+	
+	def static dispatch CharSequence generateEventForRaising(FeatureCall it){
+		'''«Expressions.generate(it.feature)»'''
+		/*val feat = it.feature
+		'''«IF feat instanceof EventDefinition || feat instanceof VariableDefinition || feat instanceof OperationDefinition»«Definitions.generate(feat)»
+		«ELSEIF feat instanceof Expression»«Expressions.generate(feat)»
+		«ENDIF»'''*/
+	}
+	// ########################
+	
+	def static dispatch CharSequence generateScopeForRaising(Object it, CharSequence name){
+		'''Scope raising not handled : «it»'''
+	}
+	
+	def static dispatch CharSequence generateScopeForRaising(Expression it, CharSequence name){
+		'''PB : «it»'''
+	}
+	
+	def static dispatch CharSequence generateScopeForRaising(EventRaisingExpression it, CharSequence nameEvent){
+		'''«generateScopeForRaising(it.event, nameEvent)»'''
+	}
+
+	def static dispatch CharSequence generateScopeForRaising(FeatureCall it, CharSequence name){
+		'''«generateScopeForRaising(it.feature, name)»'''
+	}
+	def static dispatch CharSequence generateScopeForRaising(ElementReferenceExpression it, CharSequence name){
+		'''«generateScopeForRaising(it.reference, name)»'''
+	}
+	
+	def static dispatch CharSequence generateScopeForRaising(EventDefinition it, CharSequence name){
+		'''«IF it.direction == Direction.LOCAL»scope="local"«ELSE»scope="output" port="«Functions.findPort(name.toString())»"«ENDIF»'''
+	}
+	
+	// #########################
+	
+	def static dispatch CharSequence generate(EventValueReferenceExpression it){
+		// built in fct : valueof
+		val expr = it.value.generate
+		'''«expr»«IF !(expr.toString().contains("_value"))»_value«ENDIF»'''
+	}
+	
+	def static dispatch CharSequence generate(ParenthesizedExpression it){
+		'''(«it.expression.generate»)'''
+	}
+
+
+	def static dispatch CharSequence generate(AssignmentExpression it){
+		var String operator;
+		switch it.operator {
+			// Assignment Operator
+			case AssignmentOperator.ADD_ASSIGN: operator 		= "+="
+			case AssignmentOperator.AND_ASSIGN: operator 		= "&="
+			case AssignmentOperator.ASSIGN: operator 			= "="
+			case AssignmentOperator.DIV_ASSIGN: operator 		= "/="
+			case AssignmentOperator.LEFT_SHIFT_ASSIGN: operator = "<<="
+			case AssignmentOperator.RIGHT_SHIFT_ASSIGN: operator = ">>="
+			case AssignmentOperator.MOD_ASSIGN: operator 		= "%="
+			case AssignmentOperator.MULT_ASSIGN: operator 		= "*="
+			case AssignmentOperator.OR_ASSIGN: operator 		= "|="
+			case AssignmentOperator.SUB_ASSIGN: operator 		= "-="
+			case AssignmentOperator.XOR_ASSIGN: operator 		= "^="
+			
+			// Default
+			default: operator = "##"
+		}
+		'''«it.varRef.generate» «operator» «it.expression.generate»'''
+	}
+	
+	def static dispatch CharSequence generate(ActiveStateReferenceExpression it){
+		'''INSTATE(«value.name»)'''
+	}
+
+	def static dispatch CharSequence generate(ConditionalExpression it){
+		// exp1 ? exp2 : exp3
+		// In Python exp2 if exp1 else exp3
+		'''«trueCase.generate» if «condition.generate» else «falseCase.generate»'''
+	}
+	
+	def static dispatch CharSequence generate(Expression it){
+		'''unhandled Expression : «it.class.toString()»'''
+	}
+	
+	/*def static dispatch generate(EObject it){
+		'''«it.generate»'''
+	}*/
+	
+	def static dispatch generate(EObject it){
+		'''NOT HANDLED : «it.class.toString()»'''
+	}
+}

plugins/org.yakindu.sct.generator.sccd/src/org/yakindu/sct/generator/sccd/Functions.xtend

@@ -0,0 +1,85 @@
+package org.yakindu.sct.generator.sccd
+
+import org.yakindu.base.expressions.expressions.Argument
+import java.util.List
+import org.yakindu.sct.model.stext.stext.DefaultTrigger
+import org.yakindu.sct.model.stext.stext.ReactionTrigger
+import org.yakindu.sct.model.stext.stext.RegularEventSpec
+import org.yakindu.sct.model.sgraph.Statechart
+import org.yakindu.base.types.Declaration
+import org.yakindu.sct.model.stext.stext.OperationDefinition
+import org.yakindu.sct.model.sgraph.Scope
+import org.yakindu.sct.model.stext.stext.InterfaceScope
+import org.yakindu.sct.model.stext.stext.InternalScope
+import org.yakindu.sct.model.stext.stext.EventDefinition
+import org.yakindu.sct.model.sgraph.Region
+import org.yakindu.sct.model.sgraph.EntryKind
+import org.yakindu.sct.model.sgraph.Entry
+
+class Functions {
+	
+	def static initialState(Region it){
+		vertices.filter(Entry).filter([entry | entry.kind == EntryKind.INITIAL]).head.outgoingTransitions.head.target
+	}
+	
+	def static CharSequence generateListArgs(List<Argument> it){
+		'''(«FOR arg : it SEPARATOR ", "»«Expressions.generate(arg.value)»«ENDFOR»)'''
+	}
+	
+	def static CharSequence findPort(CharSequence name){
+		'''«Names.DICTIONNARY_PORTS.get(name.toString())»'''
+	}
+	
+	def static dispatch CharSequence generateNameEvent(DefaultTrigger it){
+		''''''
+	}
+	
+	def static dispatch CharSequence generateNameEvent(ReactionTrigger it){
+		var firstTrigger = it.triggers.head
+		var CharSequence result
+		if(firstTrigger instanceof RegularEventSpec){
+			result = Expressions.generate((firstTrigger as RegularEventSpec).event)
+		}
+		'''«result»'''
+	}
+	
+	def static List<CharSequence> generateOperationCallback(Statechart it){
+		var setScopeWithOperation = newLinkedHashSet()
+		var toReturn = newArrayList()
+		for(Scope scope : it.scopes){
+			for(Declaration decla : scope.declarations){
+				if(decla instanceof OperationDefinition){
+					setScopeWithOperation.add(scope)
+				}
+			}
+		}
+		val value = '''«FOR scope : setScopeWithOperation SEPARATOR "\n"»<parameter name="«scope.generateNameForScope»"/>«ENDFOR»'''
+		toReturn.add(value)
+		val last = '''«FOR scope : setScopeWithOperation SEPARATOR "\n"»self.«scope.generateNameForScope» = «scope.generateNameForScope»«ENDFOR»'''
+		toReturn.add(last)
+		return toReturn
+	}
+	
+	def static dispatch CharSequence generateNameForScope(InterfaceScope it){
+		'''«IF it.name !== null»«it.name»«ELSE»«Names.DEFAULT_INTERFACE_NAME»«ENDIF»'''
+	}
+	
+	def static dispatch CharSequence generateNameForScope(InternalScope it){
+		'''«Names.INTERNAL_SCOPE_NAME»'''
+	}
+	
+	def static dispatch CharSequence generateNameForScope(Scope it){
+		'''unhandled scope : «class.toString()»'''
+	}
+	
+	def static List<Scope> hasEvent(List<Scope> it){
+		val result = newArrayList()
+		for(Scope scope : it){
+			if(scope.declarations.filter(EventDefinition).length > 0){
+				result.add(scope)
+			}
+		}
+		return result
+	}
+	
+}

plugins/org.yakindu.sct.generator.sccd/src/org/yakindu/sct/generator/sccd/GenerateForRaising.xtend

@@ -0,0 +1,93 @@
+package org.yakindu.sct.generator.sccd
+
+import org.yakindu.sct.model.stext.stext.OperationDefinition
+import org.yakindu.sct.model.stext.stext.VariableDefinition
+import org.yakindu.sct.model.stext.stext.EventDefinition
+import org.yakindu.base.expressions.expressions.FeatureCall
+import org.eclipse.emf.ecore.EObject
+import org.yakindu.base.expressions.expressions.ElementReferenceExpression
+import org.yakindu.base.expressions.expressions.Expression
+import org.yakindu.sct.model.stext.stext.BuiltinEventSpec
+import org.yakindu.sct.model.stext.stext.InterfaceScope
+import org.yakindu.sct.model.stext.stext.InternalScope
+
+class GenerateForRaising {
+	
+	def static dispatch CharSequence generateForRaising(EventDefinition it){
+		// TODO : change that
+		'''«Definitions.generate(it)»'''
+	}
+	def static dispatch CharSequence generateForRaising(OperationDefinition it){
+		'''«Definitions.generate(it)»'''
+	}
+	def static dispatch CharSequence generateForRaising(VariableDefinition it){
+		'''«Definitions.generate(it)»'''
+	}
+	def static dispatch CharSequence generateForRaising(BuiltinEventSpec it){
+		'''«Transitions.generate(it)»'''
+	}
+	
+	def static dispatch CharSequence generateForRaising(InternalScope it){
+		'''«Names.INTERNAL_SCOPE_NAME»'''
+	}
+	def static dispatch CharSequence generateForRaising(InterfaceScope it){
+		'''«IF it.name.length <= 0»«Names.DEFAULT_INTERFACE_NAME»«ELSE»«it.name»«ENDIF»'''
+	}
+	
+	def static dispatch CharSequence generateForRaising(Expression it){
+		'''«Expressions.generate(it)»'''
+	}
+	
+	def static dispatch CharSequence generateForRaising(ElementReferenceExpression it){
+		// Related to the internal interface or the default interface
+		var result = generateSpecialForRaising(it.reference)
+		'''«result»«IF operationCall»«Functions.generateListArgs(it.arguments)»«ENDIF»'''
+	}
+	
+	def static dispatch CharSequence generateSpecialForRaising(EventDefinition it){
+		'''«IF it.type !== null»«it.name»_value«ENDIF»'''
+		
+	}
+	
+	def static dispatch CharSequence generateSpecialForRaising(OperationDefinition it){
+		var nameInterface = Names.DEFAULT_INTERFACE_NAME
+		val split = it.id.split("[.]")
+		if(split.length == 2){nameInterface = Names.INTERNAL_SCOPE_NAME}
+		'''self.«nameInterface».«it.name»'''
+		
+	}
+	def static dispatch CharSequence generateSpecialForRaising(VariableDefinition it){
+		var nameInterface = Names.DEFAULT_INTERFACE_NAME
+		val split = it.id.split("[.]")
+		if(split.length == 2){nameInterface = Names.INTERNAL_SCOPE_NAME}
+		'''self.«Names.VARIABLES_DICT_NAME»['«nameInterface»']['«it.name»']'''
+		
+	}
+	def static dispatch CharSequence generateSpecialForRaising(EObject it){
+		'''«it.generateForRaising»'''
+	}
+	
+	def static dispatch CharSequence generateForRaising(FeatureCall it){
+		// For everything related to a interface
+		var CharSequence result
+		if(it.feature instanceof EventDefinition){
+			val casted = (it.feature as EventDefinition)
+			if(casted.type !== null){
+				result = '''«casted.name»_value'''
+			}
+		}
+		else if(it.feature instanceof VariableDefinition){
+			val casted = (it.feature as VariableDefinition)
+			result = '''self.«Names.VARIABLES_DICT_NAME»['«it.owner.generateForRaising»']['«casted.name»']'''
+			
+		}
+		else if(it.feature instanceof OperationDefinition){
+			val casted = (it.feature as OperationDefinition)
+			result = '''self.«it.owner.generateForRaising».«casted.name»'''
+		}
+		else{
+			result = '''UNHDANLED TYPE : «it.feature» || «it.owner»'''
+		}
+		'''«result»«IF operationCall»«Functions.generateListArgs(it.arguments)»«ENDIF»'''
+	}
+}

plugins/org.yakindu.sct.generator.sccd/src/org/yakindu/sct/generator/sccd/HasValueOf.xtend

@@ -0,0 +1,78 @@
+package org.yakindu.sct.generator.sccd
+
+import java.util.List
+import org.yakindu.base.expressions.expressions.Expression
+import org.yakindu.sct.model.stext.stext.EventRaisingExpression
+import org.yakindu.base.expressions.expressions.ArgumentExpression
+import org.yakindu.base.expressions.expressions.BinaryExpression
+import org.yakindu.base.expressions.expressions.ConditionalExpression
+import org.yakindu.base.expressions.expressions.FeatureCall
+import org.yakindu.base.expressions.expressions.ElementReferenceExpression
+import org.yakindu.base.expressions.expressions.UnaryExpression
+import org.yakindu.base.expressions.expressions.ParenthesizedExpression
+import org.yakindu.sct.model.stext.stext.EventValueReferenceExpression
+import org.yakindu.base.expressions.expressions.AssignmentExpression
+import org.yakindu.base.expressions.expressions.Argument
+
+class HasValueOf {
+	def static dispatch boolean hasValueof(Object it){
+		return false
+	}
+
+	def static dispatch boolean hasValueof(EventValueReferenceExpression it){
+		return true
+	}
+	def static dispatch boolean hasValueof(UnaryExpression it){
+		return it.operand.hasValueof
+	}
+	/*def static dispatch boolean hasValueof(PrimitiveValueExpression it){
+		return false
+	}*/
+	def static dispatch boolean hasValueof(ParenthesizedExpression it){
+		return it.expression.hasValueof
+	}
+	def static dispatch boolean hasValueof(ElementReferenceExpression it){
+		return it.reference.hasValueof
+	}
+	def static dispatch boolean hasValueof(FeatureCall it){
+		return it.feature.hasValueof || it.arguments.hasValueof
+	}
+	def static dispatch boolean hasValueof(ConditionalExpression it){
+		return it.condition.hasValueof || it.trueCase.hasValueof || it.falseCase.hasValueof
+	}
+	def static dispatch boolean hasValueof(BinaryExpression it){
+		return it.leftOperand.hasValueof || it.rightOperand.hasValueof
+	}
+	def static dispatch boolean hasValueof(AssignmentExpression it){
+		return it.varRef.hasValueof || it.expression.hasValueof
+	}
+	
+	def static dispatch boolean hasValueof(ArgumentExpression it){
+		return it.arguments.hasValueof
+	}
+	def static dispatch boolean hasValueof(EventRaisingExpression it){
+		if(it.value !== null){
+			return it.value.hasValueof
+		}
+		else{
+			return false
+		}
+		
+	}
+	
+	def static dispatch boolean hasValueof(Expression it){
+		return false
+	}
+	
+	def static dispatch boolean hasValueof(Argument it){
+		return it.value.hasValueof
+	}
+	
+	def static dispatch boolean hasValueof(List<?> it){
+		for(var i = 0; i < it.length; i++){
+			val item = it.get(i)
+			if(item.hasValueof == true){return true}
+		}
+		return false
+	}
+}

plugins/org.yakindu.sct.generator.sccd/src/org/yakindu/sct/generator/sccd/Interfaces.xtend

@@ -0,0 +1,106 @@
+package org.yakindu.sct.generator.sccd
+
+import org.yakindu.sct.model.stext.stext.InterfaceScope
+import org.yakindu.sct.model.stext.stext.InternalScope
+import org.yakindu.sct.model.stext.stext.VariableDefinition
+import org.yakindu.sct.model.stext.stext.EventDefinition
+import org.yakindu.base.types.Declaration
+import org.yakindu.base.types.PrimitiveType
+import org.yakindu.sct.model.sgraph.Scope
+import java.util.List
+
+class Interfaces {
+	
+	def static CharSequence generateScopes(List<Scope> it){
+		var listScopeGenerated = newArrayList()
+		for(Scope scope : it){
+			var temp = Interfaces.generate(scope)
+			if(temp.length > 0){
+				listScopeGenerated.add(temp)
+			}
+		}
+		var String result
+		if(listScopeGenerated.size() > 0){
+			listScopeGenerated.add(0, "self."+ Names.VARIABLES_DICT_NAME + " = {}")
+			listScopeGenerated.add(0, "## Declarations of variables")
+			result = String.join("\n", listScopeGenerated)
+		}
+		'''«result»'''
+	}
+	
+	def static dispatch CharSequence generate(Scope it){
+		''''''
+	}
+	
+	def static dispatch CharSequence generate(InterfaceScope it){
+		var nameInterface = Names.DEFAULT_INTERFACE_NAME
+		if(name !== null){
+			nameInterface = name
+		}
+		val noNull = declarations.filter([dd | dd !== null])
+		val VariableDefList = noNull.filter([decla | decla instanceof VariableDefinition])
+		'''
+		«IF VariableDefList.length > 0»
+		## Variables for : «nameInterface»
+		self.«Names.VARIABLES_DICT_NAME»['«nameInterface»'] = {}
+		«FOR decla : VariableDefList»
+		self.«Names.VARIABLES_DICT_NAME»['«nameInterface»']['«decla.name»'] = «decla.generateDefaultValue»
+		«ENDFOR»
+		«ENDIF»
+		'''
+	}
+	
+	def static dispatch CharSequence generate(InternalScope it){
+		// TODO : find a super interface of interfaceScope and internalScope (StatechartScope i believe ?)
+		// the only difference is that the name of the interface is the default one
+		val noNull = declarations.filter([dd | dd !== null])
+		val VariableDefList = noNull.filter([decla | decla instanceof VariableDefinition])
+		'''
+		«IF VariableDefList.length > 0»
+		## Variables for : «Names.INTERNAL_SCOPE_NAME»
+		self.«Names.VARIABLES_DICT_NAME»['«Names.INTERNAL_SCOPE_NAME»'] = {}
+		«FOR decla : VariableDefList»
+		self.«Names.VARIABLES_DICT_NAME»['«Names.INTERNAL_SCOPE_NAME»']['«decla.name»'] = «decla.generateDefaultValue»
+		«ENDFOR»
+		«ENDIF»
+		'''
+	}
+	
+	def static dispatch CharSequence generateDefaultValue(Declaration it){
+		'''unhandled type : «it.class.toString()»'''
+	}
+	
+	def static dispatch CharSequence generateDefaultValue(EventDefinition it){
+		'''«it.type.generateDefaultValue»'''
+	}
+	
+	def static dispatch CharSequence generateDefaultValue(PrimitiveType it){
+		var CharSequence defaultVal;
+		switch it.name {
+			case "integer": 	defaultVal = "0"
+			case "real":		defaultVal = "0.0"
+			case "string": 		defaultVal = "\"\""
+			case "boolean": 	defaultVal = "False"
+			case "void": 		defaultVal = "None"
+			default: 			defaultVal = "None"
+		}
+		'''«defaultVal»'''
+	}
+	
+	def static dispatch CharSequence generateDefaultValue(VariableDefinition it){
+		// TODO : find a better way. Is there object for the type like for the Literals ?
+		var CharSequence defaultValue;
+		var CharSequence initialVal = ""
+		if(it.initialValue !== null){
+			initialVal = Expressions.generate(initialValue)
+		}
+		if(initialVal.length > 0){
+			defaultValue = initialVal
+		}
+		else{
+			defaultValue = it.type.generateDefaultValue
+		}
+		'''«defaultValue»'''
+	}
+	
+}

plugins/org.yakindu.sct.generator.sccd/src/org/yakindu/sct/generator/sccd/Literals.xtend

@@ -0,0 +1,50 @@
+package org.yakindu.sct.generator.sccd
+
+import org.yakindu.base.expressions.expressions.IntLiteral
+import org.yakindu.base.expressions.expressions.HexLiteral
+import org.yakindu.base.expressions.expressions.BinaryLiteral
+import org.yakindu.base.expressions.expressions.DoubleLiteral
+import org.yakindu.base.expressions.expressions.FloatLiteral
+import org.yakindu.base.expressions.expressions.BoolLiteral
+import org.yakindu.base.expressions.expressions.StringLiteral
+import org.yakindu.base.expressions.expressions.NullLiteral
+
+class Literals {
+	
+	def static dispatch CharSequence generate(IntLiteral it){
+		'''«value»'''
+	}
+	
+	def static dispatch CharSequence generate(HexLiteral it){
+		// In Python, hexadecimal numbers are represented like this : 0x127AF
+		'''0x«value»'''
+	}
+	
+	def static dispatch CharSequence generate(BinaryLiteral it){
+		// In Python, binary numbers are represented like this : 0b01010101
+		'''0b«value»'''
+	}
+	
+	def static dispatch CharSequence generate(DoubleLiteral it){
+		'''«value»'''
+	}
+	
+	def static dispatch CharSequence generate(FloatLiteral it){
+		'''«value»'''
+	}
+	
+	def static dispatch CharSequence generate(BoolLiteral it){
+		// In Python, true -> True and false -> False
+		'''«IF value»True«ELSE»False«ENDIF»'''
+	}
+	
+	def static dispatch CharSequence generate(StringLiteral it){
+		val trueVal = "'''" + it.value.replaceAll("'''", "\"") + "'''"
+		'''«trueVal»'''
+	}
+	
+	def static dispatch CharSequence generate(NullLiteral it){
+		'''None'''
+	}
+	
+}

plugins/org.yakindu.sct.generator.sccd/src/org/yakindu/sct/generator/sccd/ModifyNames.xtend

@@ -0,0 +1,85 @@
+package org.yakindu.sct.generator.sccd
+
+import org.yakindu.sct.model.sgraph.Statechart
+import org.yakindu.sct.model.sgraph.Region
+import org.yakindu.sct.model.sgraph.Vertex
+import org.yakindu.sct.model.sgraph.State
+import org.yakindu.sct.model.sgraph.Entry
+import org.yakindu.sct.model.sgraph.EntryKind
+import org.yakindu.base.base.NamedElement
+import org.yakindu.sct.model.sgraph.Scope
+import org.yakindu.sct.model.stext.stext.InterfaceScope
+import org.yakindu.sct.model.stext.stext.InternalScope
+import org.yakindu.base.types.Declaration
+import org.yakindu.sct.model.stext.stext.EventDefinition
+
+class ModifyNames {
+	
+	def static dispatch void generateAbsoluteName(Statechart it, String currentName){
+		for(Region region : regions){
+			generateAbsoluteName(region, "")
+		}
+			
+	}
+	
+	def static dispatch void generateAbsoluteName(Region it, String currentName){
+		for(Vertex vertex : vertices){
+			if(vertex instanceof State){
+				if((vertex as State).regions.length >= 2){
+					vertex.name = currentName + "/" + vertex.name
+					for(Region reg : (vertex as State).regions){
+						generateAbsoluteName(reg, vertex.name + "/" + Names.PARALLEL_REGIONS_NAME + vertex.generateName + "/" + reg.name)
+					}
+				}
+				else if((vertex as State).regions.length >= 1){
+					vertex.name = currentName + "/" + vertex.name
+					for(Region reg : (vertex as State).regions){
+						generateAbsoluteName(reg, vertex.name + "/" + reg.name)
+					}
+					
+				}
+				else{
+					vertex.name = currentName + "/" + vertex.name
+					}
+			}
+			var isEntry = vertex instanceof Entry
+			if(isEntry){
+				var isShallowOrDeep = ((vertex as Entry).kind == EntryKind.DEEP_HISTORY || (vertex as Entry).kind == EntryKind.SHALLOW_HISTORY)
+				if(isShallowOrDeep){
+					vertex.name = currentName + "/" + vertex.name
+				}
+		}
+		
+		}
+	}
+	
+	def static CharSequence generateName(NamedElement it){
+		var splitName = name.split("/")
+		'''«splitName.last»'''
+	}
+	
+	def static void modifyEventNames(Statechart it){
+		for(Scope scope : it.scopes){
+			var String interfaceName;
+			if(scope instanceof InterfaceScope){
+				interfaceName = (scope as InterfaceScope).name
+				if(interfaceName === null || interfaceName.length <= 0){
+					interfaceName = Names.DEFAULT_NAME_EVENT
+				}
+			}
+			else if(scope instanceof InternalScope){
+				interfaceName = Names.INTERNAL_NAME_EVENT
+			}
+			for(Declaration decla : scope.declarations){
+				if(decla instanceof EventDefinition){
+					val casted = (decla as EventDefinition)
+					casted.name = interfaceName + "_" + casted.name
+					val String key = (casted.name as CharSequence).toString()
+					val String value = (interfaceName as CharSequence).toString()
+					Names.DICTIONNARY_PORTS.put(key, value)
+				}
+			}
+		}
+	}
+	
+}

plugins/org.yakindu.sct.generator.sccd/src/org/yakindu/sct/generator/sccd/Names.xtend

@@ -0,0 +1,17 @@
+package org.yakindu.sct.generator.sccd
+
+import java.util.HashMap
+
+interface Names {
+	val PARALLEL_REGIONS_NAME 	= "parallelRegionsOf_"
+	val DEFAULT_CALLBACK_NAME 	= "defaultCallback"
+	val DEFAULT_INTERFACE_NAME 	= "defaultInterface"
+	val VARIABLES_DICT_NAME 	= "variables"
+	val INTERNAL_SCOPE_NAME 	= "internalInterface"
+	val OPEN_CDATA 				= "<![CDATA["
+	val CLOSE_CDATA 			= "]]>"
+	val DEFAULT_NAME_EVENT 		= "default"
+	val INTERNAL_NAME_EVENT 	= "internal"
+	val DICTIONNARY_PORTS 		= new HashMap<String, String>()
+	
+}

plugins/org.yakindu.sct.generator.sccd/src/org/yakindu/sct/generator/sccd/Ports.xtend

@@ -0,0 +1,24 @@
+package org.yakindu.sct.generator.sccd
+
+import org.yakindu.sct.model.sgraph.Statechart
+import org.yakindu.sct.model.stext.stext.InterfaceScope
+import org.yakindu.sct.model.stext.stext.InternalScope
+import static org.yakindu.sct.generator.sccd.Functions.hasEvent
+
+class Ports {
+	def static CharSequence generatePorts(Statechart it){
+		val hasEvents = hasEvent(it.scopes)
+		'''
+		«FOR scope : hasEvents SEPARATOR "\n"»
+		«IF scope instanceof InterfaceScope»
+		<inport name="«IF scope.name === null || scope.name.length <= 0»«Names.DEFAULT_NAME_EVENT»«ELSE»«scope.name»«ENDIF»"/>
+		<outport name="«IF scope.name === null || scope.name.length <= 0»«Names.DEFAULT_NAME_EVENT»«ELSE»«scope.name»«ENDIF»"/>
+		«ELSEIF scope instanceof InternalScope»
+		<inport name="«Names.INTERNAL_NAME_EVENT»"/>
+		<outport name="«Names.INTERNAL_NAME_EVENT»"/>
+		«ENDIF»
+		«ENDFOR»
+		'''
+		
+	}
+}

plugins/org.yakindu.sct.generator.sccd/src/org/yakindu/sct/generator/sccd/Transitions.xtend

@@ -0,0 +1,105 @@
+package org.yakindu.sct.generator.sccd
+
+import org.yakindu.sct.model.sgraph.Transition
+import org.yakindu.sct.model.stext.stext.ReactionTrigger
+import org.yakindu.sct.model.stext.stext.ReactionEffect
+
+import static org.yakindu.sct.generator.sccd.HasValueOf.hasValueof
+import org.yakindu.sct.model.stext.stext.RegularEventSpec
+import org.yakindu.sct.model.stext.stext.AlwaysEvent
+import org.yakindu.sct.model.stext.stext.EntryEvent
+import org.yakindu.sct.model.stext.stext.ExitEvent
+import org.yakindu.sct.model.stext.stext.TimeEventSpec
+import org.yakindu.sct.model.stext.stext.TimeEventType
+import org.yakindu.sct.model.stext.stext.TimeUnit
+import org.yakindu.sct.model.stext.stext.Guard
+
+class Transitions {
+	
+	def static dispatch CharSequence generate(Transition it){
+		//TODO : find a better, expecting name_value
+		val nameEvent = Functions.generateNameEvent(trigger).toString().replaceAll("_value", "")
+		val transitionInfo = generateSpecialTransition(it)
+		val transitionString = transitionInfo.get(0)
+		val hasIt = transitionInfo.get(1)
+		'''
+		<transition«IF transitionString.toString().trim().length > 0» «transitionString» «ELSE» «ENDIF»target="«target.name»">
+			«IF hasIt == true»<parameter name="«nameEvent»_value"/>«ENDIF»
+			«IF it.effect !== null»
+			«Effects.generate((it.effect as ReactionEffect))»
+			«ENDIF»
+		</transition>
+		'''
+	}
+	
+	def static generateSpecialTransition(Transition it){
+		var boolean hasIt = false
+		val listResult = newArrayList()
+		val action = it.effect
+		if(it.trigger instanceof ReactionTrigger){
+			val casted = (it.trigger as ReactionTrigger)
+			val realGuard = casted.guard
+			val realTrigger = casted.triggers.head
+			if(realTrigger !== null){
+				listResult.add(realTrigger.generate.toString().replaceAll("_value", ""))
+			}
+			if(realGuard !== null){
+				hasIt = hasValueof(realGuard.expression)
+				listResult.add('''cond="«realGuard.generate»"''')
+				if(hasIt){
+					if(realTrigger instanceof RegularEventSpec){
+						// TODO : find a better way that doesn't use .replaceAll
+						listResult.set(0, '''event="«Expressions.generate(realTrigger.event).toString().replaceAll("_value", "")»"''')
+						
+					}
+				}
+			}
+		}
+		if(action instanceof ReactionEffect){
+			//listResult.add("ReactionEffectDetected")
+			hasIt = hasValueof(action.actions)
+		}
+		val result = newArrayList(String.join(" ", listResult), hasIt)
+		return result
+	}
+	
+	def static dispatch CharSequence generate(Guard it){
+		//'''«it.expression.generate»'''
+		'''«Expressions.generate(it.expression)»'''
+	}
+	
+	def static dispatch CharSequence generate(AlwaysEvent it){
+		''' '''
+	}
+	
+	def static dispatch CharSequence generate(EntryEvent it){
+		// Those events are handled by the generateOneExitEntry function
+		// Only one <onentry> is allowed
+		''''''
+	}
+	
+	def static dispatch CharSequence generate(ExitEvent it){
+		// Those events are handled by the generateOneExitEntry function
+		// Only one <onexit> is allowed
+		''''''
+	}
+	
+	def static dispatch CharSequence generate(TimeEventSpec it){
+		// No support for te keyword "every", too complex to manage. (for now ?)
+		var String operation;
+		switch it.unit {
+			case TimeUnit.MILLISECOND : operation = " / 1000"
+			case TimeUnit.MICROSECOND : operation = " / 1000000"
+			case TimeUnit.NANOSECOND : operation = " / 1000000000"
+			default : operation = ""
+		}
+		//'''«IF type == TimeEventType.AFTER»after="«value.generate»«operation»"«ENDIF»'''
+		'''«IF type == TimeEventType.AFTER»after="«Expressions.generate(value)»«operation»"«ENDIF»'''
+	}
+	
+	def static dispatch CharSequence generate(RegularEventSpec it){
+		//'''event="«it.event.generate»"'''
+		'''event="«Expressions.generate(it.event)»"'''
+	}
+	
+}

plugins/org.yakindu.sct.generator.sccd/src/org/yakindu/sct/generator/sccd/Triggers.xtend

@@ -0,0 +1,5 @@
+package org.yakindu.sct.generator.sccd
+
+class Triggers {
+	
+}

plugins/org.yakindu.sct.generator.sccd/src/org/yakindu/sct/generator/sccd/Unary.xtend

@@ -0,0 +1,40 @@
+package org.yakindu.sct.generator.sccd
+
+import org.yakindu.base.expressions.expressions.LogicalNotExpression
+import org.yakindu.base.expressions.expressions.NumericalUnaryExpression
+import org.yakindu.base.expressions.expressions.PostFixUnaryExpression
+import org.yakindu.base.expressions.expressions.UnaryOperator
+import org.yakindu.base.expressions.expressions.PostFixOperator
+
+class Unary {
+	//def static dispatch CharSequence generate(Unary it){}
+	
+	def static dispatch CharSequence generate(LogicalNotExpression it){
+		'''not («Expressions.generate(operand)»)'''
+	}
+	
+	def static dispatch CharSequence generate(NumericalUnaryExpression it){
+		var String operator;
+		switch it.operator{
+			// UnaryOperator
+			case UnaryOperator.COMPLEMENT: operator = "~"
+			case UnaryOperator.NEGATIVE: operator 	= "-"
+			//case UnaryOperator.POSITIVE: operator 	= "+"
+			// TODO : check if this expression is correct
+			case UnaryOperator.POSITIVE: operator 	= ""
+			default: operator = "##"
+		}
+		'''«operator»«Expressions.generate(operand)»'''
+	}
+	
+	def static dispatch CharSequence generate(PostFixUnaryExpression it){
+		var String operator;
+		switch it.operator{
+			// Postfix Operator
+			case PostFixOperator.DECREMENT: operator = "-= 1"
+			case PostFixOperator.INCREMENT: operator = "+= 1"
+			default: operator = "##"
+		}
+		'''«Expressions.generate(operand)» «operator»'''
+	}
+}

plugins/org.yakindu.sct.generator.sccd/src/org/yakindu/sct/generator/sccd/Vertices.xtend

@@ -0,0 +1,78 @@
+package org.yakindu.sct.generator.sccd
+
+import org.yakindu.sct.model.sgraph.Synchronization
+import org.yakindu.sct.model.sgraph.Exit
+import org.yakindu.sct.model.sgraph.Choice
+import org.yakindu.sct.model.sgraph.EntryKind
+import org.yakindu.sct.model.sgraph.FinalState
+import org.yakindu.sct.model.sgraph.State
+import org.yakindu.sct.model.sgraph.Entry
+import org.yakindu.sct.model.sgraph.Region
+import static org.yakindu.sct.generator.sccd.ExitEntry.generateOneExitEntry
+import static org.yakindu.sct.generator.sccd.ModifyNames.generateName
+import static org.yakindu.sct.generator.sccd.Functions.initialState
+
+class Vertices {
+	
+	def static dispatch CharSequence generate(Region it){
+		'''
+		«FOR vertex : vertices»
+			«vertex.generate»
+		«ENDFOR»
+		'''
+	}
+	
+	def static dispatch CharSequence generate(State it){
+		val toJoin = newArrayList('''«generateOneExitEntry(it.localReactions)»''', '''«FOR transition : outgoingTransitions SEPARATOR "\n"»«Transitions.generate(transition)»«ENDFOR»''')
+		val commonPart = String.join("\n", toJoin.filter([str | str.length > 0])) 
+		'''«IF regions.length >= 2»
+		<state id="«generateName(it)»" initial="«Names.PARALLEL_REGIONS_NAME»«generateName(it)»">
+			«commonPart»
+			<parallel id="«Names.PARALLEL_REGIONS_NAME»«generateName(it)»">
+				«FOR region : regions»
+					<state id="«region.name»" initial="«initialState(region).name»">
+						«region.generate»
+					</state>
+				«ENDFOR»
+			</parallel>
+		</state>
+		«ELSE»
+		<state id="«generateName(it)»"«IF regions.head !== null» initial="«initialState(regions.head).name»"«ENDIF»>
+			«commonPart»
+			«FOR region : regions»
+				«region.generate»
+			«ENDFOR»
+		</state>«ENDIF»'''
+	}
+	
+	def static dispatch CharSequence generate(FinalState it){
+		// TODO
+		''''''
+	}
+	
+	def static dispatch CharSequence generate(Entry it){
+		'''
+		«IF kind == EntryKind.DEEP_HISTORY»
+		<history id="«generateName(it)»" type="deep"/>
+		«ELSEIF kind == EntryKind.SHALLOW_HISTORY»
+		<history id="«generateName(it)»" type="shallow"/>
+		«ENDIF»
+		'''
+	}
+	
+	def static dispatch CharSequence generate(Choice it){
+		// TODO
+		''''''
+	}
+	
+	def static dispatch CharSequence generate(Exit it){
+		// TODO
+		''''''
+	}
+	
+	def static dispatch CharSequence generate(Synchronization it){
+		// TODO
+		''''''
+	}
+	
+}