compiled.py 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478
  1. from modelverse_kernel.primitives import PrimitiveFinished
  2. def reverseKeyLookup(a, b, **remainder):
  3. edges, = yield [("RO", [a])]
  4. expanded_edges = yield [("RE", [i]) for i in edges]
  5. for i, edge in enumerate(expanded_edges):
  6. if b == edge[1]:
  7. # Found our edge: edges[i]
  8. outgoing, = yield [("RO", [edges[i]])]
  9. result, = yield [("RE", [outgoing[0]])]
  10. raise PrimitiveFinished(result[1])
  11. result, = yield [("CNV", ["(unknown: %s)" % b])]
  12. raise PrimitiveFinished(result)
  13. def read_attribute(a, b, c, **remainder):
  14. model_dict, b_val, c_val, type_mapping = \
  15. yield [("RD", [a, "model"]),
  16. ("RV", [b]),
  17. ("RV", [c]),
  18. ("RD", [a, "type_mapping"]),
  19. ]
  20. model_instance, = \
  21. yield [("RD", [model_dict, b_val])]
  22. edges, = yield [("RO", [model_instance])]
  23. edge_types = yield [("RDN", [type_mapping, i]) for i in edges]
  24. type_edge_val = yield [("RE", [i]) for i in edge_types]
  25. src_nodes = set([i[0] for i in type_edge_val])
  26. found_edges = yield [("RDE", [i, c_val]) for i in src_nodes]
  27. for e1 in found_edges:
  28. if e1 is not None:
  29. # Found an edge!
  30. for i, e2 in enumerate(edge_types):
  31. if e1 == e2:
  32. # The instance of this edge is the one we want!
  33. edge = edges[i]
  34. edge_val, = yield [("RE", [edge])]
  35. result = edge_val[1]
  36. raise PrimitiveFinished(result)
  37. else:
  38. result, = yield [("RR", [])]
  39. raise PrimitiveFinished(result)
  40. raise Exception("Error in reading edge!")
  41. def precompute_cardinalities(a, **remainder):
  42. result, = yield [("CN", [])]
  43. # Read out all edges from the metamodel
  44. a, = yield [("RD", [a, "metamodel"])]
  45. model_dict, = yield [("RD", [a, "model"])]
  46. model_keys, = yield [("RDK", [model_dict])]
  47. type_mapping, = yield [("RD", [a, "type_mapping"])]
  48. elems = yield [("RDN", [model_dict, k]) for k in model_keys]
  49. model_keys_str = yield [("RV", [i]) for i in model_keys]
  50. elem_to_name = dict(zip(elems, model_keys_str))
  51. edges = yield [("RE", [i]) for i in elems]
  52. elems = [elems[i] for i, edge_val in enumerate(edges) if edge_val is not None]
  53. # Now we have all edges in the metamodel
  54. # Read out the type of the Association defining all cardinalities
  55. metamodel, = yield [("RD", [a, "metamodel"])]
  56. metametamodel, = yield [("RD", [metamodel, "metamodel"])]
  57. metametamodel_dict, = \
  58. yield [("RD", [metametamodel, "model"])]
  59. assoc, = yield [("RD", [metametamodel_dict, "Association"])]
  60. slc, suc, tlc, tuc = \
  61. yield [("RDE", [assoc, "source_lower_cardinality"]),
  62. ("RDE", [assoc, "source_upper_cardinality"]),
  63. ("RDE", [assoc, "target_lower_cardinality"]),
  64. ("RDE", [assoc, "target_upper_cardinality"]),
  65. ]
  66. # All that we now have to do is find, for each edge, whether or not it has an edge typed by any of these links!
  67. # Just find all links typed by these links!
  68. types = yield [("RDN", [type_mapping, i]) for i in elems]
  69. cardinalities = {}
  70. for i, edge_type in enumerate(types):
  71. if edge_type == slc:
  72. t = "slc"
  73. elif edge_type == suc:
  74. t = "suc"
  75. elif edge_type == tlc:
  76. t = "tlc"
  77. elif edge_type == tuc:
  78. t = "tuc"
  79. else:
  80. continue
  81. # Found a link, so add it
  82. srcdst, = yield [("RE", [elems[i]])]
  83. source, destination = srcdst
  84. # The edge gives the "source" the cardinality found in "destination"
  85. cardinalities.setdefault(elem_to_name[source], {})[t] = destination
  86. # Now we have to translate the "cardinalities" Python dictionary to a Modelverse dictionary
  87. nodes = yield [("CN", []) for i in cardinalities]
  88. yield [("CD", [result, i, node]) for i, node in zip(cardinalities.keys(), nodes)]
  89. l = cardinalities.keys()
  90. values = yield [("RD", [result, i]) for i in l]
  91. for i, value in enumerate(values):
  92. cards = cardinalities[l[i]]
  93. yield [("CD", [value, card_type, cards[card_type]]) for card_type in cards]
  94. raise PrimitiveFinished(result)
  95. def set_copy(a, **remainder):
  96. b, = yield [("CN", [])]
  97. links, = yield [("RO", [a])]
  98. exp_links = yield [("RE", [i]) for i in links]
  99. _ = yield [("CE", [b, i[1]]) for i in exp_links]
  100. raise PrimitiveFinished(b)
  101. def allInstances(a, b, **remainder):
  102. b_val, = yield [("RV", [b])]
  103. model_dict,= yield [("RD", [a, "model"])]
  104. metamodel, = yield [("RD", [a, "metamodel"])]
  105. mm_dict, = yield [("RD", [metamodel, "model"])]
  106. typing, = yield [("RD", [a, "type_mapping"])]
  107. elem_keys, = yield [("RDK", [model_dict])]
  108. elems = yield [("RDN", [model_dict, i]) for i in elem_keys]
  109. mms = yield [("RDN", [typing, i]) for i in elems]
  110. # Have the type for each name
  111. types_to_name_nodes = {}
  112. for key, mm in zip(elem_keys, mms):
  113. types_to_name_nodes.setdefault(mm, set()).add(key)
  114. # And now we have the inverse mapping: for each type, we have the node containing the name
  115. # Get the inheritance link type
  116. inheritance_type, = yield [("RD", [metamodel, "inheritance"])]
  117. # Now we figure out which types are valid for the specified model
  118. desired_types = set()
  119. mm_element, = yield [("RD", [mm_dict, b_val])]
  120. work_list = []
  121. work_list.append(mm_element)
  122. mm_typing, = yield [("RD", [metamodel, "type_mapping"])]
  123. while work_list:
  124. mm_element = work_list.pop()
  125. if mm_element in desired_types:
  126. # Already been here, so stop
  127. continue
  128. # New element, so continue
  129. desired_types.add(mm_element)
  130. # Follow all inheritance links that COME IN this node, as all these are subtypes and should also match
  131. incoming, = yield [("RI", [mm_element])]
  132. for i in incoming:
  133. t, = yield [("RDN", [mm_typing, i])]
  134. if t == inheritance_type:
  135. e, = yield [("RE", [i])]
  136. # Add the source of the inheritance link to the work list
  137. work_list.append(e[0])
  138. # Now desired_types holds all the direct types that we are interested in!
  139. # Construct the result out of all models that are direct instances of our specified type
  140. final = set()
  141. for t in desired_types:
  142. final |= types_to_name_nodes.get(t, set())
  143. # Result is a Python set with nodes, so just make this a Mv set
  144. result, = yield [("CN", [])]
  145. v = yield [("RV", [i]) for i in final]
  146. _ = yield [("CE", [result, i]) for i in final]
  147. raise PrimitiveFinished(result)
  148. def add_AL(a, b, **remainder):
  149. worklist = [(b, "funcdef")]
  150. added = set()
  151. type_cache = {}
  152. model_dict, = yield [("RD", [a, "model"])]
  153. metamodel, = yield [("RD", [a, "metamodel"])]
  154. metamodel_dict, = yield [("RD", [metamodel, "model"])]
  155. type_map, = yield [("RD", [a, "type_mapping"])]
  156. outgoing, = yield [("RO", [model_dict])]
  157. edges = yield [("RE", [i]) for i in outgoing]
  158. added |= set([i[1] for i in edges])
  159. result, = yield [("CNV", ["__%s" % b])]
  160. # All the action language elements and their expected output links
  161. type_links = {
  162. "if": [("cond", ""), ("then", ""), ("else", ""), ("next", "")],
  163. "while": [("cond", ""), ("body", ""), ("next", "")],
  164. "assign": [("var", ""), ("value", ""), ("next", "")],
  165. "break": [("while", "while")],
  166. "continue": [("while", "while")],
  167. "return": [("value", "")],
  168. "resolve": [("var", "")],
  169. "access": [("var", "")],
  170. "constant": [("node", "")],
  171. "output": [("node", ""), ("next", "")],
  172. "global": [("var", "String"), ("next", "")],
  173. "param": [("name", "String"), ("value", ""), ("next_param", "param")],
  174. "funcdef": [("body", ""), ("next", "")],
  175. "call": [("func", ""), ("params", "param"), ("last_param", "param"), ("next", "")],
  176. }
  177. # Already add some often used types to the type cache, so we don't have to check for their presence
  178. to_str, string = yield [("RD", [metamodel_dict, "to_str"]),
  179. ("RD", [metamodel_dict, "String"])]
  180. type_cache = {"to_str": to_str,
  181. "String": string}
  182. while worklist:
  183. # Fetch the element and see if we need to add it
  184. worknode, expected_type = worklist.pop(0)
  185. if worknode in added:
  186. continue
  187. # Determine type of element
  188. if expected_type == "":
  189. value, = yield [("RV", [worknode])]
  190. if (isinstance(value, dict)) and ("value" in value):
  191. v = value["value"]
  192. if v in ["if", "while", "assign", "call", "break", "continue", "return", "resolve", "access", "constant", "global", "declare"]:
  193. expected_type = v
  194. else:
  195. expected_type = "Any"
  196. else:
  197. expected_type = "Any"
  198. # Fill the cache
  199. if expected_type not in type_cache:
  200. type_cache[expected_type], = yield [("RD", [metamodel_dict, expected_type])]
  201. # Need to add it now
  202. yield [("CD", [model_dict, "__%s" % worknode, worknode])]
  203. added.add(worknode)
  204. # NOTE can't just use CD here, as the key is a node and not a value
  205. t1, = yield [("CE", [type_map, type_cache[expected_type]])]
  206. t2, = yield [("CE", [t1, worknode])]
  207. if t1 is None or t2 is None:
  208. raise Exception("ERROR")
  209. # Now add all its outgoing links, depending on the type we actually saw
  210. links = type_links.get(expected_type, [])
  211. for link in links:
  212. link_name, destination_type = link
  213. # Check if the link actually exists
  214. destination, = yield [("RD", [worknode, link_name])]
  215. if destination is not None:
  216. # If so, we add it and continue
  217. edge, = yield [("RDE", [worknode, link_name])]
  218. edge_outlinks, = yield [("RO", [edge])]
  219. edge_outlink = edge_outlinks[0]
  220. edge_name, = yield [("RE", [edge_outlink])]
  221. edge_name = edge_name[1]
  222. # Now add: edge, edge_outlink, edge_name
  223. # Add 'edge'
  224. yield [("CD", [model_dict, "__%s" % edge, edge])]
  225. added.add(edge)
  226. link_type = "%s_%s" % (expected_type, link_name)
  227. if link_type not in type_cache:
  228. type_cache[link_type], = yield [("RD", [metamodel_dict, link_type])]
  229. t, = yield [("CE", [type_map, type_cache[link_type]])]
  230. yield [("CE", [t, edge])]
  231. # Add 'edge_outlink'
  232. yield [("CD", [model_dict, "__%s" % edge_outlink, edge_outlink])]
  233. added.add(edge_outlink)
  234. t, = yield [("CE", [type_map, type_cache["to_str"]])]
  235. yield [("CE", [t, edge_outlink])]
  236. # Add 'edge_name' (if not present)
  237. if edge_name not in added:
  238. yield [("CD", [model_dict, "__%s" % edge_name, edge_name])]
  239. t, = yield [("CE", [type_map, type_cache["String"]])]
  240. yield [("CE", [t, edge_name])]
  241. added.add(edge_name)
  242. # Add the destination to the worklist
  243. worklist.append((destination, destination_type))
  244. raise PrimitiveFinished(result)
  245. def get_superclasses(a, b, **remainder):
  246. inheritance, = yield [("RD", [a, "inheritance"])]
  247. model_dict, = yield [("RD", [a, "model"])]
  248. b_v, = yield [("RV", [b])]
  249. subclass, = yield [("RD", [model_dict, b_v])]
  250. type_mapping, = yield [("RD", [a, "type_mapping"])]
  251. names, = yield [("RDK", [model_dict])]
  252. elems = yield [("RDN", [model_dict, i]) for i in names]
  253. elem_to_name = dict(zip(elems, names))
  254. result, = yield [("CN", [])]
  255. worklist = [subclass]
  256. while worklist:
  257. subclass = worklist.pop()
  258. res = elem_to_name[subclass]
  259. yield [("CE", [result, res])]
  260. outgoing, = yield [("RO", [subclass])]
  261. types = yield [("RDN", [type_mapping, i]) for i in outgoing]
  262. for i, t in enumerate(types):
  263. if t == inheritance:
  264. # Found an inheritance link!
  265. elem = outgoing[i]
  266. srcdst, = yield [("RE", [elem])]
  267. src, dst = srcdst
  268. # Find elem in elems
  269. worklist.append(dst)
  270. raise PrimitiveFinished(result)
  271. def selectPossibleIncoming(a, b, c, **remainder):
  272. model_dict, = yield [("RD", [a, "model"])]
  273. limit_set_links, = \
  274. yield [("RO", [c])]
  275. limit_set = yield [("RE", [i]) for i in limit_set_links]
  276. limit_set_names = [i[1] for i in limit_set]
  277. name_values = yield [("RV", [i]) for i in limit_set_names]
  278. limit_set = yield [("RD", [model_dict, i]) for i in name_values]
  279. try:
  280. gen = get_superclasses(a, b)
  281. inp = None
  282. while 1:
  283. inp = yield gen.send(inp)
  284. except PrimitiveFinished as e:
  285. superclasses = e.result
  286. vals, = yield [("RO", [superclasses])]
  287. superclasses = yield [("RE", [i]) for i in vals]
  288. superclasses = [i[1] for i in superclasses]
  289. superclass_names = yield [("RV", [i]) for i in superclasses]
  290. elems = yield [("RD", [model_dict, i]) for i in superclass_names]
  291. result, = yield [("CN", [])]
  292. for i, edge in enumerate(limit_set):
  293. srcdst, = yield [("RE", [edge])]
  294. src, dst = srcdst
  295. if dst in elems:
  296. yield [("CE", [result, limit_set_names[i]])]
  297. raise PrimitiveFinished(result)
  298. def selectPossibleOutgoing(a, b, c, **remainder):
  299. model_dict, = yield [("RD", [a, "model"])]
  300. limit_set_links, = \
  301. yield [("RO", [c])]
  302. limit_set = yield [("RE", [i]) for i in limit_set_links]
  303. limit_set_names = \
  304. [i[1] for i in limit_set]
  305. name_values = yield [("RV", [i]) for i in limit_set_names]
  306. limit_set = yield [("RD", [model_dict, i]) for i in name_values]
  307. try:
  308. gen = get_superclasses(a, b)
  309. inp = None
  310. while 1:
  311. inp = yield gen.send(inp)
  312. except PrimitiveFinished as e:
  313. superclasses = e.result
  314. vals, = yield [("RO", [superclasses])]
  315. superclasses = yield [("RE", [i]) for i in vals]
  316. superclasses = [i[1] for i in superclasses]
  317. superclass_names = yield [("RV", [i]) for i in superclasses]
  318. elems = yield [("RD", [model_dict, i]) for i in superclass_names]
  319. result, = yield [("CN", [])]
  320. for i, edge in enumerate(limit_set):
  321. srcdst, = yield [("RE", [edge])]
  322. src, dst = srcdst
  323. if src in elems:
  324. yield [("CE", [result, limit_set_names[i]])]
  325. raise PrimitiveFinished(result)
  326. def check_symbols(a, b, c, **remainder):
  327. symbols = {}
  328. function_name, = yield [("RV", [b])]
  329. symbols[function_name] = False
  330. object_links, = yield [("RO", [c])]
  331. set_elements = yield [("RE", [i]) for i in object_links]
  332. set_elements = [i[1] for i in set_elements]
  333. set_values = yield [("RV", [i]) for i in set_elements]
  334. set_elements = yield [("RD", [a, i]) for i in set_values]
  335. symbols_set = yield [("RD", [i, "symbols"]) for i in set_elements]
  336. all_keys = yield [("RDK", [i]) for i in symbols_set]
  337. for i, s in zip(all_keys, symbols_set):
  338. # For each object we have found
  339. keys = yield [("RV", [j]) for j in i]
  340. values = yield [("RD", [s, j]) for j in keys]
  341. values = yield [("RV", [j]) for j in values]
  342. for key, value in zip(keys, values):
  343. k = key
  344. v = value
  345. if v and symbols.get(k, False):
  346. result = yield [("CNV", ["ERROR: multiple definition of symbol " + str(key)])]
  347. raise PrimitiveFinished(result)
  348. elif v and not symbols.get(k, False):
  349. symbols[k] = True
  350. elif not v and k not in symbols:
  351. symbols[k] = False
  352. for i, j in symbols.items():
  353. if i == "input" or i == "output":
  354. continue
  355. if not j:
  356. result, = yield [("CNV", ["ERROR: undefined symbol " + str(i)])]
  357. raise PrimitiveFinished(result)
  358. result, = yield [("CNV", ["OK"])]
  359. raise PrimitiveFinished(result)
  360. def construct_const(**remainder):
  361. v, = yield [("CNV", [{"value": "constant"}])]
  362. # Get input: keep trying until we get something
  363. try:
  364. gen = __get_input(remainder)
  365. inp = None
  366. while 1:
  367. inp = yield gen.send(inp)
  368. except PrimitiveFinished as e:
  369. inp = e.result
  370. yield [("CD", [v, "node", inp])]
  371. raise PrimitiveFinished(v)
  372. def instantiated_name(a, b, **remainder):
  373. name_value, = yield [("RV", [b])]
  374. if name_value == "":
  375. b, = yield [("CNV", ["__" + str(a)])]
  376. raise PrimitiveFinished(b)
  377. def retype(a, b, c, **remainder):
  378. tm, = yield [("RD", [a, "type_mapping"])]
  379. m, = yield [("RD", [a, "model"])]
  380. mm, = yield [("RD", [a, "metamodel"])]
  381. mm_dict, = yield [("RD", [mm, "model"])]
  382. c_val, = yield [("RV", [c])]
  383. mm_ref, = yield [("RD", [mm_dict, c_val])]
  384. b_val, = yield [("RV", [b])]
  385. m_ref, = yield [("RD", [m, b_val])]
  386. prev_edge, = yield [("RDNE", [tm, m_ref])]
  387. if prev_edge is not None:
  388. yield [("DE", [prev_edge])]
  389. t, = yield [("CE", [tm, mm_ref])]
  390. yield [("CE", [t, m_ref])]
  391. raise PrimitiveFinished(None)
  392. def __get_input(parameters):
  393. mvk = parameters["mvk"]
  394. user_root = parameters["user_root"]
  395. while 1:
  396. try:
  397. gen = mvk.input_init(user_root)
  398. inp = None
  399. while 1:
  400. inp = yield gen.send(inp)
  401. except StopIteration:
  402. # Finished
  403. if mvk.success:
  404. # Got some input, so we can access it
  405. raise PrimitiveFinished(mvk.input_value)
  406. else:
  407. # No input, so yield None but don't stop
  408. yield None