Examples with NodeEquation verdict.vdm.vdm_lustre.NodeEquation used on opensource projects

Example 1 with NodeEquation

use of verdict.vdm.vdm_lustre.NodeEquation in project VERDICT by ge-high-assurance.

the class VDMInstrumentor method instrument_link.

// public void instrument_link(Connection connection) {
// // Connection Source
// ConnectionEnd src = connection.getSource();
// 
// // Connection Destination
// ConnectionEnd dest = connection.getDestination();
// 
// // Source Component
// Port src_port = src.getComponentPort();
// // Destination Component
// Port dest_port = dest.getComponentPort();
// 
// if (src_port == null && dest_port == null) {
// // Both are sub-compon
// System.out.println("Both are subcomponents.");
// }
// if (src_port == null && dest_port != null) {
// // Only one is Subcomponent
// System.out.println(dest_port.getId() + " -- " + dest_port.getName());
// }
// if (src_port != null && dest_port == null) {
// // One Subcomponent
// System.out.println(src_port.getId() + " -- " + src_port.getName());
// }
// }
// public void create_link(Connection old_channel, ComponentInstance
// src_componentInstance,
// ComponentInstance dest_componentInstance) {
// 
// ComponentInstance instrumented_componentInstance = new ComponentInstance();
// 
// String component_ID = src_componentInstance.getName() + "_Inst_" +
// dest_componentInstance.getName();
// instrumented_componentInstance.setId(component_ID + "_Instance");
// instrumented_componentInstance.setName(component_ID);
// 
// instrumented_componentInstance.setSpecification(value);
// instrumented_componentInstance.setImplementation(value);
// 
// ComponentType instrumented_component = new ComponentType();
// instrumented_component.setId(component_ID);
// instrumented_component.setName(component_ID);
// 
// 
// 
// Connection inst_channel = new Connection();
// 
// //Update Old connection Destination
// old_channel.setDestination(value);
// 
// //Add New Connection Source
// inst_channel.setSource(value);
// //Add New Connection Destination
// inst_channel.setDestination(value);
// 
// 
// }
public String instrument_link(String compID, Connection connection, BlockImpl blockImpl) {
    // instrument_link(connection);
    // System.out.println("Instrumented Link ***" + connection.getName());
    // Default Block Implementation
    ComponentImpl compImpl = null;
    if (compID != null) {
        compImpl = retrieve_cmp_impl(compID);
    }
    // Connections without Components Instrumentation.
    if (compImpl == null) {
        compImpl = retrieve_main_cmp_impl();
    }
    ComponentType instrumented_cmp = new ComponentType();
    // R.H.S
    ConnectionEnd src = connection.getSource();
    ComponentInstance src_componentInstance = new ComponentInstance();
    // Source Connection
    Port src_port = src.getComponentPort();
    if (src_port != null) {
        String identifier = compImpl.getId();
        // identifier = identifier.replace(".I", "_I");
        identifier = identifier.replace(".", "_dot_");
        identifier = identifier.replace("::", "_double_colon_");
        src_componentInstance.setId(identifier);
        src_componentInstance.setName(identifier);
        src_componentInstance.setImplementation(compImpl);
    }
    // if (src_port == instrumented_port) {
    CompInstancePort compInstancePort = src.getSubcomponentPort();
    if (compInstancePort != null) {
        src_componentInstance = compInstancePort.getSubcomponent();
        src_port = compInstancePort.getPort();
    }
    // R.H.S
    ConnectionEnd dest = connection.getDestination();
    ComponentInstance dest_componentInstance = new ComponentInstance();
    // Source Connection
    Port dest_port = dest.getComponentPort();
    if (dest_port != null) {
        String identifier = compImpl.getId();
        // identifier = identifier.replace(".I", "_I");
        identifier = identifier.replace(".", "_dot_");
        identifier = identifier.replace("::", "_double_colon_");
        dest_componentInstance.setId(identifier);
        dest_componentInstance.setName(identifier);
        dest_componentInstance.setImplementation(compImpl);
    }
    // if (dest_port == instrumented_port) {
    compInstancePort = dest.getSubcomponentPort();
    if (compInstancePort != null) {
        dest_componentInstance = compInstancePort.getSubcomponent();
        dest_port = compInstancePort.getPort();
    }
    String instrument_cmp_Id = src_componentInstance.getName() + "_Inst_" + dest_componentInstance.getName() + "_port_" + dest_port.getName();
    instrument_cmp_Id = instrument_cmp_Id.replace(".", "_dot_");
    // Setting Component IDs
    instrumented_cmp.setId(instrument_cmp_Id);
    instrumented_cmp.setName(instrument_cmp_Id);
    // output port
    Port instrumented_port_dest = new Port();
    instrumented_port_dest.setId(dest_port.getId());
    instrumented_port_dest.setName(dest_port.getName());
    instrumented_port_dest.setMode(dest_port.getMode());
    instrumented_port_dest.setType(dest_port.getType());
    if (dest_port.isEvent() != null && dest_port.isEvent()) {
        instrumented_port_dest.setEvent(true);
    } else {
        instrumented_port_dest.setEvent(false);
    }
    instrumented_cmp.getPort().add(instrumented_port_dest);
    // Input port
    Port instrumented_port_src = new Port();
    instrumented_port_src.setId(src_port.getId());
    instrumented_port_src.setName(src_componentInstance + "_port_" + src_port.getName());
    instrumented_port_src.setMode(src_port.getMode());
    if (src_port.isEvent() != null && src_port.isEvent()) {
        instrumented_port_src.setEvent(true);
    } else {
        instrumented_port_src.setEvent(false);
    }
    String global_constant_Id = src_componentInstance.getName();
    if (instrumented_port_src.getMode() == instrumented_port_dest.getMode()) {
        instrumented_port_src.setName(src_port.getName());
        if (instrumented_port_src.getMode() == PortMode.IN) {
            instrumented_port_src.setMode(PortMode.OUT);
        } else {
            instrumented_port_dest.setMode(PortMode.IN);
        }
    } else {
        instrumented_port_src.setName(src_port.getName());
    }
    if (dest_port.getMode() == PortMode.OUT) {
        global_constant_Id += "_port_" + dest_port.getName() + "_instrumented";
    } else {
        global_constant_Id += "_port_" + src_port.getName() + "_instrumented";
    }
    instrumented_port_src.setType(dest_port.getType());
    instrumented_cmp.getPort().add(instrumented_port_src);
    vdm_model.getComponentType().add(instrumented_cmp);
    // Modify connection.
    ConnectionEnd con_end_inst = new ConnectionEnd();
    // instrumentd_port.setPort(value);
    ComponentInstance instrumented_compInstance = new ComponentInstance();
    instrumented_compInstance.setId(connection.getName());
    instrumented_compInstance.setName(connection.getName());
    instrumented_compInstance.setSpecification(instrumented_cmp);
    // -----------------------------------------
    // Adding Auxiliary Node.
    NodeCall nodeCall = new NodeCall();
    nodeCall.setNodeId(instrumented_cmp.getId());
    Expression callExpr = new Expression();
    callExpr.setCall(nodeCall);
    ContractItem true_guarantee_item = new ContractItem();
    // true_guarantee_item.setName("true");
    Expression true_expr = new Expression();
    Boolean true_lit = Boolean.TRUE;
    true_expr.setBoolLiteral(true_lit);
    true_guarantee_item.setExpression(true_expr);
    ContractSpec contractSpec = new ContractSpec();
    contractSpec.getGuarantee().add(true_guarantee_item);
    // ---------------------------------------------
    ComponentImpl instrument_compImpl = new ComponentImpl();
    instrument_compImpl.setId(instrumented_cmp.getId() + "_dot_impl");
    instrument_compImpl.setName(instrumented_cmp.getName() + "_dot_Impl");
    instrument_compImpl.setType(instrumented_cmp);
    IfThenElse ifelse = new IfThenElse();
    // Condition
    Expression cond_expr = new Expression();
    global_constant_Id = global_constant_Id.replace(".", "_dot_");
    cond_expr.setIdentifier(global_constant_Id);
    ifelse.setCondition(cond_expr);
    // Then
    Expression then_arg = new Expression();
    then_arg.setIdentifier(dest_port.getName());
    ifelse.setThenBranch(callExpr);
    // Else
    Expression else_arg = new Expression();
    else_arg.setIdentifier(dest_port.getName());
    nodeCall.getArgument().add(else_arg);
    ifelse.setElseBranch(then_arg);
    Expression instrumented_expr = new Expression();
    instrumented_expr.setConditionalExpression(ifelse);
    NodeEquation n_eq = new NodeEquation();
    NodeEquationLHS neq_lhs = new NodeEquationLHS();
    neq_lhs.getIdentifier().add(src_port.getName() + "_instrumented");
    n_eq.setLhs(neq_lhs);
    n_eq.setRhs(instrumented_expr);
    NodeBody nodeBody = new NodeBody();
    // VariableDeclaration cond_var = new VariableDeclaration();
    // cond_var.setName(gloabal_constant_Id);
    // DataType dataType = new DataType();
    // dataType.setPlainType(PlainType.BOOL);
    // cond_var.setDataType(dataType);
    // nodeBody.getVariableDeclaration().add(cond_var);
    nodeBody.setIsMain(false);
    nodeBody.getEquation().add(n_eq);
    instrument_compImpl.setDataflowImpl(nodeBody);
    instrumented_compInstance.setImplementation(instrument_compImpl);
    vdm_model.getComponentImpl().add(instrument_compImpl);
    vdm_model.getComponentType().add(instrumented_cmp);
    // -----------------------------------------
    CompInstancePort compInstance_inst_port = new CompInstancePort();
    compInstance_inst_port.setPort(dest_port);
    compInstance_inst_port.setSubcomponent(instrumented_compInstance);
    con_end_inst.setSubcomponentPort(compInstance_inst_port);
    blockImpl.getSubcomponent().add(instrumented_compInstance);
    connection.setDestination(con_end_inst);
    Connection new_con = new Connection();
    // Copying connection related artifacts
    new_con.setName(connection.getName() + "_instrumented_channel");
    // new_con.setConnType(connection.getConnType());
    // new_con.setFlowType(connection.getFlowType());
    // 
    // new_con.setDataEncrypted(connection.isEncryptedTransmission());
    // new_con.setAuthenticated(connection.isAuthenticated());
    new_con.setSource(con_end_inst);
    compInstance_inst_port.setPort(src_port);
    new_con.setDestination(dest);
    blockImpl.getConnection().add(new_con);
    return global_constant_Id;
}

Example 2 with NodeEquation

use of verdict.vdm.vdm_lustre.NodeEquation in project VERDICT by ge-high-assurance.

the class VDM2Lustre method visit.

// Connect -> NodeCall
public void visit(Connection connection, NodeBody nodeBody) {
    // R.H.S
    ConnectionEnd src = connection.getSource();
    // Source Connection
    Port src_component_port = src.getComponentPort();
    // L.H.S.
    ConnectionEnd dest = connection.getDestination();
    // Destination Connection
    Port dest_component_port = dest.getComponentPort();
    if (dest_component_port != null) {
        // Destination = Component (z3)
        // Source = SubComponent (my_b:B _z2)
        NodeEquation neq = new NodeEquation();
        NodeEquationLHS eq_lhs = new NodeEquationLHS();
        eq_lhs.getIdentifier().add(dest_component_port.getName());
        neq.setLhs(eq_lhs);
        CompInstancePort compInstancePort = src.getSubcomponentPort();
        ComponentInstance componentInstance = compInstancePort.getSubcomponent();
        src_component_port = compInstancePort.getPort();
        String src_portID = src_component_port.getName();
        Expression expr = new Expression();
        List<VariableDeclaration> vars = nodeBody.getVariableDeclaration();
        boolean match = false;
        String id_expr = componentInstance.getId() + "_port_" + src_portID;
        for (VariableDeclaration var : vars) {
            if (var.getName().equals(id_expr)) {
                match = true;
                break;
            }
        }
        if (match) {
            expr.setIdentifier(id_expr);
        } else {
            String inst_cmp = "(.+)_instrumented";
            Pattern inst_pattern = Pattern.compile(inst_cmp);
            // System.out.println(src_portID);
            Matcher m = inst_pattern.matcher(src_portID);
            if (m.matches()) {
                src_portID = m.group(1);
            }
            id_expr = componentInstance.getId() + "_port_" + src_portID;
            expr.setIdentifier(id_expr);
        // System.out.println(id_expr);
        // System.out.println(">>>>>>>>>>>>>Identifiers: " +
        // expr.getIdentifier());
        }
        neq.setRhs(expr);
        nodeBody.getEquation().add(neq);
    } else if (src_component_port != null) {
        CompInstancePort compInstancePort = dest.getSubcomponentPort();
        // X1
        dest_component_port = compInstancePort.getPort();
        // my_a1 : A
        ComponentInstance componentInstance = compInstancePort.getSubcomponent();
        String arg_value = src_component_port.getName();
        // called node Identifier.
        String called_node_ID = null;
        ComponentType componentType = componentInstance.getSpecification();
        ComponentImpl componentImpl = componentInstance.getImplementation();
        if (componentType == null) {
            componentType = componentImpl.getType();
            called_node_ID = componentType.getName() + "_dot_Impl";
        }
        if (componentType != null && componentImpl != null) {
            componentType = componentImpl.getType();
            called_node_ID = componentType.getName() + "_dot_Impl";
            String inst_cmp = "(.+)_instrumented";
            Pattern inst_pattern = Pattern.compile(inst_cmp);
            // System.out.println(arg_value);
            Matcher m = inst_pattern.matcher(arg_value);
            if (m.matches()) {
                arg_value = m.group(1);
            }
        } else {
            called_node_ID = componentType.getName();
            arg_value = src_component_port.getName();
        // System.out.println(arg_value);
        }
        for (Port port : componentType.getPort()) {
            // MODE
            PortMode port_mode = port.getMode();
            if (port_mode == PortMode.OUT) {
                // EQ L.H.S Variables *called Node return values
                String expr_id = componentInstance.getId() + "_port_" + port.getName();
                // System.out.print(">>>" + expr_id);
                NodeEquation n_eq = getNodeEq(expr_id, nodeBody);
                if (n_eq != null) {
                    Expression eq_rhs = n_eq.getRhs();
                    NodeCall node_called = eq_rhs.getCall();
                    String inst_cmp = "(.+)_Inst_.*";
                    Pattern inst_pattern = Pattern.compile(inst_cmp);
                    // String node_id = "";
                    // if (node_called != null) {
                    // node_id = node_called.getNodeId();
                    // }
                    // System.out.println(" = " + node_id + " (" + arg_value
                    // +
                    // ")");
                    Matcher m = inst_pattern.matcher(node_called.getNodeId());
                    IfThenElse ifelse = new IfThenElse();
                    Expression called_expr = new Expression();
                    // Condition
                    Expression gps_expr = new Expression();
                    if (m.matches()) {
                        // Instrumented component Instance ID
                        String component_id = m.group(1);
                        gps_expr.setIdentifier(component_id);
                    }
                    ifelse.setCondition(gps_expr);
                    // Then
                    ifelse.setThenBranch(called_expr);
                    // Else
                    Expression arg = new Expression();
                    arg.setIdentifier(src_component_port.getName());
                    ifelse.setElseBranch(arg);
                    // NodeCalled Expr
                    called_expr.setCall(node_called);
                    Expression instrumented_expr = new Expression();
                    instrumented_expr.setConditionalExpression(ifelse);
                    if (node_called != null) {
                        if (node_called.getNodeId().equals(called_node_ID)) {
                            for (Expression arg_expr : node_called.getArgument()) {
                                if (arg_expr.getIdentifier().equals(dest_component_port.getName())) {
                                    arg_expr.setIdentifier(arg_value);
                                } else if (node_called.getArgument().size() == 1) {
                                    arg_expr.setIdentifier(arg_value);
                                }
                            }
                        }
                    }
                }
            }
        }
    } else {
        CompInstancePort compInstancePort = src.getSubcomponentPort();
        ComponentInstance componentInstance = compInstancePort.getSubcomponent();
        src_component_port = compInstancePort.getPort();
        Expression arg_expr = new Expression();
        // my_a1_y1
        String src_portID = src_component_port.getName();
        String componentInstanceID = componentInstance.getId();
        arg_expr.setIdentifier(componentInstanceID + "_port_" + src_portID);
        // called node Identifier.
        String called_node_ID = null;
        compInstancePort = dest.getSubcomponentPort();
        componentInstance = compInstancePort.getSubcomponent();
        dest_component_port = compInstancePort.getPort();
        ComponentType componentType = componentInstance.getSpecification();
        ComponentImpl componentImpl = componentInstance.getImplementation();
        String old_portID = null;
        if (componentType == null) {
            componentType = componentImpl.getType();
            called_node_ID = componentType.getName();
        }
        if (componentType != null && componentImpl != null) {
            componentType = componentImpl.getType();
            called_node_ID = componentType.getName() + "_dot_Impl";
            String inst_cmp = "(.+)_instrumented";
            Pattern inst_pattern = Pattern.compile(inst_cmp);
            // System.out.print(src_portID + " ==> ");
            Matcher m = inst_pattern.matcher(src_portID);
            if (m.matches()) {
                old_portID = src_portID;
                src_portID = m.group(1);
                arg_expr.setIdentifier(componentInstanceID + "_port_" + src_portID);
            // System.out.println(old_portID + " -- " + src_portID);
            }
        // System.out.println(arg_expr.getIdentifier() + " <== " +
        // src_portID);
        } else {
            called_node_ID = componentType.getName();
        }
        String node_arg = "(.+)_Inst_.*";
        Pattern arg_pattern = Pattern.compile(node_arg);
        Matcher m_arg = arg_pattern.matcher(called_node_ID);
        if (!m_arg.matches() && old_portID != null) {
            arg_expr.setIdentifier(componentInstanceID + "_port_" + old_portID);
        // System.out.println("Node ID =>" + called_node_ID + "(" +
        // arg_expr.getIdentifier() + ")");
        }
        // System.out.println(called_node_ID);
        for (Port port : componentType.getPort()) {
            // MODE
            PortMode port_mode = port.getMode();
            if (port_mode == PortMode.OUT) {
                // EQ L.H.S Variables *called Node return values
                String expr_id = componentInstance.getId() + "_port_" + port.getName();
                NodeEquation n_eq = getNodeEq(expr_id, nodeBody);
                if (n_eq != null) {
                    Expression eq_rhs = n_eq.getRhs();
                    NodeCall node_called = eq_rhs.getCall();
                    String inst_cmp = "(.+)_Inst_.*";
                    Pattern inst_pattern = Pattern.compile(inst_cmp);
                    String node_id = "";
                    if (node_called != null) {
                        node_id = node_called.getNodeId();
                    }
                    Matcher m = inst_pattern.matcher(node_id);
                    IfThenElse ifelse = new IfThenElse();
                    Expression called_expr = new Expression();
                    // Condition
                    Expression g_expr = new Expression();
                    if (m.matches()) {
                        // Instrumented component Instance ID
                        String component_id = m.group(1);
                        g_expr.setIdentifier(component_id);
                    }
                    ifelse.setCondition(g_expr);
                    // Then
                    ifelse.setThenBranch(called_expr);
                    // Else
                    // Expression arg = new Expression();
                    ifelse.setElseBranch(arg_expr);
                    // NodeCalled Expr
                    called_expr.setCall(node_called);
                    Expression instrumented_expr = new Expression();
                    instrumented_expr.setConditionalExpression(ifelse);
                    if (node_called != null) {
                        if (node_called.getNodeId().equals(called_node_ID)) {
                            for (Expression a_expr : node_called.getArgument()) {
                                if (a_expr.getIdentifier().equals(dest_component_port.getName())) {
                                    a_expr.setIdentifier(arg_expr.getIdentifier());
                                } else if (node_called.getArgument().size() == 1) {
                                    a_expr.setIdentifier(arg_expr.getIdentifier());
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

Example 3 with NodeEquation

use of verdict.vdm.vdm_lustre.NodeEquation in project VERDICT by ge-high-assurance.

the class Agree2Vdm method translateEqStatementImpl.

private NodeBody translateEqStatementImpl(EqStatementImpl eqStmtImpl, HashSet<String> dataTypeDecl, HashSet<String> nodeDecl, Model model, NodeBody nodebody) {
    // get all LHS identifiers in the statement and add it to the vdm node equation LHS
    NodeEquation vdmNodeEquation = new NodeEquation();
    EList<Arg> agreeLHSArgs = eqStmtImpl.getLhs();
    // this type is just a list of strings
    NodeEquationLHS vdmNodeEquationLHS = new NodeEquationLHS();
    VariableDeclaration varDecl = new VariableDeclaration();
    for (Arg agreeLHSArg : agreeLHSArgs) {
        vdmNodeEquationLHS.getIdentifier().add(agreeLHSArg.getName());
        varDecl.setName(agreeLHSArg.getName());
        varDecl.setDataType(getVdmTypeFromAgreeType(agreeLHSArg.getType(), dataTypeDecl, model));
        nodebody.getVariableDeclaration().add(varDecl);
    }
    vdmNodeEquation.setLhs(vdmNodeEquationLHS);
    // get the RHS i.e.expr of the agree NodeEq and set it as the vdm node equation's RHS
    vdmNodeEquation.setRhs(getVdmExpressionFromAgreeExpression(eqStmtImpl.getExpr(), dataTypeDecl, nodeDecl, model));
    nodebody.getEquation().add(vdmNodeEquation);
    return nodebody;
}

Example 4 with NodeEquation

use of verdict.vdm.vdm_lustre.NodeEquation 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;
}

Example 5 with NodeEquation

use of verdict.vdm.vdm_lustre.NodeEquation in project VERDICT by ge-high-assurance.

the class VDM2Lustre method visit.

public void visit(ComponentType componentType, NodeBody nodeBody, String componentInstanceID, boolean impl_type) {
    // Rename componentType
    String cmpName = componentType.getName();
    cmpName = cmpName.replace(".", "_dot_");
    cmpName = cmpName.replace("::", "_double_colon_");
    componentType.setName(cmpName);
    // Node Equation
    NodeEquation node_eq = new NodeEquation();
    // Return variables
    NodeEquationLHS eq_lhs = new NodeEquationLHS();
    // Node Call
    Expression node = new Expression();
    NodeCall nodeCall = new NodeCall();
    if (impl_type) {
        nodeCall.setNodeId(componentType.getName() + "_dot_Impl");
    } else {
        nodeCall.setNodeId(componentType.getName());
    }
    // Port
    for (Port port : componentType.getPort()) {
        // //Event Port Definition
        // for (Port port : componentType.getPort()) {
        // visit(port);
        // }
        // MODE
        PortMode port_mode = port.getMode();
        if (port_mode == PortMode.IN) {
            Expression arg = new Expression();
            arg.setIdentifier(port.getName());
            nodeCall.getArgument().add(arg);
        }
        if (port_mode == PortMode.OUT) {
            VariableDeclaration var = new VariableDeclaration();
            // Node Name
            String output_name = port.getName();
            String var_name = componentInstanceID + "_port_" + output_name;
            var.setName(var_name);
            // Node DataType
            DataType dataType = port.getType();
            var.setDataType(dataType);
            nodeBody.getVariableDeclaration().add(var);
            eq_lhs.getIdentifier().add(var_name);
        }
    }
    // Ignore node call that do not have output
    if (eq_lhs.getIdentifier() != null) {
        node.setCall(nodeCall);
        node_eq.setRhs(node);
        node_eq.setLhs(eq_lhs);
        nodeBody.getEquation().add(node_eq);
    }
}