Fixed several bugs in precompiled code

bootstrap/conformance_scd.alc

@@ -4,6 +4,21 @@ include "object_operations.alh"
 include "constructors.alh"
 include "modelling.alh"
 
+Element function set_copy(a : Element):
+	Element b
+	Integer i
+	Integer count
+
+	b = create_node()
+	i = 0
+	count = read_nr_out(a)
+
+	while (i < count):
+		set_add(b, read_edge_dst(read_out(a, i)))
+		i = i + 1
+
+	return b
+
 Boolean function is_direct_instance(model : Element, instance : String, type : String):
 	// Just check whether or not the type mapping specifies the type as the type of the instance
 	return element_eq(dict_read_node(model["type_mapping"], model["model"][instance]), model["metamodel"]["model"][type])
@@ -66,24 +81,23 @@ Element function precompute_cardinalities(model : Element):
 	cardinalities = create_node()
 	while (0 < list_len(keys)):
 		key = set_pop(keys)
-		if (is_edge(model["model"][key])):
-			tmp_dict = create_node()
-			slc = read_attribute(metamodel, key, "source_lower_cardinality")
-			suc = read_attribute(metamodel, key, "source_upper_cardinality")
-			tlc = read_attribute(metamodel, key, "target_lower_cardinality")
-			tuc = read_attribute(metamodel, key, "target_upper_cardinality")
-
-			if (element_neq(slc, read_root())):
-				dict_add(tmp_dict, "slc", slc)
-			if (element_neq(suc, read_root())):
-				dict_add(tmp_dict, "suc", suc)
-			if (element_neq(tlc, read_root())):
-				dict_add(tmp_dict, "tlc", tlc)
-			if (element_neq(tuc, read_root())):
-				dict_add(tmp_dict, "tuc", tuc)
-
-			if (list_len(tmp_dict) > 0):
-				dict_add(cardinalities, key, tmp_dict)
+		tmp_dict = create_node()
+		slc = read_attribute(metamodel, key, "source_lower_cardinality")
+		suc = read_attribute(metamodel, key, "source_upper_cardinality")
+		tlc = read_attribute(metamodel, key, "target_lower_cardinality")
+		tuc = read_attribute(metamodel, key, "target_upper_cardinality")
+
+		if (element_neq(slc, read_root())):
+			dict_add(tmp_dict, "slc", slc)
+		if (element_neq(suc, read_root())):
+			dict_add(tmp_dict, "suc", suc)
+		if (element_neq(tlc, read_root())):
+			dict_add(tmp_dict, "tlc", tlc)
+		if (element_neq(tuc, read_root())):
+			dict_add(tmp_dict, "tuc", tuc)
+
+		if (list_len(tmp_dict) > 0):
+			dict_add(cardinalities, key, tmp_dict)
 
 	return cardinalities
 
@@ -159,7 +173,7 @@ String function conformance_scd(model : Element):
 			if (bool_not(dict_in(spo_cache, type_name))):
 				dict_add(spo_cache, type_name, selectPossibleOutgoing(metamodel, type_name, dict_keys(cardinalities)))
 
-			check_list = spo_cache[type_name]
+			check_list = set_copy(spo_cache[type_name])
 			while (0 < list_len(check_list)):
 				check_type = set_pop(check_list)
 				if (dict_in(cardinalities, check_type)):
@@ -185,7 +199,7 @@ String function conformance_scd(model : Element):
 			if (bool_not(dict_in(spi_cache, type_name))):
 				dict_add(spi_cache, type_name, selectPossibleIncoming(metamodel, type_name, dict_keys(cardinalities)))
 
-			check_list = spi_cache[type_name]
+			check_list = set_copy(spi_cache[type_name])
 			while (0 < list_len(check_list)):
 				check_type = set_pop(check_list)
 				if (dict_in(cardinalities, check_type)):

bootstrap/metamodels.alc

@@ -193,139 +193,139 @@ Element function initialize_SCD(location : String):
 	instantiate_attribute(scd, "tuc", "name", "target_upper_cardinality")
 
 	// Add in the Action Language metamodel
-	instantiate_node(scd, "Class", "Action")
-	instantiate_node(scd, "Class", "Statement")
-	instantiate_node(scd, "Class", "Expression")
-	instantiate_node(scd, "Class", "funcdef")
-	instantiate_node(scd, "Class", "param")
-	instantiate_node(scd, "Class", "if")
-	instantiate_node(scd, "Class", "break")
-	instantiate_node(scd, "Class", "while")
-	instantiate_node(scd, "Class", "continue")
-	instantiate_node(scd, "Class", "assign")
-	instantiate_node(scd, "Class", "return")
-	instantiate_node(scd, "Class", "output")
-	instantiate_node(scd, "Class", "declare")
-	instantiate_node(scd, "Class", "global")
-	instantiate_node(scd, "Class", "access")
-	instantiate_node(scd, "Class", "constant")
-	instantiate_node(scd, "Class", "input")
-	instantiate_node(scd, "Class", "resolve")
-	instantiate_node(scd, "Class", "call")
-	instantiate_link(scd, "Association", "dict_link", "Action", "Any")
-	instantiate_link(scd, "Association", "to_str", "dict_link", "String")
-	instantiate_attribute(scd, "to_str", "name", "name")
-	instantiate_link(scd, "Inheritance", "", "Action", "Any")
-	instantiate_link(scd, "Inheritance", "", "funcdef", "Action")
-	instantiate_link(scd, "Inheritance", "", "param", "Action")
-	instantiate_link(scd, "Inheritance", "", "Statement", "Action")
-	instantiate_link(scd, "Inheritance", "", "Expression", "Action")
-	instantiate_link(scd, "Inheritance", "", "resolve", "Statement")
-	instantiate_link(scd, "Inheritance", "", "if", "Statement")
-	instantiate_link(scd, "Inheritance", "", "break", "Statement")
-	instantiate_link(scd, "Inheritance", "", "continue", "Statement")
-	instantiate_link(scd, "Inheritance", "", "global", "Statement")
-	instantiate_link(scd, "Inheritance", "", "while", "Statement")
-	instantiate_link(scd, "Inheritance", "", "assign", "Statement")
-	instantiate_link(scd, "Inheritance", "", "return", "Statement")
-	instantiate_link(scd, "Inheritance", "", "call", "Statement")
-	instantiate_link(scd, "Inheritance", "", "declare", "Statement")
-	instantiate_link(scd, "Inheritance", "", "call", "Expression")
-	instantiate_link(scd, "Inheritance", "", "access", "Expression")
-	instantiate_link(scd, "Inheritance", "", "constant", "Expression")
-	instantiate_link(scd, "Inheritance", "", "input", "Expression")
-	instantiate_link(scd, "Association", "statement_next", "Statement", "Statement")
-	instantiate_link(scd, "Association", "if_cond", "if", "Expression")
-	instantiate_link(scd, "Association", "if_then", "if", "Statement")
-	instantiate_link(scd, "Association", "if_else", "if", "Statement")
-	instantiate_link(scd, "Association", "while_cond", "while", "Expression")
-	instantiate_link(scd, "Association", "while_body", "while", "Statement")
-	instantiate_link(scd, "Association", "assign_var", "assign", "Any")
-	instantiate_link(scd, "Association", "assign_value", "assign", "Expression")
-	instantiate_link(scd, "Association", "break_while", "break", "while")
-	instantiate_link(scd, "Association", "continue_while", "continue", "while")
-	instantiate_link(scd, "Association", "return_value", "return", "Expression")
-	instantiate_link(scd, "Association", "resolve_var", "resolve", "Any")
-	instantiate_link(scd, "Association", "access_var", "access", "Any")
-	instantiate_link(scd, "Association", "constant_node", "constant", "Any")
-	instantiate_link(scd, "Association", "output_node", "output", "Expression")
-	instantiate_link(scd, "Association", "global_var", "global", "String")
-	instantiate_link(scd, "Association", "param_name", "param", "String")
-	instantiate_link(scd, "Association", "param_value", "param", "Expression")
-	instantiate_link(scd, "Association", "param_next_param", "param", "param")
-	instantiate_link(scd, "Association", "funcdef_body", "funcdef", "Statement")
-	instantiate_link(scd, "Association", "call_func", "call", "Expression")
-	instantiate_link(scd, "Association", "call_params", "call", "param")
-	instantiate_link(scd, "Association", "call_last_param", "call", "param")
-	instantiate_link(scd, "Inheritance", "", "statement_next", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "if_cond", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "if_then", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "if_else", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "while_cond", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "while_body", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "assign_var", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "assign_value", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "break_while", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "continue_while", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "return_value", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "resolve_var", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "access_var", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "constant_node", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "output_node", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "global_var", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "param_name", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "param_value", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "param_next_param", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "funcdef_body", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "call_func", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "call_params", "dict_link")
-	instantiate_link(scd, "Inheritance", "", "call_last_param", "dict_link")
-
-	// Add cardinalities on how many connections are allowed: one of each
-	instantiate_attribute(scd, "statement_next", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "if_cond", "target_lower_cardinality", 1)
-	instantiate_attribute(scd, "if_cond", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "if_then", "target_lower_cardinality", 1)
-	instantiate_attribute(scd, "if_then", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "if_else", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "while_cond", "target_lower_cardinality", 1)
-	instantiate_attribute(scd, "while_cond", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "while_body", "target_lower_cardinality", 1)
-	instantiate_attribute(scd, "while_body", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "assign_var", "target_lower_cardinality", 1)
-	instantiate_attribute(scd, "assign_var", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "assign_value", "target_lower_cardinality", 1)
-	instantiate_attribute(scd, "assign_value", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "break_while", "target_lower_cardinality", 1)
-	instantiate_attribute(scd, "break_while", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "continue_while", "target_lower_cardinality", 1)
-	instantiate_attribute(scd, "continue_while", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "return_value", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "resolve_var", "target_lower_cardinality", 1)
-	instantiate_attribute(scd, "resolve_var", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "access_var", "target_lower_cardinality", 1)
-	instantiate_attribute(scd, "access_var", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "constant_node", "target_lower_cardinality", 1)
-	instantiate_attribute(scd, "constant_node", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "output_node", "target_lower_cardinality", 1)
-	instantiate_attribute(scd, "output_node", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "global_var", "target_lower_cardinality", 1)
-	instantiate_attribute(scd, "global_var", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "param_name", "target_lower_cardinality", 1)
-	instantiate_attribute(scd, "param_name", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "param_value", "target_lower_cardinality", 1)
-	instantiate_attribute(scd, "param_value", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "param_next_param", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "funcdef_body", "target_lower_cardinality", 1)
-	instantiate_attribute(scd, "funcdef_body", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "call_func", "target_lower_cardinality", 1)
-	instantiate_attribute(scd, "call_func", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "call_params", "target_upper_cardinality", 1)
-	instantiate_attribute(scd, "call_last_param", "target_upper_cardinality", 1)
-
-	// Now still allow for constraints on classes
-	instantiate_link(scd, "Association", "constraint", "Class", "funcdef")
-	instantiate_attribute(scd, "constraint", "name", "constraint")
+	//instantiate_node(scd, "Class", "Action")
+	//instantiate_node(scd, "Class", "Statement")
+	//instantiate_node(scd, "Class", "Expression")
+	//instantiate_node(scd, "Class", "funcdef")
+	//instantiate_node(scd, "Class", "param")
+	//instantiate_node(scd, "Class", "if")
+	//instantiate_node(scd, "Class", "break")
+	//instantiate_node(scd, "Class", "while")
+	//instantiate_node(scd, "Class", "continue")
+	//instantiate_node(scd, "Class", "assign")
+	//instantiate_node(scd, "Class", "return")
+	//instantiate_node(scd, "Class", "output")
+	//instantiate_node(scd, "Class", "declare")
+	//instantiate_node(scd, "Class", "global")
+	//instantiate_node(scd, "Class", "access")
+	//instantiate_node(scd, "Class", "constant")
+	//instantiate_node(scd, "Class", "input")
+	//instantiate_node(scd, "Class", "resolve")
+	//instantiate_node(scd, "Class", "call")
+	//instantiate_link(scd, "Association", "dict_link", "Action", "Any")
+	//instantiate_link(scd, "Association", "to_str", "dict_link", "String")
+	//instantiate_attribute(scd, "to_str", "name", "name")
+	//instantiate_link(scd, "Inheritance", "", "Action", "Any")
+	//instantiate_link(scd, "Inheritance", "", "funcdef", "Action")
+	//instantiate_link(scd, "Inheritance", "", "param", "Action")
+	//instantiate_link(scd, "Inheritance", "", "Statement", "Action")
+	//instantiate_link(scd, "Inheritance", "", "Expression", "Action")
+	//instantiate_link(scd, "Inheritance", "", "resolve", "Statement")
+	//instantiate_link(scd, "Inheritance", "", "if", "Statement")
+	//instantiate_link(scd, "Inheritance", "", "break", "Statement")
+	//instantiate_link(scd, "Inheritance", "", "continue", "Statement")
+	//instantiate_link(scd, "Inheritance", "", "global", "Statement")
+	//instantiate_link(scd, "Inheritance", "", "while", "Statement")
+	//instantiate_link(scd, "Inheritance", "", "assign", "Statement")
+	//instantiate_link(scd, "Inheritance", "", "return", "Statement")
+	//instantiate_link(scd, "Inheritance", "", "call", "Statement")
+	//instantiate_link(scd, "Inheritance", "", "declare", "Statement")
+	//instantiate_link(scd, "Inheritance", "", "call", "Expression")
+	//instantiate_link(scd, "Inheritance", "", "access", "Expression")
+	//instantiate_link(scd, "Inheritance", "", "constant", "Expression")
+	//instantiate_link(scd, "Inheritance", "", "input", "Expression")
+	//instantiate_link(scd, "Association", "statement_next", "Statement", "Statement")
+	//instantiate_link(scd, "Association", "if_cond", "if", "Expression")
+	//instantiate_link(scd, "Association", "if_then", "if", "Statement")
+	//instantiate_link(scd, "Association", "if_else", "if", "Statement")
+	//instantiate_link(scd, "Association", "while_cond", "while", "Expression")
+	//instantiate_link(scd, "Association", "while_body", "while", "Statement")
+	//instantiate_link(scd, "Association", "assign_var", "assign", "Any")
+	//instantiate_link(scd, "Association", "assign_value", "assign", "Expression")
+	//instantiate_link(scd, "Association", "break_while", "break", "while")
+	//instantiate_link(scd, "Association", "continue_while", "continue", "while")
+	//instantiate_link(scd, "Association", "return_value", "return", "Expression")
+	//instantiate_link(scd, "Association", "resolve_var", "resolve", "Any")
+	//instantiate_link(scd, "Association", "access_var", "access", "Any")
+	//instantiate_link(scd, "Association", "constant_node", "constant", "Any")
+	//instantiate_link(scd, "Association", "output_node", "output", "Expression")
+	//instantiate_link(scd, "Association", "global_var", "global", "String")
+	//instantiate_link(scd, "Association", "param_name", "param", "String")
+	//instantiate_link(scd, "Association", "param_value", "param", "Expression")
+	//instantiate_link(scd, "Association", "param_next_param", "param", "param")
+	//instantiate_link(scd, "Association", "funcdef_body", "funcdef", "Statement")
+	//instantiate_link(scd, "Association", "call_func", "call", "Expression")
+	//instantiate_link(scd, "Association", "call_params", "call", "param")
+	//instantiate_link(scd, "Association", "call_last_param", "call", "param")
+	//instantiate_link(scd, "Inheritance", "", "statement_next", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "if_cond", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "if_then", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "if_else", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "while_cond", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "while_body", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "assign_var", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "assign_value", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "break_while", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "continue_while", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "return_value", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "resolve_var", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "access_var", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "constant_node", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "output_node", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "global_var", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "param_name", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "param_value", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "param_next_param", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "funcdef_body", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "call_func", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "call_params", "dict_link")
+	//instantiate_link(scd, "Inheritance", "", "call_last_param", "dict_link")
+
+	//// Add cardinalities on how many connections are allowed: one of each
+	//instantiate_attribute(scd, "statement_next", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "if_cond", "target_lower_cardinality", 1)
+	//instantiate_attribute(scd, "if_cond", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "if_then", "target_lower_cardinality", 1)
+	//instantiate_attribute(scd, "if_then", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "if_else", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "while_cond", "target_lower_cardinality", 1)
+	//instantiate_attribute(scd, "while_cond", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "while_body", "target_lower_cardinality", 1)
+	//instantiate_attribute(scd, "while_body", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "assign_var", "target_lower_cardinality", 1)
+	//instantiate_attribute(scd, "assign_var", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "assign_value", "target_lower_cardinality", 1)
+	//instantiate_attribute(scd, "assign_value", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "break_while", "target_lower_cardinality", 1)
+	//instantiate_attribute(scd, "break_while", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "continue_while", "target_lower_cardinality", 1)
+	//instantiate_attribute(scd, "continue_while", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "return_value", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "resolve_var", "target_lower_cardinality", 1)
+	//instantiate_attribute(scd, "resolve_var", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "access_var", "target_lower_cardinality", 1)
+	//instantiate_attribute(scd, "access_var", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "constant_node", "target_lower_cardinality", 1)
+	//instantiate_attribute(scd, "constant_node", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "output_node", "target_lower_cardinality", 1)
+	//instantiate_attribute(scd, "output_node", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "global_var", "target_lower_cardinality", 1)
+	//instantiate_attribute(scd, "global_var", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "param_name", "target_lower_cardinality", 1)
+	//instantiate_attribute(scd, "param_name", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "param_value", "target_lower_cardinality", 1)
+	//instantiate_attribute(scd, "param_value", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "param_next_param", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "funcdef_body", "target_lower_cardinality", 1)
+	//instantiate_attribute(scd, "funcdef_body", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "call_func", "target_lower_cardinality", 1)
+	//instantiate_attribute(scd, "call_func", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "call_params", "target_upper_cardinality", 1)
+	//instantiate_attribute(scd, "call_last_param", "target_upper_cardinality", 1)
+
+	//// Now still allow for constraints on classes
+	//instantiate_link(scd, "Association", "constraint", "Class", "funcdef")
+	//instantiate_attribute(scd, "constraint", "name", "constraint")
 
 	// Add constraints to all primitive classes
 	//add_constraint(scd, "if", constraint_if)
@@ -344,8 +344,8 @@ Element function initialize_SCD(location : String):
 	//add_constraint(scd, "call", constraint_call)
 
 	// And add some, to enforce correct physical types
-	add_constraint(scd, "Natural", constraint_natural)
-	add_constraint(scd, "String", constraint_string)
+	//add_constraint(scd, "Natural", constraint_natural)
+	//add_constraint(scd, "String", constraint_string)
 
 	// Finally done, so export!
 	export_node(location, scd)
@@ -378,7 +378,7 @@ Element function initialize_PN(location_SCD : String, location_PN : String):
 	instantiate_attribute(pn, "T2P_weight", "target_upper_cardinality", 1)
 
 	// Add constraint on the Natural
-	add_constraint(pn, "Natural", constraint_natural)
+	//add_constraint(pn, "Natural", constraint_natural)
 
 	// Add global constraints
 	//set_model_constraints(pn, petrinet_constraints)

kernel/modelverse_kernel/compiled.py

@@ -14,25 +14,28 @@ def reverseKeyLookup(a, b, **remainder):
     raise PrimitiveFinished(result)
 
 def read_attribute(a, b, c, **remainder):
+    def make_list(v, l):
+        return [v] if l else v
+
     #TODO this can be optimized even further...
-    model_dict, b_val, type_mapping = \
+    model_dict, b_val, c_val, type_mapping = \
                     yield [("RD", [a, "model"]),
                            ("RV", [b]),
+                           ("RV", [c]),
                            ("RD", [a, "type_mapping"]),
                            ]
-    model_instance, edges = \
-                    yield [("RD", [model_dict, b]),
-                           ("RO", [a]),
-                           ]
+    model_instance = \
+                    yield [("RD", [model_dict, b_val])]
+    edges =         yield [("RO", [model_instance])]
     edge_types =    yield [("RDN", [type_mapping, i]) for i in edges]
+    edge_types = make_list(edge_types, len(edges) == 1)
     type_edge_val = yield [("RE", [i]) for i in edge_types]
+    type_edge_val = make_list(type_edge_val, len(edges) == 1)
 
     src_nodes = set([i[0] for i in type_edge_val])
 
-    found_edges =   yield [("RDE", [i, b_val]) for i in src_nodes]
-
-    if len(src_nodes) == 1:
-        found_edges = [found_edges]
+    found_edges =   yield [("RDE", [i, c_val]) for i in src_nodes]
+    found_edges = make_list(found_edges, len(src_nodes) == 1)
 
     for e1 in found_edges:
         if e1 is not None:
@@ -54,19 +57,24 @@ def precompute_cardinalities(a, **remainder):
     result =        yield [("CN", [])]
 
     # Read out all edges from the metamodel
+    a =             yield [("RD", [a, "metamodel"])]
     model_dict =    yield [("RD", [a, "model"])]
+    model_keys =    yield [("RDK", [model_dict])]
     type_mapping =  yield [("RD", [a, "type_mapping"])]
-    elems =         yield [("RO", [model_dict])]
-    elems =         yield [("RE", [i]) for i in elems]
-    elems = [i[1] for i in elems]
+    elems =         yield [("RDN", [model_dict, k]) for k in model_keys]
+    model_keys_str= yield [("RV", [i]) for i in model_keys]
+    elem_to_name =  dict(zip(elems, model_keys_str))
     edges =         yield [("RE", [i]) for i in elems]
     elems = [elems[i] for i, edge_val in enumerate(edges) if edge_val is not None]
     # Now we have all edges in the metamodel
 
     # Read out the type of the Association defining all cardinalities
     metamodel =     yield [("RD", [a, "metamodel"])]
-    metamodel_dict= yield [("RD", [metamodel, "model"])]
-    assoc =         yield [("RD", [metamodel_dict, "Association"])]
+    metametamodel = yield [("RD", [metamodel, "metamodel"])]
+    metametamodel_dict = \
+                    yield [("RD", [metametamodel, "model"])]
+    assoc =         yield [("RD", [metametamodel_dict, "Association"])]
+    print(assoc)
     slc, suc, tlc, tuc = \
                     yield [("RDE", [assoc, "source_lower_cardinality"]),
                            ("RDE", [assoc, "source_upper_cardinality"]),
@@ -74,9 +82,17 @@ def precompute_cardinalities(a, **remainder):
                            ("RDE", [assoc, "target_upper_cardinality"]),
                           ]
 
+    print("===================================================================================")
+    print(slc)
+    print(suc)
+    print(tlc)
+    print(tuc)
+    print("===================================================================================")
+    print(elems)
     # All that we now have to do is find, for each edge, whether or not it has an edge typed by any of these links!
     # Just find all links typed by these links!
     types =         yield [("RDN", [type_mapping, i]) for i in elems]
+    print(types)
 
     cardinalities = {}
     for i, edge_type in enumerate(types):
@@ -91,19 +107,22 @@ def precompute_cardinalities(a, **remainder):
         else:
             continue
         
+        print("HIT CARDINALITY!")
         # Found a link, so add it
         source, destination = yield [("RE", [elems[i]])]
         # The edge gives the "source" the cardinality found in "destination"
-        cardinalities.setdefault(source, {})[t] = destination
+        cardinalities.setdefault(elem_to_name[source], {})[t] = destination
 
     # Now we have to translate the "cardinalities" Python dictionary to a Modelverse dictionary
     nodes = yield [("CN", []) for i in cardinalities]
-    yield [("CD", [result, i, node]) for i, node in zip(cardinalities, nodes)]
-    l = list(cardinalities)
+    yield [("CD", [result, i, node]) for i, node in zip(cardinalities.keys(), nodes)]
+    print("Create dict entries for " + str(cardinalities.keys()))
+    l = cardinalities.keys()
     values = yield [("RD", [result, i]) for i in l]
 
     for i, value in enumerate(values):
         cards = cardinalities[l[i]]
         yield [("CD", [value, card_type, cards[card_type]]) for card_type in cards]
+        print("CD %s --> %s" % (card_type, cards[card_type]))
 
     raise PrimitiveFinished(result)