First port of constructors to immediately create the required model

bootstrap/constructors.alc

@@ -4,6 +4,7 @@ include "library.alh"
 include "io.alh"
 include "modelling.alh"
 include "utils.alh"
+include "object_operations.alh"
 
 Element while_stack = ?
 Element variable_map = ?
@@ -17,7 +18,7 @@ Element function construct_function_list(list : Element):
 	Element first_element
 
 	Element model
-	model = instantiate_model("formalisms/SimpleClassDiagrams")
+	model = instantiate_model("formalisms/ActionLanguage")
 
 	list = list_reverse(list)
 
@@ -66,50 +67,56 @@ Element function construct_function_list(list : Element):
 		return read_root()!
 
 	// Overwrite the main function with our declaration function
-	prev_element = main_function["body"]
-	log("Got parameters for main function: " + set_to_string(dict_keys(main_function)))
-	dict_delete(main_function, "body")
-	dict_add_fast(main_function, "body", first_element)
-	dict_add_fast(result["end"], "next", prev_element)
+	prev_element = set_pop(allAssociationDestinations(model, main_function, "funcdef_body"))
+	log("Got parameters for main function: " + set_to_string(dict_keys(model["model"][main_function])))
+	model_delete_element(model, set_pop(allOutgoingAssociationInstances(model, main_function, "funcdef_body")))
+	create_al_link(model, "funcdef_body", main_function, first_element, "body")
+	create_al_link(model, "Statement_next", result["end"], prev_element, "next")
+
+	instantiate_link(model, "initial_funcdef", "", instantiate_node(model, "Initial", ""), main_function)
 	
-	return main_function!
+	return model!
+
+Void function create_al_link(model : Element, linktype : String, source : String, target : String, dictname : String):
+	instantiate_attribute(model, instantiate_link(model, linktype, "", source, target), "name", dictname)
+	return!
 
-Action function construct_global(model : Element, list : Element):
-	Action this_element
+String function construct_global(model : Element, list : Element):
+	String this_element
 	String declared_element
 	String op
 
-	this_element = create_value(!global)
+	this_element = instantiate_value(model, "global", "", create_value(!global))
 	declared_element = list_pop_final(list)
-	dict_add_fast(this_element, "var", declared_element)
+	create_al_link(model, "global_var", this_element, instantiate_value(model, "String", "", declared_element), "var")
 
 	op = list_pop_final(list)
 	if (op != "none"):
 		// Defines
-		Action assign
-		Action resolve
-		Action value
-		assign = create_value(!assign)
-		dict_add_fast(this_element, "next", assign)
-		resolve = create_value(!resolve)
-		dict_add_fast(assign, "var", resolve)
-		dict_add_fast(resolve, "var", declared_element)
+		String assign
+		String resolve
+		String value
+		assign = instantiate_value(model, "assign", "", create_value(!assign))
+		create_al_link(model, "Statement_next", this_element, assign, "next")
+		resolve = instantiate_value(model, "resolve", "", create_value(!resolve))
+		create_al_link(model, "assign_var", assign, resolve, "var")
+		create_al_link(model, "resolve_var", resolve, declared_element, "var")
 		if (op == "deref"):
-			value = create_value(!constant)
-			dict_add_fast(value, "node", import_node(list_pop_final(list)))
+			value = instantiate_value(model, "constant", "", create_value(!constant))
+			create_al_link(model, "constant_node", this_element, value, "node")
 		elif (op == "empty"):
-			value = create_value(!call)
-			Element res
-			Element acc
-			res = create_value(!resolve)
-			acc = create_value(!access)
-			dict_add_fast(value, "func", acc)
-			dict_add_fast(acc, "var", res)
-			dict_add_fast(res, "var", "create_node")
+			value = instantiate_value(model, "call", "", create_value(!call))
+			String res
+			String acc
+			res = instantiate_value(model, "resolve", "", create_value(!resolve))
+			acc = instantiate_value(model, "access", "", create_value(!access))
+			create_al_link(model, "call_func", value, acc, "func")
+			create_al_link(model, "access_var", acc, res, "var")
+			create_al_link(model, "resolve_var", res, instantiate_value(model, "String", "", "create_node"), "var")
 		elif (op == "const"):
-			value = create_value(!constant)
-			dict_add_fast(value, "node", list_pop_final(list))
-		dict_add_fast(assign, "value", value)
+			value = instantiate_value(model, "constant", "", create_value(!constant))
+			create_al_link(model, "constant_node", value, list_pop_final(list), "node")
+		create_al_link(model, "assign_value", assign, value, "value")
 
 		Element result
 		result = dict_create()
@@ -127,37 +134,38 @@ Action function construct_global(model : Element, list : Element):
 		dict_add_fast(result, "end", this_element)
 		return result!
 
-Action function construct_funcdef(model : Element, list : Element, mutable : Boolean):
-	Action assign
-	Action resolve
-	Action constant
+String function construct_funcdef(model : Element, list : Element, mutable : Boolean):
+	String assign
+	String resolve
+	String constant
 	Element formal
 	Element func
 	Element params
-	Action declare
+	String declare
 	String name
 
-	declare = create_value(!global)
-	assign = create_value(!assign)
-	resolve = create_value(!resolve)
-	constant = create_value(!constant)
+	declare = instantiate_value(model, "global", "", create_value(!global))
+	assign = instantiate_value(model, "assign", "", create_value(!assign))
+	resolve = instantiate_value(model, "resolve", "", create_value(!resolve))
+	constant = instantiate_value(model, "constant", "", create_value(!constant))
 	name = list_pop_final(list)
 	if (dict_in(variable_map, name)):
 		formal = dict_read(variable_map, name)
 	else:
-		formal = name
-	func = create_node()
-	params = create_node()
-	dict_add_fast(declare, "var", formal)
-	dict_add_fast(declare, "next", assign)
-	dict_add_fast(assign, "var", resolve)
-	dict_add_fast(assign, "value", constant)
-	dict_add_fast(resolve, "var", formal)
-	dict_add_fast(constant, "node", func)
-	dict_add_fast(func, "params", params)
+		formal = instantiate_value(model, "String", "", name)
+	formal = instantiate_value(model, "String", "", formal)
+	func = instantiate_node(model, "funcdef", "")
+	params = instantiate_node(model, "param_dict", "")
+	create_al_link(model, "declare_var", declare, formal, "var")
+	create_al_link(model, "Statement_next", declare, assign, "next")
+	create_al_link(model, "assign_var", assign, resolve, "var")
+	create_al_link(model, "assign_value", assign, constant, "value")
+	create_al_link(model, "resolve_var", resolve, formal, "var")
+	create_al_link(model, "constant_node", constant, func, "node")
+	create_al_link(model, "funcdef_params", func, params, "params")
 
 	if (mutable):
-		dict_add_fast(func, "mutable", create_node())
+		create_al_link(model, "funcdef_mutable", func, instantiate_node(model, "Element", ""), "mutable")
 
 	Integer nrParams
 	nrParams = list_pop_final(list)
@@ -169,15 +177,14 @@ Action function construct_funcdef(model : Element, list : Element, mutable : Boo
 	arg_names_decl = "abcdefghijklmnopqrstuvwxyz"
 
 	while (counter < nrParams):
-		param = create_node()
-		dict_add_fast(params, string_get(arg_names_decl, counter), param)
-		dict_add_fast(param, "name", string_get(arg_names_decl, counter))
-		dict_add_fast(variable_map, list_pop_final(list), param)
+		param = instantiate_node(model, "Element", "")
+		create_al_link(model, "param_dict_link", params, param, string_get(arg_names_decl, counter))
+		dict_add_fast(variable_map, list_pop_final(list), model["model"][param])
 		// Output each parameter in turn
 		counter = counter + 1
 
 	// Now add the body
-	dict_add_fast(func, "body", construct_unknown(model, list))
+	create_al_link(model, "funcdef_body", func, construct_unknown(model, list), "body")
 
 	Element result
 	result = dict_create()
@@ -226,63 +233,64 @@ Element function construct_unknown(model : Element, list : Element):
 		output("ERROR: compiled code not understood: " + cast_value(elem))
 		return read_root()!
 
-Action function construct_if(model : Element, list : Element):
-	Action this_element
-	this_element = create_value(!if)
-	dict_add_fast(this_element, "cond", construct_unknown(model, list))
-	dict_add_fast(this_element, "then", construct_unknown(model, list))
+String function construct_if(model : Element, list : Element):
+	String this_element
+	this_element = instantiate_value(model, "if", "", create_value(!if))
+	create_al_link(model, "if_cond", this_element, construct_unknown(model, list), "cond")
+	create_al_link(model, "if_then", this_element, construct_unknown(model, list), "then")
 	if (list_pop_final(list)):
-		dict_add_fast(this_element, "else", construct_unknown(model, list))
+		create_al_link(model, "if_else", this_element, construct_unknown(model, list), "else")
 	if (list_pop_final(list)):
-		dict_add_fast(this_element, "next", construct_unknown(model, list))
+		create_al_link(model, "Statement_next", this_element, construct_unknown(model, list), "next")
 	return this_element!
 
-Action function construct_while(model : Element, list : Element):
-	Action this_element
-	this_element = create_value(!while)
-	dict_add_fast(this_element, "cond", construct_unknown(model, list))
+String function construct_while(model : Element, list : Element):
+	String this_element
+	this_element = instantiate_value(model, "while", "", create_value(!while))
+	create_al_link(model, "while_cond", this_element, construct_unknown(model, list), "cond")
 
 	list_append(while_stack, this_element)
-	dict_add_fast(this_element, "body", construct_unknown(model, list))
+	create_al_link(model, "while_body", this_element, construct_unknown(model, list), "body")
 	list_delete(while_stack, list_len(while_stack) - 1)
 
 	if (list_pop_final(list)):
-		dict_add_fast(this_element, "next", construct_unknown(model, list))
+		create_al_link(model, "Statement_next", this_element, construct_unknown(model, list), "next")
 	return this_element!
 
-Action function construct_access(model : Element, list : Element):
-	Action this_element
-	this_element = create_value(!access)
-	dict_add_fast(this_element, "var", construct_unknown(model, list))
+String function construct_access(model : Element, list : Element):
+	String this_element
+	this_element = instantiate_value(model, "access", "", create_value(!access))
+	create_al_link(model, "access_var", this_element, construct_unknown(model, list), "var")
 	return this_element!
 
-Action function construct_resolve(model : Element, list : Element):
-	Action this_element
+String function construct_resolve(model : Element, list : Element):
+	String this_element
 	Element linked_element
 	String name
 
-	this_element = create_value(!resolve)
+	this_element = instantiate_value(model, "resolve", "", create_value(!resolve))
 	name = list_pop_final(list)
+	// TODO might have to check if this is to be added
 	if dict_in(variable_map, name):
 		linked_element = variable_map[name]
 	else:
-		linked_element = name
-	dict_add_fast(this_element, "var", linked_element)
+		linked_element = instantiate_value(model, "String", "", name)
+	create_al_link(model, "resolve_var", this_element, linked_element, "var")
 	return this_element!
 
-Action function construct_assign(model : Element, list : Element):
-	Action this_element
-	this_element = create_value(!assign)
-	dict_add_fast(this_element, "var", construct_unknown(model, list))
-	dict_add_fast(this_element, "value", construct_unknown(model, list))
+String function construct_assign(model : Element, list : Element):
+	String this_element
+	this_element = instantiate_value(model, "assign", "", create_value(!assign))
+	create_al_link(model, "assign_var", this_element, construct_unknown(model, list), "var")
+	create_al_link(model, "assign_value", this_element, construct_unknown(model, list), "value")
 	if (list_pop_final(list)):
-		dict_add_fast(this_element, "next", construct_unknown(model, list))
+		create_al_link(model, "Statement_next", this_element, construct_unknown(model, list), "next")
 	return this_element!
 
-Action function construct_call(model : Element, list : Element):
-	Action this_element
-	this_element = create_value(!call)
-	dict_add_fast(this_element, "func", construct_unknown(model, list))
+String function construct_call(model : Element, list : Element):
+	String this_element
+	this_element = instantiate_value(model, "call", "", create_value(!call))
+	create_al_link(model, "call_func", this_element, construct_unknown(model, list), "func")
 
 	Integer nrParams
 	nrParams = list_pop_final(list)
@@ -295,49 +303,49 @@ Action function construct_call(model : Element, list : Element):
 	arg_names_call = "abcdefghijklmnopqrstuvwxyz"
 
 	while (counter < nrParams):
-		param = create_node()
+		param = instantiate_node(model, "param", "")
 
-		dict_add_fast(param, "name", string_get(arg_names_call, counter))
-		dict_add_fast(param, "value", construct_unknown(model, list))
+		create_al_link(model, "param_name", param, instantiate_value(model, "String", "", string_get(arg_names_call, counter)), "name")
+		create_al_link(model, "param_value", param, construct_unknown(model, list), "value")
 
 		if (counter == 0):
-			dict_add_fast(this_element, "params", param)
+			create_al_link(model, "call_params", this_element, param, "params")
 		else:
-			dict_add_fast(prev_param, "next_param", param)
+			create_al_link(model, "param_next_param", prev_param, param, "next_param")
 		prev_param = param
 
 		counter = counter + 1
 
 	if (nrParams > 0):
-		dict_add_fast(this_element, "last_param", prev_param)
+		create_al_link(model, "call_last_param", this_element, prev_param, "last_param")
 
 	if (list_pop_final(list)):
-		dict_add_fast(this_element, "next", construct_unknown(model, list))
+		create_al_link(model, "Statement_next", this_element, construct_unknown(model, list), "next")
 	return this_element!
 
-Action function construct_return(model : Element, list : Element):
+String function construct_return(model : Element, list : Element):
 	if (list_pop_final(list)):
-		Action this_element
-		this_element = create_value(!return)
-		dict_add_fast(this_element, "value", construct_unknown(model, list))
+		String this_element
+		this_element = instantiate_value(model, "return", "", create_value(!return))
+		create_al_link(model, "return_value", this_element, construct_unknown(model, list), "value")
 		return this_element!
 	else:
-		return create_value(!return)!
+		return instantiate_value(model, "return", "", create_value(!return))!
 
-Action function construct_const(model : Element, list : Element):
-	Action this_element
-	this_element = create_value(!constant)
-	dict_add_fast(this_element, "node", list_pop_final(list))
+String function construct_const(model : Element, list : Element):
+	String this_element
+	this_element = instantiate_value(model, "constant", "", create_value(!constant))
+	create_al_link(model, "constant_node", this_element, instantiate_value(model, "Element", "", list_pop_final(list)), "node")
 	return this_element!
 
-Action function construct_declare(model : Element, list : Element):
-	Action this_element
+String function construct_declare(model : Element, list : Element):
+	String this_element
 	Element declared_element
 	String name
 
-	this_element = create_value(!declare)
-	declared_element = create_node()
-	dict_add_fast(this_element, "var", declared_element)
+	this_element = instantiate_value(model, "declare", "", create_value(!declare))
+	declared_element = instantiate_node(model, "Element", "")
+	create_al_link(model, "declare_var", this_element, declared_element, "var")
 	name = list_pop_final(list)
 	dict_add_fast(variable_map, name, declared_element)
 
@@ -345,65 +353,65 @@ Action function construct_declare(model : Element, list : Element):
 	String op
 	op = list_pop_final(list)
 	if (op != "none"):
-		Action assign
-		Action resolve
-		Action value
-		assign = create_value(!assign)
-		dict_add_fast(this_element, "next", assign)
-		resolve = create_value(!resolve)
-		dict_add_fast(assign, "var", resolve)
-		dict_add_fast(resolve, "var", declared_element)
+		String assign
+		String resolve
+		String value
+		assign = instantiate_value(model, "assign", "", create_value(!assign))
+		create_al_link(model, "Statement_next", this_element, assign, "next")
+		resolve = instantiate_value(model, "resolve", "", create_value(!resolve))
+		create_al_link(model, "assign_var", assign, resolve, "var")
+		create_al_link(model, "resolve_var", resolve, declared_element, "var")
 		if (op == "deref"):
-			value = create_value(!constant)
-			dict_add_fast(value, "node", import_node(list_pop_final(list)))
+			value = instantiate_value(model, "constant", "", create_value(!constant))
+			create_al_link(model, "constant_node", value, reuse_element(model, "Element", "", import_node(list_pop_final(list))), "node")
 		elif (op == "empty"):
-			value = create_value(!call)
+			value = instantiate_value(model, "call", "", create_value(!call))
 			Element res
 			Element acc
-			res = create_value(!resolve)
-			acc = create_value(!access)
-			dict_add_fast(value, "func", acc)
-			dict_add_fast(acc, "var", res)
+			res = instantiate_value(model, "resolve", "", create_value(!resolve))
+			acc = instantiate_value(model, "access", "", create_value(!access))
+			create_al_link(model, "call_func", value, acc, "func")
+			create_al_link(model, "access_var", acc, res, "var")
 			dict_add_fast(res, "var", "create_node")
+			create_al_link(model, "resolve_var", res, instantiate_value(model, "String", "", "create_node"), "var")
 		elif (op == "const"):
-			value = create_value(!constant)
-			dict_add_fast(value, "node", list_pop_final(list))
-		dict_add_fast(assign, "value", value)
+			value = instantiate_value(model, "constant", "", create_value(!constant))
+			create_al_link(model, "constant_node", value, instantiate_value(model, "Element", "", list_pop_final(list)), "node")
+		create_al_link(model, "assign_value", assign, value, "value")
 
 		if (list_pop_final(list)):
-			dict_add_fast(assign, "next", construct_unknown(model, list))
+			create_al_link(model, "Statement_next", assign, construct_unknown(model, list), "next")
 	else:
 		if (list_pop_final(list)):
-			dict_add_fast(this_element, "next", construct_unknown(model, list))
+			create_al_link(model, "Statement_next", this_element, construct_unknown(model, list), "next")
 	return this_element!
 
-Action function construct_input(model : Element, list : Element):
-	Action this_element
-	this_element = create_value(!input)
-	return this_element!
+String function construct_input(model : Element, list : Element):
+	return instantiate_value(model, "input", "", create_value(!input))!
+
+String function construct_output(model : Element, list : Element):
+	String this_element
+	this_element = instantiate_value(model, "output", "", create_value(!output))
+	create_al_link(model, "output_value", this_element, construct_unknown(model, list), "value")
 
-Action function construct_output(model : Element, list : Element):
-	Action this_element
-	this_element = create_value(!output)
-	dict_add_fast(this_element, "value", construct_unknown(model, list))
 	if (list_pop_final(list)):
-		dict_add_fast(this_element, "next", construct_unknown(model, list))
+		create_al_link(model, "Statement_next", this_element, construct_unknown(model, list), "next")
 	return this_element!
 
-Action function construct_deref(model : Element, list : Element):
-	Action this_element
-	this_element = create_value(!constant)
-	dict_add_fast(this_element, "node", import_node(list_pop_final(list)))
+String function construct_deref(model : Element, list : Element):
+	String this_element
+	this_element = instantiate_value(model, "constant", "", create_value(!constant))
+	create_al_link(model, "constant_node", this_element, reuse_element(model, "Element", "", import_node(list_pop_final(list))), "node")
 	return this_element!
 
-Action function construct_break(model : Element, list : Element):
-	Action this_element
-	this_element = create_value(!break)
-	dict_add_fast(this_element, "while", while_stack[list_len(while_stack) - 1])
+String function construct_break(model : Element, list : Element):
+	String this_element
+	this_element = instantiate_value(model, "break", "", create_value(!break))
+	create_al_link(model, "break_while", this_element, while_stack[list_len(while_stack) - 1], "while")
 	return this_element!
 
-Action function construct_continue(model : Element, list : Element):
-	Action this_element
-	this_element = create_value(!continue)
-	dict_add_fast(this_element, "while", while_stack[list_len(while_stack) - 1])
+String function construct_continue(model : Element, list : Element):
+	String this_element
+	this_element = instantiate_value(model, "continue", "", create_value(!continue))
+	create_al_link(model, "continue_while", this_element, while_stack[list_len(while_stack) - 1], "while")
 	return this_element!

bootstrap/metamodels.alt

@@ -246,6 +246,7 @@ Void function initialize_AL(scd_location : String, export_location : String):
 	instantiate_link(model, "Association", "param_next_param", "param", "param")
 	instantiate_link(model, "Association", "funcdef_body", "funcdef", "Statement")
 	instantiate_link(model, "Association", "funcdef_params", "funcdef", "param_dict")
+	instantiate_link(model, "Association", "funcdef_mutable", "funcdef", "Element")
 	instantiate_link(model, "Association", "call_func", "call", "Expression")
 	instantiate_link(model, "Association", "call_params", "call", "param")
 	instantiate_link(model, "Association", "call_last_param", "call", "param")
@@ -271,6 +272,8 @@ Void function initialize_AL(scd_location : String, export_location : String):
 	instantiate_link(model, "Inheritance", "", "param_value", "dict_link")
 	instantiate_link(model, "Inheritance", "", "param_next_param", "dict_link")
 	instantiate_link(model, "Inheritance", "", "funcdef_body", "dict_link")
+	instantiate_link(model, "Inheritance", "", "funcdef_params", "dict_link")
+	instantiate_link(model, "Inheritance", "", "funcdef_mutable", "dict_link")
 	instantiate_link(model, "Inheritance", "", "call_func", "dict_link")
 	instantiate_link(model, "Inheritance", "", "call_params", "dict_link")
 	instantiate_link(model, "Inheritance", "", "call_last_param", "dict_link")
@@ -292,6 +295,7 @@ Void function initialize_AL(scd_location : String, export_location : String):
 	instantiate_attribute(model, "param_name", "target_lower_cardinality", 1)
 	instantiate_attribute(model, "param_value", "target_lower_cardinality", 1)
 	instantiate_attribute(model, "funcdef_body", "target_lower_cardinality", 1)
+	instantiate_attribute(model, "funcdef_params", "target_lower_cardinality", 1)
 	instantiate_attribute(model, "call_func", "target_lower_cardinality", 1)
 
 	instantiate_attribute(model, "Statement_next", "target_upper_cardinality", 1)
@@ -315,6 +319,8 @@ Void function initialize_AL(scd_location : String, export_location : String):
 	instantiate_attribute(model, "param_value", "target_upper_cardinality", 1)
 	instantiate_attribute(model, "param_next_param", "target_upper_cardinality", 1)
 	instantiate_attribute(model, "funcdef_body", "target_upper_cardinality", 1)
+	instantiate_attribute(model, "funcdef_params", "target_upper_cardinality", 1)
+	instantiate_attribute(model, "funcdef_mutable", "target_upper_cardinality", 1)
 	instantiate_attribute(model, "call_func", "target_upper_cardinality", 1)
 	instantiate_attribute(model, "call_params", "target_upper_cardinality", 1)
 	instantiate_attribute(model, "call_last_param", "target_upper_cardinality", 1)

bootstrap/modelling.alc

@@ -275,10 +275,8 @@ Void function instantiate_attribute_ref(model : Element, element : String, attri
 
 	return!
 
-Void function add_code_model(model : Element, export_name : String, code : Element):
+Void function add_code_model(model : Element, export_name : String, code_model : Element):
 	Element code_model
-	code_model = instantiate_model(model)
-	add_AL(code_model, code)
 	export_node(export_name, code_model)
 
 	return !
@@ -467,160 +465,6 @@ Void function unset_attribute(model : Element, element : String, attribute : Str
 
 	return!
 
-Void function add_AL_links(model : Element, list : Element, element : Element, type: String, linkname : String, expected_type : String):
-	if (bool_not(dict_in(element, linkname))):
-		return!
-
-	Element link
-	link = dict_read_edge(element, linkname)
-
-	// The link
-	if (linkname == "next"):
-		type = "Statement"
-	if (expected_type == "param_dict"):
-		// Add the link to param_dict
-		log("In param_dict adder")
-
-		reuse_element(model, "funcdef_params", "", link)
-		link = read_out(link, 0)
-		reuse_element(model, "dict_link_name", "", link)
-		link = read_edge_dst(link)
-		if (bool_not(dict_in(model["model"], "__" + cast_id(link)))):
-			reuse_element(model, "StringAttr", "__" + cast_id(link), link)
-
-		element = element[linkname]
-		reuse_element(model, "param_dict", "", element)
-
-		Element keys
-		String key
-		keys = dict_keys(element)
-		while (set_len(keys) > 0):
-			key = set_pop(keys)
-			log("Adding key " + cast_value(key))
-			link = dict_read_edge(element, key)
-
-			reuse_element(model, "param_dict_link", "", link)
-			reuse_element(model, "Element", "", read_edge_dst(link))
-			link = read_out(link, 0)
-			reuse_element(model, "dict_link_name", "", link)
-			link = read_edge_dst(link)
-			if (bool_not(dict_in(model["model"], "__" + cast_id(link)))):
-				reuse_element(model, "StringAttr", "__" + cast_id(link), link)
-
-		log("Done!")
-		return!
-	else:
-		reuse_element(model, (type + "_") + linkname, "", link)
-
-	// The name link
-	link = read_out(link, 0)
-	reuse_element(model, "dict_link_name", "", link)
-	
-	// The name node
-	String link_name
-	link = read_edge_dst(link)
-	link_name = "__" + cast_id(link)
-
-	if (bool_not(dict_in(model["model"], link_name))):
-		reuse_element(model, "StringAttr", link_name, link)
-
-	// Now add the destination to the worker list
-	set_add_node(list, create_tuple(element[linkname], expected_type))
-
-	return!
-
-String function add_AL(model : Element, element : Element):
-	Element todo
-	Element node
-	Element work_node
-	Element elem
-	String type
-	String elem_name
-
-	todo = set_create()
-	set_add_node(todo, create_tuple(element, "funcdef"))
-
-	while (0 < dict_len(todo)):
-		work_node = set_pop(todo)
-		elem = list_read(work_node, 0)
-		type = list_read(work_node, 1)
-
-		elem_name = "__" + cast_id(elem)
-		if (bool_not(set_in(model["model"], elem_name))):
-			// Determine the type if we don't know it
-			if (type == ""):
-				if (is_physical_action(elem)):
-					type = cast_value(elem)
-				else:
-					type = "Element"
-
-			// Add the node itself
-			reuse_element(model, type, elem_name, elem)
-
-			// Now add its edges
-			if (type == "if"):
-				add_AL_links(model, todo, elem, type, "cond", "")
-				add_AL_links(model, todo, elem, type, "then", "")
-				add_AL_links(model, todo, elem, type, "else", "")
-				add_AL_links(model, todo, elem, type, "next", "")
-			elif (type == "while"):
-				add_AL_links(model, todo, elem, type, "cond", "")
-				add_AL_links(model, todo, elem, type, "body", "")
-				add_AL_links(model, todo, elem, type, "next", "")
-			elif (type == "assign"):
-				add_AL_links(model, todo, elem, type, "var", "resolve")
-				add_AL_links(model, todo, elem, type, "value", "")
-				add_AL_links(model, todo, elem, type, "next", "")
-			elif (type == "break"):
-				add_AL_links(model, todo, elem, type, "while", "while")
-			elif (type == "continue"):
-				add_AL_links(model, todo, elem, type, "while", "while")
-			elif (type == "return"):
-				add_AL_links(model, todo, elem, type, "value", "")
-			elif (type == "resolve"):
-				add_AL_links(model, todo, elem, type, "var", "")
-			elif (type == "access"):
-				add_AL_links(model, todo, elem, type, "var", "resolve")
-			elif (type == "constant"):
-				add_AL_links(model, todo, elem, type, "node", "")
-			elif (type == "output"):
-				add_AL_links(model, todo, elem, type, "node", "")
-				add_AL_links(model, todo, elem, type, "next", "")
-			elif (type == "global"):
-				add_AL_links(model, todo, elem, type, "var", "String")
-				add_AL_links(model, todo, elem, type, "next", "")
-			elif (type == "param"):
-				add_AL_links(model, todo, elem, type, "name", "String")
-				add_AL_links(model, todo, elem, type, "value", "")
-				add_AL_links(model, todo, elem, type, "next_param", "param")
-			elif (type == "funcdef"):
-				log("Adding param_dict!")
-				add_AL_links(model, todo, elem, type, "body", "")
-				add_AL_links(model, todo, elem, type, "params", "param_dict")
-				add_AL_links(model, todo, elem, type, "next", "")
-			elif (type == "call"):
-				add_AL_links(model, todo, elem, type, "func", "")
-				add_AL_links(model, todo, elem, type, "params", "param")
-				add_AL_links(model, todo, elem, type, "last_param", "param")
-				add_AL_links(model, todo, elem, type, "next", "")
-			elif (type == "Element"):
-				log("Potential funcdef found!")
-				log("   keys: " + set_to_string(dict_keys(elem)))
-				if (dict_in(elem, "body")):
-					log("Potential next function found!")
-					add_AL_links(model, todo, elem, "funcdef", "body", "")
-					add_AL_links(model, todo, elem, "funcdef", "params", "param_dict")
-					add_AL_links(model, todo, elem, "funcdef", "next", "")
-
-			// TODO why isn't declare added here? --> this causes the JIT to crash with a "localXXXXX is undefined" error
-
-	// Mark the node as first
-	String initial
-	initial = instantiate_node(model, "Initial", "")
-	instantiate_link(model, "initial_funcdef", "", initial, reverseKeyLookup(model["model"], element))
-
-	return reverseKeyLookup(model["model"], element)!
-
 Element function get_func_AL_model(al_model : Element):
 	Element initial_function
 

wrappers/modelverse_SCCD.py

@@ -1,7 +1,7 @@
 """
 Generated by Statechart compiler by Glenn De Jonghe, Joeri Exelmans, Simon Van Mierlo, and Yentl Van Tendeloo (for the inspiration)
 
-Date:   Tue Apr  3 13:31:36 2018
+Date:   Tue Apr  3 16:07:17 2018
 
 Model author: Yentl Van Tendeloo
 Model name:   MvK Server