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

Introduction

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

Prototype

public final void setSourceRange(int startPosition, int length) 

Source Link

Document

Sets the source range of the original source file where the source fragment corresponding to this node was found.

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 ava2  s.c  om*/
    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);
    }/*  w ww .j  ava 2  s .  co  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   www.j  a v a 2s .co  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();/* w  ww  .j  a  v  a 2  s  .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);
    }//from   w  w  w.j a v a2  s.c om
    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;
}

---