/*******************************************************************************
* Copyright (c) 2000, 2007 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.wst.jsdt.internal.corext.refactoring.code;
import org.eclipse.wst.jsdt.core.dom.Assignment;
import org.eclipse.wst.jsdt.core.dom.ConditionalExpression;
import org.eclipse.wst.jsdt.core.dom.Expression;
import org.eclipse.wst.jsdt.core.dom.InfixExpression;
import org.eclipse.wst.jsdt.core.dom.InstanceofExpression;
import org.eclipse.wst.jsdt.core.dom.PostfixExpression;
import org.eclipse.wst.jsdt.core.dom.PrefixExpression;
import org.eclipse.wst.jsdt.core.dom.InfixExpression.Operator;
public class OperatorPrecedence {
private static final int ASSIGNMENT= 0;
private static final int CONDITIONAL= 1;
private static final int CONDITIONAL_OR= 2;
private static final int CONDITIONAL_AND= 3;
private static final int BITWISE_INCLUSIVE_OR= 4;
private static final int BITWISE_EXCLUSIVE_OR= 5;
private static final int BITWISE_AND= 6;
private static final int EQUALITY= 7;
private static final int RATIONAL= 8;
private static final int SHIFT= 9;
private static final int ADDITIVE= 10;
private static final int MULTIPLICATIVE= 11;
private static final int PREFIX= 12;
private static final int POSTFIX= 13;
public static int getValue(Expression expression) {
if (expression instanceof InfixExpression) {
return getNormalizedValue((InfixExpression)expression);
} else if (expression instanceof PostfixExpression) {
return getNormalizedValue((PostfixExpression)expression);
} else if (expression instanceof PrefixExpression) {
return getNormalizedValue((PrefixExpression)expression);
} else if (expression instanceof Assignment) {
return getNormalizedValue((Assignment)expression);
} else if (expression instanceof ConditionalExpression) {
return getNormalizedValue((ConditionalExpression)expression);
} else if (expression instanceof InstanceofExpression) {
return getNormalizedValue((InstanceofExpression)expression);
}
return -1;
}
private static int getNormalizedValue(Assignment ass) {
return ASSIGNMENT;
}
private static int getNormalizedValue(ConditionalExpression exp) {
return CONDITIONAL;
}
private static int getNormalizedValue(InfixExpression exp) {
Operator operator= exp.getOperator();
if (operator == Operator.CONDITIONAL_OR) {
return CONDITIONAL_OR;
} else if (operator == Operator.CONDITIONAL_AND) {
return CONDITIONAL_AND;
} else if (operator == Operator.OR) {
return BITWISE_INCLUSIVE_OR;
} else if (operator == Operator.XOR) {
return BITWISE_EXCLUSIVE_OR;
} else if (operator == Operator.AND) {
return BITWISE_AND;
} else if (operator == Operator.EQUALS || operator == Operator.NOT_EQUALS) {
return EQUALITY;
} else if (operator == Operator.LESS || operator == Operator.LESS_EQUALS || operator == Operator.GREATER || operator == Operator.GREATER_EQUALS) {
return RATIONAL;
} else if (operator == Operator.LEFT_SHIFT || operator == Operator.RIGHT_SHIFT_SIGNED || operator == Operator.RIGHT_SHIFT_UNSIGNED) {
return SHIFT;
} else if (operator == Operator.PLUS || operator == Operator.MINUS) {
return ADDITIVE;
} else if (operator == Operator.REMAINDER || operator == Operator.DIVIDE || operator == Operator.TIMES) {
return MULTIPLICATIVE;
}
return -1;
}
private static int getNormalizedValue(InstanceofExpression exp) {
return RATIONAL;
}
private static int getNormalizedValue(PrefixExpression exp) {
return PREFIX;
}
private static int getNormalizedValue(PostfixExpression exp) {
return POSTFIX;
}
}