modelverse/bootstrap/modelling.alc

include "primitives.alh"
include "io.alh"
include "object_operations.alh"

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("ERROR: source of link unknown")
		return ""
	if (bool_not(dict_in(model["model"], destination))):
		log("ERROR: destination of link unknown")
		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_node(model["type_mapping"], model["model"][element])):
		dict_delete(model["type_mapping"], model["model"][element])
	dict_add(model["type_mapping"], model["model"][element], model["metamodel"]["model"][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

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

	return actual_name

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

	direct_type = reverseKeyLookup(model["metamodel"]["model"], dict_read_node(model["type_mapping"], model["model"][elem]))
	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:
		return reverseKeyLookup(model["metamodel"]["model"], dict_read_edge(model["metamodel"]["model"][mm_elem], name))

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

	elem = model["model"][name]

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

	// Read out all outgoing edges
	num_edges = read_nr_out(elem)
	while (i < num_edges):
		edge = read_out(elem, i)
		if (element_eq(dict_read_node(model["type_mapping"], edge), model["inheritance"])):
			create_edge(result, reverseKeyLookup(model["model"], read_edge_dst(edge)))
		i = i + 1

	return result

String function find_attribute_definer(model : Element, elem_name : String, name : String):
	if (dict_in(model["model"][elem_name], name)):
		// Try in the current class definition
		return elem_name
	else:
		// Not found, so go to all superclasses and try there
		Element superclasses
		Element current
		Element found

		superclasses = get_superclasses(model, elem_name)
		while (list_len(superclasses) > 0):
			current = set_pop(superclasses)
			found = find_attribute_definer(model, current, name)
			if (bool_not(value_eq(found, ""))):
				// Found something!
				return current

		// Error
		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

	attr_type = find_attribute_type(model, element, attribute_name)

	if (attr_type == ""):
		log("Could not find attribute!")
		return
		
	attr_name = model_add_value(model, "", 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

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

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

	return actual_name

Void function define_inheritance(model : Element, inheritance_name : String):
	// Set the inheritance link to the one defined in our own metamodel, given by the specified name
	dict_add(model, "inheritance", model["metamodel"]["model"][inheritance_name])

	return

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

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

	return

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

	elem = model["model"][element]
	count = read_nr_out(elem)

	i = 0
	while (i < count):
		edge = read_out(elem, i)
		if (dict_in_node(model["type_mapping"], edge)):
			edge_type = dict_read_node(model["type_mapping"], edge)
			if (element_eq(edge_type, dict_read_edge(read_edge_src(edge_type), attribute))):
				return read_edge_dst(edge)
		i = i + 1

	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)
		model_delete_element(model, attr_link)

	return

Void function recursive_add_AL(model : Element, element : Element):
	// TODO
	String name

	name = "__" + cast_id2s(element)
	if (dict_in(model["model"], name)):
		return
	else:
		// Add this element and call it for all its outgoing links
		dict_add(model["model"], name, element)
		if (is_physical_action(element)):
			dict_add(model["type_mapping"], element, model["metamodel"][cast_a2s(element)])
		else:
			// Either dealing with a param, a funcdef, or just some other kind of node that we have no clue about
			// TODO add this code
			return

		// Add all its outgoing links
		Integer counter
		Integer i
		Element elem

		counter = read_nr_out(element)
		i = 0
		while (i < counter):
			elem = read_out(element, i)
			// TODO add the link and all its attributes

			recursive_add_AL(model, elem)
			i = i + 1

		return

String function type_action_code(model : Element, constraint : Action):
	recursive_add_AL(model, constraint)
	return reverseKeyLookup(model["model"], constraint)

Void function add_constraint(model : Element, element : String):
	// Add local constraints to an element
	Action constraint
	Element attr_type
	String link_name
	String constraint_name

	constraint = construct_function()
	attr_type = find_attribute_type(model, element, "constraint")
	constraint_name = type_action_code(model, constraint)
	link_name = instantiate_link(model, attr_type, "", model["model"][element], constraint_name)

	return

Void function construct_model():
	String command
	while (True):
		command = input()
		if (command == "instantiate_bottom"):
			output(instantiate_bottom())
		elif (command == "add_node"):
			model_add_node(input(), input())
		elif (command == "add_value"):
			model_add_value(input(), input(), input())
		elif (command == "add_edge"):
			model_add_edge(input(), input(), input(), input())
		elif (command == "exit"):
			return
		elif (command == "retype_model"):
			retype_model(input(), input())
		elif (command == "retype"):
			retype(input(), input(), input())
		elif (command == "instantiate_model"):
			output(instantiate_model(input()))
		elif (command == "instantiate_node"):
			instantiate_node(input(), input(), input())
		elif (command == "instantiate_attribute"):
			instantiate_attribute(input(), input(), input(), input())
		elif (command == "instantiate_link"):
			instantiate_link(input(), input(), input(), input(), input())
		elif (command == "define_inheritance"):
			define_inheritance(input(), input())
		elif (command == "add_constraint"):
			add_constraint(input(), input())
		else:
			log("Modelling error: did not understand command " + command)