Merge remote-tracking branch 'yentl/master' into jit

README.md

@@ -11,7 +11,7 @@ Starting up the Modelverse
 
 Starting up the Modelverse is easy: simply execute the `scripts/run_local_modelverse.py` script, with as parameter the port you want to use.
 This will compile the Modelverse statechart and execute it afterwards.
-You can now directly communicate with the Modelverse user initialisation layer.
+You can now directly communicate with the Modelverse task initialisation layer.
 It is not recommended that you do this manually, so we will now introduce the action language.
 
 Compiling Action Language
@@ -20,18 +20,18 @@ Compiling Action Language
 For a more user-friendly experience, an Action Language compiler was introduced that can automatically generate Modelverse instructions.
 During compilation, a live Modelverse is required, as the bytecodes are immediately uploaded after compilation.
 The Modelverse uses a traditional compilation phase and linking phase, though this is all hidden to the user through the `scripts/make_all.py` script.
-The script takes as parameter the address of the Modelverse, the username in whose name to execute the code, and a list of source files.
+The script takes as parameter the address of the Modelverse, the taskname with which to communicate, and a list of source files.
 For realistic applications, we recommend to always link to the bootstrap code, by including the file `bootstrap/\*.alc`.
 Even on systems that don't support globbing (e.g., Windows), this will automatically be expanded by the compiler.
 
 For example, to compile the simple textual interface, you must compile the interface's action language, together with all bootstrapping code (the libraries):
 
 ```sh
-python scripts/make_all.py http://127.0.0.1:8001 test_user bootstrap/*.alc integration/code/pn_interface.alc
+python scripts/make_all.py http://127.0.0.1:8001 test_task bootstrap/*.alc integration/code/pn_interface.alc
 ```
 
 Compilation is (relatively) smart, as it will not compile code again that is already present in the Modelverse.
-As such, except for the first user, the bootstrap code no longer needs to be compiled, only linked.
+As such, except for the first task, the bootstrap code no longer needs to be compiled, only linked.
 In the future, this is expected to become more user friendly for users, such that they no longer need to have the bootstrapping code available locally.
 
 After this part, your action language in `integration/code/pn_interface.alc` is compiled and running on the Modelverse.
@@ -45,7 +45,6 @@ To do this, you can use whatever tool you want, as long as it can send and recei
 For example, a mere internet browser can already communicate with the Modelverse, though not in the most user-friendly way.
 
 A nicer way is through the Python prompt script `scripts/prompt.py`.
-It will ask you the location of the Modelverse, and the user to connect to.
 After that, it will print out all the output of the Modelverse, and send in all your queries directly to the Modelverse.
 
 Performance

bootstrap/bootstrap.py

@@ -7,18 +7,18 @@ import gzip
 def bootstrap():
     root = ["__hierarchy"]
 
-    user_manager = "user_manager"
+    task_manager = "task_manager"
     initial_code_manager = "bootstrap/initial_code_manager.alb"
-    initial_code_user = "bootstrap/initial_code_user.alb"
-    bootstrap_files = glob.glob("bootstrap/*.alc") + [initial_code_manager, initial_code_user]
+    initial_code_task = "bootstrap/initial_code_task.alb"
+    bootstrap_files = glob.glob("bootstrap/*.alc") + [initial_code_manager, initial_code_task]
 
-    user_data = [   "input",
+    task_data = [   "input",
                     "output",
                     "globals",
                     "frame",
                     ]
 
-    user_frame = [  "evalstack",
+    task_frame = [  "evalstack",
                     "symbols",
                     "returnvalue",
                     ]
@@ -102,7 +102,7 @@ def bootstrap():
                     "element_eq": ["Boolean", "Element", "Element"],
                     "element_neq": ["Boolean", "Element", "Element"],
                     "read_root": ["Element"],
-                    "read_userroot": ["Element"],
+                    "read_taskroot": ["Element"],
                     "deserialize": ["Element", "String"],
                     "log": ["String", "String"],
                     "time": ["Float"],
@@ -179,31 +179,31 @@ def bootstrap():
                 declare_primitive_class('primitives', primitives)
                 declare_primitive_class('jit', jit_primitives)
 
-                # Create the initial user
-                f.write("Node user_root()\n")
+                # Create the initial task
+                f.write("Node task_root()\n")
 
-                for data in user_data:
-                    f.write("Node user_%s()\n" % data)
-                    f.write('Node ___user_%s("%s")\n' % (data, data))
-                    f.write("Edge _user_%s(user_root, user_%s)\n" % (data, data))
-                    f.write("Edge __user_%s(_user_%s, ___user_%s)\n" % (data, data, data))
+                for data in task_data:
+                    f.write("Node task_%s()\n" % data)
+                    f.write('Node ___task_%s("%s")\n' % (data, data))
+                    f.write("Edge _task_%s(task_root, task_%s)\n" % (data, data))
+                    f.write("Edge __task_%s(_task_%s, ___task_%s)\n" % (data, data, data))
 
-                for data in user_frame:
-                    f.write("Node user_%s()\n" % data)
-                    f.write('Node ___user_%s("%s")\n' % (data, data))
-                    f.write("Edge _user_%s(user_frame, user_%s)\n" % (data, data))
-                    f.write("Edge __user_%s(_user_%s, ___user_%s)\n" % (data, data, data))
+                for data in task_frame:
+                    f.write("Node task_%s()\n" % data)
+                    f.write('Node ___task_%s("%s")\n' % (data, data))
+                    f.write("Edge _task_%s(task_frame, task_%s)\n" % (data, data))
+                    f.write("Edge __task_%s(_task_%s, ___task_%s)\n" % (data, data, data))
 
                 # Add last_input and last_output links
                 for data in ["input", "output"]:
-                    f.write('Node ___user_last_%s("last_%s")\n' % (data, data))
-                    f.write("Edge _user_last_%s(user_root, user_%s)\n" % (data, data))
-                    f.write("Edge __user_last_%s(_user_last_%s, ___user_last_%s)\n" % (data, data, data))
+                    f.write('Node ___task_last_%s("last_%s")\n' % (data, data))
+                    f.write("Edge _task_last_%s(task_root, task_%s)\n" % (data, data))
+                    f.write("Edge __task_last_%s(_task_last_%s, ___task_last_%s)\n" % (data, data, data))
                     
-                # Bind user to the root
-                f.write('Node ___new_user("%s")\n' % user_manager)
-                f.write("Edge _new_user(root, user_root)\n")
-                f.write("Edge __new_user(_new_user, ___new_user)\n")
+                # Bind task to the root
+                f.write('Node ___new_task("%s")\n' % task_manager)
+                f.write("Edge _new_task(root, task_root)\n")
+                f.write("Edge __new_task(_new_task, ___new_task)\n")
 
                 def compile_code_AL(filename, target, prepend="", main=False, symbols=None):
                     import sys
@@ -225,7 +225,7 @@ def bootstrap():
                     bootstrap_file = bootstrap_file.replace("\\", "/")
                     print("[COMP] %s" % bootstrap_file)
                     symbols = {}
-                    f.write(compile_code_AL(bootstrap_file, "initial_IP", prepend=bootstrap_file, symbols=symbols, main = bootstrap_file in [initial_code_manager, initial_code_user]), both=False)
+                    f.write(compile_code_AL(bootstrap_file, "initial_IP", prepend=bootstrap_file, symbols=symbols, main = bootstrap_file in [initial_code_manager, initial_code_task]), both=False)
 
                     # Now link the code with the compilation manager structure
                     f.write("Node elem()\n", both=False)
@@ -253,22 +253,22 @@ def bootstrap():
                         f.write('Edge _(__symbols, v)\n', both=False)
                         f.write('Edge _(_, k)\n', both=False)
 
-                # Create code for initial user
-                print("[BOOT] user_manager")
+                # Create code for initial task
+                print("[BOOT] task_manager")
                 f.write('Node _IP_str("IP")\n', both=False)
-                f.write("Edge _user_frame(user_frame, %s_initial_IP)\n" % initial_code_manager, both=False)
-                f.write("Edge __user_frame(_user_frame, _IP_str)\n", both=False)
+                f.write("Edge _task_frame(task_frame, %s_initial_IP)\n" % initial_code_manager, both=False)
+                f.write("Edge __task_frame(_task_frame, _IP_str)\n", both=False)
 
                 f.write('Node __phase("init")\n', both=False)
                 f.write('Node __phase_str("phase")\n', both=False)
-                f.write("Edge _user_phase(user_frame, __phase)\n", both=False)
-                f.write("Edge __user_phase(_user_phase, __phase_str)\n", both=False)
+                f.write("Edge _task_phase(task_frame, __phase)\n", both=False)
+                f.write("Edge __task_phase(_task_phase, __phase_str)\n", both=False)
 
-                # Create code for new users to start at
-                print("[BOOT] new_user")
+                # Create code for new tasks to start at
+                print("[BOOT] new_task")
                 f.write('Node __IP_str("__IP")\n', both=False)
-                f.write("Edge _user_IP(__hierarchy, %s_initial_IP)\n" % initial_code_user, both=False)
-                f.write("Edge __user_IP(_user_IP, __IP_str)\n", both=False)
+                f.write("Edge _task_IP(__hierarchy, %s_initial_IP)\n" % initial_code_task, both=False)
+                f.write("Edge __task_IP(_task_IP, __IP_str)\n", both=False)
     except:
         os.remove("bootstrap/bootstrap.m.gz")
         os.remove("bootstrap/minimal.m.gz")

bootstrap/constructors.alc

@@ -18,7 +18,7 @@ Action function construct_top():
 		elif (command == "mutable_funcdef"):
 			return construct_top_funcdef(True)!
 		else:
-			log("ERROR: did not understand command " + cast_e2s(command))
+			log("ERROR (1): did not understand command " + cast_e2s(command))
 
 Action function construct_global():
 	Action this_element
@@ -155,7 +155,7 @@ Action function construct_unknown():
 		construct_model()
 		return construct_unknown()!
 	else:
-		log("ERROR: did not understand command " + cast_e2s(elem))
+		log("ERROR (2): did not understand command " + cast_e2s(elem))
 
 Action function construct_if():
 	Action this_element

bootstrap/ftg.alc

@@ -1,54 +0,0 @@
-include "primitives.alh"
-include "modelling.alh"
-include "library.alh"
-
-Void function visit_ftg(ftg : Element, root : Element, path : String, current : Element):
-	log("Visit FTG: " + path)
-	if (dict_in(current, "source")):
-		// Is a transformation, and therefore an edge for the FTG
-		if (bool_not(dict_in(ftg["model"], path))):
-			if (bool_not(dict_in(ftg["model"], current["source"]))):
-				visit_ftg(ftg, root, current["source"], root[current["source"]])
-
-			if (bool_not(dict_in(ftg["model"], current["target"]))):
-				visit_ftg(ftg, root, current["target"], root[current["source"]])
-
-			instantiate_link(ftg, "Transformation", path, current["source"], current["target"])
-			instantiate_attribute(ftg, path, "location", path)
-	else:
-		// Is a model, and therefore a node for the FTG
-		if (bool_not(dict_in(ftg["model"], path))):
-			instantiate_node(ftg, "Formalism", path)
-			instantiate_attribute(ftg, path, "location", path)
-
-	return !
-
-Element function create_ftg(root : Element):
-	Element queue
-	Element current
-	Element submodels
-	Element ftg
-	String path
-	String submodel
-
-	queue = create_node()
-	set_add(queue, create_tuple("models", root))
-	ftg = instantiate_model(import_node("models/FTG"))
-
-	while (read_nr_out(queue) > 0):
-		current = set_pop(queue)
-		path = current[0]
-		current = current[1]
-		log("Check node: " + cast_e2s(current))
-		if (dict_in(current, "__hierarchy_node" )):
-			log("IS HIERARCHY: " + path)
-			submodels = dict_keys(current)
-			// Is a browser structure, and therefore not part of the FTG
-			while (read_nr_out(submodels) > 0):
-				submodel = set_pop(submodels)
-				set_add(queue, create_tuple((path + "/") + submodel, current[submodel]))
-		else:
-			log("IS MODEL: " + path)
-			visit_ftg(ftg, root, path, current)
-
-	return ftg!

bootstrap/initial_code_manager.alb

@@ -1,10 +1,10 @@
 include "bootstrap/primitives.alc"
-include "user_manager.alh"
+include "task_manager.alh"
 
 Void function __main():
 	Element root
 	root = read_root()
 	root = root["__hierarchy"]["objects"]
-	exec(root["bootstrap/user_manager.alc"]["initializers"])
-	user_management()
+	exec(root["bootstrap/task_manager.alc"]["initializers"])
+	task_management()
 	return!

bootstrap/initial_code_user.alb

@@ -1,5 +1,5 @@
 include "bootstrap/primitives.alc"
-include "user_interface.alh"
+include "task_interface.alh"
 
 Void mutable function __main():
 	Element root
@@ -12,6 +12,6 @@ Void mutable function __main():
 	exec(root["bootstrap/conformance_scd.alc"]["initializers"])
 	exec(root["bootstrap/metamodels.alc"]["initializers"])
 	exec(root["bootstrap/modelling.alc"]["initializers"])
-	exec(root["bootstrap/user_interface.alc"]["initializers"])
-	new_user()
+	exec(root["bootstrap/task_interface.alc"]["initializers"])
+	new_task()
 	return!

bootstrap/model_management.alc

@@ -138,8 +138,6 @@ Void function model_join(dst_model : Element, src_model : Element, retyping_key
 		name = list_pop(queue, 0)
 
 		type = read_type(src_model, name)
-		log("Instantiate element with old type: " + type)
-		log("New type: " + (retyping_key + type))
 
 		if (is_edge(src_model["model"][name])):
 			// Is an edge, so potentially queue it

bootstrap/primitives.alc

@@ -74,7 +74,7 @@ Integer function string_len(a: String) = ?primitives/string_len
 Element function deserialize(a: String) = ?primitives/deserialize
 Element function log(a: String) = ?primitives/log
 Element function read_root() = ?primitives/read_root
-Element function read_userroot() = ?primitives/read_userroot
+Element function read_taskroot() = ?primitives/read_taskroot
 Boolean function is_physical_int(a: Element) = ?primitives/is_physical_int
 Boolean function is_physical_float(a: Element) = ?primitives/is_physical_float
 Boolean function is_physical_string(a: Element) = ?primitives/is_physical_string
@@ -164,16 +164,16 @@ String function string_substr(a: String, b: Integer, c: Integer):
 Element function resolve(name : String):
 	// Could directly access it through introspection
 	// But seems safer to create some code and execute it...
-	Element user_root
-	user_root = read_userroot()
-	user_root = user_root["globals"][name]["value"]
-	return user_root!
+	Element task_root
+	task_root = read_taskroot()
+	task_root = task_root["globals"][name]["value"]
+	return task_root!
 
 Integer function integer_modulo(a : Integer, b : Integer):
 	return a - b * (a / b)!
 
 Boolean function has_input():
-	return (element_neq(dict_read(read_userroot(), "input"), dict_read(read_userroot(),"last_input")))!
+	return (element_neq(dict_read(read_taskroot(), "input"), dict_read(read_taskroot(),"last_input")))!
 
 Element function list_pop(lst : Element, index : Integer):
 	Element v

bootstrap/user_interface.alc

@@ -5,7 +5,7 @@ include "compilation_manager.alh"
 include "constructors.alh"
 include "modelling.alh"
 
-Void mutable function new_user():
+Void mutable function new_task():
 	Integer interface
 	while (True):
 		interface = input()

bootstrap/task_manager.alc

@@ -0,0 +1,32 @@
+include "io.alh"
+include "primitives.alh"
+
+Void function task_management():
+	String taskname
+	Element task_root
+	Element task_frame
+	Element output_value
+	Element input_value
+	
+	while (True):
+		taskname = input()
+		if (bool_not(dict_in(read_root(), taskname))):
+			task_root = create_node()
+			task_frame = create_node()
+			output_value = create_node()
+			input_value = create_node()
+			dict_add(task_root, "frame", task_frame)
+			dict_add(task_root, "globals", create_node())
+			dict_add(task_root, "output", output_value)
+			dict_add(task_root, "last_output", output_value)
+			dict_add(task_root, "input", input_value)
+			dict_add(task_root, "last_input", input_value)
+			dict_add(task_frame, "evalstack", create_node())
+			dict_add(task_frame, "returnvalue", create_node())
+			dict_add(task_frame, "phase", "init")
+			dict_add(task_frame, "IP", dict_read(dict_read(read_root(), "__hierarchy"), "__IP"))
+			dict_add(task_frame, "symbols", create_node())
+
+			//Add this only at the end, as otherwise the task will already be detected
+			dict_add(read_root(), taskname, task_root)
+	return!

bootstrap/transform.alc

@@ -176,12 +176,13 @@ Element function full_match(host_model : Element, schedule_model : Element, curr
 		mapping = set_pop(mappings)
 		i = 0
 		allowed = True
-		while (bool_and(i < read_nr_out(NACs), allowed)):
+		while (i < read_nr_out(NACs)):
 			NAC = read_edge_dst(read_out(NACs, i))
 			result = match(host_model, schedule_model, NAC, mapping)
 			if (read_nr_out(result) > 0):
 				// NAC could be matched, and therefore is not allowed
 				allowed = False
+				break!
 			i = i + 1
 		
 		if (allowed):
@@ -398,8 +399,6 @@ Boolean function transform_atomic(host_model : Element, schedule_model : Element
 	Element mappings
 	Element mapping
 	mappings = full_match(host_model, schedule_model, current)
-	log("Execute atomic " + current)
-	log("Mappings: " + cast_v2s(read_nr_out(mappings)))
 
 	if (read_nr_out(mappings) > 0):
 		// Pick one!
@@ -419,8 +418,6 @@ Boolean function transform_forall(host_model : Element, schedule_model : Element
 	Boolean result
 
 	mappings = full_match(host_model, schedule_model, current)
-	log("Execute forall " + current)
-	log("Mappings: " + cast_v2s(read_nr_out(mappings)))
 
 	if (read_nr_out(mappings) > 0):
 		result = True

bootstrap/user_manager.alc

@@ -1,32 +0,0 @@
-include "io.alh"
-include "primitives.alh"
-
-Void function user_management():
-	String username
-	Element user_root
-	Element user_frame
-	Element output_value
-	Element input_value
-	
-	while (True):
-		username = input()
-		if (bool_not(dict_in(read_root(), username))):
-			user_root = create_node()
-			user_frame = create_node()
-			output_value = create_node()
-			input_value = create_node()
-			dict_add(user_root, "frame", user_frame)
-			dict_add(user_root, "globals", create_node())
-			dict_add(user_root, "output", output_value)
-			dict_add(user_root, "last_output", output_value)
-			dict_add(user_root, "input", input_value)
-			dict_add(user_root, "last_input", input_value)
-			dict_add(user_frame, "evalstack", create_node())
-			dict_add(user_frame, "returnvalue", create_node())
-			dict_add(user_frame, "phase", "init")
-			dict_add(user_frame, "IP", dict_read(dict_read(read_root(), "__hierarchy"), "__IP"))
-			dict_add(user_frame, "symbols", create_node())
-
-			//Add this only at the end, as otherwise the user will already be detected
-			dict_add(read_root(), username, user_root)
-	return!

core/core_algorithm.alc

@@ -58,11 +58,9 @@ Void function main():
 	instantiate_attribute(core, admin_user, "name", input())
 	instantiate_attribute(core, admin_user, "admin", True)
 
-	Boolean ct
 	String password
 
-	ct = True
-	while (ct):
+	while (True):
 		output("Desired password for admin user?")
 		password = hash(input())
 
@@ -70,7 +68,7 @@ Void function main():
 		if (password == hash(input())):
 			output("Passwords match!")
 			instantiate_attribute(core, admin_user, "password", password)
-			ct = False
+			break!
 		else:
 			output("Not the same password, please try again!")
 
@@ -112,6 +110,7 @@ Void function main():
 	instantiate_link(core, "owner", "", core_model, admin_user)
 
 	// Call this for ourselves as well
+	log("MvC is ready!")
 	user_function_skip_init(admin_user)
 
 	// Done, so finish up
@@ -198,6 +197,14 @@ Boolean function check_login(user_id : String):
 
 	return password == stored_password!
 
+Element function extract_ftg(user_id : String):
+	// Extract your personal FTG, showing only the readable models that can be opened
+	// This function does the actual projection of transformations
+
+	// TODO: Only keep transformations satisfying some properties!
+
+	return create_node()!
+
 Element function user_function():
 	String username
 	String user_id
@@ -230,10 +237,7 @@ Element function user_function():
 		instantiate_attribute(core, user_id, "name", username)
 		instantiate_attribute(core, user_id, "admin", False)
 
-		Boolean ct
-		ct = True
-
-		while (ct):
+		while (True):
 			output("This is a new user: please give password!")
 			password = hash(input())
 
@@ -242,7 +246,7 @@ Element function user_function():
 				output("Passwords match!")
 				output("User created")
 				instantiate_attribute(core, user_id, "password", password)
-				ct = False
+				break!
 			else:
 				output("Not the same password, please try again!")
 
@@ -325,15 +329,12 @@ Void function model_overwrite(model : Element, model_id : String):
 	return!
 
 Void function user_function_skip_init(user_id : String):
-	Boolean do_continue
 	String cmd
 
-	do_continue = True
-
 	output("Welcome to the Model Management Interface v2.0!")
 	output("Use the 'help' command for a list of possible commands")
 
-	while (do_continue):
+	while (True):
 		output("Ready for command...")
 		cmd = input()
 		if (cmd == "help"):
@@ -910,10 +911,12 @@ Void function user_function_skip_init(user_id : String):
 					i = 0
 					if (string_len(permissions) != 3):
 						fail = True
-					while (bool_and(bool_not(fail), i < 3)):
+
+					while (i < 3):
 						permission = cast_s2i(string_get(permissions, i))
 						if (bool_or(permission < 0, permission > 2)):
 							fail = True
+							break!
 						i = i + 1
 
 					if (bool_not(fail)):
@@ -1015,14 +1018,14 @@ Void function user_function_skip_init(user_id : String):
 					if (other_user_id != ""):
 						Element overlap
 
-						overlap = set_overlap(allIncomingAssociationInstances(core, user_id, "owner"), allOutgoingAssociationInstances(core, group_id, "owner"))
+						overlap = set_overlap(allIncomingAssociationInstances(core, other_user_id, "owner"), allOutgoingAssociationInstances(core, group_id, "owner"))
 						if (read_nr_out(overlap) == 0):
-							instantiate_link(core, "owner", "", group_id, user_id)
+							instantiate_link(core, "owner", "", group_id, other_user_id)
 
-							overlap = set_overlap(allOutgoingAssociationInstances(core, user_id, "belongsTo"), allIncomingAssociationInstances(core, group_id, "belongsTo"))
+							overlap = set_overlap(allOutgoingAssociationInstances(core, other_user_id, "belongsTo"), allIncomingAssociationInstances(core, group_id, "belongsTo"))
 
 							if (read_nr_out(overlap) == 0):
-								instantiate_link(core, "belongsTo", "", user_id, group_id)
+								instantiate_link(core, "belongsTo", "", other_user_id, group_id)
 
 							output("New owner added to group!")
 						else:
@@ -1048,9 +1051,9 @@ Void function user_function_skip_init(user_id : String):
 					if (other_user_id != ""):
 						Element overlap
 
-						overlap = set_overlap(allOutgoingAssociationInstances(core, user_id, "belongsTo"), allIncomingAssociationInstances(core, group_id, "belongsTo"))
+						overlap = set_overlap(allOutgoingAssociationInstances(core, other_user_id, "belongsTo"), allIncomingAssociationInstances(core, group_id, "belongsTo"))
 						if (read_nr_out(overlap) > 0):
-							overlap = set_overlap(allIncomingAssociationInstances(core, user_id, "owner"), allOutgoingAssociationInstances(core, group_id, "owner"))
+							overlap = set_overlap(allIncomingAssociationInstances(core, other_user_id, "owner"), allOutgoingAssociationInstances(core, group_id, "owner"))
 							if (read_nr_out(overlap) > 0):
 								model_delete_element(core, set_pop(overlap))
 								output("Disowned group from user!")
@@ -1079,9 +1082,13 @@ Void function user_function_skip_init(user_id : String):
 					if (other_user_id != ""):
 						Element overlap
 
-						overlap = set_overlap(allOutgoingAssociationInstances(core, user_id, "belongsTo"), allIncomingAssociationInstances(core, group_id, "belongsTo"))
+						overlap = set_overlap(allOutgoingAssociationInstances(core, other_user_id, "belongsTo"), allIncomingAssociationInstances(core, group_id, "belongsTo"))
+
+						log("Size of overlap: " + cast_v2s(read_nr_out(overlap)))
+						log("Overlap: " + set_to_string(overlap))
+
 						if (read_nr_out(overlap) == 0):
-							instantiate_link(core, "belongsTo", "", user_id, group_id)
+							instantiate_link(core, "belongsTo", "", other_user_id, group_id)
 							output("User added to the group!")
 						else:
 							output("User is already a member of the group!")
@@ -1106,12 +1113,12 @@ Void function user_function_skip_init(user_id : String):
 					if (other_user_id != ""):
 						Element overlap
 
-						overlap = set_overlap(allOutgoingAssociationInstances(core, user_id, "belongsTo"), allIncomingAssociationInstances(core, group_id, "belongsTo"))
+						overlap = set_overlap(allOutgoingAssociationInstances(core, other_user_id, "belongsTo"), allIncomingAssociationInstances(core, group_id, "belongsTo"))
 						if (read_nr_out(overlap) > 0):
 							model_delete_element(core, set_pop(overlap))
 
 							// Check if user was an owner as well
-							overlap = set_overlap(allIncomingAssociationInstances(core, user_id, "owner"), allOutgoingAssociationInstances(core, group_id, "owner"))
+							overlap = set_overlap(allIncomingAssociationInstances(core, other_user_id, "owner"), allOutgoingAssociationInstances(core, group_id, "owner"))
 							if (read_nr_out(overlap) > 0):
 								model_delete_element(core, set_pop(overlap))
 
@@ -1176,17 +1183,16 @@ Void function user_function_skip_init(user_id : String):
 		elif (cmd == "self-destruct"):
 			// Delete user from Core Formalism
 			model_delete_element(core, user_id)
-			do_continue = False
+			return !
 
 		elif (cmd == "exit"):
 			// Exit by actually removing the user and decoupling it from all of its models
 			// Restarting with the same user name will NOT grant you access to anything of the previous user with that same name
 			// as the current user will have been deleted
-			do_continue = False
+			return !
 
 		else:
 			output("Unknown command: " + cmd)
 
-	output("Goodbye!")
-
+	// We never get here!
 	return !

hybrid_server/classes/mvkcontroller.xml

@@ -37,14 +37,14 @@
             self.timeout = False
             self.init_time = time.time()
 
-            self.users = set()
+            self.tasks = set()
             self.input_queue = defaultdict(list)
             self.output_queue = defaultdict(list)
             self.source = None
             self.port = int(sys.argv[1])
             self.count = 0
             
-            self.debugged_users = set()
+            self.debugged_tasks = set()
             self.debug_info = {}
             self.done_something = False
 
@@ -76,7 +76,7 @@
     </constructor>
 
     <method name="execute_modelverse">
-        <parameter name="username"/>
+        <parameter name="taskname"/>
         <parameter name="operation"/>
         <parameter name="params"/>
         <body>
@@ -84,7 +84,7 @@
             reply = None
             commands = []
             while 1:
-                commands = self.mvk.execute_yields(username, operation, params, reply)
+                commands = self.mvk.execute_yields(taskname, operation, params, reply)
                 if commands is None:
                     break
                 reply = [self.mvs_operations[command[0]](*(command[1]))[0] for command in commands]
@@ -127,27 +127,27 @@
                                         value = [json.loads(data["value"])]
                                     else:
                                         value = json.loads(data["data"])
-                                    self.input_queue[data["username"]].append((source, value))
+                                    self.input_queue[data["taskname"]].append((source, value))
                                 elif data["op"] == "get_output":
-                                    self.output_queue[data["username"]].append(source)
+                                    self.output_queue[data["taskname"]].append(source)
                                 elif data["op"] == "attach_debugger":
-                                    self.debugged_users.add(data["username"])
+                                    self.debugged_tasks.add(data["taskname"])
                                     self.done_something = True
                                     self.source = source
-                                    self.debug_info[data["username"]] = {'state': 'running', 'breakpoints': []}
+                                    self.debug_info[data["taskname"]] = {'state': 'running', 'breakpoints': []}
                                 elif data["op"] == "detach_debugger":
-                                    self.debugged_users.discard(data["username"])
+                                    self.debugged_tasks.discard(data["taskname"])
                                     self.done_something = True
                                     self.source = source
-                                    del self.debug_info[data["username"]]
+                                    del self.debug_info[data["taskname"]]
                                 elif data["op"] == "pause":
-                                    if data["username"] in self.debugged_users:
-                                        self.debug_info[data["username"]]['state'] = 'paused'
+                                    if data["taskname"] in self.debugged_tasks:
+                                        self.debug_info[data["taskname"]]['state'] = 'paused'
                                     self.done_something = True
                                     self.source = source
                                 elif data["op"] == "resume":
-                                    if data["username"] in self.debugged_users:
-                                        self.debug_info[data["username"]]['state'] = 'running'
+                                    if data["taskname"] in self.debugged_tasks:
+                                        self.debug_info[data["taskname"]]['state'] = 'running'
                                     self.done_something = True
                                     self.source = source
                                 elif data["op"] == "step_over":
@@ -183,23 +183,23 @@
                         <script>
                             self.timeout = False
                             self.destination = None
-                            if self.users:
-                                user = self.users.pop()
-                                if not user in self.debugged_users or self.debug_info[user]['state'] == 'running':
+                            if self.tasks:
+                                task = self.tasks.pop()
+                                if not task in self.debugged_tasks or self.debug_info[task]['state'] == 'running':
                                     # Check if there are values to input
-                                    if self.input_queue[user]:
-                                        source, args = self.input_queue[user].pop(0)
+                                    if self.input_queue[task]:
+                                        source, args = self.input_queue[task].pop(0)
                                         for args_entry in args:
-                                            self.execute_modelverse(user, "set_input", [args_entry])
+                                            self.execute_modelverse(task, "set_input", [args_entry])
 
                                         self.destination = source
                                         self.value = "OK"
                                         self.all_failed = False
 
-                                    nr_of_steps = 1 if user in self.debugged_users else 100
+                                    nr_of_steps = 1 if task in self.debugged_tasks else 100
                                     # Now process for some steps, or until we are again blocked for input
                                     for x in xrange(nr_of_steps):
-                                        self.execute_modelverse(user, "execute_rule", [])
+                                        self.execute_modelverse(task, "execute_rule", [])
 
                                         if not self.mvk.success:
                                             # Blocking or broken, so quit already to stop wasting CPU
@@ -211,10 +211,10 @@
                                     # Check that we don't have anything to output yet, otherwise we wait
                                     if self.destination is None:
                                         # Perform output if there is anything
-                                        if self.output_queue[user]:
-                                            self.execute_modelverse(user, "get_output", [])
+                                        if self.output_queue[task]:
+                                            self.execute_modelverse(task, "get_output", [])
                                             if self.mvk.success:
-                                                self.destination = self.output_queue[user].pop(0)
+                                                self.destination = self.output_queue[task].pop(0)
                                                 self.value = self.mvk.returnvalue
                                                 self.all_failed = False
 
@@ -227,14 +227,14 @@
                                     self.mvs.garbage_collect()
                                 out = self.mvs.read_outgoing(self.root)[0]
                                 for m in out:
-                                    src, user = self.mvs.read_edge(m)[0]
+                                    src, task = self.mvs.read_edge(m)[0]
                                     outgoing = self.mvs.read_outgoing(m)[0]
                                     first = self.mvs.read_edge(outgoing[0])[0]
                                     dest = first[1]
                                     name = self.mvs.read_value(dest)[0]
                                     if name.startswith("__"):
                                         continue
-                                    self.users.add(name)
+                                    self.tasks.add(name)
                                 self.timeout = self.all_failed
                                 self.all_failed = True
                         </script>
@@ -257,8 +257,8 @@
                     <transition event="delete_socket" target=".">
                         <parameter name="socket"/>
                         <script>
-                            for user in self.output_queue.keys():
-                                self.output_queue[user] = [s for s in self.output_queue[user] if s != socket]
+                            for task in self.output_queue.keys():
+                                self.output_queue[task] = [s for s in self.output_queue[task] if s != socket]
                         </script>
                     </transition>
                 </state>

integration/code/pn_design_model_larger.mvc

@@ -0,0 +1,55 @@
+import models/PetriNets_Design as PetriNets
+
+PetriNets pn {
+    Place critical_section_1 {
+        tokens = 0
+        name = "critical_section_1"
+    }
+    Place critical_section_2 {
+        tokens = 0
+        name = "critical_section_2"
+    }
+    Place lock_available {
+        tokens = 1
+        name = "lock_available"
+    }
+
+    Transition release_section_1 {}
+    Transition release_section_2 {}
+    Transition acquire_section_1 {}
+    Transition acquire_section_2 {}
+
+    P2T (critical_section_1, release_section_1) {
+        weight = 1
+    }
+
+    P2T (critical_section_2, release_section_2) {
+        weight = 1
+    }
+
+    P2T (lock_available, acquire_section_1) {
+        weight = 1
+    }
+
+    P2T (lock_available, acquire_section_2) {
+        weight = 1
+    }
+
+    T2P (release_section_1, lock_available) {
+        weight = 1
+    }
+
+    T2P (release_section_2, lock_available) {
+        weight = 1
+    }
+
+    T2P (acquire_section_1, critical_section_1) {
+        weight = 1
+    }
+
+    T2P (acquire_section_2, critical_section_2) {
+        weight = 1
+    }
+}
+
+export pn to models/pn

integration/code/pn_simulate.mvc

@@ -8,25 +8,29 @@ RAM_PN_R s {
             LHS {
                 Pre_PetriNets_Runtime/Transition {
                     label = "1"
-                    constraint = $
-                        include "primitives.alh"
-                        include "modelling.alh"
-                        include "object_operations.alh"
-                        Boolean function constraint(host_model : Element, name : String):
-                            Element links
-                            String link
-                            String place
-                            log("Types in metamodel: " + set_to_string(dict_keys(host_model["metamodel"]["model"])))
-                            links = allIncomingAssociationInstances(host_model, name, "PetriNets_Runtime/P2T")
-                            while (read_nr_out(links) > 0):
-                                link = set_pop(links)
-                                place = readAssociationSource(host_model, link)
-                                if (integer_lt(read_attribute(host_model, place, "tokens"), read_attribute(host_model, link, "weight"))):
-                                    return False!
-                            return True!
-                        $
                 }
             }
+            NAC {
+				Pre_PetriNets_Runtime/Transition mark_nac_t {
+					label = "1"
+				}
+				Pre_PetriNets_Runtime/Place mark_nac_p{
+					label = "10"
+				}
+				Pre_PetriNets_Runtime/P2T (mark_nac_p, mark_nac_t){
+					label = "11"
+				}
+				constraint = $
+					include "primitives.alh"
+					include "modelling.alh"
+					Boolean function constraint(host_model : Element, mapping : Element):
+						Integer tokens
+						Integer weight
+						tokens = read_attribute(host_model, mapping["10"], "tokens")
+						weight = read_attribute(host_model, mapping["11"], "weight")
+                        return (tokens < weight)!
+					$
+            }
             RHS {
                 Post_PetriNets_Runtime/Transition {
                     label = "1"

integration/test_mvc.py

@@ -9,7 +9,6 @@ all_files = [   "core/mini_modify.alc",
                 "object_operations.alc",
                 "conformance_scd.alc",
                 "library.alc",
-                "ftg.alc",
                 "transform.alc",
                 "model_management.alc",
                 "ramify.alc",
@@ -24,6 +23,9 @@ class TestModelverseCore(unittest.TestCase):
     def test_po_list(self):
         self.list("PO")
 
+    def test_co_list(self):
+        self.list("CO")
+
     def list(self, mode):
         self.assertTrue(run_file(all_files,
             [ "root", "root", "root", 
@@ -849,3 +851,315 @@ class TestModelverseCore(unittest.TestCase):
                 "Ready for command...",
             ],
             mode))
+
+    def test_po_transform_add_MT_pn_simulate_larger(self):
+        self.transform_add_MT_pn_simulate_larger("PO")
+
+    def transform_add_MT_pn_simulate_larger(self, mode):
+        def step_and_print():
+            return [ \
+                # transformation_execute (pn_step)
+                "Which transformation do you want to execute?",
+                "Which model to bind for source element PetriNets_Runtime",
+                "Which model to create for target element PetriNets_Runtime",
+                "Transformation executed with result: True",
+                "Ready for command...",
+                # transformation_execute (pn_runtime_to_design)
+                "Which transformation do you want to execute?",
+                "Which model to bind for source element PetriNets_Runtime",
+                "Which model to create for target element PetriNets",
+                "Transformation executed with result: True",
+                "Ready for command...",
+                # transformation_execute (pn_print)
+                "Which transformation do you want to execute?",
+                "Which model to bind for source element PetriNets",
+                None,
+                None,
+                None,
+                "Transformation executed with result: True",
+                "Ready for command...",
+                ]
+
+        self.assertTrue(run_file(all_files,
+            [ "root", "root", "root", 
+                "model_add",
+                    "SimpleClassDiagrams",
+                    "PetriNets",
+                    ] + get_model_constructor(open("integration/code/pn_design.mvc", "r").read()) + [
+                "model_add",
+                    "SimpleClassDiagrams",
+                    "PetriNets_Runtime",
+                    ] + get_model_constructor(open("integration/code/pn_runtime.mvc", "r").read()) + [
+                "model_add",
+                    "PetriNets",
+                    "my_pn",
+                    ] + get_model_constructor(open("integration/code/pn_design_model_larger.mvc", "r").read()) + [
+                "model_list",
+                "transformation_add_MT_language",
+                    "PetriNets_Runtime",
+                    "PetriNets",
+                    "",
+                    "PetriNets_RAM",
+                "model_list",
+                "model_modify",
+                    "__merged_PetriNets_RAM",
+                        "instantiate",
+                            "Association",
+                            "D2R_PlaceLink",
+                            "PetriNets/Place",
+                            "PetriNets_Runtime/Place",
+                        "instantiate",
+                            "Association",
+                            "D2R_TransitionLink",
+                            "PetriNets/Transition",
+                            "PetriNets_Runtime/Transition",
+                        "instantiate",
+                            "Association",
+                            "R2D_PlaceLink",
+                            "PetriNets_Runtime/Place",
+                            "PetriNets/Place",
+                        "instantiate",
+                            "Association",
+                            "R2D_TransitionLink",
+                            "PetriNets_Runtime/Transition",
+                            "PetriNets/Transition",
+                        "exit",
+                "transformation_RAMify",
+                    "__merged_PetriNets_RAM",
+                    "PetriNets_RAM",
+                "transformation_add_MT",
+                    "PetriNets_RAM",
+                    "PetriNets",
+                    "",
+                    "PetriNets_Runtime",
+                    "",
+                    "pn_design_to_runtime",
+                    ] + get_model_constructor(open("integration/code/pn_design_to_runtime.mvc", "r").read()) + [
+                "transformation_add_MT",
+                    "PetriNets_RAM",
+                    "PetriNets_Runtime",
+                    "",
+                    "PetriNets",
+                    "",
+                    "pn_runtime_to_design",
+                    ] + get_model_constructor(open("integration/code/pn_runtime_to_design.mvc", "r").read()) + [
+                "transformation_add_MT",
+                    "PetriNets_RAM",
+                    "PetriNets_Runtime",
+                    "",
+                    "PetriNets_Runtime",
+                    "",
+                    "pn_step",
+                    ] + get_model_constructor(open("integration/code/pn_simulate.mvc", "r").read()) + [
+                "transformation_add_MT",
+                    "PetriNets_RAM",
+                    "PetriNets",
+                    "",
+                    "",
+                    "pn_print",
+                    ] + get_model_constructor(open("integration/code/pn_print.mvc", "r").read()) + [
+                "model_list",
+                "transformation_list",
+                "transformation_execute",
+                "pn_print",
+                "my_pn",
+                "transformation_execute",
+                "pn_design_to_runtime",
+                "my_pn",
+                "my_pn_runtime", ] + [
+                    "transformation_execute",
+                    "pn_step",
+                    "my_pn_runtime",
+                    "my_pn_runtime",
+                    "transformation_execute",
+                    "pn_runtime_to_design",
+                    "my_pn_runtime",
+                    "my_pn",
+                    "transformation_execute",
+                    "pn_print",
+                    "my_pn",
+                    ] * 10 + [
+            ],
+            [   # bootup phase
+                "Desired username for admin user?",
+                "Desired password for admin user?",
+                "Please repeat the password",
+                "Passwords match!",
+                "Welcome to the Model Management Interface v2.0!",
+                "Use the 'help' command for a list of possible commands",
+                "Ready for command...",
+                # model_add
+                "Creating new model!",
+                "Model type?",
+                "Model name?",
+                "Waiting for model constructors...",
+                "Model upload success!",
+                "Ready for command...",
+                # model_add
+                "Creating new model!",
+                "Model type?",
+                "Model name?",
+                "Waiting for model constructors...",
+                "Model upload success!",
+                "Ready for command...",
+                # model_add
+                "Creating new model!",
+                "Model type?",
+                "Model name?",
+                "Waiting for model constructors...",
+                "Model upload success!",
+                "Ready for command...",
+                # model_list
+                set(["  SimpleClassDiagrams : SimpleClassDiagrams",
+                     "  CoreFormalism : SimpleClassDiagrams",
+                     "  PetriNets : SimpleClassDiagrams",
+                     "  my_pn : PetriNets",
+                     "  PetriNets_Runtime : SimpleClassDiagrams",
+                     "  core : CoreFormalism"]),
+                "Ready for command...",
+                # transformation_add_MT_language
+                "Formalisms to include (terminate with empty string)?",
+                "Name of the RAMified transformation metamodel?",
+                "Ready for command...",
+                # model_list
+                set(["  SimpleClassDiagrams : SimpleClassDiagrams",
+                     "  CoreFormalism : SimpleClassDiagrams",
+                     "  PetriNets_Runtime : SimpleClassDiagrams",
+                     "  PetriNets : SimpleClassDiagrams",
+                     "  __merged_PetriNets_RAM : SimpleClassDiagrams",
+                     "  PetriNets_RAM : SimpleClassDiagrams",
+                     "  my_pn : PetriNets",
+                     "  core : CoreFormalism"]),
+                "Ready for command...",
+                # model_modify
+                "Which model do you want to modify?",
+                "Model loaded, ready for commands!",
+                "Use 'help' command for a list of possible commands",
+                "Please give your command.",
+                # instantiate 1
+                "Type to instantiate?",
+                "Name of new element?",
+                "Source name?",
+                "Destination name?",
+                "Instantiation successful!",
+                "Please give your command.",
+                # instantiate 2
+                "Type to instantiate?",
+                "Name of new element?",
+                "Source name?",
+                "Destination name?",
+                "Instantiation successful!",
+                "Please give your command.",
+                # instantiate 3
+                "Type to instantiate?",
+                "Name of new element?",
+                "Source name?",
+                "Destination name?",
+                "Instantiation successful!",
+                "Please give your command.",
+                # instantiate 4
+                "Type to instantiate?",
+                "Name of new element?",
+                "Source name?",
+                "Destination name?",
+                "Instantiation successful!",
+                "Please give your command.",
+                "Ready for command...",
+                # transformation_RAMify
+                "Which metamodel do you want to RAMify?",
+                "Where do you want to store the RAMified metamodel?",
+                "Ready for command...",
+                # transformation_add_MT
+                "RAMified metamodel to use?",
+                "Supported metamodels:",
+                set(["  PetriNets",
+                     "  PetriNets_Runtime",
+                    ]),
+                "",
+                "Which ones do you want to use as source (empty string to finish)?",
+                "Model added as source",
+                "Which ones do you want to use as target (empty string to finish)?",
+                "Model added as target",
+                "Name of new transformation?",
+                "Waiting for model constructors...",
+                "Ready for command...",
+                # transformation_add_MT
+                "RAMified metamodel to use?",
+                "Supported metamodels:",
+                set(["  PetriNets",
+                     "  PetriNets_Runtime",
+                    ]),
+                "",
+                "Which ones do you want to use as source (empty string to finish)?",
+                "Model added as source",
+                "Which ones do you want to use as target (empty string to finish)?",
+                "Model added as target",
+                "Name of new transformation?",
+                "Waiting for model constructors...",
+                "Ready for command...",
+                # transformation_add_MT
+                "RAMified metamodel to use?",
+                "Supported metamodels:",
+                set(["  PetriNets",
+                     "  PetriNets_Runtime",
+                    ]),
+                "",
+                "Which ones do you want to use as source (empty string to finish)?",
+                "Model added as source",
+                "Which ones do you want to use as target (empty string to finish)?",
+                "Model added as target",
+                "Name of new transformation?",
+                "Waiting for model constructors...",
+                "Ready for command...",
+                # transformation_add_MT
+                "RAMified metamodel to use?",
+                "Supported metamodels:",
+                set(["  PetriNets",
+                     "  PetriNets_Runtime",
+                    ]),
+                "",
+                "Which ones do you want to use as source (empty string to finish)?",
+                "Model added as source",
+                "Which ones do you want to use as target (empty string to finish)?",
+                "Name of new transformation?",
+                "Waiting for model constructors...",
+                "Ready for command...",
+                # model_list
+                set(["  SimpleClassDiagrams : SimpleClassDiagrams",
+                     "  CoreFormalism : SimpleClassDiagrams",
+                     "  PetriNets_Runtime : SimpleClassDiagrams",
+                     "  PetriNets : SimpleClassDiagrams",
+                     "  pn_print : PetriNets_RAM",
+                     "  pn_design_to_runtime : PetriNets_RAM",
+                     "  pn_runtime_to_design : PetriNets_RAM",
+                     "  pn_step : PetriNets_RAM",
+                     "  __merged_PetriNets_RAM : SimpleClassDiagrams",
+                     "  PetriNets_RAM : SimpleClassDiagrams",
+                     "  my_pn : PetriNets",
+                     "  core : CoreFormalism"]),
+                "Ready for command...",
+                # transformation_list
+                set(["[ModelTransformation] pn_print : PetriNets_RAM",
+                     "[ModelTransformation] pn_design_to_runtime : PetriNets_RAM",
+                     "[ModelTransformation] pn_runtime_to_design : PetriNets_RAM",
+                     "[ModelTransformation] pn_step : PetriNets_RAM"]),
+                "Ready for command...",
+                # transformation_execute (pn_print)
+                "Which transformation do you want to execute?",
+                "Which model to bind for source element PetriNets",
+                set(['"lock_available" --> 1',
+                     '"critical_section_1" --> 0',
+                     '"critical_section_2" --> 0',
+                    ]),
+                "Transformation executed with result: True",
+                "Ready for command...",
+                # transformation_execute (pn_design_to_runtime)
+                "Which transformation do you want to execute?",
+                "Which model to bind for source element PetriNets",
+                "Which model to create for target element PetriNets_Runtime",
+                "Transformation executed with result: True",
+                "Ready for command...",
+                ] + \
+                    step_and_print() * 10 +
+                [],
+            mode))

integration/utils.py

@@ -16,7 +16,7 @@ sys.path.append("scripts")
 from hutn_compiler.compiler import main as do_compile
 from check_objects import to_recompile
 
-username = "test_user"
+taskname = "test_task"
 parallel_push = True
 
 ports = set()
@@ -51,7 +51,7 @@ def kill(process):
 
 def flush_data(address, data):
     if data:
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "username": username})), timeout=10).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "taskname": taskname})), timeout=10).read()
     return []
 
 def compile_file(address, mod_filename, filename, mode, proc):
@@ -59,9 +59,9 @@ def compile_file(address, mod_filename, filename, mode, proc):
     try:
         timeout_val = 240
         import random
-        username = str(random.random())
+        taskname = str(random.random())
         while 1:
-            proc2 = execute("compile", [address, mod_filename, username, filename, mode], wait=False)
+            proc2 = execute("compile", [address, mod_filename, taskname, filename, mode], wait=False)
 
             if proc.returncode is not None:
                 # Modelverse has already terminated, which isn't a good sign!
@@ -139,7 +139,7 @@ def run_file(files, parameters, expected, mode, wait=False):
 
         if mode[-1] == "O":
             # Fire up the linker
-            val = execute("link_and_load", [address, username] + mod_files, wait=True)
+            val = execute("link_and_load", [address, taskname] + mod_files, wait=True)
             if val != 0:
                 raise Exception("Linking error")
 
@@ -149,13 +149,13 @@ def run_file(files, parameters, expected, mode, wait=False):
         # ... and wait for replies
         if expected is None:
             while 1:
-                val = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username})), timeout=240).read()
+                val = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname})), timeout=240).read()
                 val = json.loads(val)
                 print(val)
         for e in expected:
             c = len(e) if isinstance(e, set) else 1
             for _ in range(c):
-                val = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username})), timeout=240).read()
+                val = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname})), timeout=240).read()
                 val = json.loads(val)
 
                 if proc.returncode is not None:
@@ -167,6 +167,9 @@ def run_file(files, parameters, expected, mode, wait=False):
                     assert val in e
                     if val not in e:
                         return False
+                elif e is None:
+                    # Skip output value
+                    pass
                 else:
                     assert val == e
                     if val != e:
@@ -189,7 +192,7 @@ def run_barebone(parameters, expected, interface="0", timeout=False, wait=False,
         # Run Modelverse server
         proc = execute("run_local_modelverse", [str(port)], wait=False)
 
-        # Create user and set interface
+        # Create task and set interface
         timeout_val = 15
         start = time.time()
         while 1:
@@ -199,9 +202,9 @@ def run_barebone(parameters, expected, interface="0", timeout=False, wait=False,
                 return False
 
             try:
-                urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "element_type": "V", "value": '"%s"' % username, "username": "user_manager"})), timeout=1).read()
+                urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "element_type": "V", "value": '"%s"' % taskname, "taskname": "task_manager"})), timeout=1).read()
                 if interface is not None:
-                    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "element_type": "V", "value": interface, "username": username})), timeout=1).read()
+                    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "element_type": "V", "value": interface, "taskname": taskname})), timeout=1).read()
                 break
             except:
                 time.sleep(0.01)
@@ -216,7 +219,7 @@ def run_barebone(parameters, expected, interface="0", timeout=False, wait=False,
         if link is not None:
             # Execute linker
             timeout_val = 10
-            proc2 = execute("link_and_load", [address, username] + link, wait=False)
+            proc2 = execute("link_and_load", [address, taskname] + link, wait=False)
 
             while proc2.returncode is None:
                 time.sleep(0.01)
@@ -231,7 +234,7 @@ def run_barebone(parameters, expected, interface="0", timeout=False, wait=False,
                     return False
 
         for inp in inputs:
-            urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "element_type": "V", "value": inp, "username": username})), timeout=1).read()
+            urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "element_type": "V", "value": inp, "taskname": taskname})), timeout=1).read()
             proc.poll()
             if proc.returncode is not None:
                 # Modelverse has already terminated, which isn't a good sign!
@@ -248,7 +251,7 @@ def run_barebone(parameters, expected, interface="0", timeout=False, wait=False,
                         # Modelverse has already terminated, which isn't a good sign!
                         return False
 
-                    val = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username})), timeout=240 if not timeout else 20).read()
+                    val = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname})), timeout=240 if not timeout else 20).read()
                     val = json.loads(val)
                 except:
                     if timeout:
@@ -261,6 +264,9 @@ def run_barebone(parameters, expected, interface="0", timeout=False, wait=False,
                     assert val in e
                     if val not in e:
                         return False
+                elif e is None:
+                    # Skip this input
+                    pass
                 else:
                     assert val == e
                     if val != e:

interface/CBD/main.py

@@ -18,7 +18,7 @@ JUMP = 50
 MAX_WIDTH = 20 * JUMP
 MAX_HEIGHT = 20 * JUMP
 address = "http://127.0.0.1:8001"
-username = "test"
+taskname = "test"
 
 root = Tk()
 
@@ -72,7 +72,7 @@ def poll(address):
     working_simulation = None
 
     while 1:
-        returnvalue = json.loads(urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username}))).read())
+        returnvalue = json.loads(urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname}))).read())
         print("Process " + str(returnvalue))
         if (returnvalue.startswith("AVAILABLE_ATTR_VALUE")):
             working_available_attrs.append([json.loads(returnvalue.split(" ", 1)[1]), None])
@@ -110,58 +110,58 @@ class MvLayer():
         import threading
 
         self.address = address
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % username, "username": "user_manager"}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % taskname, "taskname": "task_manager"}))).read()
         thrd = threading.Thread(target=poll, args=[address])
         thrd.daemon = True
         thrd.start()
 
     def read_available_attributes(self, name):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_available_attributes"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_available_attributes"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "taskname": taskname}))).read()
 
         while not available_attrs:
             time.sleep(0.1)
         return available_attrs.pop(0)
 
     def read_attribute(self, name, attr):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_attribute"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_attribute"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "taskname": taskname}))).read()
 
         while not attribute:
             time.sleep(0.1)
         return attribute.pop(0)
 
     def set_attribute(self, name, attr, value):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"set_attribute"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": json.dumps(value), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"set_attribute"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": json.dumps(value), "taskname": taskname}))).read()
 
     def instantiate_block(self, name, block_type):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate_node"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (block_type), "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate_node"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (block_type), "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "taskname": taskname}))).read()
 
     def instantiate_link(self, name, link_type, source, target):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate_association"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (link_type), "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (source), "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (target), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate_association"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (link_type), "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (source), "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (target), "taskname": taskname}))).read()
 
     def simulate(self):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"simulate"', "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"simulate"', "taskname": taskname}))).read()
 
     def step(self):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"step"', "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"step"', "taskname": taskname}))).read()
 
     def pause(self):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"pause"', "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"pause"', "taskname": taskname}))).read()
 
     def delete(self, block):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"delete_element"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (block), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"delete_element"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (block), "taskname": taskname}))).read()
 
 def lower(value):
     return value / JUMP * JUMP

interface/FSA/main.py

@@ -21,7 +21,7 @@ MAX_WIDTH = 10 * JUMP
 MAX_HEIGHT = 10 * JUMP
 CLICK_TOLERANCE = 5
 address = "http://127.0.0.1:8001"
-username = "test"
+taskname = "test"
 
 root = Tk()
 names = {}
@@ -101,7 +101,7 @@ def poll(address):
     global request_new_state
 
     while 1:
-        returnvalue = json.loads(urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username}))).read())
+        returnvalue = json.loads(urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname}))).read())
         print("Process " + str(returnvalue))
         if (returnvalue.startswith("AVAILABLE_ATTR_VALUE")):
             working_available_attrs.append([json.loads(returnvalue.split(" ", 1)[1]), None])
@@ -140,7 +140,7 @@ class MvLayer():
         import threading
 
         self.address = address
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % username, "username": "user_manager"}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % taskname, "taskname": "task_manager"}))).read()
         thrd = threading.Thread(target=poll, args=[address])
         thrd.daemon = True
         thrd.start()
@@ -156,8 +156,8 @@ class MvLayer():
         thrd.start()
 
     def read_available_attributes(self, name):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_available_attributes"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_available_attributes"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "taskname": taskname}))).read()
 
         while 1:
             try:
@@ -168,9 +168,9 @@ class MvLayer():
 
     def read_attribute(self, name, attr):
         print("Sending read_attribute")
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_attribute"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_attribute"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "taskname": taskname}))).read()
 
         print("Waiting for attribute")
         while 1:
@@ -181,51 +181,51 @@ class MvLayer():
                 time.sleep(0.1)
 
     def set_attribute(self, name, attr, value):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"set_attribute"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": json.dumps(value), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"set_attribute"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": json.dumps(value), "taskname": taskname}))).read()
 
     def instantiate_element(self, name, block_type):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate_node"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (block_type), "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate_node"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (block_type), "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "taskname": taskname}))).read()
 
     def instantiate_link(self, name, link_type, source, target):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate_association"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (link_type), "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (source), "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (target), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate_association"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (link_type), "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (source), "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (target), "taskname": taskname}))).read()
 
     def simulate(self):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"simulate"', "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"simulate"', "taskname": taskname}))).read()
 
     def pause(self):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"pause"', "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"pause"', "taskname": taskname}))).read()
 
     def send_event(self, event):
         print("SENDING EVENT")
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"event"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (event), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"event"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (event), "taskname": taskname}))).read()
 
     def delete(self, block):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"delete_element"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (block), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"delete_element"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (block), "taskname": taskname}))).read()
 
     def switch_initial(self, name):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"switch_initial"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"switch_initial"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "taskname": taskname}))).read()
 
     def auto_sanitize(self, auto):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"auto_sanitize"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": "true" if auto else "false", "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"auto_sanitize"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": "true" if auto else "false", "taskname": taskname}))).read()
 
     def set_current(self, name):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "taskname": taskname}))).read()
 
     def poll(self):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"poll"', "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"poll"', "taskname": taskname}))).read()
 
 def lower(value):
     return value / JUMP * JUMP

interface/HUTN/grammars/actionlanguage.g

@@ -1,10 +1,6 @@
 grammar{
     start: (include | vardecl | definition | funcdecl | newline)+;
 
-    definition : type_specifier ID ASSIGN atomvalue;
-
-    include: INCLUDE STRVALUE newline+;
-
     statement 
         : (vardecl newline)
         | (assignment newline)
@@ -12,18 +8,21 @@ grammar{
         | (func_call newline)
         | ifelse
         | while
+        | (continue newline)
+        | (break newline)
         | newline @Rm;
 
-    vardecl: type_specifier ID;
+    primary
+        :   parenthesized
+        |   rvalue
+        |   func_call
+        |   atomvalue;
 
-    assignment
-        :   lvalue ASSIGN expression;
+    assignment: lvalue ASSIGN expression;
 
-    expression
-        :   binary_operation;
+    expression: binary_operation;
 
-	binary_operation
-	    :   disjunction;
+	binary_operation: disjunction;
 
     disjunction
         :   (disjunction OR conjunction)
@@ -60,37 +59,42 @@ grammar{
         |   invert_sign
         |   keep_sign
         |   primary;
-	logical_not
-	    :   NOT primary;
-	invert_sign
-	    :   MINUS primary;
-	keep_sign
-	    :   PLUS primary;
 
-    primary
-        :   parenthesized
-        |   rvalue
-        |   func_call
-        |   atomvalue;
+    rvalue
+        : (rvalue LSQUARE expression RSQUARE)
+        | ID;
 
-    parenthesized
-        :   LPAREN expression RPAREN;
+    vardecl: type_specifier ID;
+
+	logical_not: NOT primary;
+
+	invert_sign: MINUS primary;
+
+	keep_sign: PLUS primary;
+
+    definition : type_specifier ID ASSIGN atomvalue;
+
+    include: INCLUDE STRVALUE newline+;
+
+    continue: CONTINUE EXCLAMATION;
+
+    break: BREAK EXCLAMATION;
+
+    parenthesized: LPAREN expression RPAREN;
 
     atomvalue: string | integer | float | bool | type_specifier | actionname | deref;
 
     deref: QUESTIONMARK ANYTHING?;
 
     type_specifier: INT | FLOAT | BOOL | STRING | TYPE | ACTION | ELEMENT;
+
     actionname: IF_NODE | WHILE_NODE | ASSIGN_NODE | CALL_NODE | BREAK_NODE | CONTINUE_NODE | RETURN_NODE | RESOLVE_NODE | ACCESS_NODE | CONSTANT_NODE | GLOBAL_NODE | DECLARE_NODE | INPUT_NODE | OUTPUT_NODE;
 
     string: (STRVALUE|LONG_STRVALUE);
 
     integer: DEC_NUMBER;
-    float: FLOAT_NUMBER;
 
-    rvalue
-        : (rvalue LSQUARE expression RSQUARE)
-        | ID;
+    float: FLOAT_NUMBER;
 
     lvalue: ID;
 
@@ -148,11 +152,12 @@ grammar{
 
         FUNCTION: 'function';
         RETURN: 'return';
-
         WHILE: 'while';
         IF: 'if';
         ELSE: 'else';
         ELIF: 'elif';
+        CONTINUE: 'continue';
+        BREAK: 'break';
 
         INT: 'Integer';
         FLOAT: 'Float';

interface/HUTN/hutn_compiler/constructors_object_visitor.py

@@ -14,7 +14,7 @@ class ConstructorsObjectVisitor(ConstructorsVisitor):
     def __init__(self, args):
         ConstructorsVisitor.__init__(self, args)
 
-        self.username = args[0]
+        self.taskname = args[0]
         self.obj_file = args[1]
         self.real_file = args[2]
         self.address = args[3]
@@ -27,8 +27,8 @@ class ConstructorsObjectVisitor(ConstructorsVisitor):
             md5.update(f.read())
         self.hash_file = md5.hexdigest()
 
-        # Create user
-        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "value": '"%s"' % self.username, "username": "user_manager"}))).read()
+        # Create task
+        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "value": '"%s"' % self.taskname, "taskname": "task_manager"}))).read()
 
         simple_filename = self.real_file.rsplit("/")[-1]
         print("[COMPILE] %s" % simple_filename)
@@ -38,7 +38,7 @@ class ConstructorsObjectVisitor(ConstructorsVisitor):
 
         def flush_data(data):
             if data:
-                urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "username": self.username})), timeout=timeout).read()
+                urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "taskname": self.taskname})), timeout=timeout).read()
             return []
 
         # Set up interface
@@ -52,11 +52,11 @@ class ConstructorsObjectVisitor(ConstructorsVisitor):
         # Finish the symbol table
         data.append(False)
 
-        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "username": self.username}))).read()
+        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "taskname": self.taskname}))).read()
 
         # Wait for kernel to signal that it finished
-        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "value": '2', "username": self.username}))).read()
-        v = urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "get_output", "username": self.username}))).read()
+        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "value": '2', "taskname": self.taskname}))).read()
+        v = urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "get_output", "taskname": self.taskname}))).read()
         v = json.loads(v)
         if v == "DONE":
             return True

interface/HUTN/hutn_compiler/constructors_visitor.py

@@ -10,7 +10,6 @@ class ConstructorsVisitor(Visitor):
     def dump(self):
         return self.constructors
         # return pickle.dumps(self.constructors, pickle.HIGHEST_PROTOCOL)
-        # return '\n'.join([repr(x) for x in self.constructors])
 
     def add_constructors(self, *constructors):
         self.constructors.extend(constructors)
@@ -27,7 +26,7 @@ class ConstructorsVisitor(Visitor):
         #     tree.get_tail_without(["newline", "funcdecl"])
         last = tail[-1]
         for child in tail[:-1]:
-            if child.head == "return":
+            if child.head in ["return", "break", "continue"]:
                 last = child
                 break
             else:
@@ -41,7 +40,7 @@ class ConstructorsVisitor(Visitor):
         if last.head == "func_call":  # pop 'false'
             self.constructors.pop()
         if new_constructors_were_added:
-            if last.head != "return":
+            if last.head not in ["return", "break", "continue"]:
                 self.add_constructors(False)
         elif self.constructors:
             self.constructors.pop()  # pop 'true'
@@ -196,7 +195,7 @@ class ConstructorsVisitor(Visitor):
         tail = tree.get_tail_without(["newline", "indent"])
         last = tail[-1]
         for child in tail[:-1]:
-            if child.head == "return":
+            if child.head in ["return", "break", "continue"]:
                 last = child
                 break
             else:
@@ -207,7 +206,7 @@ class ConstructorsVisitor(Visitor):
         self.visit(last)
         if last.head == "func_call":  # pop 'false'
             self.constructors.pop()
-        if last.head != "return":
+        if last.head not in ["return", "break", "continue"]:
             self.add_constructors(False)
 
     def visit_func_body(self, tree):
@@ -256,6 +255,14 @@ class ConstructorsVisitor(Visitor):
         self.add_constructors(symbol.node)
         self.free_id += 1
 
+    def visit_continue(self, tree):
+        self.add_constructors("continue")
+        return True
+
+    def visit_break(self, tree):
+        self.add_constructors("break")
+        return True
+        
     def visit_return(self, tree):
         self.add_constructors("return")
         if len(tree.get_tail()) > 2:

interface/HUTN/hutn_compiler/linker.py

@@ -5,17 +5,17 @@ import json
 
 sys.path.append("scripts")
 
-def link(address, username, objects):
+def link(address, taskname, objects):
     # Read out all symbol tables that are to be linked
     definers = {}
-    users = {}
+    tasks = {}
     def flush_data(data):
         if data:
-            urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "username": username})), timeout=10).read()
+            urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "taskname": taskname})), timeout=10).read()
         return []
     flush_data([3, "link_and_load"] + objects + ["", "main"])
 
-    v = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username}))).read()
+    v = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname}))).read()
     v = json.loads(v)
     if "OK" not in v:
         print(v)
@@ -23,13 +23,13 @@ def link(address, username, objects):
 
 if __name__ == "__main__":
     if len(sys.argv) == 1:
-        print("No username defined")
+        print("No taskname defined")
     else:
         address = sys.argv[1]
-        username = sys.argv[2]
+        taskname = sys.argv[2]
         objects = set(sys.argv[3:])
 
         if objects:
-            link(address, username, objects)
+            link(address, taskname, objects)
         else:
             print("No files to link defined")

interface/HUTN/hutn_compiler/model_object_visitor.py

@@ -11,7 +11,7 @@ def empty(s):
 class ModelObjectVisitor(ModelVisitor):
     def __init__(self, args):
         ModelVisitor.__init__(self, args)
-        self.username = args[0]
+        self.taskname = args[0]
         self.obj_file = args[1]
         self.real_file = args[2]
         self.address = args[3]
@@ -23,8 +23,8 @@ class ModelObjectVisitor(ModelVisitor):
         # Wait for kernel to signal that it finished
         data.append(2)
 
-        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "username": self.username}))).read()
-        v = urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "get_output", "username": self.username}))).read()
+        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "taskname": self.taskname}))).read()
+        v = urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "get_output", "taskname": self.taskname}))).read()
         v = json.loads(v)
         if v == "DONE":
             return True

interface/HUTN/hutn_compiler/primitives_object_visitor.py

@@ -10,7 +10,7 @@ class PrimitivesObjectVisitor(PrimitivesVisitor):
     def __init__(self, args):
         PrimitivesVisitor.__init__(self, args)
 
-        self.username = args[0]
+        self.taskname = args[0]
         self.obj_file = args[1]
         self.real_file = args[2]
         self.address = args[3]
@@ -23,8 +23,8 @@ class PrimitivesObjectVisitor(PrimitivesVisitor):
             md5.update(f.read())
         self.hash_file = md5.hexdigest()
 
-        # Create user
-        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "value": '"%s"' % self.username, "username": "user_manager"}))).read()
+        # Create task
+        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "value": '"%s"' % self.taskname, "taskname": "task_manager"}))).read()
 
         simple_filename = self.real_file.rsplit("/")[-1]
         print("[COMPILE] %s" % simple_filename)
@@ -49,8 +49,8 @@ class PrimitivesObjectVisitor(PrimitivesVisitor):
         # Wait for kernel to signal that it finished
         data.append(2)
 
-        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "username": self.username}))).read()
-        v = urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "get_output", "username": self.username}))).read()
+        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "taskname": self.taskname}))).read()
+        v = urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "get_output", "taskname": self.taskname}))).read()
         v = json.loads(v)
         if v == "DONE":
             return True

interface/HUTN/hutn_compiler/primitives_visitor.py

@@ -13,6 +13,7 @@ class PrimitivesVisitor(Visitor):
         self.free_id = 0
         self.function_values = dict()
         self.debug_symbols = "--debug" in args
+        self.while_stack = []
 
     def debug(self, node, tree, msg=""):
         if self.debug_symbols:
@@ -296,10 +297,23 @@ class PrimitivesVisitor(Visitor):
 
         self.set_primitive(tree, first)
 
+    def visit_continue(self, tree):
+        w = self.value(Action("continue"))
+        self.dict(w, "while", self.while_stack[-1])
+        self.set_primitive(tree, w)
+
+    def visit_break(self, tree):
+        w = self.value(Action("break"))
+        self.dict(w, "while", self.while_stack[-1])
+        self.set_primitive(tree, w)
+
     def visit_while(self, tree):
+        w = self.value(Action("while"))
+
+        self.while_stack.append(w)
         self.visit_children(tree)
+        self.while_stack.pop()
 
-        w = self.value(Action("while"))
         self.debug(w, tree)
         c = self.get_primitive(tree.get_child("expression"))
         b = self.get_primitive(tree.get_child("block"))

interface/HUTN/hutn_compiler/semantics_visitor.py

@@ -14,6 +14,9 @@ class SemanticsVisitor(Visitor):
         # there is only one input file, list is for sharing it among visitors
         self.inputfiles = []
 
+        # Count whether we are in a while or not
+        self.while_counter = 0
+
         # inherited attribute, set in funcdecl and used in return,
         # to ensure that (returned type == declared type)
         self.current_funcdecl = None
@@ -591,7 +594,9 @@ class SemanticsVisitor(Visitor):
             self.check_predicate(expression)
 
     def visit_while(self, tree):
+        self.while_counter += 1
         self.visit_children(tree)
+        self.while_counter -= 1
         expression = tree.get_child("expression")
         self.check_predicate(expression)
 
@@ -640,3 +645,17 @@ class SemanticsVisitor(Visitor):
 
     def visit_bool(self, tree):
         self.set_type(tree, types_mv.Boolean())
+
+    def visit_break(self, tree):
+        if self.while_counter == 0:
+            raise RuntimeError(
+                "{}:{}:{}: error: break outside of while".format(
+                    self.inputfiles[0], tree.startpos['line'],
+                    tree.startpos['column']))
+
+    def visit_continue(self, tree):
+        if self.while_counter == 0:
+            raise RuntimeError(
+                "{}:{}:{}: error: continue outside of while".format(
+                    self.inputfiles[0], tree.startpos['line'],
+                    tree.startpos['column']))

interface/HUTN/includes/primitives.alh

@@ -81,7 +81,7 @@ Boolean function string_startswith(a: String, b: String)
 Element function deserialize(a: String) 
 String function log(a: String)
 Element function read_root()
-Element function read_userroot()
+Element function read_taskroot()
 Element function input()
 Element function output(a : Element)
 Boolean function is_physical_int(a : Element)

interface/HUTN/includes/task_interface.alh

@@ -0,0 +1 @@
+Void function new_task()

interface/HUTN/includes/task_manager.alh

@@ -0,0 +1 @@
+Void function task_management()

interface/HUTN/includes/user_interface.alh

@@ -1 +0,0 @@
-Void function new_user()

interface/HUTN/includes/user_manager.alh

@@ -1 +0,0 @@
-Void function user_management()

kernel/modelverse_kernel/compiled.py

@@ -452,4 +452,4 @@ def retype(a, b, c, **remainder):
         yield [("DE", [prev_edge])]
     t, =        yield [("CE", [tm, mm_ref])]
     yield [("CE", [t, m_ref])]
-    raise PrimitiveFinished(None)
+    raise PrimitiveFinished(None)

kernel/modelverse_kernel/primitives.py

@@ -486,7 +486,6 @@ def is_edge(a, **remainder):
 
 #TODO deprecate
 def deserialize(a, root, **remainder):
-    print("DESERIALIZE")
     value, = yield [("RV", [a])]
     id_mappings = {}
     complex_primitives = frozenset(["if", "while", "assign", "call", "break", "continue", "return","resolve","access", "constant", "input", "output", "declare", "global"])
@@ -559,8 +558,8 @@ def log(a, **remainder):
     print("== LOG == " + str(a_value))
     raise PrimitiveFinished(a)
 
-def read_userroot(user_root, **remainder):
-    raise PrimitiveFinished(user_root)
+def read_taskroot(task_root, **remainder):
+    raise PrimitiveFinished(task_root)
 
 def time(**remainder):
     import time

kernel/mvk_server/classes/executor.xml

@@ -65,22 +65,22 @@
                 <state id="queue">
                     <transition event="execute" target=".">
                         <parameter name="returnpath"/>
-                        <parameter name="username"/>
+                        <parameter name="taskname"/>
                         <parameter name="operation"/>
                         <parameter name="params"/>
                         <parameter name="request_id"/>
                         <script>
-                            self.request_queue.append((("/" + returnpath) if returnpath is not None else None, username, operation, params, request_id, True))
+                            self.request_queue.append((("/" + returnpath) if returnpath is not None else None, taskname, operation, params, request_id, True))
                         </script>
                     </transition>
                     <transition event="execute_debug" target=".">
                         <parameter name="returnpath"/>
-                        <parameter name="username"/>
+                        <parameter name="taskname"/>
                         <parameter name="operation"/>
                         <parameter name="params"/>
                         <parameter name="request_id"/>
                         <script>
-                            self.request_queue.append((("/" + returnpath) if returnpath is not None else None, username, operation, params, request_id, False))
+                            self.request_queue.append((("/" + returnpath) if returnpath is not None else None, taskname, operation, params, request_id, False))
                         </script>
                     </transition>
                 </state>
@@ -98,11 +98,11 @@
                             self.mvk.success = True
                             self.first = True
 
-                            self.returnpath, username, operation, params, self.request_id, self.mvk.allow_compiled = self.request_queue.pop(0)
+                            self.returnpath, taskname, operation, params, self.request_id, self.mvk.allow_compiled = self.request_queue.pop(0)
                             reply = None
                             commands = []
                             while 1:
-                                commands = self.mvk.execute_yields(username, operation, params, reply)
+                                commands = self.mvk.execute_yields(taskname, operation, params, reply)
                                 if commands is None:
                                     break
                                 reply = [self.mvs_operations[command[0]](*(command[1]))[0] for command in commands]

kernel/mvk_server/classes/mvkcontroller.xml

@@ -2,17 +2,17 @@
     <relationships>
         <association name="to_mvs" class="HTTPClient" min="1" max="1"/>
         <association name="to_mvi" class="Server" min="1" max="1"/>
-        <association name="users" class="UserStatechart"/>
+        <association name="tasks" class="UserStatechart"/>
         <association name="executor" class="Executor" min="1" max="1"/>
     </relationships>
     <constructor>
         <parameter name="params"/>
         <body>
             <![CDATA[
-            self.users = []
-            self.user_statecharts = {"__hierarchy": None}
+            self.tasks = []
+            self.task_statecharts = {"__hierarchy": None}
             self.input_queue = []
-            self.user_queue = {}
+            self.task_queue = {}
             self.source = None
             self.root = None
 
@@ -101,12 +101,12 @@
                                     else:
                                         value = json.loads(data["data"])
                                     for v in value[:-1]:
-                                        self.input_queue.append((None, data["op"], [v], data["username"]))
-                                    self.input_queue.append((source, data["op"], [value[-1]], data["username"]))
+                                        self.input_queue.append((None, data["op"], [v], data["taskname"]))
+                                    self.input_queue.append((source, data["op"], [value[-1]], data["taskname"]))
                                     print("Added to input queue")
                                 else:
                                     print("Appending " + data["op"])
-                                    self.input_queue.append((source, data["op"], args, data["username"]))
+                                    self.input_queue.append((source, data["op"], args, data["taskname"]))
                             except ValueError:
                                 print("Error when deserializing request: " + str(data))
                                 raise
@@ -117,16 +117,16 @@
 
             <state id="push" initial="wait">
                 <state id="wait">
-                    <transition cond="self.input_queue and self.input_queue[0][3] in self.user_statecharts" target="../process"/>
+                    <transition cond="self.input_queue and self.input_queue[0][3] in self.task_statecharts" target="../process"/>
                     <!-- User is not yet detected, so stall this message -->
-                    <transition cond="self.input_queue and self.input_queue[0][3] not in self.user_statecharts" target=".">
-                        <!-- Move it to the back of the list, so we can process other users first -->
+                    <transition cond="self.input_queue and self.input_queue[0][3] not in self.task_statecharts" target=".">
+                        <!-- Move it to the back of the list, so we can process other tasks first -->
                         <script>
-                            print("Queue user")
-                            self.user_queue.setdefault(self.input_queue[0][3], []).append(self.input_queue.pop(0))
+                            print("Queue task")
+                            self.task_queue.setdefault(self.input_queue[0][3], []).append(self.input_queue.pop(0))
                         </script>
                         <!-- Force a refresh too -->
-                        <raise event="force_user_refresh"/>
+                        <raise event="force_task_refresh"/>
                     </transition>
 
                 </state>
@@ -134,9 +134,9 @@
                 <state id="process">
                     <transition cond="self.input_queue[0][1] == 'set_input'" target="../wait">
                         <script>
-                            source, op, args, username = self.input_queue.pop(0)
+                            source, op, args, taskname = self.input_queue.pop(0)
                         </script>
-                        <raise event="set_input" scope="narrow" target="self.user_statecharts[username]">
+                        <raise event="set_input" scope="narrow" target="self.task_statecharts[taskname]">
                             <parameter expr="source"/>
                             <parameter expr="args"/>
                         </raise>
@@ -144,9 +144,9 @@
 
                     <transition cond="self.input_queue[0][1] == 'get_output'" target="../wait">
                         <script>
-                            source, op, args, username = self.input_queue.pop(0)
+                            source, op, args, taskname = self.input_queue.pop(0)
                         </script>
-                        <raise event="get_output" scope="narrow" target="self.user_statecharts[username]">
+                        <raise event="get_output" scope="narrow" target="self.task_statecharts[taskname]">
                             <parameter expr="source"/>
                             <parameter expr="args"/>
                         </raise>
@@ -155,9 +155,9 @@
                     <transition cond="self.input_queue[0][1] == 'pause'" target="../wait">
                         <script>
                             print("Sending pause")
-                            source, op, args, username = self.input_queue.pop(0)
+                            source, op, args, taskname = self.input_queue.pop(0)
                         </script>
-                        <raise event="pause" scope="narrow" target="self.user_statecharts[username]">
+                        <raise event="pause" scope="narrow" target="self.task_statecharts[taskname]">
                             <parameter expr="source"/>
                             <parameter expr="args"/>
                         </raise>
@@ -165,9 +165,9 @@
                     
                     <transition cond="self.input_queue[0][1] == 'resume'" target="../wait">
                         <script>
-                            source, op, args, username = self.input_queue.pop(0)
+                            source, op, args, taskname = self.input_queue.pop(0)
                         </script>
-                        <raise event="resume" scope="narrow" target="self.user_statecharts[username]">
+                        <raise event="resume" scope="narrow" target="self.task_statecharts[taskname]">
                             <parameter expr="source"/>
                             <parameter expr="args"/>
                         </raise>
@@ -175,7 +175,7 @@
                 </state>
             </state>
 
-            <state id="find_users" initial="get_all_links">
+            <state id="find_tasks" initial="get_all_links">
                 <state id="get_all_links">
                     <onentry>
                         <raise event="raw_exec" scope="narrow" target="'executor'">
@@ -184,54 +184,54 @@
                         </raise>
                     </onentry>
 
-                    <transition event="raw_exec_reply" target="../retrieve_users">
+                    <transition event="raw_exec_reply" target="../retrieve_tasks">
                         <parameter name="data"/>
                         <script>
-                            self.users = data[0][0]
+                            self.tasks = data[0][0]
                         </script>
                     </transition>
                 </state>
 
-                <state id="retrieve_users">
-                    <transition cond="self.users" target="../got_usernames">
+                <state id="retrieve_tasks">
+                    <transition cond="self.tasks" target="../got_tasknames">
                         <raise event="raw_exec" scope="narrow" target="'executor'">
-                            <parameter expr="[['RV', [user]] for user in self.users]"/>
+                            <parameter expr="[['RV', [task]] for task in self.tasks]"/>
                             <parameter expr="'parent'"/>
                         </raise>
                     </transition>
-                    <transition cond="not self.users" target="../wait"/>
+                    <transition cond="not self.tasks" target="../wait"/>
                 </state>
 
-                <state id="got_usernames">
-                    <transition event="raw_exec_reply" target="../process_users">
+                <state id="got_tasknames">
+                    <transition event="raw_exec_reply" target="../process_tasks">
                         <parameter name="data"/>
                         <script>
                             data = set([v[0] for v in data])
-                            self.add_users = [v for v in data if v not in self.user_statecharts]
-                            self.delete_users = [v for v in self.user_statecharts if v not in data]
+                            self.add_tasks = [v for v in data if v not in self.task_statecharts]
+                            self.delete_tasks = [v for v in self.task_statecharts if v not in data]
                         </script>
                     </transition>
                 </state>
 
-                <state id="process_users">
-                    <transition cond="not self.add_users and not self.delete_users" target="../wait"/>
-                    <transition cond="self.add_users and not self.delete_users" target="../creating_user">
+                <state id="process_tasks">
+                    <transition cond="not self.add_tasks and not self.delete_tasks" target="../wait"/>
+                    <transition cond="self.add_tasks and not self.delete_tasks" target="../creating_task">
                         <raise event="create_instance" scope="cd">
-                            <parameter expr="'users'"/>
+                            <parameter expr="'tasks'"/>
                             <parameter expr="'UserStatechart'"/>
-                            <parameter expr="self.add_users[0]"/>
+                            <parameter expr="self.add_tasks[0]"/>
                             <parameter expr="self.mvk"/>
                         </raise>
                     </transition>
-                    <transition cond="self.delete_users" target=".">
+                    <transition cond="self.delete_tasks" target=".">
                         <raise event="delete_instance" scope="cd">
-                            <parameter expr="self.user_statecharts.pop(self.delete_users.pop(0))"/>
+                            <parameter expr="self.task_statecharts.pop(self.delete_tasks.pop(0))"/>
                         </raise>
                     </transition>
                 </state>
 
-                <state id="creating_user">
-                    <transition event="instance_created" target="../retrieve_users">
+                <state id="creating_task">
+                    <transition event="instance_created" target="../retrieve_tasks">
                         <parameter name="instancename"/>
                         <raise scope="cd" event="start_instance">
                             <parameter expr="instancename"/>
@@ -240,17 +240,17 @@
                             <parameter expr="instancename"/>
                         </raise>
                         <script>
-                            self.user_statecharts[self.add_users[0]] = instancename
-                            # Repush all this user's messages in the input queue
-                            self.input_queue.extend(self.user_queue.pop(self.add_users[0], []))
-                            self.add_users.pop(0)
+                            self.task_statecharts[self.add_tasks[0]] = instancename
+                            # Repush all this task's messages in the input queue
+                            self.input_queue.extend(self.task_queue.pop(self.add_tasks[0], []))
+                            self.add_tasks.pop(0)
                         </script>
                     </transition>
                 </state>
 
                 <state id="wait">
                     <transition after="1.0" target="../get_all_links"/>
-                    <transition event="force_user_refresh" target="../get_all_links"/>
+                    <transition event="force_task_refresh" target="../get_all_links"/>
                 </state>
             </state>
         </parallel>

kernel/mvk_server/classes/user_statechart.xml

@@ -3,11 +3,11 @@
         <association name="parent" class="MvKController" min="1" max="1"/>
     </relationships>
     <constructor>
-        <parameter name="username"/>
+        <parameter name="taskname"/>
         <parameter name="mvk" />
         <body>
             <![CDATA[
-            self.username = username
+            self.taskname = taskname
             self.mvk = mvk
 
             self.output_queue = []
@@ -37,7 +37,7 @@
                         <onentry>
                             <raise event="execute" scope="narrow" target="'parent/executor'">
                                 <parameter expr="self.returnpath"/>
-                                <parameter expr="self.username"/>
+                                <parameter expr="self.taskname"/>
                                 <parameter expr="'execute_rule'"/>
                                 <parameter expr="[]"/>
                                 <parameter expr="self.request_id"/>
@@ -68,7 +68,7 @@
                         <parameter name="source"/>
                         <parameter name="args"/>
                         <raise event="HTTP_input" scope="narrow" target="'parent/to_mvi/' + source">
-                            <parameter expr="json.dumps({'user': self.username, 'state': 'paused', 'info': self.mvk.debug_info[self.username]})"/>
+                            <parameter expr="json.dumps({'task': self.taskname, 'state': 'paused', 'info': self.mvk.debug_info[self.taskname]})"/>
                         </raise>
                     </transition>
                 </state>
@@ -77,7 +77,7 @@
                         <parameter name="source"/>
                         <parameter name="args"/>
                         <raise event="HTTP_input" scope="narrow" target="'parent/to_mvi/' + source">
-                            <parameter expr="json.dumps({'user': self.username, 'state': 'running'})"/>
+                            <parameter expr="json.dumps({'task': self.taskname, 'state': 'running'})"/>
                         </raise>
                     </transition>
                 </state>
@@ -90,7 +90,7 @@
                         <parameter name="args"/>
                         <raise event="execute" scope="narrow" target="'parent/executor'">
                             <parameter expr="self.returnpath"/>
-                            <parameter expr="self.username"/>
+                            <parameter expr="self.taskname"/>
                             <parameter expr="'set_input'"/>
                             <parameter expr="args"/>
                             <parameter expr="self.request_id"/>
@@ -133,7 +133,7 @@
                     <transition cond="self.outstanding_output is None and self.output_queue" target=".">
                         <raise event="execute" scope="narrow" target="'parent/executor'">
                             <parameter expr="self.returnpath"/>
-                            <parameter expr="self.username"/>
+                            <parameter expr="self.taskname"/>
                             <parameter expr="'get_output'"/>
                             <parameter expr="[]"/>
                             <parameter expr="self.request_id"/>

kernel/mvk_server/server.xml

@@ -22,6 +22,6 @@
     <class src="classes/server.xml"/>
     <class src="classes/socket.xml"/>
     <class src="classes/http_client.xml"/>
-    <class src="classes/user_statechart.xml"/>
+    <class src="classes/task_statechart.xml"/>
     <class src="classes/executor.xml"/>
 </diagram>

kernel/test/functions/factorial.eps

@@ -167,12 +167,12 @@ def
 % /arrowwidth 5 def
 
 % make sure pdfmark is harmless for PS-interpreters other than Distiller
-/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+/pdfmark where {pop} {taskdict /pdfmark /cleartomark load put} ifelse
 % make '<<' and '>>' safe on PS Level 1 devices
 /languagelevel where {pop languagelevel}{1} ifelse
 2 lt {
-    userdict (<<) cvn ([) cvn load put
-    userdict (>>) cvn ([) cvn load put
+    taskdict (<<) cvn ([) cvn load put
+    taskdict (>>) cvn ([) cvn load put
 } if
 
 %%EndSetup

kernel/test/functions/fib_naive.eps

@@ -167,12 +167,12 @@ def
 % /arrowwidth 5 def
 
 % make sure pdfmark is harmless for PS-interpreters other than Distiller
-/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+/pdfmark where {pop} {taskdict /pdfmark /cleartomark load put} ifelse
 % make '<<' and '>>' safe on PS Level 1 devices
 /languagelevel where {pop languagelevel}{1} ifelse
 2 lt {
-    userdict (<<) cvn ([) cvn load put
-    userdict (>>) cvn ([) cvn load put
+    taskdict (<<) cvn ([) cvn load put
+    taskdict (>>) cvn ([) cvn load put
 } if
 
 %%EndSetup

kernel/test/functions/test_factorial.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_inst_ref, add_new_user
+from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_inst_ref, add_new_task
 import math
 
 class TestFactorial(unittest.TestCase):
@@ -178,9 +178,9 @@ class TestFactorial(unittest.TestCase):
         self.mvs.execute("CD", [invoke_factorial, "next", const_5])
         self.mvs.execute("CD", [const_5, "node", value_c])
 
-        execute_until_finished(self.mvk, self.mvs, "initialize_new_user", [])
+        execute_until_finished(self.mvk, self.mvs, "initialize_new_task", [])
 
-        t = self.mvs.execute("CE", [self.mvs.execute("RD", [self.mvs.execute("RD", [root, "user_1"])[0], "globals"])[0] , var_value_4])[0]
+        t = self.mvs.execute("CE", [self.mvs.execute("RD", [self.mvs.execute("RD", [root, "task_1"])[0], "globals"])[0] , var_value_4])[0]
         self.mvs.execute("CE", [t, var_4])
 
         ### Execute rules

kernel/test/functions/test_fib_naive.py

@@ -213,10 +213,10 @@ class TestFibNaive(unittest.TestCase):
         self.mvs.execute("CD", [invoke_fib, "next", const_6])
         self.mvs.execute("CD", [const_6, "node", value_c])
 
-        execute_until_finished(self.mvk, self.mvs, "initialize_new_user", ["user_1"])
+        execute_until_finished(self.mvk, self.mvs, "initialize_new_task", ["task_1"])
 
-        # Define in globals for user, kind of a hack...
-        t = self.mvs.execute("CE", [self.mvs.execute("RD", [self.mvs.execute("RD", [root, "user_1"])[0], "globals"])[0] , var_value_4])[0]
+        # Define in globals for task, kind of a hack...
+        t = self.mvs.execute("CE", [self.mvs.execute("RD", [self.mvs.execute("RD", [root, "task_1"])[0], "globals"])[0] , var_value_4])[0]
         self.mvs.execute("CE", [t, var_4])
 
         ### Execute rules

kernel/test/functions/utils.py

@@ -34,11 +34,11 @@ class MvSWrapper(object):
 
         return [retval[0]]
 
-def add_new_user(root, mvs, username):
+def add_new_task(root, mvs, taskname):
     hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
     initial = mvs.execute("RD", [hierarchy, "__IP"])[0]
 
-    user_root = mvs.execute("CN", [])[0]
+    task_root = mvs.execute("CN", [])[0]
     _globals = mvs.execute("CN", [])[0]
     frame = mvs.execute("CN", [])[0]
     evalstack = mvs.execute("CN", [])[0]
@@ -48,13 +48,13 @@ def add_new_user(root, mvs, username):
     returnvalue = mvs.execute("CN", [])[0]
     phase = mvs.execute("CNV", ["init"])[0]
 
-    mvs.execute("CD", [root, username, user_root])
-    mvs.execute("CD", [user_root, "frame", frame])
-    mvs.execute("CD", [user_root, "globals", _globals])
-    mvs.execute("CD", [user_root, "input", _input])
-    mvs.execute("CD", [user_root, "last_input", _input])
-    mvs.execute("CD", [user_root, "output", _output])
-    mvs.execute("CD", [user_root, "last_output", _output])
+    mvs.execute("CD", [root, taskname, task_root])
+    mvs.execute("CD", [task_root, "frame", frame])
+    mvs.execute("CD", [task_root, "globals", _globals])
+    mvs.execute("CD", [task_root, "input", _input])
+    mvs.execute("CD", [task_root, "last_input", _input])
+    mvs.execute("CD", [task_root, "output", _output])
+    mvs.execute("CD", [task_root, "last_output", _output])
     mvs.execute("CD", [frame, "evalstack", evalstack])
     mvs.execute("CD", [frame, "returnvalue", returnvalue])
     mvs.execute("CD", [frame, "phase", phase])
@@ -62,12 +62,12 @@ def add_new_user(root, mvs, username):
     mvs.execute("CD", [frame, "symbols", symbols])
 
 def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
-    username = "user_1"
-    if operation == "initialize_new_user":
-        return add_new_user(mvk.root, mvs, username)
+    taskname = "task_1"
+    if operation == "initialize_new_task":
+        return add_new_task(mvk.root, mvs, taskname)
     response = None
     while 1:
-        mvs_commands = mvk.execute_yields(username, operation, params, response)
+        mvs_commands = mvk.execute_yields(taskname, operation, params, response)
         if mvs_commands is None:
             break
         response = []
@@ -75,37 +75,37 @@ def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
             response.append(mvs.execute(command, param)[0])
 
 def get_inst(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    inst = mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    inst = mvs.execute("RD", [task_frame, "IP"])[0]
     return mvs.execute("RV", [inst])[0]["value"]
 
 def get_phase(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return mvs.execute("RV", [phase])[0]
 
 def get_returnvalue(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    returnvalue = mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])[0]
     return mvs.execute("RV", [returnvalue])[0]
 
 def get_inst_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "IP"])[0]
 
 def get_returnvalue_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "returnvalue"])[0]
 
 def get_phase_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return phase
 
 def read_primitive_interfaces(root, mvs):

kernel/test/instructions/test_instruction_access.py

@@ -8,19 +8,19 @@ class Testaccess(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_access(self):
         """
@@ -35,7 +35,7 @@ class Testaccess(unittest.TestCase):
 
         self.value_a = self.mvs.execute("CNV", ["a"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.resolve])
         self.mvs.execute("CD", [self.resolve, "var", self.var])
         self.mvs.execute("CD", [self.value, "value", self.const_a])

kernel/test/instructions/test_instruction_assign.py

@@ -8,19 +8,19 @@ class TestAssign(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_assign_simple(self):
         """
@@ -36,7 +36,7 @@ class TestAssign(unittest.TestCase):
         self.inst = self.mvs.execute("CNV", [{"value":"assign"}])[0]
         self.resolve = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.resolve])
         self.mvs.execute("CD", [self.inst, "value", self.const])
         self.mvs.execute("CD", [self.resolve, "var", self.var])
@@ -79,7 +79,7 @@ class TestAssign(unittest.TestCase):
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
 
         # Check if the new value is really assigned
-        t = self.mvs.execute("RD", [self.root, "user_1"])[0]
+        t = self.mvs.execute("RD", [self.root, "task_1"])[0]
         t = self.mvs.execute("RD", [t, "frame"])[0]
         t = self.mvs.execute("RD", [t, "symbols"])[0]
         t = self.mvs.execute("RDN", [t, self.var])[0]

kernel/test/instructions/test_instruction_break.py

@@ -8,19 +8,19 @@ class TestBreak(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_break(self):
         """
@@ -28,31 +28,26 @@ class TestBreak(unittest.TestCase):
             while True:
                 a
                 break
-                b
             c
         """
         self.inst = self.mvs.execute("CNV", [{"value":"while"}])[0]
 
         self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.const_cond = self.mvs.execute("CNV", [{"value":"constant"}])[0]
 
         self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_cond = self.mvs.execute("CNV", [True])[0]
         self.break_inst = self.mvs.execute("CNV", [{"value":"break"}])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_cond])
         self.mvs.execute("CD", [self.inst, "body", self.const_a])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
         self.mvs.execute("CD", [self.const_a, "node", self.value_a])
         self.mvs.execute("CD", [self.const_a, "next", self.break_inst])
-        self.mvs.execute("CD", [self.break_inst, "next", self.const_b])
         self.mvs.execute("CD", [self.break_inst, "while", self.inst])
-        self.mvs.execute("CD", [self.const_b, "node", self.value_b])
         self.mvs.execute("CD", [self.const_c, "node", self.value_c])
         self.mvs.execute("CD", [self.const_cond, "node", self.value_cond])
 
@@ -87,6 +82,10 @@ class TestBreak(unittest.TestCase):
         self.assertEquals(get_phase(self.root, self.mvs), "init")
         execute_until_finished(self.mvk, self.mvs)
 
+        self.assertEquals(get_inst(self.root, self.mvs), "break")
+        self.assertEquals(get_phase(self.root, self.mvs), "finish")
+        execute_until_finished(self.mvk, self.mvs)
+
         self.assertEquals(get_inst(self.root, self.mvs), "while")
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
         execute_until_finished(self.mvk, self.mvs)

kernel/test/instructions/test_instruction_call.py

@@ -8,19 +8,19 @@ class Testcall(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_no_params(self):
         """
@@ -44,7 +44,7 @@ class Testcall(unittest.TestCase):
         self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.value_a = self.mvs.execute("CNV", ["a"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "func", self.access])
         self.mvs.execute("CD", [self.inst, "next", self.const_a])
         self.mvs.execute("CD", [self.access, "var", self.resolve])
@@ -128,7 +128,7 @@ class Testcall(unittest.TestCase):
         self.value_abc = self.mvs.execute("CNV", ["abc"])[0]
         self.value_def = self.mvs.execute("CNV", ["def"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "func", self.access])
         self.mvs.execute("CD", [self.inst, "next", self.const_a])
         self.mvs.execute("CD", [self.inst, "params", self.actual_arg])
@@ -237,7 +237,7 @@ class Testcall(unittest.TestCase):
         self.value_e = self.mvs.execute("CNV", ["e"])[0]
         self.value_f = self.mvs.execute("CNV", ["f"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "func", self.access])
         self.mvs.execute("CD", [self.inst, "next", self.const_a])
         self.mvs.execute("CD", [self.inst, "params", self.actual_arg_a])
@@ -369,7 +369,7 @@ class Testcall(unittest.TestCase):
         self.value_e = self.mvs.execute("CNV", ["e"])[0]
         self.value_f = self.mvs.execute("CNV", ["f"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "func", self.access])
         self.mvs.execute("CD", [self.inst, "next", self.const_a])
         self.mvs.execute("CD", [self.inst, "params", self.actual_arg_a])

kernel/test/instructions/test_instruction_continue.py

@@ -8,19 +8,19 @@ class Testcontinue(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_continue(self):
         """
@@ -28,31 +28,26 @@ class Testcontinue(unittest.TestCase):
             while True:
                 a
                 continue
-                b
             c
         """
         self.inst = self.mvs.execute("CNV", [{"value":"while"}])[0]
 
         self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
-        self.const_b = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.const_c = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.const_cond = self.mvs.execute("CNV", [{"value":"constant"}])[0]
 
         self.value_a = self.mvs.execute("CNV", ["a"])[0]
-        self.value_b = self.mvs.execute("CNV", ["b"])[0]
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_cond = self.mvs.execute("CNV", [True])[0]
         self.continue_inst = self.mvs.execute("CNV", [{"value":"continue"}])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_cond])
         self.mvs.execute("CD", [self.inst, "body", self.const_a])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
         self.mvs.execute("CD", [self.const_a, "node", self.value_a])
         self.mvs.execute("CD", [self.const_a, "next", self.continue_inst])
-        self.mvs.execute("CD", [self.continue_inst, "next", self.const_b])
         self.mvs.execute("CD", [self.continue_inst, "while", self.inst])
-        self.mvs.execute("CD", [self.const_b, "node", self.value_b])
         self.mvs.execute("CD", [self.const_c, "node", self.value_c])
         self.mvs.execute("CD", [self.const_cond, "node", self.value_cond])
 
@@ -87,6 +82,10 @@ class Testcontinue(unittest.TestCase):
         self.assertEquals(get_phase(self.root, self.mvs), "init")
         execute_until_finished(self.mvk, self.mvs)
 
+        self.assertEquals(get_inst(self.root, self.mvs), "continue")
+        self.assertEquals(get_phase(self.root, self.mvs), "finish")
+        execute_until_finished(self.mvk, self.mvs)
+
         # Loop 2
         self.assertEquals(get_inst(self.root, self.mvs), "while")
         self.assertEquals(get_phase(self.root, self.mvs), "init")
@@ -118,6 +117,10 @@ class Testcontinue(unittest.TestCase):
         self.assertEquals(get_phase(self.root, self.mvs), "init")
         execute_until_finished(self.mvk, self.mvs)
 
+        self.assertEquals(get_inst(self.root, self.mvs), "continue")
+        self.assertEquals(get_phase(self.root, self.mvs), "finish")
+        execute_until_finished(self.mvk, self.mvs)
+
         # Loop 3
         self.assertEquals(get_inst(self.root, self.mvs), "while")
         self.assertEquals(get_phase(self.root, self.mvs), "init")
@@ -149,3 +152,7 @@ class Testcontinue(unittest.TestCase):
         self.assertEquals(get_phase(self.root, self.mvs), "init")
         execute_until_finished(self.mvk, self.mvs)
 
+        self.assertEquals(get_inst(self.root, self.mvs), "continue")
+        self.assertEquals(get_phase(self.root, self.mvs), "finish")
+        execute_until_finished(self.mvk, self.mvs)
+

kernel/test/instructions/test_instruction_declare.py

@@ -8,27 +8,27 @@ class TestDeclare(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
         self.globals = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_root, "globals", self.globals])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_root, "globals", self.globals])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_declare(self):
         self.inst = self.mvs.execute("CNV", [{"value":"declare"}])[0]
         self.var = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.var])
 
         ### Execute rules
@@ -41,11 +41,11 @@ class TestDeclare(unittest.TestCase):
         self.assertNotEquals(self.mvs.execute("RDN", [self.symbols, self.var])[0], None)
 
     def test_global(self):
-        self.global_symbols = self.mvs.execute("RD", [self.user_root, "globals"])[0]
+        self.global_symbols = self.mvs.execute("RD", [self.task_root, "globals"])[0]
         self.inst = self.mvs.execute("CNV", [{"value":"global"}])[0]
         self.var = self.mvs.execute("CNV", ["abc"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.var])
 
         ### Execute rules

kernel/test/instructions/test_instruction_if.py

@@ -8,19 +8,19 @@ class Testif(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_if_true_with_else(self):
         """
@@ -43,7 +43,7 @@ class Testif(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_true = self.mvs.execute("CNV", [True])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_true])
         self.mvs.execute("CD", [self.inst, "then", self.const_a])
         self.mvs.execute("CD", [self.inst, "else", self.const_b])
@@ -109,7 +109,7 @@ class Testif(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_true = self.mvs.execute("CNV", [True])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_true])
         self.mvs.execute("CD", [self.inst, "then", self.const_a])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -177,7 +177,7 @@ class Testif(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_false = self.mvs.execute("CNV", [False])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_false])
         self.mvs.execute("CD", [self.inst, "then", self.const_a])
         self.mvs.execute("CD", [self.inst, "else", self.const_b])
@@ -243,7 +243,7 @@ class Testif(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_false = self.mvs.execute("CNV", [False])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_false])
         self.mvs.execute("CD", [self.inst, "then", self.const_a])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])

kernel/test/instructions/test_instruction_input.py

@@ -8,21 +8,21 @@ class TestInput(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
-        self.user_input = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
+        self.task_input = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "input", self.user_input])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "input", self.task_input])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_input(self):
         self.input_value = self.mvs.execute("CN", [])[0]
@@ -30,9 +30,9 @@ class TestInput(unittest.TestCase):
 
         self.value_a = self.mvs.execute("CNV", ["a"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
-        self.mvs.execute("CD", [self.user_input, "next", self.input_value])
-        self.mvs.execute("CD", [self.user_input, "value", self.value_a])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_input, "next", self.input_value])
+        self.mvs.execute("CD", [self.task_input, "value", self.value_a])
 
         ### Execute rules
         self.assertEquals(get_inst(self.root, self.mvs), "input")

kernel/test/instructions/test_instruction_output.py

@@ -8,25 +8,25 @@ class TestOutput(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
-        self.user_input = self.mvs.execute("CN", [])[0]
-        self.user_output = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
+        self.task_input = self.mvs.execute("CN", [])[0]
+        self.task_output = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "input", self.user_input])
-        self.mvs.execute("CD", [self.user_root, "last_input", self.user_input])
-        self.mvs.execute("CD", [self.user_root, "output", self.user_output])
-        self.mvs.execute("CD", [self.user_root, "last_output", self.user_output])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "input", self.task_input])
+        self.mvs.execute("CD", [self.task_root, "last_input", self.task_input])
+        self.mvs.execute("CD", [self.task_root, "output", self.task_output])
+        self.mvs.execute("CD", [self.task_root, "last_output", self.task_output])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_output_value(self):
         self.input_value = self.mvs.execute("CN", [])[0]
@@ -35,7 +35,7 @@ class TestOutput(unittest.TestCase):
         self.const = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.value_a = self.mvs.execute("CNV", ["a"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "value", self.const])
         self.mvs.execute("CD", [self.const, "node", self.value_a])
 
@@ -59,7 +59,7 @@ class TestOutput(unittest.TestCase):
 
         self.assertEquals(get_inst(self.root, self.mvs), "output")
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [self.user_output, "value"])[0]])[0], "a")
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [self.task_output, "value"])[0]])[0], "a")
 
     def test_output_node(self):
         self.input_value = self.mvs.execute("CN", [])[0]
@@ -68,7 +68,7 @@ class TestOutput(unittest.TestCase):
         self.const = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.value = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "value", self.const])
         self.mvs.execute("CD", [self.const, "node", self.value])
 
@@ -92,7 +92,7 @@ class TestOutput(unittest.TestCase):
 
         self.assertEquals(get_inst(self.root, self.mvs), "output")
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        self.assertEquals(self.mvs.execute("RD", [self.user_output, "value"])[0], self.value)
+        self.assertEquals(self.mvs.execute("RD", [self.task_output, "value"])[0], self.value)
 
     def test_output_edge(self):
         self.input_value = self.mvs.execute("CN", [])[0]
@@ -103,7 +103,7 @@ class TestOutput(unittest.TestCase):
         b = self.mvs.execute("CN", [])[0]
         self.value = self.mvs.execute("CE", [a,b])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "value", self.const])
         self.mvs.execute("CD", [self.const, "node", self.value])
 
@@ -127,4 +127,4 @@ class TestOutput(unittest.TestCase):
 
         self.assertEquals(get_inst(self.root, self.mvs), "output")
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        self.assertEquals(self.mvs.execute("RD", [self.user_output, "value"])[0], self.value)
+        self.assertEquals(self.mvs.execute("RD", [self.task_output, "value"])[0], self.value)

kernel/test/instructions/test_instruction_resolve.py

@@ -8,21 +8,21 @@ class Testresolve(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.global_user = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.global_task = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_root, "globals", self.global_user])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_root, "globals", self.global_task])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_resolve_simple_local(self):
         """
@@ -33,7 +33,7 @@ class Testresolve(unittest.TestCase):
 
         self.inst = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.var])
         t = self.mvs.execute("CE", [self.symbols, self.value])[0]
         self.mvs.execute("CE", [t, self.var])
@@ -56,9 +56,9 @@ class Testresolve(unittest.TestCase):
 
         self.inst = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.var])
-        t = self.mvs.execute("CE", [self.global_user, self.value])[0]
+        t = self.mvs.execute("CE", [self.global_task, self.value])[0]
         self.mvs.execute("CE", [t, self.var])
 
         ### Execute rules
@@ -80,9 +80,9 @@ class Testresolve(unittest.TestCase):
 
         self.inst = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.var])
-        t = self.mvs.execute("CE", [self.global_user, self.global_value])[0]
+        t = self.mvs.execute("CE", [self.global_task, self.global_value])[0]
         self.mvs.execute("CE", [t, self.var])
         t = self.mvs.execute("CE", [self.symbols, self.local_value])[0]
         self.mvs.execute("CE", [t, self.var])

kernel/test/instructions/test_instruction_return.py

@@ -8,44 +8,44 @@ class Testreturn(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_return(self):
         """
         Test the code:
             return True
         """
-        prev_user_frame = self.mvs.execute("CN", [])[0]
+        prev_task_frame = self.mvs.execute("CN", [])[0]
         prev_symbols = self.mvs.execute("CN", [])[0]
         prev_evalstack = self.mvs.execute("CN", [])[0]
         prev_returnvalue = self.mvs.execute("CN", [])[0]
         prev_phase = self.mvs.execute("CNV", ["init"])[0]
         prev_IP = self.mvs.execute("CNV", [{"value":"constant"}])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "prev", prev_user_frame])
-        self.mvs.execute("CD", [prev_user_frame, "symbols", prev_symbols])
-        self.mvs.execute("CD", [prev_user_frame, "evalstack", prev_evalstack])
-        self.mvs.execute("CD", [prev_user_frame, "phase", prev_phase])
-        self.mvs.execute("CD", [prev_user_frame, "IP", prev_IP])
-        self.mvs.execute("CD", [prev_user_frame, "returnvalue", prev_returnvalue])
+        self.mvs.execute("CD", [self.task_frame, "prev", prev_task_frame])
+        self.mvs.execute("CD", [prev_task_frame, "symbols", prev_symbols])
+        self.mvs.execute("CD", [prev_task_frame, "evalstack", prev_evalstack])
+        self.mvs.execute("CD", [prev_task_frame, "phase", prev_phase])
+        self.mvs.execute("CD", [prev_task_frame, "IP", prev_IP])
+        self.mvs.execute("CD", [prev_task_frame, "returnvalue", prev_returnvalue])
 
         self.inst = self.mvs.execute("CNV", [{"value":"return"}])[0]
         self.const_true = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.value_true = self.mvs.execute("CNV", [True])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "value", self.const_true])
         self.mvs.execute("CD", [self.const_true, "node", self.value_true])
 
@@ -71,6 +71,6 @@ class Testreturn(unittest.TestCase):
         self.assertEquals(get_phase(self.root, self.mvs), "init")
         self.assertEquals(get_returnvalue(self.root, self.mvs), True)
 
-        t = self.mvs.execute("RD", [self.root, "user_1"])[0]
+        t = self.mvs.execute("RD", [self.root, "task_1"])[0]
         t = self.mvs.execute("RD", [t, "frame"])[0]
-        self.assertEquals(t, prev_user_frame)
+        self.assertEquals(t, prev_task_frame)

kernel/test/instructions/test_instruction_while.py

@@ -8,19 +8,19 @@ class Testwhile(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_while_true(self):
         """
@@ -39,7 +39,7 @@ class Testwhile(unittest.TestCase):
         self.value_b = self.mvs.execute("CNV", ["b"])[0]
         self.value_cond = self.mvs.execute("CNV", [True])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_cond])
         self.mvs.execute("CD", [self.inst, "body", self.const_a])
         self.mvs.execute("CD", [self.inst, "next", self.const_b])
@@ -146,7 +146,7 @@ class Testwhile(unittest.TestCase):
         self.value_b = self.mvs.execute("CNV", ["b"])[0]
         self.value_cond = self.mvs.execute("CNV", [False])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_cond])
         self.mvs.execute("CD", [self.inst, "body", self.const_a])
         self.mvs.execute("CD", [self.inst, "next", self.const_b])
@@ -202,7 +202,7 @@ class Testwhile(unittest.TestCase):
         self.value_b = self.mvs.execute("CNV", ["b"])[0]
         self.value_cond = self.mvs.execute("CNV", [True])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_cond])
         self.mvs.execute("CD", [self.inst, "body", self.const_a])
         self.mvs.execute("CD", [self.inst, "next", self.const_b])

kernel/test/instructions/utils.py

@@ -34,11 +34,11 @@ class MvSWrapper(object):
 
         return [retval[0]]
 
-def add_new_user(root, mvs, username):
+def add_new_task(root, mvs, taskname):
     hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
     initial = mvs.execute("RD", [hierarchy, "__IP"])[0]
 
-    user_root = mvs.execute("CN", [])[0]
+    task_root = mvs.execute("CN", [])[0]
     _globals = mvs.execute("CN", [])[0]
     frame = mvs.execute("CN", [])[0]
     evalstack = mvs.execute("CN", [])[0]
@@ -48,13 +48,13 @@ def add_new_user(root, mvs, username):
     returnvalue = mvs.execute("CN", [])[0]
     phase = mvs.execute("CNV", ["init"])[0]
 
-    mvs.execute("CD", [root, username, user_root])
-    mvs.execute("CD", [user_root, "frame", frame])
-    mvs.execute("CD", [user_root, "globals", _globals])
-    mvs.execute("CD", [user_root, "input", _input])
-    mvs.execute("CD", [user_root, "last_input", _input])
-    mvs.execute("CD", [user_root, "output", _output])
-    mvs.execute("CD", [user_root, "last_output", _output])
+    mvs.execute("CD", [root, taskname, task_root])
+    mvs.execute("CD", [task_root, "frame", frame])
+    mvs.execute("CD", [task_root, "globals", _globals])
+    mvs.execute("CD", [task_root, "input", _input])
+    mvs.execute("CD", [task_root, "last_input", _input])
+    mvs.execute("CD", [task_root, "output", _output])
+    mvs.execute("CD", [task_root, "last_output", _output])
     mvs.execute("CD", [frame, "evalstack", evalstack])
     mvs.execute("CD", [frame, "returnvalue", returnvalue])
     mvs.execute("CD", [frame, "phase", phase])
@@ -62,12 +62,12 @@ def add_new_user(root, mvs, username):
     mvs.execute("CD", [frame, "symbols", symbols])
 
 def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
-    username = "user_1"
-    if operation == "initialize_new_user":
-        return add_new_user(mvk.root, mvs, username)
+    taskname = "task_1"
+    if operation == "initialize_new_task":
+        return add_new_task(mvk.root, mvs, taskname)
     response = None
     while 1:
-        mvs_commands = mvk.execute_yields(username, operation, params, response)
+        mvs_commands = mvk.execute_yields(taskname, operation, params, response)
         if mvs_commands is None:
             break
         response = []
@@ -75,37 +75,37 @@ def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
             response.append(mvs.execute(command, param)[0])
 
 def get_inst(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    inst = mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    inst = mvs.execute("RD", [task_frame, "IP"])[0]
     return mvs.execute("RV", [inst])[0]["value"]
 
 def get_phase(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return mvs.execute("RV", [phase])[0]
 
 def get_returnvalue(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    returnvalue = mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])[0]
     return mvs.execute("RV", [returnvalue])[0]
 
 def get_inst_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "IP"])[0]
 
 def get_returnvalue_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "returnvalue"])[0]
 
 def get_phase_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return phase
 
 def read_primitive_interfaces(root, mvs):

kernel/test/primitives/test_action.py

@@ -8,19 +8,19 @@ class TestAction(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -59,7 +59,7 @@ class TestAction(unittest.TestCase):
         self.value_first = self.mvs.execute("CNV", [a])[0]
         self.value_second = self.mvs.execute("CNV", [b])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -152,7 +152,7 @@ class TestAction(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = self.mvs.execute("CNV", [a])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_bool.py

@@ -8,19 +8,19 @@ class TestBool(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -95,7 +95,7 @@ class TestBool(unittest.TestCase):
         self.value_first = self.mvs.execute("CNV", [a])[0]
         self.value_second = self.mvs.execute("CNV", [b])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -188,7 +188,7 @@ class TestBool(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = self.mvs.execute("CNV", [a])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_cast.py

@@ -8,19 +8,19 @@ class TestCast(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -142,7 +142,7 @@ class TestCast(unittest.TestCase):
         else:
             self.value_first = self.mvs.execute("CNV", [a])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_create.py

@@ -8,19 +8,19 @@ class TestCreate(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -76,7 +76,7 @@ class TestCreate(unittest.TestCase):
         self.value_first = a
         self.value_second = b
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -159,7 +159,7 @@ class TestCreate(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = a
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -222,7 +222,7 @@ class TestCreate(unittest.TestCase):
         self.value_b = self.mvs.execute("CNV", ["b"])[0]
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_delete.py

@@ -8,19 +8,19 @@ class TestDelete(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -90,7 +90,7 @@ class TestDelete(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = a
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_dict.py

@@ -8,19 +8,19 @@ class TestDict(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -100,7 +100,7 @@ class TestDict(unittest.TestCase):
 
         self.construct(self.value_first, a)
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -184,7 +184,7 @@ class TestDict(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -261,7 +261,7 @@ class TestDict(unittest.TestCase):
         self.value_second = self.mvs.execute("CNV", [b])[0]
         self.value_third = self.mvs.execute("CNV", [c])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_dict_special.py

@@ -8,19 +8,19 @@ class TestDictSpecials(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -106,7 +106,7 @@ class TestDictSpecials(unittest.TestCase):
         self.value_first = a
         self.value_second = b
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -193,7 +193,7 @@ class TestDictSpecials(unittest.TestCase):
 
         self.value_first = a
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_edge.py

@@ -8,19 +8,19 @@ class TestEdge(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -52,7 +52,7 @@ class TestEdge(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = a
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_element.py

@@ -8,19 +8,19 @@ class TestType(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -77,7 +77,7 @@ class TestType(unittest.TestCase):
         self.value_first = a
         self.value_second = b
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_float.py

@@ -8,19 +8,19 @@ class TestInteger(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -92,7 +92,7 @@ class TestInteger(unittest.TestCase):
         self.value_first = self.mvs.execute("CNV", [a])[0]
         self.value_second = self.mvs.execute("CNV", [b])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -185,7 +185,7 @@ class TestInteger(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = self.mvs.execute("CNV", [a])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_integer.py

@@ -8,19 +8,19 @@ class TestInteger(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -92,7 +92,7 @@ class TestInteger(unittest.TestCase):
         self.value_first = self.mvs.execute("CNV", [a])[0]
         self.value_second = self.mvs.execute("CNV", [b])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -185,7 +185,7 @@ class TestInteger(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = self.mvs.execute("CNV", [a])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_list.py

@@ -8,19 +8,19 @@ class TestList(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -107,7 +107,7 @@ class TestList(unittest.TestCase):
 
         self.construct(self.value_first, a)
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -192,7 +192,7 @@ class TestList(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -268,7 +268,7 @@ class TestList(unittest.TestCase):
         self.value_second = self.mvs.execute("CNV", [b])[0]
         self.value_third = self.mvs.execute("CNV", [c])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_read.py

@@ -8,19 +8,19 @@ class TestRead(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -205,7 +205,7 @@ class TestRead(unittest.TestCase):
         self.value_first = a
         self.value_second = b
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -287,7 +287,7 @@ class TestRead(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = a
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -350,7 +350,7 @@ class TestRead(unittest.TestCase):
         self.value_b = self.mvs.execute("CNV", ["b"])[0]
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_set.py

@@ -8,19 +8,19 @@ class TestSet(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -85,7 +85,7 @@ class TestSet(unittest.TestCase):
 
         self.construct(self.value_first, a)
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -170,7 +170,7 @@ class TestSet(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -246,7 +246,7 @@ class TestSet(unittest.TestCase):
         self.value_second = self.mvs.execute("CNV", [b])[0]
         self.value_third = self.mvs.execute("CNV", [c])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_set_node.py

@@ -8,19 +8,19 @@ class TestSetNode(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -93,7 +93,7 @@ class TestSetNode(unittest.TestCase):
 
         self.value_first = a
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_string.py

@@ -8,19 +8,19 @@ class TestString(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -104,7 +104,7 @@ class TestString(unittest.TestCase):
         self.value_first = self.mvs.execute("CNV", [a])[0]
         self.value_second = self.mvs.execute("CNV", [b])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -202,7 +202,7 @@ class TestString(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = self.mvs.execute("CNV", [a])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -284,7 +284,7 @@ class TestString(unittest.TestCase):
         self.value_second = self.mvs.execute("CNV", [b])[0]
         self.value_third = self.mvs.execute("CNV", [c])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/utils.py

@@ -34,11 +34,11 @@ class MvSWrapper(object):
 
         return [retval[0]]
 
-def add_new_user(root, mvs, username):
+def add_new_task(root, mvs, taskname):
     hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
     initial = mvs.execute("RD", [hierarchy, "__IP"])[0]
 
-    user_root = mvs.execute("CN", [])[0]
+    task_root = mvs.execute("CN", [])[0]
     _globals = mvs.execute("CN", [])[0]
     frame = mvs.execute("CN", [])[0]
     evalstack = mvs.execute("CN", [])[0]
@@ -48,13 +48,13 @@ def add_new_user(root, mvs, username):
     returnvalue = mvs.execute("CN", [])[0]
     phase = mvs.execute("CNV", ["init"])[0]
 
-    mvs.execute("CD", [root, username, user_root])
-    mvs.execute("CD", [user_root, "frame", frame])
-    mvs.execute("CD", [user_root, "globals", _globals])
-    mvs.execute("CD", [user_root, "input", _input])
-    mvs.execute("CD", [user_root, "last_input", _input])
-    mvs.execute("CD", [user_root, "output", _output])
-    mvs.execute("CD", [user_root, "last_output", _output])
+    mvs.execute("CD", [root, taskname, task_root])
+    mvs.execute("CD", [task_root, "frame", frame])
+    mvs.execute("CD", [task_root, "globals", _globals])
+    mvs.execute("CD", [task_root, "input", _input])
+    mvs.execute("CD", [task_root, "last_input", _input])
+    mvs.execute("CD", [task_root, "output", _output])
+    mvs.execute("CD", [task_root, "last_output", _output])
     mvs.execute("CD", [frame, "evalstack", evalstack])
     mvs.execute("CD", [frame, "returnvalue", returnvalue])
     mvs.execute("CD", [frame, "phase", phase])
@@ -62,12 +62,12 @@ def add_new_user(root, mvs, username):
     mvs.execute("CD", [frame, "symbols", symbols])
 
 def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
-    username = "user_1"
-    if operation == "initialize_new_user":
-        return add_new_user(mvk.root, mvs, username)
+    taskname = "task_1"
+    if operation == "initialize_new_task":
+        return add_new_task(mvk.root, mvs, taskname)
     response = None
     while 1:
-        mvs_commands = mvk.execute_yields(username, operation, params, response)
+        mvs_commands = mvk.execute_yields(taskname, operation, params, response)
         if mvs_commands is None:
             break
         response = []
@@ -75,37 +75,37 @@ def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
             response.append(mvs.execute(command, param)[0])
 
 def get_inst(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    inst = mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    inst = mvs.execute("RD", [task_frame, "IP"])[0]
     return mvs.execute("RV", [inst])[0]["value"]
 
 def get_phase(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return mvs.execute("RV", [phase])[0]
 
 def get_returnvalue(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    returnvalue = mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])[0]
     return mvs.execute("RV", [returnvalue])[0]
 
 def get_inst_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "IP"])[0]
 
 def get_returnvalue_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "returnvalue"])[0]
 
 def get_phase_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return phase
 
 def read_primitive_interfaces(root, mvs):

kernel/test/rules/test_rules_access.py

@@ -10,29 +10,29 @@ class Testaccess(unittest.TestCase):
 
     def test_access_init(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"access"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         var_inst = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
         self.mvs.execute("CD", [inst, "var", var_inst])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], var_inst)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], var_inst)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -40,26 +40,26 @@ class Testaccess(unittest.TestCase):
 
     def test_access_eval(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["eval"])[0]
         inst = self.mvs.execute("CNV", [{"value":"access"}])[0]
         value = self.mvs.execute("CN", [])[0]
         returnvalue = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [returnvalue, "value", value])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], value)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], value)

kernel/test/rules/test_rules_assign.py

@@ -10,29 +10,29 @@ class TestAssign(unittest.TestCase):
 
     def test_assign_init(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"assign"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         var_inst = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
         self.mvs.execute("CD", [inst, "var", var_inst])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], var_inst)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], var_inst)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -40,42 +40,42 @@ class TestAssign(unittest.TestCase):
 
     def test_assign_value(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["value"])[0]
         inst = self.mvs.execute("CNV", [{"value":"assign"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         returnvalue = self.mvs.execute("CN", [])[0]
         value_inst = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [inst, "value", value_inst])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], value_inst)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], value_inst)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], returnvalue)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "variable"])[0], returnvalue)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], returnvalue)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "variable"])[0], returnvalue)
         self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])[0]])[0], "assign")
 
     def test_assign_assign(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["assign"])[0]
         inst = self.mvs.execute("CNV", [{"value":"assign"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
@@ -83,23 +83,23 @@ class TestAssign(unittest.TestCase):
         variable = self.mvs.execute("CN", [])[0]
         value_inst = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
-        self.mvs.execute("CD", [user_frame, "variable", variable])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [task_frame, "variable", variable])
         self.mvs.execute("CD", [variable, "value", value_inst])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "variable"])[0], None)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "variable"])[0], None)
         self.assertEquals(self.mvs.execute("RD", [variable, "value"])[0], returnvalue)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], returnvalue)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], returnvalue)

kernel/test/rules/test_rules_break.py

@@ -11,24 +11,32 @@ class Testbreak(unittest.TestCase):
     def test_basic(self):
         # Create a break construct
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"break"}])[0]
         while_inst = self.mvs.execute("CNV", ["while"])[0]
+        evalstack_top = self.mvs.execute("CN", [])[0]
+        evalstack_bottom = self.mvs.execute("CN", [])[0]
+        finish_phase = self.mvs.execute("CNV", ["finish"])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack_top])
+        self.mvs.execute("CD", [evalstack_top, "prev", evalstack_bottom])
+        self.mvs.execute("CD", [evalstack_bottom, "inst", while_inst])
+        self.mvs.execute("CD", [evalstack_bottom, "phase", finish_phase])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "while", while_inst])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], while_inst)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
         self.assertEquals(self.mvs.execute("RD", [inst, "while"])[0], while_inst)
+        self.assertNotEquals(self.mvs.execute("RD", [task_frame, "evalstack"])[0], evalstack_top)

kernel/test/rules/test_rules_call.py

@@ -10,30 +10,30 @@ class Testcall(unittest.TestCase):
 
     def test_call_resolve_none(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         func = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "symbols", self.mvs.execute("CN", [])[0]])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "symbols", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "func", func])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], func)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], func)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -41,32 +41,32 @@ class Testcall(unittest.TestCase):
 
     def test_call_resolve_params(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         func = self.mvs.execute("CN", [])[0]
         params = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "symbols", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "symbols", self.mvs.execute("CN", [])[0]])
         self.mvs.execute("CD", [inst, "func", func])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
         self.mvs.execute("CD", [inst, "params", params])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], func)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], func)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -74,31 +74,31 @@ class Testcall(unittest.TestCase):
 
     def test_call_execute_none(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["call"])[0]
         inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
         returnvalue = self.mvs.execute("CN", [])[0]
         body = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "symbols", self.mvs.execute("CN", [])[0]])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "symbols", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [returnvalue, "body", body])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        new_frame = self.mvs.execute("RD", [user_root, "frame"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        new_frame = self.mvs.execute("RD", [task_root, "frame"])[0]
         self.assertNotEquals(new_frame, None)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], new_frame)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], new_frame)
         new_evalstack = self.mvs.execute("RD", [new_frame, "evalstack"])[0]
         self.assertNotEquals(new_evalstack, None)
         new_symbols = self.mvs.execute("RD", [new_frame, "symbols"])[0]
@@ -114,12 +114,12 @@ class Testcall(unittest.TestCase):
         self.assertNotEquals(new_IP, None)
         self.assertEquals(self.mvs.execute("RD", [new_frame, "IP"])[0], body)
         self.assertEquals(self.mvs.execute("RD", [new_frame, "caller"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], user_frame)
+        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], task_frame)
 
     def test_call_execute_params(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["call"])[0]
         inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
         returnvalue = self.mvs.execute("CN", [])[0]
@@ -132,13 +132,13 @@ class Testcall(unittest.TestCase):
         last_param = self.mvs.execute("CN", [])[0]
         formal_parameter = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [new_frame, "caller", inst])
-        self.mvs.execute("CD", [new_frame, "prev", user_frame])
+        self.mvs.execute("CD", [new_frame, "prev", task_frame])
         self.mvs.execute("CD", [new_frame, "symbols", symbols])
         self.mvs.execute("CD", [signature, "body", body])
         self.mvs.execute("CD", [signature, "params", params])
@@ -153,20 +153,20 @@ class Testcall(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], new_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        new_frame = self.mvs.execute("RD", [user_root, "frame"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], new_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        new_frame = self.mvs.execute("RD", [task_root, "frame"])[0]
         self.assertNotEquals(new_frame, None)
         self.assertEquals(self.mvs.execute("RD", [new_frame, "IP"])[0], body)
         self.assertEquals(self.mvs.execute("RD", [new_frame, "caller"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], user_frame)
+        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], task_frame)
 
     def test_call_param_first_multi(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
         returnvalue = self.mvs.execute("CN", [])[0]
         body = self.mvs.execute("CN", [])[0]
@@ -178,11 +178,11 @@ class Testcall(unittest.TestCase):
         next_param = self.mvs.execute("CN", [])[0]
         evalstack = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", params])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", params])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [signature, "body", body])
         self.mvs.execute("CD", [signature, "params", params])
         self.mvs.execute("CD", [inst, "params", params])
@@ -190,16 +190,16 @@ class Testcall(unittest.TestCase):
         self.mvs.execute("CD", [params, "next_param", next_param])
         self.mvs.execute("CD", [params, "value", param_value])
         self.mvs.execute("CD", [returnvalue, "body", body])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        new_frame = self.mvs.execute("RRD", [user_frame, "prev"])[0][0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        new_frame = self.mvs.execute("RRD", [task_frame, "prev"])[0][0]
         self.assertNotEquals(new_frame, None)
         new_evalstack = self.mvs.execute("RD", [new_frame, "evalstack"])[0]
         self.assertNotEquals(new_evalstack, None)
@@ -214,16 +214,16 @@ class Testcall(unittest.TestCase):
         self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [new_frame, "phase"])[0]])[0], "init")
         new_IP = self.mvs.execute("RD", [new_frame, "IP"])[0]
         self.assertNotEquals(new_IP, None)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], param_value)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], param_value)
         self.assertEquals(self.mvs.execute("RD", [new_frame, "caller"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], user_frame)
+        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], task_frame)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "phase"])[0], next_param)
 
     def test_call_param_first_single(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
         returnvalue = self.mvs.execute("CN", [])[0]
         body = self.mvs.execute("CN", [])[0]
@@ -234,26 +234,26 @@ class Testcall(unittest.TestCase):
         param_value = self.mvs.execute("CN", [])[0]
         evalstack = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", params])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", params])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [signature, "body", body])
         self.mvs.execute("CD", [inst, "params", params])
         self.mvs.execute("CD", [inst, "last_param", params])
         self.mvs.execute("CD", [params, "value", param_value])
         self.mvs.execute("CD", [returnvalue, "body", body])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        new_frame = self.mvs.execute("RRD", [user_frame, "prev"])[0][0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        new_frame = self.mvs.execute("RRD", [task_frame, "prev"])[0][0]
         self.assertNotEquals(new_frame, None)
         new_evalstack = self.mvs.execute("RD", [new_frame, "evalstack"])[0]
         self.assertNotEquals(new_evalstack, None)
@@ -268,21 +268,21 @@ class Testcall(unittest.TestCase):
         self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [new_frame, "phase"])[0]])[0], "init")
         new_IP = self.mvs.execute("RD", [new_frame, "IP"])[0]
         self.assertNotEquals(new_IP, None)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], param_value)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], param_value)
         self.assertEquals(self.mvs.execute("RD", [new_frame, "caller"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], user_frame)
+        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], task_frame)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
         self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])[0]])[0], "call")
 
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
 
     def test_params_last(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
         returnvalue = self.mvs.execute("CN", [])[0]
         body = self.mvs.execute("CN", [])[0]
@@ -297,17 +297,17 @@ class Testcall(unittest.TestCase):
         formal_parameter = self.mvs.execute("CN", [])[0]
         formal_parameter_name = self.mvs.execute("CNV", ["param_a"])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", last_param])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", last_param])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [inst, "last_param", last_param])
         self.mvs.execute("CD", [inst, "params", prev_param])
         self.mvs.execute("CD", [params, "value", param_value])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
         self.mvs.execute("CD", [new_frame, "caller", inst])
-        self.mvs.execute("CD", [new_frame, "prev", user_frame])
+        self.mvs.execute("CD", [new_frame, "prev", task_frame])
         self.mvs.execute("CD", [new_frame, "symbols", symbols])
         self.mvs.execute("CD", [new_frame, "IP", body])
         self.mvs.execute("CD", [signature, "body", body])
@@ -322,14 +322,14 @@ class Testcall(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], param_value)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], param_value)
         var = self.mvs.execute("RDN", [symbols, formal_parameter])[0]
         self.assertNotEquals(var, None)
         self.assertEquals(self.mvs.execute("RD", [var, "value"])[0], returnvalue)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -337,8 +337,8 @@ class Testcall(unittest.TestCase):
 
     def test_params_next(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
         returnvalue = self.mvs.execute("CN", [])[0]
         body = self.mvs.execute("CN", [])[0]
@@ -355,17 +355,17 @@ class Testcall(unittest.TestCase):
         param_b = self.mvs.execute("CN", [])[0]
         param_c = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", param_b])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", param_b])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "params", self.mvs.execute("CN", [])[0]])
         self.mvs.execute("CD", [inst, "last_param", self.mvs.execute("CN", [])[0]])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [params, "value", param_value])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
         self.mvs.execute("CD", [new_frame, "caller", inst])
-        self.mvs.execute("CD", [new_frame, "prev", user_frame])
+        self.mvs.execute("CD", [new_frame, "prev", task_frame])
         self.mvs.execute("CD", [new_frame, "symbols", symbols])
         self.mvs.execute("CD", [new_frame, "IP", body])
         self.mvs.execute("CD", [signature, "body", body])
@@ -381,11 +381,11 @@ class Testcall(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], param_value)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], param_value)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)

kernel/test/rules/test_rules_constant.py

@@ -10,26 +10,26 @@ class Testconstant(unittest.TestCase):
 
     def test_constant(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         node = self.mvs.execute("CN", [])[0]
         returnvalue = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [inst, "node", node])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
         self.assertEquals(self.mvs.execute("RD", [inst, "node"])[0], node)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], node)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], node)

kernel/test/rules/test_rules_continue.py

@@ -9,26 +9,34 @@ class Testcontinue(unittest.TestCase):
         self.mvk = ModelverseKernel(self.root)
 
     def test_basic(self):
-        # Create a break construct
+        # Create a continue construct
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"continue"}])[0]
         while_inst = self.mvs.execute("CNV", ["while"])[0]
+        evalstack_top = self.mvs.execute("CN", [])[0]
+        evalstack_bottom = self.mvs.execute("CN", [])[0]
+        init_phase = self.mvs.execute("CNV", ["finish"])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack_top])
+        self.mvs.execute("CD", [evalstack_top, "prev", evalstack_bottom])
+        self.mvs.execute("CD", [evalstack_bottom, "inst", while_inst])
+        self.mvs.execute("CD", [evalstack_bottom, "phase", init_phase])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "while", while_inst])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
-        # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], while_inst)
+        # Execution of the command inited, so the MvS should be in the correct new state right now
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
         self.assertEquals(self.mvs.execute("RD", [inst, "while"])[0], while_inst)
+        self.assertNotEquals(self.mvs.execute("RD", [task_frame, "evalstack"])[0], evalstack_top)

kernel/test/rules/test_rules_helper.py

@@ -10,32 +10,32 @@ class TestHelper(unittest.TestCase):
 
     def test_next(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["finish"])[0]
         inst = self.mvs.execute("CN", [])[0]
         next_inst = self.mvs.execute("CNV", ["next"])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "next", next_inst])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
         self.assertEquals(self.mvs.execute("RD", [inst, "next"])[0], next_inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], next_inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], next_inst)
 
     def test_evalstack(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["finish"])[0]
         inst = self.mvs.execute("CN", [])[0]
         evalstack = self.mvs.execute("CN", [])[0]
@@ -43,11 +43,11 @@ class TestHelper(unittest.TestCase):
         evalstack_inst = self.mvs.execute("CN", [])[0]
         evalstack_phase = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
         self.mvs.execute("CD", [evalstack, "prev", prev_evalstack])
         self.mvs.execute("CD", [prev_evalstack, "inst", evalstack_inst])
         self.mvs.execute("CD", [prev_evalstack, "phase", evalstack_phase])
@@ -56,8 +56,8 @@ class TestHelper(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], evalstack_inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "phase"])[0], evalstack_phase)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "evalstack"])[0], prev_evalstack)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], evalstack_inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "phase"])[0], evalstack_phase)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "evalstack"])[0], prev_evalstack)

kernel/test/rules/test_rules_if.py

@@ -10,29 +10,29 @@ class Testif(unittest.TestCase):
 
     def test_if_evaluate_condition(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"if"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         cond = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "cond", cond])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], cond)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], cond)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -40,31 +40,31 @@ class Testif(unittest.TestCase):
 
     def test_if_true(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["cond"])[0]
         inst = self.mvs.execute("CNV", [{"value":"if"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         returnvalue = self.mvs.execute("CNV", [True])[0]
         then = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [inst, "then", then])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], then)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], then)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -72,31 +72,31 @@ class Testif(unittest.TestCase):
 
     def test_if_false_else(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["cond"])[0]
         inst = self.mvs.execute("CNV", [{"value":"if"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         returnvalue = self.mvs.execute("CNV", [False])[0]
         else_inst = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [inst, "else", else_inst])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], else_inst)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], else_inst)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -104,25 +104,25 @@ class Testif(unittest.TestCase):
 
     def test_if_false_no_else(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["cond"])[0]
         inst = self.mvs.execute("CNV", [{"value":"if"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         returnvalue = self.mvs.execute("CNV", [False])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)

kernel/test/rules/test_rules_input.py

@@ -10,8 +10,8 @@ class TestInput(unittest.TestCase):
 
     def test_input(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"input"}])[0]
         old_retval = self.mvs.execute("CN", [])[0]
@@ -19,12 +19,12 @@ class TestInput(unittest.TestCase):
         input_queue_next = self.mvs.execute("CN", [])[0]
         value = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "returnvalue", old_retval])
-        self.mvs.execute("CD", [user_root, "input", input_queue_first])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "returnvalue", old_retval])
+        self.mvs.execute("CD", [task_root, "input", input_queue_first])
         self.mvs.execute("CD", [input_queue_first, "value", value])
         self.mvs.execute("CD", [input_queue_first, "next", input_queue_next])
 
@@ -32,36 +32,36 @@ class TestInput(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], value)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "input"])[0], input_queue_next)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], value)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "input"])[0], input_queue_next)
 
     def test_input_none(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"input"}])[0]
         old_retval = self.mvs.execute("CN", [])[0]
         input_queue_first = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "returnvalue", old_retval])
-        self.mvs.execute("CD", [user_root, "input", input_queue_first])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "returnvalue", old_retval])
+        self.mvs.execute("CD", [task_root, "input", input_queue_first])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], old_retval)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "input"])[0], input_queue_first)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], old_retval)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "input"])[0], input_queue_first)

kernel/test/rules/test_rules_output.py

@@ -10,29 +10,29 @@ class TestOutput(unittest.TestCase):
 
     def test_output_init(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"output"}])[0]
         value = self.mvs.execute("CN", [])[0]
         evalstack = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
         self.mvs.execute("CD", [inst, "value", value])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], value)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], value)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(new_evalstack, evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -40,31 +40,31 @@ class TestOutput(unittest.TestCase):
 
     def test_output_output(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["output"])[0]
         inst = self.mvs.execute("CNV", [{"value":"output"}])[0]
         retval = self.mvs.execute("CN", [])[0]
         output_queue = self.mvs.execute("CN", [])[0]
         value = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "returnvalue", retval])
-        self.mvs.execute("CD", [user_root, "last_output", output_queue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "returnvalue", retval])
+        self.mvs.execute("CD", [task_root, "last_output", output_queue])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], retval)
-        output_queue_next = self.mvs.execute("RD", [user_root, "last_output"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], retval)
+        output_queue_next = self.mvs.execute("RD", [task_root, "last_output"])[0]
         self.assertNotEquals(output_queue_next, output_queue)
         self.assertEquals(self.mvs.execute("RD", [output_queue, "next"])[0], output_queue_next)
         self.assertEquals(self.mvs.execute("RD", [output_queue, "value"])[0], retval)

kernel/test/rules/test_rules_resolve.py

@@ -10,8 +10,8 @@ class Testresolve(unittest.TestCase):
 
     def test_resolve_init_local(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
         var_inst = self.mvs.execute("CN", [])[0]
@@ -19,14 +19,14 @@ class Testresolve(unittest.TestCase):
         returnvalue = self.mvs.execute("CN", [])[0]
         entry = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "var", var_inst])
-        self.mvs.execute("CD", [user_frame, "symbols", symbols])
-        self.mvs.execute("CD", [user_frame, "returnvalue", self.mvs.execute("CN", [])[0]])
-        self.mvs.execute("CD", [user_frame, "evalstack", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "symbols", symbols])
+        self.mvs.execute("CD", [task_frame, "returnvalue", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "evalstack", self.mvs.execute("CN", [])[0]])
 
         t1 = self.mvs.execute("CE", [symbols, entry])[0]
         self.mvs.execute("CE", [t1, var_inst])[0]
@@ -35,19 +35,19 @@ class Testresolve(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], entry)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], entry)
 
     def test_resolve_init_global(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         _globals = self.mvs.execute("CN", [])[0]
-        self.mvs.execute("CD", [user_root, "globals", _globals])
-        global_user = self.mvs.execute("RD", [user_root, "globals"])[0]
+        self.mvs.execute("CD", [task_root, "globals", _globals])
+        global_task = self.mvs.execute("RD", [task_root, "globals"])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
         var_inst = self.mvs.execute("CNV", ["var"])[0]
@@ -55,33 +55,33 @@ class Testresolve(unittest.TestCase):
         returnvalue = self.mvs.execute("CN", [])[0]
         entry = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "var", var_inst])
-        self.mvs.execute("CD", [user_frame, "symbols", symbols])
-        self.mvs.execute("CD", [user_frame, "returnvalue", self.mvs.execute("CN", [])[0]])
-        self.mvs.execute("CD", [user_frame, "evalstack", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "symbols", symbols])
+        self.mvs.execute("CD", [task_frame, "returnvalue", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "evalstack", self.mvs.execute("CN", [])[0]])
 
-        t1 = self.mvs.execute("CE", [global_user, entry])[0]
+        t1 = self.mvs.execute("CE", [global_task, entry])[0]
         self.mvs.execute("CE", [t1, var_inst])[0]
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], entry)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], entry)
 
     def test_resolve_init_local_over_global(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
-        global_user = self.mvs.execute("RD", [user_root, "globals"])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
+        global_task = self.mvs.execute("RD", [task_root, "globals"])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
         var_inst = self.mvs.execute("CNV", ["var"])[0]
@@ -90,16 +90,16 @@ class Testresolve(unittest.TestCase):
         local_entry = self.mvs.execute("CN", [])[0]
         global_entry = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "var", var_inst])
-        self.mvs.execute("CD", [user_frame, "symbols", symbols])
-        self.mvs.execute("CD", [user_frame, "returnvalue", self.mvs.execute("CN", [])[0]])
-        self.mvs.execute("CD", [user_frame, "evalstack", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "symbols", symbols])
+        self.mvs.execute("CD", [task_frame, "returnvalue", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "evalstack", self.mvs.execute("CN", [])[0]])
 
-        t1 = self.mvs.execute("CE", [global_user, global_entry])[0]
+        t1 = self.mvs.execute("CE", [global_task, global_entry])[0]
         self.mvs.execute("CE", [t1, var_inst])[0]
         t2 = self.mvs.execute("CE", [symbols, local_entry])[0]
         self.mvs.execute("CE", [t2, var_inst])[0]
@@ -108,8 +108,8 @@ class Testresolve(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], local_entry)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], local_entry)

kernel/test/rules/test_rules_return.py

@@ -10,50 +10,50 @@ class Testreturn(unittest.TestCase):
 
     def test_return_init(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"return"}])[0]
         prev_stackframe = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "prev", prev_stackframe])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "prev", prev_stackframe])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], prev_stackframe)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], prev_stackframe)
 
     def test_return_init_value(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"return"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         value = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "value", value])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], value)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], value)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -61,26 +61,26 @@ class Testreturn(unittest.TestCase):
 
     def test_return_eval(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["eval"])[0]
         inst = self.mvs.execute("CNV", [{"value":"return"}])[0]
         prev_stackframe = self.mvs.execute("CN", [])[0]
         returnvalue_top = self.mvs.execute("CN", [])[0]
         returnvalue_bottom = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "prev", prev_stackframe])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue_top])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "prev", prev_stackframe])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue_top])
         self.mvs.execute("CD", [prev_stackframe, "returnvalue", returnvalue_bottom])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], prev_stackframe)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], prev_stackframe)
         self.assertEquals(self.mvs.execute("RD", [prev_stackframe, "returnvalue"])[0], returnvalue_top)

kernel/test/rules/test_rules_while.py

@@ -10,29 +10,29 @@ class Testwhile(unittest.TestCase):
 
     def test_while_evaluate_condition(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"while"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         cond = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "cond", cond])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], cond)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], cond)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -40,31 +40,31 @@ class Testwhile(unittest.TestCase):
 
     def test_while_true(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["cond"])[0]
         inst = self.mvs.execute("CNV", [{"value":"while"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         body = self.mvs.execute("CN", [])[0]
         returnvalue = self.mvs.execute("CNV", [True])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "body", body])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], body)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], body)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -72,23 +72,23 @@ class Testwhile(unittest.TestCase):
 
     def test_while_false(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["cond"])[0]
         inst = self.mvs.execute("CNV", [{"value":"while"}])[0]
         returnvalue = self.mvs.execute("CNV", [False])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)

kernel/test/rules/utils.py

@@ -34,11 +34,11 @@ class MvSWrapper(object):
 
         return [retval[0]]
 
-def add_new_user(root, mvs, username):
+def add_new_task(root, mvs, taskname):
     hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
     initial = mvs.execute("RD", [hierarchy, "__IP"])[0]
 
-    user_root = mvs.execute("CN", [])[0]
+    task_root = mvs.execute("CN", [])[0]
     _globals = mvs.execute("CN", [])[0]
     frame = mvs.execute("CN", [])[0]
     evalstack = mvs.execute("CN", [])[0]
@@ -48,13 +48,13 @@ def add_new_user(root, mvs, username):
     returnvalue = mvs.execute("CN", [])[0]
     phase = mvs.execute("CNV", ["init"])[0]
 
-    mvs.execute("CD", [root, username, user_root])
-    mvs.execute("CD", [user_root, "frame", frame])
-    mvs.execute("CD", [user_root, "globals", _globals])
-    mvs.execute("CD", [user_root, "input", _input])
-    mvs.execute("CD", [user_root, "last_input", _input])
-    mvs.execute("CD", [user_root, "output", _output])
-    mvs.execute("CD", [user_root, "last_output", _output])
+    mvs.execute("CD", [root, taskname, task_root])
+    mvs.execute("CD", [task_root, "frame", frame])
+    mvs.execute("CD", [task_root, "globals", _globals])
+    mvs.execute("CD", [task_root, "input", _input])
+    mvs.execute("CD", [task_root, "last_input", _input])
+    mvs.execute("CD", [task_root, "output", _output])
+    mvs.execute("CD", [task_root, "last_output", _output])
     mvs.execute("CD", [frame, "evalstack", evalstack])
     mvs.execute("CD", [frame, "returnvalue", returnvalue])
     mvs.execute("CD", [frame, "phase", phase])
@@ -62,12 +62,12 @@ def add_new_user(root, mvs, username):
     mvs.execute("CD", [frame, "symbols", symbols])
 
 def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
-    username = "user_1"
-    if operation == "initialize_new_user":
-        return add_new_user(mvk.root, mvs, username)
+    taskname = "task_1"
+    if operation == "initialize_new_task":
+        return add_new_task(mvk.root, mvs, taskname)
     response = None
     while 1:
-        mvs_commands = mvk.execute_yields(username, operation, params, response)
+        mvs_commands = mvk.execute_yields(taskname, operation, params, response)
         if mvs_commands is None:
             break
         response = []
@@ -75,37 +75,37 @@ def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
             response.append(mvs.execute(command, param)[0])
 
 def get_inst(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    inst = mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    inst = mvs.execute("RD", [task_frame, "IP"])[0]
     return mvs.execute("RV", [inst])[0]["value"]
 
 def get_phase(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return mvs.execute("RV", [phase])[0]
 
 def get_returnvalue(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    returnvalue = mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])[0]
     return mvs.execute("RV", [returnvalue])[0]
 
 def get_inst_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "IP"])[0]
 
 def get_returnvalue_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "returnvalue"])[0]
 
 def get_phase_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return phase
 
 def read_primitive_interfaces(root, mvs):

kernel/test/utils.py

@@ -34,11 +34,11 @@ class MvSWrapper(object):
 
         return [retval[0]]
 
-def add_new_user(root, mvs, username):
+def add_new_task(root, mvs, taskname):
     hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
     initial = mvs.execute("RD", [hierarchy, "__IP"])[0]
 
-    user_root = mvs.execute("CN", [])[0]
+    task_root = mvs.execute("CN", [])[0]
     _globals = mvs.execute("CN", [])[0]
     frame = mvs.execute("CN", [])[0]
     evalstack = mvs.execute("CN", [])[0]
@@ -48,13 +48,13 @@ def add_new_user(root, mvs, username):
     returnvalue = mvs.execute("CN", [])[0]
     phase = mvs.execute("CNV", ["init"])[0]
 
-    mvs.execute("CD", [root, username, user_root])
-    mvs.execute("CD", [user_root, "frame", frame])
-    mvs.execute("CD", [user_root, "globals", _globals])
-    mvs.execute("CD", [user_root, "input", _input])
-    mvs.execute("CD", [user_root, "last_input", _input])
-    mvs.execute("CD", [user_root, "output", _output])
-    mvs.execute("CD", [user_root, "last_output", _output])
+    mvs.execute("CD", [root, taskname, task_root])
+    mvs.execute("CD", [task_root, "frame", frame])
+    mvs.execute("CD", [task_root, "globals", _globals])
+    mvs.execute("CD", [task_root, "input", _input])
+    mvs.execute("CD", [task_root, "last_input", _input])
+    mvs.execute("CD", [task_root, "output", _output])
+    mvs.execute("CD", [task_root, "last_output", _output])
     mvs.execute("CD", [frame, "evalstack", evalstack])
     mvs.execute("CD", [frame, "returnvalue", returnvalue])
     mvs.execute("CD", [frame, "phase", phase])
@@ -62,12 +62,12 @@ def add_new_user(root, mvs, username):
     mvs.execute("CD", [frame, "symbols", symbols])
 
 def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
-    username = "user_1"
-    if operation == "initialize_new_user":
-        return add_new_user(mvk.root, mvs, username)
+    taskname = "task_1"
+    if operation == "initialize_new_task":
+        return add_new_task(mvk.root, mvs, taskname)
     response = None
     while 1:
-        mvs_commands = mvk.execute_yields(username, operation, params, response)
+        mvs_commands = mvk.execute_yields(taskname, operation, params, response)
         if mvs_commands is None:
             break
         response = []
@@ -75,37 +75,37 @@ def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
             response.append(mvs.execute(command, param)[0])
 
 def get_inst(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    inst = mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    inst = mvs.execute("RD", [task_frame, "IP"])[0]
     return mvs.execute("RV", [inst])[0]["value"]
 
 def get_phase(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return mvs.execute("RV", [phase])[0]
 
 def get_returnvalue(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    returnvalue = mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])[0]
     return mvs.execute("RV", [returnvalue])[0]
 
 def get_inst_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "IP"])[0]
 
 def get_returnvalue_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "returnvalue"])[0]
 
 def get_phase_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return phase
 
 def read_primitive_interfaces(root, mvs):

model/model.py

@@ -24,7 +24,7 @@ def get_object_constructor(code, filename):
     constructors = [3, "upload", filename, str(random.random()), True] + constructors + [False]
     return constructors
 
-def link_code(main_function, username, objects):
+def link_code(main_function, taskname, objects):
     return [3, "link_and_load"] + objects + ["", main_function]
 
 def translate(operation):
@@ -144,12 +144,12 @@ class MvKState(object):
         self.waiting = False
         self.inputs = {}
         self.outputs = {}
-        self.users = []
+        self.tasks = []
         self.reply = None
         self.phase = None
         self.commands = None
         self.root = None
-        self.current_user = None
+        self.current_task = None
         self.loaded_primitives = False
         self.execution_counter = 0
         self.all_failed = True
@@ -159,12 +159,12 @@ class MvKState(object):
                 "waiting: %s\n" % self.waiting + \
                 "inputs: %s\n" % self.inputs + \
                 "outputs: %s\n" % self.outputs + \
-                "users: %s\n" % self.users + \
+                "tasks: %s\n" % self.tasks + \
                 "reply: %s\n" % self.reply + \
                 "phase: %s\n" % self.phase + \
                 "commands: %s\n" % self.commands + \
                 "root: %s\n" % self.root + \
-                "current user: %s\n" % self.current_user + \
+                "current task: %s\n" % self.current_task + \
                 "execution counter: %s\n"
 
 class ModelverseKernel(AtomicDEVS):
@@ -183,12 +183,12 @@ class ModelverseKernel(AtomicDEVS):
         if self.from_mvi in inputs:
             # Got input from MvI, so we queue it
             for inp in inputs[self.from_mvi]:
-                username = inp[0]
+                taskname = inp[0]
                 data = inp[1]
                 if data is not None:
-                    self.state.inputs.setdefault(username, []).extend(data)
+                    self.state.inputs.setdefault(taskname, []).extend(data)
                 else:
-                    self.state.outputs.setdefault(username, []).append(None)
+                    self.state.outputs.setdefault(taskname, []).append(None)
 
         if self.from_mvs in inputs:
             # Got input from MvS, so we can continue processing
@@ -205,7 +205,7 @@ class ModelverseKernel(AtomicDEVS):
         return self.state
 
     def intTransition(self):
-        was_empty = len(self.state.users) == 0
+        was_empty = len(self.state.tasks) == 0
         if self.state.commands is not None:
             self.state.commands = None
             return self.state
@@ -223,44 +223,44 @@ class ModelverseKernel(AtomicDEVS):
             self.state.commands = commands
         else:
             # Are initialized and have work to do
-            if len(self.state.users) == 0:
-                # Read out new set of users first
+            if len(self.state.tasks) == 0:
+                # Read out new set of tasks first
                 if self.state.reply is None:
                     commands = [("RDK", [self.state.root])]
                 else:
-                    self.state.users = self.state.reply[0]
+                    self.state.tasks = self.state.reply[0]
                     commands = None
-            elif self.state.phase == "init_user":
+            elif self.state.phase == "init_task":
                 if self.state.reply is None:
-                    commands = [("RV", [self.state.users[0]])]
+                    commands = [("RV", [self.state.tasks[0]])]
                 else:
-                    self.state.current_user = self.state.reply[0]
-                    if self.state.current_user.startswith("__"):
-                        # Don't process this user and force termination of user
+                    self.state.current_task = self.state.reply[0]
+                    if self.state.current_task.startswith("__"):
+                        # Don't process this task and force termination of task
                         self.state.phase = "output"
                     commands = None
             elif self.state.phase == "input":
                 # Process inputs
-                if self.state.inputs.get(self.state.current_user, None):
-                    element_type, value = self.state.inputs[self.state.current_user][0]
-                    commands = self.state.mvk.execute_yields(self.state.current_user, "set_input", [element_type, value], self.state.reply)
+                if self.state.inputs.get(self.state.current_task, None):
+                    element_type, value = self.state.inputs[self.state.current_task][0]
+                    commands = self.state.mvk.execute_yields(self.state.current_task, "set_input", [element_type, value], self.state.reply)
                     if commands is None:
-                        self.state.inputs[self.state.current_user].pop(0)
+                        self.state.inputs[self.state.current_task].pop(0)
                 else:
                     commands = None
 
             elif self.state.phase == "computation":
-                commands = self.state.mvk.execute_yields(self.state.current_user, "execute_rule", [], self.state.reply)
+                commands = self.state.mvk.execute_yields(self.state.current_task, "execute_rule", [], self.state.reply)
             elif self.state.phase == "output":
-                commands = self.state.mvk.execute_yields(self.state.current_user, "get_output", [], self.state.reply)
+                commands = self.state.mvk.execute_yields(self.state.current_task, "get_output", [], self.state.reply)
             else:
                 raise Exception("Phase: " + str(self.state.phase))
 
             # Advance phase
             if commands is None:
                 if was_empty:
-                    self.state.phase = "init_user"
-                elif self.state.phase == "init_user":
+                    self.state.phase = "init_task"
+                elif self.state.phase == "init_task":
                     self.state.phase = "input"
                 elif self.state.phase == "input":
                     self.state.phase = "computation"
@@ -271,8 +271,8 @@ class ModelverseKernel(AtomicDEVS):
                     else:
                         self.state.execution_counter += 1
                 elif self.state.phase == "output":
-                    self.state.users.pop(0)
-                    self.state.phase = "init_user"
+                    self.state.tasks.pop(0)
+                    self.state.phase = "init_task"
                 self.state.waiting = False
                 self.state.reply = None
             else:
@@ -292,7 +292,7 @@ class ModelverseKernel(AtomicDEVS):
         return {}
 
     def timeAdvance(self):
-        if self.state.phase == "init_user" and self.state.all_failed:
+        if self.state.phase == "init_task" and self.state.all_failed:
             # Make this a parameter
             return 200
         if self.state.commands is not None:
@@ -313,11 +313,11 @@ class MvIState():
         self.init = True
 
 class ModelverseInterface(AtomicDEVS):
-    def __init__(self, username, operations):
-        AtomicDEVS.__init__(self, "MvI_%s" % username)
+    def __init__(self, taskname, operations):
+        AtomicDEVS.__init__(self, "MvI_%s" % taskname)
         self.state = MvIState()
         self.state.operations = operations
-        self.username = username
+        self.taskname = taskname
 
         self.to_mvk = self.addOutPort("to_MvK")
         self.from_mvk = self.addInPort("from_MvK")
@@ -340,7 +340,7 @@ class ModelverseInterface(AtomicDEVS):
         return self.state
 
     def outputFnc(self):
-        return {self.to_mvk: [(self.username, self.state.operations)]}
+        return {self.to_mvk: [(self.taskname, self.state.operations)]}
 
     def timeAdvance(self):
         if self.state.init:
@@ -392,7 +392,7 @@ class Network(AtomicDEVS):
 
 class System(CoupledDEVS):
     def __init__(self,
-                username,
+                taskname,
                 operations,
                 rules_per_phase,
                 mvi2mvk_latency,
@@ -423,11 +423,11 @@ class System(CoupledDEVS):
         CoupledDEVS.__init__(self, "System")
 
         self.mvi_manager = self.addSubModel(ModelverseInterface(\
-                            username            = "user_manager",
-                            operations          = [username],
+                            taskname            = "task_manager",
+                            operations          = [taskname],
                         ))
         self.mvi = self.addSubModel(ModelverseInterface(\
-                            username            = username,
+                            taskname            = taskname,
                             operations          = operations
                         ))
         self.mvk = self.addSubModel(ModelverseKernel(\
@@ -492,17 +492,17 @@ Void function main():
 \tlog("Executed the code!")
 \treturn !
     """
-username = "test_user"
+taskname = "test_task"
 
 operations = [get_object_constructor(open(f, 'r').read(), str(f)) for f in files] + \
               get_object_constructor(code, "main") + \
-              link_code("main", username, files + ["code.alc"])
+              link_code("main", taskname, files + ["code.alc"])
 
 print("Generated operations:")
 print(operations)
 
 args = {
-        "username":             username,
+        "taskname":             taskname,
         "operations":           operations,
         "mvi2mvk_latency":      1,
         "mvi2mvk_bandwidth":    2000,

performance/utils.py

@@ -17,7 +17,7 @@ sys.path.append("scripts")
 from hutn_compiler.compiler import main as do_compile
 from check_objects import to_recompile
 
-USERNAME = "test_user"
+USERNAME = "test_task"
 PARALLEL_PUSH = True
 
 BOOTSTRAP_FOLDER_NAME = "bootstrap"
@@ -37,7 +37,7 @@ ALL_OPTIMIZATION_LEVELS = [
 ]
 
 class ModelverseTerminated(Exception):
-    """An exception that tells the user that the Modelverse has terminated."""
+    """An exception that tells the task that the Modelverse has terminated."""
     pass
 
 def get_code_folder_name():
@@ -82,7 +82,7 @@ def set_input_data(address, data):
             urllib2.Request(
                 address,
                 urllib.urlencode(
-                    {"op": "set_input", "data": json.dumps(data), "username": USERNAME})),
+                    {"op": "set_input", "data": json.dumps(data), "taskname": USERNAME})),
             timeout=10).read()
     else:
         return []
@@ -92,10 +92,10 @@ def compile_file(address, mod_filename, filename, mode, proc):
     # Load in the file required
     try:
         timeout_val = 240
-        username = str(random.random())
+        taskname = str(random.random())
         while 1:
             proc2 = execute(
-                "compile", [address, mod_filename, username, filename, mode], wait=False)
+                "compile", [address, mod_filename, taskname, filename, mode], wait=False)
 
             if proc.returncode is not None:
                 # Modelverse has already terminated, which isn't a good sign!
@@ -183,7 +183,7 @@ def run_file(files, parameters, mode, handle_output, optimization_level=None):
             val = urllib2.urlopen(
                 urllib2.Request(
                     address,
-                    urllib.urlencode({"op": "get_output", "username": USERNAME})),
+                    urllib.urlencode({"op": "get_output", "taskname": USERNAME})),
                 timeout=240).read()
             val = json.loads(val)
 

scripts/check_objects.py

@@ -6,17 +6,17 @@ import hashlib
 import time
 
 def to_recompile(address, files):
-    username = str(random.random())
+    taskname = str(random.random())
     files = sorted(files)
     rebuild = []
 
     def flush_data(data):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "taskname": taskname}))).read()
 
     while 1:
         try:
-            # Create new user
-            urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % username, "username": "user_manager"}))).read()
+            # Create new task
+            urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % taskname, "taskname": "task_manager"}))).read()
             break
         except:
             time.sleep(0.01)
@@ -33,7 +33,7 @@ def to_recompile(address, files):
         md5_values[f] = md5.hexdigest()
 
     for f in files:
-        v = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username}))).read()
+        v = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname}))).read()
         mv_md5 = json.loads(v)
         if md5_values[f] == mv_md5:
             # Identical, so don't rebuild
@@ -43,5 +43,5 @@ def to_recompile(address, files):
             # Different, so rebuild
             rebuild.append(f)
 
-    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '-1', "username": username}))).read()
+    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '-1', "taskname": taskname}))).read()
     return rebuild

scripts/compile.py

@@ -5,7 +5,7 @@ import urllib
 import subprocess
 import time
 
-def do_compile(address, filename, username, modulename, mode, optionals=['--debug'], grammar=""):
+def do_compile(address, filename, taskname, modulename, mode, optionals=['--debug'], grammar=""):
     filename = os.path.realpath(filename)
     if grammar == "":
         if mode[0] == "M":
@@ -14,26 +14,25 @@ def do_compile(address, filename, username, modulename, mode, optionals=['--debu
         else:
             # Load AL grammar
             grammar = "grammars/actionlanguage.g"
-    while 1:
-        try:
-            # Create new user
-            urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % username, "username": "user_manager"}))).read()
-            subprocess.check_call([sys.executable, "hutn_compiler/compiler.py", filename, grammar, mode, username, modulename, filename, address] + optionals, cwd="interface/HUTN")
-            break
-        except:
-            time.sleep(0.01)
-    return 0
+
+    # Create new task
+    try:
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % taskname, "taskname": "task_manager"}))).read()
+        subprocess.check_call([sys.executable, "hutn_compiler/compiler.py", filename, grammar, mode, taskname, modulename, filename, address] + optionals, cwd="interface/HUTN")
+        return 0
+    except:
+        return 1
 
 if __name__ == "__main__":
     if len(sys.argv) != 6:
         sys.stderr.write("Expected different parameters!\n")
-        sys.stderr.write("    %s address filename username modulename mode\n" % sys.argv[0])
+        sys.stderr.write("    %s address filename taskname modulename mode\n" % sys.argv[0])
         sys.exit(1)
     else:
         address = sys.argv[1]
         filename = sys.argv[2]
-        username = sys.argv[3]
+        taskname = sys.argv[3]
         modulename = sys.argv[4]
         mode = sys.argv[5]
         
-        sys.exit(do_compile(address, filename, username, modulename, mode))
+        sys.exit(do_compile(address, filename, taskname, modulename, mode))

scripts/debug_prompt.py

@@ -25,11 +25,11 @@ location = raw_input()
 if location == "":
     address = "http://127.0.0.1:8001/"
     
-local_print("Please specify user name (default: test)")
+local_print("Please specify task name (default: test)")
 
-username = raw_input()
+taskname = raw_input()
 if location == "":
-    username = "test"
+    taskname = "test"
 
 local_print("Switching context to Modelverse: all data is piped.")
 local_print("Available commands: 'pause', 'resume'")
@@ -42,4 +42,4 @@ while 1:
         local_print("Received quit: breaking connection to Modelverse immediately!")
         break
 
-    print json.loads(urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": action, "username": username}))).read())
+    print json.loads(urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": action, "taskname": taskname}))).read())

scripts/execute_model.py

@@ -12,7 +12,7 @@ models = []
 code = []
 
 address = sys.argv[1]
-username = sys.argv[2]
+taskname = sys.argv[2]
 files = [a.replace("\\", "/") for a in sum([glob.glob(f) for f in sys.argv[3:]], [])]
 
 for f in files:
@@ -28,12 +28,12 @@ def initialize_SCD():
     import urllib2
     import urllib
     import json
-    username = random.random()
+    taskname = random.random()
 
     while 1:
         try:
-            # Create new user
-            urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % username, "username": "user_manager"}))).read()
+            # Create new task
+            urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % taskname, "taskname": "task_manager"}))).read()
             break
         except:
             time.sleep(0.01)
@@ -46,8 +46,8 @@ def initialize_SCD():
     data.append(2)
 
     print("Initializing SCD")
-    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "username": username}))).read()
-    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username}))).read()
+    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "taskname": taskname}))).read()
+    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname}))).read()
     print("Initialized!")
 
 def do_compile_wrapper(filename, mode, grammar):
@@ -60,4 +60,4 @@ for m in models:
     print("[MODEL] %s" % m)
     do_compile_wrapper(m, "MO", "grammars/modelling.g")
 
-main(address, username, code)
+main(address, taskname, code)

scripts/link_and_load.py

@@ -1,20 +1,20 @@
 import sys
 import urllib2
 
-def link_and_load(address, username, objs):
-    urllib2.urlopen(urllib2.Request(address, 'op=set_input&username=user_manager&value="%s"' % username)).read()
+def link_and_load(address, taskname, objs):
+    urllib2.urlopen(urllib2.Request(address, 'op=set_input&taskname=task_manager&value="%s"' % taskname)).read()
 
     sys.path.append("interface/HUTN")
     from hutn_compiler.linker import link
-    link(address, username, objs)
+    link(address, taskname, objs)
 
 if __name__ == "__main__":
     if len(sys.argv) < 4:
         sys.stderr.write("Expected different parameters!\n")
-        sys.stderr.write("    %s address username [files]*\n")
+        sys.stderr.write("    %s address taskname [files]*\n")
     else:
         address = sys.argv[1]
-        username = sys.argv[2]
+        taskname = sys.argv[2]
         objs = sys.argv[3:]
 
-        link_and_load(address, username, objs)
+        link_and_load(address, taskname, objs)