Axiom.Compiler.Framework.PrologOperatorTable.ExclusivelyPrefix C# (CSharp) Метод

        public bool ExclusivelyPrefix(string name)
        {
            if (IsOperator(name))
            {
                return true;
            }
            PrologOperator op = GetOperator(name);
            if (op != null)
            {
                return op.PostfixPrecedence == -1;
            }
            return false;
        }

        private BinaryTree Right(int n, int m, ref BinaryTree result)
        {
            switch (_scanner.Lookahead.Kind)
            {
            case PrologToken.DOT:
            case PrologToken.RPAREN:
            case PrologToken.RBRACKET:
                return(result);

            case PrologToken.LPAREN:
            case PrologToken.LBRACKET:
                _errors.Add(new PrologCompilerError("P0007", "Unexpected open brackets or parenthsis", "", false, _scanner.Current.Line, _scanner.Current.Column));
                return(result);

            case PrologToken.COMMA:
                if (n >= 1000 && m <= 1000)
                {
                    m = 1000;
                    _scanner.Next();
                    result = new BinaryTree(",", result, Term(m));
                    if (n > m)
                    {
                        Right(n, m, ref result);
                    }
                }
                return(result);

            case PrologToken.ATOM:
                PrologOperator laOp = _operators.GetOperator(_scanner.Lookahead.StringValue);
                if (laOp != null)
                {
                    if (laOp.IsPostfix &&
                        n >= laOp.PostfixPrecedence &&
                        m <= laOp.PostfixLeftPrecedence)
                    {
                        _scanner.Next();
                        if (_operators.IsOperator(_scanner.Current.StringValue))
                        {
                            PrologOperator o = _operators.GetOperator(_scanner.Current.StringValue);
                            if (o.IsInfix &&
                                n >= o.InfixPrecedence &&
                                m <= o.InfixLeftPrecedence)
                            {
                                switch (_scanner.Lookahead.Kind)
                                {
                                case PrologToken.LPAREN:
                                case PrologToken.LBRACKET:
                                    result = new BinaryTree(o.Name, result, Term(o.InfixRightPrecedence));
                                    m      = o.InfixPrecedence;
                                    Right(n, m, ref result);
                                    break;

                                case PrologToken.COMMA:
                                case PrologToken.RPAREN:
                                case PrologToken.RBRACKET:
                                    result = new BinaryTree(_scanner.Current.StringValue, result);
                                    m      = o.InfixPrecedence;
                                    Right(n, m, ref result);
                                    break;

                                case PrologToken.ATOM:
                                    if (_operators.IsOperator(_scanner.Lookahead.StringValue))
                                    {
                                        if (_operators.ExclusivelyPrefix(_scanner.Lookahead.StringValue))
                                        {
                                            result = new BinaryTree(_scanner.Lookahead.StringValue, result, Term(_operators.GetOperator(_scanner.Lookahead.StringValue).PrefixRightPrecedence));
                                            m      = o.InfixPrecedence;
                                            Right(n, m, ref result);
                                            break;
                                        }
                                    }
                                    else
                                    {
                                        result = new BinaryTree(_scanner.Lookahead.StringValue, result, null);
                                        m      = _operators.GetOperator(_scanner.Lookahead.StringValue).InfixPrecedence;
                                        Right(n, m, ref result);
                                        break;
                                    }
                                    break;
                                }
                            }
                            else
                            {
                                result = new BinaryTree(_scanner.Current.StringValue, result);
                                m      = _operators.GetOperator(_scanner.Current.StringValue).InfixPrecedence;
                                Right(n, m, ref result);
                            }
                        }
                        break;
                    }
                    else if (laOp.IsInfix && n >= laOp.InfixPrecedence && m <= laOp.InfixLeftPrecedence)
                    {
                        _scanner.Next();
                        int p = _operators.GetOperator(_scanner.Current.StringValue).InfixPrecedence;
                        int t = _operators.GetOperator(_scanner.Current.StringValue).InfixRightPrecedence;
                        result = new BinaryTree(_scanner.Current.StringValue, result, Term(t));
                        m      = p;
                        Right(n, m, ref result);
                        break;
                    }
                }
                else
                {
                    return(result);
                }
                break;
            }
            return(result);
        }