ES3Parser.unaryExpression C# (CSharp) Method

    public ES3Parser.unaryExpression_return unaryExpression() // throws RecognitionException [1]
    {   
        ES3Parser.unaryExpression_return retval = new ES3Parser.unaryExpression_return();
        retval.Start = input.LT(1);

        object root_0 = null;

        ES3Parser.postfixExpression_return post = default(ES3Parser.postfixExpression_return);

        ES3Parser.unaryOperator_return op = default(ES3Parser.unaryOperator_return);

        ES3Parser.unaryExpression_return exp = default(ES3Parser.unaryExpression_return);



        try 
    	{
            // C:\\Users\\s.ros\\Projets\\Jint\\Jint\\ES3.g:1105:2: (post= postfixExpression | op= unaryOperator exp= unaryExpression )
            int alt24 = 2;
            int LA24_0 = input.LA(1);

            if ( ((LA24_0 >= NULL && LA24_0 <= FALSE) || LA24_0 == FUNCTION || LA24_0 == NEW || LA24_0 == THIS || LA24_0 == LBRACE || LA24_0 == LPAREN || LA24_0 == LBRACK || (LA24_0 >= Identifier && LA24_0 <= StringLiteral) || LA24_0 == RegularExpressionLiteral || (LA24_0 >= DecimalLiteral && LA24_0 <= HexIntegerLiteral)) )
            {
                alt24 = 1;
            }
            else if ( (LA24_0 == DELETE || LA24_0 == TYPEOF || LA24_0 == VOID || (LA24_0 >= ADD && LA24_0 <= SUB) || (LA24_0 >= INC && LA24_0 <= DEC) || (LA24_0 >= NOT && LA24_0 <= INV)) )
            {
                alt24 = 2;
            }
            else 
            {
                NoViableAltException nvae_d24s0 =
                    new NoViableAltException("", 24, 0, input);

                throw nvae_d24s0;
            }
            switch (alt24) 
            {
                case 1 :
                    // C:\\Users\\s.ros\\Projets\\Jint\\Jint\\ES3.g:1105:4: post= postfixExpression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_postfixExpression_in_unaryExpression3845);
                    	post = postfixExpression();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, post.Tree);
                    	 retval.value =  post.value; 

                    }
                    break;
                case 2 :
                    // C:\\Users\\s.ros\\Projets\\Jint\\Jint\\ES3.g:1106:4: op= unaryOperator exp= unaryExpression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_unaryOperator_in_unaryExpression3854);
                    	op = unaryOperator();
                    	state.followingStackPointer--;

                    	root_0 = (object)adaptor.BecomeRoot(op.Tree, root_0);
                    	PushFollow(FOLLOW_unaryExpression_in_unaryExpression3859);
                    	exp = unaryExpression();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, exp.Tree);
                    	 retval.value =  new UnaryExpression(op.value, exp.value); 

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "unaryExpression"