下面列出了org.eclipse.jdt.core.dom.PostfixExpression#getOperator ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
@Override
public boolean visit(final PostfixExpression node) {
final AST dummyAST = AST.newAST(node.getAST().apiLevel());
final PostfixExpression.Operator pfOperator = node.getOperator();
Expression _operand = node.getOperand();
if ((_operand instanceof ArrayAccess)) {
Expression _operand_1 = node.getOperand();
final ArrayAccess pfOperand = ((ArrayAccess) _operand_1);
if ((Objects.equal(pfOperator, PostfixExpression.Operator.INCREMENT) ||
Objects.equal(pfOperator, PostfixExpression.Operator.DECREMENT))) {
final String arrayName = this.computeArrayName(pfOperand);
StringConcatenation _builder = new StringConcatenation();
_builder.append("_postIndx_");
_builder.append(arrayName);
final String idxName = _builder.toString();
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("_postVal_");
_builder_1.append(arrayName);
final String tempVarName = _builder_1.toString();
StringConcatenation _builder_2 = new StringConcatenation();
_builder_2.append("{ var ");
_builder_2.append(idxName);
_builder_2.append("=");
this.appendToBuffer(_builder_2.toString());
pfOperand.getIndex().accept(this);
StringConcatenation _builder_3 = new StringConcatenation();
_builder_3.append(" ");
_builder_3.append("var ");
this.appendToBuffer(_builder_3.toString());
final VariableDeclarationFragment varDeclaration = dummyAST.newVariableDeclarationFragment();
varDeclaration.setName(dummyAST.newSimpleName(tempVarName));
ASTNode _copySubtree = ASTNode.copySubtree(dummyAST, pfOperand);
final ArrayAccess arrayAccess = ((ArrayAccess) _copySubtree);
arrayAccess.setIndex(dummyAST.newSimpleName(idxName));
varDeclaration.setInitializer(arrayAccess);
varDeclaration.accept(this);
final InfixExpression infixOp = dummyAST.newInfixExpression();
infixOp.setLeftOperand(dummyAST.newSimpleName(tempVarName));
PostfixExpression.Operator _operator = node.getOperator();
boolean _equals = Objects.equal(_operator, PostfixExpression.Operator.DECREMENT);
if (_equals) {
infixOp.setOperator(InfixExpression.Operator.MINUS);
} else {
infixOp.setOperator(InfixExpression.Operator.PLUS);
}
infixOp.setRightOperand(dummyAST.newNumberLiteral("1"));
final Assignment assigment = dummyAST.newAssignment();
ASTNode _copySubtree_1 = ASTNode.copySubtree(dummyAST, pfOperand);
final ArrayAccess writeArray = ((ArrayAccess) _copySubtree_1);
writeArray.setIndex(dummyAST.newSimpleName(idxName));
assigment.setLeftHandSide(writeArray);
ASTNode _copySubtree_2 = ASTNode.copySubtree(dummyAST, infixOp);
assigment.setRightHandSide(((Expression) _copySubtree_2));
assigment.accept(this);
StringConcatenation _builder_4 = new StringConcatenation();
String _xifexpression = null;
boolean _needsReturnValue = this._aSTFlattenerUtils.needsReturnValue(node);
if (_needsReturnValue) {
_xifexpression = tempVarName;
}
_builder_4.append(_xifexpression);
_builder_4.append(" }");
this.appendToBuffer(_builder_4.toString());
return false;
}
}
node.getOperand().accept(this);
this.appendToBuffer(pfOperator.toString());
return false;
}
/**
* Converts an assignment, postfix expression or prefix expression into an assignable equivalent expression using the getter.
*
* @param node the assignment/prefix/postfix node
* @param astRewrite the astRewrite to use
* @param getterExpression the expression to insert for read accesses or <code>null</code> if such an expression does not exist
* @param variableType the type of the variable that the result will be assigned to
* @param is50OrHigher <code>true</code> if a 5.0 or higher environment can be used
* @return an expression that can be assigned to the type variableType with node being replaced by a equivalent expression using the getter
*/
public static Expression getAssignedValue(ASTNode node, ASTRewrite astRewrite, Expression getterExpression, ITypeBinding variableType, boolean is50OrHigher) {
InfixExpression.Operator op= null;
AST ast= astRewrite.getAST();
if (isNotInBlock(node))
return null;
if (node.getNodeType() == ASTNode.ASSIGNMENT) {
Assignment assignment= ((Assignment) node);
Expression rightHandSide= assignment.getRightHandSide();
Expression copiedRightOp= (Expression) astRewrite.createCopyTarget(rightHandSide);
if (assignment.getOperator() == Operator.ASSIGN) {
ITypeBinding rightHandSideType= rightHandSide.resolveTypeBinding();
copiedRightOp= createNarrowCastIfNessecary(copiedRightOp, rightHandSideType, ast, variableType, is50OrHigher);
return copiedRightOp;
}
if (getterExpression != null) {
InfixExpression infix= ast.newInfixExpression();
infix.setLeftOperand(getterExpression);
infix.setOperator(ASTNodes.convertToInfixOperator(assignment.getOperator()));
ITypeBinding infixType= infix.resolveTypeBinding();
if (NecessaryParenthesesChecker.needsParenthesesForRightOperand(rightHandSide, infix, variableType)) {
ParenthesizedExpression p= ast.newParenthesizedExpression();
p.setExpression(copiedRightOp);
copiedRightOp= p;
}
infix.setRightOperand(copiedRightOp);
return createNarrowCastIfNessecary(infix, infixType, ast, variableType, is50OrHigher);
}
} else if (node.getNodeType() == ASTNode.POSTFIX_EXPRESSION) {
PostfixExpression po= (PostfixExpression) node;
if (po.getOperator() == PostfixExpression.Operator.INCREMENT)
op= InfixExpression.Operator.PLUS;
if (po.getOperator() == PostfixExpression.Operator.DECREMENT)
op= InfixExpression.Operator.MINUS;
} else if (node.getNodeType() == ASTNode.PREFIX_EXPRESSION) {
PrefixExpression pe= (PrefixExpression) node;
if (pe.getOperator() == PrefixExpression.Operator.INCREMENT)
op= InfixExpression.Operator.PLUS;
if (pe.getOperator() == PrefixExpression.Operator.DECREMENT)
op= InfixExpression.Operator.MINUS;
}
if (op != null && getterExpression != null) {
return createInfixInvocationFromPostPrefixExpression(op, getterExpression, ast, variableType, is50OrHigher);
}
return null;
}