Example usage for org.eclipse.jdt.core.dom InfixExpression InfixExpression

Introduction

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

Prototype

InfixExpression(AST ast) 

Source Link

Document

Creates a new AST node for an infix expression owned by the given AST.

Usage

From source file:org.eclipse.jdt.core.dom.ASTConverter.java

License:Open Source License

public Expression convert(org.eclipse.jdt.internal.compiler.ast.AND_AND_Expression expression) {
    InfixExpression infixExpression = new InfixExpression(this.ast);
    infixExpression.setOperator(InfixExpression.Operator.CONDITIONAL_AND);
    if (this.resolveBindings) {
        this.recordNodes(infixExpression, expression);
    }//from  w  ww. j  a  v a2 s .com
    final int expressionOperatorID = (expression.bits
            & org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorMASK) >> org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorSHIFT;
    if (expression.left instanceof org.eclipse.jdt.internal.compiler.ast.BinaryExpression
            && ((expression.left.bits
                    & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0)) {
        // create an extended string literal equivalent => use the extended operands list
        infixExpression.extendedOperands().add(convert(expression.right));
        org.eclipse.jdt.internal.compiler.ast.Expression leftOperand = expression.left;
        org.eclipse.jdt.internal.compiler.ast.Expression rightOperand = null;
        do {
            rightOperand = ((org.eclipse.jdt.internal.compiler.ast.BinaryExpression) leftOperand).right;
            if ((((leftOperand.bits
                    & org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorMASK) >> org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorSHIFT) != expressionOperatorID
                    && ((leftOperand.bits
                            & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0))
                    || ((rightOperand instanceof org.eclipse.jdt.internal.compiler.ast.BinaryExpression
                            && ((rightOperand.bits
                                    & org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorMASK) >> org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorSHIFT) != expressionOperatorID)
                            && ((rightOperand.bits
                                    & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0))) {
                List extendedOperands = infixExpression.extendedOperands();
                InfixExpression temp = new InfixExpression(this.ast);
                if (this.resolveBindings) {
                    this.recordNodes(temp, expression);
                }
                temp.setOperator(getOperatorFor(expressionOperatorID));
                Expression leftSide = convert(leftOperand);
                temp.setLeftOperand(leftSide);
                temp.setSourceRange(leftSide.getStartPosition(), leftSide.getLength());
                int size = extendedOperands.size();
                for (int i = 0; i < size - 1; i++) {
                    Expression expr = temp;
                    temp = new InfixExpression(this.ast);

                    if (this.resolveBindings) {
                        this.recordNodes(temp, expression);
                    }
                    temp.setLeftOperand(expr);
                    temp.setOperator(getOperatorFor(expressionOperatorID));
                    temp.setSourceRange(expr.getStartPosition(), expr.getLength());
                }
                infixExpression = temp;
                for (int i = 0; i < size; i++) {
                    Expression extendedOperand = (Expression) extendedOperands.remove(size - 1 - i);
                    temp.setRightOperand(extendedOperand);
                    int startPosition = temp.getLeftOperand().getStartPosition();
                    temp.setSourceRange(startPosition,
                            extendedOperand.getStartPosition() + extendedOperand.getLength() - startPosition);
                    if (temp.getLeftOperand().getNodeType() == ASTNode.INFIX_EXPRESSION) {
                        temp = (InfixExpression) temp.getLeftOperand();
                    }
                }
                int startPosition = infixExpression.getLeftOperand().getStartPosition();
                infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
                if (this.resolveBindings) {
                    this.recordNodes(infixExpression, expression);
                }
                return infixExpression;
            }
            infixExpression.extendedOperands().add(0, convert(rightOperand));
            leftOperand = ((org.eclipse.jdt.internal.compiler.ast.BinaryExpression) leftOperand).left;
        } while (leftOperand instanceof org.eclipse.jdt.internal.compiler.ast.BinaryExpression
                && ((leftOperand.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0));
        Expression leftExpression = convert(leftOperand);
        infixExpression.setLeftOperand(leftExpression);
        infixExpression.setRightOperand((Expression) infixExpression.extendedOperands().remove(0));
        int startPosition = leftExpression.getStartPosition();
        infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
        return infixExpression;
    }
    Expression leftExpression = convert(expression.left);
    infixExpression.setLeftOperand(leftExpression);
    infixExpression.setRightOperand(convert(expression.right));
    infixExpression.setOperator(InfixExpression.Operator.CONDITIONAL_AND);
    int startPosition = leftExpression.getStartPosition();
    infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
    return infixExpression;
}

---

From source file:org.eclipse.jdt.core.dom.ASTConverter.java

License:Open Source License

public Expression convert(org.eclipse.jdt.internal.compiler.ast.BinaryExpression expression) {
    InfixExpression infixExpression = new InfixExpression(this.ast);
    if (this.resolveBindings) {
        this.recordNodes(infixExpression, expression);
    }//ww w  .  j a v  a 2  s. c o m

    int expressionOperatorID = (expression.bits
            & org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorMASK) >> org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorSHIFT;
    infixExpression.setOperator(getOperatorFor(expressionOperatorID));

    if (expression.left instanceof org.eclipse.jdt.internal.compiler.ast.BinaryExpression
            && ((expression.left.bits
                    & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0)) {
        // create an extended string literal equivalent => use the extended operands list
        infixExpression.extendedOperands().add(convert(expression.right));
        org.eclipse.jdt.internal.compiler.ast.Expression leftOperand = expression.left;
        org.eclipse.jdt.internal.compiler.ast.Expression rightOperand = null;
        do {
            rightOperand = ((org.eclipse.jdt.internal.compiler.ast.BinaryExpression) leftOperand).right;
            if ((((leftOperand.bits
                    & org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorMASK) >> org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorSHIFT) != expressionOperatorID
                    && ((leftOperand.bits
                            & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0))
                    || ((rightOperand instanceof org.eclipse.jdt.internal.compiler.ast.BinaryExpression
                            && ((rightOperand.bits
                                    & org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorMASK) >> org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorSHIFT) != expressionOperatorID)
                            && ((rightOperand.bits
                                    & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0))) {
                List extendedOperands = infixExpression.extendedOperands();
                InfixExpression temp = new InfixExpression(this.ast);
                if (this.resolveBindings) {
                    this.recordNodes(temp, expression);
                }
                temp.setOperator(getOperatorFor(expressionOperatorID));
                Expression leftSide = convert(leftOperand);
                temp.setLeftOperand(leftSide);
                temp.setSourceRange(leftSide.getStartPosition(), leftSide.getLength());
                int size = extendedOperands.size();
                for (int i = 0; i < size - 1; i++) {
                    Expression expr = temp;
                    temp = new InfixExpression(this.ast);

                    if (this.resolveBindings) {
                        this.recordNodes(temp, expression);
                    }
                    temp.setLeftOperand(expr);
                    temp.setOperator(getOperatorFor(expressionOperatorID));
                    temp.setSourceRange(expr.getStartPosition(), expr.getLength());
                }
                infixExpression = temp;
                for (int i = 0; i < size; i++) {
                    Expression extendedOperand = (Expression) extendedOperands.remove(size - 1 - i);
                    temp.setRightOperand(extendedOperand);
                    int startPosition = temp.getLeftOperand().getStartPosition();
                    temp.setSourceRange(startPosition,
                            extendedOperand.getStartPosition() + extendedOperand.getLength() - startPosition);
                    if (temp.getLeftOperand().getNodeType() == ASTNode.INFIX_EXPRESSION) {
                        temp = (InfixExpression) temp.getLeftOperand();
                    }
                }
                int startPosition = infixExpression.getLeftOperand().getStartPosition();
                infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
                if (this.resolveBindings) {
                    this.recordNodes(infixExpression, expression);
                }
                return infixExpression;
            }
            infixExpression.extendedOperands().add(0, convert(rightOperand));
            leftOperand = ((org.eclipse.jdt.internal.compiler.ast.BinaryExpression) leftOperand).left;
        } while (leftOperand instanceof org.eclipse.jdt.internal.compiler.ast.BinaryExpression
                && ((leftOperand.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0));
        Expression leftExpression = convert(leftOperand);
        infixExpression.setLeftOperand(leftExpression);
        infixExpression.setRightOperand((Expression) infixExpression.extendedOperands().remove(0));
        int startPosition = leftExpression.getStartPosition();
        infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
        return infixExpression;
    } else if (expression.left instanceof StringLiteralConcatenation
            && ((expression.left.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0)
            && (OperatorIds.PLUS == expressionOperatorID)) {
        StringLiteralConcatenation literal = (StringLiteralConcatenation) expression.left;
        final org.eclipse.jdt.internal.compiler.ast.Expression[] stringLiterals = literal.literals;
        infixExpression.setLeftOperand(convert(stringLiterals[0]));
        infixExpression.setRightOperand(convert(stringLiterals[1]));
        for (int i = 2; i < literal.counter; i++) {
            infixExpression.extendedOperands().add(convert(stringLiterals[i]));
        }
        infixExpression.extendedOperands().add(convert(expression.right));
        int startPosition = literal.sourceStart;
        infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
        return infixExpression;
    }
    Expression leftExpression = convert(expression.left);
    infixExpression.setLeftOperand(leftExpression);
    infixExpression.setRightOperand(convert(expression.right));
    int startPosition = leftExpression.getStartPosition();
    infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
    return infixExpression;
}

---

From source file:org.eclipse.jdt.core.dom.ASTConverter.java

License:Open Source License

public Expression convert(org.eclipse.jdt.internal.compiler.ast.EqualExpression expression) {
    InfixExpression infixExpression = new InfixExpression(this.ast);
    if (this.resolveBindings) {
        recordNodes(infixExpression, expression);
    }/*from w ww.  j a va 2 s.c  o m*/
    Expression leftExpression = convert(expression.left);
    infixExpression.setLeftOperand(leftExpression);
    infixExpression.setRightOperand(convert(expression.right));
    int startPosition = leftExpression.getStartPosition();
    infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
    switch ((expression.bits
            & org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorMASK) >> org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorSHIFT) {
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.EQUAL_EQUAL:
        infixExpression.setOperator(InfixExpression.Operator.EQUALS);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.NOT_EQUAL:
        infixExpression.setOperator(InfixExpression.Operator.NOT_EQUALS);
    }
    return infixExpression;

}

---

From source file:org.eclipse.jdt.core.dom.ASTConverter.java

License:Open Source License

public InfixExpression convert(StringLiteralConcatenation expression) {
    expression.computeConstant();//  ww  w .j av a 2s . c  om
    final InfixExpression infixExpression = new InfixExpression(this.ast);
    infixExpression.setOperator(InfixExpression.Operator.PLUS);
    org.eclipse.jdt.internal.compiler.ast.Expression[] stringLiterals = expression.literals;
    infixExpression.setLeftOperand(convert(stringLiterals[0]));
    infixExpression.setRightOperand(convert(stringLiterals[1]));
    for (int i = 2; i < expression.counter; i++) {
        infixExpression.extendedOperands().add(convert(stringLiterals[i]));
    }
    if (this.resolveBindings) {
        this.recordNodes(infixExpression, expression);
    }
    infixExpression.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);
    return infixExpression;
}

---

From source file:org.eclipse.jdt.core.dom.ASTConverter.java

License:Open Source License

public Expression convert(org.eclipse.jdt.internal.compiler.ast.OR_OR_Expression expression) {
    InfixExpression infixExpression = new InfixExpression(this.ast);
    infixExpression.setOperator(InfixExpression.Operator.CONDITIONAL_OR);
    if (this.resolveBindings) {
        this.recordNodes(infixExpression, expression);
    }//  www. j  av a2  s.  co m
    final int expressionOperatorID = (expression.bits
            & org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorMASK) >> org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorSHIFT;
    if (expression.left instanceof org.eclipse.jdt.internal.compiler.ast.BinaryExpression
            && ((expression.left.bits
                    & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0)) {
        // create an extended string literal equivalent => use the extended operands list
        infixExpression.extendedOperands().add(convert(expression.right));
        org.eclipse.jdt.internal.compiler.ast.Expression leftOperand = expression.left;
        org.eclipse.jdt.internal.compiler.ast.Expression rightOperand = null;
        do {
            rightOperand = ((org.eclipse.jdt.internal.compiler.ast.BinaryExpression) leftOperand).right;
            if ((((leftOperand.bits
                    & org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorMASK) >> org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorSHIFT) != expressionOperatorID
                    && ((leftOperand.bits
                            & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0))
                    || ((rightOperand instanceof org.eclipse.jdt.internal.compiler.ast.BinaryExpression
                            && ((rightOperand.bits
                                    & org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorMASK) >> org.eclipse.jdt.internal.compiler.ast.ASTNode.OperatorSHIFT) != expressionOperatorID)
                            && ((rightOperand.bits
                                    & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0))) {
                List extendedOperands = infixExpression.extendedOperands();
                InfixExpression temp = new InfixExpression(this.ast);
                if (this.resolveBindings) {
                    this.recordNodes(temp, expression);
                }
                temp.setOperator(getOperatorFor(expressionOperatorID));
                Expression leftSide = convert(leftOperand);
                temp.setLeftOperand(leftSide);
                temp.setSourceRange(leftSide.getStartPosition(), leftSide.getLength());
                int size = extendedOperands.size();
                for (int i = 0; i < size - 1; i++) {
                    Expression expr = temp;
                    temp = new InfixExpression(this.ast);

                    if (this.resolveBindings) {
                        this.recordNodes(temp, expression);
                    }
                    temp.setLeftOperand(expr);
                    temp.setOperator(getOperatorFor(expressionOperatorID));
                    temp.setSourceRange(expr.getStartPosition(), expr.getLength());
                }
                infixExpression = temp;
                for (int i = 0; i < size; i++) {
                    Expression extendedOperand = (Expression) extendedOperands.remove(size - 1 - i);
                    temp.setRightOperand(extendedOperand);
                    int startPosition = temp.getLeftOperand().getStartPosition();
                    temp.setSourceRange(startPosition,
                            extendedOperand.getStartPosition() + extendedOperand.getLength() - startPosition);
                    if (temp.getLeftOperand().getNodeType() == ASTNode.INFIX_EXPRESSION) {
                        temp = (InfixExpression) temp.getLeftOperand();
                    }
                }
                int startPosition = infixExpression.getLeftOperand().getStartPosition();
                infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
                if (this.resolveBindings) {
                    this.recordNodes(infixExpression, expression);
                }
                return infixExpression;
            }
            infixExpression.extendedOperands().add(0, convert(rightOperand));
            leftOperand = ((org.eclipse.jdt.internal.compiler.ast.BinaryExpression) leftOperand).left;
        } while (leftOperand instanceof org.eclipse.jdt.internal.compiler.ast.BinaryExpression
                && ((leftOperand.bits & org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0));
        Expression leftExpression = convert(leftOperand);
        infixExpression.setLeftOperand(leftExpression);
        infixExpression.setRightOperand((Expression) infixExpression.extendedOperands().remove(0));
        int startPosition = leftExpression.getStartPosition();
        infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
        return infixExpression;
    }
    Expression leftExpression = convert(expression.left);
    infixExpression.setLeftOperand(leftExpression);
    infixExpression.setRightOperand(convert(expression.right));
    infixExpression.setOperator(InfixExpression.Operator.CONDITIONAL_OR);
    int startPosition = leftExpression.getStartPosition();
    infixExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
    return infixExpression;
}

---