Example usage for org.eclipse.jdt.core.dom Block statements

Introduction

In this page you can find the example usage for org.eclipse.jdt.core.dom Block statements.

Prototype

ASTNode.NodeList statements

To view the source code for org.eclipse.jdt.core.dom Block statements.

Click Source Link

Document

The list of statements (element type: Statement ).

Usage

From source file:org.smeup.sys.dk.compiler.rpj.writer.JDTStatementWriter.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override/*from w w w  .j av  a2s.com*/
public boolean visit(QBreak statement) {

    Block block = blocks.peek();
    if (isParentOnError(statement)) {
        IfStatement ifSt = ast.newIfStatement();
        ifSt.setExpression(ast.newName(new String[] { "RPJProgramSupport", "TRUE" }));
        BreakStatement breakSt = ast.newBreakStatement();
        ifSt.setThenStatement(breakSt);

        block.statements().add(ifSt);
    } else {
        BreakStatement breakSt = ast.newBreakStatement();
        block.statements().add(breakSt);
    }

    return super.visit(statement);
}

---

From source file:org.smeup.sys.dk.compiler.rpj.writer.JDTStatementWriter.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override/*w  ww  . j  a  v  a 2s  .c  o m*/
public boolean visit(QCall statement) {

    Block block = blocks.peek();

    MethodInvocation methodInvocation = ast.newMethodInvocation();
    methodInvocation.setExpression(ast.newSimpleName("qRPJ"));
    methodInvocation.setName(ast.newSimpleName("qCall"));

    // program name
    QTermExpression expression = expressionParser.parseTerm(statement.getProgram());
    Expression jdtExpression = JDTStatementHelper.buildExpression(ast, compilationUnit, expression,
            String.class);
    methodInvocation.arguments().add(jdtExpression);

    // array of parameter
    ArrayCreation arrayCreation = ast.newArrayCreation();
    arrayCreation.setType(ast.newArrayType(ast.newSimpleType(ast.newSimpleName(QData.class.getSimpleName()))));
    ArrayInitializer arrayInitializer = ast.newArrayInitializer();
    for (String parameter : statement.getParameters()) {
        expression = expressionParser.parseTerm(parameter);
        jdtExpression = JDTStatementHelper.buildExpression(ast, compilationUnit, expression, QData.class);
        arrayInitializer.expressions().add(jdtExpression);

    }
    arrayCreation.setInitializer(arrayInitializer);
    methodInvocation.arguments().add(arrayCreation);

    // error indicator
    if (statement.getError() != null) {
        QTermExpression errorExpression = expressionParser.parseTerm(statement.getError());
        Expression jdtErrorExpression = JDTStatementHelper.buildExpression(ast, compilationUnit,
                errorExpression, null);

        methodInvocation.arguments().add(jdtErrorExpression);
    }
    // error handling
    if (statement.getErrorHandling() != null) {
        QTermExpression errorExpression = expressionParser.parseTerm(statement.getErrorHandling());
        Expression jdtErrorExpression = JDTStatementHelper.buildExpression(ast, compilationUnit,
                errorExpression, null);

        methodInvocation.arguments().add(jdtErrorExpression);
    }

    ExpressionStatement expressionStatement = ast.newExpressionStatement(methodInvocation);
    block.statements().add(expressionStatement);

    return super.visit(statement);
}

---

From source file:org.smeup.sys.dk.compiler.rpj.writer.JDTStatementWriter.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override// www .  j  a  v a2s.co m
public boolean visit(QContinue statement) {

    Block block = blocks.peek();
    // TODO
    if (isParentOnError(statement) || isParentFor(statement)) {
        IfStatement ifSt = ast.newIfStatement();
        ifSt.setExpression(ast.newName(new String[] { "RPJProgramSupport", "TRUE" }));
        ContinueStatement continueSt = ast.newContinueStatement();
        ifSt.setThenStatement(continueSt);

        block.statements().add(ifSt);
    } else if (isParentIf(statement)) {
        ContinueStatement continueSt = ast.newContinueStatement();
        block.statements().add(continueSt);
    } else {
        ContinueStatement continueSt = ast.newContinueStatement();
        block.statements().add(continueSt);
    }

    return false;
}

---

From source file:org.smeup.sys.dk.compiler.rpj.writer.JDTStatementWriter.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override/*from  ww  w.  j av a  2  s.com*/
public boolean visit(QEval statement) {

    Block block = blocks.peek();

    QAssignmentExpression assignmentExpression = expressionParser.parseAssignment(statement.getAssignment());
    MethodInvocation methodInvocation = buildAssignmentMethod(assignmentExpression, statement.isRightAdjust());

    if (statement.isHalfAdjust() || statement.isMaxPrecision())
        methodInvocation.arguments().add(ast.newBooleanLiteral(statement.isHalfAdjust()));

    if (statement.isMaxPrecision())
        methodInvocation.arguments().add(ast.newBooleanLiteral(statement.isMaxPrecision()));

    ExpressionStatement expressionStatement = ast.newExpressionStatement(methodInvocation);
    block.statements().add(expressionStatement);

    // test annotations
    for (QAnnotationTest annotationTest : statement.getFacets(QAnnotationTest.class))
        writeAssertion(annotationTest, statement.toString());

    return false;
}

---

From source file:org.smeup.sys.dk.compiler.rpj.writer.JDTStatementWriter.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override/*from   w  w  w .  j ava  2 s . c  o  m*/
public boolean visit(QIf statement) {

    Block block = blocks.peek();

    IfStatement ifSt = ast.newIfStatement();

    QPredicateExpression condition = expressionParser.parsePredicate(statement.getCondition());

    Expression expression = null;

    if (RPJContextHelper.isPrimitive(compilationUnit, condition))
        expression = JDTStatementHelper.buildExpression(ast, compilationUnit, condition, Boolean.class);
    else
        expression = JDTStatementHelper.buildExpression(ast, compilationUnit, condition, Boolean.class);

    ifSt.setExpression(expression);

    block.statements().add(ifSt);

    // then
    if (statement.getThen() != null) {
        Block thenBlock = null;
        if (ifSt.getThenStatement() instanceof Block)
            thenBlock = (Block) ifSt.getThenStatement();
        else {
            thenBlock = ast.newBlock();
            ifSt.setThenStatement(thenBlock);
        }

        blocks.push(thenBlock);
        statement.getThen().accept(this);
        blocks.pop();
    }

    // else
    if (statement.getElse() != null) {
        Block elseBlock = null;
        if (ifSt.getElseStatement() instanceof Block)
            elseBlock = (Block) ifSt.getElseStatement();
        else {
            elseBlock = ast.newBlock();
            ifSt.setElseStatement(elseBlock);
        }

        // walk else
        blocks.push(elseBlock);
        statement.getElse().accept(this);
        blocks.pop();
    }

    // interrupt navigation
    return false;
}

---

From source file:org.smeup.sys.dk.compiler.rpj.writer.JDTStatementWriter.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override/*from w ww .ja  va2s. c om*/
public boolean visit(QProcedureExec statement) {

    Block block = blocks.peek();

    MethodInvocation methodInvocation = ast.newMethodInvocation();

    QPrototype prototype = compilationUnit.getPrototype(statement.getProcedure(), true);

    if (prototype == null)
        prototype = compilationUnit.getMethod(null, statement.getProcedure());

    if (prototype == null)
        throw new IntegratedLanguageExpressionRuntimeException("Binding error: " + statement.getProcedure());

    methodInvocation.setName(ast.newSimpleName(compilationUnit.normalizeTermName(prototype.getName())));

    if (!isOwner(prototype)) {
        QNode parent = prototype.getParent();
        if (parent instanceof QModule) {
            methodInvocation.setExpression(
                    ast.newSimpleName(compilationUnit.normalizeModuleName(((QModule) parent).getName())));
        } else if (parent instanceof QNamedNode) {
            // invoke on module
            String qualifiedParent = compilationUnit.getQualifiedName((QNamedNode) parent);
            methodInvocation.setExpression(JDTStatementHelper.buildExpression(ast, compilationUnit,
                    expressionParser.parseTerm(qualifiedParent), null));
        } else
            throw new IntegratedLanguageExpressionRuntimeException(
                    "Invalid procedure: " + statement.getProcedure());

    }

    // entry
    if (prototype.getEntry() != null) {
        Iterator<QEntryParameter<?>> entryParameters = prototype.getEntry().getParameters().iterator();

        for (String parameter : statement.getParameters()) {

            QExpression expression = expressionParser.parseExpression(parameter);

            if (entryParameters.hasNext()) {
                QEntryParameter<?> entryParameter = entryParameters.next();
                QTerm parameterDelegate = entryParameter.getDelegate();

                if (parameterDelegate instanceof QDataTerm) {
                    QDataTerm<?> dataTerm = (QDataTerm<?>) parameterDelegate;

                    if (dataTerm.isConstant() && !dataTerm.getDataTermType().isMultiple()) {
                        Expression jdtExpression = JDTStatementHelper.buildExpression(ast, compilationUnit,
                                expression, dataTerm.getDefinition().getJavaClass());
                        methodInvocation.arguments().add(jdtExpression);
                    } else {
                        Expression jdtExpression = JDTStatementHelper.buildExpression(ast, compilationUnit,
                                expression, dataTerm.getDefinition().getDataClass());
                        methodInvocation.arguments().add(jdtExpression);
                    }
                } else if (parameterDelegate instanceof QDataSetTerm) {
                    Expression jdtExpression = JDTStatementHelper.buildExpression(ast, compilationUnit,
                            expression, QDataSet.class);
                    methodInvocation.arguments().add(jdtExpression);
                } else
                    throw new IntegratedLanguageExpressionRuntimeException(
                            "Invalid procedure invocation: " + statement.getProcedure());
            } else
                throw new IntegratedLanguageExpressionRuntimeException(
                        "Invalid procedure invocation: " + statement.getProcedure());
        }

        while (entryParameters.hasNext()) {
            QEntryParameter<?> entryParameter = entryParameters.next();
            if (entryParameter.isNullable())
                methodInvocation.arguments().add(ast.newNullLiteral());
            else
                throw new IntegratedLanguageExpressionRuntimeException(
                        "Invalid procedure invocation: " + statement.getProcedure());
        }
    }

    ExpressionStatement expressionStatement = ast.newExpressionStatement(methodInvocation);
    block.statements().add(expressionStatement);

    return super.visit(statement);
}

---

From source file:org.smeup.sys.dk.compiler.rpj.writer.JDTStatementWriter.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override//ww w. ja va  2s . co m
public boolean visit(QJump statement) {

    Block block = blocks.peek();

    MethodInvocation methodInvocation = ast.newMethodInvocation();
    methodInvocation.setExpression(ast.newSimpleName("qRPJ"));
    methodInvocation.setName(ast.newSimpleName("qJump"));

    Name labelName = ast
            .newName(new String[] { "TAG", compilationUnit.normalizeLabelName(statement.getLabel()) });
    methodInvocation.arguments().add(0, labelName);

    ExpressionStatement expressionStatement = ast.newExpressionStatement(methodInvocation);
    block.statements().add(expressionStatement);

    // dummy break
    if (isParentFor(statement))
        block.statements().add(ast.newBreakStatement());

    return super.visit(statement);
}

---

From source file:org.smeup.sys.dk.compiler.rpj.writer.JDTStatementWriter.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override/*  w w  w. jav  a2  s .c  o m*/
public boolean visit(QLabel statement) {

    Block block = blocks.peek();

    MethodInvocation methodInvocation = ast.newMethodInvocation();
    methodInvocation.setExpression(ast.newSimpleName("qRPJ"));
    methodInvocation.setName(ast.newSimpleName("qLabel"));

    Name labelName = ast
            .newName(new String[] { "TAG", compilationUnit.normalizeLabelName(statement.getName()) });
    methodInvocation.arguments().add(0, labelName);

    ExpressionStatement expressionStatement = ast.newExpressionStatement(methodInvocation);
    block.statements().add(expressionStatement);

    return super.visit(statement);
}

---

From source file:org.smeup.sys.dk.compiler.rpj.writer.JDTStatementWriter.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override//w w  w . j  a va2 s  .  c  o  m
public boolean visit(QMethodExec statement) {

    Block block = blocks.peek();
    if (statement.getObject() != null) {

        MethodInvocation methodInvocation = ast.newMethodInvocation();
        methodInvocation.setName(ast.newSimpleName(compilationUnit.normalizeTermName(statement.getMethod())));

        QExpression objectExpression = expressionParser.parseExpression(statement.getObject());
        QNamedNode namedNode = null;
        if (objectExpression instanceof QTermExpression) {
            QTermExpression termExpression = (QTermExpression) objectExpression;

            switch (termExpression.getExpressionType()) {
            case FUNCTION:
                namedNode = compilationUnit.getNamedNode(termExpression.getValue(), true);
                break;
            case QUALIFIED:
                namedNode = compilationUnit.getNamedNode(termExpression.getValue(), true);
                break;
            case ATOMIC: {
                QAtomicTermExpression atomicTermExpression = (QAtomicTermExpression) termExpression;
                if (atomicTermExpression.getType() == AtomicType.NAME)
                    namedNode = compilationUnit.getNamedNode(termExpression.getValue(), true);
                break;
            }

            case ARITHMETIC:
            case ARRAY:
            case ASSIGNMENT:
            case BLOCK:
            case BOOLEAN:
            case LOGICAL:
            case RELATIONAL:
                break;
            }
        }

        if (namedNode == null) {
            Class<?> target = null;
            if (objectExpression instanceof QArithmeticExpression
                    || objectExpression instanceof QBlockExpression) {
                target = RPJContextHelper.getTargetClass(compilationUnit, objectExpression, false);
                // force boxing
                if (String.class.isAssignableFrom(target))
                    target = QCharacter.class;
                else if (Number.class.isAssignableFrom(target))
                    target = QNumeric.class;
                else if (Date.class.isAssignableFrom(target))
                    target = QDatetime.class;
            } else if (objectExpression instanceof QAtomicTermExpression) {
                QAtomicTermExpression atomicTermExpression = (QAtomicTermExpression) objectExpression;
                switch (atomicTermExpression.getType()) {
                case BOOLEAN:
                    target = QIndicator.class;
                    break;
                case DATE:
                case TIME:
                case TIMESTAMP:
                    target = QDatetime.class;
                    break;
                case FLOATING:
                    target = QFloating.class;
                    break;
                case HEXADECIMAL:
                    target = QHexadecimal.class;
                    break;
                case INDICATOR:
                    target = QIndicator.class;
                    break;
                case INTEGER:
                    target = QDecimal.class;
                    break;
                case STRING:
                    target = QCharacter.class;
                    break;
                case SPECIAL:
                case NAME:
                    target = QData.class;
                    break;
                }
            }
            methodInvocation.setExpression(
                    JDTStatementHelper.buildExpression(ast, compilationUnit, objectExpression, target));
        }
        // display and print
        else if (namedNode.getParent() instanceof QDisplayTerm || namedNode.getParent() instanceof QPrintTerm) {

            methodInvocation.setExpression(
                    ast.newName(compilationUnit.getQualifiedName((QNamedNode) namedNode.getParent())));

            TypeLiteral typeLiteral = ast.newTypeLiteral();
            String fileName = compilationUnit.normalizeTypeName(((QNamedNode) namedNode.getParent()).getName());
            String formatName = compilationUnit.normalizeTypeName(namedNode.getName());
            typeLiteral.setType(ast.newSimpleType(ast.newName(new String[] { fileName, formatName })));

            methodInvocation.arguments().add(typeLiteral);

        } else {
            Class<?> target = RPJContextHelper.getTargetClass(compilationUnit, objectExpression, false);
            methodInvocation.setExpression(
                    JDTStatementHelper.buildExpression(ast, compilationUnit, objectExpression, target));

            if (target != null && QDataArea.class.isAssignableFrom(target)) {

                // unwrap
                if (!isDataAreaMethod(statement.getMethod())) {
                    MethodInvocation unwrapMethodInvocation = ast.newMethodInvocation();
                    unwrapMethodInvocation.setName(ast.newSimpleName("get"));
                    unwrapMethodInvocation.setExpression(
                            JDTStatementHelper.buildExpression(ast, compilationUnit, objectExpression, null));
                    methodInvocation.setExpression(unwrapMethodInvocation);
                }
            }
        }

        if (statement.getParameters() != null) {
            for (String parameter : statement.getParameters()) {
                QExpression expression = expressionParser.parseExpression(parameter);
                Expression jdtExpression = JDTStatementHelper.buildExpression(ast, compilationUnit, expression,
                        null);
                methodInvocation.arguments().add(jdtExpression);
            }
        }

        ExpressionStatement expressionStatement = ast.newExpressionStatement(methodInvocation);
        block.statements().add(expressionStatement);

    } else {
        QProcedureExec procedureExec = QIntegratedLanguageFlowFactory.eINSTANCE.createProcedureExec();
        procedureExec.setProcedure(statement.getMethod());
        procedureExec.getParameters().addAll(statement.getParameters());
        visit(procedureExec);
    }

    // test annotations
    for (QAnnotationTest annotationTest : statement.getFacets(QAnnotationTest.class))
        writeAssertion(annotationTest, statement.toString());

    return false;
}

---

From source file:org.smeup.sys.dk.compiler.rpj.writer.JDTStatementWriter.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override/*from  w ww . ja  v a  2  s  .  com*/
public boolean visit(QMonitor statement) {

    Block block = blocks.peek();

    // -> try
    TryStatement tryStatement = ast.newTryStatement();
    blocks.push(tryStatement.getBody());
    if (statement.getBody() != null)
        statement.getBody().accept(this);

    String exceptionName = "e" + blocks.size();

    // catch
    CatchClause catchClause = ast.newCatchClause();
    SingleVariableDeclaration exceptionDeclaration = ast.newSingleVariableDeclaration();

    Type exception = ast
            .newSimpleType(ast.newSimpleName(OperatingSystemMessageException.class.getSimpleName()));
    exceptionDeclaration.setType(exception);
    exceptionDeclaration.setName(ast.newSimpleName(exceptionName));
    catchClause.setException(exceptionDeclaration);
    tryStatement.catchClauses().add(catchClause);

    // -> catch
    blocks.push(catchClause.getBody());

    // switch
    SwitchStatement switchStatement = ast.newSwitchStatement();

    MethodInvocation methodInvocation = ast.newMethodInvocation();
    methodInvocation.setExpression(ast.newSimpleName(exceptionName));
    methodInvocation.setName(ast.newSimpleName("getMessageName"));

    switchStatement.setExpression(methodInvocation);

    boolean defaultError = true;
    boolean caseStatement = false;
    for (QOnError error : statement.getOnErrors()) {
        if (error.getBody() == null)
            continue;

        if (error.getErrors().isEmpty() || error.getErrors().contains("CPF0000")
                || error.getErrors().contains("*ALL")) {
            // Case
            SwitchCase switchCase = ast.newSwitchCase();
            switchCase.setExpression(null);
            switchStatement.statements().add(switchCase);
            defaultError = false;
        } else {
            for (String caseError : error.getErrors()) {
                StringLiteral caseLiteral = ast.newStringLiteral();
                caseLiteral.setLiteralValue(caseError);
                // Case
                SwitchCase switchCase = ast.newSwitchCase();
                switchCase.setExpression(caseLiteral);
                switchStatement.statements().add(switchCase);
            }
        }

        // Case body

        // -> Case
        Block caseBlock = ast.newBlock();
        blocks.push(caseBlock);

        error.getBody().accept(this);

        // copy case block to switch statement
        for (int i = 0; i < caseBlock.statements().size(); i++) {
            Object temp = caseBlock.statements().remove(i);
            if (temp instanceof Block) {
                Block tempBlock = (Block) temp;
                if (tempBlock.statements().isEmpty())
                    continue;
            }

            caseStatement = true;
            switchStatement.statements().add(temp);
        }

        switchStatement.statements().add(ast.newBreakStatement());

        // <- case
        blocks.pop();
    }

    if (defaultError) {
        SwitchCase switchCase = ast.newSwitchCase();
        switchCase.setExpression(null);
        switchStatement.statements().add(switchCase);
        ThrowStatement throwStatement = ast.newThrowStatement();
        throwStatement.setExpression(ast.newSimpleName(exceptionName));

        switchStatement.statements().add(throwStatement);

        blocks.peek().statements().add(switchStatement);
    } else if (caseStatement) {
        blocks.peek().statements().add(switchStatement);
    }

    // <-catch
    blocks.pop();

    // <-try
    blocks.pop();

    block.statements().add(tryStatement);

    return false;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• »