def execute(self) -> None:
try:
ExecutionUnit.execute(self)
except RuntimeException as e:
e.set_statement(self.stmt)
raise AttributeException(self.stmt, self.instance,
self.stmt.attribute_name, e)
def __init__(self, queue_scheduler: QueueScheduler, resolver: Resolver,
result: ResultVariable, requires: typing.Dict[object,
ResultVariable],
expression: ExpressionStatement, stmt: Statement,
instance: Instance) -> None:
ExecutionUnit.__init__(self, queue_scheduler, resolver, result,
requires, expression)
self.stmt = stmt
self.instance = instance
def test_slots_rt():
ns = Namespace("root", None)
rs = Resolver(ns)
e = Entity("xx", ns)
qs = QueueScheduler(None, [], [], None, set())
r = RelationAttribute(e, None, "xx", Location("", 1))
i = Instance(e, rs, qs)
assert_slotted(ResultVariable())
assert_slotted(AttributeVariable(None, None))
assert_slotted(Promise(None, None))
assert_slotted(ListVariable(r, i, qs))
assert_slotted(OptionVariable(r, i, qs))
assert_slotted(qs)
assert_slotted(DelegateQueueScheduler(qs, None))
assert_slotted(Waiter(qs))
assert_slotted(
ExecutionUnit(qs, r, ResultVariable(), {}, Literal(""), None))
assert_slotted(HangUnit(qs, r, {}, None, Resumer()))
assert_slotted(RawUnit(qs, r, {}, Resumer()))
assert_slotted(FunctionUnit(qs, rs, ResultVariable(), {}, None))
assert_slotted(i)
def resume(self, requires: Dict[object, ResultVariable],
resolver: Resolver, queue_scheduler: QueueScheduler,
target: ResultVariable) -> None:
"""
Instance is ready to execute, do it and see if the attribute is already present
"""
# get the Instance
obj = self.instance.execute(requires, resolver, queue_scheduler)
if isinstance(obj, list):
raise RuntimeException(
self, "can not get a attribute %s, %s is a list" %
(self.attribute, obj))
if not isinstance(obj, Instance):
raise RuntimeException(
self, "can not get a attribute %s, %s not an entity" %
(self.attribute, obj))
# get the attribute result variable
attr = obj.get_attribute(self.attribute)
# Cache it
self.attr = attr
if attr.is_ready():
# go ahead
# i.e. back to the AttributeReference itself
self.target.set_value(attr.get_value(), self.location)
else:
# reschedule on the attribute, XU will assign it to the target variable
if self.resultcollector is not None:
attr.listener(self.resultcollector, self.location)
ExecutionUnit(queue_scheduler, resolver, self.target, {"x": attr},
self)
def requires_emit_gradual(
self, resolver: Resolver, queue: QueueScheduler, resultcollector: Optional[ResultCollector]
) -> typing.Dict[object, ResultVariable]:
if resultcollector is None:
return self.requires_emit(resolver, queue)
# if we are in gradual mode, transform to a list of assignments instead of assignment of a list
# to get more accurate gradual execution
# temp variable is required get all heuristics right
# ListVariable to hold all the stuff. Used as a proxy for gradual execution and to track promises.
# Freezes itself once all promises have been fulfilled, at which point it represents the full list literal created by
# this statement.
temp = ListLiteral(queue)
# add listener for gradual execution
temp.listener(resultcollector, self.location)
# Assignments, wired for gradual
for expr in self.items:
ExecutionUnit(queue, resolver, temp, expr.requires_emit_gradual(resolver, queue, temp), expr, self)
if not self.items:
# empty: just close
temp.freeze()
# pass temp
return {self: temp}
def resume(self, requires, resolver, queue, target):
result = self.children[0].execute(requires, resolver, queue)
if self._is_final(result):
target.set_value(result, self.location)
else:
ExecutionUnit(queue, resolver, target,
self.children[1].requires_emit(resolver, queue),
self.children[1])
def resume(self, requires: Dict[object, object], resolver: Resolver, queue: QueueScheduler, target: ResultVariable) -> None:
result = self.children[0].execute(requires, resolver, queue)
self._validate_value(result, 0)
assert isinstance(result, bool)
if self._is_final(result):
target.set_value(result, self.location)
else:
ExecutionUnit(
queue, resolver, target, self.children[1].requires_emit(resolver, queue), self.children[1], owner=self
)
def emit_expression(self, stmt):
"""
Add a new statement
"""
self.owner.copy_location(stmt)
stmt.normalize(self.resolver)
reqs = stmt.requires_emit(self.resolver, self.queue)
ExecutionUnit(self.queue,
self.resolver,
self.result,
reqs,
stmt,
provides=False)
def emit(self, resolver: Resolver, queue: QueueScheduler) -> None:
target = resolver.lookup(self.name)
reqs = self.value.requires_emit(resolver, queue)
ExecutionUnit(queue, resolver, target, reqs, self.value)
def emit(self, resolver: Resolver, queue: QueueScheduler) -> None:
target = ResultVariable()
reqs = self.requires_emit(resolver, queue)
ExecutionUnit(queue, resolver, target, reqs, self)
def emit(self, resolver: Resolver, queue: QueueScheduler) -> None:
for rv, exp in self.annotation_expression:
reqs = exp.requires_emit(resolver, queue)
ExecutionUnit(queue, resolver, rv, reqs, exp)
def emit(self, resolver: Resolver, queue: QueueScheduler) -> None:
self._add_to_dataflow_graph(resolver.dataflow_graph)
target = resolver.lookup(str(self.name))
assert isinstance(target, ResultVariable)
reqs = self.value.requires_emit(resolver, queue)
ExecutionUnit(queue, resolver, target, reqs, self.value, owner=self)