static void RecurseParameters(AstNodeList parameterList, AstNode node) { if (node != null) { // if this is a comma operator, then we need to var binOp = node as BinaryExpression; if (binOp != null && binOp.OperatorToken == JSToken.Comma) { // there are two or more parameters - recurse the list so we get them added left to right, // converting each one to a binding object RecurseParameters(parameterList, binOp.Operand1); // comma operators can flatten lots of commas to an element on the left, and subsequent // elements in a list on the right. var rightList = binOp.Operand2 as AstNodeList; if (rightList != null) { foreach (var listItem in rightList.Children) { parameterList.Append(ConvertToParameter(listItem, parameterList.Count)); } } else { // nope, just a single item parameterList.Append(ConvertToParameter(binOp.Operand2, parameterList.Count)); } } else { // nope; single operand to convert to a parameter parameterList.Append(ConvertToParameter(node, 0)); } } }
public override bool ReplaceChild(AstNode oldNode, AstNode newNode) { // if the old node isn't our element list, ignore the cal if (oldNode == Elements) { if (newNode == null) { // we want to remove the list altogether Elements = null; return(true); } else { // if the new node isn't an AstNodeList, then ignore the call AstNodeList newList = newNode as AstNodeList; if (newList != null) { // replace it Elements = newList; return(true); } } } return(false); }
public static AstNodeList ToParameters(AstNode node) { AstNodeList parameterList = null; if (node != null) { parameterList = new AstNodeList(node.Context); // ignore any parentheses around the parameter(s) var groupingOperator = node as GroupingOperator; RecurseParameters( parameterList, groupingOperator != null ? groupingOperator.Operand : node); } return(parameterList); }
public override bool ReplaceChild(AstNode oldNode, AstNode newNode) { if (Expression == oldNode) { Expression = newNode; return(true); } if (Cases == oldNode) { AstNodeList newList = newNode as AstNodeList; if (newNode == null || newList != null) { // remove it Cases = newList; return(true); } } return(false); }
/// <summary> /// an astlist is equivalent to another astlist if they both have the same number of /// items, and each item is equivalent to the corresponding item in the other /// </summary> /// <param name="otherNode"></param> /// <returns></returns> public override bool IsEquivalentTo(AstNode otherNode) { bool isEquivalent = false; AstNodeList otherList = otherNode as AstNodeList; if (otherList != null && m_list.Count == otherList.Count) { // now assume it's true unless we come across an item that ISN'T // equivalent, at which case we'll bail the test. isEquivalent = true; for (var ndx = 0; ndx < m_list.Count; ++ndx) { if (!m_list[ndx].IsEquivalentTo(otherList[ndx])) { isEquivalent = false; break; } } } return(isEquivalent); }