def unflatten_set_clause(cl): """Opposite of above. Unflatten clauses over the M-set. Works for both enumerators and conditions. Returns the (possibly unchanged) clause. """ # Enumerator case. if isinstance(cl, L.Enumerator): res = get_menum(cl) if res is None: return cl cont, item = res cont = L.ContextSetter.run(cont, L.Load) new_cl = L.Enumerator(item, cont) return new_cl # Condition case. if isinstance(cl, L.expr) and L.is_cmp(cl): lhs, op, rhs = L.get_cmp(cl) if not (isinstance(op, L.In) and isinstance(lhs, L.Tuple) and len(lhs.elts) == 2 and L.is_name(rhs) and is_mrel(L.get_name(rhs))): return cl cont, item = lhs.elts new_cl = L.cmp(item, L.In(), cont) return new_cl return cl
def flatten_set_clause(cl, input_rels): """Turn a membership clause that is not over a comprehension, special relation, or input relation, into a clause over the M-set. Return a pair of the (possibly unchanged) clause and a bool indicating whether or not the change was done. This also works on condition clauses that express membership constraints. The rewritten clause is still a condition clause. """ def should_trans(rhs): return (not isinstance(rhs, L.Comp) and not (isinstance(rhs, L.Name) and (is_specialrel(rhs.id) or rhs.id in input_rels))) # Enumerator case. if isinstance(cl, L.Enumerator) and should_trans(cl.iter): item = cl.target cont = cl.iter cont = L.ContextSetter.run(cont, L.Store) new_cl = L.Enumerator(L.tuplify((cont, item), lval=True), L.ln(make_mrel())) return new_cl, True # Condition case. if isinstance(cl, L.expr) and L.is_cmp(cl): item, op, cont = L.get_cmp(cl) if isinstance(op, L.In) and should_trans(cont): new_cl = L.cmp(L.tuplify((cont, item)), L.In(), L.ln(make_mrel())) return new_cl, True return cl, False
def from_expr(cls, node): """Construct from a condition expression of form <vars> == <rel> """ checktype(node, L.AST) left, op, val = L.get_cmp(node) checktype(op, L.Eq) lhs = L.get_vartuple(left) return cls(lhs, val)
def from_expr(cls, node): """Construct from a condition expression of form <vars> == <rel> """ checktype(node, L.AST) left, op, val = L.get_cmp(node) checktype(op, L.Eq) lhs = L.get_vartuple(left) return cls(lhs, val)
def from_expr(cls, node): """Construct from a membership expression (<var>, <var>) in _M """ checktype(node, L.AST) left, op, right = L.get_cmp(node) checktype(op, L.In) lhs = L.get_vartuple(left) assert len(lhs) == 2 cont, item = lhs rel = L.get_name(right) assert is_mrel(rel) return cls(cont, item)
def from_expr(cls, node): """Construct from a membership expression (<var>, <var>) in _M """ checktype(node, L.AST) left, op, right = L.get_cmp(node) checktype(op, L.In) lhs = L.get_vartuple(left) assert len(lhs) == 2 cont, item = lhs rel = L.get_name(right) assert is_mrel(rel) return cls(cont, item)
def from_expr(cls, node): """Construct from a membership condition expression of form <vars> in <rel> Note that this is syntactically different from the form used in comprehensions, even though their textual representation in source code is the same. """ checktype(node, L.AST) left, op, right = L.get_cmp(node) checktype(op, L.In) lhs = L.get_vartuple(left) rel = L.get_name(right) return cls(lhs, rel)
def from_expr(cls, node): """Construct from a membership condition expression of form <vars> in <rel> Note that this is syntactically different from the form used in comprehensions, even though their textual representation in source code is the same. """ checktype(node, L.AST) left, op, right = L.get_cmp(node) checktype(op, L.In) lhs = L.get_vartuple(left) rel = L.get_name(right) return cls(lhs, rel)
def membercond_to_enum(cls, cl): """For a condition clause that expresses a membership, return an equivalent enumerator clause. For other kinds of conditions, return the same clause. For enumerators, raise TypeError. """ if cl.kind is not Clause.KIND_COND: raise TypeError compre_ast = None clast = cl.to_AST() if L.is_cmp(clast): lhs, op, rhs = L.get_cmp(clast) if (L.is_vartuple(lhs) and isinstance(op, L.In)): compre_ast = L.Enumerator( L.tuplify(L.get_vartuple(lhs), lval=True), rhs) if compre_ast is None: return cl else: return cls.from_AST(compre_ast)
def membercond_to_enum(cls, cl): """For a condition clause that expresses a membership, return an equivalent enumerator clause. For other kinds of conditions, return the same clause. For enumerators, raise TypeError. """ if cl.kind is not Clause.KIND_COND: raise TypeError compre_ast = None clast = cl.to_AST() if L.is_cmp(clast): lhs, op, rhs = L.get_cmp(clast) if (L.is_vartuple(lhs) and isinstance(op, L.In)): compre_ast = L.Enumerator( L.tuplify(L.get_vartuple(lhs), lval=True), rhs) if compre_ast is None: return cl else: return cls.from_AST(compre_ast)