modelling.alc 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531
  1. include "primitives.alh"
  2. include "io.alh"
  3. include "object_operations.alh"
  4. include "constructors.alh"
  5. include "metamodels.alh"
  6. include "library.alh"
  7. Element global_models = ?
  8. String function instantiated_name(element : Element, original : String):
  9. if (original == ""):
  10. return "__" + cast_id2s(element)!
  11. else:
  12. return original!
  13. Element function instantiate_bottom():
  14. // Just create a new node that serves as the basis for everything
  15. // We don't know anything about the model yet, so just create an empty one
  16. Element new_model
  17. // The actual root node of the model
  18. new_model = create_node()
  19. // Add an empty model and empty type mapping
  20. dict_add(new_model, "model", create_node())
  21. dict_add(new_model, "type_mapping", create_node())
  22. // Return the created model
  23. return new_model!
  24. String function model_add_node(model : Element, name : String):
  25. // Adds a new node to the specified model with the desired name
  26. // This is a bottom operation, as it doesn't take any type
  27. Element new_node
  28. String actual_name
  29. new_node = create_node()
  30. actual_name = instantiated_name(new_node, name)
  31. dict_add(model["model"], actual_name, new_node)
  32. return actual_name!
  33. String function model_add_value(model : Element, name : String, value : Element):
  34. // Similar to model_add_node, but add a value as well
  35. String actual_name
  36. actual_name = instantiated_name(value, name)
  37. dict_add(model["model"], actual_name, value)
  38. return actual_name!
  39. String function model_add_edge(model : Element, name : String, source : String, destination : String):
  40. // Add an edge between the source and destination nodes
  41. // Nodes are specified using their string representation previously defined
  42. Element new_edge
  43. String actual_name
  44. if (bool_not(dict_in(model["model"], source))):
  45. log("In link " + name)
  46. log("ERROR: source of link unknown: " + source)
  47. log("Destination: " + destination)
  48. return ""!
  49. if (bool_not(dict_in(model["model"], destination))):
  50. log("In link " + name)
  51. log("ERROR: destination of link unknown: " + destination)
  52. log("Source: " + source)
  53. return ""!
  54. new_edge = create_edge(model["model"][source], model["model"][destination])
  55. actual_name = instantiated_name(new_edge, name)
  56. dict_add(model["model"], actual_name, new_edge)
  57. return actual_name!
  58. Void function retype_model(model : Element, metamodel : Element):
  59. // Remove the type mapping and add a new one for the specified metamodel
  60. dict_delete(model, "type_mapping")
  61. dict_add(model, "type_mapping", create_node())
  62. dict_add(model, "metamodel", metamodel)
  63. return!
  64. Void function retype(model : Element, element : String, type : String):
  65. // Retype a model, deleting any previous type the element had
  66. // The type string is evaluated in the metamodel previously specified
  67. if (dict_in_node(model["type_mapping"], model["model"][element])):
  68. dict_delete_node(model["type_mapping"], model["model"][element])
  69. dict_add(model["type_mapping"], model["model"][element], model["metamodel"]["model"][type])
  70. return!
  71. Element function instantiate_model(metamodel : Element):
  72. // Instantiate a model
  73. // Basically create an untyped model and retype it
  74. Element model
  75. model = instantiate_bottom()
  76. retype_model(model, metamodel)
  77. return model!
  78. String function instantiate_node(model : Element, type_name : String, instance_name : String):
  79. // Create a node typed by a node from the metamodel
  80. // Basically create a node and type it immediately
  81. String actual_name
  82. actual_name = model_add_node(model, instance_name)
  83. retype(model, actual_name, type_name)
  84. return actual_name!
  85. String function instantiate_value(model : Element, type_name : String, instance_name : String, value : Element):
  86. // Create a node typed by a node from the metamodel
  87. // Basically create a node and type it immediately
  88. String actual_name
  89. actual_name = model_add_value(model, instance_name, value)
  90. retype(model, actual_name, type_name)
  91. return actual_name!
  92. String function find_attribute_type(model : Element, elem : String, name : String):
  93. String mm_elem
  94. String direct_type
  95. direct_type = reverseKeyLookup(model["metamodel"]["model"], dict_read_node(model["type_mapping"], model["model"][elem]))
  96. mm_elem = find_attribute_definer(model["metamodel"], direct_type, name)
  97. if (value_eq(mm_elem, "")):
  98. // Couldn't find element, so is not allowed!
  99. return ""!
  100. else:
  101. return reverseKeyLookup(model["metamodel"]["model"], dict_read_edge(model["metamodel"]["model"][mm_elem], name))!
  102. Element function get_superclasses(model : Element, name : String):
  103. Element result
  104. Integer i
  105. Integer j
  106. Integer num_edges
  107. Element edge
  108. Element elem
  109. Element nodes
  110. nodes = create_node()
  111. set_add(nodes, model["model"][name])
  112. // Initialize empty set
  113. result = create_node()
  114. i = 0
  115. while (0 < list_len(nodes)):
  116. elem = set_pop(nodes)
  117. create_edge(result, reverseKeyLookup(model["model"], elem))
  118. // Read out all outgoing edges
  119. num_edges = read_nr_out(elem)
  120. j = 0
  121. while (j < num_edges):
  122. edge = read_out(elem, j)
  123. if (element_eq(dict_read_node(model["type_mapping"], edge), model["inheritance"])):
  124. set_add(nodes, read_edge_dst(edge))
  125. j = j + 1
  126. return result!
  127. String function find_attribute_definer(model : Element, elem_name : String, name : String):
  128. Element superclasses
  129. Element current
  130. superclasses = get_superclasses(model, elem_name)
  131. while (list_len(superclasses) > 0):
  132. current = set_pop(superclasses)
  133. if (dict_in(model["model"][current], name)):
  134. return current!
  135. return ""!
  136. Void function instantiate_attribute(model : Element, element : String, attribute_name : String, value : Element):
  137. // Instantiate an attribute of something that needs to be instantiated
  138. // Actually a bit more difficult than all the rest, as we need to find the attribute to instantiate
  139. String attr_type
  140. String attr_name
  141. attr_type = find_attribute_type(model, element, attribute_name)
  142. if (attr_type == ""):
  143. log("Could not find attribute " + cast_v2s(attribute_name))
  144. return!
  145. // Make a copy of the value, as it is likely that this value is reused later on
  146. value = create_value(value)
  147. attr_name = model_add_value(model, (element + ".") + attribute_name, value)
  148. retype(model, attr_name, reverseKeyLookup(model["metamodel"]["model"], read_edge_dst(model["metamodel"]["model"][attr_type])))
  149. instantiate_link(model, attr_type, "", element, attr_name)
  150. return!
  151. Void function instantiate_attribute_code(model : Element, element : String, attribute_name : String, code : Element):
  152. String ref
  153. ref = add_AL(model, code)
  154. instantiate_existing_attribute(model, element, attribute_name, ref)
  155. return!
  156. Void function instantiate_existing_attribute(model : Element, element : String, attribute_name : String, attr_ref : String):
  157. // Instantiate an attribute of something that needs to be instantiated
  158. // Actually a bit more difficult than all the rest, as we need to find the attribute to instantiate
  159. String attr_type
  160. String attr_name
  161. attr_type = find_attribute_type(model, element, attribute_name)
  162. if (attr_type == ""):
  163. log("Could not find attribute " + cast_v2s(attribute_name))
  164. return!
  165. // Make a copy of the value, as it is likely that this value is reused later on
  166. retype(model, attr_ref, reverseKeyLookup(model["metamodel"]["model"], read_edge_dst(model["metamodel"]["model"][attr_type])))
  167. instantiate_link(model, attr_type, "", element, attr_ref)
  168. return!
  169. String function instantiate_link(model : Element, type : String, name : String, source : String, destination : String):
  170. // Create a typed link between two nodes
  171. String actual_name
  172. actual_name = model_add_edge(model, name, source, destination)
  173. if (type == ""):
  174. // Have to find the type ourselves, as it isn't defined
  175. Element out
  176. Element in
  177. Element options
  178. out = selectPossibleOutgoing(model, source, create_node())
  179. in = selectPossibleIncoming(model, destination, create_node())
  180. options = set_overlap(out, in)
  181. if (read_nr_out(options) == 1):
  182. type = set_pop(options)
  183. elif (read_nr_out(options) == 0):
  184. log("ERROR: cannot find possible link between entries")
  185. return ""!
  186. else:
  187. log("ERROR: too many possible links between entries")
  188. return ""!
  189. retype(model, actual_name, type)
  190. return actual_name!
  191. Void function define_inheritance(model : Element, inheritance_name : String):
  192. // Set the inheritance link to the one defined in our own metamodel, given by the specified name
  193. dict_add(model, "inheritance", model["metamodel"]["model"][inheritance_name])
  194. return!
  195. Void function model_delete_element(model : Element, name : String):
  196. // Remove the link
  197. // 1) from the type mapping
  198. dict_delete_node(model["type_mapping"], model["model"][name])
  199. // 2) from the model
  200. delete_element(model["model"][name])
  201. return!
  202. String function model_define_attribute(model : Element, elem : String, name : String, type : String):
  203. // Create the necessary links to make it an attribute
  204. String edge_name
  205. edge_name = instantiate_link(model, "Association", "", elem, type)
  206. instantiate_attribute(model, edge_name, "name", name)
  207. return edge_name!
  208. Element function read_attribute(model : Element, element : String, attribute : String):
  209. Integer i
  210. Integer count
  211. Element edge
  212. Element edge_type
  213. Element elem
  214. Element typing
  215. elem = model["model"][element]
  216. typing = model["type_mapping"]
  217. count = read_nr_out(elem)
  218. i = 0
  219. while (i < count):
  220. edge = read_out(elem, i)
  221. if (dict_in_node(typing, edge)):
  222. edge_type = dict_read_node(typing, edge)
  223. if (element_eq(edge_type, dict_read_edge(read_edge_src(edge_type), attribute))):
  224. return read_edge_dst(edge)!
  225. i = i + 1
  226. return read_root()!
  227. Void function unset_attribute(model : Element, element : String, attribute : String):
  228. // Removes an attribute if it exists
  229. String attr_type
  230. Element attr_links
  231. String attr_link
  232. attr_type = find_attribute_type(model, element, attribute)
  233. attr_links = allOutgoingAssociationInstances(model, element, attr_type)
  234. while (list_len(attr_links) > 0):
  235. attr_link = set_pop(attr_links)
  236. dict_delete_node(model["type_mapping"], read_edge_dst(model["model"][attr_link]))
  237. dict_delete_node(model["type_mapping"], model["model"][attr_link])
  238. dict_delete_node(model["model"], reverseKeyLookup(model["model"], read_edge_dst(model["model"][attr_link])))
  239. delete_element(model["model"][attr_link])
  240. return!
  241. Void function add_AL_links(model : Element, list : Element, element : Element, type: String, linkname : String, expected_type : String):
  242. if (bool_not(dict_in(element, linkname))):
  243. return!
  244. Element link
  245. link = dict_read_edge(element, linkname)
  246. // The link
  247. dict_add(model["model"], "__" + cast_id2s(link), link)
  248. dict_add(model["type_mapping"], link, model["metamodel"]["model"][(type + "_") + linkname])
  249. // The name link
  250. link = read_out(link, 0)
  251. dict_add(model["model"], "__" + cast_id2s(link), link)
  252. dict_add(model["type_mapping"], link, model["metamodel"]["model"]["to_str"])
  253. // The name node
  254. link = read_edge_dst(link)
  255. if (bool_not(set_in_node(model["model"], link))):
  256. dict_add(model["model"], "__" + cast_id2s(link), link)
  257. dict_add(model["type_mapping"], link, model["metamodel"]["model"]["String"])
  258. // Now add the destination to the worker list
  259. Element node
  260. node = create_node()
  261. list_append(node, element[linkname])
  262. list_append(node, expected_type)
  263. set_add(list, node)
  264. return!
  265. String function add_AL(model : Element, element : Element):
  266. Element todo
  267. Element node
  268. Element work_node
  269. Element elem
  270. String type
  271. todo = create_node()
  272. node = create_node()
  273. list_append(node, element)
  274. list_append(node, "funcdef")
  275. set_add(todo, node)
  276. while (0 < dict_len(todo)):
  277. work_node = set_pop(todo)
  278. elem = list_read(work_node, 0)
  279. type = list_read(work_node, 1)
  280. if (bool_not(set_in_node(model["model"], elem))):
  281. // Determine the type if we don't know it
  282. if (type == ""):
  283. if (is_physical_action(elem)):
  284. type = cast_a2s(elem)
  285. else:
  286. type = "Any"
  287. // Add the node itself
  288. dict_add(model["model"], "__" + cast_id2s(elem), elem)
  289. dict_add(model["type_mapping"], elem, model["metamodel"]["model"][type])
  290. // Now add its edges
  291. if (type == "if"):
  292. add_AL_links(model, todo, elem, type, "cond", "")
  293. add_AL_links(model, todo, elem, type, "then", "")
  294. add_AL_links(model, todo, elem, type, "else", "")
  295. add_AL_links(model, todo, elem, type, "next", "")
  296. elif (type == "while"):
  297. add_AL_links(model, todo, elem, type, "cond", "")
  298. add_AL_links(model, todo, elem, type, "body", "")
  299. add_AL_links(model, todo, elem, type, "next", "")
  300. elif (type == "assign"):
  301. add_AL_links(model, todo, elem, type, "var", "")
  302. add_AL_links(model, todo, elem, type, "value", "")
  303. add_AL_links(model, todo, elem, type, "next", "")
  304. elif (type == "break"):
  305. add_AL_links(model, todo, elem, type, "while", "while")
  306. elif (type == "continue"):
  307. add_AL_links(model, todo, elem, type, "while", "while")
  308. elif (type == "return"):
  309. add_AL_links(model, todo, elem, type, "value", "")
  310. elif (type == "resolve"):
  311. add_AL_links(model, todo, elem, type, "var", "")
  312. elif (type == "access"):
  313. add_AL_links(model, todo, elem, type, "var", "")
  314. elif (type == "constant"):
  315. add_AL_links(model, todo, elem, type, "node", "")
  316. elif (type == "output"):
  317. add_AL_links(model, todo, elem, type, "node", "")
  318. add_AL_links(model, todo, elem, type, "next", "")
  319. elif (type == "global"):
  320. add_AL_links(model, todo, elem, type, "var", "String")
  321. add_AL_links(model, todo, elem, type, "next", "")
  322. elif (type == "param"):
  323. add_AL_links(model, todo, elem, type, "name", "String")
  324. add_AL_links(model, todo, elem, type, "value", "")
  325. add_AL_links(model, todo, elem, type, "next_param", "param")
  326. elif (type == "funcdef"):
  327. add_AL_links(model, todo, elem, type, "body", "")
  328. add_AL_links(model, todo, elem, type, "next", "")
  329. elif (type == "call"):
  330. add_AL_links(model, todo, elem, type, "func", "")
  331. add_AL_links(model, todo, elem, type, "params", "param")
  332. add_AL_links(model, todo, elem, type, "last_param", "param")
  333. add_AL_links(model, todo, elem, type, "next", "")
  334. return reverseKeyLookup(model["model"], element)!
  335. Void function add_constraint(model : Element, element : String, constraint : Action):
  336. // Add local constraints to an element
  337. Element attr_type
  338. String link_name
  339. String constraint_name
  340. constraint_name = add_AL(model, constraint)
  341. attr_type = find_attribute_type(model, element, "constraint")
  342. instantiate_link(model, attr_type, "", element, constraint_name)
  343. return!
  344. Void function construct_model():
  345. String command
  346. while (True):
  347. command = input()
  348. if (command == "instantiate_bottom"):
  349. Element m
  350. m = instantiate_bottom()
  351. dict_add(global_models, input(), m)
  352. elif (command == "add_node"):
  353. model_add_node(global_models[input()], input())
  354. elif (command == "add_value"):
  355. model_add_value(global_models[input()], input(), input())
  356. elif (command == "add_edge"):
  357. model_add_edge(global_models[input()], input(), input(), input())
  358. elif (command == "exit"):
  359. return!
  360. elif (command == "retype_model"):
  361. retype_model(global_models[input()], global_models[input()])
  362. elif (command == "retype"):
  363. retype(global_models[input()], input(), input())
  364. elif (command == "instantiate_model"):
  365. Element m
  366. m = instantiate_model(global_models[input()])
  367. dict_add(global_models, input(), m)
  368. elif (command == "instantiate_node"):
  369. instantiate_node(global_models[input()], input(), input())
  370. elif (command == "instantiate_attribute"):
  371. instantiate_attribute(global_models[input()], input(), input(), input())
  372. elif (command == "instantiate_link"):
  373. instantiate_link(global_models[input()], input(), input(), input(), input())
  374. elif (command == "define_inheritance"):
  375. define_inheritance(global_models[input()], input())
  376. elif (command == "add_constraint"):
  377. add_constraint(global_models[input()], input(), construct_function())
  378. elif (command == "initialize_SCD"):
  379. initialize_SCD(input())
  380. elif (command == "initialize_bottom"):
  381. initialize_bottom(input())
  382. elif (command == "export_node"):
  383. String local_name
  384. String location
  385. local_name = input()
  386. location = input()
  387. export_node(location, global_models[local_name])
  388. elif (command == "import_node"):
  389. Element m
  390. m = import_node(input())
  391. if (element_eq(m, read_root())):
  392. log("Error: import not found")
  393. else:
  394. dict_add(global_models, input(), m)
  395. else:
  396. log("Modelling error: did not understand command " + command)
  397. Element function model_fuse(models : Element):
  398. Element new_model
  399. Element tagged_model
  400. String model_name
  401. Element model
  402. Element keys
  403. String key
  404. Element selected_MM
  405. String type
  406. // Read out some data first
  407. tagged_model = set_pop(models)
  408. set_add(models, tagged_model)
  409. model = list_read(tagged_model, 1)
  410. selected_MM = model["metamodel"]
  411. new_model = instantiate_model(selected_MM)
  412. models = set_copy(models)
  413. while (read_nr_out(models)):
  414. tagged_model = set_pop(models)
  415. model_name = list_read(tagged_model, 0)
  416. model = list_read(tagged_model, 1)
  417. // Add all elements from 'model', but prepend it with the 'model_name'
  418. keys = set_to_list(dict_keys(model["model"]))
  419. while (read_nr_out(keys) > 0):
  420. key = list_pop(keys, 0)
  421. type = reverseKeyLookup(model["metamodel"]["model"], dict_read_node(model["type_mapping"], model["model"][key]))
  422. if (is_edge(model["model"][key])):
  423. String src
  424. String dst
  425. src = (model_name + "/") + reverseKeyLookup(model["model"], read_edge_src(model["model"][key]))
  426. dst = (model_name + "/") + reverseKeyLookup(model["model"], read_edge_dst(model["model"][key]))
  427. if (bool_and(dict_in(new_model["model"], src), dict_in(new_model["model"], dst))):
  428. instantiate_link(new_model, type, (model_name + "/") + key, (model_name + "/") + src, (model_name + "/") + dst)
  429. else:
  430. list_append(keys, key)
  431. elif (has_value(model["model"][key])):
  432. instantiate_value(new_model, type, (model_name + "/") + key, model["model"][key])
  433. else:
  434. instantiate_node(new_model, type, (model_name + "/") + key)
  435. return new_model!