приоритет операторов вместо рекурсивного спуска

Author: Mr-Rm

src/OneScript.Language/LanguageDef.cs

@@ -282,7 +282,31 @@ public static Token GetToken(string tokText)
         public static int GetPriority(Token op)
         {
             return _priority[op];
-        }
+        }
+
+        public static int GetBinaryPriority(Token op)
+        {
+            return IsBinaryOperator(op) ? _priority[op] : -1;
+        }
+
+        public static int GetUnaryPriority(Token op)
+        {
+            return op switch
+            {
+                Token.OpenPar => MAX_OPERATION_PRIORITY + 1,
+
+                Token.Not => _priority[op],
+                Token.UnaryMinus => _priority[op],
+                Token.UnaryPlus => _priority[op],
+
+                Token.Minus => _priority[Token.UnaryMinus],
+                Token.Plus => _priority[Token.UnaryPlus],
+
+                _ => MAX_OPERATION_PRIORITY
+            };
+        }
+
+
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool IsBuiltInFunction(Token token)

src/OneScript.Language/SyntaxAnalysis/DefaultBslParser.cs

@@ -389,8 +389,8 @@ private void BuildMethodBody()
             finally
             {
                 PopContext();
-            }
-            
+            }
+
             CreateChild(CurrentParent, NodeKind.BlockEnd, _lastExtractedLexem);
             NextLexem();
         }
@@ -1237,130 +1237,68 @@ private BslSyntaxNode BuildExpression(NonTerminalNode parent, Token stopToken)
                 return default;
             }
 
-            var op = BuildOrExpression();
+            var op = BuildExpression(0);
             parent.AddChild(op);
             return op;
         }
-        
-        private BslSyntaxNode BuildOrExpression()
-        {
-            var firstArg = BuildAndExpression();
-            while (_lastExtractedLexem.Token == Token.Or)
-            {
-                var operationLexem = _lastExtractedLexem;
-                NextLexem();
-                var secondArg = BuildAndExpression();
-                firstArg = MakeBinaryOperationNode(firstArg, secondArg, operationLexem);
-            }
 
-            return firstArg;
-        }
-        
-        private BslSyntaxNode BuildAndExpression()
+        private BslSyntaxNode BuildExpression(int prio)
         {
-            var firstArg = BuildNotExpression();
-            while (_lastExtractedLexem.Token == Token.And)
+            var firstArg = BuildPrimaryExpression();
+            while (LanguageDef.GetBinaryPriority(_lastExtractedLexem.Token) > prio)
             {
                 var operationLexem = _lastExtractedLexem;
                 NextLexem();
-                var secondArg = BuildNotExpression();
-                firstArg = MakeBinaryOperationNode(firstArg, secondArg, operationLexem);
-            }
+                var secondArg = BuildExpression(LanguageDef.GetBinaryPriority(operationLexem.Token));
 
-            return firstArg;
-        }
-        
-        private BslSyntaxNode BuildNotExpression()
-        {
-            if (_lastExtractedLexem.Token == Token.Not)
-            {
-                var operation = _lastExtractedLexem;
-                NextLexem();
-                var op = new UnaryOperationNode(operation);
-                var argument = BuildLogicalComparison();
-                op.AddChild(argument);
-                return op;
-            }
-
-            return BuildLogicalComparison();
-        }
-
-        private BslSyntaxNode BuildLogicalComparison()
-        {
-            var firstArg = BuildAdditionExpression();
-            while (_lastExtractedLexem.Token == Token.Equal ||
-                _lastExtractedLexem.Token == Token.MoreThan ||
-                _lastExtractedLexem.Token == Token.LessThan ||
-                _lastExtractedLexem.Token == Token.MoreOrEqual ||
-                _lastExtractedLexem.Token == Token.LessOrEqual ||
-                _lastExtractedLexem.Token == Token.NotEqual)
-            {
-                var operationLexem = _lastExtractedLexem;
-                NextLexem();
-                var secondArg = BuildAdditionExpression();
                 firstArg = MakeBinaryOperationNode(firstArg, secondArg, operationLexem);
             }
 
             return firstArg;
-        }
-        
-        private BslSyntaxNode BuildAdditionExpression()
+        }
+
+        private BslSyntaxNode BuildPrimaryExpression()
         {
-            var firstArg = BuildMultiplyExpression();
-            while (_lastExtractedLexem.Token == Token.Plus ||
-                   _lastExtractedLexem.Token == Token.Minus)
-            {
-                var operationLexem = _lastExtractedLexem;
-                NextLexem();
-                var secondArg = BuildMultiplyExpression();
-                firstArg = MakeBinaryOperationNode(firstArg, secondArg, operationLexem);
-            }
-
-            return firstArg;
-        }
-        
-        private BslSyntaxNode BuildMultiplyExpression()
-        {
-            var firstArg = BuildUnaryMathExpression();
-            while (_lastExtractedLexem.Token == Token.Multiply ||
-                   _lastExtractedLexem.Token == Token.Division ||
-                   _lastExtractedLexem.Token == Token.Modulo)
-            {
-                var operationLexem = _lastExtractedLexem;
-                NextLexem();
-                var secondArg = BuildUnaryMathExpression();
-                firstArg = MakeBinaryOperationNode(firstArg, secondArg, operationLexem);
-            }
-
-            return firstArg;
-        }
-
-        private BslSyntaxNode BuildUnaryMathExpression()
-        {
-            if (_lastExtractedLexem.Token == Token.Plus)
-                _lastExtractedLexem.Token = Token.UnaryPlus;
-            else if (_lastExtractedLexem.Token == Token.Minus)
-                _lastExtractedLexem.Token = Token.UnaryMinus;
-            else
-                return BuildParenthesis();
-            
-            // Можно оптимизировать численный литерал до константы
-            var operation = _lastExtractedLexem;
-            NextLexem();
-            if (_lastExtractedLexem.Type == LexemType.NumberLiteral)
-            {
-                if (operation.Token == Token.UnaryMinus)
-                    _lastExtractedLexem.Content = '-' + _lastExtractedLexem.Content;
-
-                return TerminalNode();
-            }
-            
-            var op = new UnaryOperationNode(operation);
-            var argument = BuildParenthesis();
-            op.AddChild(argument);
-            return op;
-        }
-
+            if (_lastExtractedLexem.Token == Token.OpenPar)
+            {
+                return BuildParenthesis();
+            }
+
+            var operation = _lastExtractedLexem;
+            var prio = LanguageDef.GetUnaryPriority(operation.Token);
+
+            if (prio == LanguageDef.MAX_OPERATION_PRIORITY)
+            {
+                return TerminalNode();
+            }
+
+            NextLexem();
+
+            if (operation.Token == Token.Plus)
+                operation.Token = Token.UnaryPlus;
+            else if (operation.Token == Token.Minus)
+            {
+                operation.Token = Token.UnaryMinus;
+                if (_lastExtractedLexem.Type == LexemType.NumberLiteral) //TODO:move it to lexer
+                {
+                    _lastExtractedLexem.Content = '-' + _lastExtractedLexem.Content;
+                    return TerminalNode();
+                }
+            }
+
+            if (LanguageDef.GetUnaryPriority(_lastExtractedLexem.Token) <= prio)
+            {
+                AddError(LocalizedErrors.ExpressionSyntax());
+                return default;
+            }
+
+            var arg = BuildExpression(prio);
+            var op = new UnaryOperationNode(operation);
+            op.AddChild(arg);
+            return op;
+        }
+
+ 
         private BslSyntaxNode BuildExpressionUpTo(NonTerminalNode parent, Token stopToken)
         {
             var node = BuildExpression(parent, stopToken);
@@ -1392,36 +1330,31 @@ private void BuildOptionalExpression(NonTerminalNode parent, Token stopToken)
                 return;
             }
 
-            var op = BuildOrExpression();
+            var op = BuildExpression(0);
             parent.AddChild(op);
         }
 
         #region Operators
 
-        private static BslSyntaxNode MakeBinaryOperationNode(BslSyntaxNode firstArg, BslSyntaxNode secondArg, in Lexem lexem)
+        private static BinaryOperationNode MakeBinaryOperationNode(BslSyntaxNode firstArg, BslSyntaxNode secondArg, in Lexem lexem)
         {
             var node = new BinaryOperationNode(lexem);
             node.AddChild(firstArg);
             node.AddChild(secondArg);
             return node;
-        }
-        
+        }
+
         private BslSyntaxNode BuildParenthesis()
-        {
-            if (_lastExtractedLexem.Token == Token.OpenPar)
-            {
-                NextLexem();
-                var expr = BuildOrExpression();
-                if (_lastExtractedLexem.Token != Token.ClosePar)
-                {
-                    AddError(LocalizedErrors.TokenExpected(Token.ClosePar));
-                }
-                NextLexem();
-                
-                return BuildDereference(expr);
-            }
-
-            return TerminalNode();
+        {
+            NextLexem();
+            var expr = BuildExpression(0);
+            if (_lastExtractedLexem.Token != Token.ClosePar)
+            {
+                AddError(LocalizedErrors.TokenExpected(Token.ClosePar));
+            }
+            NextLexem();
+
+            return BuildDereference(expr);
         }
 
         #endregion
@@ -1676,7 +1609,7 @@ private Token[] PopStructureToken()
             return tok;
         }
 
-        private BslSyntaxNode CreateChild(NonTerminalNode parent, NodeKind kind, in Lexem lex)
+        private static BslSyntaxNode CreateChild(NonTerminalNode parent, NodeKind kind, in Lexem lex)
         {
             var child = NodeBuilder.CreateNode(kind, lex);
             parent.AddChild(child);