validationparser.java

EclipseIM是一个Eclipse插件, 其可以与Java开发人员即时聊天, 当在聊天中, 可以发送Eclipse中的java源码.

                if ( (LA3_0==14) ) {
                    alt3=1;
                }


                switch (alt3) {
            	case 1 :
            	    // antlr/Validation.g:31:23: ',' ruleBody
            	    {
            	    char_literal9=(Token)input.LT(1);
            	    match(input,14,FOLLOW_14_in_rulesList143); if (failed) return retval;
            	    if ( backtracking==0 ) {
            	    char_literal9_tree = (CommonTree)adaptor.create(char_literal9);
            	    adaptor.addChild(root_0, char_literal9_tree);
            	    }
            	    pushFollow(FOLLOW_ruleBody_in_rulesList145);
            	    ruleBody10=ruleBody();
            	    _fsp--;
            	    if (failed) return retval;
            	    if ( backtracking==0 ) adaptor.addChild(root_0, ruleBody10.getTree());

            	    }
            	    break;

            	default :
            	    break loop3;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( backtracking==0 ) {
                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( backtracking>0 ) { memoize(input, 3, rulesList_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end rulesList

    public static class ruleBody_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start ruleBody
    // antlr/Validation.g:33:1: ruleBody : ( name -> ^( GROUP name ) | java_method -> ^( RULE java_method ) | iterator | '!' -> ^( BREAK ) );
    public final ruleBody_return ruleBody() throws RecognitionException {
        ruleBody_return retval = new ruleBody_return();
        retval.start = input.LT(1);
        int ruleBody_StartIndex = input.index();
        CommonTree root_0 = null;

        Token char_literal14=null;
        name_return name11 = null;

        java_method_return java_method12 = null;

        iterator_return iterator13 = null;


        CommonTree char_literal14_tree=null;
        RewriteRuleTokenStream stream_15=new RewriteRuleTokenStream(adaptor,"token 15");
        RewriteRuleSubtreeStream stream_name=new RewriteRuleSubtreeStream(adaptor,"rule name");
        RewriteRuleSubtreeStream stream_java_method=new RewriteRuleSubtreeStream(adaptor,"rule java_method");
        try {
            if ( backtracking>0 && alreadyParsedRule(input, 4) ) { return retval; }
            // antlr/Validation.g:33:10: ( name -> ^( GROUP name ) | java_method -> ^( RULE java_method ) | iterator | '!' -> ^( BREAK ) )
            int alt4=4;
            int LA4_0 = input.LA(1);

            if ( (LA4_0==ID) ) {
                int LA4_1 = input.LA(2);

                if ( (LA4_1==18) ) {
                    int LA4_3 = input.LA(3);

                    if ( (LA4_3==ID) ) {
                        int LA4_7 = input.LA(4);

                        if ( (LA4_7==16) ) {
                            alt4=3;
                        }
                        else if ( (LA4_7==EOF||(LA4_7>=13 && LA4_7<=14)) ) {
                            alt4=2;
                        }
                        else {
                            if (backtracking>0) {failed=true; return retval;}
                            NoViableAltException nvae =
                                new NoViableAltException("33:1: ruleBody : ( name -> ^( GROUP name ) | java_method -> ^( RULE java_method ) | iterator | '!' -> ^( BREAK ) );", 4, 7, input);

                            throw nvae;
                        }
                    }
                    else {
                        if (backtracking>0) {failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("33:1: ruleBody : ( name -> ^( GROUP name ) | java_method -> ^( RULE java_method ) | iterator | '!' -> ^( BREAK ) );", 4, 3, input);

                        throw nvae;
                    }
                }
                else if ( (LA4_1==EOF||(LA4_1>=13 && LA4_1<=14)) ) {
                    alt4=1;
                }
                else {
                    if (backtracking>0) {failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("33:1: ruleBody : ( name -> ^( GROUP name ) | java_method -> ^( RULE java_method ) | iterator | '!' -> ^( BREAK ) );", 4, 1, input);

                    throw nvae;
                }
            }
            else if ( (LA4_0==15) ) {
                alt4=4;
            }
            else {
                if (backtracking>0) {failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("33:1: ruleBody : ( name -> ^( GROUP name ) | java_method -> ^( RULE java_method ) | iterator | '!' -> ^( BREAK ) );", 4, 0, input);

                throw nvae;
            }
            switch (alt4) {
                case 1 :
                    // antlr/Validation.g:33:12: name
                    {
                    pushFollow(FOLLOW_name_in_ruleBody155);
                    name11=name();
                    _fsp--;
                    if (failed) return retval;
                    if ( backtracking==0 ) stream_name.add(name11.getTree());

                    // AST REWRITE
                    // elements: name
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    if ( backtracking==0 ) {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 33:17: -> ^( GROUP name )
                    {
                        // antlr/Validation.g:33:20: ^( GROUP name )
                        {
                        CommonTree root_1 = (CommonTree)adaptor.nil();
                        root_1 = (CommonTree)adaptor.becomeRoot(adaptor.create(GROUP, "GROUP"), root_1);

                        adaptor.addChild(root_1, stream_name.next());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    }

                    }
                    break;
                case 2 :
                    // antlr/Validation.g:34:6: java_method
                    {
                    pushFollow(FOLLOW_java_method_in_ruleBody170);
                    java_method12=java_method();
                    _fsp--;
                    if (failed) return retval;
                    if ( backtracking==0 ) stream_java_method.add(java_method12.getTree());

                    // AST REWRITE
                    // elements: java_method
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    if ( backtracking==0 ) {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 34:18: -> ^( RULE java_method )
                    {
                        // antlr/Validation.g:34:21: ^( RULE java_method )
                        {
                        CommonTree root_1 = (CommonTree)adaptor.nil();
                        root_1 = (CommonTree)adaptor.becomeRoot(adaptor.create(RULE, "RULE"), root_1);

                        adaptor.addChild(root_1, stream_java_method.next());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    }

                    }
                    break;
                case 3 :
                    // antlr/Validation.g:35:6: iterator
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_iterator_in_ruleBody185);
                    iterator13=iterator();
                    _fsp--;
                    if (failed) return retval;
                    if ( backtracking==0 ) adaptor.addChild(root_0, iterator13.getTree());

                    }
                    break;
                case 4 :
                    // antlr/Validation.g:36:6: '!'
                    {
                    char_literal14=(Token)input.LT(1);
                    match(input,15,FOLLOW_15_in_ruleBody192); if (failed) return retval;
                    if ( backtracking==0 ) stream_15.add(char_literal14);


                    // AST REWRITE
                    // elements: 
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    if ( backtracking==0 ) {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"token retval",retval!=null?retval.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 36:10: -> ^( BREAK )
                    {
                        // antlr/Validation.g:36:13: ^( BREAK )
                        {
                        CommonTree root_1 = (CommonTree)adaptor.nil();
                        root_1 = (CommonTree)adaptor.becomeRoot(adaptor.create(BREAK, "BREAK"), root_1);

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    }

                    }
                    break;

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

            if ( backtracking==0 ) {
                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( backtracking>0 ) { memoize(input, 4, ruleBody_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end ruleBody

    public static class iterator_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start iterator
    // antlr/Validation.g:39:1: iterator : java_method '#' param -> ^( ITERATOR ^( RULE java_method ) param ) ;
    public final iterator_return iterator() throws RecognitionException {
        iterator_return retval = new iterator_return();
        retval.start = input.LT(1);
        int iterator_StartIndex = input.index();
        CommonTree root_0 = null;

        Token char_literal16=null;
        java_method_return java_method15 = null;

        param_return param17 = null;


        CommonTree char_literal16_tree=null;
        RewriteRuleTokenStream stream_16=new RewriteRuleTokenStream(adaptor,"token 16");
        RewriteRuleSubtreeStream stream_param=new RewriteRuleSubtreeStream(adaptor,"rule param");
        RewriteRuleSubtreeStream stream_java_method=new RewriteRuleSubtreeStream(adaptor,"rule java_method");
        try {
            if ( backtracking>0 && alreadyParsedRule(input, 5) ) { return retval; }
            // antlr/Validation.g:39:10: ( java_method '#' param -> ^( ITERATOR ^( RULE java_method ) param ) )
            // antlr/Validation.g:39:12: java_method '#' param
            {
            pushFollow(FOLLOW_java_method_in_iterator213);
            java_method15=java_method();
            _fsp--;
            if (failed) return retval;
            if ( backtracking==0 ) stream_java_method.add(java_method15.getTree());
            char_literal16=(Token)input.LT(1);
            match(input,16,FOLLOW_16_in_iterator215); if (failed) return retval;
            if ( backtracking==0 ) stream_16.add(char_literal16);

            pushFollow(FOLLOW_param_in_iterator217);
            param17=param();
            _fsp--;
            if (failed) return retval;
            if ( backtracking==0 ) stream_param.add(param17.getTree());