List of usage examples for org.eclipse.jdt.internal.compiler.ast OperatorIds PLUS
int PLUS
To view the source code for org.eclipse.jdt.internal.compiler.ast OperatorIds PLUS.
Click Source Link
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 . ja va 2 s. co 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 ww. j a v a 2 s.com 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:lombok.eclipse.handlers.HandleEqualsAndHashCode.java
License:Open Source License
public Expression createResultCalculation(ASTNode source, Expression ex) { /* result = result * PRIME + (ex); */ int pS = source.sourceStart, pE = source.sourceEnd; long p = (long) pS << 32 | pE; SingleNameReference resultRef = new SingleNameReference(RESULT, p); setGeneratedBy(resultRef, source);//from w w w . j a v a 2s .c om SingleNameReference primeRef = new SingleNameReference(PRIME, p); setGeneratedBy(primeRef, source); BinaryExpression multiplyByPrime = new BinaryExpression(resultRef, primeRef, OperatorIds.MULTIPLY); multiplyByPrime.sourceStart = pS; multiplyByPrime.sourceEnd = pE; setGeneratedBy(multiplyByPrime, source); BinaryExpression addItem = new BinaryExpression(multiplyByPrime, ex, OperatorIds.PLUS); addItem.sourceStart = pS; addItem.sourceEnd = pE; setGeneratedBy(addItem, source); resultRef = new SingleNameReference(RESULT, p); setGeneratedBy(resultRef, source); Assignment assignment = new Assignment(resultRef, addItem, pE); assignment.sourceStart = pS; assignment.sourceEnd = assignment.statementEnd = pE; setGeneratedBy(assignment, source); return assignment; }
From source file:lombok.eclipse.handlers.HandleToString.java
License:Open Source License
public static MethodDeclaration createToString(EclipseNode type, Collection<EclipseNode> fields, boolean includeFieldNames, boolean callSuper, ASTNode source, FieldAccess fieldAccess) { String typeName = getTypeName(type); char[] suffix = ")".toCharArray(); String infixS = ", "; char[] infix = infixS.toCharArray(); int pS = source.sourceStart, pE = source.sourceEnd; long p = (long) pS << 32 | pE; final int PLUS = OperatorIds.PLUS; char[] prefix; if (callSuper) { prefix = (typeName + "(super=").toCharArray(); } else if (fields.isEmpty()) { prefix = (typeName + "()").toCharArray(); } else if (includeFieldNames) { prefix = (typeName + "(" + new String(((FieldDeclaration) fields.iterator().next().get()).name) + "=") .toCharArray();/*from w ww .jav a2 s . c om*/ } else { prefix = (typeName + "(").toCharArray(); } boolean first = true; Expression current = new StringLiteral(prefix, pS, pE, 0); setGeneratedBy(current, source); if (callSuper) { MessageSend callToSuper = new MessageSend(); callToSuper.sourceStart = pS; callToSuper.sourceEnd = pE; setGeneratedBy(callToSuper, source); callToSuper.receiver = new SuperReference(pS, pE); setGeneratedBy(callToSuper, source); callToSuper.selector = "toString".toCharArray(); current = new BinaryExpression(current, callToSuper, PLUS); setGeneratedBy(current, source); first = false; } for (EclipseNode field : fields) { TypeReference fieldType = getFieldType(field, fieldAccess); Expression fieldAccessor = createFieldAccessor(field, fieldAccess, source); // The distinction between primitive and object will be useful if we ever add a 'hideNulls' option. boolean fieldBaseTypeIsPrimitive = BUILT_IN_TYPES.contains(new String(fieldType.getLastToken())); boolean fieldIsPrimitive = fieldType.dimensions() == 0 && fieldBaseTypeIsPrimitive; boolean fieldIsPrimitiveArray = fieldType.dimensions() == 1 && fieldBaseTypeIsPrimitive; boolean fieldIsObjectArray = fieldType.dimensions() > 0 && !fieldIsPrimitiveArray; @SuppressWarnings("unused") boolean fieldIsObject = !fieldIsPrimitive && !fieldIsPrimitiveArray && !fieldIsObjectArray; Expression ex; if (fieldIsPrimitiveArray || fieldIsObjectArray) { MessageSend arrayToString = new MessageSend(); arrayToString.sourceStart = pS; arrayToString.sourceEnd = pE; arrayToString.receiver = generateQualifiedNameRef(source, TypeConstants.JAVA, TypeConstants.UTIL, "Arrays".toCharArray()); arrayToString.arguments = new Expression[] { fieldAccessor }; setGeneratedBy(arrayToString.arguments[0], source); arrayToString.selector = (fieldIsObjectArray ? "deepToString" : "toString").toCharArray(); ex = arrayToString; } else { ex = fieldAccessor; } setGeneratedBy(ex, source); if (first) { current = new BinaryExpression(current, ex, PLUS); current.sourceStart = pS; current.sourceEnd = pE; setGeneratedBy(current, source); first = false; continue; } StringLiteral fieldNameLiteral; if (includeFieldNames) { char[] namePlusEqualsSign = (infixS + field.getName() + "=").toCharArray(); fieldNameLiteral = new StringLiteral(namePlusEqualsSign, pS, pE, 0); } else { fieldNameLiteral = new StringLiteral(infix, pS, pE, 0); } setGeneratedBy(fieldNameLiteral, source); current = new BinaryExpression(current, fieldNameLiteral, PLUS); setGeneratedBy(current, source); current = new BinaryExpression(current, ex, PLUS); setGeneratedBy(current, source); } if (!first) { StringLiteral suffixLiteral = new StringLiteral(suffix, pS, pE, 0); setGeneratedBy(suffixLiteral, source); current = new BinaryExpression(current, suffixLiteral, PLUS); setGeneratedBy(current, source); } ReturnStatement returnStatement = new ReturnStatement(current, pS, pE); setGeneratedBy(returnStatement, source); MethodDeclaration method = new MethodDeclaration( ((CompilationUnitDeclaration) type.top().get()).compilationResult); setGeneratedBy(method, source); method.modifiers = toEclipseModifier(AccessLevel.PUBLIC); method.returnType = new QualifiedTypeReference(TypeConstants.JAVA_LANG_STRING, new long[] { p, p, p }); setGeneratedBy(method.returnType, source); method.annotations = new Annotation[] { makeMarkerAnnotation(TypeConstants.JAVA_LANG_OVERRIDE, source) }; method.arguments = null; method.selector = "toString".toCharArray(); method.thrownExceptions = null; method.typeParameters = null; method.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG; method.bodyStart = method.declarationSourceStart = method.sourceStart = source.sourceStart; method.bodyEnd = method.declarationSourceEnd = method.sourceEnd = source.sourceEnd; method.statements = new Statement[] { returnStatement }; return method; }
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;/*from ww w . j a v a 2 s .c o 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.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); }//from w ww .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 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 v a 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); }//w w w . j ava2 s .co 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); }/*from w w w . ja v a 2 s .c o m*/ 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); }//from w w w.j a va 2 s .co 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; }