use of com.rockwellcollins.atc.agree.analysis.AgreeException in project AGREE by loonwerks.
the class AgreeASTBuilder method getConnectionsFromInstances.
private List<AgreeAADLConnection> getConnectionsFromInstances(EList<ConnectionInstance> connectionInstances, ComponentInstance compInst, List<AgreeNode> subnodes, boolean latched) {
List<AgreeAADLConnection> result = new ArrayList<>();
for (ConnectionInstance connectionInstance : connectionInstances) {
boolean isDelayed = isDelayed(connectionInstance, compInst);
for (ConnectionReference connectionReference : connectionInstance.getConnectionReferences()) {
ConnectionInstanceEnd sourceEndInstance = connectionReference.getSource();
ConnectionInstanceEnd destinationEndInstance = connectionReference.getDestination();
ComponentInstance sourceComponentInstance = sourceEndInstance.getComponentInstance();
ComponentInstance destinationComponentInstance = destinationEndInstance.getComponentInstance();
if (!compInst.equals(sourceComponentInstance) && !compInst.getComponentInstances().contains(sourceComponentInstance)) {
// This connection reference connects to component instances not germane to this level of hierarchy
continue;
}
if (!compInst.equals(destinationComponentInstance) && !compInst.getComponentInstances().contains(destinationComponentInstance)) {
// This connection reference connects to component instances not germane to this level of hierarchy
continue;
}
// make connections only to subcomponents that have annexes
if (!compInst.equals(sourceComponentInstance) && compInst.getAllComponentInstances().contains(sourceComponentInstance)) {
if (!AgreeUtils.containsTransitiveAgreeAnnex(sourceComponentInstance, isMonolithic)) {
continue;
}
}
if (!compInst.equals(destinationComponentInstance) && compInst.getAllComponentInstances().contains(destinationComponentInstance)) {
if (!AgreeUtils.containsTransitiveAgreeAnnex(destinationComponentInstance, isMonolithic)) {
continue;
}
}
AgreeNode sourceNode = agreeNodeFromNamedEl(subnodes, sourceComponentInstance);
AgreeNode destinationNode = agreeNodeFromNamedEl(subnodes, destinationComponentInstance);
ConnectionEnd sourceConnectionEnd;
if (sourceEndInstance instanceof FeatureInstance) {
sourceConnectionEnd = ((FeatureInstance) sourceEndInstance).getFeature();
} else {
AgreeLogger.logWarning("unable to reason about connection '" + connectionInstance.getQualifiedName() + "' because it connects from a " + sourceEndInstance.getClass().getName());
continue;
}
ConnectionEnd destinationConnectionEnd;
if (destinationEndInstance instanceof FeatureInstance) {
destinationConnectionEnd = ((FeatureInstance) destinationEndInstance).getFeature();
} else {
AgreeLogger.logWarning("unable to reason about connection '" + connectionInstance.getQualifiedName() + "' because it connects to a " + destinationEndInstance.getClass().getName());
continue;
}
// TODO: Paranoia? Is this redundant with the previous lines?
if (sourceConnectionEnd instanceof DataSubcomponent || destinationConnectionEnd instanceof DataSubcomponent) {
AgreeLogger.logWarning("unable to reason about connection '" + connectionInstance.getQualifiedName() + "' because it connects to a data subcomponent");
continue;
}
// Handle prefixing elements of feature groups
String sourcePrefix = null;
if (sourceConnectionEnd instanceof FeatureGroup) {
sourcePrefix = sourceConnectionEnd.getName();
}
String destinationPrefix = null;
if (destinationConnectionEnd instanceof FeatureGroup) {
destinationPrefix = destinationConnectionEnd.getName();
}
List<AgreeVar> sourceVars = getAgreePortNames(sourceConnectionEnd, sourcePrefix, sourceNode == null ? null : sourceNode.compInst);
List<AgreeVar> destinationVars = getAgreePortNames(destinationConnectionEnd, destinationPrefix, destinationNode == null ? null : destinationNode.compInst);
if (sourceVars.size() != destinationVars.size()) {
throw new AgreeException("The number of AGREE variables differ for connection '" + connectionInstance.getQualifiedName() + "'. Do the types of the source and destination differ? Perhaps one is an implementation and the other is a type?");
}
for (int i = 0; i < sourceVars.size(); i++) {
AgreeVar sourceVar = sourceVars.get(i);
AgreeVar destinationVar = destinationVars.get(i);
if (!matches((ConnectionEnd) sourceVar.reference, (ConnectionEnd) destinationVar.reference)) {
AgreeLogger.logWarning("Connection '" + connectionInstance.getQualifiedName() + "' has ports '" + sourceVar.id.replace(dotChar, ".") + "' and '" + destinationVar.id.replace(dotChar, ".") + "' of differing type");
continue;
}
if (!sourceVar.type.equals(destinationVar.type)) {
throw new AgreeException("Type mismatch during connection generation");
}
ConnectionType connType;
if (sourceVar.id.endsWith(eventSuffix)) {
connType = ConnectionType.EVENT;
} else {
connType = ConnectionType.DATA;
}
AgreeAADLConnection agreeConnection = new AgreeAADLConnection(sourceNode, destinationNode, sourceVar, destinationVar, connType, latched, isDelayed, connectionReference.getConnection());
result.add(agreeConnection);
}
}
}
return result;
}
use of com.rockwellcollins.atc.agree.analysis.AgreeException in project AGREE by loonwerks.
the class AgreeASTBuilder method filterConnections.
private List<AgreeConnection> filterConnections(List<AgreeAADLConnection> aadlConnections, List<AgreeOverriddenConnection> userDefinedConections) {
List<AgreeConnection> conns = new ArrayList<>();
// connection twice
for (AgreeAADLConnection aadlConn : aadlConnections) {
EObject aadlRef = aadlConn.reference;
AgreeConnection replacementConn = aadlConn;
for (AgreeOverriddenConnection agreeConn : userDefinedConections) {
EObject agreeRef = agreeConn.aadlConn;
if (aadlRef == agreeRef) {
replacementConn = agreeConn;
break;
}
}
if (!conns.contains(replacementConn)) {
conns.add(replacementConn);
}
}
// throw errors for non-override connections with multiple fanin
Set<AgreeVar> destinations = new HashSet<>();
for (AgreeConnection conn : conns) {
if (conn instanceof AgreeAADLConnection) {
AgreeAADLConnection aadlConn = (AgreeAADLConnection) conn;
if (!destinations.add(aadlConn.destinationVarName)) {
String message = "Multiple connections to feature '" + (aadlConn.reference instanceof PortConnection ? ((PortConnection) aadlConn.reference).getDestination().getConnectionEnd().getQualifiedName() : aadlConn.destinationVarName) + "'. Remove the additional AADL connections or override them with a connection statement " + "in the AGREE annex.";
throw new AgreeException(message);
}
}
}
return conns;
}
use of com.rockwellcollins.atc.agree.analysis.AgreeException in project AGREE by loonwerks.
the class VerifyHandler method wrapVerificationResult.
protected void wrapVerificationResult(ComponentInstance si, CompositeAnalysisResult wrapper) {
AgreeProgram agreeProgram = new AgreeASTBuilder().getAgreeProgram(si, isMonolithic());
// generate different lustre depending on which model checker we are
// using
Program program;
if (AgreeUtils.usingKind2()) {
if (!isMonolithic()) {
throw new AgreeException("Kind2 now only supports monolithic verification");
}
program = LustreContractAstBuilder.getContractLustreProgram(agreeProgram);
} else {
program = LustreAstBuilder.getAssumeGuaranteeLustreProgram(agreeProgram);
}
List<Pair<String, Program>> consistencies = LustreAstBuilder.getConsistencyChecks(agreeProgram);
wrapper.addChild(createVerification("Contract Guarantees", si, program, agreeProgram, AnalysisType.AssumeGuarantee));
for (Pair<String, Program> consistencyAnalysis : consistencies) {
wrapper.addChild(createVerification(consistencyAnalysis.getFirst(), si, consistencyAnalysis.getSecond(), agreeProgram, AnalysisType.Consistency));
}
}
use of com.rockwellcollins.atc.agree.analysis.AgreeException in project AGREE by loonwerks.
the class VerifyHandler method createVerification.
private AnalysisResult createVerification(String resultName, ComponentInstance compInst, Program lustreProgram, AgreeProgram agreeProgram, AnalysisType analysisType) {
// ///////
// Logger logger = Logger.getLogger("MyLog");
// FileHandler fh;
// try {
// This block configure the logger with handler and formatter
// fh = new FileHandler("/home/thomas/zzz.log");
// logger.addHandler(fh);
// SimpleFormatter formatter = new SimpleFormatter();
// fh.setFormatter(formatter);
// logger.info("Agree Program:");
// AgreeASTPrettyprinter pp = new AgreeASTPrettyprinter();
// pp.visit(agreeProgram);
// logger.info(pp.toString());
// } catch (SecurityException ex) {
// ex.printStackTrace();
// }
// catch (IOException ex) {
// ex.printStackTrace();
// }
// //////////////
AgreeAutomaterRegistry aAReg = (AgreeAutomaterRegistry) ExtensionRegistry.getRegistry(ExtensionRegistry.AGREE_AUTOMATER_EXT_ID);
List<AgreeAutomater> automaters = aAReg.getAgreeAutomaters();
AgreeRenaming renaming = new AgreeRenaming();
AgreeLayout layout = new AgreeLayout();
Node mainNode = null;
for (Node node : lustreProgram.nodes) {
if (node.id.equals(lustreProgram.main)) {
mainNode = node;
break;
}
}
if (mainNode == null) {
throw new AgreeException("Could not find main lustre node after translation");
}
List<String> properties = new ArrayList<>();
RenamingVisitor.addRenamings(lustreProgram, renaming, compInst, layout);
addProperties(renaming, properties, mainNode, agreeProgram);
for (AgreeAutomater aa : automaters) {
renaming = aa.rename(renaming);
layout = aa.transformLayout(layout);
}
JKindResult result;
switch(analysisType) {
case Consistency:
result = new ConsistencyResult(resultName, mainNode.properties, Collections.singletonList(true), renaming);
break;
case Realizability:
result = new JRealizabilityResult(resultName, renaming);
break;
case AssumeGuarantee:
final Set<String> invertedProperties = renaming.getInvertedProperties();
List<Boolean> invertedPropertyMask = mainNode.properties.stream().map(p -> invertedProperties.contains(p)).collect(Collectors.toList());
result = new JKindResult(resultName, properties, invertedPropertyMask, renaming);
break;
default:
throw new AgreeException("Unhandled Analysis Type");
}
queue.add(result);
ComponentImplementation compImpl = AgreeUtils.getInstanceImplementation(compInst);
linker.setProgram(result, lustreProgram);
linker.setComponent(result, compImpl);
linker.setContract(result, getContract(compImpl));
linker.setLayout(result, layout);
linker.setReferenceMap(result, renaming.getRefMap());
linker.setLog(result, AgreeLogger.getLog());
linker.setRenaming(result, renaming);
// System.out.println(program);
return result;
}
use of com.rockwellcollins.atc.agree.analysis.AgreeException in project AGREE by loonwerks.
the class Util method getDoubleValue.
public static Double getDoubleValue(Expr expr) {
Double result = Double.valueOf(0.0);
assert (AgreeJavaValidator.exprIsConst(expr));
if (expr instanceof NamedElement) {
if (expr instanceof ConstStatement) {
result = getDoubleValue(((ConstStatement) expr).getExpr());
}
} else if (expr instanceof SelectionExpr) {
NamedElement finalId = ((SelectionExpr) expr).getField();
if (finalId instanceof ConstStatement) {
result = getDoubleValue(((ConstStatement) finalId).getExpr());
}
} else if (expr instanceof RealLitExpr) {
result = Double.valueOf(((RealLitExpr) expr).getVal());
} else if (expr instanceof IntLitExpr) {
result = Double.valueOf(((IntLitExpr) expr).getVal());
} else if (expr instanceof BinaryExpr) {
BinaryExpr binExpr = (BinaryExpr) expr;
Double left = getDoubleValue(binExpr.getLeft());
Double right = getDoubleValue(binExpr.getRight());
switch(binExpr.getOp()) {
case "+":
result = left + right;
break;
case "-":
result = left - right;
break;
case "*":
result = left * right;
break;
case "/":
result = left / right;
break;
case "^":
result = Math.pow(left, right);
break;
default:
throw new AgreeException("binary expression is not evaluable as integer constant");
}
return result;
} else if (expr instanceof UnaryExpr) {
UnaryExpr unExpr = (UnaryExpr) expr;
Double right = getDoubleValue(unExpr.getExpr());
switch(unExpr.getOp()) {
case "-":
result = -right;
break;
default:
throw new AgreeException("unary expression is not evaluable as integer constant");
}
} else {
throw new AgreeException("expression is not evaluable as integer constant");
}
return result;
}
Aggregations