modelverse/bootstrap/modelling.alc

include "primitives.alh"
include "io.alh"
include "object_operations.alh"
include "constructors.alh"
include "metamodels.alh"
include "library.alh"

Element global_models = ?

String function instantiated_name(element : Element, original : String):
	if (original == ""):
		return "__" + cast_id2s(element)!
	else:
		return original!

Element function instantiate_bottom():
	// Just create a new node that serves as the basis for everything
	// We don't know anything about the model yet, so just create an empty one
	Element new_model

	// The actual root node of the model
	new_model = create_node()

	// Add an empty model and empty type mapping
	dict_add(new_model, "model", create_node())
	dict_add(new_model, "type_mapping", create_node())

	// Return the created model
	return new_model!

String function model_add_node(model : Element, name : String):
	// Adds a new node to the specified model with the desired name
	// This is a bottom operation, as it doesn't take any type
	Element new_node
	String actual_name

	new_node = create_node()
	actual_name = instantiated_name(new_node, name)
	dict_add(model["model"], actual_name, new_node)

	return actual_name!

String function model_add_value(model : Element, name : String, value : Element):
	// Similar to model_add_node, but add a value as well
	String actual_name

	actual_name = instantiated_name(value, name)
	dict_add(model["model"], actual_name, value)

	return actual_name!

String function model_add_edge(model : Element, name : String, source : String, destination : String):
	// Add an edge between the source and destination nodes
	// Nodes are specified using their string representation previously defined
	Element new_edge
	String actual_name
	
	if (bool_not(dict_in(model["model"], source))):
		log("In link " + name)
		log("ERROR: source of link unknown: " + source)
		log("Destination: " + destination)
		return ""!
	if (bool_not(dict_in(model["model"], destination))):
		log("In link " + name)
		log("ERROR: destination of link unknown: " + destination)
		log("Source: " + source)
		return ""!

	new_edge = create_edge(model["model"][source], model["model"][destination])
	actual_name = instantiated_name(new_edge, name)
	dict_add(model["model"], actual_name, new_edge)

	return actual_name!

Void function retype_model(model : Element, metamodel : Element):
	// Remove the type mapping and add a new one for the specified metamodel
	dict_delete(model, "type_mapping")
	dict_add(model, "type_mapping", create_node())
	dict_add(model, "metamodel", metamodel)
	return!

Void function retype(model : Element, element : String, type : String):
	// Retype a model, deleting any previous type the element had
	// The type string is evaluated in the metamodel previously specified

	if (dict_in(model["type_mapping"], element)):
		dict_delete(model["type_mapping"], element)

	dict_add(model["type_mapping"], element, type)

	return!

Element function instantiate_model(metamodel : Element):
	// Instantiate a model
	// Basically create an untyped model and retype it
	Element model
	model = instantiate_bottom()
	retype_model(model, metamodel)
	return model!

String function instantiate_node(model : Element, type_name : String, instance_name : String):
	// Create a node typed by a node from the metamodel
	// Basically create a node and type it immediately
	String actual_name

	if (bool_not(dict_in(model["metamodel"]["model"], type_name))):
		log("ERROR: (instantiate_node) no such type in metamodel: " + type_name)
		log("    for " + instance_name)
		return ""!

	if (dict_in(model["model"], instance_name)):
		return ""!

	actual_name = model_add_node(model, instance_name)
	retype(model, actual_name, type_name)

	return actual_name!

String function instantiate_value(model : Element, type_name : String, instance_name : String, value : Element):
	// Create a node typed by a node from the metamodel
	// Basically create a node and type it immediately
	String actual_name

	if (bool_not(dict_in(model["metamodel"]["model"], type_name))):
		log("ERROR: (instantiate_value) no such type in metamodel: " + type_name)
		log("     for " + instance_name)
		return ""!

	if (dict_in(model["model"], instance_name)):
		return ""!

	actual_name = model_add_value(model, instance_name, value)
	retype(model, actual_name, type_name)

	return actual_name!

String function find_attribute_type(model : Element, elem : String, name : String):
	String mm_elem
	String direct_type
	String result

	direct_type = read_type(model, elem)

	if (direct_type == ""):
		return ""!
	
	mm_elem = find_attribute_definer(model["metamodel"], direct_type, name)

	if (value_eq(mm_elem, "")):
		// Couldn't find element, so is not allowed!
		return ""!
	else:
		result = reverseKeyLookup(model["metamodel"]["model"], dict_read_edge(model["metamodel"]["model"][mm_elem], name))
		return result!

Element function get_superclasses(model : Element, name : String):
	Element result
	Integer i
	Integer j
	Integer num_edges
	Element edge
	String elem
	Element nodes
	Element inheritance

	nodes = create_node()
	set_add(nodes, name)
	inheritance = "Inheritance"

	// Initialize empty set
	result = create_node()
	i = 0

	while (list_len(nodes) > 0):
		elem = set_pop(nodes)
		if (bool_not(set_in(result, elem))):
			create_edge(result, elem)
			// Read out all outgoing edges
			num_edges = read_nr_out(model["model"][elem])
			j = 0
			while (j < num_edges):
				edge = read_out(model["model"][elem], j)
				if (value_eq(model["type_mapping"][reverseKeyLookup(model["model"], edge)], inheritance)):
					set_add(nodes, reverseKeyLookup(model["model"], read_edge_dst(edge)))
				j = j + 1

	return result!

String function find_attribute_definer(model : Element, elem_name : String, name : String):
	Element superclasses
	String current
	Integer nr_out
	Element out
	String name_attr

	superclasses = get_superclasses(model, elem_name)
	while (list_len(superclasses) > 0):
		current = set_pop(superclasses)
		
		nr_out = read_nr_out(model["model"][current])
		while (nr_out > 0):
			nr_out = nr_out - 1
			out = read_out(model["model"][current], nr_out)
			name_attr = read_attribute(model, reverseKeyLookup(model["model"], out), "name")
			if (name_attr == name):
				return current!

	return ""!

Void function instantiate_attribute(model : Element, element : String, attribute_name : String, value : Element):
	// Instantiate an attribute of something that needs to be instantiated
	// Actually a bit more difficult than all the rest, as we need to find the attribute to instantiate
	String attr_type
	String attr_name

	if (element_neq(read_attribute(model, element, attribute_name), read_root())):
		unset_attribute(model, element, attribute_name)

	attr_type = find_attribute_type(model, element, attribute_name)

	if (attr_type == ""):
		log("Could not find attribute " + cast_v2s(attribute_name))
		log("For element " + element)
		log("Type: " + read_type(model, element))
		return!

	if (has_value(value)):
		value = create_value(value)
		
	attr_name = model_add_value(model, (element + ".") + attribute_name, value)
	retype(model, attr_name, reverseKeyLookup(model["metamodel"]["model"], read_edge_dst(model["metamodel"]["model"][attr_type])))
	instantiate_link(model, attr_type, "", element, attr_name)

	return!

Void function instantiate_attribute_ref(model : Element, element : String, attribute_name : String, ref : String):
	// Instantiate an attribute of something that needs to be instantiated
	// Actually a bit more difficult than all the rest, as we need to find the attribute to instantiate
	String attr_type
	String attr_name

	attr_type = find_attribute_type(model, element, attribute_name)

	if (attr_type == ""):
		log("Could not find attribute " + cast_v2s(attribute_name))
		return!
		
	instantiate_link(model, attr_type, "", element, ref)

	return!

Void function add_code_model(model : Element, export_name : String, code : Element):
	Element code_model
	code_model = instantiate_model(model)
	add_AL(code_model, code)
	export_node(export_name, code_model)

	return !

Void function instantiate_attribute_code(model : Element, element : String, attribute_name : String, code : Element):
	// First create a new model for the AL part
	String location
	location = "code/" + cast_id2s(code)

	add_code_model(import_node("models/ActionLanguage"), location, code)

	// Now link it with a complex attribute
	instantiate_attribute(model, element, attribute_name, location)

	return!

Void function instantiate_existing_attribute(model : Element, element : String, attribute_name : String, attr_ref : String):
	// Instantiate an attribute of something that needs to be instantiated
	// Actually a bit more difficult than all the rest, as we need to find the attribute to instantiate
	String attr_type
	String attr_name

	attr_type = find_attribute_type(model, element, attribute_name)

	if (attr_type == ""):
		log("Could not find attribute " + cast_v2s(attribute_name))
		return!
		
	// Make a copy of the value, as it is likely that this value is reused later on
	retype(model, attr_ref, reverseKeyLookup(model["metamodel"]["model"], read_edge_dst(model["metamodel"]["model"][attr_type])))
	instantiate_link(model, attr_type, "", element, attr_ref)

	return!

String function instantiate_link(model : Element, type : String, name : String, source : String, destination : String):
	// Create a typed link between two nodes
	String actual_name

	if (dict_in(model["model"], name)):
		return ""!

	if (type == ""):
		// Have to find the type ourselves, as it isn't defined
		Element out
		Element in
		Element options

		options = allowedAssociationsBetween(model, source, destination)

		if (read_nr_out(options) == 1):
			type = set_pop(options)
		elif (read_nr_out(options) == 0):
			log("ERROR: cannot find possible link between entries")
			return ""!
		else:
			log("ERROR: too many possible links between entries")
			return ""!

	if (bool_not(dict_in(model["metamodel"]["model"], type))):
		log("ERROR: (instantiate_link) no such type in metamodel: " + type)
		log("    for " + name)
		return ""!

	actual_name = model_add_edge(model, name, source, destination)
	
	retype(model, actual_name, type)
	return actual_name!

Void function model_delete_element(model : Element, name : String):
	// Remove the link
	// 1) from the type mapping
	dict_delete(model["type_mapping"], name)

	// 2) from the model
	delete_element(model["model"][name])

	return!

String function model_define_attribute(model : Element, elem : String, name : String, optional : Boolean, type : String):
	// Create the necessary links to make it an attribute
	String edge_name

	edge_name = (elem + "_") + name
	while (dict_in(model["model"], edge_name)):
		// Already exists, so make random name
		edge_name = edge_name + cast_id2s(model["model"][elem])
		log("Name clash detected for attribute: try new name: " + edge_name)

	edge_name = instantiate_link(model, "AttributeLink", edge_name, elem, type)
	instantiate_attribute(model, edge_name, "name", name)
	instantiate_attribute(model, edge_name, "optional", optional)

	return edge_name!

Element function read_attribute(model : Element, element : String, attribute : String):
	Integer i
	Integer count
	Element edge
	String edge_type_name
	Element elem
	Element typing
	Element name

	if (dict_in(model["model"], element)):
		elem = model["model"][element]
		typing = model["type_mapping"]
		count = read_nr_out(elem)

		i = 0
		while (i < count):
			edge = read_out(elem, i)
			name = reverseKeyLookup(model["model"], edge)
			if (dict_in(typing, name)):
				edge_type_name = typing[name]
				if (edge_type_name == reverseKeyLookup(model["metamodel"]["model"], dict_read_edge(read_edge_src(model["metamodel"]["model"][edge_type_name]), attribute))):
					return read_edge_dst(edge)!
			i = i + 1

	else:
		log("Element does not exist: " + element)

	// Not found: either element doesn't exist, or we couldn't find it
	return read_root()!

Void function unset_attribute(model : Element, element : String, attribute : String):
	// Removes an attribute if it exists
	String attr_type
	Element attr_links
	String attr_link
	
	attr_type = find_attribute_type(model, element, attribute)
	attr_links = allOutgoingAssociationInstances(model, element, attr_type)

	while (list_len(attr_links) > 0):
		attr_link = set_pop(attr_links)
		dict_delete(model["type_mapping"], reverseKeyLookup(model["model"], read_edge_dst(model["model"][attr_link])))
		dict_delete(model["type_mapping"], attr_link)
		dict_delete_node(model["model"], reverseKeyLookup(model["model"], read_edge_dst(model["model"][attr_link])))
		delete_element(model["model"][attr_link])

	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
	String link_name

	link = dict_read_edge(element, linkname)
	link_name = "__" + cast_id2s(link)

	// The link
	dict_add(model["model"], link_name, link)
	dict_add(model["type_mapping"], link_name, (type + "_") + linkname)

	// The name link
	link = read_out(link, 0)
	link_name = "__" + cast_id2s(link)

	dict_add(model["model"], link_name, link)
	dict_add(model["type_mapping"], link_name, "dict_link_name")
	
	// The name node
	link = read_edge_dst(link)
	link_name = "__" + cast_id2s(link)

	if (bool_not(set_in_node(model["model"], link))):
		dict_add(model["model"], link_name, link)
		dict_add(model["type_mapping"], link_name, "StringAttr")

	// Now add the destination to the worker list
	set_add(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 = create_node()
	node = create_node()
	list_append(node, element)
	list_append(node, "funcdef")
	set_add(todo, node)

	while (0 < dict_len(todo)):
		work_node = set_pop(todo)
		elem = list_read(work_node, 0)
		type = list_read(work_node, 1)

		if (bool_not(set_in_node(model["model"], elem))):
			// Determine the type if we don't know it
			if (type == ""):
				if (is_physical_action(elem)):
					type = cast_a2s(elem)
				else:
					type = "Element"

			// Add the node itself
			elem_name = "__" + cast_id2s(elem)
			dict_add(model["model"], elem_name, elem)
			dict_add(model["type_mapping"], elem_name, type)

			// 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"):
				add_AL_links(model, todo, elem, type, "body", "")
				// TODO this should be added, but is not the same as "param"
				//add_AL_links(model, todo, elem, type, "params", "")
				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", "")

	// 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)!

Void function construct_model():
	String command

	initialize_SCD("models/SimpleClassDiagrams")

	while (True):
		command = input()
		if (command == "instantiate_bottom"):
			Element m
			m = instantiate_bottom()
			dict_add(global_models, input(), m)
		elif (command == "add_node"):
			model_add_node(global_models[input()], input())
		elif (command == "add_value"):
			model_add_value(global_models[input()], input(), input())
		elif (command == "add_edge"):
			model_add_edge(global_models[input()], input(), input(), input())
		elif (command == "exit"):
			return!
		elif (command == "retype_model"):
			retype_model(global_models[input()], global_models[input()])
		elif (command == "retype"):
			retype(global_models[input()], input(), input())
		elif (command == "instantiate_model"):
			Element m
			m = instantiate_model(global_models[input()])
			dict_add(global_models, input(), m)
		elif (command == "instantiate_node"):
			instantiate_node(global_models[input()], input(), input())
		elif (command == "instantiate_attribute"):
			instantiate_attribute(global_models[input()], input(), input(), input())
		elif (command == "instantiate_attribute_ref"):
			instantiate_attribute_ref(global_models[input()], input(), input(), input())
		elif (command == "instantiate_attribute_code"):
			instantiate_attribute_code(global_models[input()], input(), input(), construct_function())
		elif (command == "instantiate_link"):
			instantiate_link(global_models[input()], input(), input(), input(), input())
		elif (command == "model_define_attribute"):
			model_define_attribute(global_models[input()], input(), input(), input(), input())
		elif (command == "initialize_SCD"):
			initialize_SCD(input())
		elif (command == "initialize_bottom"):
			initialize_bottom(input())
		elif (command == "export_node"):
			String local_name
			String location
			local_name = input()
			location = input()
			export_node(location, global_models[local_name])
		elif (command == "import_node"):
			Element m
			command = input()
			m = import_node(command)
			if (element_eq(m, read_root())):
				log("Error: import not found for " + command)
			else:
				dict_add(global_models, input(), m)
		elif (command == "add_code_model"):
			add_code_model(global_models[input()], input(), construct_function())
		else:
			log("Modelling error: did not understand command " + command)

Element function construct_model_raw(metamodel : Element):
	String command
	Element model

	model = instantiate_model(metamodel)

	while (True):
		command = input()
		if (command == "add_node"):
			input()
			model_add_node(model, input())
		elif (command == "add_value"):
			input()
			model_add_value(model, input(), input())
		elif (command == "add_edge"):
			input()
			model_add_edge(model, input(), input(), input())
		elif (command == "exit"):
			return model!
		elif (command == "instantiate_node"):
			input()
			instantiate_node(model, input(), input())
		elif (command == "model_define_attribute"):
			input()
			model_define_attribute(model, input(), input(), input(), input())
		elif (command == "instantiate_attribute"):
			input()
			instantiate_attribute(model, input(), input(), input())
		elif (command == "instantiate_attribute_ref"):
			input()
			instantiate_attribute_ref(model, input(), input(), input())
		elif (command == "instantiate_attribute_code"):
			input()
			instantiate_attribute_code(model, input(), input(), construct_function())
		elif (command == "instantiate_link"):
			input()
			instantiate_link(model, input(), input(), input(), input())
		elif (command == "import_node"):
			input()
			input()
		elif (command == "export_node"):
			input()
			input()
		elif (command == "instantiate_model"):
			input()
			input()
		elif (command == "add_code_model"):
			input()
			add_code_model(model, input(), construct_function())
		else:
			log("Modelling error: did not understand command " + command)

Element function get_func_AL_model(al_model : Element):
	Element result
	Element initial_function

	// Fetch the model to execute
	log("Imported model: " + cast_e2s(al_model))
	log("Outgoing: " + set_to_string(dict_keys(al_model)))

	// Find the initial function
	initial_function = allInstances(al_model, "Initial")
	log("Initial functions: " + set_to_string(initial_function))

	if (read_nr_out(initial_function) == 0):
		log("Could not find function to execute in this model!")
		return create_node()!
	elif (read_nr_out(initial_function) > 1):
		log("Too many functions to execute in this model!")
		return create_node()!
	else:
		log("Retrieving")
		initial_function = al_model["model"][set_pop(allAssociationDestinations(al_model, set_pop(initial_function), "initial_funcdef"))]
		log("Found initial_function: " + cast_e2s(initial_function))

	return initial_function!