Examples with Expr edu.mit.csail.sdg.ast.Expr used on opensource projects

Example 36 with Expr

use of edu.mit.csail.sdg.ast.Expr in project org.alloytools.alloy by AlloyTools.

the class SimInstance method visit.

/**
 * {@inheritDoc}
 */
@Override
public SimTupleset visit(Sig x) throws Err {
    if (x.isSame(Sig.NONE))
        return SimTupleset.EMPTY;
    if (x.isSame(Sig.SEQIDX))
        return SimTupleset.make(0, maxseq - 1);
    if (x.isSame(Sig.SIGINT))
        return SimTupleset.make(min, max);
    if (x.isSame(Sig.STRING)) {
        if (cacheSTRING == null) {
            cacheSTRING = SimTupleset.EMPTY;
            for (Map.Entry<Expr, SimTupleset> e : sfs.entrySet()) if (e.getKey() instanceof Field || e.getKey() instanceof ExprVar) {
                for (SimTuple t : e.getValue()) for (int i = t.arity() - 1; i >= 0; i--) {
                    String a = t.get(i).toString();
                    if (a.length() > 0 && a.charAt(0) == '"')
                        cacheSTRING = cacheSTRING.union(SimTuple.make(t.get(i)));
                }
            }
        }
        return cacheSTRING;
    }
    if (x == Sig.UNIV) {
        if (cacheUNIV == null) {
            cacheUNIV = SimTupleset.make(min, max);
            for (Map.Entry<Expr, SimTupleset> e : sfs.entrySet()) if (e.getKey() instanceof PrimSig && ((PrimSig) (e.getKey())).isTopLevel())
                cacheUNIV = cacheUNIV.union(e.getValue());
            cacheUNIV = cacheUNIV.union(visit(Sig.STRING));
        }
        return cacheUNIV;
    }
    Object ans = sfs.get(x);
    if (ans instanceof SimTupleset)
        return (SimTupleset) ans;
    else
        throw new ErrorFatal("Unknown sig " + x + " encountered during evaluation.");
}

Example 37 with Expr

use of edu.mit.csail.sdg.ast.Expr in project org.alloytools.alloy by AlloyTools.

the class A4Solution method highLevelCore.

/**
 * If this solution is unsatisfiable and its unsat core is available, then
 * return the core; else return an empty set.
 */
public Pair<Set<Pos>, Set<Pos>> highLevelCore() {
    if (hCoreCache != null)
        return hCoreCache;
    Set<Pos> ans1 = new LinkedHashSet<Pos>(), ans2 = new LinkedHashSet<Pos>();
    if (hCore != null)
        for (Node f : hCore) {
            Object x = k2pos(f);
            if (x instanceof Pos) {
                // System.out.println("F: "+f+" at "+x+"\n");
                // System.out.flush();
                ans1.add((Pos) x);
            } else if (x instanceof Expr) {
                Expr expr = (Expr) x;
                Pos p = ((Expr) x).span();
                ans1.add(p);
                // System.out.flush();
                for (Func func : expr.findAllFunctions()) ans2.add(func.getBody().span());
            }
        }
    return hCoreCache = new Pair<Set<Pos>, Set<Pos>>(Collections.unmodifiableSet(ans1), Collections.unmodifiableSet(ans2));
}

Example 38 with Expr

use of edu.mit.csail.sdg.ast.Expr in project org.alloytools.alloy by AlloyTools.

the class A4SolutionWriter method writeExpr.

/**
 * Write the given Expr and its Type.
 */
private boolean writeExpr(String prefix, Expr expr) throws Err {
    Type type = expr.type();
    if (!type.hasTuple())
        return false;
    if (sol != null) {
        // Check to see if the tupleset is *really* fully contained inside
        // "type".
        // If not, then grow "type" until the tupleset is fully contained
        // inside "type"
        Expr sum = type.toExpr();
        int lastSize = (-1);
        while (true) {
            A4TupleSet ts = (A4TupleSet) (sol.eval(expr.minus(sum)));
            int n = ts.size();
            if (n <= 0)
                break;
            if (lastSize > 0 && lastSize <= n)
                throw new ErrorFatal("An internal error occurred in the evaluator.");
            lastSize = n;
            Type extra = ts.iterator().next().type();
            type = type.merge(extra);
            sum = sum.plus(extra.toExpr());
        }
        // Now, write out the tupleset
        A4TupleSet ts = (A4TupleSet) (sol.eval(expr));
        for (A4Tuple t : ts) {
            if (prefix.length() > 0) {
                out.print(prefix);
                prefix = "";
            }
            out.print("   <tuple>");
            for (int i = 0; i < t.arity(); i++) Util.encodeXMLs(out, " <atom label=\"", t.atom(i), "\"/>");
            out.print(" </tuple>\n");
        }
    }
    // Now, write out the type
    if (prefix.length() > 0)
        return false;
    for (List<PrimSig> ps : type.fold()) {
        out.print("   <types>");
        for (PrimSig sig : ps) Util.encodeXMLs(out, " <type ID=\"", map(sig), "\"/>");
        out.print(" </types>\n");
    }
    return true;
}

Example 39 with Expr

use of edu.mit.csail.sdg.ast.Expr in project org.alloytools.alloy by AlloyTools.

the class CompModule method resolveFacts.

/**
 * Each fact name now points to a typechecked Expr rather than an untypechecked
 * Exp; we'll also add the sig appended facts.
 */
private JoinableList<Err> resolveFacts(CompModule res, A4Reporter rep, JoinableList<Err> errors, List<ErrorWarning> warns) throws Err {
    Context cx = new Context(this, warns);
    for (int i = 0; i < facts.size(); i++) {
        String name = facts.get(i).a;
        Expr expr = facts.get(i).b;
        Expr checked = cx.check(expr);
        expr = checked.resolve_as_formula(warns);
        if (expr.errors.isEmpty()) {
            facts.set(i, new Pair<String, Expr>(name, expr));
            rep.typecheck("Fact " + name + ": " + expr.type() + "\n");
        } else
            errors = errors.make(expr.errors);
    }
    for (Sig s : sigs.values()) {
        Expr f = res.old2appendedfacts.get(res.new2old.get(s));
        if (f == null)
            continue;
        if (f instanceof ExprConstant && ((ExprConstant) f).op == ExprConstant.Op.TRUE)
            continue;
        Expr formula;
        cx.rootsig = s;
        if (s.isOne == null) {
            cx.put("this", s.decl.get());
            formula = cx.check(f).resolve_as_formula(warns);
        } else {
            cx.put("this", s);
            formula = cx.check(f).resolve_as_formula(warns);
        }
        cx.remove("this");
        if (formula.errors.size() > 0)
            errors = errors.make(formula.errors);
        else {
            s.addFact(formula);
            rep.typecheck("Fact " + s + "$fact: " + formula.type() + "\n");
        }
    }
    return errors;
}

Example 40 with Expr

use of edu.mit.csail.sdg.ast.Expr in project org.alloytools.alloy by AlloyTools.

the class TranslateAlloyToKodkod method visit_qt.

/**
 * Helper method that translates the quantification expression "op vars | sub"
 */
private Object visit_qt(final ExprQt.Op op, final ConstList<Decl> xvars, final Expr sub) throws Err {
    if (op == ExprQt.Op.NO) {
        return visit_qt(ExprQt.Op.ALL, xvars, sub.not());
    }
    if (op == ExprQt.Op.ONE || op == ExprQt.Op.LONE) {
        boolean ok = true;
        for (int i = 0; i < xvars.size(); i++) {
            Expr v = addOne(xvars.get(i).expr).deNOP();
            if (v.type().arity() != 1 || v.mult() != ExprUnary.Op.ONEOF) {
                ok = false;
                break;
            }
        }
        if (op == ExprQt.Op.ONE && ok)
            return ((Expression) visit_qt(ExprQt.Op.COMPREHENSION, xvars, sub)).one();
        if (op == ExprQt.Op.LONE && ok)
            return ((Expression) visit_qt(ExprQt.Op.COMPREHENSION, xvars, sub)).lone();
    }
    if (op == ExprQt.Op.ONE) {
        Formula f1 = (Formula) visit_qt(ExprQt.Op.LONE, xvars, sub);
        Formula f2 = (Formula) visit_qt(ExprQt.Op.SOME, xvars, sub);
        return f1.and(f2);
    }
    if (op == ExprQt.Op.LONE) {
        QuantifiedFormula p1 = (QuantifiedFormula) visit_qt(ExprQt.Op.ALL, xvars, sub);
        QuantifiedFormula p2 = (QuantifiedFormula) visit_qt(ExprQt.Op.ALL, xvars, sub);
        Decls s1 = p1.decls(), s2 = p2.decls(), decls = null;
        Formula f1 = p1.formula(), f2 = p2.formula();
        Formula[] conjuncts = new Formula[s1.size()];
        for (int i = 0; i < conjuncts.length; i++) {
            kodkod.ast.Decl d1 = s1.get(i), d2 = s2.get(i);
            conjuncts[i] = d1.variable().eq(d2.variable());
            if (decls == null)
                decls = d1.and(d2);
            else
                decls = decls.and(d1).and(d2);
        }
        return f1.and(f2).implies(Formula.and(conjuncts)).forAll(decls);
    }
    Decls dd = null;
    List<Formula> guards = new ArrayList<Formula>();
    for (Decl dep : xvars) {
        final Expr dexexpr = addOne(dep.expr);
        final Expression dv = cset(dexexpr);
        for (ExprHasName dex : dep.names) {
            final Variable v = Variable.nary(skolem(dex.label), dex.type().arity());
            final kodkod.ast.Decl newd;
            env.put((ExprVar) dex, v);
            if (dex.type().arity() != 1) {
                guards.add(isIn(v, dexexpr));
                newd = v.setOf(dv);
            } else
                switch(dexexpr.mult()) {
                    case SETOF:
                        newd = v.setOf(dv);
                        break;
                    case SOMEOF:
                        newd = v.someOf(dv);
                        break;
                    case LONEOF:
                        newd = v.loneOf(dv);
                        break;
                    default:
                        newd = v.oneOf(dv);
                }
            if (frame != null)
                frame.kv2typepos(v, dex.type(), dex.pos);
            if (dd == null)
                dd = newd;
            else
                dd = dd.and(newd);
        }
    }
    final Formula ans = (op == ExprQt.Op.SUM) ? null : cform(sub);
    final IntExpression ians = (op != ExprQt.Op.SUM) ? null : cint(sub);
    for (Decl d : xvars) for (ExprHasName v : d.names) env.remove((ExprVar) v);
    if (op == ExprQt.Op.COMPREHENSION)
        // guards.size()==0, since each var
        return ans.comprehension(dd);
    // has to be unary
    if (op == ExprQt.Op.SUM)
        // guards.size()==0, since each var has to be
        return ians.sum(dd);
    // unary
    if (op == ExprQt.Op.SOME) {
        if (guards.size() == 0)
            return ans.forSome(dd);
        guards.add(ans);
        return Formula.and(guards).forSome(dd);
    } else {
        if (guards.size() == 0)
            return ans.forAll(dd);
        return Formula.and(guards).implies(ans).forAll(dd);
    }
}