use of verdict.vdm.vdm_lustre.LustreProgram in project VERDICT by ge-high-assurance.
the class VDMInstrumentor method retrieve_component_and_channels.
protected void retrieve_component_and_channels(Model vdm_model, List<String> threats, boolean blame_assignment, boolean component_level) {
HashSet<ComponentType> vdm_components = new HashSet<ComponentType>();
HashSet<Connection> vdm_links = new HashSet<Connection>();
// Initialize Components with Empty Ports and Ignore
identifyEmptyOutputComponents();
// Initialize DataFlow for empty Implementations.
LustreProgram lt = vdm_model.getDataflowCode();
if (lt == null) {
lt = new LustreProgram();
vdm_model.setDataflowCode(lt);
}
if (threats.contains("LS")) {
System.out.println("Location Spoofing Instrumentation");
locationSpoofing(vdm_components);
}
if (threats.contains("LB")) {
System.out.println("Logic Bomb Instrumentation");
logicBomb(vdm_components);
}
if (threats.contains("SV")) {
System.out.println("Software Virus/malware/worm/trojan");
softwareVirus(vdm_components);
}
if (threats.contains("RI")) {
System.out.println("Remote Code Injection");
remoteCodeInjection(vdm_components);
}
if (threats.contains("OT")) {
System.out.println("Outsider Threat");
outsiderThreat(vdm_components);
}
if (threats.contains("IT")) {
System.out.println("Insider Threat");
insiderThreat(vdm_components);
}
if (threats.contains("HT")) {
System.out.println("Hardware Trojans");
hardwareTrojan(vdm_components);
}
if (threats.contains("NI")) {
System.out.println("Network Injection Instrumentation");
// Snooze links for component level blame assignment.
if (!component_level) {
networkInjection(vdm_links);
}
}
if (threats.contains("BN")) {
System.out.println("Benign");
vdm_components.clear();
vdm_links.clear();
}
// int component_index = 1;
// Removed Once component Implemtation assumption.
ComponentImpl componentImpl = retrieve_main_cmp_impl();
BlockImpl blockImpl = null;
if (componentImpl != null) {
blockImpl = componentImpl.getBlockImpl();
}
Map<String, HashSet<Connection>> components_map = new HashMap<String, HashSet<Connection>>();
if (vdm_components.size() > 0) {
for (ComponentType component : vdm_components) {
blockImpl = retrieve_block(component);
HashSet<Connection> vdm_cmp_links = instrument_component(component, blockImpl);
for (Connection link_con : vdm_cmp_links) {
// Check if connection contains Empty Component on Port Ends.
if (!ignoreMarkedLink(link_con)) {
// Check if Port is Probe Port
if (!isProbePort(link_con)) {
vdm_links.add(link_con);
}
}
}
components_map.put(component.getId(), vdm_cmp_links);
}
}
// Snoorzing probe ports and Empty output components
if (vdm_links.size() > 0) {
Iterator<Connection> it = vdm_links.iterator();
while (it.hasNext()) {
Connection con = it.next();
if (isProbePort(con)) {
it.remove();
} else if (ignoreMarkedLink(con)) {
it.remove();
}
}
}
HashSet<String> global_constants = new HashSet<String>();
Map<Connection, String> connections_map = new HashMap<Connection, String>();
if (vdm_links.size() > 0) {
for (Connection connection : vdm_links) {
// System.out.println("(" + connection_index++ + ") " +
// connection.getName());
// instrument_link(connection, blockImpl);
String cmpID = getComponentID(components_map, connection);
if (cmpID != null) {
// Find Block based on Connection
blockImpl = getBlockID(cmpID);
String constant = instrument_link(cmpID, connection, blockImpl);
global_constants.add(constant);
connections_map.put(connection, constant);
} else {
// Handle 'NI' as Special Case.
ConnectionEnd conDest = connection.getSource();
Port dest_port = conDest.getComponentPort();
if (dest_port != null) {
cmpID = dest_port.getId();
} else {
CompInstancePort compInstance = conDest.getSubcomponentPort();
ComponentInstance compInst = compInstance.getSubcomponent();
cmpID = compInst.getId();
}
blockImpl = retrieve_block(connection);
String constant = instrument_link(cmpID, connection, blockImpl);
global_constants.add(constant);
connections_map.put(connection, constant);
}
}
} else {
emptySelection = true;
}
// Declare Global Constants
for (String comp_id : global_constants) {
ConstantDeclaration global_comp_const = new ConstantDeclaration();
DataType global_comp_dataType = new DataType();
global_comp_dataType.setPlainType(PlainType.BOOL);
global_comp_const.setName(comp_id);
global_comp_const.setDataType(global_comp_dataType);
// Expression global_expr = new Expression();
// global_expr.setBoolLiteral(true);
// global_comp_const.setDefinition(global_expr);
vdm_model.getDataflowCode().getConstantDeclaration().add(global_comp_const);
// g_constants.add(global_comp_const);
}
Map<String, List<String>> connection_gps_comp_map = connection_gps_mapper(connections_map, components_map);
// Choosing Blame options
if (threats.contains("LS") && component_level) {
// Link Level Instrumentation varibales
dec_var_asmp_const(connection_gps_comp_map, blame_assignment, false);
} else if (threats.contains("LS") && !component_level) {
dec_var_asmp_const(connection_gps_comp_map, blame_assignment, true);
}
if (blame_assignment && component_level) {
Map<String, List<String>> connection_comp_map = connection_mapper(connections_map, components_map);
ComponentImpl compImpl = retrieve_main_cmp_impl();
// if (compImpl.getBlockImpl() == null) {
// compImpl = retrieve_block(compImpl);
// }
ContractSpec contractSpec = compImpl.getType().getContract();
for (String key : components_map.keySet()) {
String id = key.replace("::", "_double_colon_");
Expression wk_expr = new Expression();
wk_expr.setIdentifier(id);
Expression not_wkexpr = new Expression();
not_wkexpr.setNot(wk_expr);
// Adding weakly assume variables
ContractItem weakly_assume_item = new ContractItem();
weakly_assume_item.setName(id + " is not instrumented");
weakly_assume_item.setExpression(not_wkexpr);
// Checking connection before adding assumption
HashSet<Connection> empty_connection_check = components_map.get(key);
if (empty_connection_check.size() > 0) {
contractSpec.getWeaklyassume().add(weakly_assume_item);
}
}
dec_var_const(connection_comp_map);
} else if (blame_assignment && !component_level) {
ComponentImpl compImpl = retrieve_main_cmp_impl();
if (compImpl != null) {
// if (compImpl.getBlockImpl() == null) {
// compImpl = retrieve_block_impl(compImpl);
// }
ContractSpec contractSpec = compImpl.getType().getContract();
for (String key : global_constants) {
Expression wk_expr = new Expression();
wk_expr.setIdentifier(key);
Expression not_wkexpr = new Expression();
not_wkexpr.setNot(wk_expr);
// Adding weakly assume variables
ContractItem weakly_assume_item = new ContractItem();
weakly_assume_item.setName(link_name(key) + " is not instrumented");
weakly_assume_item.setExpression(not_wkexpr);
contractSpec.getWeaklyassume().add(weakly_assume_item);
}
}
}
}
use of verdict.vdm.vdm_lustre.LustreProgram in project VERDICT by ge-high-assurance.
the class Agree2Vdm method getVdmExpressionFromAgreeExpression.
// method to translate expression in Agree to expression in vdm
private Expression getVdmExpressionFromAgreeExpression(Expr agreeExpr, HashSet<String> dataTypeDecl, HashSet<String> nodeDecl, Model model) {
Expression vdmExpr = new Expression();
if (agreeExpr instanceof IfThenElseExpr) {
IfThenElseExpr ifexpr = (IfThenElseExpr) agreeExpr;
// for vdm model
IfThenElse ifThenElseVal = new IfThenElse();
Expression condExpr = getVdmExpressionFromAgreeExpression(ifexpr.getA(), dataTypeDecl, nodeDecl, model);
ifThenElseVal.setCondition(condExpr);
Expression thenBranchExpr = getVdmExpressionFromAgreeExpression(ifexpr.getB(), dataTypeDecl, nodeDecl, model);
ifThenElseVal.setThenBranch(thenBranchExpr);
Expression elseBranchExpr = getVdmExpressionFromAgreeExpression(ifexpr.getC(), dataTypeDecl, nodeDecl, model);
ifThenElseVal.setElseBranch(elseBranchExpr);
vdmExpr.setConditionalExpression(ifThenElseVal);
} else if (agreeExpr instanceof CallExpr) {
CallExpr callExpr = (CallExpr) agreeExpr;
DoubleDotRef ddref = (DoubleDotRef) callExpr.getRef();
if (ddref.getElm() instanceof NodeDef) {
NodeDef nodeDef = (NodeDef) ddref.getElm();
addNodeDefToTypeDeclarations(nodeDef, dataTypeDecl, nodeDecl, model);
// create node call in vdm model
NodeCall vdmNodeCall = new NodeCall();
// setting node name
vdmNodeCall.setNodeId(nodeDef.getName());
EList<Expr> callExprArgs = callExpr.getArgs();
// below are the parameters passed to the function call
for (Expr callExprArg : callExprArgs) {
Expression argExpr = getVdmExpressionFromAgreeExpression(callExprArg, dataTypeDecl, nodeDecl, model);
// setting node arguments
vdmNodeCall.getArgument().add(argExpr);
}
vdmExpr.setCall(vdmNodeCall);
} else {
System.out.println("Unmapped Typed");
}
} else if (agreeExpr instanceof NamedElmExpr) {
NamedElmExpr nmExpr = (NamedElmExpr) agreeExpr;
vdmExpr.setIdentifier(nmExpr.getElm().getName());
// define corresponding types in the VDM if not already defined
if (nmExpr.getElm() instanceof Arg) {
Arg nmElmArg = (Arg) nmExpr.getElm();
// define corresponding type in the VDM if not already defined
Type argType = nmElmArg.getType();
defineDataTypeDataImplementationTypeInVDM(argType, dataTypeDecl, model);
} else if (nmExpr.getElm() instanceof Port) {
Port nmElmPort = (Port) nmExpr.getElm();
// define corresponding type in the VDM if not already defined
if (nmElmPort instanceof DataPortImpl) {
DataPort nmElmDataPort = (DataPort) nmElmPort;
DataSubcomponentType dSubCompType = nmElmDataPort.getDataFeatureClassifier();
defineDataTypeDataImplementationTypeInVDM(dSubCompType, dataTypeDecl, model);
} else if (nmElmPort instanceof EventDataPortImpl) {
EventDataPort nmElmDataPort = (EventDataPort) nmElmPort;
DataSubcomponentType dSubCompType = nmElmDataPort.getDataFeatureClassifier();
defineDataTypeDataImplementationTypeInVDM(dSubCompType, dataTypeDecl, model);
} else {
if (!(nmElmPort instanceof EventPort)) {
System.out.println("Unresolved Port Type");
}
}
} else if (nmExpr.getElm() instanceof ConstStatement) {
ConstStatement nmElmConstStatement = (ConstStatement) nmExpr.getElm();
String nmElmConstStatementName = nmElmConstStatement.getName();
// add const declaration to VDM if not already defined
if (!dataTypeDecl.contains(nmElmConstStatementName)) {
dataTypeDecl.add(nmElmConstStatementName);
ConstantDeclaration vdmConstDeclaration = new ConstantDeclaration();
vdmConstDeclaration.setName(nmElmConstStatementName);
vdmConstDeclaration.setDefinition(getVdmExpressionFromAgreeExpression(nmElmConstStatement.getExpr(), dataTypeDecl, nodeDecl, model));
vdmConstDeclaration.setDataType(getVdmTypeFromAgreeType(nmElmConstStatement.getType(), dataTypeDecl, model));
LustreProgram lustreProgram = model.getDataflowCode();
lustreProgram.getConstantDeclaration().add(vdmConstDeclaration);
model.setDataflowCode(lustreProgram);
}
} else {
System.out.println("Unresolved/unmapped NamedExprElm: " + nmExpr.getElm().getName());
}
} else if (agreeExpr instanceof SelectionExpr) {
// selection expression corresponds to record projection in VDM
RecordProjection vdmRecordProj = new RecordProjection();
SelectionExpr selExpr = (SelectionExpr) agreeExpr;
if (selExpr.getField() == null) {
System.out.println("Null Selection Expr field: " + selExpr.getField());
} else {
NamedElement field = selExpr.getField();
// set record-projection's reference
if (selExpr.getTarget() != null) {
// target can be NamedElmExpr or a SelectionExpr
vdmRecordProj.setRecordReference(getVdmExpressionFromAgreeExpression(selExpr.getTarget(), dataTypeDecl, nodeDecl, model));
}
// set record-projection's field id
vdmRecordProj.setFieldId(field.getName());
// also set the name of the field's type as the record-projection's record-type
if (field instanceof DataPortImpl) {
DataPort dport = (DataPort) field;
DataSubcomponentType dSubCompType = dport.getDataFeatureClassifier();
defineDataTypeDataImplementationTypeInVDM(dSubCompType, dataTypeDecl, model);
vdmRecordProj.setRecordType(dSubCompType.getName());
} else if (field instanceof DataSubcomponentImpl) {
DataSubcomponent dSubComp = (DataSubcomponent) field;
DataSubcomponentType dSubCompType = dSubComp.getDataSubcomponentType();
defineDataTypeDataImplementationTypeInVDM(dSubCompType, dataTypeDecl, model);
vdmRecordProj.setRecordType(dSubCompType.getName());
} else if (field instanceof ArgImpl) {
Arg arg = (Arg) field;
Type argType = arg.getType();
defineDataTypeDataImplementationTypeInVDM(argType, dataTypeDecl, model);
if (argType instanceof PrimType) {
vdmRecordProj.setRecordType(getDataTypeName(argType));
} else {
System.out.println("Unresolved Arg Type so not setting record-type in record-projection.");
}
} else {
System.out.println("Unresolved type of field.");
}
}
vdmExpr.setRecordProjection(vdmRecordProj);
} else if (agreeExpr instanceof BinaryExpr) {
BinaryExpr binExpr = (BinaryExpr) agreeExpr;
// for vdm
BinaryOperation binoper = new BinaryOperation();
// set left operand
Expression leftOperand = getVdmExpressionFromAgreeExpression(binExpr.getLeft(), dataTypeDecl, nodeDecl, model);
binoper.setLhsOperand(leftOperand);
// set right operand
Expression rightOperand = getVdmExpressionFromAgreeExpression(binExpr.getRight(), dataTypeDecl, nodeDecl, model);
binoper.setRhsOperand(rightOperand);
// set appropriate operator
String operator = binExpr.getOp();
if (operator.equalsIgnoreCase("->")) {
vdmExpr.setArrow(binoper);
} else if (operator.equalsIgnoreCase("=>")) {
vdmExpr.setImplies(binoper);
} else if (operator.equalsIgnoreCase("and")) {
vdmExpr.setAnd(binoper);
} else if (operator.equalsIgnoreCase("or")) {
vdmExpr.setOr(binoper);
} else if (operator.equalsIgnoreCase("=")) {
vdmExpr.setEqual(binoper);
} else if (operator.equalsIgnoreCase(">")) {
vdmExpr.setGreaterThan(binoper);
} else if (operator.equalsIgnoreCase("<")) {
vdmExpr.setLessThan(binoper);
} else if (operator.equalsIgnoreCase(">=")) {
vdmExpr.setGreaterThanOrEqualTo(binoper);
} else if (operator.equalsIgnoreCase("<=")) {
vdmExpr.setLessThanOrEqualTo(binoper);
} else if (operator.equalsIgnoreCase("+")) {
vdmExpr.setPlus(binoper);
} else if (operator.equalsIgnoreCase("-")) {
vdmExpr.setMinus(binoper);
} else if (operator.equalsIgnoreCase("!=") || operator.equalsIgnoreCase("<>")) {
vdmExpr.setNotEqual(binoper);
} else if (operator.equalsIgnoreCase("/")) {
vdmExpr.setDiv(binoper);
} else if (operator.equalsIgnoreCase("*")) {
vdmExpr.setTimes(binoper);
} else {
System.out.println("Unmapped binary operator: " + operator);
}
} else if (agreeExpr instanceof UnaryExpr) {
UnaryExpr unExpr = (UnaryExpr) agreeExpr;
Expression singleOperand = getVdmExpressionFromAgreeExpression(unExpr.getExpr(), dataTypeDecl, nodeDecl, model);
String operator = unExpr.getOp();
if (operator.equalsIgnoreCase("this")) {
vdmExpr.setCurrent(singleOperand);
} else if (operator.equalsIgnoreCase("not")) {
vdmExpr.setNot(singleOperand);
} else if (operator.equalsIgnoreCase("-")) {
vdmExpr.setNegative(singleOperand);
} else {
System.out.println("Unmapped unary operator.");
}
} else if (agreeExpr instanceof BoolLitExpr) {
BoolLitExpr boolExpr = (BoolLitExpr) agreeExpr;
vdmExpr.setBoolLiteral(boolExpr.getVal().getValue());
} else if (agreeExpr instanceof EnumLitExpr) {
EnumLitExpr enumExpr = (EnumLitExpr) agreeExpr;
// check if elm is DataImplementationImpl or DataTypeImpl -- if yes add definition to type declarations if not already present
DoubleDotRef enumType = enumExpr.getEnumType();
if (enumType.getElm() instanceof DataTypeImpl) {
org.osate.aadl2.DataType aadlDType = (org.osate.aadl2.DataType) enumType.getElm();
resolveAADLDataType(aadlDType, dataTypeDecl, model);
} else {
System.out.println("Unexpected Elm type for EnumLitExpr");
}
vdmExpr.setIdentifier(enumExpr.getValue());
} else if (agreeExpr instanceof PreExpr) {
PreExpr preExpr = (PreExpr) agreeExpr;
Expression expr = getVdmExpressionFromAgreeExpression(preExpr.getExpr(), dataTypeDecl, nodeDecl, model);
vdmExpr.setPre(expr);
} else if (agreeExpr instanceof RecordLitExpr) {
RecordLiteral vdmRecordLiteral = new RecordLiteral();
RecordLitExpr recLitExpr = (RecordLitExpr) agreeExpr;
if (recLitExpr.getRecordType() instanceof DoubleDotRef) {
DoubleDotRef recType = (DoubleDotRef) recLitExpr.getRecordType();
if (recType.getElm().getName() != null) {
// check if elm is DataImplementationImpl -- if yes add definition to type declarations if not already present
if (recType.getElm() instanceof DataImplementation) {
org.osate.aadl2.DataImplementation aadlDImpl = (org.osate.aadl2.DataImplementation) recType.getElm();
resolveAADLDataImplementationType(aadlDImpl, dataTypeDecl, model);
} else {
System.out.println("Unexpected Elm type for EnumLitExpr");
}
// set name of the record literal in the vdm model
vdmRecordLiteral.setRecordType(recType.getElm().getName());
// get args and arg-expr and set them as field identifier and value in the vdm model
EList<NamedElement> recLitArgs = recLitExpr.getArgs();
EList<Expr> recLitArgsExpr = recLitExpr.getArgExpr();
// below are the values set to variable
for (int ind = 0; ind < recLitArgs.size(); ind++) {
FieldDefinition fieldDef = new FieldDefinition();
fieldDef.setFieldIdentifier(recLitArgs.get(ind).getName());
fieldDef.setFieldValue(getVdmExpressionFromAgreeExpression(recLitArgsExpr.get(ind), dataTypeDecl, nodeDecl, model));
// set field definitions in the record literal in the vdm model
vdmRecordLiteral.getFieldDefinition().add(fieldDef);
}
vdmExpr.setRecordLiteral(vdmRecordLiteral);
} else {
System.out.println("Unexpected Literal's Record Type that has null named elm.");
}
} else {
System.out.println("Unresolved or unmapped record literal expression.");
}
} else if (agreeExpr instanceof IntLitExpr) {
IntLitExpr intLitExpr = (IntLitExpr) agreeExpr;
BigInteger bigInt = new BigInteger(intLitExpr.getVal());
vdmExpr.setIntLiteral(bigInt);
} else if (agreeExpr instanceof RealLitExpr) {
RealLitExpr realLitExpr = (RealLitExpr) agreeExpr;
BigDecimal bigDecimal = new BigDecimal(realLitExpr.getVal());
vdmExpr.setRealLiteral(bigDecimal);
} else if (agreeExpr instanceof EventExpr) {
EventExpr eventExpr = (EventExpr) agreeExpr;
if (eventExpr.getPort() != null) {
vdmExpr.setEvent(getVdmExpressionFromAgreeExpression(eventExpr.getPort(), dataTypeDecl, nodeDecl, model));
} else {
System.out.println("EventExpr does not have port infornation.");
}
} else if (agreeExpr instanceof RealCast) {
RealCast realCastExpr = (RealCast) agreeExpr;
vdmExpr.setToReal(getVdmExpressionFromAgreeExpression(realCastExpr.getExpr(), dataTypeDecl, nodeDecl, model));
} else {
System.out.println("Unresolved/umapped agree expr" + agreeExpr.toString());
}
return vdmExpr;
}
use of verdict.vdm.vdm_lustre.LustreProgram in project VERDICT by ge-high-assurance.
the class Agree2Vdm method translateAgreeAnnex.
private Model translateAgreeAnnex(List<SystemType> systemTypes, List<SystemImplementation> systemImpls, Model model, HashSet<String> dataTypeDecl, HashSet<String> nodeDecl) {
LustreProgram lustreProgram = new LustreProgram();
// Initializing the lustre program in the VDM
model.setDataflowCode(lustreProgram);
// System.out.println("Processing "+systemTypes.size()+" SystemTypes for agree annexes");
for (SystemType sysType : systemTypes) {
// unpacking sysType
for (AnnexSubclause annex : sysType.getOwnedAnnexSubclauses()) {
if (annex.getName().equalsIgnoreCase("agree")) {
// annex is of type DefaultAnnexSubclause
DefaultAnnexSubclause ddASC = (DefaultAnnexSubclause) annex;
// AnnexSubclause aSC = ddASC.getParsedAnnexSubclause();
AgreeContractSubclause agreeAnnex = (AgreeContractSubclause) ddASC.getParsedAnnexSubclause();
// populating agree contracts in the vdm component type -- SHOULD ADD THIS CODE TO AADL2VDM
verdict.vdm.vdm_lustre.ContractSpec contractSpec = new verdict.vdm.vdm_lustre.ContractSpec();
EList<EObject> annexContents = agreeAnnex.eContents();
if (annexContents.isEmpty()) {
System.out.println("Empty Agree Annex.");
}
for (EObject clause : annexContents) {
// mapping to AgreeContractclause
AgreeContract agreeContract = (AgreeContract) clause;
// getting specStatements
EList<SpecStatement> specStatements = agreeContract.getSpecs();
for (SpecStatement specStatement : specStatements) {
if (specStatement instanceof EqStatement) {
EqStatement eqStmt = (EqStatement) specStatement;
// translate EqStatement in Agree to SymbolDefinition in vdm
SymbolDefinition symbDef = translateEqStatement(eqStmt, model, dataTypeDecl, nodeDecl);
// Add agree variable/symbol definition to the contractSpec in vdm
contractSpec.getSymbol().add(symbDef);
} else if (specStatement instanceof GuaranteeStatement) {
GuaranteeStatement guaranteeStmt = (GuaranteeStatement) specStatement;
ContractItem contractItem = translateGuaranteeStatement(guaranteeStmt, dataTypeDecl, nodeDecl, model);
contractSpec.getGuarantee().add(contractItem);
} else if (specStatement instanceof AssumeStatement) {
AssumeStatement assumeStmt = (AssumeStatement) specStatement;
ContractItem contractItem = translateAssumeStatement(assumeStmt, dataTypeDecl, nodeDecl, model);
contractSpec.getAssume().add(contractItem);
} else {
if (!(specStatement instanceof ConstStatementImpl)) {
System.out.println("Element not recognizable" + clause.eContents().toString());
}
}
}
}
if (contractSpec != null) {
List<ComponentType> vdmComponentTypes = model.getComponentType();
for (ComponentType vdmComponentType : vdmComponentTypes) {
// populating agree contract details in the corresponding componentType instance in vdm
if (vdmComponentType.getName().equalsIgnoreCase(sysType.getName())) {
vdmComponentType.setContract(contractSpec);
}
}
// populating agree contract details in the componentType instance in vdm
// packComponent.setContract(contractSpec);
}
}
}
// End of unpacking sysType
}
for (SystemImplementation sysImpl : systemImpls) {
// unpacking sysType
for (AnnexSubclause annex : sysImpl.getOwnedAnnexSubclauses()) {
if (annex.getName().equalsIgnoreCase("agree")) {
// annex is of type DefaultAnnexSubclause
DefaultAnnexSubclause ddASC = (DefaultAnnexSubclause) annex;
// AnnexSubclause aSC = ddASC.getParsedAnnexSubclause();
AgreeContractSubclause agreeAnnex = (AgreeContractSubclause) ddASC.getParsedAnnexSubclause();
// populating agree contracts in the vdm node body for component implementation type
verdict.vdm.vdm_lustre.NodeBody nodeBody = new verdict.vdm.vdm_lustre.NodeBody();
;
EList<EObject> annexContents = agreeAnnex.eContents();
if (annexContents.isEmpty()) {
System.out.println("Empty Agree Annex.");
}
for (EObject clause : annexContents) {
// mapping to AgreeContractclause
AgreeContract agreeContract = (AgreeContract) clause;
// getting specStatements
EList<SpecStatement> specStatements = agreeContract.getSpecs();
for (SpecStatement specStatement : specStatements) {
if (specStatement instanceof ConstStatementImpl) {
ConstStatementImpl constStmtImpl = (ConstStatementImpl) specStatement;
ConstantDeclaration constDecl = translateConstStatementImpl(constStmtImpl, dataTypeDecl, nodeDecl, model);
nodeBody.getConstantDeclaration().add(constDecl);
} else if (specStatement instanceof EqStatementImpl) {
EqStatementImpl eqStmtImpl = (EqStatementImpl) specStatement;
nodeBody = translateEqStatementImpl(eqStmtImpl, dataTypeDecl, nodeDecl, model, nodeBody);
} else if (specStatement instanceof AssignStatementImpl) {
AssignStatementImpl assignStmtImpl = (AssignStatementImpl) specStatement;
NodeEquation nodeEquation = translateAssignStatementImpl(assignStmtImpl, dataTypeDecl, nodeDecl, model);
nodeBody.getEquation().add(nodeEquation);
} else if (specStatement instanceof AssertStatementImpl) {
AssertStatementImpl assertStmtImpl = (AssertStatementImpl) specStatement;
Expression assertion = translateAssertStatementImpl(assertStmtImpl, dataTypeDecl, nodeDecl, model);
nodeBody.getAssertion().add(assertion);
} else {
System.out.println("Element not recognizable" + clause.eContents().toString());
}
}
}
List<ComponentImpl> vdmComponentImpls = model.getComponentImpl();
for (ComponentImpl vdmComponentImpl : vdmComponentImpls) {
// populating agree contract details in the corresponding componentImplType instance in vdm
if (vdmComponentImpl.getName().equalsIgnoreCase(sysImpl.getName())) {
vdmComponentImpl.setDataflowImpl(nodeBody);
}
}
}
}
}
return model;
}
use of verdict.vdm.vdm_lustre.LustreProgram in project VERDICT by ge-high-assurance.
the class VDM2Lustre method visit.
public Model visit(Model vdm_model) {
Model dataFlowModel = new Model();
// I) Naming Model *.lus
String program_name = vdm_model.getName() + ".lus";
dataFlowModel.setName(program_name);
// II) Copying exiting DataFlow code
LustreProgram lustre_program = vdm_model.getDataflowCode();
if (lustre_program == null) {
lustre_program = new LustreProgram();
}
visit(vdm_model, lustre_program);
dataFlowModel.setDataflowCode(lustre_program);
return dataFlowModel;
}
use of verdict.vdm.vdm_lustre.LustreProgram in project VERDICT by ge-high-assurance.
the class VerdictLustreListener method exitNode.
/**
* Extract a node declaration.
*/
@Override
public void exitNode(LustreParser.NodeContext ctx) {
Node node = new Node();
if ("function".equals(ctx.nodeType.getText())) {
node.setIsFunction(true);
}
node.setName(ctx.ID().getText());
if (ctx.input != null) {
node.getInputParameter().addAll(ctx.input.nodeParameters);
}
if (ctx.output != null) {
node.getOutputParameter().addAll(ctx.output.nodeParameters);
}
if (ctx.nodeBody() != null) {
node.setBody(ctx.nodeBody().body);
}
if (ctx.inlineContract() != null) {
node.setContract(ctx.inlineContract().spec);
}
if (!ctx.importedContract().isEmpty()) {
if (node.getContract() == null) {
node.setContract(new ContractSpec());
}
final ContractSpec spec = node.getContract();
ctx.importedContract().forEach(importedContract -> spec.getImport().add(importedContract.imprt));
}
LustreProgram program = model.getDataflowCode();
program.getNodeDeclaration().add(node);
}
Aggregations