def env_node(env):
"""
Return the node associated to this environment.
:param AbstractExpression env: The source environment.
"""
return BasicExpr('{}.Node', T.root_node, [construct(env, LexicalEnvType)])
def make_expr(cls, lhs, rhs, abstract_expr=None):
if lhs.type.is_entity_type:
return cls.make_expr_for_entities(lhs, rhs, abstract_expr)
elif lhs.type.has_equivalent_function:
return CallExpr('Is_Equal', 'Equivalent', T.Bool, [lhs, rhs],
abstract_expr=abstract_expr)
else:
return BasicExpr('Is_Equal', '{} = {}', T.Bool, [lhs, rhs],
abstract_expr=abstract_expr)
def construct(self):
return BasicExpr(
"Logic_{} (Relation_Array ({{}}.Items))".format(
"Any" if self.kind == self.KIND_OR else "All"
),
EquationType,
[construct(self.equation_array, EquationType.array_type())],
result_var_name="Logic_Boolean_Op"
)
def make_expr(expr):
return BasicExpr('not ({})', BoolType, [expr])
def make_expr(lhs, rhs):
return BasicExpr('{} = {}', BoolType, [lhs, rhs])
def construct(self):
check_multiple([
(isinstance(self.pred_property, PropertyDef),
"Needs a property reference, got {}".format(self.pred_property)),
(self.pred_property.type.matches(BoolType),
"The property passed to predicate must return a boolean, "
"got {}".format(self.pred_property.type.name().camel)),
(self.pred_property.struct.matches(T.root_node),
"The property passed to bind must belong to a subtype "
"of {}".format(T.root_node.name().camel))
])
exprs = [construct(e) for e in self.exprs]
prop_types = [self.pred_property.struct] + [
a.type for a in self.pred_property.explicit_arguments
]
# Separate logic variable expressions from extra argument expressions
logic_var_exprs, closure_exprs = funcy.split_by(
lambda e: e.type == LogicVarType, exprs
)
check_source_language(
len(logic_var_exprs) > 0, "Predicate instantiation should have at "
"least one logic variable expression"
)
check_source_language(
all(e.type != LogicVarType for e in closure_exprs), "Logic "
"variable expressions should be grouped at the beginning, and "
"should not appear after non logic variable expressions"
)
for i, (expr, arg_type) in enumerate(zip(exprs, prop_types)):
if expr.type == LogicVarType:
check_source_language(
arg_type.matches(T.root_node), "Argument #{} of predicate "
"is a logic variable, the corresponding property formal "
"has type {}, but should be a descendent of {}".format(
i, arg_type.name().camel, T.root_node.name().camel
)
)
else:
check_source_language(
expr.type.matches(arg_type), "Argument #{} of predicate "
"has type {}, should be {}".format(
i, expr.type.name().camel, arg_type.name().camel
)
)
pred_id = self.pred_property.do_generate_logic_predicate(*[
e.type for e in closure_exprs
])
closure_exprs.append(construct(Env))
# Append the debug image for the predicate
closure_exprs.append(LiteralExpr('"{}.{}"'.format(
self.pred_property.name.camel_with_underscores,
self.pred_property.struct.name().camel_with_underscores
), type=None))
logic_var_exprs.append(
BasicExpr("{}_Predicate_Caller'({})".format(
pred_id, ", ".join(
["{}" for _ in range(len(closure_exprs) - 2)]
+ ["Env => {}, "
"Dbg_Img => (if Debug then new String'({})"
" else null)"]
)
), type=None, operands=closure_exprs)
)
return BuiltinCallExpr(
"{}_Pred.Create".format(pred_id), EquationType, logic_var_exprs,
result_var_name="Pred"
)
