Update to use RETURN instead of PrimitiveFinished, but broke everything

kernel/modelverse_kernel/compiled.py

@@ -49,7 +49,8 @@ def get_superclasses(a, b, **remainder):
     result, = yield [("CN", [])]
     yield [("CD", [result, i, result]) for i in found]
 
-    raise PrimitiveFinished({'id': result})
+    #raise PrimitiveFinished({'id': result})
+    yield [("RETURN", [{'id': result}])]
 
 def reverseKeyLookupMulti(a, b, **remainder):
     if "value" not in b:
@@ -70,7 +71,8 @@ def reverseKeyLookupMulti(a, b, **remainder):
     edges = yield [("CE", [result, result]) for value in values]
     yield [("CE", [edge, value[1]]) for edge, value in zip(edges, values)]
 
-    raise PrimitiveFinished({'id': result})
+    #raise PrimitiveFinished({'id': result})
+    yield [("RETURN", [{'id': result}])]
 
 def reverseKeyLookup(a, b, **remainder):
     edges_out, edges_in = yield [("RO", [a['id']]), ("RI", [b['id']])]
@@ -82,9 +84,11 @@ def reverseKeyLookup(a, b, **remainder):
         # Select one option randomly
         out_edge = out_edges.pop()
         e, = yield [("RE", [out_edge])]
-        raise PrimitiveFinished({'id': e[1]})
+        #raise PrimitiveFinished({'id': e[1]})
+        yield [("RETURN", [{'id': e[1]}])]
     else:
-        raise PrimitiveFinished({'value': ""})
+        #raise PrimitiveFinished({'value': ""})
+        yield [("RETURN", [{'value': ""}])]
 
 def instantiated_name(a, b, **remainder):
     if "id" not in a:
@@ -93,30 +97,36 @@ def instantiated_name(a, b, **remainder):
         b['value'], = yield [("RV", [b["id"]])]
 
     if b['value'] == "":
-        raise PrimitiveFinished({'value': "__" + str(a['id'])})
+        #raise PrimitiveFinished({'value': "__" + str(a['id'])})
+        yield [("RETURN", [{'value': "__" + str(a['id'])}])]
     else:
-        raise PrimitiveFinished(b)
+        #raise PrimitiveFinished(b)
+        yield [("RETURN", [b])]
 
 def set_merge(a, b, **remainder):
     keys, =         yield [("RDK", [b['id']])]
     edges =         yield [("CE", [a['id'], a['id']]) for key in keys]
     _ =             yield [("CE", [edge, key]) for edge, key in zip(edges, keys)]
-    raise PrimitiveFinished(a)
+    #raise PrimitiveFinished(a)
+    yield [("RETURN", [a])]
 
 def has_value(a, **remainder):
     if "value" not in a:
         a['value'], = yield [("RV", [a['id']])]
     if a['value'] is None:
-        raise PrimitiveFinished({'value': False})
+        #raise PrimitiveFinished({'value': False})
+        yield [("RETURN", [{'value': False}])]
     else:
-        raise PrimitiveFinished({'value': True})
+        #raise PrimitiveFinished({'value': True})
+        yield [("RETURN", [{'value': True}])]
 
 def make_reverse_dictionary(a, **remainder):
     reverse, = yield [("CN", [])]
     key_nodes, = yield [("RDK", [a['id']])]
     values = yield [("RDN", [a['id'], i]) for i in key_nodes]
     yield [("CD", [reverse, str(v), k]) for k, v in zip(key_nodes, values)]
-    raise PrimitiveFinished({'id': reverse})
+    #raise PrimitiveFinished({'id': reverse})
+    yield [("RETURN", [{'id': reverse}])]
 
 def dict_eq(a, b, **remainder):
     key_nodes, = yield [("RDK", [a['id']])]
@@ -131,7 +141,8 @@ def dict_eq(a, b, **remainder):
     values = yield [("RV", [i]) for i in values]
     b_dict = dict(list(zip(key_values, values)))
 
-    raise PrimitiveFinished({'value': a_dict == b_dict})
+    #raise PrimitiveFinished({'value': a_dict == b_dict})
+    yield [("RETURN", [{'value': a_dict == b_dict}])]
 
 def string_substr(a, b, c, **remainder):
     if "value" not in a:
@@ -146,51 +157,60 @@ def string_substr(a, b, c, **remainder):
     except:
         new_value = ""
     
-    raise PrimitiveFinished({'value': new_value})
+    #raise PrimitiveFinished({'value': new_value})
+    yield [("RETURN", [{'value': new_value}])]
 
 def integer_gt(a, b, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
     if 'value' not in b:
         b['value'], = yield [("RV", [b['id']])]
-    raise PrimitiveFinished({'value': a['value'] > b['value']})
+    #raise PrimitiveFinished({'value': a['value'] > b['value']})
+    yield [("RETURN", [{'value': a['value'] > b['value']}])]
 
 def integer_neg(a, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
-    raise PrimitiveFinished({'value': -a['value']})
+    #raise PrimitiveFinished({'value': -a['value']})
+    yield [("RETURN", [{'value': -a['value']}])]
 
 def float_gt(a, b, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
     if 'value' not in b:
         b['value'], = yield [("RV", [b['id']])]
-    raise PrimitiveFinished({'value': a['value'] > b['value']})
+    #raise PrimitiveFinished({'value': a['value'] > b['value']})
+    yield [("RETURN", [{'value': a['value'] > b['value']}])]
 
 def float_neg(a, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
-    raise PrimitiveFinished({'value': -a['value']})
+    #raise PrimitiveFinished({'value': -a['value']})
+    yield [("RETURN", [{'value': -a['value']}])]
 
 def value_neq(a, b, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
     if 'value' not in b:
         b['value'], = yield [("RV", [b['id']])]
-    raise PrimitiveFinished({'value': a['value'] != b['value']})
+    #raise PrimitiveFinished({'value': a['value'] != b['value']})
+    yield [("RETURN", [{'value': a['value'] != b['value']}])]
 
 def element_neq(a, b, **remainder):
     if 'id' not in a or 'id' not in b:
-        raise PrimitiveFinished({'value': False})
+        #raise PrimitiveFinished({'value': False})
+        yield [("RETURN", [{'value': False}])]
     else:
-        raise PrimitiveFinished({'value': a['id'] != b['id']})
+        #raise PrimitiveFinished({'value': a['id'] != b['id']})
+        yield [("RETURN", [{'value': a['value'] != b['value']}])]
 
 def list_append(a, b, **remainder):
     if "id" not in b:
         b['id'], = yield [("CNV", [b['value']])]
     a_outgoing, = yield [("RO", [a['id']])]
     _ = yield [("CD", [a['id'], len(a_outgoing), b['id']])]
-    raise PrimitiveFinished(a)
+    #raise PrimitiveFinished(a)
+    yield [("RETURN", [a])]
 
 def list_read(a, b, **remainder):
     if 'value' not in b:
@@ -198,12 +218,14 @@ def list_read(a, b, **remainder):
     result, = yield [("RD", [a['id'], b['value']])]
     if result is None:
         raise Exception("List read out of bounds: %s" % b['value'])
-    raise PrimitiveFinished({'id': result})
+    #raise PrimitiveFinished({'id': result})
+    yield [("RETURN", [{'id': result}])]
 
 def list_len(a, **remainder):
     outgoings, = yield [("RO", [a['id']])]
     result, = yield [("CNV", [len(outgoings)])]
-    raise PrimitiveFinished({'id': result})
+    #raise PrimitiveFinished({'id': result})
+    yield [("RETURN", [{'id': result}])]
 
 def dict_add(a, b, c, **remainder):
     if 'id' not in b:
@@ -212,11 +234,13 @@ def dict_add(a, b, c, **remainder):
         c['id'], = yield [("CNV", [c['value']])]
     new_edge, = yield [("CE", [a['id'], c['id']])]
     yield [("CE", [new_edge, b['id']])]
-    raise PrimitiveFinished(a)
+    #raise PrimitiveFinished(a)
+    yield [("RETURN", [a])]
 
 def dict_len(a, **remainder):
     outgoings, = yield [("RO", [a['id']])]
-    raise PrimitiveFinished({'value': len(outgoings)})
+    #raise PrimitiveFinished({'value': len(outgoings)})
+    yield [("RETURN", [{'value': len(outgoing)}])]
 
 def set_add(a, b, **remainder):
     if 'value' not in b:
@@ -224,7 +248,8 @@ def set_add(a, b, **remainder):
     is_in, =    yield [("RD", [a['id'], b['value']])]
     if not is_in:
         _, =    yield [("CD", [a['id'], b['value'], a['id']])]
-    raise PrimitiveFinished(a)
+    #raise PrimitiveFinished(a)
+    yield [("RETURN", [a])]
 
 def set_add_node(a, b, **remainder):
     if 'id' not in b:
@@ -233,7 +258,8 @@ def set_add_node(a, b, **remainder):
     if not is_in:
         edge, = yield [("CE", [a['id'], a['id']])]
         _, =    yield [("CE", [edge, b['id']])]
-    raise PrimitiveFinished(a)
+    #raise PrimitiveFinished(a)
+    yield [("RETURN", [a])]
 
 def set_pop(a, **remainder):
     outgoing, = yield [("RO", [a['id']])]
@@ -242,23 +268,28 @@ def set_pop(a, **remainder):
         new_outgoing, = yield [("RO", [outgoing])]
         new_outgoing = new_outgoing[0]
         edge, _ = yield [("RE", [new_outgoing]), ("DE", [outgoing])]
-        raise PrimitiveFinished({'id': edge[1]})
+        #raise PrimitiveFinished({'id': edge[1]})
+        yield [("RETURN", [{'id': edge[1]}])]
     else:
         raise Exception("POP from empty set")
         print("Pop from empty set!")
-        raise PrimitiveFinished({'id': remainder["root"]})
+        #raise PrimitiveFinished({'id': remainder["root"]})
+        yield [("RETURN", [{'id': remainder["root"]}])]
 
 def set_create(**remainder):
     result, = yield [("CN", [])]
-    raise PrimitiveFinished({'id': result})
+    #raise PrimitiveFinished({'id': result})
+    yield [("RETURN", [{'id': result}])]
 
 def list_create(**remainder):
     result, = yield [("CN", [])]
-    raise PrimitiveFinished({'id': result})
+    #raise PrimitiveFinished({'id': result})
+    yield [("RETURN", [{'id': result}])]
 
 def dict_create(**remainder):
     result, = yield [("CN", [])]
-    raise PrimitiveFinished({'id': result})
+    #raise PrimitiveFinished({'id': result})
+    yield [("RETURN", [{'id': result}])]
 
 def create_tuple(a, b, **remainder):
     if "id" not in a:
@@ -270,7 +301,8 @@ def create_tuple(a, b, **remainder):
     _, _ =    yield [("CD", [result, 0, a['id']]),
                      ("CD", [result, 1, b['id']]),
                     ]
-    raise PrimitiveFinished({'id': result})
+    #raise PrimitiveFinished({'id': result})
+    yield [("RETURN", [{'id': result}])]
 
 def set_overlap(a, b, **remainder):
     a_keys, b_keys, res = yield [("RDK", [a['id']]), ("RDK", [b['id']]), ("CN", [])]
@@ -280,7 +312,8 @@ def set_overlap(a, b, **remainder):
     result = set(a_values) & set(b_values)
     yield [("CD", [res, value, res]) for value in result]
 
-    raise PrimitiveFinished({'id': res})
+    #raise PrimitiveFinished({'id': res})
+    yield [("RETURN", [{'id': res}])]
 
 def list_pop_final(a, **remainder):
     lst, = yield [("RO", [a['id']])]
@@ -288,7 +321,8 @@ def list_pop_final(a, **remainder):
     result, result_edge = yield [("RD", [a['id'], length - 1]),
                                  ("RDE", [a['id'], length -1])]
     _, = yield [("DE", [result_edge])]
-    raise PrimitiveFinished({'id': result})
+    #raise PrimitiveFinished({'id': result})
+    yield [("RETURN", [{'id': result}])]
 
 def instantiate_node(a, b, c, **remainder):
     if "value" not in c:
@@ -312,7 +346,8 @@ def instantiate_node(a, b, c, **remainder):
     yield [("CD", [dict_entry, name, node])]
     yield [("CD", [typing, name, b['id']])]
 
-    raise PrimitiveFinished(name_node)
+    #raise PrimitiveFinished(name_node)
+    yield [("RETURN", [name_node])]
 
 def list_insert(a, b, c, **remainder):
     if "id" not in b:
@@ -330,7 +365,8 @@ def list_insert(a, b, c, **remainder):
     yield [("CD", [a['id'], c['value'], b['id']])] + \
           [("CD", [a['id'], c['value'] + 1 + index, value]) for index, value in enumerate(values)] + \
           [("DE", [i]) for i in edges]
-    raise PrimitiveFinished(a)
+    #raise PrimitiveFinished(a)
+    yield [("RETURN", [a])]
 
 def list_delete(a, b, **remainder):
     if "value" not in b:
@@ -345,4 +381,5 @@ def list_delete(a, b, **remainder):
 
     yield [("CD", [a['id'], b['value'] + index, value]) for index, value in enumerate(values[1:])] + \
           [("DE", [i]) for i in edges]
-    raise PrimitiveFinished(a)
+    #raise PrimitiveFinished(a)
+    yield [("RETURN", [a])]

kernel/modelverse_kernel/jit.py

@@ -155,7 +155,8 @@ class ModelverseJit(object):
                 param_names = [i[0] for i in lst]
                 self.jitted_parameters[body_id] = (param_vars, param_names, is_mutable)
 
-        raise primitive_functions.PrimitiveFinished(self.jitted_parameters[body_id])
+        #raise primitive_functions.PrimitiveFinished(self.jitted_parameters[body_id])
+        yield [("RETURN", [self.jitted_parameters[body_id]])]
 
     def check_jittable(self, body_id, suggested_name=None):
         """Checks if the function with the given body id is obviously non-jittable. If it's

kernel/modelverse_kernel/main.py

@@ -169,9 +169,11 @@ class ModelverseKernel(object):
             value, = yield [("RD", [inst, "value"])]
             if value:
                 (prev_value, instruction_value), = yield [("CALL_ARGS", [self.print_instruction, (value, 0, indent)])]
-                instruction = prev_value + "  " * indent + "raise PrimitiveFinished(%s)\n" % instruction_value
+                #instruction = prev_value + "  " * indent + "raise PrimitiveFinished(%s)\n" % instruction_value
+                instruction = prev_value + "  " * indent + "yield [('RETURN', [%s])]\n" % instruction_value
             else:
-                instruction = "  " * indent + "raise PrimitiveFinished(None)\n"
+                #instruction = "  " * indent + "raise PrimitiveFinished(None)\n"
+                instruction = "  " * indent + "yield [('RETURN', [None])]\n"
 
         elif inst_type["value"] == "declare":
             instruction = ""
@@ -318,7 +320,8 @@ class ModelverseKernel(object):
         else:
             next_inst = ""
 
-        raise primitive_functions.PrimitiveFinished((prev, instruction + next_inst))
+        #raise primitive_functions.PrimitiveFinished((prev, instruction + next_inst))
+        yield [('RETURN', [(prev, instruction + next_inst)])]
 
     def read_function(self, inst, suggested_name):
         initial_instruction = inst
@@ -347,7 +350,8 @@ class ModelverseKernel(object):
         with open('/tmp/junk/%s' % suggested_name, 'w') as f:
             f.write(func)
 
-        raise primitive_functions.PrimitiveFinished(func)
+        #raise primitive_functions.PrimitiveFinished(func)
+        yield [("RETURN", [func])]
 
     def jit_compile(self, task_root, inst):
         # Try to retrieve the suggested name.
@@ -359,8 +363,8 @@ class ModelverseKernel(object):
             raise ValueError('body_id cannot be None: ' + str(suggested_name))
 
         elif inst in self.jit.jitted_entry_points:
-            raise primitive_functions.PrimitiveFinished(
-                self.jit.jit_globals[self.jit.jitted_entry_points[inst]])
+            #raise primitive_functions.PrimitiveFinished(self.jit.jit_globals[self.jit.jitted_entry_points[inst]])
+            yield [("RETURN", [self.jit.jit_globals[self.jit.jitted_entry_points[inst]]])]
         else:
             compiled_func = self.jit.lookup_compiled_body(inst)
 
@@ -373,7 +377,8 @@ class ModelverseKernel(object):
                 compiled_func = self.jit.jit_globals[suggested_name]
                 self.jit.register_compiled(inst, compiled_func, suggested_name)
 
-            raise primitive_functions.PrimitiveFinished(compiled_func)
+            #raise primitive_functions.PrimitiveFinished(compiled_func)
+            yield [("RETURN", [compiled_func])]
 
     def execute_jit(self, task_root, inst, taskname, params = {}, store=False, resolve=True):
         # execute_jit
@@ -457,7 +462,8 @@ class ModelverseKernel(object):
                                       ]
 
         else:
-            raise primitive_functions.PrimitiveFinished(result)
+            #raise primitive_functions.PrimitiveFinished(result)
+            yield [("RETURN", [result])]
 
     ########################################
     ### Execute input and output methods ###

kernel/modelverse_kernel/primitives.py

@@ -46,96 +46,110 @@ def integer_subtraction(a, b, **remainder):
         a['value'], = yield [("RV", [a['id']])]
     if 'value' not in b:
         b['value'], = yield [("RV", [b['id']])]
-    raise PrimitiveFinished({'value': a['value'] - b['value']})
+    #raise PrimitiveFinished({'value': a['value'] - b['value']})
+    yield [("RETURN", [{'value': a['value'] - b['value']}])]
 
 def integer_addition(a, b, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
     if 'value' not in b:
         b['value'], = yield [("RV", [b['id']])]
-    raise PrimitiveFinished({'value': a['value'] + b['value']})
+    #raise PrimitiveFinished({'value': a['value'] + b['value']})
+    yield [("RETURN", [{'value': a['value'] + b['value']}])]
 
 def integer_multiplication(a, b, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
     if 'value' not in b:
         b['value'], = yield [("RV", [b['id']])]
-    raise PrimitiveFinished({'value': a['value'] * b['value']})
+    #raise PrimitiveFinished({'value': a['value'] * b['value']})
+    yield [("RETURN", [{'value': a['value'] * b['value']}])]
 
 def integer_division(a, b, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
     if 'value' not in b:
         b['value'], = yield [("RV", [b['id']])]
-    raise PrimitiveFinished({'value': int(a['value']) // b['value']})
+    #raise PrimitiveFinished({'value': int(a['value']) // b['value']})
+    yield [("RETURN", [{'value': int(a['value']) // b['value']}])]
 
 def integer_lt(a, b, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
     if 'value' not in b:
         b['value'], = yield [("RV", [b['id']])]
-    raise PrimitiveFinished({'value': a['value'] < b['value']})
+    #raise PrimitiveFinished({'value': a['value'] < b['value']})
+    yield [("RETURN", [{'value': a['value'] < b['value']}])]
 
 def bool_and(a, b, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
     if 'value' not in b:
         b['value'], = yield [("RV", [b['id']])]
-    raise PrimitiveFinished({'value': a['value'] and b['value']})
+    #raise PrimitiveFinished({'value': a['value'] and b['value']})
+    yield [("RETURN", [{'value': a['value'] and b['value']}])]
 
 def bool_or(a, b, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
     if 'value' not in b:
         b['value'], = yield [("RV", [b['id']])]
-    raise PrimitiveFinished({'value': a['value'] or b['value']})
+    #raise PrimitiveFinished({'value': a['value'] or b['value']})
+    yield [("RETURN", [{'value': a['value'] or b['value']}])]
 
 def bool_not(a, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
-    raise PrimitiveFinished({'value': not a['value']})
+    #raise PrimitiveFinished({'value': not a['value']})
+    yield [("RETURN", [{'value': not a['value']}])]
 
 def float_subtraction(a, b, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
     if 'value' not in b:
         b['value'], = yield [("RV", [b['id']])]
-    raise PrimitiveFinished({'value': a['value'] - b['value']})
+    #raise PrimitiveFinished({'value': a['value'] - b['value']})
+    yield [("RETURN", [{'value': a['value'] - b['value']}])]
 
 def float_addition(a, b, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
     if 'value' not in b:
         b['value'], = yield [("RV", [b['id']])]
-    raise PrimitiveFinished({'value': a['value'] + b['value']})
+    #raise PrimitiveFinished({'value': a['value'] + b['value']})
+    yield [("RETURN", [{'value': a['value'] + b['value']}])]
 
 def float_multiplication(a, b, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
     if 'value' not in b:
         b['value'], = yield [("RV", [b['id']])]
-    raise PrimitiveFinished({'value': a['value'] * b['value']})
+    #raise PrimitiveFinished({'value': a['value'] * b['value']})
+    yield [("RETURN", [{'value': a['value'] * b['value']}])]
 
 def float_division(a, b, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
     if 'value' not in b:
         b['value'], = yield [("RV", [b['id']])]
-    raise PrimitiveFinished({'value': float(a['value']) / float(b['value'])})
+    #raise PrimitiveFinished({'value': float(a['value']) / float(b['value'])})
+    yield [("RETURN", [{'value': float(a['value']) / b['value']}])]
 
 def float_lt(a, b, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
     if 'value' not in b:
         b['value'], = yield [("RV", [b['id']])]
-    raise PrimitiveFinished({'value': a['value'] < b['value']})
+    #raise PrimitiveFinished({'value': a['value'] < b['value']})
+    yield [("RETURN", [{'value': a['value'] < b['value']}])]
 
 def string_join(a, b, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
     if 'value' not in b:
         b['value'], = yield [("RV", [b['id']])]
-    raise PrimitiveFinished({'value': str(a['value']) + str(b['value'])})
+    #raise PrimitiveFinished({'value': str(a['value']) + str(b['value'])})
+    yield [("RETURN", [{'value': str(a['value']) + str(b['value'])}])]
 
 def string_split(a, b, **remainder):
     # TODO make non-primitive, though compiled
@@ -147,26 +161,30 @@ def string_split(a, b, **remainder):
     elems = yield [("CN", [])] + [("CNV", [v]) for v in result]
     new_val = elems[0]
     yield [("CD", [new_val, i, v]) for i, v in enumerate(elems[1:])]
-    raise PrimitiveFinished({'id': new_val})
+    #raise PrimitiveFinished({'id': new_val})
+    yield [("RETURN", [{'id': new_val}])]
 
 def string_get(a, b, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
     if 'value' not in b:
         b['value'], = yield [("RV", [b['id']])]
-    raise PrimitiveFinished({'value': a['value'][b['value']]})
+    #raise PrimitiveFinished({'value': a['value'][b['value']]})
+    yield [("RETURN", [{'value': a['value'][b['value']]}])]
 
 def string_len(a, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
-    raise PrimitiveFinished({'value': len(a['value'])})
+    #raise PrimitiveFinished({'value': len(a['value'])})
+    yield [("RETURN", [{'value': len(a['value'])}])]
 
 def value_eq(a, b, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
     if 'value' not in b:
         b['value'], = yield [("RV", [b['id']])]
-    raise PrimitiveFinished({'value': a['value'] == b['value']})
+    #raise PrimitiveFinished({'value': a['value'] == b['value']})
+    yield [("RETURN", [{'value': a['value'] == b['value']}])]
 
 def element_eq(a, b, **remainder):
     if "id" not in a:
@@ -175,44 +193,53 @@ def element_eq(a, b, **remainder):
     if "id" not in b:
         #print("MATERIALIZING B element_eq")
         b['id'], = yield [("CNV", [b['value']])]
-    raise PrimitiveFinished({'value': a['id'] == b['id']})
+    #raise PrimitiveFinished({'value': a['id'] == b['id']})
+    yield [("RETURN", [{'value': a['id'] == b['id']}])]
 
 def cast_string(a, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
     if isinstance(a['value'], dict):
-        raise PrimitiveFinished({'value': str(a['value']['value'])})
+        #raise PrimitiveFinished({'value': str(a['value']['value'])})
+        yield [("RETURN", [{'value': str(a['value']['value'])}])]
     else:
-        raise PrimitiveFinished({'value': str(a['value'])})
+        #raise PrimitiveFinished({'value': str(a['value'])})
+        yield [("RETURN", [{'value': str(a['value'])}])]
 
 def cast_float(a, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
-    raise PrimitiveFinished({'value': float(a['value'])})
+    #raise PrimitiveFinished({'value': float(a['value'])})
+    yield [("RETURN", [{'value': float(a['value'])}])]
 
 def cast_boolean(a, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
-    raise PrimitiveFinished({'value': bool(a['value'])})
+    #raise PrimitiveFinished({'value': bool(a['value'])})
+    yield [("RETURN", [{'value': bool(a['value'])}])]
 
 def cast_integer(a, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
-    raise PrimitiveFinished({'value': int(a['value'])})
+    #raise PrimitiveFinished({'value': int(a['value'])})
+    yield [("RETURN", [{'value': int(a['value'])}])]
 
 def cast_value(a, **remainder):
     if 'value' not in a:
         a['value'], = yield [("RV", [a['id']])]
     if isinstance(a['value'], dict):
-        raise PrimitiveFinished({'value': str(a['value']['value'])})
+        #raise PrimitiveFinished({'value': str(a['value']['value'])})
+        yield [("RETURN", [{'value': str(a['value']['value'])}])]
     else:
-        raise PrimitiveFinished({'value': json.dumps(a['value'])})
+        #raise PrimitiveFinished({'value': json.dumps(a['value'])})
+        yield [("RETURN", [{'value': json.dumps(a['value'])}])]
 
 def cast_id(a, **remainder):
     if "id" not in a:
         #print("MATERIALIZING A cast_id")
         a['id'], = yield [("CNV", [a['value']])]
-    raise PrimitiveFinished({'value': str(a['id'])})
+    #raise PrimitiveFinished({'value': str(a['id'])})
+    yield [("RETURN", [{'value': str(a['id'])}])]
 
 def dict_add_fast(a, b, c, **remainder):
     # TODO deprecate, as dict_add is now also efficient
@@ -223,7 +250,8 @@ def dict_add_fast(a, b, c, **remainder):
         c['id'], = yield [("CNV", [c['value']])]
 
     yield [("CD", [a['id'], b['value'], c['id']])]
-    raise PrimitiveFinished(a)
+    #raise PrimitiveFinished(a)
+    yield [("RETURN", [a])]
 
 def dict_delete(a, b, **remainder):
     if "value" not in b:
@@ -237,89 +265,107 @@ def dict_delete(a, b, **remainder):
         print("Keys: " + str(keys))
         raise Exception()
     yield [("DE", [edge])]
-    raise PrimitiveFinished(a)
+    #raise PrimitiveFinished(a)
+    yield [("RETURN", [a])]
 
 def dict_delete_node(a, b, **remainder):
     edge, = yield [("RDNE", [a['id'], b['id']])]
     if edge is None:
         print("Failed dict_delete_node!")
     yield [("DE", [edge])]
-    raise PrimitiveFinished(a)
+    #raise PrimitiveFinished(a)
+    yield [("RETURN", [a])]
 
 def dict_read(a, b, **remainder):
     if "value" not in b:
         b['value'], = yield [("RV", [b['id']])]
     result, = yield [("RD", [a['id'], b['value']])]
-    raise PrimitiveFinished({'id': result})
+    #raise PrimitiveFinished({'id': result})
+    yield [("RETURN", [{'id': result}])]
 
 def dict_read_edge(a, b, **remainder):
     if "value" not in b:
         b['value'], = yield [("RV", [b['id']])]
     result, = yield [("RDE", [a['id'], b['value']])]
-    raise PrimitiveFinished({'id': result})
+    #raise PrimitiveFinished({'id': result})
+    yield [("RETURN", [{'id': result}])]
 
 def dict_read_node(a, b, **remainder):
     result, = yield [("RDN", [a['id'], b['id']])]
-    raise PrimitiveFinished({'id': result})
+    #raise PrimitiveFinished({'id': result})
+    yield [("RETURN", [{'id': result}])]
 
 def dict_in(a, b, **remainder):
     if "value" not in b:
         b['value'], = yield [("RV", [b['id']])]
     value, = yield [("RD", [a['id'], b['value']])]
-    raise PrimitiveFinished({'value': value is not None})
+    #raise PrimitiveFinished({'value': value is not None})
+    yield [("RETURN", [{'value': value is not None}])]
 
 def dict_in_node(a, b, **remainder):
     if "id" not in b:
         # Not even allocated the node, so it is certain not to be in the dictionary
-        raise PrimitiveFinished({'value': False})
+        #raise PrimitiveFinished({'value': False})
+        yield [("RETURN", [{'value': False}])]
     value, = yield [("RDN", [a['id'], b['id']])]
-    raise PrimitiveFinished({'value': value is not None})
+    #raise PrimitiveFinished({'value': value is not None})
+    yield [("RETURN", [{'value': value is not None}])]
 
 def dict_keys(a, **remainder):
     keys, result = yield [("RDK", [a['id']]), ("CN", [])]
     edges = yield [("CE", [result, result]) for _ in keys]
     _ = yield [("CE", [edge, key]) for edge, key in zip(edges, keys)]
-    raise PrimitiveFinished({'id': result})
+    #raise PrimitiveFinished({'id': result})
+    yield [("RETURN", [{'id': result}])]
 
 def is_physical_int(a, **remainder):
     if "value" not in a:
         a['value'], = yield [("RV", [a['id']])]
     try:
-        raise PrimitiveFinished({'value': isinstance(a['value'], int) or isinstance(a['value'], long)})
+        #raise PrimitiveFinished({'value': isinstance(a['value'], int) or isinstance(a['value'], long)})
+        yield [("RETURN", [{'value': isinstance(a['value'], int) or isinstance(a['value'], long)}])]
     except NameError:
-        raise PrimitiveFinished({'value': isinstance(a['value'], int)})
+        #raise PrimitiveFinished({'value': isinstance(a['value'], int)})
+        yield [("RETURN", [{'value': isinstance(a['value'], int)}])]
 
 def is_physical_string(a, **remainder):
     if "value" not in a:
         a['value'], = yield [("RV", [a['id']])]
     try:
-        raise PrimitiveFinished({'value': isinstance(a['value'], str) or isinstance(a['value'], unicode)})
+        #raise PrimitiveFinished({'value': isinstance(a['value'], str) or isinstance(a['value'], unicode)})
+        yield [("RETURN", [{'value': isinstance(a['value'], str) or isinstance(a['value'], unicode)}])]
     except NameError:
-        raise PrimitiveFinished({'value': isinstance(a['value'], str)})
+        #raise PrimitiveFinished({'value': isinstance(a['value'], str)})
+        yield [("RETURN", [{'value': isinstance(a['value'], str)}])]
 
 def is_physical_float(a, **remainder):
     if "value" not in a:
         a['value'], = yield [("RV", [a['id']])]
-    raise PrimitiveFinished({'value': isinstance(a['value'], float)})
+    #raise PrimitiveFinished({'value': isinstance(a['value'], float)})
+    yield [("RETURN", [{'value': isinstance(a['value'], float)}])]
 
 def is_physical_boolean(a, **remainder):
     if "value" not in a:
         a['value'], = yield [("RV", [a['id']])]
-    raise PrimitiveFinished({'value': isinstance(a['value'], bool)})
+    #raise PrimitiveFinished({'value': isinstance(a['value'], bool)})
+    yield [("RETURN", [{'value': isinstance(a['value'], bool)}])]
 
 def is_physical_action(a, **remainder):
     if "value" not in a:
         a['value'], = yield [("RV", [a['id']])]
-    raise PrimitiveFinished({'value': isinstance(a['value'], dict) and a['value']["value"] in ["if", "while", "assign", "call", "break", "continue", "return", "resolve", "access", "constant", "global", "declare"]})
+    #raise PrimitiveFinished({'value': isinstance(a['value'], dict) and a['value']["value"] in ["if", "while", "assign", "call", "break", "continue", "return", "resolve", "access", "constant", "global", "declare"]})
+    yield [("RETURN", [{'value': isinstance(a['value'], dict) and a['value']["value"] in ["if", "while", "assign", "call", "break", "continue", "return", "resolve", "access", "constant", "global", "declare"]}])]
 
 def is_physical_none(a, **remainder):
     if "value" not in a:
         a['value'], = yield [("RV", [a['id']])]
-    raise PrimitiveFinished({'value': isinstance(a['value'], dict) and a['value']["value"] == "none"})
+    #raise PrimitiveFinished({'value': isinstance(a['value'], dict) and a['value']["value"] == "none"})
+    yield [("RETURN", [{'value': isinstance(a['value'], dict) and a['value']["value"] == "none"}])]
 
 def create_node(**remainder):
     result, = yield [("CN", [])]
-    raise PrimitiveFinished({'id': result})
+    #raise PrimitiveFinished({'id': result})
+    yield [("RETURN", [{'id': result}])]
 
 def create_edge(a, b, **remainder):
     if "id" not in a:
@@ -329,18 +375,21 @@ def create_edge(a, b, **remainder):
         #print("MATERIALIZING B create_edge")
         b['id'], = yield [("CNV", [b['value']])]
     result, = yield [("CE", [a['id'], b['id']])]
-    raise PrimitiveFinished({'id': result})
+    #raise PrimitiveFinished({'id': result})
+    yield [("RETURN", [{'id': result}])]
 
 def create_value(a, **remainder):
     if "value" not in a:
         a['value'], = yield [("RV", [a['id']])]
-    raise PrimitiveFinished({'value': a['value']})
+    #raise PrimitiveFinished({'value': a['value']})
+    yield [("RETURN", [{'value': a['value']}])]
 
 def read_nr_out(a, **remainder):
     if "id" not in a:
         a['id'], = yield [("CNV", [a['value']])]
     outgoing, = yield [("RO", [a['id']])]
-    raise PrimitiveFinished({'value': len(outgoing)})
+    #raise PrimitiveFinished({'value': len(outgoing)})
+    yield [("RETURN", [{'value': len(outgoing)}])]
 
 def read_out(a, b, root, **remainder):
     if "id" not in a:
@@ -349,13 +398,15 @@ def read_out(a, b, root, **remainder):
         b['value'], = yield [("RV", [b['id']])]
 
     outgoing, = yield [("RO", [a['id']])]
-    raise PrimitiveFinished({'id': sorted(outgoing)[b['value']] if len(outgoing) > b['value'] else root})
+    #raise PrimitiveFinished({'id': sorted(outgoing)[b['value']] if len(outgoing) > b['value'] else root})
+    yield [("RETURN", [{'id': sorted(outgoing)[b['value']] if len(outgoing) > b['value'] else root}])]
 
 def read_nr_in(a, **remainder):
     if "id" not in a:
         a['id'], = yield [("CNV", [a['value']])]
     incoming, = yield [("RI", [a['id']])]
-    raise PrimitiveFinished({'value': len(incoming)})
+    #raise PrimitiveFinished({'value': len(incoming)})
+    yield [("RETURN", [{'value': len(incoming)}])]
 
 def read_in(a, b, root, **remainder):
     if "id" not in a:
@@ -364,50 +415,62 @@ def read_in(a, b, root, **remainder):
         b['value'], = yield [("RV", [b['id']])]
 
     incoming, = yield [("RI", [a['id']])]
-    raise PrimitiveFinished({'id': sorted(incoming)[b['value']] if len(incoming) > b['value'] else root})
+    #raise PrimitiveFinished({'id': sorted(incoming)[b['value']] if len(incoming) > b['value'] else root})
+    yield [("RETURN", [{'id': sorted(outgoing)[b['value']] if len(incoming) > b['value'] else root}])]
 
 def read_edge_src(a, **remainder):
     result, = yield [("RE", [a['id']])]
-    raise PrimitiveFinished({'id': result[0]})
+    #raise PrimitiveFinished({'id': result[0]})
+    yield [("RETURN", [{'id': result[0]}])]
 
 def read_edge_dst(a, **remainder):
     result, = yield [("RE", [a['id']])]
-    raise PrimitiveFinished({'id': result[1]})
+    #raise PrimitiveFinished({'id': result[1]})
+    yield [("RETURN", [{'id': result[1]}])]
 
 def delete_element(a, **remainder):
     if "id" not in a:
-        raise PrimitiveFinished({'value': False})
+        #raise PrimitiveFinished({'value': False})
+        yield [("RETURN", [{'value': False}])]
 
     edge, = yield [("RE", [a['id']])]
     if edge[0] is None:
         # Not an edge:
         yield [("DN", [a['id']])]
-        raise PrimitiveFinished({'value': False})
+        #raise PrimitiveFinished({'value': False})
+        yield [("RETURN", [{'value': False}])]
     else:
         yield [("DE", [a['id']])]
-        raise PrimitiveFinished({'value': True})
+        #raise PrimitiveFinished({'value': True})
+        yield [("RETURN", [{'value': True}])]
 
 def read_root(root, **remainder):
-    raise PrimitiveFinished({'id': root})
+    #raise PrimitiveFinished({'id': root})
+    yield [("RETURN", [{'id': root}])]
 
 def is_edge(a, **remainder):
     if "id" not in a:
-        raise PrimitiveFinished({'value': False})
+        #raise PrimitiveFinished({'value': False})
+        yield [("RETURN", [{'value': False}])]
 
     edge, = yield [("RE", [a['id']])]
-    raise PrimitiveFinished({'value': edge[0] is not None})
+    #raise PrimitiveFinished({'value': edge[0] is not None})
+    yield [("RETURN", [{'value': edge[0] is not None}])]
 
 def log(a, **remainder):
     if "value" not in a:
         a['value'], = yield [("RV", [a['id']])]
     print("== LOG == " + str(a['value']))
-    raise PrimitiveFinished(a)
+    #raise PrimitiveFinished(a)
+    yield [("RETURN", [a])]
 
 def read_taskroot(task_root, **remainder):
-    raise PrimitiveFinished({'id': task_root})
+    #raise PrimitiveFinished({'id': task_root})
+    yield [("RETURN", [{'id': task_root}])]
 
 def time(**remainder):
-    raise PrimitiveFinished({'value': python_time.time()})
+    #raise PrimitiveFinished({'value': python_time.time()})
+    yield [("RETURN", [{'value': python_time.time()}])]
 
 def hash(a, **remainder):
     if "value" not in a:
@@ -418,7 +481,8 @@ def hash(a, **remainder):
         value = hashlib.sha512(a['value']).hexdigest()
     except TypeError:
         value = hashlib.sha512(a['value'].encode()).hexdigest()
-    raise PrimitiveFinished({'value': value})
+    #raise PrimitiveFinished({'value': value})
+    yield [("RETURN", [{'value': value}])]
 
 def __sleep(a, b, **remainder):
     if "value" not in a:
@@ -428,10 +492,13 @@ def __sleep(a, b, **remainder):
     timeout = a['value']
     interruptable = b['value']
     yield [("SLEEP", [timeout, interruptable])]
-    raise PrimitiveFinished(a)
+    #raise PrimitiveFinished(a)
+    yield [("RETURN", [a])]
 
 def is_error(a, **remainder):
     if a['id'] is None:
-        raise PrimitiveFinished({'value': True})
+        #raise PrimitiveFinished({'value': True})
+        yield [("RETURN", [{'value': True}])]
     else:
-        raise PrimitiveFinished({'value': False})
+        #raise PrimitiveFinished({'value': False})
+        yield [("RETURN", [{'value': False}])]

kernel/modelverse_kernel/request_handler.py

@@ -9,15 +9,19 @@ class RequestHandler(object):
         self.handlers = {"CALL": lambda i: i[0],
                          "CALL_ARGS": lambda i: i[0](*(i[1])),
                          "CALL_KWARGS": lambda i: i[0](**(i[1])),
+                         "RETURN": self.execute_return,
                          "SLEEP": self.execute_sleep}
 
     def push_generator(self, gen):
         self.generator_stack.append(gen)
 
     def handle_request(self, reply):
+        self.reply = reply
         while self.generator_stack:
             try:
-                requests = self.generator_stack[-1].send(reply)
+                print("Stack: " + str(self.generator_stack))
+                requests = self.generator_stack[-1].send(self.reply)
+                print("Requests: " + str(requests))
 
                 # Generated new request, so process
                 if requests and requests[0][0] in self.handlers:
@@ -26,25 +30,34 @@ class RequestHandler(object):
                     # This next command potentially raises a finished message already, meaning that we should stop already
                     # We avoid an extra try/except block by putting the None on the stack already
                     self.generator_stack[-1] = self.handlers[requests[0][0]](requests[0][1])
-                    reply = None
+                    self.reply = None
                 else:
                     # MvS request, so forward that instead
                     return requests
 
-            except primitive_functions.PrimitiveFinished as ex:
-                # Exception, so finished execution of this generator, passing on ex.result to the caller
-                del self.generator_stack[-1]
-                reply = [ex.result]
-
             except StopIteration:
                 # Exception, so finished execution of this generator, passing on None to the caller
+                print("STOPITER")
                 del self.generator_stack[-1]
-                reply = [None]
+                self.reply = [None]
                 
             except primitive_functions.SleepKernel:
                 # Processing sleep, so pop its generator and reraise
                 del self.generator_stack[-1]
                 raise
 
+            except primitive_functions.PrimitiveFinished as ex:
+                # Exception, so finished execution of this generator, passing on ex.result to the caller
+                del self.generator_stack[-1]
+                self.reply = [ex.result]
+                print("SHOULD NOT HAPPEN")
+
     def execute_sleep(self, request_args):
         raise primitive_functions.SleepKernel(request_args[0], request_args[1])
+
+    def execute_return(self, request_args):
+        print("RETURNING")
+        print(self.generator_stack)
+        del self.generator_stack[-1]
+        self.reply = request_args[0]
+        print(self.generator_stack)

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:   Fri Apr 27 15:11:46 2018
+Date:   Fri Apr 27 16:59:23 2018
 
 Model author: Yentl Van Tendeloo
 Model name:   MvK Server