Bugfixes

kernel/modelverse_kernel/generated.py

@@ -12,6 +12,12 @@ class ModelverseKernel(object):
 		self.success = True
 		self.generators = {}
 
+	def set_overlap(self, lst):
+		s = set(lst.pop())
+		while (lst):
+			s &= set(lst.pop())
+		return list(s)
+
 	def execute_yields(self, taskname, operation, params, reply):
 		try:
 			self.success = True
@@ -185,8 +191,6 @@ class ModelverseKernel(object):
 		Rules_N8_4, = yield [('RD', [Rules_N8_3, 'IP'])]
 		Rules_N8_4_V, = yield [('RV', [Rules_N8_4])]
 		Rules_N8_5, = yield [('RD', [Rules_N8_4, 'last_param'])]
-		Rules_N8_6, = yield [('RD', [Rules_N8_5, 'name'])]
-		Rules_N8_6_V, = yield [('RV', [Rules_N8_6])]
 		Rules_N9_0 = root
 		Rules_N9_1, = yield [('RD', [Rules_N9_0, taskname])]
 		Rules_N9_2, = yield [('RD', [Rules_N9_1, 'frame'])]
@@ -519,8 +523,6 @@ class ModelverseKernel(object):
 			Rules_N6_3_DEL, = yield [('RDE', [Rules_N6_2, 'phase'])]
 			yield [('DE', [Rules_N6_3_DEL])]
 			Rules_N6_5, = yield [('RD', [Rules_N6_2, 'IP'])]
-			Rules_N6_5_DEL, = yield [('RDE', [Rules_N6_2, 'IP'])]
-			yield [('DE', [Rules_N6_5_DEL])]
 			Rules_N6_7, = yield [('RD', [Rules_N6_2, 'evalstack'])]
 			Rules_N6_7_DEL, = yield [('RDE', [Rules_N6_2, 'evalstack'])]
 			yield [('DE', [Rules_N6_7_DEL])]
@@ -535,10 +537,11 @@ class ModelverseKernel(object):
 			Rules_N6_10 = self.set_overlap(matched)[0]
 			Rules_N6_4, = yield [('CNV', ['finish'])]
 			Rules_N6_9, = yield [('CN', [])]
-			Rules___169, = yield [('CD', [Rules_N6_2, 'phase', Rules_N6_4])]
-			Rules___173, = yield [('CD', [Rules_N6_2, 'IP', Rules_N6_6])]
+			Rules_N6_11, = yield [('CNV', ['finish'])]
+			Rules___171, = yield [('CD', [Rules_N6_2, 'phase', Rules_N6_4])]
 			Rules___183, = yield [('CD', [Rules_N6_2, 'evalstack', Rules_N6_9])]
 			Rules___185, = yield [('CD', [Rules_N6_9, 'prev', Rules_N6_8])]
+			Rules___187, = yield [('CD', [Rules_N6_8, 'phase', Rules_N6_11])]
 		elif (True  and Rules_N7_1 is not None  and Rules_N7_3 is not None  and Rules_N7_6 is not None  and Rules_N7_6_V['value'] == 'call' and Rules_N7_10 is not None  and Rules_N7_10_V == 'call' and Rules_N7_11 is None ):
 			# Execute rule Rules/Call_Call_None_N7
 			print('Execute rule Rules/Call_Call_None_N7')
@@ -559,16 +562,16 @@ class ModelverseKernel(object):
 			Rules_N7_7, = yield [('CN', [])]
 			Rules_N7_9, = yield [('CNV', ['finish'])]
 			Rules_N7_13, = yield [('CNV', ['init'])]
-			Rules___203, = yield [('CD', [Rules_N7_1, 'frame', Rules_N7_2])]
-			Rules___207, = yield [('CD', [Rules_N7_2, 'evalstack', Rules_N7_4])]
-			Rules___209, = yield [('CD', [Rules_N7_2, 'symbols', Rules_N7_5])]
-			Rules___211, = yield [('CD', [Rules_N7_2, 'caller', Rules_N7_6])]
-			Rules___213, = yield [('CD', [Rules_N7_2, 'returnvalue', Rules_N7_7])]
-			Rules___215, = yield [('CD', [Rules_N7_2, 'IP', Rules_N7_12])]
-			Rules___217, = yield [('CD', [Rules_N7_2, 'phase', Rules_N7_13])]
-			Rules___221, = yield [('CD', [Rules_N7_2, 'prev', Rules_N7_3])]
-			Rules___227, = yield [('CD', [Rules_N7_3, 'phase', Rules_N7_9])]
-		elif (True  and Rules_N8_1 is not None  and Rules_N8_3 is not None  and Rules_N8_4 is not None  and Rules_N8_4_V['value'] == 'call' and Rules_N8_5 is not None  and Rules_N8_6 is not None  and Rules_N8_6_V == a):
+			Rules___205, = yield [('CD', [Rules_N7_1, 'frame', Rules_N7_2])]
+			Rules___209, = yield [('CD', [Rules_N7_2, 'evalstack', Rules_N7_4])]
+			Rules___211, = yield [('CD', [Rules_N7_2, 'symbols', Rules_N7_5])]
+			Rules___213, = yield [('CD', [Rules_N7_2, 'caller', Rules_N7_6])]
+			Rules___215, = yield [('CD', [Rules_N7_2, 'returnvalue', Rules_N7_7])]
+			Rules___217, = yield [('CD', [Rules_N7_2, 'IP', Rules_N7_12])]
+			Rules___219, = yield [('CD', [Rules_N7_2, 'phase', Rules_N7_13])]
+			Rules___223, = yield [('CD', [Rules_N7_2, 'prev', Rules_N7_3])]
+			Rules___229, = yield [('CD', [Rules_N7_3, 'phase', Rules_N7_9])]
+		elif (True  and Rules_N8_1 is not None  and Rules_N8_3 is not None  and Rules_N8_4 is not None  and Rules_N8_4_V['value'] == 'call' and Rules_N8_5 is not None ):
 			# Execute rule Rules/Call_Call_Params_N8
 			print('Execute rule Rules/Call_Call_Params_N8')
 			Rules_N8_1, = yield [('RD', [Rules_N8_0, taskname])]
@@ -608,11 +611,11 @@ class ModelverseKernel(object):
 			Rules_N8_9, = yield [('RD', [Rules_N8_11, a])]
 			Rules_N8_7, = yield [('CNV', ['finish'])]
 			Rules_N8_10, = yield [('CN', [])]
-			Rules___251, = yield [('CD', [Rules_N8_1, 'frame', Rules_N8_2])]
-			Rules___265, = yield [('CD', [Rules_N8_3, 'finish', Rules_N8_7])]
-			Rules___275, = yield [('CD', [Rules_N8_10, 'value', Rules_N8_8])]
+			Rules___253, = yield [('CD', [Rules_N8_1, 'frame', Rules_N8_2])]
+			Rules___267, = yield [('CD', [Rules_N8_3, 'finish', Rules_N8_7])]
+			Rules___277, = yield [('CD', [Rules_N8_10, 'value', Rules_N8_8])]
 			Rules_N8_16, = yield [('CE', [Rules_N8_15, Rules_N8_10])]
-			Rules___284, = yield [('CE', [Rules_N8_16, Rules_N8_9])]
+			Rules___286, = yield [('CE', [Rules_N8_16, Rules_N8_9])]
 		elif (True  and Rules_N9_1 is not None  and Rules_N9_2 is not None  and Rules_N9_14 is not None  and Rules_N9_14_V['value'] == 'call' and Rules_N9_15 is not None  and Rules_N9_16 is not None ):
 			# Execute rule Rules/Call_Params_First_Multi_N9
 			print('Execute rule Rules/Call_Params_First_Multi_N9')
@@ -640,19 +643,19 @@ class ModelverseKernel(object):
 			Rules_N9_7, = yield [('CN', [])]
 			Rules_N9_11, = yield [('CNV', ['init'])]
 			Rules_N9_12, = yield [('CN', [])]
-			Rules___308, = yield [('CD', [Rules_N9_2, 'evalstack', Rules_N9_12])]
-			Rules___314, = yield [('CD', [Rules_N9_2, 'init', Rules_N9_11])]
-			Rules___320, = yield [('CD', [Rules_N9_2, 'IP', Rules_N9_17])]
-			Rules___322, = yield [('CD', [Rules_N9_3, 'caller', Rules_N9_14])]
-			Rules___324, = yield [('CD', [Rules_N9_3, 'prev', Rules_N9_2])]
-			Rules___326, = yield [('CD', [Rules_N9_3, 'phase', Rules_N9_4])]
-			Rules___328, = yield [('CD', [Rules_N9_3, 'evalstack', Rules_N9_5])]
-			Rules___330, = yield [('CD', [Rules_N9_3, 'symbols', Rules_N9_6])]
-			Rules___332, = yield [('CD', [Rules_N9_3, 'returnvalue', Rules_N9_7])]
-			Rules___334, = yield [('CD', [Rules_N9_3, 'IP', Rules_N9_8])]
-			Rules___340, = yield [('CD', [Rules_N9_12, 'prev', Rules_N9_13])]
-			Rules___342, = yield [('CD', [Rules_N9_13, 'inst', Rules_N9_14])]
-			Rules___344, = yield [('CD', [Rules_N9_13, 'phase', Rules_N9_16])]
+			Rules___310, = yield [('CD', [Rules_N9_2, 'evalstack', Rules_N9_12])]
+			Rules___316, = yield [('CD', [Rules_N9_2, 'init', Rules_N9_11])]
+			Rules___322, = yield [('CD', [Rules_N9_2, 'IP', Rules_N9_17])]
+			Rules___324, = yield [('CD', [Rules_N9_3, 'caller', Rules_N9_14])]
+			Rules___326, = yield [('CD', [Rules_N9_3, 'prev', Rules_N9_2])]
+			Rules___328, = yield [('CD', [Rules_N9_3, 'phase', Rules_N9_4])]
+			Rules___330, = yield [('CD', [Rules_N9_3, 'evalstack', Rules_N9_5])]
+			Rules___332, = yield [('CD', [Rules_N9_3, 'symbols', Rules_N9_6])]
+			Rules___334, = yield [('CD', [Rules_N9_3, 'returnvalue', Rules_N9_7])]
+			Rules___336, = yield [('CD', [Rules_N9_3, 'IP', Rules_N9_8])]
+			Rules___342, = yield [('CD', [Rules_N9_12, 'prev', Rules_N9_13])]
+			Rules___344, = yield [('CD', [Rules_N9_13, 'inst', Rules_N9_14])]
+			Rules___346, = yield [('CD', [Rules_N9_13, 'phase', Rules_N9_16])]
 		elif (True  and Rules_N10_1 is not None  and Rules_N10_2 is not None  and Rules_N10_14 is not None  and Rules_N10_14_V['value'] == 'call' and Rules_N10_15 is not None ):
 			# Execute rule Rules/Call_Params_First_Single_N10
 			print('Execute rule Rules/Call_Params_First_Single_N10')
@@ -681,19 +684,19 @@ class ModelverseKernel(object):
 			Rules_N10_9, = yield [('CNV', ['init'])]
 			Rules_N10_13, = yield [('CNV', ['call'])]
 			Rules_N10_17, = yield [('CN', [])]
-			Rules___374, = yield [('CD', [Rules_N10_2, 'IP', Rules_N10_16])]
-			Rules___376, = yield [('CD', [Rules_N10_2, 'phase', Rules_N10_9])]
-			Rules___382, = yield [('CD', [Rules_N10_2, 'evalstack', Rules_N10_17])]
-			Rules___388, = yield [('CD', [Rules_N10_3, 'phase', Rules_N10_4])]
-			Rules___390, = yield [('CD', [Rules_N10_3, 'evalstack', Rules_N10_5])]
-			Rules___392, = yield [('CD', [Rules_N10_3, 'symbols', Rules_N10_6])]
-			Rules___394, = yield [('CD', [Rules_N10_3, 'returnvalue', Rules_N10_7])]
-			Rules___396, = yield [('CD', [Rules_N10_3, 'prev', Rules_N10_2])]
-			Rules___398, = yield [('CD', [Rules_N10_3, 'IP', Rules_N10_8])]
-			Rules___400, = yield [('CD', [Rules_N10_3, 'caller', Rules_N10_14])]
-			Rules___406, = yield [('CD', [Rules_N10_12, 'phase', Rules_N10_13])]
-			Rules___408, = yield [('CD', [Rules_N10_12, 'inst', Rules_N10_14])]
-			Rules___416, = yield [('CD', [Rules_N10_17, 'prev', Rules_N10_12])]
+			Rules___376, = yield [('CD', [Rules_N10_2, 'IP', Rules_N10_16])]
+			Rules___378, = yield [('CD', [Rules_N10_2, 'phase', Rules_N10_9])]
+			Rules___384, = yield [('CD', [Rules_N10_2, 'evalstack', Rules_N10_17])]
+			Rules___390, = yield [('CD', [Rules_N10_3, 'phase', Rules_N10_4])]
+			Rules___392, = yield [('CD', [Rules_N10_3, 'evalstack', Rules_N10_5])]
+			Rules___394, = yield [('CD', [Rules_N10_3, 'symbols', Rules_N10_6])]
+			Rules___396, = yield [('CD', [Rules_N10_3, 'returnvalue', Rules_N10_7])]
+			Rules___398, = yield [('CD', [Rules_N10_3, 'prev', Rules_N10_2])]
+			Rules___400, = yield [('CD', [Rules_N10_3, 'IP', Rules_N10_8])]
+			Rules___402, = yield [('CD', [Rules_N10_3, 'caller', Rules_N10_14])]
+			Rules___408, = yield [('CD', [Rules_N10_12, 'phase', Rules_N10_13])]
+			Rules___410, = yield [('CD', [Rules_N10_12, 'inst', Rules_N10_14])]
+			Rules___418, = yield [('CD', [Rules_N10_17, 'prev', Rules_N10_12])]
 		elif (True  and Rules_N11_1 is not None  and Rules_N11_2 is not None  and Rules_N11_14 is not None  and Rules_N11_16 is not None  and Rules_N11_16_V['value'] == 'call'):
 			# Execute rule Rules/Call_Params_Last_N11
 			print('Execute rule Rules/Call_Params_Last_N11')
@@ -747,15 +750,15 @@ class ModelverseKernel(object):
 			Rules_N11_15, = yield [('CNV', ['call'])]
 			Rules_N11_18, = yield [('CN', [])]
 			Rules_N11_19, = yield [('CNV', ['init'])]
-			Rules___446, = yield [('CD', [Rules_N11_2, 'evalstack', Rules_N11_18])]
-			Rules___448, = yield [('CD', [Rules_N11_2, 'phase', Rules_N11_19])]
-			Rules___454, = yield [('CD', [Rules_N11_2, 'IP', Rules_N11_13])]
-			Rules___470, = yield [('CD', [Rules_N11_9, 'value', Rules_N11_10])]
-			Rules___480, = yield [('CD', [Rules_N11_17, 'inst', Rules_N11_16])]
-			Rules___482, = yield [('CD', [Rules_N11_17, 'phase', Rules_N11_15])]
-			Rules___484, = yield [('CD', [Rules_N11_18, 'prev', Rules_N11_17])]
+			Rules___448, = yield [('CD', [Rules_N11_2, 'evalstack', Rules_N11_18])]
+			Rules___450, = yield [('CD', [Rules_N11_2, 'phase', Rules_N11_19])]
+			Rules___456, = yield [('CD', [Rules_N11_2, 'IP', Rules_N11_13])]
+			Rules___472, = yield [('CD', [Rules_N11_9, 'value', Rules_N11_10])]
+			Rules___482, = yield [('CD', [Rules_N11_17, 'inst', Rules_N11_16])]
+			Rules___484, = yield [('CD', [Rules_N11_17, 'phase', Rules_N11_15])]
+			Rules___486, = yield [('CD', [Rules_N11_18, 'prev', Rules_N11_17])]
 			Rules_N11_8, = yield [('CE', [Rules_N11_20, Rules_N11_9])]
-			Rules___487, = yield [('CE', [Rules_N11_8, Rules_N11_7])]
+			Rules___489, = yield [('CE', [Rules_N11_8, Rules_N11_7])]
 		elif (True  and Rules_N12_1 is not None  and Rules_N12_2 is not None  and Rules_N12_11 is not None  and Rules_N12_18 is not None  and Rules_N12_19 is not None  and Rules_N12_19_V['value'] == 'call'):
 			# Execute rule Rules/Call_Params_Next_N12
 			print('Execute rule Rules/Call_Params_Next_N12')
@@ -808,15 +811,15 @@ class ModelverseKernel(object):
 			Rules_N12_9, = yield [('CN', [])]
 			Rules_N12_15, = yield [('CN', [])]
 			Rules_N12_20, = yield [('CNV', ['init'])]
-			Rules___519, = yield [('CD', [Rules_N12_2, 'evalstack', Rules_N12_15])]
-			Rules___521, = yield [('CD', [Rules_N12_2, 'IP', Rules_N12_16])]
-			Rules___525, = yield [('CD', [Rules_N12_2, 'phase', Rules_N12_20])]
-			Rules___541, = yield [('CD', [Rules_N12_9, 'value', Rules_N12_10])]
-			Rules___551, = yield [('CD', [Rules_N12_15, 'prev', Rules_N12_17])]
-			Rules___553, = yield [('CD', [Rules_N12_17, 'phase', Rules_N12_18])]
-			Rules___555, = yield [('CD', [Rules_N12_17, 'inst', Rules_N12_19])]
+			Rules___521, = yield [('CD', [Rules_N12_2, 'evalstack', Rules_N12_15])]
+			Rules___523, = yield [('CD', [Rules_N12_2, 'IP', Rules_N12_16])]
+			Rules___527, = yield [('CD', [Rules_N12_2, 'phase', Rules_N12_20])]
+			Rules___543, = yield [('CD', [Rules_N12_9, 'value', Rules_N12_10])]
+			Rules___553, = yield [('CD', [Rules_N12_15, 'prev', Rules_N12_17])]
+			Rules___555, = yield [('CD', [Rules_N12_17, 'phase', Rules_N12_18])]
+			Rules___557, = yield [('CD', [Rules_N12_17, 'inst', Rules_N12_19])]
 			Rules_N12_8, = yield [('CE', [Rules_N12_13, Rules_N12_9])]
-			Rules___558, = yield [('CE', [Rules_N12_8, Rules_N12_7])]
+			Rules___560, = yield [('CE', [Rules_N12_8, Rules_N12_7])]
 		elif (True  and Rules_N13_1 is not None  and Rules_N13_2 is not None  and Rules_N13_3 is not None  and Rules_N13_3_V == 'init' and Rules_N13_6 is not None  and Rules_N13_6_V['value'] == 'call' and Rules_N13_9 is None ):
 			# Execute rule Rules/Call_Resolve_No_Params_N13
 			print('Execute rule Rules/Call_Resolve_No_Params_N13')
@@ -833,11 +836,11 @@ class ModelverseKernel(object):
 			Rules_N13_8, = yield [('RD', [Rules_N13_6, 'func'])]
 			Rules_N13_4, = yield [('CN', [])]
 			Rules_N13_7, = yield [('CNV', ['call'])]
-			Rules___578, = yield [('CD', [Rules_N13_2, 'evalstack', Rules_N13_4])]
-			Rules___582, = yield [('CD', [Rules_N13_2, 'IP', Rules_N13_8])]
-			Rules___584, = yield [('CD', [Rules_N13_4, 'prev', Rules_N13_5])]
-			Rules___586, = yield [('CD', [Rules_N13_5, 'inst', Rules_N13_6])]
-			Rules___588, = yield [('CD', [Rules_N13_5, 'phase', Rules_N13_7])]
+			Rules___580, = yield [('CD', [Rules_N13_2, 'evalstack', Rules_N13_4])]
+			Rules___584, = yield [('CD', [Rules_N13_2, 'IP', Rules_N13_8])]
+			Rules___586, = yield [('CD', [Rules_N13_4, 'prev', Rules_N13_5])]
+			Rules___588, = yield [('CD', [Rules_N13_5, 'inst', Rules_N13_6])]
+			Rules___590, = yield [('CD', [Rules_N13_5, 'phase', Rules_N13_7])]
 		elif (True  and Rules_N14_1 is not None  and Rules_N14_2 is not None  and Rules_N14_5 is not None  and Rules_N14_5_V['value'] == 'call' and Rules_N14_8 is not None ):
 			# Execute rule Rules/Call_Resolve_Params_N14
 			print('Execute rule Rules/Call_Resolve_Params_N14')
@@ -853,11 +856,11 @@ class ModelverseKernel(object):
 			Rules_N14_8, = yield [('RD', [Rules_N14_5, 'params'])]
 			Rules_N14_6, = yield [('RD', [Rules_N14_5, 'func'])]
 			Rules_N14_4, = yield [('CN', [])]
-			Rules___609, = yield [('CD', [Rules_N14_2, 'evalstack', Rules_N14_4])]
-			Rules___613, = yield [('CD', [Rules_N14_2, 'IP', Rules_N14_6])]
-			Rules___617, = yield [('CD', [Rules_N14_3, 'phase', Rules_N14_8])]
-			Rules___619, = yield [('CD', [Rules_N14_3, 'inst', Rules_N14_5])]
-			Rules___621, = yield [('CD', [Rules_N14_4, 'prev', Rules_N14_3])]
+			Rules___611, = yield [('CD', [Rules_N14_2, 'evalstack', Rules_N14_4])]
+			Rules___615, = yield [('CD', [Rules_N14_2, 'IP', Rules_N14_6])]
+			Rules___619, = yield [('CD', [Rules_N14_3, 'phase', Rules_N14_8])]
+			Rules___621, = yield [('CD', [Rules_N14_3, 'inst', Rules_N14_5])]
+			Rules___623, = yield [('CD', [Rules_N14_4, 'prev', Rules_N14_3])]
 		elif (True  and Rules_N15_1 is not None  and Rules_N15_2 is not None  and Rules_N15_4 is not None  and Rules_N15_4_V == 'init' and Rules_N15_6 is not None  and Rules_N15_6_V['value'] == 'constant'):
 			# Execute rule Rules/Const_N15
 			print('Execute rule Rules/Const_N15')
@@ -872,8 +875,8 @@ class ModelverseKernel(object):
 			Rules_N15_6, = yield [('RD', [Rules_N15_2, 'IP'])]
 			Rules_N15_7, = yield [('RD', [Rules_N15_6, 'node'])]
 			Rules_N15_5, = yield [('CNV', ['finish'])]
-			Rules___639, = yield [('CD', [Rules_N15_2, 'returnvalue', Rules_N15_7])]
-			Rules___645, = yield [('CD', [Rules_N15_2, 'phase', Rules_N15_5])]
+			Rules___641, = yield [('CD', [Rules_N15_2, 'returnvalue', Rules_N15_7])]
+			Rules___647, = yield [('CD', [Rules_N15_2, 'phase', Rules_N15_5])]
 		elif (True  and Rules_N16_1 is not None  and Rules_N16_2 is not None  and Rules_N16_3 is not None  and Rules_N16_3_V == 'init' and Rules_N16_4 is not None  and Rules_N16_4_V['value'] == 'continue'):
 			# Execute rule Rules/Continue_N16
 			print('Execute rule Rules/Continue_N16')
@@ -896,9 +899,9 @@ class ModelverseKernel(object):
 			matched.append(_tmp)
 			Rules_N16_9 = self.set_overlap(matched)[0]
 			Rules_N16_8, = yield [('CN', [])]
-			Rules___669, = yield [('CD', [Rules_N16_2, 'IP', Rules_N16_5])]
-			Rules___679, = yield [('CD', [Rules_N16_2, 'evalstack', Rules_N16_8])]
-			Rules___681, = yield [('CD', [Rules_N16_8, 'prev', Rules_N16_7])]
+			Rules___671, = yield [('CD', [Rules_N16_2, 'IP', Rules_N16_5])]
+			Rules___681, = yield [('CD', [Rules_N16_2, 'evalstack', Rules_N16_8])]
+			Rules___683, = yield [('CD', [Rules_N16_8, 'prev', Rules_N16_7])]
 		elif (True  and Rules_N17_1 is not None  and Rules_N17_2 is not None  and Rules_N17_3 is not None  and Rules_N17_3_V == 'init' and Rules_N17_5 is not None  and Rules_N17_5_V['value'] == 'declare'):
 			# Execute rule Rules/Declare_Init_N17
 			print('Execute rule Rules/Declare_Init_N17')
@@ -912,9 +915,9 @@ class ModelverseKernel(object):
 			Rules_N17_7, = yield [('RD', [Rules_N17_5, 'var'])]
 			Rules_N17_4, = yield [('CNV', ['finish'])]
 			Rules_N17_8, = yield [('CN', [])]
-			Rules___698, = yield [('CD', [Rules_N17_2, 'phase', Rules_N17_4])]
+			Rules___700, = yield [('CD', [Rules_N17_2, 'phase', Rules_N17_4])]
 			Rules_N17_9, = yield [('CE', [Rules_N17_6, Rules_N17_8])]
-			Rules___707, = yield [('CE', [Rules_N17_9, Rules_N17_7])]
+			Rules___709, = yield [('CE', [Rules_N17_9, Rules_N17_7])]
 		elif (True  and Rules_N18_1 is not None  and Rules_N18_2 is not None  and Rules_N18_4 is not None  and Rules_N18_4_V == 'init' and Rules_N18_6 is not None  and Rules_N18_6_V['value'] == 'global'):
 			# Execute rule Rules/Global_Init_N18
 			print('Execute rule Rules/Global_Init_N18')
@@ -928,9 +931,9 @@ class ModelverseKernel(object):
 			Rules_N18_7, = yield [('RD', [Rules_N18_6, 'var'])]
 			Rules_N18_5, = yield [('CNV', ['finish'])]
 			Rules_N18_8, = yield [('CN', [])]
-			Rules___726, = yield [('CD', [Rules_N18_2, 'phase', Rules_N18_5])]
+			Rules___728, = yield [('CD', [Rules_N18_2, 'phase', Rules_N18_5])]
 			Rules_N18_9, = yield [('CE', [Rules_N18_3, Rules_N18_8])]
-			Rules___733, = yield [('CE', [Rules_N18_9, Rules_N18_7])]
+			Rules___735, = yield [('CE', [Rules_N18_9, Rules_N18_7])]
 		elif (True  and Rules_N19_1 is not None  and Rules_N19_2 is not None  and Rules_N19_3 is not None  and Rules_N19_3_V == 'init' and Rules_N19_6 is not None  and Rules_N19_6_V['value'] == 'if'):
 			# Execute rule Rules/If_Cond_N19
 			print('Execute rule Rules/If_Cond_N19')
@@ -946,11 +949,11 @@ class ModelverseKernel(object):
 			Rules_N19_8, = yield [('RD', [Rules_N19_6, 'cond'])]
 			Rules_N19_4, = yield [('CN', [])]
 			Rules_N19_7, = yield [('CNV', ['cond'])]
-			Rules___752, = yield [('CD', [Rules_N19_2, 'evalstack', Rules_N19_4])]
-			Rules___756, = yield [('CD', [Rules_N19_2, 'IP', Rules_N19_8])]
-			Rules___758, = yield [('CD', [Rules_N19_4, 'prev', Rules_N19_5])]
-			Rules___760, = yield [('CD', [Rules_N19_5, 'inst', Rules_N19_6])]
-			Rules___762, = yield [('CD', [Rules_N19_5, 'phase', Rules_N19_7])]
+			Rules___754, = yield [('CD', [Rules_N19_2, 'evalstack', Rules_N19_4])]
+			Rules___758, = yield [('CD', [Rules_N19_2, 'IP', Rules_N19_8])]
+			Rules___760, = yield [('CD', [Rules_N19_4, 'prev', Rules_N19_5])]
+			Rules___762, = yield [('CD', [Rules_N19_5, 'inst', Rules_N19_6])]
+			Rules___764, = yield [('CD', [Rules_N19_5, 'phase', Rules_N19_7])]
 		elif (True  and Rules_N20_1 is not None  and Rules_N20_2 is not None  and Rules_N20_3 is not None  and Rules_N20_3_V == 'cond' and Rules_N20_4 is not None  and Rules_N20_4_V['value'] == 'if' and Rules_N20_6 is not None  and Rules_N20_6_V == False and Rules_N20_8 is not None ):
 			# Execute rule Rules/If_False_Else_N20
 			print('Execute rule Rules/If_False_Else_N20')
@@ -970,12 +973,12 @@ class ModelverseKernel(object):
 			Rules_N20_5, = yield [('CN', [])]
 			Rules_N20_7, = yield [('CNV', ['init'])]
 			Rules_N20_10, = yield [('CNV', ['finish'])]
-			Rules___785, = yield [('CD', [Rules_N20_2, 'evalstack', Rules_N20_5])]
-			Rules___789, = yield [('CD', [Rules_N20_2, 'phase', Rules_N20_7])]
-			Rules___793, = yield [('CD', [Rules_N20_2, 'IP', Rules_N20_8])]
-			Rules___797, = yield [('CD', [Rules_N20_5, 'prev', Rules_N20_9])]
-			Rules___799, = yield [('CD', [Rules_N20_9, 'inst', Rules_N20_4])]
-			Rules___801, = yield [('CD', [Rules_N20_9, 'phase', Rules_N20_10])]
+			Rules___787, = yield [('CD', [Rules_N20_2, 'evalstack', Rules_N20_5])]
+			Rules___791, = yield [('CD', [Rules_N20_2, 'phase', Rules_N20_7])]
+			Rules___795, = yield [('CD', [Rules_N20_2, 'IP', Rules_N20_8])]
+			Rules___799, = yield [('CD', [Rules_N20_5, 'prev', Rules_N20_9])]
+			Rules___801, = yield [('CD', [Rules_N20_9, 'inst', Rules_N20_4])]
+			Rules___803, = yield [('CD', [Rules_N20_9, 'phase', Rules_N20_10])]
 		elif (True  and Rules_N21_1 is not None  and Rules_N21_2 is not None  and Rules_N21_3 is not None  and Rules_N21_3_V == 'cond' and Rules_N21_5 is not None  and Rules_N21_5_V['value'] == 'if' and Rules_N21_6 is not None  and Rules_N21_6_V == False and Rules_N21_7 is None ):
 			# Execute rule Rules/If_False_None_N21
 			print('Execute rule Rules/If_False_None_N21')
@@ -988,7 +991,7 @@ class ModelverseKernel(object):
 			yield [('DE', [Rules_N21_3_DEL])]
 			Rules_N21_7, = yield [('RD', [Rules_N21_5, 'else'])]
 			Rules_N21_4, = yield [('CNV', ['finish'])]
-			Rules___821, = yield [('CD', [Rules_N21_2, 'phase', Rules_N21_4])]
+			Rules___823, = yield [('CD', [Rules_N21_2, 'phase', Rules_N21_4])]
 		elif (True  and Rules_N22_1 is not None  and Rules_N22_2 is not None  and Rules_N22_3 is not None  and Rules_N22_3_V == 'cond' and Rules_N22_6 is not None  and Rules_N22_6_V == True and Rules_N22_9 is not None  and Rules_N22_9_V['value'] == 'if'):
 			# Execute rule Rules/If_True_N22
 			print('Execute rule Rules/If_True_N22')
@@ -1008,12 +1011,12 @@ class ModelverseKernel(object):
 			Rules_N22_4, = yield [('CN', [])]
 			Rules_N22_5, = yield [('CNV', ['init'])]
 			Rules_N22_10, = yield [('CNV', ['finish'])]
-			Rules___844, = yield [('CD', [Rules_N22_2, 'evalstack', Rules_N22_4])]
-			Rules___846, = yield [('CD', [Rules_N22_4, 'prev', Rules_N22_7])]
-			Rules___848, = yield [('CD', [Rules_N22_2, 'phase', Rules_N22_5])]
-			Rules___854, = yield [('CD', [Rules_N22_2, 'IP', Rules_N22_8])]
-			Rules___856, = yield [('CD', [Rules_N22_7, 'inst', Rules_N22_9])]
-			Rules___858, = yield [('CD', [Rules_N22_7, 'phase', Rules_N22_10])]
+			Rules___846, = yield [('CD', [Rules_N22_2, 'evalstack', Rules_N22_4])]
+			Rules___848, = yield [('CD', [Rules_N22_4, 'prev', Rules_N22_7])]
+			Rules___850, = yield [('CD', [Rules_N22_2, 'phase', Rules_N22_5])]
+			Rules___856, = yield [('CD', [Rules_N22_2, 'IP', Rules_N22_8])]
+			Rules___858, = yield [('CD', [Rules_N22_7, 'inst', Rules_N22_9])]
+			Rules___860, = yield [('CD', [Rules_N22_7, 'phase', Rules_N22_10])]
 		elif (True  and Rules_N23_1 is not None  and Rules_N23_2 is not None  and Rules_N23_5 is not None  and Rules_N23_5_V['value'] == 'input' and Rules_N23_6 is not None  and Rules_N23_6_V == 'init' and Rules_N23_7 is not None ):
 			# Execute rule Rules/Input_N23
 			print('Execute rule Rules/Input_N23')
@@ -1036,9 +1039,9 @@ class ModelverseKernel(object):
 			Rules_N23_9_DEL, = yield [('RDE', [Rules_N23_8, 'next'])]
 			yield [('DE', [Rules_N23_9_DEL])]
 			Rules_N23_3, = yield [('CNV', ['finish'])]
-			Rules___876, = yield [('CD', [Rules_N23_2, 'phase', Rules_N23_3])]
-			Rules___884, = yield [('CD', [Rules_N23_2, 'returnvalue', Rules_N23_7])]
-			Rules___892, = yield [('CD', [Rules_N23_1, 'input', Rules_N23_9])]
+			Rules___878, = yield [('CD', [Rules_N23_2, 'phase', Rules_N23_3])]
+			Rules___886, = yield [('CD', [Rules_N23_2, 'returnvalue', Rules_N23_7])]
+			Rules___894, = yield [('CD', [Rules_N23_1, 'input', Rules_N23_9])]
 		elif (True  and Rules_N24_1 is not None  and Rules_N24_2 is not None  and Rules_N24_3 is not None  and Rules_N24_3_V == 'finish' and Rules_N24_5 is not None  and Rules_N24_6 is not None ):
 			# Execute rule Rules/Next_Next_N24
 			print('Execute rule Rules/Next_Next_N24')
@@ -1052,8 +1055,8 @@ class ModelverseKernel(object):
 			yield [('DE', [Rules_N24_5_DEL])]
 			Rules_N24_6, = yield [('RD', [Rules_N24_5, 'next'])]
 			Rules_N24_4, = yield [('CNV', ['init'])]
-			Rules___907, = yield [('CD', [Rules_N24_2, 'phase', Rules_N24_4])]
-			Rules___911, = yield [('CD', [Rules_N24_2, 'IP', Rules_N24_6])]
+			Rules___909, = yield [('CD', [Rules_N24_2, 'phase', Rules_N24_4])]
+			Rules___913, = yield [('CD', [Rules_N24_2, 'IP', Rules_N24_6])]
 		elif (True  and Rules_N25_1 is not None  and Rules_N25_2 is not None  and Rules_N25_3 is not None  and Rules_N25_3_V == 'finish' and Rules_N25_4 is not None  and Rules_N25_9 is None ):
 			# Execute rule Rules/Next_NoNext_N25
 			print('Execute rule Rules/Next_NoNext_N25')
@@ -1078,9 +1081,9 @@ class ModelverseKernel(object):
 			Rules_N25_8, = yield [('RD', [Rules_N25_7, 'phase'])]
 			Rules_N25_8_DEL, = yield [('RDE', [Rules_N25_7, 'phase'])]
 			yield [('DE', [Rules_N25_8_DEL])]
-			Rules___933, = yield [('CD', [Rules_N25_2, 'IP', Rules_N25_5])]
-			Rules___937, = yield [('CD', [Rules_N25_2, 'evalstack', Rules_N25_7])]
-			Rules___939, = yield [('CD', [Rules_N25_2, 'phase', Rules_N25_8])]
+			Rules___935, = yield [('CD', [Rules_N25_2, 'IP', Rules_N25_5])]
+			Rules___939, = yield [('CD', [Rules_N25_2, 'evalstack', Rules_N25_7])]
+			Rules___941, = yield [('CD', [Rules_N25_2, 'phase', Rules_N25_8])]
 		elif (True  and Rules_N26_1 is not None  and Rules_N26_2 is not None  and Rules_N26_3 is not None  and Rules_N26_3_V == 'init' and Rules_N26_4 is not None  and Rules_N26_4_V['value'] == 'output'):
 			# Execute rule Rules/Output_Init_N26
 			print('Execute rule Rules/Output_Init_N26')
@@ -1096,11 +1099,11 @@ class ModelverseKernel(object):
 			Rules_N26_7, = yield [('RD', [Rules_N26_4, 'value'])]
 			Rules_N26_5, = yield [('CN', [])]
 			Rules_N26_8, = yield [('CNV', ['output'])]
-			Rules___966, = yield [('CD', [Rules_N26_2, 'evalstack', Rules_N26_5])]
-			Rules___968, = yield [('CD', [Rules_N26_5, 'prev', Rules_N26_6])]
-			Rules___972, = yield [('CD', [Rules_N26_2, 'IP', Rules_N26_7])]
-			Rules___974, = yield [('CD', [Rules_N26_6, 'inst', Rules_N26_4])]
-			Rules___976, = yield [('CD', [Rules_N26_6, 'phase', Rules_N26_8])]
+			Rules___968, = yield [('CD', [Rules_N26_2, 'evalstack', Rules_N26_5])]
+			Rules___970, = yield [('CD', [Rules_N26_5, 'prev', Rules_N26_6])]
+			Rules___974, = yield [('CD', [Rules_N26_2, 'IP', Rules_N26_7])]
+			Rules___976, = yield [('CD', [Rules_N26_6, 'inst', Rules_N26_4])]
+			Rules___978, = yield [('CD', [Rules_N26_6, 'phase', Rules_N26_8])]
 		elif (True  and Rules_N27_1 is not None  and Rules_N27_2 is not None  and Rules_N27_4 is not None  and Rules_N27_4_V['value'] == 'output' and Rules_N27_5 is not None  and Rules_N27_5_V == 'output'):
 			# Execute rule Rules/Output_Output_N27
 			print('Execute rule Rules/Output_Output_N27')
@@ -1116,10 +1119,10 @@ class ModelverseKernel(object):
 			Rules_N27_7, = yield [('RD', [Rules_N27_2, 'returnvalue'])]
 			Rules_N27_6, = yield [('CNV', ['finish'])]
 			Rules_N27_8, = yield [('CN', [])]
-			Rules___997, = yield [('CD', [Rules_N27_2, 'phase', Rules_N27_6])]
-			Rules___1001, = yield [('CD', [Rules_N27_3, 'value', Rules_N27_7])]
-			Rules___1003, = yield [('CD', [Rules_N27_3, 'next', Rules_N27_8])]
-			Rules___1005, = yield [('CD', [Rules_N27_1, 'last_output', Rules_N27_8])]
+			Rules___999, = yield [('CD', [Rules_N27_2, 'phase', Rules_N27_6])]
+			Rules___1003, = yield [('CD', [Rules_N27_3, 'value', Rules_N27_7])]
+			Rules___1005, = yield [('CD', [Rules_N27_3, 'next', Rules_N27_8])]
+			Rules___1007, = yield [('CD', [Rules_N27_1, 'last_output', Rules_N27_8])]
 		elif (True  and Rules_N28_1 is not None  and Rules_N28_3 is not None  and Rules_N28_5 is not None  and Rules_N28_7 is not None  and Rules_N28_7_V['value'] == 'resolve' and Rules_N28_8 is not None  and Rules_N28_8_V == 'init' and Rules_N28_10 is not None  and Rules_N28_11 is None ):
 			# Execute rule Rules/Resolve_NoAttrGlobal_N28
 			print('Execute rule Rules/Resolve_NoAttrGlobal_N28')
@@ -1138,8 +1141,8 @@ class ModelverseKernel(object):
 			Rules_N28_9, = yield [('RDN', [Rules_N28_2, Rules_N28_10])]
 			Rules_N28_11, = yield [('RDN', [Rules_N28_5, Rules_N28_10])]
 			Rules_N28_4, = yield [('CNV', ['finish'])]
-			Rules___1027, = yield [('CD', [Rules_N28_3, 'phase', Rules_N28_4])]
-			Rules___1037, = yield [('CD', [Rules_N28_3, 'returnvalue', Rules_N28_9])]
+			Rules___1029, = yield [('CD', [Rules_N28_3, 'phase', Rules_N28_4])]
+			Rules___1039, = yield [('CD', [Rules_N28_3, 'returnvalue', Rules_N28_9])]
 		elif (True  and Rules_N29_1 is not None  and Rules_N29_2 is not None  and Rules_N29_3 is not None  and Rules_N29_3_V['value'] == 'resolve' and Rules_N29_4 is not None  and Rules_N29_4_V == 'init' and Rules_N29_6 is not None  and Rules_N29_7 is not None  and Rules_N29_9 is not None ):
 			# Execute rule Rules/Resolve_NoAttr_N29
 			print('Execute rule Rules/Resolve_NoAttr_N29')
@@ -1156,8 +1159,8 @@ class ModelverseKernel(object):
 			Rules_N29_9, = yield [('RD', [Rules_N29_3, 'var'])]
 			Rules_N29_7, = yield [('RDN', [Rules_N29_6, Rules_N29_9])]
 			Rules_N29_5, = yield [('CNV', ['finish'])]
-			Rules___1065, = yield [('CD', [Rules_N29_2, 'phase', Rules_N29_5])]
-			Rules___1069, = yield [('CD', [Rules_N29_2, 'returnvalue', Rules_N29_7])]
+			Rules___1067, = yield [('CD', [Rules_N29_2, 'phase', Rules_N29_5])]
+			Rules___1071, = yield [('CD', [Rules_N29_2, 'returnvalue', Rules_N29_7])]
 		elif (True  and Rules_N30_1 is not None  and Rules_N30_2 is not None  and Rules_N30_4 is not None  and Rules_N30_4_V == 'eval' and Rules_N30_5 is not None  and Rules_N30_5_V['value'] == 'return'):
 			# Execute rule Rules/Return_Eval_N30
 			print('Execute rule Rules/Return_Eval_N30')
@@ -1180,8 +1183,8 @@ class ModelverseKernel(object):
 			Rules_N30_7, = yield [('RD', [Rules_N30_3, 'returnvalue'])]
 			Rules_N30_7_DEL, = yield [('RDE', [Rules_N30_3, 'returnvalue'])]
 			yield [('DE', [Rules_N30_7_DEL])]
-			Rules___1090, = yield [('CD', [Rules_N30_1, 'frame', Rules_N30_3])]
-			Rules___1100, = yield [('CD', [Rules_N30_3, 'returnvalue', Rules_N30_6])]
+			Rules___1092, = yield [('CD', [Rules_N30_1, 'frame', Rules_N30_3])]
+			Rules___1102, = yield [('CD', [Rules_N30_3, 'returnvalue', Rules_N30_6])]
 		elif (True  and Rules_N31_1 is not None  and Rules_N31_2 is not None  and Rules_N31_4 is not None  and Rules_N31_4_V == 'init' and Rules_N31_5 is not None  and Rules_N31_5_V['value'] == 'return' and Rules_N31_6 is None ):
 			# Execute rule Rules/Return_NoValue_N31
 			print('Execute rule Rules/Return_NoValue_N31')
@@ -1199,7 +1202,7 @@ class ModelverseKernel(object):
 			Rules_N31_3_DEL, = yield [('RDE', [Rules_N31_2, 'prev'])]
 			yield [('DE', [Rules_N31_3_DEL])]
 			Rules_N31_6, = yield [('RD', [Rules_N31_5, 'value'])]
-			Rules___1115, = yield [('CD', [Rules_N31_1, 'frame', Rules_N31_3])]
+			Rules___1117, = yield [('CD', [Rules_N31_1, 'frame', Rules_N31_3])]
 		elif (True  and Rules_N32_1 is not None  and Rules_N32_2 is not None  and Rules_N32_3 is not None  and Rules_N32_3_V == 'init' and Rules_N32_5 is not None  and Rules_N32_5_V['value'] == 'return' and Rules_N32_7 is not None ):
 			# Execute rule Rules/Return_Value_N32
 			print('Execute rule Rules/Return_Value_N32')
@@ -1215,11 +1218,11 @@ class ModelverseKernel(object):
 			Rules_N32_7, = yield [('RD', [Rules_N32_5, 'value'])]
 			Rules_N32_4, = yield [('CN', [])]
 			Rules_N32_8, = yield [('CNV', ['eval'])]
-			Rules___1142, = yield [('CD', [Rules_N32_2, 'evalstack', Rules_N32_4])]
-			Rules___1146, = yield [('CD', [Rules_N32_2, 'IP', Rules_N32_7])]
-			Rules___1148, = yield [('CD', [Rules_N32_4, 'prev', Rules_N32_6])]
-			Rules___1150, = yield [('CD', [Rules_N32_6, 'inst', Rules_N32_5])]
-			Rules___1152, = yield [('CD', [Rules_N32_6, 'phase', Rules_N32_8])]
+			Rules___1144, = yield [('CD', [Rules_N32_2, 'evalstack', Rules_N32_4])]
+			Rules___1148, = yield [('CD', [Rules_N32_2, 'IP', Rules_N32_7])]
+			Rules___1150, = yield [('CD', [Rules_N32_4, 'prev', Rules_N32_6])]
+			Rules___1152, = yield [('CD', [Rules_N32_6, 'inst', Rules_N32_5])]
+			Rules___1154, = yield [('CD', [Rules_N32_6, 'phase', Rules_N32_8])]
 		elif (True  and Rules_N33_1 is not None  and Rules_N33_2 is not None  and Rules_N33_3 is not None  and Rules_N33_3_V == 'init' and Rules_N33_5 is not None  and Rules_N33_5_V['value'] == 'while'):
 			# Execute rule Rules/While_Cond_N33
 			print('Execute rule Rules/While_Cond_N33')
@@ -1235,11 +1238,11 @@ class ModelverseKernel(object):
 			Rules_N33_7, = yield [('RD', [Rules_N33_5, 'cond'])]
 			Rules_N33_4, = yield [('CN', [])]
 			Rules_N33_8, = yield [('CNV', ['cond'])]
-			Rules___1173, = yield [('CD', [Rules_N33_2, 'evalstack', Rules_N33_4])]
-			Rules___1177, = yield [('CD', [Rules_N33_2, 'IP', Rules_N33_7])]
-			Rules___1179, = yield [('CD', [Rules_N33_4, 'prev', Rules_N33_6])]
-			Rules___1181, = yield [('CD', [Rules_N33_6, 'inst', Rules_N33_5])]
-			Rules___1183, = yield [('CD', [Rules_N33_6, 'phase', Rules_N33_8])]
+			Rules___1175, = yield [('CD', [Rules_N33_2, 'evalstack', Rules_N33_4])]
+			Rules___1179, = yield [('CD', [Rules_N33_2, 'IP', Rules_N33_7])]
+			Rules___1181, = yield [('CD', [Rules_N33_4, 'prev', Rules_N33_6])]
+			Rules___1183, = yield [('CD', [Rules_N33_6, 'inst', Rules_N33_5])]
+			Rules___1185, = yield [('CD', [Rules_N33_6, 'phase', Rules_N33_8])]
 		elif (True  and Rules_N34_1 is not None  and Rules_N34_2 is not None  and Rules_N34_3 is not None  and Rules_N34_3_V == 'cond' and Rules_N34_5 is not None  and Rules_N34_5_V['value'] == 'while' and Rules_N34_6 is not None  and Rules_N34_6_V == False):
 			# Execute rule Rules/While_False_N34
 			print('Execute rule Rules/While_False_N34')
@@ -1251,7 +1254,7 @@ class ModelverseKernel(object):
 			Rules_N34_5, = yield [('RD', [Rules_N34_2, 'IP'])]
 			Rules_N34_6, = yield [('RD', [Rules_N34_2, 'returnvalue'])]
 			Rules_N34_4, = yield [('CNV', ['finish'])]
-			Rules___1200, = yield [('CD', [Rules_N34_2, 'phase', Rules_N34_4])]
+			Rules___1202, = yield [('CD', [Rules_N34_2, 'phase', Rules_N34_4])]
 		elif (True  and Rules_N35_1 is not None  and Rules_N35_2 is not None  and Rules_N35_3 is not None  and Rules_N35_3_V == 'cond' and Rules_N35_5 is not None  and Rules_N35_5_V['value'] == 'while' and Rules_N35_7 is not None  and Rules_N35_7_V == True):
 			# Execute rule Rules/While_True_N35
 			print('Execute rule Rules/While_True_N35')
@@ -1274,13 +1277,13 @@ class ModelverseKernel(object):
 			Rules_N35_4, = yield [('CNV', ['init'])]
 			Rules_N35_6, = yield [('CN', [])]
 			Rules_N35_10, = yield [('CNV', ['init'])]
-			Rules___1224, = yield [('CD', [Rules_N35_2, 'phase', Rules_N35_4])]
-			Rules___1228, = yield [('CD', [Rules_N35_2, 'evalstack', Rules_N35_6])]
-			Rules___1234, = yield [('CD', [Rules_N35_2, 'IP', Rules_N35_9])]
-			Rules___1236, = yield [('CD', [Rules_N35_8, 'inst', Rules_N35_5])]
-			Rules___1238, = yield [('CD', [Rules_N35_8, 'phase', Rules_N35_10])]
-			Rules___1244, = yield [('CD', [Rules_N35_8, taskname, Rules_N35_5])]
-			Rules___1246, = yield [('CD', [Rules_N35_6, 'prev', Rules_N35_8])]
+			Rules___1226, = yield [('CD', [Rules_N35_2, 'phase', Rules_N35_4])]
+			Rules___1230, = yield [('CD', [Rules_N35_2, 'evalstack', Rules_N35_6])]
+			Rules___1236, = yield [('CD', [Rules_N35_2, 'IP', Rules_N35_9])]
+			Rules___1238, = yield [('CD', [Rules_N35_8, 'inst', Rules_N35_5])]
+			Rules___1240, = yield [('CD', [Rules_N35_8, 'phase', Rules_N35_10])]
+			Rules___1246, = yield [('CD', [Rules_N35_8, taskname, Rules_N35_5])]
+			Rules___1248, = yield [('CD', [Rules_N35_6, 'prev', Rules_N35_8])]
 		else:
 			# no rules were applicable, so idle for some time
 			pass #TODO

kernel/modelverse_kernel/main_autogen.py

@@ -1,130 +0,0 @@
-import modelverse_kernel.primitives as primitive_functions
-import modelverse_kernel.compiled as compiled_functions
-from collections import defaultdict
-import sys
-import time
-
-class ModelverseKernel(object):
-    def __init__(self, root):
-        self.root = root
-        self.primitives = {}
-        self.returnvalue = None
-        self.success = True
-        self.generators = {}
-
-    def execute_yields(self, taskname, operation, params, reply):
-        try:
-            self.success = True
-            self.taskname = taskname
-            if taskname not in self.generators:
-                self.generators[taskname] = {}
-            if operation not in self.generators[taskname]:
-                # Create the generator for the function to execute
-                self.generators[taskname][operation] = getattr(self, operation)(taskname, *params)
-
-            if reply is not None:
-                return self.generators[taskname][operation].send(reply)
-            else:
-                return self.generators[taskname][operation].next()
-        except StopIteration:
-            # Done, so remove the generator
-            del self.generators[taskname][operation]
-            return None
-        except:
-            raise
-
-    ##########################
-    ### Process primitives ###
-    ##########################
-    def load_primitives(self, taskname):
-        hierarchy, =     yield [('RD', [self.root, '__hierarchy'])]
-        primitives, =    yield [('RD', [hierarchy, 'primitives'])]
-        keys, =          yield [('RDK', [primitives])]
-        function_names = yield [('RV', [f]) for f in keys]
-        signatures  =    yield [('RDN', [primitives, f]) for f in keys]
-        bodies =         yield [('RD', [f, 'body']) for f in signatures]
-        for i in range(len(keys)):
-            self.primitives[bodies[i]] = getattr(primitive_functions, function_names[i])
-
-    def execute_primitive(self, task_root, inst, taskname):
-        # execute_primitive
-        task_frame, =    yield [('RD', [task_root, 'frame'])]
-        symbols, =       yield [('RD', [task_frame, 'symbols'])]
-        all_links, =     yield [('RO', [symbols])]
-        containers =    yield [('RE', [v]) for v in all_links]
-        outgoings =     yield [('RO', [v]) for v in all_links]
-        dict_values =   yield [('RD', [v[1], 'value']) for v in containers]
-        formals_1 =     yield [('RE', [v[0]]) for v in outgoings]
-        dict_keys_ref = yield [('RD', [v[1], 'name']) for v in formals_1]
-        dict_keys =     yield [('RV', [v]) for v in dict_keys_ref]
-        parameters = dict(zip(dict_keys, dict_values))
-
-        parameters['root'] = self.root
-        parameters['task_root'] = task_root
-        parameters['taskname'] = taskname
-        parameters['mvk'] = self
-
-        # prim is a generator itself!
-        try:
-            # Forward the message we get to this generator
-            # Sometimes it might not even be a generator, in which case this should already be in the except block (i.e., for the Read Root operation)
-            prim = self.primitives[inst](**parameters)
-            inp = None
-            while 1:
-                inp = yield prim.send(inp)
-        except StopIteration:
-            # Execution has ended without return value, so we have no idea what to do
-            raise Exception('Primitive finished without returning a value!')
-        except primitive_functions.PrimitiveFinished as e:
-            # Execution has ended with a returnvalue, so read it out from the exception being thrown
-            result = e.result
-
-            #if result is None:
-            #    raise Exception('Primitive raised exception: value of None for operation %s with parameters %s' % (self.compiled[inst], str(parameters)))
-
-        # Clean up the current stack, as if a return happened
-        old_frame, =    yield [('RD', [task_frame, 'prev'])]
-        lnk, =          yield [('RDE', [old_frame, 'returnvalue'])]
-        _, _, _, _ =    yield [('CD', [old_frame, 'returnvalue', result]),
-                               ('CD', [task_root, 'frame', old_frame]),
-                               ('DE', [lnk]),
-                               ('DN', [task_frame]),
-                              ]
-
-    ########################################
-    ### Execute input and output methods ###
-    ########################################
-    def get_output(self, taskname):
-        task_root, =        yield [('RD', [self.root, taskname])]
-        first_output, =     yield [('RD', [task_root, 'output'])]
-        next_output, rv =   yield [('RD', [first_output, 'next']),
-                                   ('RD', [first_output, 'value']),
-                                  ]
-        if next_output is None:
-            self.success = False
-            self.returnvalue = None
-        else:
-            rv_value, =     yield [('RV', [rv])]
-            _, _ =          yield [('CD', [task_root, 'output', next_output]),
-                                   ('DN', [first_output]),
-                                  ]
-            self.returnvalue = rv_value
-
-    def set_input(self, taskname, value):
-        task_root, =        yield [('RD', [self.root, taskname])]
-        old_input, link =   yield [('RD', [task_root, 'last_input']),
-                                   ('RDE', [task_root, 'last_input']),
-                                  ]
-        new_input, =        yield [('CN', [])]
-        _, _ =              yield [('CD', [task_root, 'last_input', new_input]),
-                                   ('CD', [old_input, 'next', new_input]),
-                                  ]
-
-        new_value, =        yield [('CNV', [value])]
-        _, _ =              yield [('CD', [old_input, 'value', new_value]),
-                                   ('DE', [link])
-                                  ]
-        self.returnvalue = {'id': 100, 'value': 'success'}
-
-    ### Generated rules
-    def execute_rule(self, taskname):

kernel/rules/MvK_rules.mvc

@@ -311,6 +311,10 @@ Rule Break_N6 {
     Match N6_8 {}
     Create N6_9 {}
     Match N6_10 {}
+    Create N6_11 {
+        value = "'finish'"
+    }
+    Match N6_12 {}
 
     MatchEdge (N6_0, N6_1) {
         value = "taskname"
@@ -324,10 +328,7 @@ Rule Break_N6 {
     CreateEdge (N6_2, N6_4) {
         value = "'phase'"
     }
-    DeleteEdge (N6_2, N6_5) {
-        value = "'IP'"
-    }
-    CreateEdge (N6_2, N6_6) {
+    MatchEdge (N6_2, N6_5) {
         value = "'IP'"
     }
     MatchEdge (N6_5, N6_6) {
@@ -348,6 +349,9 @@ Rule Break_N6 {
     CreateEdge (N6_9, N6_8) {
         value = "'prev'"
     }
+    CreateEdge (N6_8, N6_11) {
+        value = "'phase'"
+    }
 }
 
 Rule Call_Call_None_N7 {
@@ -450,7 +454,6 @@ Rule Call_Call_Params_N8 {
     }
     Match N8_6 {
         value = "a"
-        match = True
     }
     Create N8_7 {
         value = "'finish'"

kernel/rules/to_python.alc

@@ -40,6 +40,12 @@ Boolean function main(model : Element):
 	result = result + "        self.success = True\n"
 	result = result + "        self.generators = {}\n"
 	result = result + "\n"
+    result = result + "    def set_overlap(self, lst):\n"
+    result = result + "        s = set(lst.pop())\n"
+    result = result + "        while (lst):\n"
+    result = result + "            s &= set(lst.pop())\n"
+    result = result + "        return list(s)\n"
+	result = result + "\n"
 	result = result + "    def execute_yields(self, taskname, operation, params, reply):\n"
 	result = result + "        try:\n"
 	result = result + "            self.success = True\n"
@@ -405,6 +411,8 @@ Boolean function main(model : Element):
 				result = result + "            " + string_replace(edge, "/", "_") + ", = yield [('CD', [" + string_replace(readAssociationSource(model, edge), "/", "_") + ", " + attr + ", " + string_replace(readAssociationDestination(model, edge), "/", "_") + "])]\n"
 			else:
 				result = result + "            " + string_replace(edge, "/", "_") + ", = yield [('CE', [" + string_replace(readAssociationSource(model, edge), "/", "_") + ", " + string_replace(readAssociationDestination(model, edge), "/", "_") + "])]\n"
+		
+		result = result + "            print(str(locals()))\n"
 
 	result = result + "        else:\n"
 	result = result + "            # no rules were applicable, so idle for some time\n"

wrappers/modelverse_SCCD.py

@@ -1,7 +1,7 @@
 """
 Generated by Statechart compiler by Glenn De Jonghe, Joeri Exelmans, Simon Van Mierlo, and Yentl Van Tendeloo (for the inspiration)
 
-Date:   Mon Nov 27 15:23:49 2017
+Date:   Mon Nov 27 16:06:55 2017
 
 Model author: Yentl Van Tendeloo
 Model name:   MvK Server