ES3Parser.reservedWord C# (CSharp) Method

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

        object root_0 = null;

        IToken NULL8 = null;
        ES3Parser.keyword_return keyword6 = default(ES3Parser.keyword_return);

        ES3Parser.futureReservedWord_return futureReservedWord7 = default(ES3Parser.futureReservedWord_return);

        ES3Parser.booleanLiteral_return booleanLiteral9 = default(ES3Parser.booleanLiteral_return);


        object NULL8_tree=null;

        try 
    	{
            // C:\\Users\\s.ros\\Projets\\Jint\\Jint\\ES3.g:657:2: ( keyword | futureReservedWord | NULL | booleanLiteral )
            int alt2 = 4;
            switch ( input.LA(1) ) 
            {
            case BREAK:
            case CASE:
            case CATCH:
            case CONTINUE:
            case DEFAULT:
            case DELETE:
            case DO:
            case ELSE:
            case FINALLY:
            case FOR:
            case FUNCTION:
            case IF:
            case IN:
            case INSTANCEOF:
            case NEW:
            case RETURN:
            case SWITCH:
            case THIS:
            case THROW:
            case TRY:
            case TYPEOF:
            case VAR:
            case VOID:
            case WHILE:
            case WITH:
            	{
                alt2 = 1;
                }
                break;
            case ABSTRACT:
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case CLASS:
            case CONST:
            case DEBUGGER:
            case DOUBLE:
            case ENUM:
            case EXPORT:
            case EXTENDS:
            case FINAL:
            case FLOAT:
            case GOTO:
            case IMPLEMENTS:
            case IMPORT:
            case INT:
            case INTERFACE:
            case LONG:
            case NATIVE:
            case PACKAGE:
            case PRIVATE:
            case PROTECTED:
            case PUBLIC:
            case SHORT:
            case STATIC:
            case SUPER:
            case SYNCHRONIZED:
            case THROWS:
            case TRANSIENT:
            case VOLATILE:
            	{
                alt2 = 2;
                }
                break;
            case NULL:
            	{
                alt2 = 3;
                }
                break;
            case TRUE:
            case FALSE:
            	{
                alt2 = 4;
                }
                break;
            	default:
            	    NoViableAltException nvae_d2s0 =
            	        new NoViableAltException("", 2, 0, input);

            	    throw nvae_d2s0;
            }

            switch (alt2) 
            {
                case 1 :
                    // C:\\Users\\s.ros\\Projets\\Jint\\Jint\\ES3.g:657:4: keyword
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_keyword_in_reservedWord1782);
                    	keyword6 = keyword();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, keyword6.Tree);

                    }
                    break;
                case 2 :
                    // C:\\Users\\s.ros\\Projets\\Jint\\Jint\\ES3.g:658:4: futureReservedWord
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_futureReservedWord_in_reservedWord1787);
                    	futureReservedWord7 = futureReservedWord();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, futureReservedWord7.Tree);

                    }
                    break;
                case 3 :
                    // C:\\Users\\s.ros\\Projets\\Jint\\Jint\\ES3.g:659:4: NULL
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	NULL8=(IToken)Match(input,NULL,FOLLOW_NULL_in_reservedWord1792); 
                    		NULL8_tree = (object)adaptor.Create(NULL8);
                    		adaptor.AddChild(root_0, NULL8_tree);


                    }
                    break;
                case 4 :
                    // C:\\Users\\s.ros\\Projets\\Jint\\Jint\\ES3.g:660:4: booleanLiteral
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_booleanLiteral_in_reservedWord1797);
                    	booleanLiteral9 = booleanLiteral();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, booleanLiteral9.Tree);

                    }
                    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 "reservedWord"