protected static ParseValueNode ( List |
||
tokenList | List |
Token list. |
curIndex | int | Current index. |
owner | the equation that this node is part of. required to pull function delegates out of the dictionary | |
return |
protected static BaseNode ParseValueNode(List<Token> tokenList, ref int curIndex, Equation owner)
{
Debug.Assert(null != tokenList);
Debug.Assert(null != owner);
Debug.Assert(curIndex < tokenList.Count);
//what kind of token do I have at that index?
switch (tokenList[curIndex].TypeOfToken)
{
case TokenType.Number:
{
//awesome, that's nice and easy... just shove the text into a node as a number
//create the number node
NumberNode valueNode = new NumberNode();
//parse the text into the number node
valueNode.ParseToken(tokenList, ref curIndex, owner);
//return the number node as our result
return valueNode;
}
case TokenType.Param:
{
//also not bad, grab the text as a parameter index and put in a node
//create the param node
ParamNode valueNode = new ParamNode();
//parse the parameter index into the node
valueNode.ParseToken(tokenList, ref curIndex, owner);
//return it as our result
return valueNode;
}
case TokenType.Function:
{
//hmmm... need to get the delegate and put in a node?
//create the function node
FunctionNode valueNode = new FunctionNode();
//parse the function delegate into the node
valueNode.ParseToken(tokenList, ref curIndex, owner);
//return it as our result
return valueNode;
}
case TokenType.OpenParen:
{
//ok don't panic...
//verify that this is not the last token
if (curIndex >= (tokenList.Count - 1))
{
throw new FormatException("Can't end an equation with an open paranthesis");
}
//move past this token, cuz nothing else to do with it
curIndex++;
//starting at the next token, start an equation node
EquationNode valueNode = new EquationNode();
//start parsing into the equation node
valueNode.ParseToken(tokenList, ref curIndex, owner);
//return it as the result
return valueNode;
}
case TokenType.Operator:
{
//whoa, how did an operator get in here? it better be a minus sign
return EquationNode.ParseNegativeToken(tokenList, ref curIndex, owner);
}
default:
{
//should just be close paren nodes in here, which we should never get
throw new FormatException("Expected a \"value\" token, but got a " + tokenList[curIndex].TypeOfToken.ToString());
}
}
}
/// <summary> /// This method gets called when the token parser encounters a minus sign in front of a value. /// If the next token is a number, it will be changed to a negative number. /// If the next token is a funcion, param, or equation, an equation will be generated that multiplies the result by -1 /// </summary> /// <returns>The negative token.</returns> /// <param name="tokenList">Token list.</param> /// <param name="curIndex">Current index.</param> /// <param name="owner">Owner.</param> public static BaseNode ParseNegativeToken(List <Token> tokenList, ref int curIndex, Equation owner) { //verify that this is not the last token if (curIndex >= (tokenList.Count - 1)) { throw new FormatException("Can't end an equation with an operator"); } //check that the token is a minus sign if ("-" != tokenList[curIndex].TokenText) { throw new FormatException("Expected a value, but found an invalid operator instead"); } //skip past the minus sign so we can get to the next token curIndex++; //create a number node, parse the next token into it BaseNode valueNode = BaseNode.ParseValueNode(tokenList, ref curIndex, owner); Debug.Assert(null != valueNode); //what did we get back? if (valueNode is NumberNode) { //the next node is a number, multiply it by minus one NumberNode myNumberNode = valueNode as NumberNode; myNumberNode.NumberValue *= -1.0f; } else { //ok the node was a function, param, or equation //create another equation to multiply that resdult by -1 NumberNode negativeOne = new NumberNode(); negativeOne.NumberValue = -1.0f; OperatorNode multiplyNode = new OperatorNode(); multiplyNode.Operator = '*'; //string it all together negativeOne.AppendNextNode(multiplyNode); multiplyNode.AppendNextNode(valueNode); //put that into an equation node and treeify it EquationNode myEquationNode = new EquationNode(); myEquationNode.SubEquation = negativeOne.Treeify(); Debug.Assert(null != myEquationNode.SubEquation); //set our result to the whole equation valueNode = myEquationNode; } //return it as the result return(valueNode); }