Example usage for org.eclipse.jdt.internal.compiler.ast OperatorIds MINUS

Introduction

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

Prototype

int MINUS

To view the source code for org.eclipse.jdt.internal.compiler.ast OperatorIds MINUS.

Click Source Link

Usage

From source file:com.android.tools.lint.psi.EcjPsiBuilder.java

License:Apache License

/** Look up the PSI element type for the given ECJ operator */
@NonNull/*from  w ww . j a v a2 s .c o  m*/
private IElementType ecjToPsiToken(int operator) {
    switch (operator) {
    case OperatorIds.PLUS_PLUS:
        return JavaTokenType.PLUSPLUS;
    case OperatorIds.MINUS_MINUS:
        return JavaTokenType.MINUSMINUS;
    case OperatorIds.TWIDDLE:
        return JavaTokenType.TILDE;
    case OperatorIds.NOT:
        return JavaTokenType.EXCL;
    case OperatorIds.PLUS:
        return JavaTokenType.PLUS;
    case OperatorIds.MINUS:
        return JavaTokenType.MINUS;
    case OperatorIds.OR_OR:
        return JavaTokenType.OROR;
    case OperatorIds.AND_AND:
        return JavaTokenType.ANDAND;
    case OperatorIds.OR:
        return JavaTokenType.OR;
    case OperatorIds.XOR:
        return JavaTokenType.XOR;
    case OperatorIds.AND:
        return JavaTokenType.AND;
    case OperatorIds.EQUAL_EQUAL:
        return JavaTokenType.EQEQ;
    case OperatorIds.NOT_EQUAL:
        return JavaTokenType.NE;
    case OperatorIds.GREATER:
        return JavaTokenType.GT;
    case OperatorIds.GREATER_EQUAL:
        return JavaTokenType.GE;
    case OperatorIds.LESS:
        return JavaTokenType.LT;
    case OperatorIds.LESS_EQUAL:
        return JavaTokenType.LE;
    case OperatorIds.LEFT_SHIFT:
        return JavaTokenType.LTLT;
    case OperatorIds.RIGHT_SHIFT:
        return JavaTokenType.GTGT;
    case OperatorIds.UNSIGNED_RIGHT_SHIFT:
        return JavaTokenType.GTGTGT;
    case OperatorIds.MULTIPLY:
        return JavaTokenType.ASTERISK;
    case OperatorIds.DIVIDE:
        return JavaTokenType.DIV;
    case OperatorIds.REMAINDER:
        return JavaTokenType.PERC;
    case OperatorIds.EQUAL:
        return JavaTokenType.EQ;
    default:
        return JavaTokenType.IDENTIFIER;
    }
}

---

From source file:com.android.tools.lint.psi.EcjPsiBuilder.java

License:Apache License

/** Look up the PSI element type for the given ECJ operator in an assignment */
@NonNull/*from  w  w  w  .j  av a 2s.  co  m*/
private IElementType ecjAssignmentToPsiToken(int operator) {
    switch (operator) {
    case OperatorIds.PLUS:
        return JavaTokenType.PLUSEQ;
    case OperatorIds.MINUS:
        return JavaTokenType.MINUSEQ;
    case OperatorIds.MULTIPLY:
        return JavaTokenType.ASTERISKEQ;
    case OperatorIds.DIVIDE:
        return JavaTokenType.DIVEQ;
    case OperatorIds.REMAINDER:
        return JavaTokenType.PERCEQ;
    case OperatorIds.AND:
        return JavaTokenType.ANDEQ;
    case OperatorIds.XOR:
        return JavaTokenType.XOREQ;
    case OperatorIds.OR:
        return JavaTokenType.OREQ;
    case OperatorIds.LEFT_SHIFT:
        return JavaTokenType.LTLTEQ;
    case OperatorIds.RIGHT_SHIFT:
        return JavaTokenType.GTGTEQ;
    case OperatorIds.UNSIGNED_RIGHT_SHIFT:
        return JavaTokenType.GTGTGTEQ;
    default:
        return JavaTokenType.EQ;
    }
}

---

From source file:com.codenvy.ide.ext.java.server.internal.core.CompilationUnitStructureRequestor.java

License:Open Source License

protected Object getMemberValue(com.codenvy.ide.ext.java.server.internal.core.MemberValuePair memberValuePair,
        Expression expression) {//from   w  w w .j a  v  a  2 s  .  co  m
    if (expression instanceof NullLiteral) {
        return null;
    } else if (expression instanceof Literal) {
        ((Literal) expression).computeConstant();
        return Util.getAnnotationMemberValue(memberValuePair, expression.constant);
    } else if (expression instanceof org.eclipse.jdt.internal.compiler.ast.Annotation) {
        org.eclipse.jdt.internal.compiler.ast.Annotation annotation = (org.eclipse.jdt.internal.compiler.ast.Annotation) expression;
        Object handle = acceptAnnotation(annotation, null, (JavaElement) this.handleStack.peek());
        memberValuePair.valueKind = IMemberValuePair.K_ANNOTATION;
        return handle;
    } else if (expression instanceof ClassLiteralAccess) {
        ClassLiteralAccess classLiteral = (ClassLiteralAccess) expression;
        char[] name = CharOperation.concatWith(classLiteral.type.getTypeName(), '.');
        memberValuePair.valueKind = IMemberValuePair.K_CLASS;
        return new String(name);
    } else if (expression instanceof QualifiedNameReference) {
        char[] qualifiedName = CharOperation.concatWith(((QualifiedNameReference) expression).tokens, '.');
        memberValuePair.valueKind = IMemberValuePair.K_QUALIFIED_NAME;
        return new String(qualifiedName);
    } else if (expression instanceof SingleNameReference) {
        char[] simpleName = ((SingleNameReference) expression).token;
        if (simpleName == RecoveryScanner.FAKE_IDENTIFIER) {
            memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
            return null;
        }
        memberValuePair.valueKind = IMemberValuePair.K_SIMPLE_NAME;
        return new String(simpleName);
    } else if (expression instanceof ArrayInitializer) {
        memberValuePair.valueKind = -1; // modified below by the first call to getMemberValue(...)
        Expression[] expressions = ((ArrayInitializer) expression).expressions;
        int length = expressions == null ? 0 : expressions.length;
        Object[] values = new Object[length];
        for (int i = 0; i < length; i++) {
            int previousValueKind = memberValuePair.valueKind;
            Object value = getMemberValue(memberValuePair, expressions[i]);
            if (previousValueKind != -1 && memberValuePair.valueKind != previousValueKind) {
                // values are heterogeneous, value kind is thus unknown
                memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
            }
            values[i] = value;
        }
        if (memberValuePair.valueKind == -1)
            memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return values;
    } else if (expression instanceof UnaryExpression) { // to deal with negative numerals (see bug - 248312)
        UnaryExpression unaryExpression = (UnaryExpression) expression;
        if ((unaryExpression.bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT == OperatorIds.MINUS) {
            if (unaryExpression.expression instanceof Literal) {
                Literal subExpression = (Literal) unaryExpression.expression;
                subExpression.computeConstant();
                return Util.getNegativeAnnotationMemberValue(memberValuePair, subExpression.constant);
            }
        }
        memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return null;
    } else {
        memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return null;
    }
}

---

From source file:com.codenvy.ide.ext.java.server.internal.core.LocalVariable.java

License:Open Source License

private Object getAnnotationMemberValue(MemberValuePair memberValuePair, Expression expression,
        JavaElement parentElement) {//from w  w w  . j a v a  2 s.c o  m
    if (expression instanceof NullLiteral) {
        return null;
    } else if (expression instanceof Literal) {
        ((Literal) expression).computeConstant();
        return Util.getAnnotationMemberValue(memberValuePair, expression.constant);
    } else if (expression instanceof org.eclipse.jdt.internal.compiler.ast.Annotation) {
        memberValuePair.valueKind = IMemberValuePair.K_ANNOTATION;
        return getAnnotation((org.eclipse.jdt.internal.compiler.ast.Annotation) expression, parentElement);
    } else if (expression instanceof ClassLiteralAccess) {
        ClassLiteralAccess classLiteral = (ClassLiteralAccess) expression;
        char[] typeName = CharOperation.concatWith(classLiteral.type.getTypeName(), '.');
        memberValuePair.valueKind = IMemberValuePair.K_CLASS;
        return new String(typeName);
    } else if (expression instanceof QualifiedNameReference) {
        char[] qualifiedName = CharOperation.concatWith(((QualifiedNameReference) expression).tokens, '.');
        memberValuePair.valueKind = IMemberValuePair.K_QUALIFIED_NAME;
        return new String(qualifiedName);
    } else if (expression instanceof SingleNameReference) {
        char[] simpleName = ((SingleNameReference) expression).token;
        if (simpleName == RecoveryScanner.FAKE_IDENTIFIER) {
            memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
            return null;
        }
        memberValuePair.valueKind = IMemberValuePair.K_SIMPLE_NAME;
        return new String(simpleName);
    } else if (expression instanceof ArrayInitializer) {
        memberValuePair.valueKind = -1; // modified below by the first call to getMemberValue(...)
        Expression[] expressions = ((ArrayInitializer) expression).expressions;
        int length = expressions == null ? 0 : expressions.length;
        Object[] values = new Object[length];
        for (int i = 0; i < length; i++) {
            int previousValueKind = memberValuePair.valueKind;
            Object value = getAnnotationMemberValue(memberValuePair, expressions[i], parentElement);
            if (previousValueKind != -1 && memberValuePair.valueKind != previousValueKind) {
                // values are heterogeneous, value kind is thus unknown
                memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
            }
            values[i] = value;
        }
        if (memberValuePair.valueKind == -1)
            memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return values;
    } else if (expression instanceof UnaryExpression) { //to deal with negative numerals (see bug - 248312)
        UnaryExpression unaryExpression = (UnaryExpression) expression;
        if ((unaryExpression.bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT == OperatorIds.MINUS) {
            if (unaryExpression.expression instanceof Literal) {
                Literal subExpression = (Literal) unaryExpression.expression;
                subExpression.computeConstant();
                return Util.getNegativeAnnotationMemberValue(memberValuePair, subExpression.constant);
            }
        }
        memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return null;
    } else {
        memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return null;
    }
}

---

From source file:lombok.eclipse.handlers.singulars.EclipseJavaUtilSingularizer.java

License:Open Source License

protected List<Statement> createJavaUtilSimpleCreationAndFillStatements(SingularData data,
        EclipseNode builderType, boolean mapMode, boolean defineVar, boolean addInitialCapacityArg,
        boolean nullGuard, String targetType) {
    char[] varName = mapMode ? (new String(data.getPluralName()) + "$key").toCharArray() : data.getPluralName();

    Statement createStat;//w  ww.jav  a2s  .co m
    {
        // pluralName = new java.util.TargetType(initialCap);
        Expression[] constructorArgs = null;
        if (addInitialCapacityArg) {
            // this.varName.size() < MAX_POWER_OF_2 ? 1 + this.varName.size() + (this.varName.size() - 3) / 3 : Integer.MAX_VALUE;
            // lessThanCutOff = this.varName.size() < MAX_POWER_OF_2
            Expression lessThanCutoff = new BinaryExpression(getSize(builderType, varName, nullGuard),
                    makeIntLiteral("0x40000000".toCharArray(), null), OperatorIds.LESS);
            FieldReference integerMaxValue = new FieldReference("MAX_VALUE".toCharArray(), 0L);
            integerMaxValue.receiver = new QualifiedNameReference(TypeConstants.JAVA_LANG_INTEGER, NULL_POSS, 0,
                    0);
            Expression sizeFormulaLeft = new BinaryExpression(makeIntLiteral(new char[] { '1' }, null),
                    getSize(builderType, varName, nullGuard), OperatorIds.PLUS);
            Expression sizeFormulaRightLeft = new BinaryExpression(getSize(builderType, varName, nullGuard),
                    makeIntLiteral(new char[] { '3' }, null), OperatorIds.MINUS);
            Expression sizeFormulaRight = new BinaryExpression(sizeFormulaRightLeft,
                    makeIntLiteral(new char[] { '3' }, null), OperatorIds.DIVIDE);
            Expression sizeFormula = new BinaryExpression(sizeFormulaLeft, sizeFormulaRight, OperatorIds.PLUS);
            Expression cond = new ConditionalExpression(lessThanCutoff, sizeFormula, integerMaxValue);
            constructorArgs = new Expression[] { cond };
        }

        TypeReference targetTypeRef = new QualifiedTypeReference(
                new char[][] { TypeConstants.JAVA, TypeConstants.UTIL, targetType.toCharArray() }, NULL_POSS);
        targetTypeRef = addTypeArgs(mapMode ? 2 : 1, false, builderType, targetTypeRef, data.getTypeArgs());
        AllocationExpression constructorCall = new AllocationExpression();
        constructorCall.type = targetTypeRef;
        constructorCall.arguments = constructorArgs;

        if (defineVar) {
            TypeReference localShadowerType = new QualifiedTypeReference(fromQualifiedName(data.getTargetFqn()),
                    NULL_POSS);
            localShadowerType = addTypeArgs(mapMode ? 2 : 1, false, builderType, localShadowerType,
                    data.getTypeArgs());
            LocalDeclaration localShadowerDecl = new LocalDeclaration(data.getPluralName(), 0, 0);
            localShadowerDecl.type = localShadowerType;
            localShadowerDecl.initialization = constructorCall;
            createStat = localShadowerDecl;
        } else {
            createStat = new Assignment(new SingleNameReference(data.getPluralName(), 0L), constructorCall, 0);
        }
    }

    Statement fillStat;
    {
        if (mapMode) {
            // for (int $i = 0; $i < this.pluralname$key.size(); i++) pluralname.put(this.pluralname$key.get($i), this.pluralname$value.get($i));
            char[] iVar = new char[] { '$', 'i' };
            MessageSend pluralnameDotPut = new MessageSend();
            pluralnameDotPut.selector = new char[] { 'p', 'u', 't' };
            pluralnameDotPut.receiver = new SingleNameReference(data.getPluralName(), 0L);
            FieldReference thisDotKey = new FieldReference(varName, 0L);
            thisDotKey.receiver = new ThisReference(0, 0);
            FieldReference thisDotValue = new FieldReference(
                    (new String(data.getPluralName()) + "$value").toCharArray(), 0L);
            thisDotValue.receiver = new ThisReference(0, 0);
            MessageSend keyArg = new MessageSend();
            keyArg.receiver = thisDotKey;
            keyArg.arguments = new Expression[] { new SingleNameReference(iVar, 0L) };
            keyArg.selector = new char[] { 'g', 'e', 't' };
            MessageSend valueArg = new MessageSend();
            valueArg.receiver = thisDotValue;
            valueArg.arguments = new Expression[] { new SingleNameReference(iVar, 0L) };
            valueArg.selector = new char[] { 'g', 'e', 't' };
            pluralnameDotPut.arguments = new Expression[] { keyArg, valueArg };

            LocalDeclaration forInit = new LocalDeclaration(iVar, 0, 0);
            forInit.type = TypeReference.baseTypeReference(TypeIds.T_int, 0);
            forInit.initialization = makeIntLiteral(new char[] { '0' }, null);
            Expression checkExpr = new BinaryExpression(new SingleNameReference(iVar, 0L),
                    getSize(builderType, varName, nullGuard), OperatorIds.LESS);
            Expression incrementExpr = new PostfixExpression(new SingleNameReference(iVar, 0L), IntLiteral.One,
                    OperatorIds.PLUS, 0);
            fillStat = new ForStatement(new Statement[] { forInit }, checkExpr,
                    new Statement[] { incrementExpr }, pluralnameDotPut, true, 0, 0);
        } else {
            // pluralname.addAll(this.pluralname);
            MessageSend pluralnameDotAddAll = new MessageSend();
            pluralnameDotAddAll.selector = new char[] { 'a', 'd', 'd', 'A', 'l', 'l' };
            pluralnameDotAddAll.receiver = new SingleNameReference(data.getPluralName(), 0L);
            FieldReference thisDotPluralname = new FieldReference(varName, 0L);
            thisDotPluralname.receiver = new ThisReference(0, 0);
            pluralnameDotAddAll.arguments = new Expression[] { thisDotPluralname };
            fillStat = pluralnameDotAddAll;
        }

        if (nullGuard) {
            FieldReference thisDotField = new FieldReference(varName, 0L);
            thisDotField.receiver = new ThisReference(0, 0);
            Expression cond = new EqualExpression(thisDotField, new NullLiteral(0, 0), OperatorIds.NOT_EQUAL);
            fillStat = new IfStatement(cond, fillStat, 0, 0);
        }
    }

    Statement unmodifiableStat;
    {
        // pluralname = Collections.unmodifiableInterfaceType(pluralname);
        Expression arg = new SingleNameReference(data.getPluralName(), 0L);
        MessageSend invoke = new MessageSend();
        invoke.arguments = new Expression[] { arg };
        invoke.selector = ("unmodifiable" + data.getTargetSimpleType()).toCharArray();
        invoke.receiver = new QualifiedNameReference(JAVA_UTIL_COLLECTIONS, NULL_POSS, 0, 0);
        unmodifiableStat = new Assignment(new SingleNameReference(data.getPluralName(), 0L), invoke, 0);
    }

    return Arrays.asList(createStat, fillStat, unmodifiableStat);
}

---

From source file:org.eclipse.che.jdt.internal.core.CompilationUnitStructureRequestor.java

License:Open Source License

protected Object getMemberValue(org.eclipse.che.jdt.internal.core.MemberValuePair memberValuePair,
        Expression expression) {//ww w  . j  a  va  2 s  . c o m
    if (expression instanceof NullLiteral) {
        return null;
    } else if (expression instanceof Literal) {
        ((Literal) expression).computeConstant();
        return Util.getAnnotationMemberValue(memberValuePair, expression.constant);
    } else if (expression instanceof org.eclipse.jdt.internal.compiler.ast.Annotation) {
        org.eclipse.jdt.internal.compiler.ast.Annotation annotation = (org.eclipse.jdt.internal.compiler.ast.Annotation) expression;
        Object handle = acceptAnnotation(annotation, null, (JavaElement) this.handleStack.peek());
        memberValuePair.valueKind = IMemberValuePair.K_ANNOTATION;
        return handle;
    } else if (expression instanceof ClassLiteralAccess) {
        ClassLiteralAccess classLiteral = (ClassLiteralAccess) expression;
        char[] name = CharOperation.concatWith(classLiteral.type.getTypeName(), '.');
        memberValuePair.valueKind = IMemberValuePair.K_CLASS;
        return new String(name);
    } else if (expression instanceof QualifiedNameReference) {
        char[] qualifiedName = CharOperation.concatWith(((QualifiedNameReference) expression).tokens, '.');
        memberValuePair.valueKind = IMemberValuePair.K_QUALIFIED_NAME;
        return new String(qualifiedName);
    } else if (expression instanceof SingleNameReference) {
        char[] simpleName = ((SingleNameReference) expression).token;
        if (simpleName == RecoveryScanner.FAKE_IDENTIFIER) {
            memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
            return null;
        }
        memberValuePair.valueKind = IMemberValuePair.K_SIMPLE_NAME;
        return new String(simpleName);
    } else if (expression instanceof ArrayInitializer) {
        memberValuePair.valueKind = -1; // modified below by the first call to getMemberValue(...)
        Expression[] expressions = ((ArrayInitializer) expression).expressions;
        int length = expressions == null ? 0 : expressions.length;
        Object[] values = new Object[length];
        for (int i = 0; i < length; i++) {
            int previousValueKind = memberValuePair.valueKind;
            Object value = getMemberValue(memberValuePair, expressions[i]);
            if (previousValueKind != -1 && memberValuePair.valueKind != previousValueKind) {
                // values are heterogeneous, value kind is thus unknown
                memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
            }
            values[i] = value;
        }
        if (memberValuePair.valueKind == -1)
            memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return values;
    } else if (expression instanceof UnaryExpression) { // to deal with negative numerals (see bug - 248312)
        UnaryExpression unaryExpression = (UnaryExpression) expression;
        if ((unaryExpression.bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT == OperatorIds.MINUS) {
            if (unaryExpression.expression instanceof Literal) {
                Literal subExpression = (Literal) unaryExpression.expression;
                subExpression.computeConstant();
                return Util.getNegativeAnnotationMemberValue(memberValuePair, subExpression.constant);
            }
        }
        memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return null;
    } else {
        memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return null;
    }
}

---

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

License:Open Source License

public Assignment convert(org.eclipse.jdt.internal.compiler.ast.CompoundAssignment expression) {
    Assignment assignment = new Assignment(this.ast);
    Expression lhs = convert(expression.lhs);
    assignment.setLeftHandSide(lhs);/*  w  w w. j  a va 2s  . c  om*/
    int start = lhs.getStartPosition();
    assignment.setSourceRange(start, expression.sourceEnd - start + 1);
    switch (expression.operator) {
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.PLUS:
        assignment.setOperator(Assignment.Operator.PLUS_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.MINUS:
        assignment.setOperator(Assignment.Operator.MINUS_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.MULTIPLY:
        assignment.setOperator(Assignment.Operator.TIMES_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.DIVIDE:
        assignment.setOperator(Assignment.Operator.DIVIDE_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.AND:
        assignment.setOperator(Assignment.Operator.BIT_AND_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.OR:
        assignment.setOperator(Assignment.Operator.BIT_OR_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.XOR:
        assignment.setOperator(Assignment.Operator.BIT_XOR_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.REMAINDER:
        assignment.setOperator(Assignment.Operator.REMAINDER_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.LEFT_SHIFT:
        assignment.setOperator(Assignment.Operator.LEFT_SHIFT_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.RIGHT_SHIFT:
        assignment.setOperator(Assignment.Operator.RIGHT_SHIFT_SIGNED_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.UNSIGNED_RIGHT_SHIFT:
        assignment.setOperator(Assignment.Operator.RIGHT_SHIFT_UNSIGNED_ASSIGN);
        break;
    }
    assignment.setRightHandSide(convert(expression.expression));
    if (this.resolveBindings) {
        recordNodes(assignment, expression);
    }
    return assignment;
}

---

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

License:Open Source License

public PostfixExpression convert(org.eclipse.jdt.internal.compiler.ast.PostfixExpression expression) {
    final PostfixExpression postfixExpression = new PostfixExpression(this.ast);
    if (this.resolveBindings) {
        recordNodes(postfixExpression, expression);
    }/*from   w  w w . j a v a 2 s . c  o m*/
    postfixExpression.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);
    postfixExpression.setOperand(convert(expression.lhs));
    switch (expression.operator) {
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.PLUS:
        postfixExpression.setOperator(PostfixExpression.Operator.INCREMENT);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.MINUS:
        postfixExpression.setOperator(PostfixExpression.Operator.DECREMENT);
        break;
    }
    return postfixExpression;
}

---

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

License:Open Source License

public PrefixExpression convert(org.eclipse.jdt.internal.compiler.ast.PrefixExpression expression) {
    final PrefixExpression prefixExpression = new PrefixExpression(this.ast);
    if (this.resolveBindings) {
        recordNodes(prefixExpression, expression);
    }//  ww w.  j  a v a2s  . c om
    prefixExpression.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);
    prefixExpression.setOperand(convert(expression.lhs));
    switch (expression.operator) {
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.PLUS:
        prefixExpression.setOperator(PrefixExpression.Operator.INCREMENT);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.MINUS:
        prefixExpression.setOperator(PrefixExpression.Operator.DECREMENT);
        break;
    }
    return prefixExpression;
}

---

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

License:Open Source License

public PrefixExpression convert(org.eclipse.jdt.internal.compiler.ast.UnaryExpression expression) {
    final PrefixExpression prefixExpression = new PrefixExpression(this.ast);
    if (this.resolveBindings) {
        this.recordNodes(prefixExpression, expression);
    }// w w  w .  ja  v  a2  s.  c o  m
    prefixExpression.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);
    prefixExpression.setOperand(convert(expression.expression));
    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.PLUS:
        prefixExpression.setOperator(PrefixExpression.Operator.PLUS);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.MINUS:
        prefixExpression.setOperator(PrefixExpression.Operator.MINUS);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.NOT:
        prefixExpression.setOperator(PrefixExpression.Operator.NOT);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.TWIDDLE:
        prefixExpression.setOperator(PrefixExpression.Operator.COMPLEMENT);
    }
    return prefixExpression;
}

---

• «
• 1
• 2
• 3
• »