Fixed some more rules

kernel/modelverse_kernel/compiled.py

@@ -2,6 +2,51 @@ from modelverse_kernel.primitives import PrimitiveFinished
 import modelverse_jit.runtime as jit_runtime 
 import time
 
+def get_superclasses(a, b, **remainder):
+    model, name = a, b
+    model_dict, tm_dict, name_value = yield [("RD", [a, "model"]), 
+                                             ("RD", [a, "type_mapping"]),
+                                             ("RV", [b])]
+
+    worklist = set([name_value])
+    found = set([])
+
+    cache_value = {}
+
+    while worklist:
+        name = worklist.pop()
+        if name in found:
+            continue
+        elem, = yield [("RD", [model_dict, name])]
+        found.add(name)
+
+        # Iterate over all outgoing links
+        outgoing, = yield [("RO", [elem])]
+        outgoing = set(outgoing)
+        while (outgoing):
+            link = outgoing.pop()
+
+            # If the link is typed by "Inheritance", we add its destination
+            link_name_node, = yield [("CALL_ARGS", [reverseKeyLookup, [model_dict, link]])]
+            link_name, = yield [("RV", [link_name_node])]
+            t_edge, = yield [("RD", [tm_dict, link_name])]
+            t_edge, = yield [("RV", [t_edge])]
+            if t_edge == "Inheritance":
+                edge, = yield [("RE", [link])]
+                src, dst = edge
+                # Look up dst's name and add it
+                if dst not in cache_value:
+                    dst_name, = yield [("CALL_ARGS", [reverseKeyLookup, [model_dict, dst]])]
+                    dst_name_value, = yield [("RV", [dst_name])]
+                    cache_value[dst] = dst_name_value
+                dst_name_value = cache_value[dst]
+                worklist.add(dst_name_value)
+
+    result, = yield [("CN", [])]
+    yield [("CD", [result, i, result]) for i in found]
+
+    raise PrimitiveFinished(result)
+
 def reverseKeyLookupMulti(a, b, **remainder):
     edges, b_val, result = yield [("RO", [a]), ("RV", [b]), ("CN", [])]
     expanded_edges = yield [("RE", [i]) for i in edges]
@@ -205,51 +250,6 @@ def set_overlap(a, b, **remainder):
 
     raise PrimitiveFinished(res)
 
-def get_superclasses(a, b, **remainder):
-    model, name = a, b
-    model_dict, tm_dict, name_value = yield [("RD", [a, "model"]), 
-                                             ("RD", [a, "type_mapping"]),
-                                             ("RV", [b])]
-
-    worklist = set([name_value])
-    found = set([])
-
-    cache_value = {}
-
-    while worklist:
-        name = worklist.pop()
-        if name in found:
-            continue
-        elem, = yield [("RD", [model_dict, name])]
-        found.add(name)
-
-        # Iterate over all outgoing links
-        outgoing, = yield [("RO", [elem])]
-        outgoing = set(outgoing)
-        while (outgoing):
-            link = outgoing.pop()
-
-            # If the link is typed by "Inheritance", we add its destination
-            link_name_node, = yield [("CALL_ARGS", [reverseKeyLookup, [model_dict, link]])]
-            link_name, = yield [("RV", [link_name_node])]
-            t_edge, = yield [("RD", [tm_dict, link_name])]
-            t_edge, = yield [("RV", [t_edge])]
-            if t_edge == "Inheritance":
-                edge, = yield [("RE", [link])]
-                src, dst = edge
-                # Look up dst's name and add it
-                if dst not in cache_value:
-                    dst_name, = yield [("CALL_ARGS", [reverseKeyLookup, [model_dict, dst]])]
-                    dst_name_value, = yield [("RV", [dst_name])]
-                    cache_value[dst] = dst_name_value
-                dst_name_value = cache_value[dst]
-                worklist.add(dst_name_value)
-
-    result, = yield [("CN", [])]
-    yield [("CD", [result, i, result]) for i in found]
-
-    raise PrimitiveFinished(result)
-
 def list_pop_final(a, **remainder):
     lst, = yield [("RO", [a])]
     length = len(lst)

kernel/modelverse_kernel/generated.py

@@ -312,6 +312,7 @@ class ModelverseKernel(object):
 		Rules_N28_8, = yield [('RD', [Rules_N28_3, 'phase'])]
 		Rules_N28_8_V, = yield [('RV', [Rules_N28_8])]
 		Rules_N28_10, = yield [('RD', [Rules_N28_7, 'var'])]
+		Rules_N28_10_V, = yield [('RV', [Rules_N28_10])]
 		Rules_N28_11, = yield [('RDN', [Rules_N28_5, Rules_N28_10])]
 		Rules_N29_0 = root
 		Rules_N29_1, = yield [('RD', [Rules_N29_0, taskname])]
@@ -376,7 +377,7 @@ class ModelverseKernel(object):
 			pass
 		elif (True  and Rules_N1_1 is not None  and Rules_N1_2 is not None  and Rules_N1_3 is not None  and isinstance(Rules_N1_3_V , dict) and Rules_N1_3_V['value'] == 'access' and Rules_N1_4 is not None  and Rules_N1_4_V == 'eval'):
 			# Execute rule Rules/Access_Eval_N1
-			print('Execute rule Rules/Access_Eval_N1')
+			print('Rules/Access_Eval_N1')
 			Rules_N1_1, = yield [('RD', [Rules_N1_0, taskname])]
 			Rules_N1_2, = yield [('RD', [Rules_N1_1, 'frame'])]
 			Rules_N1_3, = yield [('RD', [Rules_N1_2, 'IP'])]
@@ -390,10 +391,9 @@ class ModelverseKernel(object):
 			Rules_N1_5, = yield [('CNV', ['finish'])]
 			Rules___16, = yield [('CD', [Rules_N1_2, 'phase', Rules_N1_5])]
 			Rules___18, = yield [('CD', [Rules_N1_2, 'returnvalue', Rules_N1_6])]
-			print(str(locals()))
 		elif (True  and Rules_N2_1 is not None  and Rules_N2_2 is not None  and Rules_N2_3 is not None  and Rules_N2_3_V == 'init' and Rules_N2_5 is not None  and isinstance(Rules_N2_5_V , dict) and Rules_N2_5_V['value'] == 'access'):
 			# Execute rule Rules/Access_Init_N2
-			print('Execute rule Rules/Access_Init_N2')
+			print('Rules/Access_Init_N2')
 			Rules_N2_1, = yield [('RD', [Rules_N2_0, taskname])]
 			Rules_N2_2, = yield [('RD', [Rules_N2_1, 'frame'])]
 			Rules_N2_3, = yield [('RD', [Rules_N2_2, 'phase'])]
@@ -411,10 +411,9 @@ class ModelverseKernel(object):
 			Rules___47, = yield [('CD', [Rules_N2_4, 'prev', Rules_N2_6])]
 			Rules___49, = yield [('CD', [Rules_N2_6, 'phase', Rules_N2_8])]
 			Rules___51, = yield [('CD', [Rules_N2_6, 'inst', Rules_N2_5])]
-			print(str(locals()))
 		elif (True  and Rules_N3_1 is not None  and Rules_N3_2 is not None  and Rules_N3_3 is not None  and isinstance(Rules_N3_3_V , dict) and Rules_N3_3_V['value'] == 'assign' and Rules_N3_4 is not None  and Rules_N3_4_V == 'assign'):
 			# Execute rule Rules/Assign_Assign_N3
-			print('Execute rule Rules/Assign_Assign_N3')
+			print('Rules/Assign_Assign_N3')
 			Rules_N3_1, = yield [('RD', [Rules_N3_0, taskname])]
 			Rules_N3_2, = yield [('RD', [Rules_N3_1, 'frame'])]
 			Rules_N3_3, = yield [('RD', [Rules_N3_2, 'IP'])]
@@ -431,10 +430,9 @@ class ModelverseKernel(object):
 			Rules_N3_5, = yield [('CNV', ['finish'])]
 			Rules___72, = yield [('CD', [Rules_N3_2, 'phase', Rules_N3_5])]
 			Rules___78, = yield [('CD', [Rules_N3_7, 'value', Rules_N3_6])]
-			print(str(locals()))
 		elif (True  and Rules_N4_1 is not None  and Rules_N4_2 is not None  and Rules_N4_3 is not None  and Rules_N4_3_V == 'init' and Rules_N4_6 is not None  and isinstance(Rules_N4_6_V , dict) and Rules_N4_6_V['value'] == 'assign'):
 			# Execute rule Rules/Assign_Init_N4
-			print('Execute rule Rules/Assign_Init_N4')
+			print('Rules/Assign_Init_N4')
 			Rules_N4_1, = yield [('RD', [Rules_N4_0, taskname])]
 			Rules_N4_2, = yield [('RD', [Rules_N4_1, 'frame'])]
 			Rules_N4_3, = yield [('RD', [Rules_N4_2, 'phase'])]
@@ -452,10 +450,9 @@ class ModelverseKernel(object):
 			Rules___105, = yield [('CD', [Rules_N4_4, 'prev', Rules_N4_5])]
 			Rules___107, = yield [('CD', [Rules_N4_5, 'inst', Rules_N4_6])]
 			Rules___109, = yield [('CD', [Rules_N4_5, 'phase', Rules_N4_7])]
-			print(str(locals()))
 		elif (True  and Rules_N5_1 is not None  and Rules_N5_2 is not None  and Rules_N5_3 is not None  and Rules_N5_3_V == 'value' and Rules_N5_4 is not None  and isinstance(Rules_N5_4_V , dict) and Rules_N5_4_V['value'] == 'assign'):
 			# Execute rule Rules/Assign_Value_N5
-			print('Execute rule Rules/Assign_Value_N5')
+			print('Rules/Assign_Value_N5')
 			Rules_N5_1, = yield [('RD', [Rules_N5_0, taskname])]
 			Rules_N5_2, = yield [('RD', [Rules_N5_1, 'frame'])]
 			Rules_N5_3, = yield [('RD', [Rules_N5_2, 'phase'])]
@@ -479,10 +476,9 @@ class ModelverseKernel(object):
 			Rules___144, = yield [('CD', [Rules_N5_5, 'prev', Rules_N5_9])]
 			Rules___146, = yield [('CD', [Rules_N5_9, 'inst', Rules_N5_4])]
 			Rules___148, = yield [('CD', [Rules_N5_9, 'phase', Rules_N5_10])]
-			print(str(locals()))
 		elif (True  and Rules_N6_1 is not None  and Rules_N6_2 is not None  and Rules_N6_3 is not None  and Rules_N6_3_V == 'init' and Rules_N6_5 is not None  and isinstance(Rules_N6_5_V , dict) and Rules_N6_5_V['value'] == 'break'):
 			# Execute rule Rules/Break_N6
-			print('Execute rule Rules/Break_N6')
+			print('Rules/Break_N6')
 			Rules_N6_1, = yield [('RD', [Rules_N6_0, taskname])]
 			Rules_N6_2, = yield [('RD', [Rules_N6_1, 'frame'])]
 			Rules_N6_3, = yield [('RD', [Rules_N6_2, 'phase'])]
@@ -508,10 +504,9 @@ class ModelverseKernel(object):
 			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])]
-			print(str(locals()))
 		elif (True  and Rules_N7_1 is not None  and Rules_N7_3 is not None  and Rules_N7_6 is not None  and isinstance(Rules_N7_6_V , dict) 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')
+			print('Rules/Call_Call_None_N7')
 			Rules_N7_1, = yield [('RD', [Rules_N7_0, taskname])]
 			Rules_N7_3, = yield [('RD', [Rules_N7_1, 'frame'])]
 			Rules_N7_3_DEL, = yield [('RDE', [Rules_N7_1, 'frame'])]
@@ -538,10 +533,9 @@ class ModelverseKernel(object):
 			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])]
-			print(str(locals()))
 		elif (True  and Rules_N8_1 is not None  and Rules_N8_3 is not None  and Rules_N8_4 is not None  and isinstance(Rules_N8_4_V , dict) and Rules_N8_4_V['value'] == 'call' and Rules_N8_5 is not None  and Rules_N8_14 is not None  and Rules_N8_14_V == 'call'):
 			# Execute rule Rules/Call_Call_Params_N8
-			print('Execute rule Rules/Call_Call_Params_N8')
+			print('Rules/Call_Call_Params_N8')
 			Rules_N8_1, = yield [('RD', [Rules_N8_0, taskname])]
 			Rules_N8_3, = yield [('RD', [Rules_N8_1, 'frame'])]
 			Rules_N8_3_DEL, = yield [('RDE', [Rules_N8_1, 'frame'])]
@@ -584,10 +578,9 @@ class ModelverseKernel(object):
 			Rules___277, = yield [('CD', [Rules_N8_10, 'value', Rules_N8_8])]
 			Rules_N8_16, = yield [('CE', [Rules_N8_15, Rules_N8_10])]
 			Rules___286, = yield [('CE', [Rules_N8_16, Rules_N8_9])]
-			print(str(locals()))
 		elif (True  and Rules_N9_1 is not None  and Rules_N9_2 is not None  and Rules_N9_14 is not None  and isinstance(Rules_N9_14_V , dict) 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')
+			print('Rules/Call_Params_First_Multi_N9')
 			Rules_N9_1, = yield [('RD', [Rules_N9_0, taskname])]
 			Rules_N9_2, = yield [('RD', [Rules_N9_1, 'frame'])]
 			Rules_N9_13, = yield [('RD', [Rules_N9_2, 'evalstack'])]
@@ -625,10 +618,9 @@ class ModelverseKernel(object):
 			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])]
-			print(str(locals()))
 		elif (True  and Rules_N10_1 is not None  and Rules_N10_2 is not None  and Rules_N10_14 is not None  and isinstance(Rules_N10_14_V , dict) 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')
+			print('Rules/Call_Params_First_Single_N10')
 			Rules_N10_1, = yield [('RD', [Rules_N10_0, taskname])]
 			Rules_N10_2, = yield [('RD', [Rules_N10_1, 'frame'])]
 			Rules_N10_10, = yield [('RD', [Rules_N10_2, 'returnvalue'])]
@@ -667,10 +659,9 @@ class ModelverseKernel(object):
 			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])]
-			print(str(locals()))
 		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 isinstance(Rules_N11_16_V , dict) and Rules_N11_16_V['value'] == 'call'):
 			# Execute rule Rules/Call_Params_Last_N11
-			print('Execute rule Rules/Call_Params_Last_N11')
+			print('Rules/Call_Params_Last_N11')
 			Rules_N11_1, = yield [('RD', [Rules_N11_0, taskname])]
 			Rules_N11_2, = yield [('RD', [Rules_N11_1, 'frame'])]
 			Rules_N11_16, = yield [('RD', [Rules_N11_2, 'IP'])]
@@ -730,10 +721,9 @@ class ModelverseKernel(object):
 			Rules___486, = yield [('CD', [Rules_N11_18, 'prev', Rules_N11_17])]
 			Rules_N11_8, = yield [('CE', [Rules_N11_20, Rules_N11_9])]
 			Rules___489, = yield [('CE', [Rules_N11_8, Rules_N11_7])]
-			print(str(locals()))
 		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 isinstance(Rules_N12_19_V , dict) and Rules_N12_19_V['value'] == 'call'):
 			# Execute rule Rules/Call_Params_Next_N12
-			print('Execute rule Rules/Call_Params_Next_N12')
+			print('Rules/Call_Params_Next_N12')
 			Rules_N12_1, = yield [('RD', [Rules_N12_0, taskname])]
 			Rules_N12_2, = yield [('RD', [Rules_N12_1, 'frame'])]
 			Rules_N12_10, = yield [('RD', [Rules_N12_2, 'returnvalue'])]
@@ -792,10 +782,9 @@ class ModelverseKernel(object):
 			Rules___557, = yield [('CD', [Rules_N12_17, 'inst', Rules_N12_19])]
 			Rules_N12_8, = yield [('CE', [Rules_N12_13, Rules_N12_9])]
 			Rules___560, = yield [('CE', [Rules_N12_8, Rules_N12_7])]
-			print(str(locals()))
 		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 isinstance(Rules_N13_6_V , dict) 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')
+			print('Rules/Call_Resolve_No_Params_N13')
 			Rules_N13_1, = yield [('RD', [Rules_N13_0, taskname])]
 			Rules_N13_2, = yield [('RD', [Rules_N13_1, 'frame'])]
 			Rules_N13_6, = yield [('RD', [Rules_N13_2, 'IP'])]
@@ -814,10 +803,9 @@ class ModelverseKernel(object):
 			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])]
-			print(str(locals()))
 		elif (True  and Rules_N14_1 is not None  and Rules_N14_2 is not None  and Rules_N14_5 is not None  and isinstance(Rules_N14_5_V , dict) and Rules_N14_5_V['value'] == 'call' and Rules_N14_7 is not None  and Rules_N14_7_V == 'init' and Rules_N14_8 is not None ):
 			# Execute rule Rules/Call_Resolve_Params_N14
-			print('Execute rule Rules/Call_Resolve_Params_N14')
+			print('Rules/Call_Resolve_Params_N14')
 			Rules_N14_1, = yield [('RD', [Rules_N14_0, taskname])]
 			Rules_N14_2, = yield [('RD', [Rules_N14_1, 'frame'])]
 			Rules_N14_3, = yield [('RD', [Rules_N14_2, 'evalstack'])]
@@ -835,10 +823,9 @@ class ModelverseKernel(object):
 			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])]
-			print(str(locals()))
 		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 isinstance(Rules_N15_6_V , dict) and Rules_N15_6_V['value'] == 'constant'):
 			# Execute rule Rules/Const_N15
-			print('Execute rule Rules/Const_N15')
+			print('Rules/Const_N15')
 			Rules_N15_1, = yield [('RD', [Rules_N15_0, taskname])]
 			Rules_N15_2, = yield [('RD', [Rules_N15_1, 'frame'])]
 			Rules_N15_3, = yield [('RD', [Rules_N15_2, 'returnvalue'])]
@@ -852,10 +839,9 @@ class ModelverseKernel(object):
 			Rules_N15_5, = yield [('CNV', ['finish'])]
 			Rules___641, = yield [('CD', [Rules_N15_2, 'returnvalue', Rules_N15_7])]
 			Rules___647, = yield [('CD', [Rules_N15_2, 'phase', Rules_N15_5])]
-			print(str(locals()))
 		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 isinstance(Rules_N16_4_V , dict) and Rules_N16_4_V['value'] == 'continue'):
 			# Execute rule Rules/Continue_N16
-			print('Execute rule Rules/Continue_N16')
+			print('Rules/Continue_N16')
 			Rules_N16_1, = yield [('RD', [Rules_N16_0, taskname])]
 			Rules_N16_2, = yield [('RD', [Rules_N16_1, 'frame'])]
 			Rules_N16_3, = yield [('RD', [Rules_N16_2, 'phase'])]
@@ -879,10 +865,9 @@ class ModelverseKernel(object):
 			Rules___670, = yield [('CD', [Rules_N16_2, 'phase', Rules_N16_10])]
 			Rules___682, = yield [('CD', [Rules_N16_2, 'evalstack', Rules_N16_8])]
 			Rules___684, = yield [('CD', [Rules_N16_8, 'prev', Rules_N16_7])]
-			print(str(locals()))
 		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 isinstance(Rules_N17_5_V , dict) and Rules_N17_5_V['value'] == 'declare'):
 			# Execute rule Rules/Declare_Init_N17
-			print('Execute rule Rules/Declare_Init_N17')
+			print('Rules/Declare_Init_N17')
 			Rules_N17_1, = yield [('RD', [Rules_N17_0, taskname])]
 			Rules_N17_2, = yield [('RD', [Rules_N17_1, 'frame'])]
 			Rules_N17_3, = yield [('RD', [Rules_N17_2, 'phase'])]
@@ -896,10 +881,9 @@ class ModelverseKernel(object):
 			Rules___701, = yield [('CD', [Rules_N17_2, 'phase', Rules_N17_4])]
 			Rules_N17_9, = yield [('CE', [Rules_N17_6, Rules_N17_8])]
 			Rules___710, = yield [('CE', [Rules_N17_9, Rules_N17_7])]
-			print(str(locals()))
 		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 isinstance(Rules_N18_6_V , dict) and Rules_N18_6_V['value'] == 'global'):
 			# Execute rule Rules/Global_Init_N18
-			print('Execute rule Rules/Global_Init_N18')
+			print('Rules/Global_Init_N18')
 			Rules_N18_1, = yield [('RD', [Rules_N18_0, taskname])]
 			Rules_N18_2, = yield [('RD', [Rules_N18_1, 'frame'])]
 			Rules_N18_3, = yield [('RD', [Rules_N18_1, 'globals'])]
@@ -913,10 +897,9 @@ class ModelverseKernel(object):
 			Rules___729, = yield [('CD', [Rules_N18_2, 'phase', Rules_N18_5])]
 			Rules_N18_9, = yield [('CE', [Rules_N18_3, Rules_N18_8])]
 			Rules___736, = yield [('CE', [Rules_N18_9, Rules_N18_7])]
-			print(str(locals()))
 		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 isinstance(Rules_N19_6_V , dict) and Rules_N19_6_V['value'] == 'if'):
 			# Execute rule Rules/If_Cond_N19
-			print('Execute rule Rules/If_Cond_N19')
+			print('Rules/If_Cond_N19')
 			Rules_N19_1, = yield [('RD', [Rules_N19_0, taskname])]
 			Rules_N19_2, = yield [('RD', [Rules_N19_1, 'frame'])]
 			Rules_N19_3, = yield [('RD', [Rules_N19_2, 'phase'])]
@@ -934,10 +917,9 @@ class ModelverseKernel(object):
 			Rules___761, = yield [('CD', [Rules_N19_4, 'prev', Rules_N19_5])]
 			Rules___763, = yield [('CD', [Rules_N19_5, 'inst', Rules_N19_6])]
 			Rules___765, = yield [('CD', [Rules_N19_5, 'phase', Rules_N19_7])]
-			print(str(locals()))
 		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 isinstance(Rules_N20_4_V , dict) 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')
+			print('Rules/If_False_Else_N20')
 			Rules_N20_1, = yield [('RD', [Rules_N20_0, taskname])]
 			Rules_N20_2, = yield [('RD', [Rules_N20_1, 'frame'])]
 			Rules_N20_3, = yield [('RD', [Rules_N20_2, 'phase'])]
@@ -960,10 +942,9 @@ class ModelverseKernel(object):
 			Rules___800, = yield [('CD', [Rules_N20_5, 'prev', Rules_N20_9])]
 			Rules___802, = yield [('CD', [Rules_N20_9, 'inst', Rules_N20_4])]
 			Rules___804, = yield [('CD', [Rules_N20_9, 'phase', Rules_N20_10])]
-			print(str(locals()))
 		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 isinstance(Rules_N21_5_V , dict) 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')
+			print('Rules/If_False_None_N21')
 			Rules_N21_1, = yield [('RD', [Rules_N21_0, taskname])]
 			Rules_N21_2, = yield [('RD', [Rules_N21_1, 'frame'])]
 			Rules_N21_5, = yield [('RD', [Rules_N21_2, 'IP'])]
@@ -974,10 +955,9 @@ class ModelverseKernel(object):
 			Rules_N21_7, = yield [('RD', [Rules_N21_5, 'else'])]
 			Rules_N21_4, = yield [('CNV', ['finish'])]
 			Rules___824, = yield [('CD', [Rules_N21_2, 'phase', Rules_N21_4])]
-			print(str(locals()))
 		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 isinstance(Rules_N22_9_V , dict) and Rules_N22_9_V['value'] == 'if'):
 			# Execute rule Rules/If_True_N22
-			print('Execute rule Rules/If_True_N22')
+			print('Rules/If_True_N22')
 			Rules_N22_1, = yield [('RD', [Rules_N22_0, taskname])]
 			Rules_N22_2, = yield [('RD', [Rules_N22_1, 'frame'])]
 			Rules_N22_3, = yield [('RD', [Rules_N22_2, 'phase'])]
@@ -1000,10 +980,9 @@ class ModelverseKernel(object):
 			Rules___857, = yield [('CD', [Rules_N22_2, 'IP', Rules_N22_8])]
 			Rules___859, = yield [('CD', [Rules_N22_7, 'inst', Rules_N22_9])]
 			Rules___861, = yield [('CD', [Rules_N22_7, 'phase', Rules_N22_10])]
-			print(str(locals()))
 		elif (True  and Rules_N23_1 is not None  and Rules_N23_2 is not None  and Rules_N23_5 is not None  and isinstance(Rules_N23_5_V , dict) 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  and Rules_N23_8 is not None ):
 			# Execute rule Rules/Input_N23
-			print('Execute rule Rules/Input_N23')
+			print('Rules/Input_N23')
 			Rules_N23_1, = yield [('RD', [Rules_N23_0, taskname])]
 			Rules_N23_2, = yield [('RD', [Rules_N23_1, 'frame'])]
 			Rules_N23_8, = yield [('RD', [Rules_N23_1, 'input'])]
@@ -1026,10 +1005,9 @@ class ModelverseKernel(object):
 			Rules___879, = yield [('CD', [Rules_N23_2, 'phase', Rules_N23_3])]
 			Rules___887, = yield [('CD', [Rules_N23_2, 'returnvalue', Rules_N23_7])]
 			Rules___895, = yield [('CD', [Rules_N23_1, 'input', Rules_N23_9])]
-			print(str(locals()))
 		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')
+			print('Rules/Next_Next_N24')
 			Rules_N24_1, = yield [('RD', [Rules_N24_0, taskname])]
 			Rules_N24_2, = yield [('RD', [Rules_N24_1, 'frame'])]
 			Rules_N24_3, = yield [('RD', [Rules_N24_2, 'phase'])]
@@ -1042,10 +1020,9 @@ class ModelverseKernel(object):
 			Rules_N24_4, = yield [('CNV', ['init'])]
 			Rules___910, = yield [('CD', [Rules_N24_2, 'phase', Rules_N24_4])]
 			Rules___914, = yield [('CD', [Rules_N24_2, 'IP', Rules_N24_6])]
-			print(str(locals()))
 		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')
+			print('Rules/Next_NoNext_N25')
 			Rules_N25_1, = yield [('RD', [Rules_N25_0, taskname])]
 			Rules_N25_2, = yield [('RD', [Rules_N25_1, 'frame'])]
 			Rules_N25_3, = yield [('RD', [Rules_N25_2, 'phase'])]
@@ -1070,10 +1047,9 @@ class ModelverseKernel(object):
 			Rules___936, = yield [('CD', [Rules_N25_2, 'IP', Rules_N25_5])]
 			Rules___940, = yield [('CD', [Rules_N25_2, 'evalstack', Rules_N25_7])]
 			Rules___942, = yield [('CD', [Rules_N25_2, 'phase', Rules_N25_8])]
-			print(str(locals()))
 		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 isinstance(Rules_N26_4_V , dict) and Rules_N26_4_V['value'] == 'output'):
 			# Execute rule Rules/Output_Init_N26
-			print('Execute rule Rules/Output_Init_N26')
+			print('Rules/Output_Init_N26')
 			Rules_N26_1, = yield [('RD', [Rules_N26_0, taskname])]
 			Rules_N26_2, = yield [('RD', [Rules_N26_1, 'frame'])]
 			Rules_N26_3, = yield [('RD', [Rules_N26_2, 'phase'])]
@@ -1091,10 +1067,9 @@ class ModelverseKernel(object):
 			Rules___975, = yield [('CD', [Rules_N26_2, 'IP', Rules_N26_7])]
 			Rules___977, = yield [('CD', [Rules_N26_6, 'inst', Rules_N26_4])]
 			Rules___979, = yield [('CD', [Rules_N26_6, 'phase', Rules_N26_8])]
-			print(str(locals()))
 		elif (True  and Rules_N27_1 is not None  and Rules_N27_2 is not None  and Rules_N27_4 is not None  and isinstance(Rules_N27_4_V , dict) 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')
+			print('Rules/Output_Output_N27')
 			Rules_N27_1, = yield [('RD', [Rules_N27_0, taskname])]
 			Rules_N27_2, = yield [('RD', [Rules_N27_1, 'frame'])]
 			Rules_N27_3, = yield [('RD', [Rules_N27_1, 'last_output'])]
@@ -1111,10 +1086,9 @@ class ModelverseKernel(object):
 			Rules___1004, = yield [('CD', [Rules_N27_3, 'value', Rules_N27_7])]
 			Rules___1006, = yield [('CD', [Rules_N27_3, 'next', Rules_N27_8])]
 			Rules___1008, = yield [('CD', [Rules_N27_1, 'last_output', Rules_N27_8])]
-			print(str(locals()))
 		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 isinstance(Rules_N28_7_V , dict) 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')
+			print('Rules/Resolve_NoAttrGlobal_N28')
 			Rules_N28_1, = yield [('RD', [Rules_N28_0, taskname])]
 			Rules_N28_2, = yield [('RD', [Rules_N28_1, 'globals'])]
 			Rules_N28_3, = yield [('RD', [Rules_N28_1, 'frame'])]
@@ -1127,15 +1101,15 @@ class ModelverseKernel(object):
 			Rules_N28_8_DEL, = yield [('RDE', [Rules_N28_3, 'phase'])]
 			yield [('DE', [Rules_N28_8_DEL])]
 			Rules_N28_10, = yield [('RD', [Rules_N28_7, 'var'])]
-			Rules_N28_9, = yield [('RDN', [Rules_N28_2, Rules_N28_10])]
+			a, = yield [('RV', [Rules_N28_10])]
+			Rules_N28_9, = yield [('RD', [Rules_N28_2, a])]
 			Rules_N28_11, = yield [('RDN', [Rules_N28_5, Rules_N28_10])]
 			Rules_N28_4, = yield [('CNV', ['finish'])]
 			Rules___1030, = yield [('CD', [Rules_N28_3, 'phase', Rules_N28_4])]
 			Rules___1040, = yield [('CD', [Rules_N28_3, 'returnvalue', Rules_N28_9])]
-			print(str(locals()))
 		elif (True  and Rules_N29_1 is not None  and Rules_N29_2 is not None  and Rules_N29_3 is not None  and isinstance(Rules_N29_3_V , dict) 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')
+			print('Rules/Resolve_NoAttr_N29')
 			Rules_N29_1, = yield [('RD', [Rules_N29_0, taskname])]
 			Rules_N29_2, = yield [('RD', [Rules_N29_1, 'frame'])]
 			Rules_N29_3, = yield [('RD', [Rules_N29_2, 'IP'])]
@@ -1149,12 +1123,11 @@ 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___1068, = yield [('CD', [Rules_N29_2, 'phase', Rules_N29_5])]
-			Rules___1072, = yield [('CD', [Rules_N29_2, 'returnvalue', Rules_N29_7])]
-			print(str(locals()))
+			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 isinstance(Rules_N30_5_V , dict) and Rules_N30_5_V['value'] == 'return'):
 			# Execute rule Rules/Return_Eval_N30
-			print('Execute rule Rules/Return_Eval_N30')
+			print('Rules/Return_Eval_N30')
 			Rules_N30_1, = yield [('RD', [Rules_N30_0, taskname])]
 			Rules_N30_2, = yield [('RD', [Rules_N30_1, 'frame'])]
 			Rules_N30_2_DEL, = yield [('RDE', [Rules_N30_1, 'frame'])]
@@ -1174,12 +1147,11 @@ 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___1093, = yield [('CD', [Rules_N30_1, 'frame', Rules_N30_3])]
-			Rules___1103, = yield [('CD', [Rules_N30_3, 'returnvalue', Rules_N30_6])]
-			print(str(locals()))
+			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 isinstance(Rules_N31_5_V , dict) 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')
+			print('Rules/Return_NoValue_N31')
 			Rules_N31_1, = yield [('RD', [Rules_N31_0, taskname])]
 			Rules_N31_2, = yield [('RD', [Rules_N31_1, 'frame'])]
 			Rules_N31_2_DEL, = yield [('RDE', [Rules_N31_1, 'frame'])]
@@ -1194,11 +1166,10 @@ 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___1118, = yield [('CD', [Rules_N31_1, 'frame', Rules_N31_3])]
-			print(str(locals()))
+			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 isinstance(Rules_N32_5_V , dict) 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')
+			print('Rules/Return_Value_N32')
 			Rules_N32_1, = yield [('RD', [Rules_N32_0, taskname])]
 			Rules_N32_2, = yield [('RD', [Rules_N32_1, 'frame'])]
 			Rules_N32_3, = yield [('RD', [Rules_N32_2, 'phase'])]
@@ -1211,15 +1182,14 @@ class ModelverseKernel(object):
 			Rules_N32_7, = yield [('RD', [Rules_N32_5, 'value'])]
 			Rules_N32_4, = yield [('CN', [])]
 			Rules_N32_8, = yield [('CNV', ['eval'])]
-			Rules___1145, = yield [('CD', [Rules_N32_2, 'evalstack', Rules_N32_4])]
-			Rules___1149, = yield [('CD', [Rules_N32_2, 'IP', Rules_N32_7])]
-			Rules___1151, = yield [('CD', [Rules_N32_4, 'prev', Rules_N32_6])]
-			Rules___1153, = yield [('CD', [Rules_N32_6, 'inst', Rules_N32_5])]
-			Rules___1155, = yield [('CD', [Rules_N32_6, 'phase', Rules_N32_8])]
-			print(str(locals()))
+			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 isinstance(Rules_N33_5_V , dict) and Rules_N33_5_V['value'] == 'while'):
 			# Execute rule Rules/While_Cond_N33
-			print('Execute rule Rules/While_Cond_N33')
+			print('Rules/While_Cond_N33')
 			Rules_N33_1, = yield [('RD', [Rules_N33_0, taskname])]
 			Rules_N33_2, = yield [('RD', [Rules_N33_1, 'frame'])]
 			Rules_N33_3, = yield [('RD', [Rules_N33_2, 'phase'])]
@@ -1232,15 +1202,14 @@ class ModelverseKernel(object):
 			Rules_N33_7, = yield [('RD', [Rules_N33_5, 'cond'])]
 			Rules_N33_4, = yield [('CN', [])]
 			Rules_N33_8, = yield [('CNV', ['cond'])]
-			Rules___1176, = yield [('CD', [Rules_N33_2, 'evalstack', Rules_N33_4])]
-			Rules___1180, = yield [('CD', [Rules_N33_2, 'IP', Rules_N33_7])]
-			Rules___1182, = yield [('CD', [Rules_N33_4, 'prev', Rules_N33_6])]
-			Rules___1184, = yield [('CD', [Rules_N33_6, 'inst', Rules_N33_5])]
-			Rules___1186, = yield [('CD', [Rules_N33_6, 'phase', Rules_N33_8])]
-			print(str(locals()))
+			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 isinstance(Rules_N34_5_V , dict) 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')
+			print('Rules/While_False_N34')
 			Rules_N34_1, = yield [('RD', [Rules_N34_0, taskname])]
 			Rules_N34_2, = yield [('RD', [Rules_N34_1, 'frame'])]
 			Rules_N34_3, = yield [('RD', [Rules_N34_2, 'phase'])]
@@ -1249,11 +1218,10 @@ 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___1203, = yield [('CD', [Rules_N34_2, 'phase', Rules_N34_4])]
-			print(str(locals()))
+			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 isinstance(Rules_N35_5_V , dict) 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')
+			print('Rules/While_True_N35')
 			Rules_N35_1, = yield [('RD', [Rules_N35_0, taskname])]
 			Rules_N35_2, = yield [('RD', [Rules_N35_1, 'frame'])]
 			Rules_N35_3, = yield [('RD', [Rules_N35_2, 'phase'])]
@@ -1273,14 +1241,13 @@ class ModelverseKernel(object):
 			Rules_N35_4, = yield [('CNV', ['init'])]
 			Rules_N35_6, = yield [('CN', [])]
 			Rules_N35_10, = yield [('CNV', ['init'])]
-			Rules___1227, = yield [('CD', [Rules_N35_2, 'phase', Rules_N35_4])]
-			Rules___1231, = yield [('CD', [Rules_N35_2, 'evalstack', Rules_N35_6])]
-			Rules___1237, = yield [('CD', [Rules_N35_2, 'IP', Rules_N35_9])]
-			Rules___1239, = yield [('CD', [Rules_N35_8, 'inst', Rules_N35_5])]
-			Rules___1241, = yield [('CD', [Rules_N35_8, 'phase', Rules_N35_10])]
-			Rules___1247, = yield [('CD', [Rules_N35_8, taskname, Rules_N35_5])]
-			Rules___1249, = yield [('CD', [Rules_N35_6, 'prev', Rules_N35_8])]
-			print(str(locals()))
+			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:
 			task_root, = yield [('RD', [root, taskname])]
 			task_frame, = yield [('RD', [task_root, 'frame'])]
@@ -1289,7 +1256,7 @@ class ModelverseKernel(object):
 			task_phase, = yield [('RV', [task_phase])]
 			if (task_IP is not None and task_IP in self.primitives and task_phase == 'init'):
 				# Execute a primitive!
-				print('Executing primitive!')
+				print('Executing primitive: ' + str(self.primitives[task_IP]))
 				symbols, =	   yield [('RD', [task_frame, 'symbols'])]
 				all_links, =	 yield [('RO', [symbols])]
 				containers =	yield [('RE', [v]) for v in all_links]
@@ -1331,3 +1298,4 @@ class ModelverseKernel(object):
 			else:
 				# no rules were applicable, so idle for some time
 				pass #TODO
+				print('no applicable rule...')

kernel/rules/MvK_rules.mvc

@@ -1860,6 +1860,7 @@ Rule Resolve_NoAttrGlobal_N28 {
     }
     Match N28_9 {}
     Match N28_10 {
+        value = "a"
         match = True
     }
     NAC N28_11 {
@@ -1893,8 +1894,9 @@ Rule Resolve_NoAttrGlobal_N28 {
     CreateEdge (N28_3, N28_9) {
         value = "'returnvalue'"
     }
-    MatchEdge N28_13 (N28_2, N28_9) {}
-    MatchEdge (N28_13, N28_10) {}
+    MatchEdge (N28_2, N28_9) {
+        value = "a"
+    }
     MatchEdge (N28_7, N28_10) {
         value = "'var'"
     }

kernel/rules/to_python.alc

@@ -212,12 +212,12 @@ Boolean function main(model : Element):
 
 					if (string_get(value, 0) == "!"):
 						result = result + " and isinstance(" + string_replace(node, "/", "_") + "_V , dict) and " + string_replace(node, "/", "_") + "_V['value'] " + sign + " '" + string_replace(value, "!", "") + "'"
-					else:
+					elif (bool_or(bool_or(string_get(value, 0) == "'", string_get(value, 0) == "!"), bool_or(value == "True", value == "False"))):
 						result = result + " and " + string_replace(node, "/", "_") + "_V " + sign + " " + value
 
 		result = result + "):\n"
 		result = result + "            # Execute rule " + rule + "\n"
-		result = result + "            print('Execute rule " + rule + "')\n"
+		result = result + "            print('" + rule + "')\n"
 
 		// We know all the nodes that we already have (in variable "explored")
 		// Still have to match all "match" and "delete" elements
@@ -367,8 +367,6 @@ Boolean function main(model : Element):
 			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 + "            task_root, = yield [('RD', [root, taskname])]\n"
 	result = result + "            task_frame, = yield [('RD', [task_root, 'frame'])]\n"
@@ -419,6 +417,7 @@ Boolean function main(model : Element):
 	result = result + "            else:\n"
 	result = result + "                # no rules were applicable, so idle for some time\n"
 	result = result + "                pass #TODO\n"
+	result = result + "                print('no applicable rule...')\n"
 
 	log("Got result:")
 	log(result)

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:   Tue Nov 28 09:52:44 2017
+Date:   Tue Nov 28 14:40:39 2017
 
 Model author: Yentl Van Tendeloo
 Model name:   MvK Server