@Override
public void endVisit(InfixExpression node) {
if (node.getOperator() == InfixExpression.Operator.CONDITIONAL_AND
|| node.getOperator() == InfixExpression.Operator.CONDITIONAL_OR) {
boolean isAnd = node.getOperator() == InfixExpression.Operator.CONDITIONAL_AND;
boolean isSame = true;
BooleanConstantLE diffVal = isAnd ? BooleanConstantLE.FALSE : BooleanConstantLE.TRUE;
BooleanConstantLE sameVal = isAnd ? BooleanConstantLE.TRUE : BooleanConstantLE.FALSE;
List<Expression> operands = new LinkedList<Expression>();
operands.add(node.getLeftOperand());
operands.add(node.getRightOperand());
operands.addAll(node.extendedOperands());
for (Expression exp : operands) {
BooleanConstantLE val = fa.getResultsAfter(exp).get(fa.getVariable(exp));
if (val == diffVal)
reporter.reportUserProblem(
"The expression " + node + " will always be " + !isAnd + ".", node, getName());
isSame = isSame && val == sameVal;
}
if (isSame)
reporter.reportUserProblem(
"The expression " + node + " will always be " + isAnd + ".", node, getName());
}
}
/**
* 为约束表达式建立约束
*
* @param exp
* @return
*/
public Constraint constraintModeling(InfixExpression exp) {
Constraint constraint = null;
exp.getOperator();
exp.getLeftOperand();
exp.getRightOperand();
return constraint;
}
/*
* @see ASTVisitor#visit(InfixExpression)
*/
public boolean visit(InfixExpression node) {
node.getLeftOperand().accept(this);
this.fBuffer.append(' '); // for cases like x= i - -1; or x= i++ + ++i;
this.fBuffer.append(node.getOperator().toString());
this.fBuffer.append(' ');
node.getRightOperand().accept(this);
final List extendedOperands = node.extendedOperands();
if (extendedOperands.size() != 0) {
this.fBuffer.append(' ');
for (Iterator it = extendedOperands.iterator(); it.hasNext(); ) {
this.fBuffer.append(node.getOperator().toString()).append(' ');
Expression e = (Expression) it.next();
e.accept(this);
}
}
return false;
}
protected static boolean isRemainderExp(Expression remainderExp) {
while (remainderExp instanceof ParenthesizedExpression) {
remainderExp = ((ParenthesizedExpression) remainderExp).getExpression();
}
if (remainderExp instanceof InfixExpression) {
InfixExpression exp = ((InfixExpression) remainderExp);
return REMAINDER.equals(exp.getOperator()) && isNumber(exp.getRightOperand(), 2);
}
return false;
}
protected static boolean isOddnessCheck(InfixExpression oddnessCheck) {
if (EQUALS.equals(oddnessCheck.getOperator())) {
if (isRemainderExp(oddnessCheck.getLeftOperand())) {
return isNumber(oddnessCheck.getRightOperand(), 1);
}
if (isRemainderExp(oddnessCheck.getRightOperand())) {
return isNumber(oddnessCheck.getLeftOperand(), 1);
}
}
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.InfixExpression)
*/
public boolean visit(InfixExpression node) {
PTInfixExpression inf = InstantiationFactory.eINSTANCE.createPTInfixExpression();
inf.setLeftOperand(perform(node.getLeftOperand()));
PTInfixOperator inoper = getParseInfix(node.getOperator());
if (inoper == null) {
// It is not one we can handle.
throw new InvalidExpressionException(
MessageFormat.format(
WorkbenchUtilityMessages.ParseTreeCreationFromAST_OperatorTooComplicatedToHandle_EXC_,
new Object[] {node.getOperator().toString()}));
}
inf.setOperator(inoper);
inf.setRightOperand(perform(node.getRightOperand()));
List eops = inf.getExtendedOperands();
List neops = node.extendedOperands();
int nsize = neops.size();
for (int i = 0; i < nsize; i++) {
eops.add(perform((Expression) neops.get(i)));
}
expression = inf;
return false;
}
/*
* Must be one of:
* <ul>
* <li>[indexBinding] < [result].length;</li>
* <li>[result].length > [indexBinding];</li>
* <li>[indexBinding] < [lengthBinding];</li>
* <li>[lengthBinding] > [indexBinding];</li>
* </ul>
*/
private boolean validateExpression(ForStatement statement) {
Expression expression = statement.getExpression();
if (!(expression instanceof InfixExpression)) return false;
InfixExpression infix = (InfixExpression) expression;
Expression left = infix.getLeftOperand();
Expression right = infix.getRightOperand();
if (left instanceof SimpleName && right instanceof SimpleName) {
IVariableBinding lengthBinding = fLengthBinding;
if (lengthBinding == null) return false;
IBinding leftBinding = ((SimpleName) left).resolveBinding();
IBinding righBinding = ((SimpleName) right).resolveBinding();
if (fIndexBinding.equals(leftBinding)) {
return lengthBinding.equals(righBinding);
} else if (fIndexBinding.equals(righBinding)) {
return lengthBinding.equals(leftBinding);
}
return false;
} else if (left instanceof SimpleName) {
if (!fIndexBinding.equals(((SimpleName) left).resolveBinding())) return false;
if (!Operator.LESS.equals(infix.getOperator())) return false;
return validateLengthQuery(right);
} else if (right instanceof SimpleName) {
if (!fIndexBinding.equals(((SimpleName) right).resolveBinding())) return false;
if (!Operator.GREATER.equals(infix.getOperator())) return false;
return validateLengthQuery(left);
}
return false;
}
/**
* 解析exp得到ExpressionNode
*
* @param exp
* @return
*/
public ExpressionNode getExpressionNode(Expression exp) {
ExpressionNode result = null;
ExpressionNode leftPart = null;
ExpressionNode rightPart = null;
ExpressionType type = null;
ExpressionOperator operator = null;
// InfixExpression.Operator operator;
if (exp instanceof InfixExpression) {
((InfixExpression) exp).getOperator();
} else if (exp instanceof SimpleName) {
} else if (exp instanceof NumberLiteral) {
}
return result;
}
@Override
public void endVisit(InfixExpression node) {
Stack<VMExpression> exps = new Stack<VMExpression>();
exps.push((VMExpression) expressions.pop());
exps.push((VMExpression) expressions.pop());
if (node.hasExtendedOperands()) {
for (int i = 0; i < node.extendedOperands().size(); i++) {
exps.push((VMExpression) expressions.pop());
}
}
VMInfixExpression.Operator operator =
VMInfixExpression.Operator.toOperator(node.getOperator().toString());
VMInfixExpression infixExp = new VMInfixExpression(node, operator);
while (!exps.empty()) {
infixExp.getExpressions().add(exps.pop());
}
expressions.push(infixExp);
};
