use of com.rockwellcollins.atc.agree.analysis.AgreeException in project AGREE by loonwerks.
the class EvaluateSwitch method lookupMethod.
private java.lang.reflect.Method lookupMethod(com.rockwellcollins.atc.agree.agree.LibraryFnDef nativeDef) {
java.lang.reflect.Method result = nativeCallMap.get(nativeDef);
final String containingClassName = "java.lang.Math";
if (result == null) {
String methodName = nativeDef.getName();
try {
Class<?> containingClass = java.lang.Class.forName(containingClassName);
// Class<?> returnClass = double.class;
Class<?>[] parameterTypes = new Class<?>[] { double.class };
result = containingClass.getMethod(methodName, parameterTypes);
if (Modifier.isStatic(result.getModifiers())) {
nativeCallMap.put(nativeDef, result);
} else {
throw new AgreeException("Method '" + methodName + "' is not static");
}
} catch (SecurityException e) {
e.printStackTrace();
throw new AgreeException("Cannot resolve method '" + methodName + "' due to security violation: " + e.getMessage());
} catch (ClassNotFoundException e) {
e.printStackTrace();
throw new AgreeException("Cannot resolve class '" + containingClassName + "': " + e.getMessage());
} catch (NoSuchMethodException e) {
e.printStackTrace();
throw new AgreeException("Cannot resolve method '" + methodName + "': " + e.getMessage());
}
}
return result;
}
use of com.rockwellcollins.atc.agree.analysis.AgreeException in project AGREE by loonwerks.
the class AgreeNodeToLustreContract method nodeAssertsToEqs.
private static List<Equation> nodeAssertsToEqs(AgreeNode agreeNode) {
List<Equation> eqs = new ArrayList<>();
for (AgreeStatement statement : agreeNode.assertions) {
if (AgreeUtils.referenceIsInContract(statement.reference, agreeNode.compInst)) {
BinaryExpr expr = (BinaryExpr) statement.expr;
if ((expr.op != BinaryOp.EQUAL)) {
throw new AgreeException("Unexpected expression type in AGREE AST asssertion");
}
Expr leftExpr = expr.left;
Expr rightExpr = expr.right;
List<IdExpr> ids = new ArrayList<>();
if (leftExpr instanceof TupleExpr) {
TupleExpr tuple = (TupleExpr) leftExpr;
for (Expr element : tuple.elements) {
ids.add((IdExpr) element);
}
} else {
ids.add((IdExpr) leftExpr);
}
eqs.add(new Equation(ids, rightExpr));
}
}
return eqs;
}
use of com.rockwellcollins.atc.agree.analysis.AgreeException in project AGREE by loonwerks.
the class LustreAstBuilder method getRealizabilityLustreProgram.
// private static AgreeProgram translate(AgreeProgram program){
// return AgreeInlineLatchedConnections.translate(program);
// }
public static Program getRealizabilityLustreProgram(AgreeProgram agreeProgram) {
List<TypeDef> types = AgreeUtils.getLustreTypes(agreeProgram);
List<Expr> assertions = new ArrayList<>();
List<VarDecl> locals = new ArrayList<>();
List<VarDecl> inputs = new ArrayList<>();
List<Equation> equations = new ArrayList<>();
List<String> properties = new ArrayList<>();
AgreeNode topNode = agreeProgram.topNode;
for (AgreeStatement assumption : topNode.assumptions) {
assertions.add(assumption.expr);
}
int i = 0;
for (AgreeStatement guarantee : topNode.guarantees) {
String guarName = guarSuffix + i++;
locals.add(new AgreeVar(guarName, NamedType.BOOL, guarantee.reference, topNode.compInst, null));
equations.add(new Equation(new IdExpr(guarName), guarantee.expr));
properties.add(guarName);
}
List<String> inputStrs = new ArrayList<>();
for (AgreeVar var : topNode.inputs) {
inputs.add(var);
inputStrs.add(var.id);
}
for (AgreeVar var : topNode.outputs) {
inputs.add(var);
}
// and type equations. This would clear this up
for (AgreeStatement statement : topNode.assertions) {
if (AgreeUtils.referenceIsInContract(statement, topNode.compInst)) {
// this is a strange hack we have to do. we have to make
// equation and property
// statements not assertions. They should all be binary
// expressions with an
// equals operator. We will need to removing their corresponding
// variable
// from the inputs and add them to the local variables
BinaryExpr binExpr;
IdExpr varId;
try {
binExpr = (BinaryExpr) statement.expr;
varId = (IdExpr) binExpr.left;
} catch (ClassCastException e) {
// some equation variables are assertions for
// subrange types. do not translate these to
// local equations. Just add them to assertions
assertions.add(statement.expr);
continue;
}
boolean found = false;
int index;
for (index = 0; index < inputs.size(); index++) {
VarDecl var = inputs.get(index);
if (var.id.equals(varId.id)) {
found = true;
break;
}
}
if (!found || binExpr.op != BinaryOp.EQUAL) {
throw new AgreeException("Something went very wrong with the lustre generation in the realizability analysis");
}
locals.add(inputs.remove(index));
equations.add(new Equation(varId, binExpr.right));
}
}
NodeBuilder builder = new NodeBuilder("main");
builder.addInputs(inputs);
builder.addLocals(locals);
builder.addEquations(equations);
builder.addProperties(properties);
builder.addAssertions(assertions);
builder.setRealizabilityInputs(inputStrs);
Node main = builder.build();
List<Node> nodes = new ArrayList<>();
nodes.add(main);
nodes.addAll(agreeProgram.globalLustreNodes);
List<Function> uFunctions = new ArrayList<>();
uFunctions.addAll(agreeProgram.uninterpretedFunctions);
Program program = new ProgramBuilder().addTypes(types).addFunctions(uFunctions).addNodes(nodes).setMain(main.id).build();
return program;
}
use of com.rockwellcollins.atc.agree.analysis.AgreeException in project AGREE by loonwerks.
the class LustreAstBuilder method addInputsAndOutputs.
protected static void addInputsAndOutputs(AgreeNode parentNode, List<AgreeVar> inputs, List<AgreeVar> outputs, List<AgreeStatement> patternProps, AgreeNode subAgreeNode, Node lustreNode, String prefix) {
int varCount = 0;
for (AgreeVar var : subAgreeNode.inputs) {
varCount++;
AgreeVar input = new AgreeVar(prefix + var.id, var.type, var.reference, var.compInst, var.featInst);
inputs.add(input);
}
for (AgreeVar var : subAgreeNode.outputs) {
varCount++;
AgreeVar output = new AgreeVar(prefix + var.id, var.type, var.reference, var.compInst, var.featInst);
outputs.add(output);
}
// for (AgreeVar var : subAgreeNode.locals) {
// varCount++;
// AgreeVar local = new AgreeVar(prefix + var.id, var.type, var.reference, var.compInst, var.featInst);
// outputs.add(local);
// }
int i = 0;
for (AgreeStatement statement : subAgreeNode.assumptions) {
varCount++;
AgreeVar output = new AgreeVar(prefix + assumeSuffix + i++, NamedType.BOOL, statement.reference, subAgreeNode.compInst, null);
outputs.add(output);
}
int k = 0;
for (AgreeStatement statement : subAgreeNode.patternProps) {
varCount++;
AgreeVar output = new AgreeVar(prefix + patternPropSuffix + k++, NamedType.BOOL, statement, subAgreeNode.compInst, null);
patternProps.add(new AgreeStatement(prefix.replace("__", "") + ": " + statement.string, new IdExpr(output.id), statement.reference));
outputs.add(output);
}
// add the assumption history var
varCount++;
outputs.add(new AgreeVar(prefix + assumeSuffix + "__HIST", NamedType.BOOL, null, subAgreeNode.compInst, null));
int j = 0;
for (AgreeStatement statement : subAgreeNode.lemmas) {
varCount++;
AgreeVar output = new AgreeVar(prefix + lemmaSuffix + j++, NamedType.BOOL, statement.reference, subAgreeNode.compInst, null);
outputs.add(output);
}
if (parentNode.timing == TimingModel.ASYNC || parentNode.timing == TimingModel.LATCHED) {
inputs.add(subAgreeNode.clockVar);
varCount++;
}
if (lustreNode.inputs.size() != varCount) {
throw new AgreeException("Something went wrong during node flattening");
}
}
use of com.rockwellcollins.atc.agree.analysis.AgreeException in project AGREE by loonwerks.
the class LustreContractAstBuilder method flattenAgreeNodeKindContract.
protected static AgreeNode flattenAgreeNodeKindContract(AgreeNode agreeNode, String nodePrefix) {
List<AgreeVar> inputs = new ArrayList<>();
List<AgreeVar> outputs = new ArrayList<>();
List<AgreeVar> locals = new ArrayList<>();
List<AgreeStatement> assertions = new ArrayList<>();
Expr someoneTicks = null;
for (AgreeNode subAgreeNode : agreeNode.subNodes) {
String prefix = subAgreeNode.id + AgreeASTBuilder.dotChar;
Expr clockExpr = getClockExpr(agreeNode, subAgreeNode);
if (someoneTicks == null) {
someoneTicks = clockExpr;
} else {
someoneTicks = new BinaryExpr(someoneTicks, BinaryOp.OR, clockExpr);
}
AgreeNode flatNode = flattenAgreeNodeKindContract(subAgreeNode, nodePrefix + subAgreeNode.id + AgreeASTBuilder.dotChar);
Node lustreNode = addSubNodeLustre(agreeNode, nodePrefix, flatNode);
addInputsAndOutputs(inputs, outputs, flatNode, lustreNode, prefix);
addCondactCall(agreeNode, nodePrefix, inputs, assertions, flatNode, prefix, clockExpr, lustreNode);
// addClockHolds(agreeNode, assertions, flatNode, clockExpr, prefix,
// lustreNode);
addInitConstraint(agreeNode, outputs, assertions, flatNode, prefix, clockExpr, lustreNode);
}
if (agreeNode.timing == TimingModel.ASYNC) {
if (someoneTicks == null) {
throw new AgreeException("Somehow we generated a clock constraint without any clocks");
}
assertions.add(new AgreeStatement("someone ticks", someoneTicks, null));
}
addConnectionConstraints(agreeNode, assertions);
// add any clock constraints
assertions.addAll(agreeNode.assertions);
assertions.add(new AgreeStatement("", agreeNode.clockConstraint, null));
inputs.addAll(agreeNode.inputs);
outputs.addAll(agreeNode.outputs);
locals.addAll(agreeNode.locals);
AgreeNodeBuilder builder = new AgreeNodeBuilder(agreeNode.id);
builder.addInput(inputs);
builder.addOutput(outputs);
builder.addLocal(locals);
builder.addLocalEquation(agreeNode.localEquations);
builder.addSubNode(agreeNode.subNodes);
builder.addAssertion(assertions);
builder.addAssumption(agreeNode.assumptions);
builder.addGuarantee(agreeNode.guarantees);
builder.addLemma(agreeNode.lemmas);
builder.addPatternProp(agreeNode.patternProps);
builder.setClockConstraint(new BoolExpr(true));
builder.setInitialConstraint(agreeNode.initialConstraint);
builder.setClockVar(agreeNode.clockVar);
builder.setReference(agreeNode.reference);
builder.setTiming(null);
builder.addEventTime(agreeNode.eventTimes);
builder.setCompInst(agreeNode.compInst);
return builder.build();
}
Aggregations