Example usage for org.eclipse.jdt.internal.compiler.ast CombinedBinaryExpression tuneArityMax

Introduction

In this page you can find the example usage for org.eclipse.jdt.internal.compiler.ast CombinedBinaryExpression tuneArityMax.

Prototype

public void tuneArityMax() 

Source Link

Document

Change #arityMax if and as needed.

Usage

From source file:org.eclipse.jdt.internal.compiler.parser.Parser.java

License:Open Source License

protected void consumeBinaryExpression(int op) {
    // MultiplicativeExpression ::= MultiplicativeExpression '*' UnaryExpression
    // MultiplicativeExpression ::= MultiplicativeExpression '/' UnaryExpression
    // MultiplicativeExpression ::= MultiplicativeExpression '%' UnaryExpression
    // AdditiveExpression ::= AdditiveExpression '+' MultiplicativeExpression
    // AdditiveExpression ::= AdditiveExpression '-' MultiplicativeExpression
    // ShiftExpression ::= ShiftExpression '<<'  AdditiveExpression
    // ShiftExpression ::= ShiftExpression '>>'  AdditiveExpression
    // ShiftExpression ::= ShiftExpression '>>>' AdditiveExpression
    // RelationalExpression ::= RelationalExpression '<'  ShiftExpression
    // RelationalExpression ::= RelationalExpression '>'  ShiftExpression
    // RelationalExpression ::= RelationalExpression '<=' ShiftExpression
    // RelationalExpression ::= RelationalExpression '>=' ShiftExpression
    // AndExpression ::= AndExpression '&' EqualityExpression
    // ExclusiveOrExpression ::= ExclusiveOrExpression '^' AndExpression
    // InclusiveOrExpression ::= InclusiveOrExpression '|' ExclusiveOrExpression
    // ConditionalAndExpression ::= ConditionalAndExpression '&&' InclusiveOrExpression
    // ConditionalOrExpression ::= ConditionalOrExpression '||' ConditionalAndExpression

    //optimize the push/pop

    this.expressionPtr--;
    this.expressionLengthPtr--;
    Expression expr1 = this.expressionStack[this.expressionPtr];
    Expression expr2 = this.expressionStack[this.expressionPtr + 1];
    switch (op) {
    case OR_OR:/*from w w  w.j  av a2 s  .c  o  m*/
        this.expressionStack[this.expressionPtr] = new OR_OR_Expression(expr1, expr2, op);
        break;
    case AND_AND:
        this.expressionStack[this.expressionPtr] = new AND_AND_Expression(expr1, expr2, op);
        break;
    case PLUS:
        // look for "string1" + "string2"
        if (this.optimizeStringLiterals) {
            if (expr1 instanceof StringLiteral) {
                if (((expr1.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT) == 0) {
                    if (expr2 instanceof CharLiteral) { // string+char
                        this.expressionStack[this.expressionPtr] = ((StringLiteral) expr1)
                                .extendWith((CharLiteral) expr2);
                    } else if (expr2 instanceof StringLiteral) { //string+string
                        this.expressionStack[this.expressionPtr] = ((StringLiteral) expr1)
                                .extendWith((StringLiteral) expr2);
                    } else {
                        this.expressionStack[this.expressionPtr] = new BinaryExpression(expr1, expr2, PLUS);
                    }
                } else {
                    this.expressionStack[this.expressionPtr] = new BinaryExpression(expr1, expr2, PLUS);
                }
            } else if (expr1 instanceof CombinedBinaryExpression) {
                CombinedBinaryExpression cursor;
                // left branch is comprised of PLUS BEs
                // cursor is shifted upwards, while needed BEs are added
                // on demand; past the arityMax-th
                // consecutive BE, a CBE is inserted that holds a
                // full-fledged references table
                if ((cursor = (CombinedBinaryExpression) expr1).arity < cursor.arityMax) {
                    cursor.left = new BinaryExpression(cursor);
                    cursor.arity++;
                } else {
                    cursor.left = new CombinedBinaryExpression(cursor);
                    cursor.arity = 0;
                    cursor.tuneArityMax();
                }
                cursor.right = expr2;
                cursor.sourceEnd = expr2.sourceEnd;
                this.expressionStack[this.expressionPtr] = cursor;
                // BE_INSTRUMENTATION: neutralized in the released code
                //               cursor.depthTracker = ((BinaryExpression)cursor.left).
                //                  depthTracker + 1;
            } else if (expr1 instanceof BinaryExpression &&
            // single out the a + b case, which is a BE
            // instead of a CBE (slightly more than a half of
            // strings concatenation are one-deep binary
            // expressions)
                    ((expr1.bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT) == OperatorIds.PLUS) {
                this.expressionStack[this.expressionPtr] = new CombinedBinaryExpression(expr1, expr2, PLUS, 1);
            } else {
                this.expressionStack[this.expressionPtr] = new BinaryExpression(expr1, expr2, PLUS);
            }
        } else if (expr1 instanceof StringLiteral) {
            if (expr2 instanceof StringLiteral
                    && ((expr1.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT) == 0) {
                // string + string
                this.expressionStack[this.expressionPtr] = ((StringLiteral) expr1)
                        .extendsWith((StringLiteral) expr2);
            } else {
                // single out the a + b case
                this.expressionStack[this.expressionPtr] = new BinaryExpression(expr1, expr2, PLUS);
            }
        } else if (expr1 instanceof CombinedBinaryExpression) {
            CombinedBinaryExpression cursor;
            // shift cursor; create BE/CBE as needed
            if ((cursor = (CombinedBinaryExpression) expr1).arity < cursor.arityMax) {
                cursor.left = new BinaryExpression(cursor);
                // clear the bits on cursor
                cursor.bits &= ~ASTNode.ParenthesizedMASK;
                cursor.arity++;
            } else {
                cursor.left = new CombinedBinaryExpression(cursor);
                // clear the bits on cursor
                cursor.bits &= ~ASTNode.ParenthesizedMASK;
                cursor.arity = 0;
                cursor.tuneArityMax();
            }
            cursor.right = expr2;
            cursor.sourceEnd = expr2.sourceEnd;
            // BE_INSTRUMENTATION: neutralized in the released code
            //               cursor.depthTracker = ((BinaryExpression)cursor.left).
            //                  depthTracker + 1;
            this.expressionStack[this.expressionPtr] = cursor;
        } else if (expr1 instanceof BinaryExpression
                && ((expr1.bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT) == OperatorIds.PLUS) {
            // single out the a + b case
            this.expressionStack[this.expressionPtr] = new CombinedBinaryExpression(expr1, expr2, PLUS, 1);
        } else {
            this.expressionStack[this.expressionPtr] = new BinaryExpression(expr1, expr2, PLUS);
        }
        break;
    case LESS:
    case MULTIPLY:
        this.intPtr--; // star end position or starting position of angle bracket
        this.expressionStack[this.expressionPtr] = new BinaryExpression(expr1, expr2, op);
        break;
    default:
        this.expressionStack[this.expressionPtr] = new BinaryExpression(expr1, expr2, op);
    }
}

---