/**
* Generates the relation field over the model sigs for called relations Must be run before the
* relation constraint is created (otherwise recursive calls will fail)
*
* @return the Alloy field for this relation
* @throws EchoError
* @todo Support for n models
*/
private Field addRelationFields() throws EchoError {
Field field = null;
Decl fst = rootvar2alloydecl.get(relation.getDomains().get(0).getRootVariable().getName());
/*Decl snd = rootvar2alloydecl.get(relation.getDomains().get(1)
.getVariable().getName());*/
try {
Sig s = (Sig) fst.expr.type().toExpr();
for (Field f : s.getFields()) {
if (f.label.equals(AlloyUtil.relationFieldName(relation, dependency.target))) field = f;
}
if (field == null) {
field =
s.addField(
AlloyUtil.relationFieldName(relation, dependency.target),
/*type.setOf()*/ Sig.UNIV.setOf());
}
} catch (Err a) {
throw new ErrorAlloy(
ErrorAlloy.FAIL_CREATE_FIELD,
"Failed to create relation field representation: " + relation.getName(),
a,
Task.TRANSLATE_TRANSFORMATION);
}
return field;
}
/**
* Computes the bounds for sigs/fields, then construct a BoundsComputer object that you can query.
*/
private BoundsComputer(A4Reporter rep, A4Solution sol, ScopeComputer sc, Iterable<Sig> sigs)
throws Err {
this.sc = sc;
this.factory = sol.getFactory();
this.rep = rep;
this.sol = sol;
// Figure out the sig bounds
final Universe universe = factory.universe();
final int atomN = universe.size();
final List<Tuple> atoms = new ArrayList<Tuple>(atomN);
for (int i = atomN - 1; i >= 0; i--) atoms.add(factory.tuple(universe.atom(i)));
for (Sig s : sigs) if (!s.builtin && s.isTopLevel()) computeLowerBound(atoms, (PrimSig) s);
for (Sig s : sigs) if (!s.builtin && s.isTopLevel()) computeUpperBound((PrimSig) s);
// Bound the sigs
for (Sig s : sigs) if (!s.builtin && s.isTopLevel()) allocatePrimSig((PrimSig) s);
for (Sig s : sigs) if (s instanceof SubsetSig) allocateSubsetSig((SubsetSig) s);
// Bound the fields
again:
for (Sig s : sigs) {
while (s.isOne != null
&& s.getFieldDecls().size() == 2
&& s.getFields().size() == 2
&& s.getFacts().size() == 1) {
// Let's check whether this is a total ordering on an enum...
Expr fact = s.getFacts().get(0).deNOP(),
b1 = s.getFieldDecls().get(0).expr.deNOP(),
b2 = s.getFieldDecls().get(1).expr.deNOP(),
b3;
if (!(fact instanceof ExprList)
|| !(b1 instanceof ExprUnary)
|| !(b2 instanceof ExprBinary)) break;
ExprList list = (ExprList) fact;
if (list.op != ExprList.Op.TOTALORDER || list.args.size() != 3) break;
if (((ExprUnary) b1).op != ExprUnary.Op.SETOF) break;
else b1 = ((ExprUnary) b1).sub.deNOP();
if (((ExprBinary) b2).op != ExprBinary.Op.ARROW) break;
else {
b3 = ((ExprBinary) b2).right.deNOP();
b2 = ((ExprBinary) b2).left.deNOP();
}
if (!(b1 instanceof PrimSig) || b1 != b2 || b1 != b3) break;
PrimSig sub = (PrimSig) b1;
Field f1 = s.getFields().get(0), f2 = s.getFields().get(1);
if (sub.isEnum == null
|| !list.args.get(0).isSame(sub)
|| !list.args.get(1).isSame(s.join(f1))
|| !list.args.get(2).isSame(s.join(f2))) break;
// Now, we've confirmed it is a total ordering on an enum. Let's pre-bind the relations
TupleSet me = sol.query(true, sol.a2k(s), false),
firstTS = factory.noneOf(2),
lastTS = null,
nextTS = factory.noneOf(3);
if (me.size() != 1 || me.arity() != 1) break;
int n = sub.children().size();
for (PrimSig c : sub.children()) {
TupleSet TS = sol.query(true, sol.a2k(c), false);
if (TS.size() != 1 || TS.arity() != 1) {
firstTS = factory.noneOf(2);
nextTS = factory.noneOf(3);
break;
}
if (lastTS == null) {
firstTS = me.product(TS);
lastTS = TS;
continue;
}
nextTS.addAll(me.product(lastTS).product(TS));
lastTS = TS;
}
if (firstTS.size() != (n > 0 ? 1 : 0) || nextTS.size() != n - 1) break;
sol.addField(f1, sol.addRel(s.label + "." + f1.label, firstTS, firstTS));
sol.addField(f2, sol.addRel(s.label + "." + f2.label, nextTS, nextTS));
rep.bound("Field " + s.label + "." + f1.label + " == " + firstTS + "\n");
rep.bound("Field " + s.label + "." + f2.label + " == " + nextTS + "\n");
continue again;
}
for (Field f : s.getFields()) {
boolean isOne = s.isOne != null;
if (isOne && f.decl().expr.mult() == ExprUnary.Op.EXACTLYOF) {
Expression sim = sim(f.decl().expr);
if (sim != null) {
rep.bound("Field " + s.label + "." + f.label + " defined to be " + sim + "\n");
sol.addField(f, sol.a2k(s).product(sim));
continue;
}
}
Type t = isOne ? Sig.UNIV.type().join(f.type()) : f.type();
TupleSet ub = factory.noneOf(t.arity());
for (List<PrimSig> p : t.fold()) {
TupleSet upper = null;
for (PrimSig b : p) {
TupleSet tmp = sol.query(true, sol.a2k(b), false);
if (upper == null) upper = tmp;
else upper = upper.product(tmp);
}
ub.addAll(upper);
}
Relation r = sol.addRel(s.label + "." + f.label, null, ub);
sol.addField(f, isOne ? sol.a2k(s).product(r) : r);
}
}
// Add any additional SIZE constraints
for (Sig s : sigs)
if (!s.builtin) {
Expression exp = sol.a2k(s);
TupleSet upper = sol.query(true, exp, false), lower = sol.query(false, exp, false);
final int n = sc.sig2scope(s);
if (s.isOne != null && (lower.size() != 1 || upper.size() != 1)) {
rep.bound("Sig " + s + " in " + upper + " with size==1\n");
sol.addFormula(exp.one(), s.isOne);
continue;
}
if (s.isSome != null && lower.size() < 1) sol.addFormula(exp.some(), s.isSome);
if (s.isLone != null && upper.size() > 1) sol.addFormula(exp.lone(), s.isLone);
if (n < 0) continue; // This means no scope was specified
if (lower.size() == n && upper.size() == n && sc.isExact(s)) {
rep.bound("Sig " + s + " == " + upper + "\n");
} else if (sc.isExact(s)) {
rep.bound("Sig " + s + " in " + upper + " with size==" + n + "\n");
sol.addFormula(size(s, n, true), Pos.UNKNOWN);
} else if (upper.size() <= n) {
rep.bound("Sig " + s + " in " + upper + "\n");
} else {
rep.bound("Sig " + s + " in " + upper + " with size<=" + n + "\n");
sol.addFormula(size(s, n, false), Pos.UNKNOWN);
}
}
}
