private static JsAstNode CreateSplitNodeFromEnd(JsAstNodeList nodeList, int ndx)
{
JsAstNode newNode;
if (ndx == nodeList.Count - 1)
{
// the LAST one can be broken. Pull it off the list and we will just
// insert it after the current node.
newNode = nodeList[ndx];
nodeList.RemoveAt(ndx);
}
else if (ndx == nodeList.Count - 2)
{
// the PENULTIMATE item can be broken. So create a new comma operator
// with the just the last two item and we'll insert it after the current node
var left = nodeList[ndx];
nodeList.RemoveAt(ndx);
var right = nodeList[ndx];
nodeList.RemoveAt(ndx);
newNode = new JsCommaOperator(null, nodeList.Parser)
{
Operand1 = left,
Operand2 = right
};
}
else
{
// at least three items will be pulled off, which means there will
// be at least two items on the right, so we'll create a new astlist to
// insert those items into a new comma operator
var left = nodeList[ndx];
nodeList.RemoveAt(ndx);
// if we were passed zero, then just reuse the node list.
// otherwise we need to create a new one and move the items
// from the index position over.
JsAstNodeList right;
if (ndx == 0)
{
right = nodeList;
}
else
{
right = new JsAstNodeList(null, nodeList.Parser);
while (ndx < nodeList.Count)
{
var temp = nodeList[ndx];
nodeList.RemoveAt(ndx);
right.Append(temp);
}
}
newNode = new JsCommaOperator(null, nodeList.Parser)
{
Operand1 = left,
Operand2 = right
};
}
return(newNode);
}
public static JsAstNode CombineWithComma(JsContext context, JsParser parser, JsAstNode operand1, JsAstNode operand2)
{
var comma = new JsCommaOperator(context, parser);
// if the left is a comma-operator already....
var leftBinary = operand1 as JsBinaryOperator;
var rightBinary = operand2 as JsBinaryOperator;
if (leftBinary != null && leftBinary.OperatorToken == JsToken.Comma)
{
// the left-hand side is already a comma operator. Instead of nesting these, we're
// going to combine them
// move the old list's left-hand side to our left-hand side
comma.Operand1 = leftBinary.Operand1;
JsAstNodeList list;
if (rightBinary != null && rightBinary.OperatorToken == JsToken.Comma)
{
// the right is ALSO a comma operator. Create a new list, append all the rest of the operands
// and set our right-hand side to be the list
list = new JsAstNodeList(null, parser);
list.Append(leftBinary.Operand2).Append(rightBinary.Operand1).Append(rightBinary.Operand2);
}
else
{
// the right is not a comma operator.
// see if the left-hand side already has a list we can use
list = leftBinary.Operand2 as JsAstNodeList;
if (list == null)
{
// it's not a list already
// create a new list with the left's right and our right and set it to our right
list = new JsAstNodeList(null, parser);
list.Append(leftBinary.Operand2);
}
// and add our right-hand operand to the end of the list
list.Append(operand2);
}
// set the list on the right
comma.Operand2 = list;
}
else if (rightBinary != null && rightBinary.OperatorToken == JsToken.Comma)
{
// the left hand side is NOT a comma operator.
comma.Operand1 = operand1;
// the right-hand side is already a comma-operator, but the left is not.
// see if it already has a list we can reuse
var rightList = rightBinary.Operand2 as JsAstNodeList;
if (rightList != null)
{
// it does. Prepend its right-hand operand and use the list
rightList.Insert(0, rightBinary.Operand1);
}
else
{
// it's not -- create a new list containing the operands
rightList = new JsAstNodeList(rightBinary.Context, parser);
rightList.Append(rightBinary.Operand1);
rightList.Append(rightBinary.Operand2);
}
comma.Operand2 = rightList;
}
else
{
comma.Operand1 = operand1;
comma.Operand2 = operand2;
}
return(comma);
}
