Inheritance: ExpressionNode
        /// <devdoc>
        ///     Builds expression tree for higher-precedence operator to be used as left
        ///     operand of current operator. May cause errors - always do ErrorCheck() upin return.
        /// </devdoc>

        private void BuildExpression(int pri) {
            ExpressionNode expr = null;

            Debug.Assert(pri > Operators.priStart && pri <= Operators.priMax, "Invalid priority value");

            /* For all operators of higher or same precedence (we are always
            left-associative) */
            while (true) {
                Debug.Assert(topOperator > 0, "Empty operator stack!!");
                OperatorInfo opInfo = ops[topOperator - 1];

                if (opInfo.priority < pri)
                    goto end_loop;

                Debug.Assert(opInfo.priority >= pri, "Invalid prioriry value");
                topOperator--;

                ExpressionNode nodeLeft;
                ExpressionNode nodeRight;
                switch (opInfo.type) {
                    case Nodes.Binop: {
                            // get right, left operands. Bind them.

                            nodeRight = NodePop();
                            nodeLeft = NodePop();

                            /* This is the place to do type and other checks */

                            switch (opInfo.op) {
                                case Operators.Between:
                                case Operators.BetweenAnd:
                                case Operators.BitwiseAnd:
                                case Operators.BitwiseOr:
                                case Operators.BitwiseXor:
                                case Operators.BitwiseNot:
                                    throw ExprException.UnsupportedOperator(opInfo.op);

                                case Operators.Is: // 
                                case Operators.Or:
                                case Operators.And:
                                case Operators.EqualTo:
                                case Operators.NotEqual:
                                case Operators.Like:
                                case Operators.LessThen:
                                case Operators.LessOrEqual:
                                case Operators.GreaterThen:
                                case Operators.GreaterOrEqual:
                                case Operators.In:
                                    break;

                                default:
                                    Debug.Assert(opInfo.op == Operators.Plus ||
                                                 opInfo.op == Operators.Minus ||
                                                 opInfo.op == Operators.Multiply ||
                                                 opInfo.op == Operators.Divide ||
                                                 opInfo.op == Operators.Modulo,
                                                 "Invalud Binary operation");

                                    break;
                            }
                            Debug.Assert(nodeLeft != null, "Invalid left operand");
                            Debug.Assert(nodeRight != null, "Invalid right operand");

                            if (opInfo.op == Operators.Like) {
                                expr = new LikeNode(_table, opInfo.op, nodeLeft, nodeRight);
                            }
                            else {
                                expr = new BinaryNode(_table, opInfo.op, nodeLeft, nodeRight);
                            }

                            break;
                        }
                    case Nodes.Unop:
                        /* Unary operator: Pop and bind right op. */
                        nodeLeft = null;
                        nodeRight = NodePop();

                        /* Check for special cases */
                        switch (opInfo.op) {

                            case Operators.Not:
                                break;

                            case Operators.BitwiseNot:
                                throw ExprException.UnsupportedOperator(opInfo.op);

                            case Operators.Negative:
                                break;
                        }

                        Debug.Assert(nodeLeft == null, "Invalid left operand");
                        Debug.Assert(nodeRight != null, "Invalid right operand");

                        expr = new UnaryNode(_table, opInfo.op, nodeRight);
                        break;

                    case Nodes.Zop:
                        /* Intrinsic constant: just create node. */
                        expr = new ZeroOpNode(opInfo.op);
                        break;

                    default:
                        Debug.Assert(false, "Unhandled operator type");
                        goto end_loop;
                }
                Debug.Assert(expr != null, "Failed to create expression");

                NodePush(expr);
                // countinue while loop;
            }
            end_loop:
            ;
        }
Beispiel #2
0
        private void BuildExpression(int pri)
        {
            OperatorInfo   info;
            ExpressionNode node = null;

Label_0002:
            info = this.ops[this.topOperator - 1];
            if (info.priority >= pri)
            {
                ExpressionNode node2;
                ExpressionNode node3;
                this.topOperator--;
                switch (info.type)
                {
                case Nodes.Unop:
                    node3 = null;
                    node2 = this.NodePop();
                    switch (info.op)
                    {
                    case 0x19:
                        throw ExprException.UnsupportedOperator(info.op);
                    }
                    node = new UnaryNode(this._table, info.op, node2);
                    goto Label_016C;

                case Nodes.UnopSpec:
                case Nodes.BinopSpec:
                    return;

                case Nodes.Binop:
                    node2 = this.NodePop();
                    node3 = this.NodePop();
                    switch (info.op)
                    {
                    case 4:
                    case 6:
                    case 0x16:
                    case 0x17:
                    case 0x18:
                    case 0x19:
                        throw ExprException.UnsupportedOperator(info.op);
                    }
                    if (info.op == 14)
                    {
                        node = new LikeNode(this._table, info.op, node3, node2);
                    }
                    else
                    {
                        node = new BinaryNode(this._table, info.op, node3, node2);
                    }
                    goto Label_016C;

                case Nodes.Zop:
                    node = new ZeroOpNode(info.op);
                    goto Label_016C;
                }
            }
            return;

Label_016C:
            this.NodePush(node);
            goto Label_0002;
        }
Beispiel #3
0
        /// <summary>
        ///     Builds expression tree for higher-precedence operator to be used as left
        ///     operand of current operator. May cause errors - always do ErrorCheck() upin return.
        /// </summary>

        private void BuildExpression(int pri)
        {
            ExpressionNode expr = null;

            Debug.Assert(pri > Operators.priStart && pri <= Operators.priMax, "Invalid priority value");

            /* For all operators of higher or same precedence (we are always
             * left-associative) */
            while (true)
            {
                Debug.Assert(_topOperator > 0, "Empty operator stack!!");
                OperatorInfo opInfo = _ops[_topOperator - 1];

                if (opInfo._priority < pri)
                {
                    goto end_loop;
                }

                Debug.Assert(opInfo._priority >= pri, "Invalid prioriry value");
                _topOperator--;

                ExpressionNode nodeLeft;
                ExpressionNode nodeRight;
                switch (opInfo._type)
                {
                case Nodes.Binop:
                {
                    // get right, left operands. Bind them.

                    nodeRight = NodePop();
                    nodeLeft  = NodePop();

                    /* This is the place to do type and other checks */

                    switch (opInfo._op)
                    {
                    case Operators.Between:
                    case Operators.BetweenAnd:
                    case Operators.BitwiseAnd:
                    case Operators.BitwiseOr:
                    case Operators.BitwiseXor:
                    case Operators.BitwiseNot:
                        throw ExprException.UnsupportedOperator(opInfo._op);

                    case Operators.Is:
                    case Operators.Or:
                    case Operators.And:
                    case Operators.EqualTo:
                    case Operators.NotEqual:
                    case Operators.Like:
                    case Operators.LessThen:
                    case Operators.LessOrEqual:
                    case Operators.GreaterThen:
                    case Operators.GreaterOrEqual:
                    case Operators.In:
                        break;

                    default:
                        Debug.Assert(opInfo._op == Operators.Plus ||
                                     opInfo._op == Operators.Minus ||
                                     opInfo._op == Operators.Multiply ||
                                     opInfo._op == Operators.Divide ||
                                     opInfo._op == Operators.Modulo,
                                     "Invalud Binary operation");

                        break;
                    }
                    Debug.Assert(nodeLeft != null, "Invalid left operand");
                    Debug.Assert(nodeRight != null, "Invalid right operand");

                    if (opInfo._op == Operators.Like)
                    {
                        expr = new LikeNode(_table, opInfo._op, nodeLeft, nodeRight);
                    }
                    else
                    {
                        expr = new BinaryNode(_table, opInfo._op, nodeLeft, nodeRight);
                    }

                    break;
                }

                case Nodes.Unop:
                    /* Unary operator: Pop and bind right op. */
                    nodeLeft  = null;
                    nodeRight = NodePop();

                    /* Check for special cases */
                    switch (opInfo._op)
                    {
                    case Operators.Not:
                        break;

                    case Operators.BitwiseNot:
                        throw ExprException.UnsupportedOperator(opInfo._op);

                    case Operators.Negative:
                        break;
                    }

                    Debug.Assert(nodeLeft == null, "Invalid left operand");
                    Debug.Assert(nodeRight != null, "Invalid right operand");

                    expr = new UnaryNode(_table, opInfo._op, nodeRight);
                    break;

                case Nodes.Zop:
                    /* Intrinsic constant: just create node. */
                    expr = new ZeroOpNode(opInfo._op);
                    break;

                default:
                    Debug.Fail("Unhandled operator type");
                    goto end_loop;
                }
                Debug.Assert(expr != null, "Failed to create expression");

                NodePush(expr);
                // countinue while loop;
            }
end_loop:
            ;
        }
        private void BuildExpression(int pri)
        {
            OperatorInfo info;
            ExpressionNode node = null;
        Label_0002:
            info = this.ops[this.topOperator - 1];
            if (info.priority >= pri)
            {
                ExpressionNode node2;
                ExpressionNode node3;
                this.topOperator--;
                switch (info.type)
                {
                    case Nodes.Unop:
                        node3 = null;
                        node2 = this.NodePop();
                        switch (info.op)
                        {
                            case 0x19:
                                throw ExprException.UnsupportedOperator(info.op);
                        }
                        node = new UnaryNode(this._table, info.op, node2);
                        goto Label_016C;

                    case Nodes.UnopSpec:
                    case Nodes.BinopSpec:
                        return;

                    case Nodes.Binop:
                        node2 = this.NodePop();
                        node3 = this.NodePop();
                        switch (info.op)
                        {
                            case 4:
                            case 6:
                            case 0x16:
                            case 0x17:
                            case 0x18:
                            case 0x19:
                                throw ExprException.UnsupportedOperator(info.op);
                        }
                        if (info.op == 14)
                        {
                            node = new LikeNode(this._table, info.op, node3, node2);
                        }
                        else
                        {
                            node = new BinaryNode(this._table, info.op, node3, node2);
                        }
                        goto Label_016C;

                    case Nodes.Zop:
                        node = new ZeroOpNode(info.op);
                        goto Label_016C;
                }
            }
            return;
        Label_016C:
            this.NodePush(node);
            goto Label_0002;
        }