◆ Parse()

ExpressionNode System.Data.ExpressionParser.Parse ( )
inlinepackage
Definition at line 109 of file ExpressionParser.cs.
    {
        _expression = null;
        StartScan();
        int num = 0;
        while (_token != Tokens.EOS)
        {
            while (true)
            {
                Scan();
                switch (_token)
                {
                case Tokens.EOS:
                    break;
                case Tokens.Name:
                case Tokens.Numeric:
                case Tokens.Decimal:
                case Tokens.Float:
                case Tokens.StringConst:
                case Tokens.Date:
                case Tokens.Parent:
                {
                    ExpressionNode node = null;
                    string text = null;
                    if (_prevOperand != 0)
                    {
                        throw ExprException.MissingOperator(new string(_text, _start, _pos - _start));
                    }
                    if (_topOperator > 0)
                    {
                        OperatorInfo operatorInfo = _ops[_topOperator - 1];
                        if (operatorInfo._type == Nodes.Binop && operatorInfo._op == 5 && _token != Tokens.Parent)
                        {
                            throw ExprException.InWithoutParentheses();
                        }
                    }
                    _prevOperand = 1;
                    switch (_token)
                    {
                    case Tokens.Parent:
                    {
                        string relationName;
                        try
                        {
                            Scan();
                            if (_token == Tokens.LeftParen)
                            {
                                ScanToken(Tokens.Name);
                                relationName = NameNode.ParseName(_text, _start, _pos);
                                ScanToken(Tokens.RightParen);
                                ScanToken(Tokens.Dot);
                            }
                            else
                            {
                                relationName = null;
                                CheckToken(Tokens.Dot);
                            }
                        }
                        catch (Exception e) when (ADP.IsCatchableExceptionType(e))
                        {
                            throw ExprException.LookupArgument();
                        }
                        ScanToken(Tokens.Name);
                        string columnName = NameNode.ParseName(_text, _start, _pos);
                        OperatorInfo operatorInfo = _ops[_topOperator - 1];
                        node = new LookupNode(_table, columnName, relationName);
                        break;
                    }
                    case Tokens.Name:
                    {
                        OperatorInfo operatorInfo = _ops[_topOperator - 1];
                        node = new NameNode(_table, _text, _start, _pos);
                        break;
                    }
                    case Tokens.Numeric:
                        text = new string(_text, _start, _pos - _start);
                        node = new ConstNode(_table, ValueType.Numeric, text);
                        break;
                    case Tokens.Decimal:
                        text = new string(_text, _start, _pos - _start);
                        node = new ConstNode(_table, ValueType.Decimal, text);
                        break;
                    case Tokens.Float:
                        text = new string(_text, _start, _pos - _start);
                        node = new ConstNode(_table, ValueType.Float, text);
                        break;
                    case Tokens.StringConst:
                        text = new string(_text, _start + 1, _pos - _start - 2);
                        node = new ConstNode(_table, ValueType.Str, text);
                        break;
                    case Tokens.Date:
                        text = new string(_text, _start + 1, _pos - _start - 2);
                        node = new ConstNode(_table, ValueType.Date, text);
                        break;
                    }
                    NodePush(node);
                    continue;
                }
                case Tokens.LeftParen:
                {
                    num++;
                    ExpressionNode node;
                    if (_prevOperand == 0)
                    {
                        OperatorInfo operatorInfo = _ops[_topOperator - 1];
                        if (operatorInfo._type == Nodes.Binop && operatorInfo._op == 5)
                        {
                            node = new FunctionNode(_table, "In");
                            NodePush(node);
                            _ops[_topOperator++] = new OperatorInfo(Nodes.Call, 0, 2);
                        }
                        else
                        {
                            _ops[_topOperator++] = new OperatorInfo(Nodes.Paren, 0, 2);
                        }
                        continue;
                    }
                    BuildExpression(22);
                    _prevOperand = 0;
                    ExpressionNode expressionNode2 = NodePeek();
                    if (expressionNode2 == null || expressionNode2.GetType() != typeof(NameNode))
                    {
                        throw ExprException.SyntaxError();
                    }
                    NameNode nameNode2 = (NameNode)NodePop();
                    node = new FunctionNode(_table, nameNode2._name);
                    Aggregate aggregate = (Aggregate)((FunctionNode)node).Aggregate;
                    if (aggregate != Aggregate.None)
                    {
                        node = ParseAggregateArgument((FunctionId)aggregate);
                        NodePush(node);
                        _prevOperand = 2;
                    }
                    else
                    {
                        NodePush(node);
                        _ops[_topOperator++] = new OperatorInfo(Nodes.Call, 0, 2);
                    }
                    continue;
                }
                case Tokens.RightParen:
                {
                    if (_prevOperand != 0)
                    {
                        BuildExpression(3);
                    }
                    if (_topOperator <= 1)
                    {
                        throw ExprException.TooManyRightParentheses();
                    }
                    _topOperator--;
                    OperatorInfo operatorInfo = _ops[_topOperator];
                    if (_prevOperand == 0 && operatorInfo._type != Nodes.Call)
                    {
                        throw ExprException.MissingOperand(operatorInfo);
                    }
                    if (operatorInfo._type == Nodes.Call)
                    {
                        if (_prevOperand != 0)
                        {
                            ExpressionNode argument2 = NodePop();
                            FunctionNode functionNode2 = (FunctionNode)NodePop();
                            functionNode2.AddArgument(argument2);
                            functionNode2.Check();
                            NodePush(functionNode2);
                        }
                    }
                    else
                    {
                        ExpressionNode node = NodePop();
                        node = new UnaryNode(_table, 0, node);
                        NodePush(node);
                    }
                    _prevOperand = 2;
                    num--;
                    continue;
                }
                case Tokens.ListSeparator:
                {
                    if (_prevOperand == 0)
                    {
                        throw ExprException.MissingOperandBefore(",");
                    }
                    BuildExpression(3);
                    OperatorInfo operatorInfo = _ops[_topOperator - 1];
                    if (operatorInfo._type != Nodes.Call)
                    {
                        throw ExprException.SyntaxError();
                    }
                    ExpressionNode argument = NodePop();
                    FunctionNode functionNode = (FunctionNode)NodePop();
                    functionNode.AddArgument(argument);
                    NodePush(functionNode);
                    _prevOperand = 0;
                    continue;
                }
                case Tokens.BinaryOp:
                    if (_prevOperand == 0)
                    {
                        if (_op == 15)
                        {
                            _op = 2;
                        }
                        else
                        {
                            if (_op != 16)
                            {
                                throw ExprException.MissingOperandBefore(Operators.ToString(_op));
                            }
                            _op = 1;
                        }
                        goto case Tokens.UnaryOp;
                    }
                    _prevOperand = 0;
                    BuildExpression(Operators.Priority(_op));
                    _ops[_topOperator++] = new OperatorInfo(Nodes.Binop, _op, Operators.Priority(_op));
                    continue;
                case Tokens.UnaryOp:
                    _ops[_topOperator++] = new OperatorInfo(Nodes.Unop, _op, Operators.Priority(_op));
                    continue;
                case Tokens.ZeroOp:
                    if (_prevOperand != 0)
                    {
                        throw ExprException.MissingOperator(new string(_text, _start, _pos - _start));
                    }
                    _ops[_topOperator++] = new OperatorInfo(Nodes.Zop, _op, 24);
                    _prevOperand = 2;
                    continue;
                case Tokens.Dot:
                {
                    ExpressionNode expressionNode = NodePeek();
                    if (expressionNode != null && expressionNode.GetType() == typeof(NameNode))
                    {
                        Scan();
                        if (_token == Tokens.Name)
                        {
                            NameNode nameNode = (NameNode)NodePop();
                            string name = nameNode._name + "." + NameNode.ParseName(_text, _start, _pos);
                            NodePush(new NameNode(_table, name));
                            continue;
                        }
                    }
                    goto default;
                }
                default:
                    throw ExprException.UnknownToken(new string(_text, _start, _pos - _start), _start + 1);
                }
                break;
            }
            if (_prevOperand == 0)
            {
                if (_topNode != 0)
                {
                    OperatorInfo operatorInfo = _ops[_topOperator - 1];
                    throw ExprException.MissingOperand(operatorInfo);
                }
            }
            else
            {
                BuildExpression(3);
                if (_topOperator != 1)
                {
                    throw ExprException.MissingRightParen();
                }
            }
        }
        _expression = _nodeStack[0];
        return _expression;
    }