Boo.Lang.Parser.BooParserBase.unary_expression C# (CSharp) Method

unary_expression() protected method

protected unary_expression ( ) : Expression
return Expression
        protected Expression unary_expression()
        {
            Expression e;

            IToken  sub = null;
            IToken  inc = null;
            IToken  dec = null;
            IToken  oc = null;
            IToken  explode = null;
            IToken  postinc = null;
            IToken  postdec = null;

                    e = null;
                    IToken op = null;
                    UnaryOperatorType uOperator = UnaryOperatorType.None;

            try {      // for error handling
            {
                bool synPredMatched543 = false;
                if (((LA(1)==SUBTRACT||LA(1)==LONG||LA(1)==INT) && (tokenSet_74_.member(LA(2)))))
                {
                    int _m543 = mark();
                    synPredMatched543 = true;
                    inputState.guessing++;
                    try {
                        {
                            match(SUBTRACT);
                            match(LONG);
                        }
                    }
                    catch (RecognitionException)
                    {
                        synPredMatched543 = false;
                    }
                    rewind(_m543);
                    inputState.guessing--;
                }
                if ( synPredMatched543 )
                {
                    {
                        e=integer_literal();
                    }
                }
                else if ((tokenSet_122_.member(LA(1))) && (tokenSet_114_.member(LA(2)))) {
                    {
                        {
                            switch ( LA(1) )
                            {
                            case SUBTRACT:
                            {
                                sub = LT(1);
                                match(SUBTRACT);
                                if (0==inputState.guessing)
                                {
                                    op = sub; uOperator = UnaryOperatorType.UnaryNegation;
                                }
                                break;
                            }
                            case INCREMENT:
                            {
                                inc = LT(1);
                                match(INCREMENT);
                                if (0==inputState.guessing)
                                {
                                    op = inc; uOperator = UnaryOperatorType.Increment;
                                }
                                break;
                            }
                            case DECREMENT:
                            {
                                dec = LT(1);
                                match(DECREMENT);
                                if (0==inputState.guessing)
                                {
                                    op = dec; uOperator = UnaryOperatorType.Decrement;
                                }
                                break;
                            }
                            case ONES_COMPLEMENT:
                            {
                                oc = LT(1);
                                match(ONES_COMPLEMENT);
                                if (0==inputState.guessing)
                                {
                                    op = oc; uOperator = UnaryOperatorType.OnesComplement;
                                }
                                break;
                            }
                            case MULTIPLY:
                            {
                                explode = LT(1);
                                match(MULTIPLY);
                                if (0==inputState.guessing)
                                {
                                    op = explode; uOperator = UnaryOperatorType.Explode;
                                }
                                break;
                            }
                            default:
                            {
                                throw new NoViableAltException(LT(1), getFilename());
                            }
                             }
                        }
                        e=unary_expression();
                    }
                }
                else if ((tokenSet_34_.member(LA(1))) && (tokenSet_123_.member(LA(2)))) {
                    {
                        e=slicing_expression();
                        {
                            if ((LA(1)==INCREMENT) && (tokenSet_74_.member(LA(2))))
                            {
                                postinc = LT(1);
                                match(INCREMENT);
                                if (0==inputState.guessing)
                                {
                                    op = postinc; uOperator = UnaryOperatorType.PostIncrement;
                                }
                            }
                            else if ((LA(1)==DECREMENT) && (tokenSet_74_.member(LA(2)))) {
                                postdec = LT(1);
                                match(DECREMENT);
                                if (0==inputState.guessing)
                                {
                                    op = postdec; uOperator = UnaryOperatorType.PostDecrement;
                                }
                            }
                            else if ((tokenSet_74_.member(LA(1))) && (tokenSet_15_.member(LA(2)))) {
                            }
                            else
                            {
                                throw new NoViableAltException(LT(1), getFilename());
                            }

                        }
                    }
                }
                else
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }

            }
            if (0==inputState.guessing)
            {

                        if (null != op)
                        {
                            UnaryExpression ue = new UnaryExpression(ToLexicalInfo(op));
                            ue.Operator = uOperator;
                            ue.Operand = e;
                            e = ue;
                        }

            }
            }
            catch (RecognitionException ex)
            {
            if (0 == inputState.guessing)
            {
                reportError(ex, "unary_expression");
                recover(ex,tokenSet_74_);
            }
            else
            {
                throw ex;
            }
            }
            return e;
        }
BooParserBase