Search in sources :

Example 1 with BinaryOperation

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

the class VDMInstrumentor method or_expr.

protected Expression or_expr(Stack<Expression> expr_stack) {
    while (expr_stack.size() > 1) {
        Expression left_expr = expr_stack.pop();
        Expression right_expr = expr_stack.pop();
        BinaryOperation or_op = new BinaryOperation();
        or_op.setLhsOperand(left_expr);
        or_op.setRhsOperand(right_expr);
        Expression or_expr = new Expression();
        or_expr.setOr(or_op);
        expr_stack.push(or_expr);
    }
    return expr_stack.pop();
}
Also used : Expression(verdict.vdm.vdm_lustre.Expression) BinaryOperation(verdict.vdm.vdm_lustre.BinaryOperation)

Example 2 with BinaryOperation

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

the class VerdictLustreListener method exitBinaryExpr.

/**
 * Extract a binary operation.
 */
@Override
public void exitBinaryExpr(LustreParser.BinaryExprContext ctx) {
    BinaryOperation binaryOperation = new BinaryOperation();
    binaryOperation.setLhsOperand(ctx.expr(0).expression);
    binaryOperation.setRhsOperand(ctx.expr(1).expression);
    ctx.expression = new Expression();
    switch(ctx.op.getText()) {
        case "^":
            ctx.expression.setCartesianExpression(binaryOperation);
            break;
        case "when":
            ctx.expression.setWhen(binaryOperation);
            break;
        case "*":
            ctx.expression.setTimes(binaryOperation);
            break;
        case "/":
            ctx.expression.setDiv(binaryOperation);
            break;
        case "%":
        case "mod":
            ctx.expression.setMod(binaryOperation);
            break;
        case "div":
            ctx.expression.setIntDiv(binaryOperation);
            break;
        case "+":
            ctx.expression.setPlus(binaryOperation);
            break;
        case "-":
            ctx.expression.setMinus(binaryOperation);
            break;
        case "<":
            ctx.expression.setLessThan(binaryOperation);
            break;
        case "<=":
            ctx.expression.setLessThanOrEqualTo(binaryOperation);
            break;
        case "=":
            ctx.expression.setEqual(binaryOperation);
            break;
        case ">=":
            ctx.expression.setGreaterThanOrEqualTo(binaryOperation);
            break;
        case ">":
            ctx.expression.setGreaterThan(binaryOperation);
            break;
        case "<>":
            ctx.expression.setNotEqual(binaryOperation);
            break;
        case "and":
            ctx.expression.setAnd(binaryOperation);
            break;
        case "or":
            ctx.expression.setOr(binaryOperation);
            break;
        case "xor":
            ctx.expression.setXor(binaryOperation);
            break;
        case "=>":
            ctx.expression.setImplies(binaryOperation);
            break;
        case "->":
        case "fby":
            ctx.expression.setArrow(binaryOperation);
            break;
        case "|":
            ctx.expression.setConcat(binaryOperation);
            break;
    }
}
Also used : Expression(verdict.vdm.vdm_lustre.Expression) BinaryOperation(verdict.vdm.vdm_lustre.BinaryOperation)

Example 3 with BinaryOperation

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

the class VDM2Lustre method visitExpression.

protected Expression visitExpression(Expression expr) {
    Expression u_Expr = new Expression();
    // Binary Operators
    if (expr != null) {
        BinaryOperation op = expr.getEqual();
        if (op != null) {
            u_Expr.setEqual(binaryOP(op));
        }
        op = expr.getNotEqual();
        if (op != null) {
            u_Expr.setNotEqual(binaryOP(op));
        }
        op = expr.getImplies();
        if (op != null) {
            u_Expr.setImplies(binaryOP(op));
        }
        op = expr.getAnd();
        if (op != null) {
            u_Expr.setAnd(binaryOP(op));
        }
        op = expr.getOr();
        if (op != null) {
            u_Expr.setOr(binaryOP(op));
        }
        op = expr.getXor();
        if (op != null) {
            u_Expr.setXor(binaryOP(op));
        }
        op = expr.getArrow();
        if (op != null) {
            u_Expr.setArrow(binaryOP(op));
        }
        op = expr.getLessThanOrEqualTo();
        if (op != null) {
            u_Expr.setLessThanOrEqualTo(binaryOP(op));
        }
        op = expr.getLessThan();
        if (op != null) {
            u_Expr.setLessThan(binaryOP(op));
        }
        op = expr.getGreaterThan();
        if (op != null) {
            u_Expr.setGreaterThan(binaryOP(op));
        }
        op = expr.getGreaterThanOrEqualTo();
        if (op != null) {
            u_Expr.setGreaterThanOrEqualTo(binaryOP(op));
        }
        op = expr.getMinus();
        if (op != null) {
            u_Expr.setMinus(binaryOP(op));
        }
        op = expr.getPlus();
        if (op != null) {
            u_Expr.setPlus(binaryOP(op));
        }
        op = expr.getDiv();
        if (op != null) {
            u_Expr.setDiv(binaryOP(op));
        }
        op = expr.getTimes();
        if (op != null) {
            u_Expr.setTimes(binaryOP(op));
        }
        op = expr.getMod();
        if (op != null) {
            u_Expr.setMod(binaryOP(op));
        }
        op = expr.getCartesianExpression();
        if (op != null) {
            u_Expr.setCartesianExpression(binaryOP(op));
        }
        IfThenElse cond_op = expr.getConditionalExpression();
        if (cond_op != null) {
            Expression cond_expr = cond_op.getCondition();
            cond_expr = visitExpression(cond_expr);
            Expression then_expr = cond_op.getThenBranch();
            then_expr = visitExpression(then_expr);
            Expression else_expr = cond_op.getElseBranch();
            else_expr = visitExpression(else_expr);
            cond_op.setCondition(cond_expr);
            cond_op.setThenBranch(then_expr);
            cond_op.setElseBranch(else_expr);
            u_Expr.setConditionalExpression(cond_op);
        }
        // Record Literal
        RecordLiteral recordLiteral = expr.getRecordLiteral();
        if (recordLiteral != null) {
            Expression fieldExpr;
            for (FieldDefinition fieldDef : recordLiteral.getFieldDefinition()) {
                fieldExpr = fieldDef.getFieldValue();
                visitExpression(fieldExpr);
            }
            u_Expr.setRecordLiteral(recordLiteral);
        }
        // Record Project
        RecordProjection recordProj = expr.getRecordProjection();
        if (recordProj != null) {
            Expression recordRef = recordProj.getRecordReference();
            recordRef = visitExpression(recordRef);
            recordProj.setRecordReference(recordRef);
            u_Expr.setRecordProjection(recordProj);
        }
        // Unary Operators
        Expression notExpr = expr.getNot();
        if (notExpr != null) {
            notExpr = visitExpression(notExpr);
            u_Expr.setNot(notExpr);
        }
        Expression negExpr = expr.getNegative();
        if (negExpr != null) {
            negExpr = visitExpression(negExpr);
            u_Expr.setNegative(negExpr);
            ;
        }
        Expression preExpr = expr.getPre();
        if (preExpr != null) {
            preExpr = visitExpression(preExpr);
            u_Expr.setPre(preExpr);
        }
        Expression toIntExpr = expr.getToInt();
        if (toIntExpr != null) {
            toIntExpr = visitExpression(toIntExpr);
            u_Expr.setToInt(toIntExpr);
        }
        Expression toRealExpr = expr.getToReal();
        if (toRealExpr != null) {
            toRealExpr = visitExpression(toRealExpr);
            u_Expr.setToReal(toRealExpr);
        }
        Boolean b = expr.isBoolLiteral();
        if (b != null) {
            u_Expr.setBoolLiteral(b);
        }
        BigInteger int_value = expr.getIntLiteral();
        if (int_value != null) {
            u_Expr.setIntLiteral(int_value);
        }
        BigDecimal real_value = expr.getRealLiteral();
        if (real_value != null) {
            u_Expr.setRealLiteral(real_value);
        }
        // Identifier
        String identifier = expr.getIdentifier();
        if (identifier != null) {
            if (eventDeclarations.containsKey(identifier)) {
                u_Expr = eventExpression(expr, false);
            } else {
                u_Expr.setIdentifier(identifier);
            }
        }
        // NodeCall
        NodeCall nodeCall = expr.getCall();
        if (nodeCall != null) {
            u_Expr.setCall(nodeCall);
            List<Expression> arguments = new Vector<Expression>();
            for (Expression argExpr : nodeCall.getArgument()) {
                argExpr = visitExpression(argExpr);
                arguments.add(argExpr);
            }
            nodeCall.getArgument().clear();
            nodeCall.getArgument().addAll(arguments);
            u_Expr.setCall(nodeCall);
        }
        // Event Expression
        Expression event = expr.getEvent();
        if (event != null) {
            u_Expr = eventExpression(event, true);
        // System.out.println(expr + "^^^ Updated to Event ^^^ " + event);
        }
        ExpressionList expList = expr.getExpressionList();
        if (expList != null) {
            ExpressionList uList = new ExpressionList();
            for (Expression aexpr : expList.getExpression()) {
                expr = visitExpression(aexpr);
                uList.getExpression().add(expr);
            }
            expList.getExpression().clear();
            u_Expr.setExpressionList(uList);
        }
    // ExpressionList arrayExpList = expr.getArrayExpression();
    // 
    // if(expList != null) {
    // List<Expression> uList = new ArrayList<Expression>();
    // for(Expression aexpr: arrayExpList.getExpression()) {
    // expr = visitExpression(aexpr);
    // uList.add(expr);
    // }
    // arrayExpList.getExpression().clear();
    // arrayExpList.getExpression().addAll(uList);
    // u_Expr.setArrayExpression(arrayExpList);
    // }
    }
    return u_Expr;
}
Also used : RecordLiteral(verdict.vdm.vdm_lustre.RecordLiteral) NodeCall(verdict.vdm.vdm_lustre.NodeCall) BinaryOperation(verdict.vdm.vdm_lustre.BinaryOperation) FieldDefinition(verdict.vdm.vdm_lustre.FieldDefinition) BigDecimal(java.math.BigDecimal) Expression(verdict.vdm.vdm_lustre.Expression) RecordProjection(verdict.vdm.vdm_lustre.RecordProjection) BigInteger(java.math.BigInteger) IfThenElse(verdict.vdm.vdm_lustre.IfThenElse) Vector(java.util.Vector) ExpressionList(verdict.vdm.vdm_lustre.ExpressionList)

Example 4 with BinaryOperation

use of verdict.vdm.vdm_lustre.BinaryOperation 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;
}
Also used : BinaryOperation(verdict.vdm.vdm_lustre.BinaryOperation) EventPort(org.osate.aadl2.EventPort) DataPort(org.osate.aadl2.DataPort) Port(org.osate.aadl2.Port) EventDataPort(org.osate.aadl2.EventDataPort) FieldDefinition(verdict.vdm.vdm_lustre.FieldDefinition) ConstantDeclaration(verdict.vdm.vdm_lustre.ConstantDeclaration) SelectionExpr(com.rockwellcollins.atc.agree.agree.SelectionExpr) DataPort(org.osate.aadl2.DataPort) EventDataPort(org.osate.aadl2.EventDataPort) RealCast(com.rockwellcollins.atc.agree.agree.RealCast) RecordProjection(verdict.vdm.vdm_lustre.RecordProjection) DoubleDotRef(com.rockwellcollins.atc.agree.agree.DoubleDotRef) PrimType(com.rockwellcollins.atc.agree.agree.PrimType) CallExpr(com.rockwellcollins.atc.agree.agree.CallExpr) EventDataPort(org.osate.aadl2.EventDataPort) NamedElmExpr(com.rockwellcollins.atc.agree.agree.NamedElmExpr) RecordLiteral(verdict.vdm.vdm_lustre.RecordLiteral) EnumLitExpr(com.rockwellcollins.atc.agree.agree.EnumLitExpr) EventDataPortImpl(org.osate.aadl2.impl.EventDataPortImpl) RecordLitExpr(com.rockwellcollins.atc.agree.agree.RecordLitExpr) UnaryExpr(com.rockwellcollins.atc.agree.agree.UnaryExpr) IfThenElseExpr(com.rockwellcollins.atc.agree.agree.IfThenElseExpr) ConstStatement(com.rockwellcollins.atc.agree.agree.ConstStatement) DataSubcomponentType(org.osate.aadl2.DataSubcomponentType) PreExpr(com.rockwellcollins.atc.agree.agree.PreExpr) EnumLitExpr(com.rockwellcollins.atc.agree.agree.EnumLitExpr) RealLitExpr(com.rockwellcollins.atc.agree.agree.RealLitExpr) EventExpr(com.rockwellcollins.atc.agree.agree.EventExpr) NamedElmExpr(com.rockwellcollins.atc.agree.agree.NamedElmExpr) SelectionExpr(com.rockwellcollins.atc.agree.agree.SelectionExpr) IfThenElseExpr(com.rockwellcollins.atc.agree.agree.IfThenElseExpr) PreExpr(com.rockwellcollins.atc.agree.agree.PreExpr) RecordLitExpr(com.rockwellcollins.atc.agree.agree.RecordLitExpr) BinaryExpr(com.rockwellcollins.atc.agree.agree.BinaryExpr) UnaryExpr(com.rockwellcollins.atc.agree.agree.UnaryExpr) Expr(com.rockwellcollins.atc.agree.agree.Expr) BoolLitExpr(com.rockwellcollins.atc.agree.agree.BoolLitExpr) NodeBodyExpr(com.rockwellcollins.atc.agree.agree.NodeBodyExpr) IntLitExpr(com.rockwellcollins.atc.agree.agree.IntLitExpr) CallExpr(com.rockwellcollins.atc.agree.agree.CallExpr) IntLitExpr(com.rockwellcollins.atc.agree.agree.IntLitExpr) Arg(com.rockwellcollins.atc.agree.agree.Arg) BigInteger(java.math.BigInteger) RealLitExpr(com.rockwellcollins.atc.agree.agree.RealLitExpr) NamedElement(org.osate.aadl2.NamedElement) ArgImpl(com.rockwellcollins.atc.agree.agree.impl.ArgImpl) BoolLitExpr(com.rockwellcollins.atc.agree.agree.BoolLitExpr) NodeDef(com.rockwellcollins.atc.agree.agree.NodeDef) EventExpr(com.rockwellcollins.atc.agree.agree.EventExpr) DataSubcomponentImpl(org.osate.aadl2.impl.DataSubcomponentImpl) EventPort(org.osate.aadl2.EventPort) NodeCall(verdict.vdm.vdm_lustre.NodeCall) DataPortImpl(org.osate.aadl2.impl.DataPortImpl) EventDataPortImpl(org.osate.aadl2.impl.EventDataPortImpl) BinaryExpr(com.rockwellcollins.atc.agree.agree.BinaryExpr) DataImplementation(org.osate.aadl2.DataImplementation) BigDecimal(java.math.BigDecimal) PrimType(com.rockwellcollins.atc.agree.agree.PrimType) DataSubcomponentType(org.osate.aadl2.DataSubcomponentType) Type(com.rockwellcollins.atc.agree.agree.Type) EnumType(verdict.vdm.vdm_data.EnumType) RecordType(verdict.vdm.vdm_data.RecordType) SystemType(org.osate.aadl2.SystemType) ComponentType(verdict.vdm.vdm_model.ComponentType) EList(org.eclipse.emf.common.util.EList) PropertyExpression(org.osate.aadl2.PropertyExpression) Expression(verdict.vdm.vdm_lustre.Expression) LustreProgram(verdict.vdm.vdm_lustre.LustreProgram) DataSubcomponent(org.osate.aadl2.DataSubcomponent) DataTypeImpl(org.osate.aadl2.impl.DataTypeImpl) IfThenElse(verdict.vdm.vdm_lustre.IfThenElse)

Example 5 with BinaryOperation

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

the class VDM2Lustre method binaryOP.

protected BinaryOperation binaryOP(BinaryOperation op) {
    BinaryOperation op_exp = new BinaryOperation();
    Expression lhs = op.getLhsOperand();
    lhs = visitExpression(lhs);
    Expression rhs = op.getRhsOperand();
    rhs = visitExpression(rhs);
    op_exp.setLhsOperand(lhs);
    op_exp.setRhsOperand(rhs);
    return op_exp;
}
Also used : Expression(verdict.vdm.vdm_lustre.Expression) BinaryOperation(verdict.vdm.vdm_lustre.BinaryOperation)

Aggregations

BinaryOperation (verdict.vdm.vdm_lustre.BinaryOperation)8 Expression (verdict.vdm.vdm_lustre.Expression)8 FieldDefinition (verdict.vdm.vdm_lustre.FieldDefinition)3 NodeCall (verdict.vdm.vdm_lustre.NodeCall)3 RecordLiteral (verdict.vdm.vdm_lustre.RecordLiteral)3 BigDecimal (java.math.BigDecimal)2 BigInteger (java.math.BigInteger)2 IfThenElse (verdict.vdm.vdm_lustre.IfThenElse)2 RecordProjection (verdict.vdm.vdm_lustre.RecordProjection)2 Arg (com.rockwellcollins.atc.agree.agree.Arg)1 BinaryExpr (com.rockwellcollins.atc.agree.agree.BinaryExpr)1 BoolLitExpr (com.rockwellcollins.atc.agree.agree.BoolLitExpr)1 CallExpr (com.rockwellcollins.atc.agree.agree.CallExpr)1 ConstStatement (com.rockwellcollins.atc.agree.agree.ConstStatement)1 DoubleDotRef (com.rockwellcollins.atc.agree.agree.DoubleDotRef)1 EnumLitExpr (com.rockwellcollins.atc.agree.agree.EnumLitExpr)1 EventExpr (com.rockwellcollins.atc.agree.agree.EventExpr)1 Expr (com.rockwellcollins.atc.agree.agree.Expr)1 IfThenElseExpr (com.rockwellcollins.atc.agree.agree.IfThenElseExpr)1 IntLitExpr (com.rockwellcollins.atc.agree.agree.IntLitExpr)1