|
|
@@ -1,6 +1,29 @@
|
|
|
from modelverse_kernel.primitives import PrimitiveFinished
|
|
|
|
|
|
+
|
|
|
+def reverseKeyLookupMulti(a, b, **remainder):
|
|
|
+ edges, = yield [("RO", [a])]
|
|
|
+ b_val, = yield [("RV", [b])]
|
|
|
+ expanded_edges = yield [("RE", [i]) for i in edges]
|
|
|
+ values = yield [("RV", [i[1]]) for i in expanded_edges]
|
|
|
+ result, = yield [("CN", [])]
|
|
|
+
|
|
|
+ for i, edge in enumerate(values):
|
|
|
+ if b_val == edge:
|
|
|
+ # Found our edge: edges[i]
|
|
|
+ outgoing, = yield [("RO", [edges[i]])]
|
|
|
+ value, = yield [("RE", [outgoing[0]])]
|
|
|
+ yield [("CE", [result, value[1]])]
|
|
|
+
|
|
|
+ raise PrimitiveFinished(result)
|
|
|
+
|
|
|
def reverseKeyLookup(a, b, **remainder):
|
|
|
+ # Guess, which might work
|
|
|
+ guess, = yield [("RD", [a, "__%s" % b])]
|
|
|
+ if guess == b:
|
|
|
+ result, = yield [("CNV", ["__%s" % b])]
|
|
|
+ raise PrimitiveFinished(result)
|
|
|
+
|
|
|
edges, = yield [("RO", [a])]
|
|
|
expanded_edges = yield [("RE", [i]) for i in edges]
|
|
|
for i, edge in enumerate(expanded_edges):
|
|
|
@@ -13,41 +36,6 @@ def reverseKeyLookup(a, b, **remainder):
|
|
|
result, = yield [("CNV", ["(unknown: %s)" % b])]
|
|
|
raise PrimitiveFinished(result)
|
|
|
|
|
|
-"""
|
|
|
-def read_attribute(a, b, c, **remainder):
|
|
|
- model_dict, b_val, c_val, type_mapping = \
|
|
|
- yield [("RD", [a, "model"]),
|
|
|
- ("RV", [b]),
|
|
|
- ("RV", [c]),
|
|
|
- ("RD", [a, "type_mapping"]),
|
|
|
- ]
|
|
|
- model_instance, = \
|
|
|
- yield [("RD", [model_dict, b_val])]
|
|
|
- edges, = yield [("RO", [model_instance])]
|
|
|
- edge_types = yield [("RDN", [type_mapping, i]) for i in edges]
|
|
|
- type_edge_val = yield [("RE", [i]) for i in edge_types]
|
|
|
-
|
|
|
- src_nodes = set([i[0] for i in type_edge_val])
|
|
|
-
|
|
|
- found_edges = yield [("RDE", [i, c_val]) for i in src_nodes]
|
|
|
-
|
|
|
- for e1 in found_edges:
|
|
|
- if e1 is not None:
|
|
|
- # Found an edge!
|
|
|
- for i, e2 in enumerate(edge_types):
|
|
|
- if e1 == e2:
|
|
|
- # The instance of this edge is the one we want!
|
|
|
- edge = edges[i]
|
|
|
- edge_val, = yield [("RE", [edge])]
|
|
|
- result = edge_val[1]
|
|
|
- raise PrimitiveFinished(result)
|
|
|
- else:
|
|
|
- result, = yield [("RR", [])]
|
|
|
- raise PrimitiveFinished(result)
|
|
|
-
|
|
|
- raise Exception("Error in reading edge!")
|
|
|
-"""
|
|
|
-
|
|
|
def set_copy(a, **remainder):
|
|
|
b, = yield [("CN", [])]
|
|
|
links, = yield [("RO", [a])]
|
|
|
@@ -55,294 +43,6 @@ def set_copy(a, **remainder):
|
|
|
_ = yield [("CE", [b, i[1]]) for i in exp_links]
|
|
|
raise PrimitiveFinished(b)
|
|
|
|
|
|
-"""
|
|
|
-def allInstances(a, b, **remainder):
|
|
|
- b_val, = yield [("RV", [b])]
|
|
|
- model_dict,= yield [("RD", [a, "model"])]
|
|
|
- metamodel, = yield [("RD", [a, "metamodel"])]
|
|
|
- m3, = yield [("RD", [metamodel, "metamodel"])]
|
|
|
- m3_model, = yield [("RD", [m3, "model"])]
|
|
|
- mm_dict, = yield [("RD", [metamodel, "model"])]
|
|
|
- typing, = yield [("RD", [a, "type_mapping"])]
|
|
|
- elem_keys, = yield [("RDK", [model_dict])]
|
|
|
- elems = yield [("RDN", [model_dict, i]) for i in elem_keys]
|
|
|
- mms = yield [("RDN", [typing, i]) for i in elems]
|
|
|
-
|
|
|
- # Have the type for each name
|
|
|
- types_to_name_nodes = {}
|
|
|
- for key, mm in zip(elem_keys, mms):
|
|
|
- types_to_name_nodes.setdefault(mm, set()).add(key)
|
|
|
- # And now we have the inverse mapping: for each type, we have the node containing the name
|
|
|
-
|
|
|
- # Get the inheritance link type
|
|
|
- inheritance_type, = yield [("RD", [m3_model, "Inheritance"])]
|
|
|
-
|
|
|
- # Now we figure out which types are valid for the specified model
|
|
|
- desired_types = set()
|
|
|
- mm_element, = yield [("RD", [mm_dict, b_val])]
|
|
|
-
|
|
|
- work_list = []
|
|
|
- work_list.append(mm_element)
|
|
|
- mm_typing, = yield [("RD", [metamodel, "type_mapping"])]
|
|
|
-
|
|
|
- while work_list:
|
|
|
- mm_element = work_list.pop()
|
|
|
- if mm_element in desired_types:
|
|
|
- # Already been here, so stop
|
|
|
- continue
|
|
|
-
|
|
|
- # New element, so continue
|
|
|
- desired_types.add(mm_element)
|
|
|
-
|
|
|
- # Follow all inheritance links that COME IN this node, as all these are subtypes and should also match
|
|
|
- incoming, = yield [("RI", [mm_element])]
|
|
|
- for i in incoming:
|
|
|
- t, = yield [("RDN", [mm_typing, i])]
|
|
|
- if t == inheritance_type:
|
|
|
- e, = yield [("RE", [i])]
|
|
|
- # Add the source of the inheritance link to the work list
|
|
|
- work_list.append(e[0])
|
|
|
-
|
|
|
- # Now desired_types holds all the direct types that we are interested in!
|
|
|
- # Construct the result out of all models that are direct instances of our specified type
|
|
|
- final = set()
|
|
|
- for t in desired_types:
|
|
|
- final |= types_to_name_nodes.get(t, set())
|
|
|
-
|
|
|
- # Result is a Python set with nodes, so just make this a Mv set
|
|
|
- result, = yield [("CN", [])]
|
|
|
- v = yield [("RV", [i]) for i in final]
|
|
|
- _ = yield [("CE", [result, i]) for i in final]
|
|
|
- raise PrimitiveFinished(result)
|
|
|
-"""
|
|
|
-
|
|
|
-"""
|
|
|
-def add_AL(a, b, **remainder):
|
|
|
- worklist = [(b, "funcdef")]
|
|
|
- added = set()
|
|
|
- type_cache = {}
|
|
|
-
|
|
|
- model_dict, = yield [("RD", [a, "model"])]
|
|
|
- metamodel, = yield [("RD", [a, "metamodel"])]
|
|
|
- metamodel_dict, = yield [("RD", [metamodel, "model"])]
|
|
|
- type_map, = yield [("RD", [a, "type_mapping"])]
|
|
|
- outgoing, = yield [("RO", [model_dict])]
|
|
|
- edges = yield [("RE", [i]) for i in outgoing]
|
|
|
- added |= set([i[1] for i in edges])
|
|
|
-
|
|
|
- result, = yield [("CNV", ["__%s" % b])]
|
|
|
-
|
|
|
- # All the action language elements and their expected output links
|
|
|
- type_links = {
|
|
|
- "if": [("cond", ""), ("then", ""), ("else", ""), ("next", "")],
|
|
|
- "while": [("cond", ""), ("body", ""), ("next", "")],
|
|
|
- "assign": [("var", ""), ("value", ""), ("next", "")],
|
|
|
- "break": [("while", "while")],
|
|
|
- "continue": [("while", "while")],
|
|
|
- "return": [("value", "")],
|
|
|
- "resolve": [("var", "")],
|
|
|
- "access": [("var", "")],
|
|
|
- "constant": [("node", "")],
|
|
|
- "output": [("node", ""), ("next", "")],
|
|
|
- "global": [("var", "String"), ("next", "")],
|
|
|
- "param": [("name", "String"), ("value", ""), ("next_param", "param")],
|
|
|
- "funcdef": [("body", ""), ("next", "")],
|
|
|
- "call": [("func", ""), ("params", "param"), ("last_param", "param"), ("next", "")],
|
|
|
- }
|
|
|
-
|
|
|
- # Already add some often used types to the type cache, so we don't have to check for their presence
|
|
|
- to_str, string = yield [("RD", [metamodel_dict, "to_str"]),
|
|
|
- ("RD", [metamodel_dict, "String"])]
|
|
|
-
|
|
|
- type_cache = {"to_str": to_str,
|
|
|
- "String": string}
|
|
|
-
|
|
|
- while worklist:
|
|
|
- # Fetch the element and see if we need to add it
|
|
|
- worknode, expected_type = worklist.pop(0)
|
|
|
- if worknode in added:
|
|
|
- continue
|
|
|
-
|
|
|
- # Determine type of element
|
|
|
- if expected_type == "":
|
|
|
- value, = yield [("RV", [worknode])]
|
|
|
- if (isinstance(value, dict)) and ("value" in value):
|
|
|
- v = value["value"]
|
|
|
- if v in ["if", "while", "assign", "call", "break", "continue", "return", "resolve", "access", "constant", "global", "declare"]:
|
|
|
- expected_type = v
|
|
|
- else:
|
|
|
- expected_type = "Any"
|
|
|
- else:
|
|
|
- expected_type = "Any"
|
|
|
-
|
|
|
- # Fill the cache
|
|
|
- if expected_type not in type_cache:
|
|
|
- type_cache[expected_type], = yield [("RD", [metamodel_dict, expected_type])]
|
|
|
-
|
|
|
- # Need to add it now
|
|
|
- yield [("CD", [model_dict, "__%s" % worknode, worknode])]
|
|
|
- added.add(worknode)
|
|
|
- # NOTE can't just use CD here, as the key is a node and not a value
|
|
|
- t1, = yield [("CE", [type_map, type_cache[expected_type]])]
|
|
|
- t2, = yield [("CE", [t1, worknode])]
|
|
|
- if t1 is None or t2 is None:
|
|
|
- raise Exception("ERROR")
|
|
|
-
|
|
|
- # Now add all its outgoing links, depending on the type we actually saw
|
|
|
- links = type_links.get(expected_type, [])
|
|
|
- for link in links:
|
|
|
- link_name, destination_type = link
|
|
|
-
|
|
|
- # Check if the link actually exists
|
|
|
- destination, = yield [("RD", [worknode, link_name])]
|
|
|
- if destination is not None:
|
|
|
- # If so, we add it and continue
|
|
|
- edge, = yield [("RDE", [worknode, link_name])]
|
|
|
- edge_outlinks, = yield [("RO", [edge])]
|
|
|
- edge_outlink = edge_outlinks[0]
|
|
|
- edge_name, = yield [("RE", [edge_outlink])]
|
|
|
- edge_name = edge_name[1]
|
|
|
- # Now add: edge, edge_outlink, edge_name
|
|
|
-
|
|
|
- # Add 'edge'
|
|
|
- yield [("CD", [model_dict, "__%s" % edge, edge])]
|
|
|
- added.add(edge)
|
|
|
- link_type = "%s_%s" % (expected_type, link_name)
|
|
|
- if link_type not in type_cache:
|
|
|
- type_cache[link_type], = yield [("RD", [metamodel_dict, link_type])]
|
|
|
- t, = yield [("CE", [type_map, type_cache[link_type]])]
|
|
|
- yield [("CE", [t, edge])]
|
|
|
-
|
|
|
- # Add 'edge_outlink'
|
|
|
- yield [("CD", [model_dict, "__%s" % edge_outlink, edge_outlink])]
|
|
|
- added.add(edge_outlink)
|
|
|
- t, = yield [("CE", [type_map, type_cache["to_str"]])]
|
|
|
- yield [("CE", [t, edge_outlink])]
|
|
|
-
|
|
|
- # Add 'edge_name' (if not present)
|
|
|
- if edge_name not in added:
|
|
|
- yield [("CD", [model_dict, "__%s" % edge_name, edge_name])]
|
|
|
- t, = yield [("CE", [type_map, type_cache["String"]])]
|
|
|
- yield [("CE", [t, edge_name])]
|
|
|
- added.add(edge_name)
|
|
|
-
|
|
|
- # Add the destination to the worklist
|
|
|
- worklist.append((destination, destination_type))
|
|
|
-
|
|
|
- raise PrimitiveFinished(result)
|
|
|
-"""
|
|
|
-
|
|
|
-"""
|
|
|
-def get_superclasses(a, b, **remainder):
|
|
|
- mm, = yield [("RD", [a, "metamodel"])]
|
|
|
- mm, = yield [("RD", [mm, "metamodel"])]
|
|
|
- m, = yield [("RD", [mm, "model"])]
|
|
|
- inheritance, = yield [("RD", [m, "Inheritance"])]
|
|
|
- model_dict, = yield [("RD", [a, "model"])]
|
|
|
- b_v, = yield [("RV", [b])]
|
|
|
- subclass, = yield [("RD", [model_dict, b_v])]
|
|
|
- type_mapping, = yield [("RD", [a, "type_mapping"])]
|
|
|
- names, = yield [("RDK", [model_dict])]
|
|
|
- elems = yield [("RDN", [model_dict, i]) for i in names]
|
|
|
- elem_to_name = dict(zip(elems, names))
|
|
|
-
|
|
|
- result, = yield [("CN", [])]
|
|
|
- worklist = [subclass]
|
|
|
-
|
|
|
- touched = set()
|
|
|
-
|
|
|
- while worklist:
|
|
|
- subclass = worklist.pop()
|
|
|
- res = elem_to_name[subclass]
|
|
|
-
|
|
|
- if subclass not in touched:
|
|
|
- touched.add(subclass)
|
|
|
- yield [("CE", [result, res])]
|
|
|
-
|
|
|
- outgoing, = yield [("RO", [subclass])]
|
|
|
- types = yield [("RDN", [type_mapping, i]) for i in outgoing]
|
|
|
-
|
|
|
- for i, t in enumerate(types):
|
|
|
- if t == inheritance:
|
|
|
- # Found an inheritance link!
|
|
|
- elem = outgoing[i]
|
|
|
- srcdst, = yield [("RE", [elem])]
|
|
|
- src, dst = srcdst
|
|
|
- # Find elem in elems
|
|
|
- worklist.append(dst)
|
|
|
-
|
|
|
- raise PrimitiveFinished(result)
|
|
|
-"""
|
|
|
-
|
|
|
-"""
|
|
|
-def selectPossibleIncoming(a, b, c, **remainder):
|
|
|
- model_dict, = yield [("RD", [a, "model"])]
|
|
|
- limit_set_links, = \
|
|
|
- yield [("RO", [c])]
|
|
|
- limit_set = yield [("RE", [i]) for i in limit_set_links]
|
|
|
- limit_set_names = [i[1] for i in limit_set]
|
|
|
- name_values = yield [("RV", [i]) for i in limit_set_names]
|
|
|
- limit_set = yield [("RD", [model_dict, i]) for i in name_values]
|
|
|
-
|
|
|
- try:
|
|
|
- gen = get_superclasses(a, b)
|
|
|
- inp = None
|
|
|
- while 1:
|
|
|
- inp = yield gen.send(inp)
|
|
|
- except PrimitiveFinished as e:
|
|
|
- superclasses = e.result
|
|
|
- vals, = yield [("RO", [superclasses])]
|
|
|
- superclasses = yield [("RE", [i]) for i in vals]
|
|
|
- superclasses = [i[1] for i in superclasses]
|
|
|
-
|
|
|
- superclass_names = yield [("RV", [i]) for i in superclasses]
|
|
|
- elems = yield [("RD", [model_dict, i]) for i in superclass_names]
|
|
|
-
|
|
|
- result, = yield [("CN", [])]
|
|
|
- for i, edge in enumerate(limit_set):
|
|
|
- srcdst, = yield [("RE", [edge])]
|
|
|
- src, dst = srcdst
|
|
|
- if dst in elems:
|
|
|
- yield [("CE", [result, limit_set_names[i]])]
|
|
|
-
|
|
|
- raise PrimitiveFinished(result)
|
|
|
-"""
|
|
|
-
|
|
|
-"""
|
|
|
-def selectPossibleOutgoing(a, b, c, **remainder):
|
|
|
- model_dict, = yield [("RD", [a, "model"])]
|
|
|
- limit_set_links, = \
|
|
|
- yield [("RO", [c])]
|
|
|
- limit_set = yield [("RE", [i]) for i in limit_set_links]
|
|
|
- limit_set_names = \
|
|
|
- [i[1] for i in limit_set]
|
|
|
- name_values = yield [("RV", [i]) for i in limit_set_names]
|
|
|
- limit_set = yield [("RD", [model_dict, i]) for i in name_values]
|
|
|
-
|
|
|
- try:
|
|
|
- gen = get_superclasses(a, b)
|
|
|
- inp = None
|
|
|
- while 1:
|
|
|
- inp = yield gen.send(inp)
|
|
|
- except PrimitiveFinished as e:
|
|
|
- superclasses = e.result
|
|
|
- vals, = yield [("RO", [superclasses])]
|
|
|
- superclasses = yield [("RE", [i]) for i in vals]
|
|
|
- superclasses = [i[1] for i in superclasses]
|
|
|
-
|
|
|
- superclass_names = yield [("RV", [i]) for i in superclasses]
|
|
|
- elems = yield [("RD", [model_dict, i]) for i in superclass_names]
|
|
|
-
|
|
|
- result, = yield [("CN", [])]
|
|
|
- for i, edge in enumerate(limit_set):
|
|
|
- srcdst, = yield [("RE", [edge])]
|
|
|
- src, dst = srcdst
|
|
|
- if src in elems:
|
|
|
- yield [("CE", [result, limit_set_names[i]])]
|
|
|
-
|
|
|
- raise PrimitiveFinished(result)
|
|
|
-"""
|
|
|
-
|
|
|
def check_symbols(a, b, c, **remainder):
|
|
|
symbols = {}
|
|
|
function_name, = yield [("RV", [b])]
|
|
|
@@ -363,7 +63,7 @@ def check_symbols(a, b, c, **remainder):
|
|
|
k = key
|
|
|
v = value
|
|
|
if v and symbols.get(k, False):
|
|
|
- result = yield [("CNV", ["ERROR: multiple definition of symbol " + str(key)])]
|
|
|
+ result, = yield [("CNV", ["ERROR: multiple definition of symbol " + str(key)])]
|
|
|
raise PrimitiveFinished(result)
|
|
|
elif v and not symbols.get(k, False):
|
|
|
symbols[k] = True
|
|
|
@@ -419,3 +119,58 @@ def __get_input(parameters):
|
|
|
else:
|
|
|
# No input, so yield None but don't stop
|
|
|
yield None
|
|
|
+
|
|
|
+def instantiated_name(a, b, **remainder):
|
|
|
+ name_value, = yield [("RV", [b])]
|
|
|
+ if name_value == "":
|
|
|
+ b, = yield [("CNV", ["__" + str(a)])]
|
|
|
+ raise PrimitiveFinished(b)
|
|
|
+
|
|
|
+def set_merge(a, b, **remainder):
|
|
|
+ outputs, = yield [("RO", [b])]
|
|
|
+ values = yield [("RE", [i]) for i in outputs]
|
|
|
+ yield [("CE", [a, i[1]]) for i in values]
|
|
|
+ raise PrimitiveFinished(a)
|
|
|
+
|
|
|
+def has_value(a, **remainder):
|
|
|
+ v, = yield [("RV", [a])]
|
|
|
+ if v is None:
|
|
|
+ result, = yield [("CNV", [False])]
|
|
|
+ else:
|
|
|
+ result, = yield [("CNV", [True])]
|
|
|
+ raise PrimitiveFinished(result)
|
|
|
+
|
|
|
+def make_reverse_dictionary(a, **remainder):
|
|
|
+ reverse, = yield [("CN", [])]
|
|
|
+ key_nodes, = yield [("RDK", [a])]
|
|
|
+ values = yield [("RDN", [a, i]) for i in key_nodes]
|
|
|
+ yield [("CD", [reverse, str(v), k]) for k, v in zip(key_nodes, values)]
|
|
|
+ raise PrimitiveFinished(reverse)
|
|
|
+
|
|
|
+def dict_eq(a, b, **remainder):
|
|
|
+ key_nodes, = yield [("RDK", [a])]
|
|
|
+ key_values = yield [("RV", [i]) for i in key_nodes]
|
|
|
+ values = yield [("RD", [a, i]) for i in key_values]
|
|
|
+ values = yield [("RV", [i]) for i in values]
|
|
|
+ a_dict = dict(zip(key_values, values))
|
|
|
+
|
|
|
+ key_nodes, = yield [("RDK", [b])]
|
|
|
+ key_values = yield [("RV", [i]) for i in key_nodes]
|
|
|
+ values = yield [("RD", [b, i]) for i in key_values]
|
|
|
+ values = yield [("RV", [i]) for i in values]
|
|
|
+ b_dict = dict(zip(key_values, values))
|
|
|
+
|
|
|
+ result, = yield [("CNV", [a_dict == b_dict])]
|
|
|
+ raise PrimitiveFinished(result)
|
|
|
+
|
|
|
+def string_substr(a, b, c, **remainder):
|
|
|
+ a_val, b_val, c_val = yield [("RV", [a]),
|
|
|
+ ("RV", [b]),
|
|
|
+ ("RV", [c])]
|
|
|
+ try:
|
|
|
+ new_value = a_val[b_val:c_val]
|
|
|
+ except:
|
|
|
+ new_value = ""
|
|
|
+
|
|
|
+ result, = yield [("CNV", [new_value])]
|
|
|
+ raise PrimitiveFinished(result)
|
