public static Parse ( List |
||
tokenList | List |
Token list. |
curIndex | int | Current index. When this function exits, will be incremented to the past any tokens consumed by this method |
owner | the equation that this node is part of. required to pull function delegates out of the dictionary | |
Résultat |
/// <summary> /// Parse the specified equationText. /// </summary> /// <param name="equationText">Equation text.</param> public void Parse(string equationText) { //grab the equation text TextEquation = equationText; //straight up tokenize the equation: operators, numbers, parens, functions, params List <Token> tokenList = Tokenize(equationText); //sort out those tokens into a linked list of equation nodes int index = 0; BaseNode listRootNode = BaseNode.Parse(tokenList, ref index, this); //take that linked list and bend it into a binary tree. Grab the root node RootNode = listRootNode.Treeify(); }
/// <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); }