Наследование: ExpressionNode
        // 

        internal ExpressionNode Parse() {
            // free all nodes
            expression = null;

            StartScan();

            int cParens = 0;
            OperatorInfo opInfo;

            while (token != Tokens.EOS) {
                loop:
                Scan();

                switch (token) {
                    case Tokens.EOS:
                        // End of string: must be operand; force out expression;
                        // check for bomb; check nothing left on stack.

                        if (prevOperand == Empty) {
                            if (topNode == 0) {
                                // we have an empty expression
                                break;
                            }
                            // set error missing operator
                            // read the last operator info
                            opInfo = ops[topOperator - 1];

                            throw ExprException.MissingOperand(opInfo);
                        }
                        // collect all nodes
                        BuildExpression(Operators.priLow);
                        if (topOperator != 1) {
                            throw ExprException.MissingRightParen();
                        }
                        break;

                    case Tokens.Name:
                    case Tokens.Parent:
                    case Tokens.Numeric:
                    case Tokens.Decimal:
                    case Tokens.Float:
                    case Tokens.StringConst:
                    case Tokens.Date:
                        ExpressionNode node = null;
                        string str = null;

                        /* Constants and identifiers: create leaf node */

                        if (prevOperand != Empty) {
                            // set error missing operator
                            throw ExprException.MissingOperator(new string(text, start, pos - start));
                        }

                        if (topOperator > 0) {
                            // special check for IN without parentheses

                            opInfo = ops[topOperator-1];

                            if (opInfo.type == Nodes.Binop && opInfo.op == Operators.In && token != Tokens.Parent) {
                                throw ExprException.InWithoutParentheses();
                            }
                        }

                        prevOperand = Scalar;

                        switch (token) {
                            case Tokens.Parent:
                                string relname;
                                string colname;

                                // parsing Parent[(relation_name)].column_name)
                                try {
                                    // expecting an '(' or '.'
                                    Scan();
                                    if (token == Tokens.LeftParen) {
                                        //read the relation name
                                        ScanToken(Tokens.Name);
                                        relname = NameNode.ParseName(text, start, pos);
                                        ScanToken(Tokens.RightParen);
                                        ScanToken(Tokens.Dot);
                                    }
                                    else {
                                        relname = null;
                                        CheckToken(Tokens.Dot);
                                    }
                                }
                                catch (Exception e){
                                    // 
                                    if (!Common.ADP.IsCatchableExceptionType(e)) {
                                        throw;
                                    }
                                    throw ExprException.LookupArgument();
                                }

                                ScanToken(Tokens.Name);
                                colname = NameNode.ParseName(text, start, pos);

                                opInfo = ops[topOperator - 1];
                                node = new LookupNode(_table, colname, relname);

                                break;

                            case Tokens.Name:
                                /* Qualify name now for nice error checking */

                                opInfo = ops[topOperator - 1];

                                /* Create tree element -                */
                                // 
                                node = new NameNode(_table, text, start, pos);

                                break;

                            case Tokens.Numeric:
                                str = new string(text, start, pos - start);
                                node = new ConstNode(_table, ValueType.Numeric, str);
                                break;
                            case Tokens.Decimal:
                                str = new string(text, start, pos - start);
                                node = new ConstNode(_table, ValueType.Decimal, str);
                                break;
                            case Tokens.Float:
                                str = new string(text, start, pos - start);
                                node = new ConstNode(_table, ValueType.Float, str);
                                break;
                            case Tokens.StringConst:
                                Debug.Assert(text[start] == '\'' && text[pos-1] == '\'', "The expression contains an invalid string constant");
                                Debug.Assert(pos - start > 1, "The expression contains an invalid string constant");
                                // Store string without quotes..
                                str = new string(text, start+1, pos - start-2);
                                node = new ConstNode(_table, ValueType.Str, str);
                                break;
                            case Tokens.Date:
                                Debug.Assert(text[start] == '#' && text[pos-1] == '#', "The expression contains invalid date constant.");
                                Debug.Assert(pos - start > 2, "The expression contains invalid date constant '{0}'.");
                                // Store date without delimiters(#s)..
                                str = new string(text, start+1, pos - start-2);
                                node = new ConstNode(_table, ValueType.Date, str);
                                break;
                            default:
                                Debug.Assert(false, "unhandled token");
                                break;
                        }

                        NodePush(node);
                        goto loop;

                    case Tokens.LeftParen:
                        cParens++;
                        if (prevOperand == Empty) {
                            // Check for ( following IN/IFF. if not, we have a normal (.
                            // Peek: take a look at the operators stack

                            Debug.Assert(topOperator > 0, "Empty operator stack!!");
                            opInfo = ops[topOperator - 1];

                            if (opInfo.type == Nodes.Binop && opInfo.op == Operators.In) {
                                /* IN - handle as procedure call */

                                node = new FunctionNode(_table, "In");
                                NodePush(node);
                                /* Push operator decriptor */
                                ops[topOperator++] = new OperatorInfo(Nodes.Call, Operators.Noop, Operators.priParen);
                            }
                            else {  /* Normal ( */
                                /* Push operator decriptor */
                                ops[topOperator++] = new OperatorInfo(Nodes.Paren, Operators.Noop, Operators.priParen);
                            }
                        }
                        else {
                            // This is a procedure call or () qualification
                            // Force out any dot qualifiers; check for bomb

                            BuildExpression(Operators.priProc);
                            prevOperand = Empty;
                            ExpressionNode nodebefore = NodePeek();

                            if (nodebefore == null || nodebefore.GetType() != typeof(NameNode)) {
                                // this is more like an assert, so we not care about "nice" exception text..
                                //
                                throw ExprException.SyntaxError();
                            }

                            /* Get the proc name */
                            NameNode name = (NameNode)NodePop();

                            // Make sure that we can bind the name as a Function
                            // then get the argument count and types, and parse arguments..

                            node = new FunctionNode(_table, name.name);

                            // check to see if this is an aggregate function
                            Aggregate agg = (Aggregate)(int)((FunctionNode)node).Aggregate;
                            if (agg != Aggregate.None) {
                                node = ParseAggregateArgument((FunctionId)(int)agg);
                                NodePush(node);
                                prevOperand = Expr;
                                goto loop;
                            }

                            NodePush(node);
                            ops[topOperator++] = new OperatorInfo(Nodes.Call, Operators.Noop, Operators.priParen);
                        }
                        goto loop;

                    case Tokens.RightParen:
                        {
                            /* Right parentheses: Build expression if we have an operand. */
                            if (prevOperand != Empty) {
                                BuildExpression(Operators.priLow);
                            }

                            /* We must have Tokens.LeftParen on stack. If no operand, must be procedure call. */
                            if (topOperator <= 1) {
                                // set error, syntax: too many right parens..
                                throw ExprException.TooManyRightParentheses();
                            }

                            Debug.Assert(topOperator > 1, "melformed operator stack.");
                            topOperator--;
                            opInfo = ops[topOperator];

                            if (prevOperand == Empty && opInfo.type != Nodes.Call) {
                                // set error, syntax: missing operand.
                                throw ExprException.MissingOperand(opInfo);
                            }

                            Debug.Assert(opInfo.priority == Operators.priParen, "melformed operator stack.");

                            if (opInfo.type == Nodes.Call) {
                                /* add argument to the function call. */

                                if (prevOperand != Empty) {
                                    // read last function argument
                                    ExpressionNode argument = NodePop();

                                    /* Get the procedure name and append argument */
                                    Debug.Assert(topNode > 0 && NodePeek().GetType() == typeof(FunctionNode), "The function node should be created on '('");

                                    FunctionNode func = (FunctionNode)NodePop();
                                    func.AddArgument(argument);
                                    func.Check();
                                    NodePush(func);
                                }
                            }
                            else {
                                /* Normal parentheses: create tree node */
                                // Construct & Put the Nodes.Paren node on node stack
                                node = NodePop();
                                node = new UnaryNode(_table, Operators.Noop, node);
                                NodePush(node);
                            }

                            prevOperand = Expr;
                            cParens--;
                            goto loop;
                        }
                    case Tokens.ListSeparator:
                        {
                            /* Comma encountered: Must be operand; force out subexpression */

                            if (prevOperand == Empty) {
                                throw ExprException.MissingOperandBefore(",");
                            }

                            /* We are be in a procedure call */

                            /* build next argument */
                            BuildExpression(Operators.priLow);

                            opInfo = ops[topOperator - 1];

                            if (opInfo.type != Nodes.Call)
                                //
                                throw ExprException.SyntaxError();

                            ExpressionNode argument2 = NodePop();

                            /* Get the procedure name */

                            FunctionNode func = (FunctionNode)NodePop();

                            func.AddArgument(argument2);

                            NodePush(func);

                            prevOperand = Empty;

                            goto loop;
                        }
                    case Tokens.BinaryOp:
                        if (prevOperand == Empty) {
                            /* Check for unary plus/minus */
                            if (op == Operators.Plus) {
                                op = Operators.UnaryPlus;
                                // fall through to UnaryOperator;
                            }
                            else if (op  == Operators.Minus) {
                                /* Unary minus */
                                op = Operators.Negative;
                                // fall through to UnaryOperator;
                            }
                            else {
                                // Error missing operand:
                                throw ExprException.MissingOperandBefore(Operators.ToString(op));
                            }
                        }
                        else {
                            prevOperand = Empty;

                            /* CNSIDER: If we are going to support BETWEEN Translate AND to special BetweenAnd if it is. */

                            /* Force out to appropriate precedence; push operator. */

                            BuildExpression(Operators.Priority(op));

                            // PushOperator descriptor
                            ops[topOperator++] = new OperatorInfo(Nodes.Binop, op, Operators.Priority(op));
                            goto loop;
                        }
                        goto
                    case Tokens.UnaryOp; // fall through to UnaryOperator;

                    case Tokens.UnaryOp:
                        /* Must be no operand. Push it. */
                        ops[topOperator++] = new OperatorInfo(Nodes.Unop, op, Operators.Priority(op));
                        goto loop;

                    case Tokens.ZeroOp:
                        // check the we have operator on the stack
                        if (prevOperand != Empty) {
                            // set error missing operator
                            throw ExprException.MissingOperator(new string(text, start, pos - start));
                        }

                        // PushOperator descriptor
                        ops[topOperator++] = new OperatorInfo(Nodes.Zop, op, Operators.priMax);
                        prevOperand = Expr;
                        goto loop;

                    case Tokens.Dot:
                        //if there is a name on the stack append it.
                        ExpressionNode before = NodePeek();

                        if (before != null && before.GetType() == typeof(NameNode)) {
                            Scan();

                            if (token == Tokens.Name) {
                                NameNode nameBefore = (NameNode)NodePop();
                                //Debug.WriteLine("Before name '" + nameBefore.name + "'");
                                string newName = nameBefore.name + "." + NameNode.ParseName(text, start, pos);
                                //Debug.WriteLine("Create new NameNode " + newName);
                                NodePush(new NameNode(_table, newName));
                                goto loop;
                            }
                        }
                        // fall through to default
                        goto default;
                    default:
                        throw ExprException.UnknownToken(new string(text, start, pos - start), start+1);
                }
            }
            goto end_loop;
            end_loop:
            Debug.Assert(topNode == 1 || topNode == 0, "Invalid Node Stack");
            expression = NodeStack[0];

            return expression;
        }
Пример #2
0
        // CONSIDER: configure the scanner : local info

        internal ExpressionNode Parse()
        {
            // free all nodes
            _expression = null;

            StartScan();

            int          cParens = 0;
            OperatorInfo opInfo;

            while (_token != Tokens.EOS)
            {
loop:
                Scan();

                switch (_token)
                {
                case Tokens.EOS:
                    // End of string: must be operand; force out expression;
                    // check for bomb; check nothing left on stack.

                    if (_prevOperand == Empty)
                    {
                        if (_topNode == 0)
                        {
                            // we have an empty expression
                            break;
                        }
                        // set error missing operator
                        // read the last operator info
                        opInfo = _ops[_topOperator - 1];

                        throw ExprException.MissingOperand(opInfo);
                    }
                    // collect all nodes
                    BuildExpression(Operators.priLow);
                    if (_topOperator != 1)
                    {
                        throw ExprException.MissingRightParen();
                    }
                    break;

                case Tokens.Name:
                case Tokens.Parent:
                case Tokens.Numeric:
                case Tokens.Decimal:
                case Tokens.Float:
                case Tokens.StringConst:
                case Tokens.Date:
                    ExpressionNode node = null;
                    string         str  = null;

                    /* Constants and identifiers: create leaf node */

                    if (_prevOperand != Empty)
                    {
                        // set error missing operator
                        throw ExprException.MissingOperator(new string(_text, _start, _pos - _start));
                    }

                    if (_topOperator > 0)
                    {
                        // special check for IN without parentheses

                        opInfo = _ops[_topOperator - 1];

                        if (opInfo._type == Nodes.Binop && opInfo._op == Operators.In && _token != Tokens.Parent)
                        {
                            throw ExprException.InWithoutParentheses();
                        }
                    }

                    _prevOperand = Scalar;

                    switch (_token)
                    {
                    case Tokens.Parent:
                        string relname;
                        string colname;

                        // parsing Parent[(relation_name)].column_name)
                        try
                        {
                            // expecting an '(' or '.'
                            Scan();
                            if (_token == Tokens.LeftParen)
                            {
                                //read the relation name
                                ScanToken(Tokens.Name);
                                relname = NameNode.ParseName(_text, _start, _pos);
                                ScanToken(Tokens.RightParen);
                                ScanToken(Tokens.Dot);
                            }
                            else
                            {
                                relname = null;
                                CheckToken(Tokens.Dot);
                            }
                        }
                        catch (Exception e) when(Common.ADP.IsCatchableExceptionType(e))
                        {
                            throw ExprException.LookupArgument();
                        }

                        ScanToken(Tokens.Name);
                        colname = NameNode.ParseName(_text, _start, _pos);

                        opInfo = _ops[_topOperator - 1];
                        node   = new LookupNode(_table, colname, relname);

                        break;

                    case Tokens.Name:
                        /* Qualify name now for nice error checking */

                        opInfo = _ops[_topOperator - 1];

                        /* Create tree element -                */
                        // CONSIDER: Check for reserved proc names here
                        node = new NameNode(_table, _text, _start, _pos);

                        break;

                    case Tokens.Numeric:
                        str  = new string(_text, _start, _pos - _start);
                        node = new ConstNode(_table, ValueType.Numeric, str);
                        break;

                    case Tokens.Decimal:
                        str  = new string(_text, _start, _pos - _start);
                        node = new ConstNode(_table, ValueType.Decimal, str);
                        break;

                    case Tokens.Float:
                        str  = new string(_text, _start, _pos - _start);
                        node = new ConstNode(_table, ValueType.Float, str);
                        break;

                    case Tokens.StringConst:
                        Debug.Assert(_text[_start] == '\'' && _text[_pos - 1] == '\'', "The expression contains an invalid string constant");
                        Debug.Assert(_pos - _start > 1, "The expression contains an invalid string constant");
                        // Store string without quotes..
                        str  = new string(_text, _start + 1, _pos - _start - 2);
                        node = new ConstNode(_table, ValueType.Str, str);
                        break;

                    case Tokens.Date:
                        Debug.Assert(_text[_start] == '#' && _text[_pos - 1] == '#', "The expression contains invalid date constant.");
                        Debug.Assert(_pos - _start > 2, "The expression contains invalid date constant '{0}'.");
                        // Store date without delimiters(#s)..
                        str  = new string(_text, _start + 1, _pos - _start - 2);
                        node = new ConstNode(_table, ValueType.Date, str);
                        break;

                    default:
                        Debug.Fail("unhandled token");
                        break;
                    }

                    NodePush(node);
                    goto loop;

                case Tokens.LeftParen:
                    cParens++;
                    if (_prevOperand == Empty)
                    {
                        // Check for ( following IN/IFF. if not, we have a normal (.
                        // Peek: take a look at the operators stack

                        Debug.Assert(_topOperator > 0, "Empty operator stack!!");
                        opInfo = _ops[_topOperator - 1];

                        if (opInfo._type == Nodes.Binop && opInfo._op == Operators.In)
                        {
                            /* IN - handle as procedure call */

                            node = new FunctionNode(_table, "In");
                            NodePush(node);
                            /* Push operator decriptor */
                            _ops[_topOperator++] = new OperatorInfo(Nodes.Call, Operators.Noop, Operators.priParen);
                        }
                        else
                        {      /* Normal ( */
                            /* Push operator decriptor */
                            _ops[_topOperator++] = new OperatorInfo(Nodes.Paren, Operators.Noop, Operators.priParen);
                        }
                    }
                    else
                    {
                        // This is a procedure call or () qualification
                        // Force out any dot qualifiers; check for bomb

                        BuildExpression(Operators.priProc);
                        _prevOperand = Empty;
                        ExpressionNode nodebefore = NodePeek();

                        if (nodebefore == null || nodebefore.GetType() != typeof(NameNode))
                        {
                            // this is more like an assert, so we not care about "nice" exception text..
                            throw ExprException.SyntaxError();
                        }

                        /* Get the proc name */
                        NameNode name = (NameNode)NodePop();

                        // Make sure that we can bind the name as a Function
                        // then get the argument count and types, and parse arguments..

                        node = new FunctionNode(_table, name._name);

                        // check to see if this is an aggregate function
                        Aggregate agg = (Aggregate)(int)((FunctionNode)node).Aggregate;
                        if (agg != Aggregate.None)
                        {
                            node = ParseAggregateArgument((FunctionId)(int)agg);
                            NodePush(node);
                            _prevOperand = Expr;
                            goto loop;
                        }

                        NodePush(node);
                        _ops[_topOperator++] = new OperatorInfo(Nodes.Call, Operators.Noop, Operators.priParen);
                    }
                    goto loop;

                case Tokens.RightParen:
                {
                    /* Right parentheses: Build expression if we have an operand. */
                    if (_prevOperand != Empty)
                    {
                        BuildExpression(Operators.priLow);
                    }

                    /* We must have Tokens.LeftParen on stack. If no operand, must be procedure call. */
                    if (_topOperator <= 1)
                    {
                        // set error, syntax: too many right parens..
                        throw ExprException.TooManyRightParentheses();
                    }

                    Debug.Assert(_topOperator > 1, "melformed operator stack.");
                    _topOperator--;
                    opInfo = _ops[_topOperator];

                    if (_prevOperand == Empty && opInfo._type != Nodes.Call)
                    {
                        // set error, syntax: missing operand.
                        throw ExprException.MissingOperand(opInfo);
                    }

                    Debug.Assert(opInfo._priority == Operators.priParen, "melformed operator stack.");

                    if (opInfo._type == Nodes.Call)
                    {
                        /* add argument to the function call. */

                        if (_prevOperand != Empty)
                        {
                            // read last function argument
                            ExpressionNode argument = NodePop();

                            /* Get the procedure name and append argument */
                            Debug.Assert(_topNode > 0 && NodePeek().GetType() == typeof(FunctionNode), "The function node should be created on '('");

                            FunctionNode func = (FunctionNode)NodePop();
                            func.AddArgument(argument);
                            func.Check();
                            NodePush(func);
                        }
                    }
                    else
                    {
                        /* Normal parentheses: create tree node */
                        // Construct & Put the Nodes.Paren node on node stack
                        node = NodePop();
                        node = new UnaryNode(_table, Operators.Noop, node);
                        NodePush(node);
                    }

                    _prevOperand = Expr;
                    cParens--;
                    goto loop;
                }

                case Tokens.ListSeparator:
                {
                    /* Comma encountered: Must be operand; force out subexpression */

                    if (_prevOperand == Empty)
                    {
                        throw ExprException.MissingOperandBefore(",");
                    }

                    /* We are be in a procedure call */

                    /* build next argument */
                    BuildExpression(Operators.priLow);

                    opInfo = _ops[_topOperator - 1];

                    if (opInfo._type != Nodes.Call)
                    {
                        throw ExprException.SyntaxError();
                    }

                    ExpressionNode argument2 = NodePop();

                    /* Get the procedure name */

                    FunctionNode func = (FunctionNode)NodePop();

                    func.AddArgument(argument2);

                    NodePush(func);

                    _prevOperand = Empty;

                    goto loop;
                }

                case Tokens.BinaryOp:
                    if (_prevOperand == Empty)
                    {
                        /* Check for unary plus/minus */
                        if (_op == Operators.Plus)
                        {
                            _op = Operators.UnaryPlus;
                            // fall through to UnaryOperator;
                        }
                        else if (_op == Operators.Minus)
                        {
                            /* Unary minus */
                            _op = Operators.Negative;
                            // fall through to UnaryOperator;
                        }
                        else
                        {
                            // Error missing operand:
                            throw ExprException.MissingOperandBefore(Operators.ToString(_op));
                        }
                    }
                    else
                    {
                        _prevOperand = Empty;

                        /* CNSIDER: If we are going to support BETWEEN Translate AND to special BetweenAnd if it is. */

                        /* Force out to appropriate precedence; push operator. */

                        BuildExpression(Operators.Priority(_op));

                        // PushOperator descriptor
                        _ops[_topOperator++] = new OperatorInfo(Nodes.Binop, _op, Operators.Priority(_op));
                        goto loop;
                    }

                    goto
                case Tokens.UnaryOp;     // fall through to UnaryOperator;

                case Tokens.UnaryOp:
                    /* Must be no operand. Push it. */
                    _ops[_topOperator++] = new OperatorInfo(Nodes.Unop, _op, Operators.Priority(_op));
                    goto loop;

                case Tokens.ZeroOp:
                    // check the we have operator on the stack
                    if (_prevOperand != Empty)
                    {
                        // set error missing operator
                        throw ExprException.MissingOperator(new string(_text, _start, _pos - _start));
                    }

                    // PushOperator descriptor
                    _ops[_topOperator++] = new OperatorInfo(Nodes.Zop, _op, Operators.priMax);
                    _prevOperand         = Expr;
                    goto loop;

                case Tokens.Dot:
                    //if there is a name on the stack append it.
                    ExpressionNode before = NodePeek();

                    if (before != null && before.GetType() == typeof(NameNode))
                    {
                        Scan();

                        if (_token == Tokens.Name)
                        {
                            NameNode nameBefore = (NameNode)NodePop();
                            string   newName    = nameBefore._name + "." + NameNode.ParseName(_text, _start, _pos);
                            NodePush(new NameNode(_table, newName));
                            goto loop;
                        }
                    }
                    // fall through to default
                    goto default;

                default:
                    throw ExprException.UnknownToken(new string(_text, _start, _pos - _start), _start + 1);
                }
            }
            goto end_loop;
end_loop:
            Debug.Assert(_topNode == 1 || _topNode == 0, "Invalid Node Stack");
            _expression = _nodeStack[0];

            return(_expression);
        }
Пример #3
0
        private int Eval(BinaryNode expr, DataRow row, DataRowVersion version)
        {
            if (expr._op == Operators.And)
            {
                int lResult = Eval((BinaryNode)expr._left, row, version);
                if (lResult != 0)
                {
                    return(lResult);
                }
                int rResult = Eval((BinaryNode)expr._right, row, version);
                if (rResult != 0)
                {
                    return(rResult);
                }
                return(0);
            }

            long   c     = 0;
            object vLeft = expr._left.Eval(row, version);

            if (expr._op != Operators.Is && expr._op != Operators.IsNot)
            {
                object vRight   = expr._right.Eval(row, version);
                bool   isLConst = (expr._left is ConstNode);
                bool   isRConst = (expr._right is ConstNode);

                if ((vLeft == DBNull.Value) || (expr._left.IsSqlColumn && DataStorage.IsObjectSqlNull(vLeft)))
                {
                    return(-1);
                }
                if ((vRight == DBNull.Value) || (expr._right.IsSqlColumn && DataStorage.IsObjectSqlNull(vRight)))
                {
                    return(1);
                }

                StorageType leftType = DataStorage.GetStorageType(vLeft.GetType());
                if (StorageType.Char == leftType)
                {
                    if ((isRConst) || (!expr._right.IsSqlColumn))
                    {
                        vRight = Convert.ToChar(vRight, _table.FormatProvider);
                    }
                    else
                    {
                        vRight = SqlConvert.ChangeType2(vRight, StorageType.Char, typeof(char), _table.FormatProvider);
                    }
                }

                StorageType rightType = DataStorage.GetStorageType(vRight.GetType());
                StorageType resultType;
                if (expr._left.IsSqlColumn || expr._right.IsSqlColumn)
                {
                    resultType = expr.ResultSqlType(leftType, rightType, isLConst, isRConst, expr._op);
                }
                else
                {
                    resultType = expr.ResultType(leftType, rightType, isLConst, isRConst, expr._op);
                }
                if (StorageType.Empty == resultType)
                {
                    expr.SetTypeMismatchError(expr._op, vLeft.GetType(), vRight.GetType());
                }

                // if comparing a Guid column value against a string literal
                // use InvariantCulture instead of DataTable.Locale because in the Danish related cultures
                // sorting a Guid as a string has different results than in Invariant and English related cultures.
                // This fix is restricted to DataTable.Select("GuidColumn = 'string literal'") types of queries
                NameNode namedNode = null;
                System.Globalization.CompareInfo comparer =
                    ((isLConst && !isRConst && (leftType == StorageType.String) && (rightType == StorageType.Guid) && (null != (namedNode = expr._right as NameNode)) && (namedNode._column.DataType == typeof(Guid))) ||
                     (isRConst && !isLConst && (rightType == StorageType.String) && (leftType == StorageType.Guid) && (null != (namedNode = expr._left as NameNode)) && (namedNode._column.DataType == typeof(Guid))))
                     ? System.Globalization.CultureInfo.InvariantCulture.CompareInfo : null;

                c = expr.BinaryCompare(vLeft, vRight, resultType, expr._op, comparer);
            }
            switch (expr._op)
            {
            case Operators.EqualTo: c = (c == 0 ? 0 : c < 0 ? -1 : 1); break;

            case Operators.GreaterThen: c = (c > 0 ? 0 : -1); break;

            case Operators.LessThen: c = (c < 0 ? 0 : 1); break;

            case Operators.GreaterOrEqual: c = (c >= 0 ? 0 : -1); break;

            case Operators.LessOrEqual: c = (c <= 0 ? 0 : 1); break;

            case Operators.Is: c = (vLeft == DBNull.Value ? 0 : -1); break;

            case Operators.IsNot: c = (vLeft != DBNull.Value ? 0 : 1); break;

            default: Debug.Assert(true, "Unsupported Binary Search Operator!"); break;
            }
            return((int)c);
        }
Пример #4
0
        internal ExpressionNode Parse()
        {
            ExpressionNode node;
            OperatorInfo   info;

            this.expression = null;
            this.StartScan();
            int num = 0;

            goto Label_078F;
Label_0014:
            this.Scan();
            switch (this.token)
            {
            case Tokens.Name:
            case Tokens.Numeric:
            case Tokens.Decimal:
            case Tokens.Float:
            case Tokens.StringConst:
            case Tokens.Date:
            case Tokens.Parent:
            {
                node = null;
                string constant = null;
                if (this.prevOperand != 0)
                {
                    throw ExprException.MissingOperator(new string(this.text, this.start, this.pos - this.start));
                }
                if (this.topOperator > 0)
                {
                    info = this.ops[this.topOperator - 1];
                    if (((info.type == Nodes.Binop) && (info.op == 5)) && (this.token != Tokens.Parent))
                    {
                        throw ExprException.InWithoutParentheses();
                    }
                }
                this.prevOperand = 1;
                switch (this.token)
                {
                case Tokens.Name:
                    info = this.ops[this.topOperator - 1];
                    node = new NameNode(this._table, this.text, this.start, this.pos);
                    goto Label_0338;

                case Tokens.Numeric:
                    constant = new string(this.text, this.start, this.pos - this.start);
                    node     = new ConstNode(this._table, System.Data.ValueType.Numeric, constant);
                    goto Label_0338;

                case Tokens.Decimal:
                    constant = new string(this.text, this.start, this.pos - this.start);
                    node     = new ConstNode(this._table, System.Data.ValueType.Decimal, constant);
                    goto Label_0338;

                case Tokens.Float:
                    constant = new string(this.text, this.start, this.pos - this.start);
                    node     = new ConstNode(this._table, System.Data.ValueType.Float, constant);
                    goto Label_0338;

                case Tokens.StringConst:
                    constant = new string(this.text, this.start + 1, (this.pos - this.start) - 2);
                    node     = new ConstNode(this._table, System.Data.ValueType.Str, constant);
                    goto Label_0338;

                case Tokens.Date:
                    constant = new string(this.text, this.start + 1, (this.pos - this.start) - 2);
                    node     = new ConstNode(this._table, System.Data.ValueType.Date, constant);
                    goto Label_0338;

                case Tokens.Parent:
                {
                    string str2;
                    try
                    {
                        this.Scan();
                        if (this.token == Tokens.LeftParen)
                        {
                            this.ScanToken(Tokens.Name);
                            str2 = NameNode.ParseName(this.text, this.start, this.pos);
                            this.ScanToken(Tokens.RightParen);
                            this.ScanToken(Tokens.Dot);
                        }
                        else
                        {
                            str2 = null;
                            this.CheckToken(Tokens.Dot);
                        }
                    }
                    catch (Exception exception)
                    {
                        if (!ADP.IsCatchableExceptionType(exception))
                        {
                            throw;
                        }
                        throw ExprException.LookupArgument();
                    }
                    this.ScanToken(Tokens.Name);
                    string columnName = NameNode.ParseName(this.text, this.start, this.pos);
                    info = this.ops[this.topOperator - 1];
                    node = new LookupNode(this._table, columnName, str2);
                    goto Label_0338;
                }
                }
                break;
            }

            case Tokens.ListSeparator:
            {
                if (this.prevOperand == 0)
                {
                    throw ExprException.MissingOperandBefore(",");
                }
                this.BuildExpression(3);
                info = this.ops[this.topOperator - 1];
                if (info.type != Nodes.Call)
                {
                    throw ExprException.SyntaxError();
                }
                ExpressionNode argument = this.NodePop();
                FunctionNode   node4    = (FunctionNode)this.NodePop();
                node4.AddArgument(argument);
                this.NodePush(node4);
                this.prevOperand = 0;
                goto Label_0014;
            }

            case Tokens.LeftParen:
                num++;
                if (this.prevOperand != 0)
                {
                    this.BuildExpression(0x16);
                    this.prevOperand = 0;
                    ExpressionNode node5 = this.NodePeek();
                    if ((node5 == null) || (node5.GetType() != typeof(NameNode)))
                    {
                        throw ExprException.SyntaxError();
                    }
                    NameNode node9 = (NameNode)this.NodePop();
                    node = new FunctionNode(this._table, node9.name);
                    Aggregate aggregate = (Aggregate)((FunctionNode)node).Aggregate;
                    if (aggregate != Aggregate.None)
                    {
                        node = this.ParseAggregateArgument((FunctionId)aggregate);
                        this.NodePush(node);
                        this.prevOperand = 2;
                    }
                    else
                    {
                        this.NodePush(node);
                        this.ops[this.topOperator++] = new OperatorInfo(Nodes.Call, 0, 2);
                    }
                }
                else
                {
                    info = this.ops[this.topOperator - 1];
                    if ((info.type != Nodes.Binop) || (info.op != 5))
                    {
                        this.ops[this.topOperator++] = new OperatorInfo(Nodes.Paren, 0, 2);
                    }
                    else
                    {
                        node = new FunctionNode(this._table, "In");
                        this.NodePush(node);
                        this.ops[this.topOperator++] = new OperatorInfo(Nodes.Call, 0, 2);
                    }
                }
                goto Label_0014;

            case Tokens.RightParen:
                if (this.prevOperand != 0)
                {
                    this.BuildExpression(3);
                }
                if (this.topOperator <= 1)
                {
                    throw ExprException.TooManyRightParentheses();
                }
                this.topOperator--;
                info = this.ops[this.topOperator];
                if ((this.prevOperand == 0) && (info.type != Nodes.Call))
                {
                    throw ExprException.MissingOperand(info);
                }
                if (info.type == Nodes.Call)
                {
                    if (this.prevOperand != 0)
                    {
                        ExpressionNode node8 = this.NodePop();
                        FunctionNode   node2 = (FunctionNode)this.NodePop();
                        node2.AddArgument(node8);
                        node2.Check();
                        this.NodePush(node2);
                    }
                }
                else
                {
                    node = this.NodePop();
                    node = new UnaryNode(this._table, 0, node);
                    this.NodePush(node);
                }
                this.prevOperand = 2;
                num--;
                goto Label_0014;

            case Tokens.ZeroOp:
                if (this.prevOperand != 0)
                {
                    throw ExprException.MissingOperator(new string(this.text, this.start, this.pos - this.start));
                }
                this.ops[this.topOperator++] = new OperatorInfo(Nodes.Zop, this.op, 0x18);
                this.prevOperand             = 2;
                goto Label_0014;

            case Tokens.UnaryOp:
                goto Label_0647;

            case Tokens.BinaryOp:
                if (this.prevOperand != 0)
                {
                    this.prevOperand = 0;
                    this.BuildExpression(Operators.Priority(this.op));
                    this.ops[this.topOperator++] = new OperatorInfo(Nodes.Binop, this.op, Operators.Priority(this.op));
                    goto Label_0014;
                }
                if (this.op != 15)
                {
                    if (this.op != 0x10)
                    {
                        throw ExprException.MissingOperandBefore(Operators.ToString(this.op));
                    }
                    this.op = 1;
                }
                else
                {
                    this.op = 2;
                }
                goto Label_0647;

            case Tokens.Dot:
            {
                ExpressionNode node3 = this.NodePeek();
                if ((node3 == null) || !(node3.GetType() == typeof(NameNode)))
                {
                    goto Label_0763;
                }
                this.Scan();
                if (this.token != Tokens.Name)
                {
                    goto Label_0763;
                }
                NameNode node6 = (NameNode)this.NodePop();
                string   name  = node6.name + "." + NameNode.ParseName(this.text, this.start, this.pos);
                this.NodePush(new NameNode(this._table, name));
                goto Label_0014;
            }

            case Tokens.EOS:
                if (this.prevOperand != 0)
                {
                    this.BuildExpression(3);
                    if (this.topOperator != 1)
                    {
                        throw ExprException.MissingRightParen();
                    }
                }
                else if (this.topNode != 0)
                {
                    info = this.ops[this.topOperator - 1];
                    throw ExprException.MissingOperand(info);
                }
                goto Label_078F;

            default:
                goto Label_0763;
            }
Label_0338:
            this.NodePush(node);
            goto Label_0014;
Label_0647:
            this.ops[this.topOperator++] = new OperatorInfo(Nodes.Unop, this.op, Operators.Priority(this.op));
            goto Label_0014;
Label_0763:
            throw ExprException.UnknownToken(new string(this.text, this.start, this.pos - this.start), this.start + 1);
Label_078F:
            if (this.token != Tokens.EOS)
            {
                goto Label_0014;
            }
            this.expression = this.NodeStack[0];
            return(this.expression);
        }
        internal ExpressionNode Parse()
        {
            ExpressionNode node;
            OperatorInfo info;
            this.expression = null;
            this.StartScan();
            int num = 0;
            goto Label_078F;
        Label_0014:
            this.Scan();
            switch (this.token)
            {
                case Tokens.Name:
                case Tokens.Numeric:
                case Tokens.Decimal:
                case Tokens.Float:
                case Tokens.StringConst:
                case Tokens.Date:
                case Tokens.Parent:
                {
                    node = null;
                    string constant = null;
                    if (this.prevOperand != 0)
                    {
                        throw ExprException.MissingOperator(new string(this.text, this.start, this.pos - this.start));
                    }
                    if (this.topOperator > 0)
                    {
                        info = this.ops[this.topOperator - 1];
                        if (((info.type == Nodes.Binop) && (info.op == 5)) && (this.token != Tokens.Parent))
                        {
                            throw ExprException.InWithoutParentheses();
                        }
                    }
                    this.prevOperand = 1;
                    switch (this.token)
                    {
                        case Tokens.Name:
                            info = this.ops[this.topOperator - 1];
                            node = new NameNode(this._table, this.text, this.start, this.pos);
                            goto Label_0338;

                        case Tokens.Numeric:
                            constant = new string(this.text, this.start, this.pos - this.start);
                            node = new ConstNode(this._table, System.Data.ValueType.Numeric, constant);
                            goto Label_0338;

                        case Tokens.Decimal:
                            constant = new string(this.text, this.start, this.pos - this.start);
                            node = new ConstNode(this._table, System.Data.ValueType.Decimal, constant);
                            goto Label_0338;

                        case Tokens.Float:
                            constant = new string(this.text, this.start, this.pos - this.start);
                            node = new ConstNode(this._table, System.Data.ValueType.Float, constant);
                            goto Label_0338;

                        case Tokens.StringConst:
                            constant = new string(this.text, this.start + 1, (this.pos - this.start) - 2);
                            node = new ConstNode(this._table, System.Data.ValueType.Str, constant);
                            goto Label_0338;

                        case Tokens.Date:
                            constant = new string(this.text, this.start + 1, (this.pos - this.start) - 2);
                            node = new ConstNode(this._table, System.Data.ValueType.Date, constant);
                            goto Label_0338;

                        case Tokens.Parent:
                        {
                            string str2;
                            try
                            {
                                this.Scan();
                                if (this.token == Tokens.LeftParen)
                                {
                                    this.ScanToken(Tokens.Name);
                                    str2 = NameNode.ParseName(this.text, this.start, this.pos);
                                    this.ScanToken(Tokens.RightParen);
                                    this.ScanToken(Tokens.Dot);
                                }
                                else
                                {
                                    str2 = null;
                                    this.CheckToken(Tokens.Dot);
                                }
                            }
                            catch (Exception exception)
                            {
                                if (!ADP.IsCatchableExceptionType(exception))
                                {
                                    throw;
                                }
                                throw ExprException.LookupArgument();
                            }
                            this.ScanToken(Tokens.Name);
                            string columnName = NameNode.ParseName(this.text, this.start, this.pos);
                            info = this.ops[this.topOperator - 1];
                            node = new LookupNode(this._table, columnName, str2);
                            goto Label_0338;
                        }
                    }
                    break;
                }
                case Tokens.ListSeparator:
                {
                    if (this.prevOperand == 0)
                    {
                        throw ExprException.MissingOperandBefore(",");
                    }
                    this.BuildExpression(3);
                    info = this.ops[this.topOperator - 1];
                    if (info.type != Nodes.Call)
                    {
                        throw ExprException.SyntaxError();
                    }
                    ExpressionNode argument = this.NodePop();
                    FunctionNode node4 = (FunctionNode) this.NodePop();
                    node4.AddArgument(argument);
                    this.NodePush(node4);
                    this.prevOperand = 0;
                    goto Label_0014;
                }
                case Tokens.LeftParen:
                    num++;
                    if (this.prevOperand != 0)
                    {
                        this.BuildExpression(0x16);
                        this.prevOperand = 0;
                        ExpressionNode node5 = this.NodePeek();
                        if ((node5 == null) || (node5.GetType() != typeof(NameNode)))
                        {
                            throw ExprException.SyntaxError();
                        }
                        NameNode node9 = (NameNode) this.NodePop();
                        node = new FunctionNode(this._table, node9.name);
                        Aggregate aggregate = (Aggregate) ((FunctionNode) node).Aggregate;
                        if (aggregate != Aggregate.None)
                        {
                            node = this.ParseAggregateArgument((FunctionId) aggregate);
                            this.NodePush(node);
                            this.prevOperand = 2;
                        }
                        else
                        {
                            this.NodePush(node);
                            this.ops[this.topOperator++] = new OperatorInfo(Nodes.Call, 0, 2);
                        }
                    }
                    else
                    {
                        info = this.ops[this.topOperator - 1];
                        if ((info.type != Nodes.Binop) || (info.op != 5))
                        {
                            this.ops[this.topOperator++] = new OperatorInfo(Nodes.Paren, 0, 2);
                        }
                        else
                        {
                            node = new FunctionNode(this._table, "In");
                            this.NodePush(node);
                            this.ops[this.topOperator++] = new OperatorInfo(Nodes.Call, 0, 2);
                        }
                    }
                    goto Label_0014;

                case Tokens.RightParen:
                    if (this.prevOperand != 0)
                    {
                        this.BuildExpression(3);
                    }
                    if (this.topOperator <= 1)
                    {
                        throw ExprException.TooManyRightParentheses();
                    }
                    this.topOperator--;
                    info = this.ops[this.topOperator];
                    if ((this.prevOperand == 0) && (info.type != Nodes.Call))
                    {
                        throw ExprException.MissingOperand(info);
                    }
                    if (info.type == Nodes.Call)
                    {
                        if (this.prevOperand != 0)
                        {
                            ExpressionNode node8 = this.NodePop();
                            FunctionNode node2 = (FunctionNode) this.NodePop();
                            node2.AddArgument(node8);
                            node2.Check();
                            this.NodePush(node2);
                        }
                    }
                    else
                    {
                        node = this.NodePop();
                        node = new UnaryNode(this._table, 0, node);
                        this.NodePush(node);
                    }
                    this.prevOperand = 2;
                    num--;
                    goto Label_0014;

                case Tokens.ZeroOp:
                    if (this.prevOperand != 0)
                    {
                        throw ExprException.MissingOperator(new string(this.text, this.start, this.pos - this.start));
                    }
                    this.ops[this.topOperator++] = new OperatorInfo(Nodes.Zop, this.op, 0x18);
                    this.prevOperand = 2;
                    goto Label_0014;

                case Tokens.UnaryOp:
                    goto Label_0647;

                case Tokens.BinaryOp:
                    if (this.prevOperand != 0)
                    {
                        this.prevOperand = 0;
                        this.BuildExpression(Operators.Priority(this.op));
                        this.ops[this.topOperator++] = new OperatorInfo(Nodes.Binop, this.op, Operators.Priority(this.op));
                        goto Label_0014;
                    }
                    if (this.op != 15)
                    {
                        if (this.op != 0x10)
                        {
                            throw ExprException.MissingOperandBefore(Operators.ToString(this.op));
                        }
                        this.op = 1;
                    }
                    else
                    {
                        this.op = 2;
                    }
                    goto Label_0647;

                case Tokens.Dot:
                {
                    ExpressionNode node3 = this.NodePeek();
                    if ((node3 == null) || !(node3.GetType() == typeof(NameNode)))
                    {
                        goto Label_0763;
                    }
                    this.Scan();
                    if (this.token != Tokens.Name)
                    {
                        goto Label_0763;
                    }
                    NameNode node6 = (NameNode) this.NodePop();
                    string name = node6.name + "." + NameNode.ParseName(this.text, this.start, this.pos);
                    this.NodePush(new NameNode(this._table, name));
                    goto Label_0014;
                }
                case Tokens.EOS:
                    if (this.prevOperand != 0)
                    {
                        this.BuildExpression(3);
                        if (this.topOperator != 1)
                        {
                            throw ExprException.MissingRightParen();
                        }
                    }
                    else if (this.topNode != 0)
                    {
                        info = this.ops[this.topOperator - 1];
                        throw ExprException.MissingOperand(info);
                    }
                    goto Label_078F;

                default:
                    goto Label_0763;
            }
        Label_0338:
            this.NodePush(node);
            goto Label_0014;
        Label_0647:
            this.ops[this.topOperator++] = new OperatorInfo(Nodes.Unop, this.op, Operators.Priority(this.op));
            goto Label_0014;
        Label_0763:
            throw ExprException.UnknownToken(new string(this.text, this.start, this.pos - this.start), this.start + 1);
        Label_078F:
            if (this.token != Tokens.EOS)
            {
                goto Label_0014;
            }
            this.expression = this.NodeStack[0];
            return this.expression;
        }