constructors.alc 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416
  1. include "primitives.alh"
  2. include "conformance_scd.alh"
  3. include "library.alh"
  4. include "io.alh"
  5. Element while_stack = ?
  6. Action function construct_top():
  7. String command
  8. command = input()
  9. if (command == "global"):
  10. return construct_top_global()
  11. elif (command == "funcdef"):
  12. return construct_top_funcdef()
  13. else:
  14. log("ERROR: did not understand command " + cast_e2s(command))
  15. Action function construct_top_global():
  16. Action this_element
  17. String declared_element
  18. String op
  19. this_element = create_value(!global)
  20. declared_element = input()
  21. dict_add(this_element, "var", declared_element)
  22. // Defines
  23. Action assign
  24. Action resolve
  25. Action value
  26. assign = create_value(!assign)
  27. dict_add(this_element, "next", assign)
  28. resolve = create_value(!resolve)
  29. dict_add(assign, "var", resolve)
  30. dict_add(resolve, "var", declared_element)
  31. op = input()
  32. value = create_value(!constant)
  33. if (op == "deref"):
  34. dict_add(value, "node", import_node(input()))
  35. elif (op == "empty"):
  36. dict_add(value, "node", create_node())
  37. elif (op == "const"):
  38. dict_add(value, "node", input())
  39. dict_add(assign, "value", value)
  40. if (input()):
  41. dict_add(assign, "next", construct_top())
  42. return this_element
  43. Action function construct_top_funcdef():
  44. Action assign
  45. Action resolve
  46. Action constant
  47. Element formal
  48. Element func
  49. Element params
  50. Action global
  51. global = create_value(!global)
  52. assign = create_value(!assign)
  53. resolve = create_value(!resolve)
  54. constant = create_value(!constant)
  55. formal = input()
  56. func = create_node()
  57. params = create_node()
  58. dict_add(global, "var", formal)
  59. dict_add(global, "next", assign)
  60. dict_add(assign, "var", resolve)
  61. dict_add(assign, "value", constant)
  62. dict_add(resolve, "var", formal)
  63. dict_add(constant, "node", func)
  64. dict_add(func, "params", params)
  65. Integer nrParams
  66. nrParams = input()
  67. Integer counter
  68. counter = 0
  69. Element param
  70. String arg_names_decl
  71. arg_names_decl = "abcdefghijklmnopqrstuvwxyz"
  72. while (counter < nrParams):
  73. param = create_node()
  74. dict_add(params, string_get(arg_names_decl, counter), param)
  75. output(param)
  76. // Output each parameter in turn
  77. counter = counter + 1
  78. // Now add the body
  79. dict_add(func, "body", construct_unknown())
  80. if (input()):
  81. dict_add(assign, "next", construct_top())
  82. return global
  83. Action function construct_unknown():
  84. String elem
  85. Element new_model
  86. Element new_model_model
  87. elem = input()
  88. if (elem == "if"):
  89. return construct_if()
  90. elif (elem == "while"):
  91. return construct_while()
  92. elif (elem == "access"):
  93. return construct_access()
  94. elif (elem == "resolve"):
  95. return construct_resolve()
  96. elif (elem == "assign"):
  97. return construct_assign()
  98. elif (elem == "call"):
  99. return construct_call()
  100. elif (elem == "return"):
  101. return construct_return()
  102. elif (elem == "const"):
  103. return construct_const()
  104. elif (elem == "declare"):
  105. return construct_declare()
  106. elif (elem == "funcdef"):
  107. return construct_funcdef()
  108. elif (elem == "output"):
  109. return construct_output()
  110. elif (elem == "input"):
  111. return construct_input()
  112. elif (elem == "deref"):
  113. return construct_deref()
  114. elif (elem == "break"):
  115. return construct_break()
  116. elif (elem == "continue"):
  117. return construct_continue()
  118. elif (elem == "instantiate_bottom"):
  119. new_model = create_node()
  120. dict_add(new_model, "model", create_node())
  121. instantiate_bottom(new_model)
  122. output(new_model)
  123. return construct_unknown()
  124. elif (elem == "instantiate_model"):
  125. new_model = instantiate_new_model(input(), dict_read(dict_read(input(), "model"), input()))
  126. instantiate_model(new_model)
  127. output(new_model)
  128. return construct_unknown()
  129. elif (elem == "retype_model"):
  130. retype_model(input())
  131. return construct_unknown()
  132. else:
  133. log("ERROR: did not understand command " + cast_e2s(elem))
  134. Action function construct_if():
  135. Action this_element
  136. this_element = create_value(!if)
  137. dict_add(this_element, "cond", construct_unknown())
  138. dict_add(this_element, "then", construct_unknown())
  139. if (input()):
  140. dict_add(this_element, "else", construct_unknown())
  141. if (input()):
  142. dict_add(this_element, "next", construct_unknown())
  143. return this_element
  144. Action function construct_while():
  145. Action this_element
  146. this_element = create_value(!while)
  147. dict_add(this_element, "cond", construct_unknown())
  148. list_append(while_stack, this_element)
  149. dict_add(this_element, "body", construct_unknown())
  150. list_delete(while_stack, list_len(while_stack) - 1)
  151. if (input()):
  152. dict_add(this_element, "next", construct_unknown())
  153. return this_element
  154. Action function construct_access():
  155. Action this_element
  156. this_element = create_value(!access)
  157. dict_add(this_element, "var", construct_unknown())
  158. return this_element
  159. Action function construct_resolve():
  160. Action this_element
  161. this_element = create_value(!resolve)
  162. dict_add(this_element, "var", input())
  163. return this_element
  164. Action function construct_assign():
  165. Action this_element
  166. this_element = create_value(!assign)
  167. dict_add(this_element, "var", construct_unknown())
  168. dict_add(this_element, "value", construct_unknown())
  169. if (input()):
  170. dict_add(this_element, "next", construct_unknown())
  171. return this_element
  172. Action function construct_call():
  173. Action this_element
  174. this_element = create_value(!call)
  175. dict_add(this_element, "func", construct_unknown())
  176. Integer nrParams
  177. nrParams = input()
  178. Integer counter
  179. counter = 0
  180. Element param
  181. Element prev_param
  182. String arg_names_call
  183. arg_names_call = "abcdefghijklmnopqrstuvwxyz"
  184. while (counter < nrParams):
  185. param = create_node()
  186. dict_add(param, "name", string_get(arg_names_call, counter))
  187. dict_add(param, "value", construct_unknown())
  188. if (counter == 0):
  189. dict_add(this_element, "params", param)
  190. else:
  191. dict_add(prev_param, "next_param", param)
  192. prev_param = param
  193. counter = counter + 1
  194. if (nrParams > 0):
  195. dict_add(this_element, "last_param", prev_param)
  196. if (input()):
  197. dict_add(this_element, "next", construct_unknown())
  198. return this_element
  199. Action function construct_return():
  200. if (input()):
  201. Action this_element
  202. this_element = create_value(!return)
  203. dict_add(this_element, "value", construct_unknown())
  204. return this_element
  205. else:
  206. return create_value(!return)
  207. Action function construct_const():
  208. Action this_element
  209. this_element = create_value(!constant)
  210. dict_add(this_element, "node", input())
  211. return this_element
  212. Action function construct_declare():
  213. Action this_element
  214. Element declared_element
  215. this_element = create_value(!declare)
  216. declared_element = create_node()
  217. dict_add(this_element, "var", declared_element)
  218. output(declared_element)
  219. if (input()):
  220. dict_add(this_element, "next", construct_unknown())
  221. return this_element
  222. Action function construct_input():
  223. Action this_element
  224. this_element = create_value(!input)
  225. return this_element
  226. Action function construct_output():
  227. Action this_element
  228. this_element = create_value(!output)
  229. dict_add(this_element, "value", construct_unknown())
  230. if (input()):
  231. dict_add(this_element, "next", construct_unknown())
  232. return this_element
  233. Action function construct_deref():
  234. Action this_element
  235. this_element = create_value(!constant)
  236. dict_add(this_element, "node", import_node(input()))
  237. return this_element
  238. Action function construct_funcdef():
  239. Action assign
  240. Action resolve
  241. Action constant
  242. Element formal
  243. Action func
  244. Element params
  245. assign = create_value(!assign)
  246. resolve = create_value(!resolve)
  247. constant = create_value(!constant)
  248. formal = input()
  249. func = create_node()
  250. params = create_node()
  251. dict_add(assign, "var", resolve)
  252. dict_add(assign, "value", constant)
  253. dict_add(resolve, "var", formal)
  254. dict_add(constant, "node", func)
  255. dict_add(func, "params", params)
  256. Integer nrParams
  257. nrParams = input()
  258. Integer counter
  259. counter = 0
  260. Element param
  261. String arg_names_decl
  262. arg_names_decl = "abcdefghijklmnopqrstuvwxyz"
  263. while (counter < nrParams):
  264. param = create_node()
  265. dict_add(params, string_get(arg_names_decl, counter), param)
  266. output(param)
  267. // Output each parameter in turn
  268. counter = counter + 1
  269. // Now add the body
  270. dict_add(func, "body", construct_unknown())
  271. if (input()):
  272. dict_add(assign, "next", construct_unknown())
  273. return assign
  274. Action function construct_break():
  275. Action this_element
  276. this_element = create_value(!break)
  277. dict_add(this_element, "while", dict_read(while_stack, list_len(while_stack) - 1))
  278. return this_element
  279. Action function construct_continue():
  280. Action this_element
  281. this_element = create_value(!continue)
  282. dict_add(this_element, "while", dict_read(while_stack, list_len(while_stack) - 1))
  283. return this_element
  284. Element function instantiate_bottom(model : Element):
  285. Element this_element
  286. String bottom_type
  287. bottom_type = input()
  288. String element_name
  289. element_name = input()
  290. // Find out which kind of element we want to create
  291. if (bottom_type == "node"):
  292. instantiate_bottom_node(model, element_name)
  293. elif (bottom_type == "value"):
  294. instantiate_bottom_value(model, element_name, input())
  295. elif (bottom_type == "edge"):
  296. instantiate_bottom_edge(model, element_name, dict_read(dict_read(model, "model"), input()), dict_read(dict_read(model, "model"), input()))
  297. // If there is more to come, we also add these elements
  298. if (input()):
  299. return instantiate_bottom(model)
  300. else:
  301. return model
  302. Void function instantiate_model(model : Element):
  303. Element type
  304. type = dict_read(dict_read(dict_read(model, "metamodel"), "model"), input())
  305. String name
  306. name = input()
  307. Element params
  308. params = create_node()
  309. if (is_edge(type)):
  310. list_append(params, dict_read(dict_read(model, "model"), input()))
  311. list_append(params, dict_read(dict_read(model, "model"), input()))
  312. elif (type_eq(typeof(type), Type)):
  313. list_append(params, input())
  314. Element attribute_types
  315. attribute_types = create_node()
  316. while (input()):
  317. dict_add(attribute_types, input(), input())
  318. Element attribute_instances
  319. attribute_instances = create_node()
  320. while (input()):
  321. dict_add(attribute_instances, input(), input())
  322. instantiate_model_lib(model, type, name, params, attribute_types, attribute_instances)
  323. if (input()):
  324. instantiate_model(model)
  325. return
  326. Element function retype_model(model : Element):
  327. Element metamodel
  328. metamodel = input()
  329. Element inheritance
  330. inheritance = dict_read(dict_read(input(), "model"), input())
  331. Element mapping
  332. mapping = create_node()
  333. while (input()):
  334. dict_add(mapping, dict_read(dict_read(model, "model"), input()), dict_read(dict_read(metamodel, "model"), input()))
  335. return retype(model, metamodel, inheritance, mapping)
  336. Element function find_attribute(source : Element, attr_name : String, types : Element, inheritance_link : Element):
  337. if (dict_in(source, attr_name)):
  338. return source
  339. else:
  340. Integer counter
  341. Integer i
  342. Element edge
  343. counter = read_nr_out(source)
  344. i = 0
  345. while (i < counter):
  346. edge = read_out(source, i)
  347. if (element_eq(dict_read_node(types, edge), inheritance_link)):
  348. return find_attribute(read_edge_dst(edge), attr_name, types, inheritance_link)
  349. i = i + 1
  350. // No return at the moment, as this crashes the MvK
  351. log("ERROR: could not find attribute")