public static Expression Parse(string filterString)
{
var tokens = Lexer.Tokenize(filterString);
ShuntingYardParser parser = new ShuntingYardParser(tokens);
return(parser.Parse());
}
public void TestShuntingYard02()
{
var arrExpected = new[]
{
GenerateTestToken(TokenType.Number, "1"),
GenerateTestToken(TokenType.Number, "2"),
GenerateTestToken(TokenType.Operator, "+"),
GenerateTestToken(TokenType.Number, "3"),
GenerateTestToken(TokenType.Number, "4"),
GenerateTestToken(TokenType.Operator, "*"),
GenerateTestToken(TokenType.Operator, "-"),
GenerateTestToken(TokenType.Number, "5"),
GenerateTestToken(TokenType.Number, "6"),
GenerateTestToken(TokenType.Number, "7"),
GenerateTestToken(TokenType.Operator, "^"),
GenerateTestToken(TokenType.Operator, "^"),
GenerateTestToken(TokenType.Number, "8"),
GenerateTestToken(TokenType.Operator, "*"),
GenerateTestToken(TokenType.Operator, "+"),
GenerateTestToken(TokenType.Number, "9"),
GenerateTestToken(TokenType.Operator, "-"),
};
var arrResult = ShuntingYardParser.InfixToRpn("1 + 2 - 3*4 + 5^6^7*8 - 9").ToArray();
var arrResultT = ShuntingYardParser.InfixToRpn("1 + 2 - 3 4 + 5^6^7*8 - 9").ToArray();
Assert.IsTrue(arrResult.SequenceEqual(arrExpected));
Assert.IsTrue(arrResult.SequenceEqual(arrResultT));
}
/// <summary>
/// Constructor that requires a lexer
/// </summary>
/// <param name="grammar">the grammar</param>
public Parser(IGrammar grammar)
{
if (grammar == null)
{
throw new ArgumentNullException("grammar");
}
Grammar = grammar;
_shuntingYard = new ShuntingYardParser(grammar);
}
public void TestShuntingYard06()
{
var arrExpected = new[]
{
GenerateTestToken(TokenType.Number, "5"),
GenerateTestToken(TokenType.Number, "-5"),
GenerateTestToken(TokenType.Operator, "+"),
GenerateTestToken(TokenType.Number, "5"),
GenerateTestToken(TokenType.Operator, "+"),
};
var arrResult = ShuntingYardParser.InfixToRpn("5 +-5+ 5").ToArray();
Assert.IsTrue(arrResult.SequenceEqual(arrExpected));
}
public void TestShuntingYard07()
{
var arrExpected = new[]
{
GenerateTestToken(TokenType.Number, "45"),
GenerateTestToken(TokenType.Number, "2"),
GenerateTestToken(TokenType.Operator, "^"),
GenerateTestToken(TokenType.Number, "54"),
GenerateTestToken(TokenType.Function, "sqrt"),
};
var arrResult = ShuntingYardParser.InfixToRpn("sqrt(45 ^ 2, 54)", "a").ToArray();
Assert.IsTrue(arrResult.SequenceEqual(arrExpected));
}
public void TestShuntingYard05()
{
var arrExpected = new[]
{
GenerateTestToken(TokenType.Number, "2"),
GenerateTestToken(TokenType.Number, "3"),
GenerateTestToken(TokenType.Function, "max"),
GenerateTestToken(TokenType.Number, "3"),
GenerateTestToken(TokenType.Operator, "/"),
GenerateTestToken(TokenType.Constant, "π"),
GenerateTestToken(TokenType.Operator, "*"),
GenerateTestToken(TokenType.Function, "sin"),
};
var arrResult = ShuntingYardParser.InfixToRpn("sin ( max ( 2, 3 ) / 3 * π )").ToArray();
Assert.IsTrue(arrResult.SequenceEqual(arrExpected));
}
public void TestShuntingYard03()
{
var arrExpected = new[]
{
GenerateTestToken(TokenType.Number, "1"),
GenerateTestToken(TokenType.Number, "5"),
GenerateTestToken(TokenType.Function, "ln"),
GenerateTestToken(TokenType.Number, "8"),
GenerateTestToken(TokenType.Function, "exp"),
GenerateTestToken(TokenType.Operator, "-"),
GenerateTestToken(TokenType.Function, "sin"),
GenerateTestToken(TokenType.Number, "2"),
GenerateTestToken(TokenType.Operator, "^"),
GenerateTestToken(TokenType.Operator, "+"),
GenerateTestToken(TokenType.Function, "cos"),
};
var arrResult = ShuntingYardParser.InfixToRpn("cos(1 + sin(ln(5) - exp(8))^2)").ToArray();
Assert.IsTrue(arrResult.SequenceEqual(arrExpected));
}
/// <summary>
/// Erstellt eine Baumstruktur, die einen mathematischen Term repräsentiert.
/// </summary>
/// <param name="token">Eine Liste an Token, die den mathematischen Term abbilden.</param>
/// <param name="environment">Die Umgebung, in dessen Kontext der mathematische Term seine Gültigkeit besitzt.</param>
/// <param name="bInfix">true, wenn der Term in der Infix-Notation formatiert ist, ansonsten false.</param>
/// <returns>Eine Baumstruktur, die einen mathematischen Term repräsentiert.</returns>
public static Node Get(IEnumerable <Token> token, MathEnvironment environment, bool bInfix)
{
if (bInfix)
{
token = ShuntingYardParser.InfixToRpn(token);
}
Stack <Node> stack = new Stack <Node>();
foreach (Token t in token)
{
stack.Push(GenerateNodeFromToken(t, stack, environment));
}
if (stack.Count != 1)
{
throw new ArithmeticException("Unable to parse the given term.");
}
return(stack.Pop());
}
public void TestShuntingYard04()
{
var arrExpected = new[]
{
GenerateTestToken(TokenType.Number, "3"),
GenerateTestToken(TokenType.Number, "4"),
GenerateTestToken(TokenType.Number, "2"),
GenerateTestToken(TokenType.Operator, "*"),
GenerateTestToken(TokenType.Number, "1"),
GenerateTestToken(TokenType.Number, "5"),
GenerateTestToken(TokenType.Operator, "-"),
GenerateTestToken(TokenType.Number, "2"),
GenerateTestToken(TokenType.Number, "3"),
GenerateTestToken(TokenType.Operator, "^"),
GenerateTestToken(TokenType.Operator, "^"),
GenerateTestToken(TokenType.Operator, "/"),
GenerateTestToken(TokenType.Operator, "+"),
};
var arrResult = ShuntingYardParser.InfixToRpn("3 + 4 * 2 / ( 1 - 5 ) ^ 2 ^ 3").ToArray();
Assert.IsTrue(arrResult.SequenceEqual(arrExpected));
}
public void Initialize(string input)
{
player.GetComponent <Player>().UpdateParserScript();
ClearTree();
Debug.Log("input = " + input);//3 + 4 * 2 / (1 - 5) ^ 2 ^ 3
/*
* 3 + 4 * 2 / (1 - 5) ^ 2 ^ 3
+
+ 3
+ /
* ^
* 4 2 ( - ) ^
* 1 5 2 3
*/
ICollection <IMyOperator> operators = new List <IMyOperator>();
operators.Add(new MyBaseOperator('^', true, 4));
operators.Add(new MyBaseOperator('*', false, 3));
operators.Add(new MyBaseOperator('/', false, 3));
operators.Add(new MyBaseOperator('+', false, 2));
operators.Add(new MyBaseOperator('-', false, 2));
ShuntingYardParser parser = new ShuntingYardParser(operators);
ASTNode parseTree = parser.ConvertInfixNotationToAST(input);
//Debug.Log(parseTree.getValue());
GameObject treeTop = GameObject.Find("Tree1");
//parser.DrawAST(parseTree, treeTop, false, false);
parser.designateHierarchy(parseTree, false, false);
//parser.DrawAST2(parseTree, treeTop, 0);
parser.DrawAST3(parseTree, treeTop, "Tree1", nodeObjects, 0, 0, "0");
//parser.DrawASTTemplate(5, treeTop, nodeObjects, true, true);
gameObjectTreeHeight = parser.GetHeight(nodeObjects);
parser.DrawASTTemplate2(nodeObjects, gameObjectTreeHeight);
}
public void PerformanceTest2()
{
var grammar = new Grammar(new QuerySyntax())
{
Strict = true
};
var lexer = new Lexer(grammar);
var parser = new Parser(grammar);
var source = "Id!=null and FirstName like '%e%' and LastName like '%e%' and BornAt<date(now()) and Address.Street like 'e%' and Address.City like '%e' or Address.Number like '%0%'";
var shuntingYard = new ShuntingYardParser(grammar);
var tokens = lexer.Tokenize(source).ToList();
var rpn = shuntingYard.BuildRPN(tokens);
var exp = shuntingYard.BuildAST <Person, bool>(tokens);
Debug.WriteLine(exp);
var expression = parser.Parse <Person, bool>(source);
var d = expression.Compile();
var sw = new Stopwatch();
sw.Start();
for (var i = 0; i < 1000; i++)
{
tokens = lexer.Tokenize(source).ToList();
}
sw.Stop();
Debug.WriteLine("source->tokens: " + sw.ElapsedMilliseconds);
sw = new Stopwatch();
sw.Start();
for (var i = 0; i < 1000; i++)
{
shuntingYard.BuildAST <Person, bool>(tokens);
}
sw.Stop();
Debug.WriteLine("infix->AST: " + sw.ElapsedMilliseconds);
}
public ShuntingYardParserTests()
{
this.parser = new ShuntingYardParser(new Lexer());
}
public void PerformanceTest()
{
// this test shows that
var grammar = new Grammar(new QuerySyntax());
var lexer = new Lexer(grammar);
var parser = new Parser(grammar);
var source = "(1+3)*(5.0/0.4)-16.3e5";
//var source = "(color=white or color=green) and wheels >=10";
var shuntingYard = new ShuntingYardParser(grammar);
var tokens = lexer.Tokenize(source).ToArray();
var rpn = shuntingYard.BuildRPN(tokens);
var exp = shuntingYard.BuildAST <object, double>(tokens);
var expression = parser.Parse <object, double>(source);
var d = expression.Compile();
var sw = new Stopwatch();
sw.Start();
for (var i = 0; i < 10000; i++)
{
lexer.Tokenize(source);
}
sw.Stop();
Debug.WriteLine("tokenizing: " + sw.ElapsedMilliseconds);
sw = new Stopwatch();
sw.Start();
for (var i = 0; i < 10000; i++)
{
shuntingYard.BuildRPN(tokens);
}
sw.Stop();
Debug.WriteLine("infix->postfix: " + sw.ElapsedMilliseconds);
sw = new Stopwatch();
sw.Start();
for (var i = 0; i < 10000; i++)
{
shuntingYard.BuildAST <object, double>(tokens);
}
sw.Stop();
Debug.WriteLine("infix->AST: " + sw.ElapsedMilliseconds);
sw = new Stopwatch();
sw.Start();
for (var i = 0; i < 10000; i++)
{
parser.Parse <object, double>(source);
}
sw.Stop();
Debug.WriteLine("source->ast: " + sw.ElapsedMilliseconds);
sw = new Stopwatch();
sw.Start();
for (var i = 0; i < 10000; i++)
{
expression.Compile();
}
sw.Stop();
Debug.WriteLine("ast->IL: " + sw.ElapsedMilliseconds);
}
/// <summary>
/// Parst einen mathematischen Term und gibt diesen aufgeteilt in einzelne Bauteile und in umgedrehter polnischer Notation zurück.
/// </summary>
/// <param name="strTerm">Der mathematische Term als String, z.B. "5 + 5 - sqrt(9)"</param>
/// <param name="arrVariables">Eine Liste mit Variablen, die in dem Term vortkommen, beispielsweise "x", "y"</param>
/// <returns></returns>
public static Token[] TokenizeTermToRpn(string strTerm, params string[] arrVariables)
{
return(ShuntingYardParser.InfixToRpn(strTerm, arrVariables).ToArray());
}
