/// <summary> /// Parse the specified tokenList and curIndex. /// overloaded by child types to do there own specific parsing. /// </summary> /// <param name="tokenList">Token list.</param> /// <param name="curIndex">Current index.</param> /// <param name="owner">the equation that this node is part of. required to pull function delegates out of the dictionary</param> protected override void ParseToken(List <Token> tokenList, ref int curIndex, Equation owner) { Debug.Assert(null != tokenList); Debug.Assert(null != owner); Debug.Assert(curIndex < tokenList.Count); //get the function name FunctionName = tokenList[curIndex].TokenText; //check if the function is in the equation dictionary if (!owner.FunctionDictionary.ContainsKey(FunctionName)) { throw new FormatException("Unknown function call: " + FunctionName); } //set the function delegate MyFunction = owner.FunctionDictionary[FunctionName]; //increment the current index since we consumed the function name token curIndex++; }
/// <summary> /// Parse a list of tokens into a linked list of equation nodes. /// This will sort it out into a flat equation /// </summary> /// <param name="tokenList">Token list.</param> /// <param name="curIndex">Current index. When this function exits, will be incremented to the past any tokens consumed by this method</param> /// <param name="owner">the equation that this node is part of. required to pull function delegates out of the dictionary</param> /// <returns>A basenode pointing at the head of a linked list parsed by this method</returns> static public BaseNode Parse(List <Token> tokenList, ref int curIndex, Equation owner) { Debug.Assert(null != tokenList); Debug.Assert(null != owner); Debug.Assert(curIndex < tokenList.Count); //first get a value, which will be a number, function, param, or equation node BaseNode myNumNode = BaseNode.ParseValueNode(tokenList, ref curIndex, owner); Debug.Assert(null != myNumNode); //if there are any tokens left, get an operator if (curIndex < tokenList.Count) { BaseNode myOperNode = BaseNode.ParseOperNode(tokenList, ref curIndex, owner); if (null != myOperNode) { //add that node to the end of the list myNumNode.AppendNextNode(myOperNode); //If it was able to pull an operator out, there has to be a number after it. if (curIndex >= tokenList.Count) { throw new FormatException("Can't end an equation with an operator."); } //Recurse into the parse function and sort out the rest of the tokens BaseNode nextNode = BaseNode.Parse(tokenList, ref curIndex, owner); Debug.Assert(null != nextNode); //add that node to the end of the list myOperNode.AppendNextNode(nextNode); } } //return the head node that I found return(myNumNode); }
/// <summary> /// Parse the specified tokenList and curIndex. /// overloaded by child types to do there own specific parsing. /// </summary> /// <param name="tokenList">Token list.</param> /// <param name="curIndex">Current index.</param> /// <param name="owner">the equation that this node is part of. required to pull function delegates out of the dictionary</param> protected override void ParseToken(List <Token> tokenList, ref int curIndex, Equation owner) { Debug.Assert(null != tokenList); Debug.Assert(null != owner); Debug.Assert(curIndex < tokenList.Count); //parse the equation into our subnode SubEquation = BaseNode.Parse(tokenList, ref curIndex, owner); //if some smart ass types in () the parse method wouldve returned null. //it should evaluate to 0 in that case, so create a number node and set the value. if (null == SubEquation) { NumberNode fakeNode = new NumberNode(); fakeNode.NumberValue = 0.0f; SubEquation = fakeNode; } Debug.Assert(null != SubEquation); //treeify the subequation so we can solve it SubEquation = SubEquation.Treeify(); Debug.Assert(null != SubEquation); }
/// <summary> /// Parse the specified tokenList and curIndex. /// overloaded by child types to do there own specific parsing. /// </summary> /// <param name="tokenList">Token list.</param> /// <param name="curIndex">Current index.</param> /// <param name="owner">the equation that this node is part of. required to pull function delegates out of the dictionary</param> protected abstract void ParseToken(List <Token> tokenList, ref int curIndex, Equation owner);
/// <summary> /// Given a list of tokens and the index, get an operator node based on whatever is at that index. /// </summary> /// <returns>The oper node, or null if it hit the end of the equation.</returns> /// <param name="tokenList">Token list.</param> /// <param name="curIndex">Current index.</param> /// <param name="owner">the equation that this node is part of. required to pull function delegates out of the dictionary</param> static protected BaseNode ParseOperNode(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.Operator: { //ok create an operator node OperatorNode operNode = new OperatorNode(); //parse into that node operNode.ParseToken(tokenList, ref curIndex, owner); //return the thing return(operNode); } case TokenType.CloseParen: { //close paren, just eat it and return null. It means this equation is finished parsing curIndex++; return(null); } default: { //should just be close paren nodes in here, which we should never get throw new FormatException("Expected a \"operator\" token, but got a " + tokenList[curIndex].TypeOfToken.ToString()); } } }
/// <summary> /// Given a list of tokens and the index, get a node based on whatever is at that index /// </summary> /// <returns>The value node, will be a number, function, param, or equation node</returns> /// <param name="tokenList">Token list.</param> /// <param name="curIndex">Current index.</param> /// <param name="owner">the equation that this node is part of. required to pull function delegates out of the dictionary</param> static protected 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); }