static {
Precedence[] values = Precedence.values();
for (Precedence precedence : values) {
int ordinal = precedence.ordinal();
precedence.higher = ordinal > 0 ? values[ordinal - 1] : null;
}
}
static {
Set<IElementType> operations = new HashSet<IElementType>();
Precedence[] values = Precedence.values();
for (Precedence precedence : values) {
operations.addAll(Arrays.asList(precedence.getOperations().getTypes()));
}
ALL_OPERATIONS = TokenSet.create(operations.toArray(new IElementType[operations.size()]));
}
/**
* Return true if the passed in node or any of its up-stream (higher index siblings have
* moveAllowed="false".
*/
private static boolean isNotReparentable(NodeInfo ni) {
if (ni.node.getAttribute(Constants.ATT_MOVE_ALLOWED).equals("false")) return true;
Precedence nodePrec = ni.precedence;
Element node = (Element) ni.node.getNextSibling();
while (node != null) {
if (node.getAttribute(Constants.ATT_MOVE_ALLOWED).equals("false")) {
Precedence p = Precedence.newInstance(node.getAttribute(Constants.ATT_FRAGMENT));
if (nodePrec.isEqualTo(p)) return true;
}
node = (Element) node.getNextSibling();
}
return false;
}
/*
* element (operation element)*
*
* see the precedence table
*/
private void parseBinaryExpression(Precedence precedence) {
// System.out.println(precedence.name() + " at " + myBuilder.getTokenText());
PsiBuilder.Marker expression = mark();
precedence.parseHigherPrecedence(this);
while (!interruptedWithNewLine() && atSet(precedence.getOperations())) {
IElementType operation = tt();
parseOperationReference();
JetNodeType resultType = precedence.parseRightHandSide(operation, this);
expression.done(resultType);
expression = expression.precede();
}
expression.drop();
}
/**
* This method determines if any illegal hopping is being specified. To determine if the
* positioning is specifying an ordering that will result in hopping I need to determine for each
* node n in the list if any of the nodes to be positioned to its right currently lie to its left
* in the CVP and have moveAllowed="false" and have the same precedence or if any of the nodes to
* be positioned to its left currently lie to its right in the CVP and have moveAllowed="false"
* and have the same precedence.
*/
static boolean isIllegalHoppingSpecified(List<NodeInfo> order) {
for (int i = 0; i < order.size(); i++) {
NodeInfo ni = (NodeInfo) order.get(i);
// look for move restricted nodes
if (!ni.node.getAttribute(Constants.ATT_MOVE_ALLOWED).equals("false")) continue;
// now check nodes in lower position to see if they "hopped" here
// or if they have similar precedence and came from another parent.
for (int j = 0; j < i; j++) {
NodeInfo niSib = (NodeInfo) order.get(j);
// skip lower precedence nodes from this parent. These will get
// bumped during the lower precedence check
if (niSib.precedence == Precedence.getUserPrecedence()) continue;
if (niSib.precedence.isEqualTo(ni.precedence)
&& (niSib.indexInCVP == -1
|| // from another parent
ni.indexInCVP < niSib.indexInCVP)) // niSib hopping left
return true;
}
// now check upper positioned nodes to see if they "hopped"
for (int j = i + 1; j < order.size(); j++) {
NodeInfo niSib = (NodeInfo) order.get(j);
// ignore nodes from other parents and user precedence nodes
if (niSib.indexInCVP == -1 || niSib.precedence == Precedence.getUserPrecedence()) continue;
if (ni.indexInCVP > niSib.indexInCVP
&& // niSib hopped right
niSib.precedence.isEqualTo(ni.precedence)) return true;
}
}
return false;
}
