validationparser.java

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

            // AST REWRITE
            // elements: java_method, param
            // 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();
            // 39:34: -> ^( ITERATOR ^( RULE java_method ) param )
            {
                // antlr/Validation.g:39:37: ^( ITERATOR ^( RULE java_method ) param )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot(adaptor.create(ITERATOR, "ITERATOR"), root_1);

                // antlr/Validation.g:39:48: ^( RULE java_method )
                {
                CommonTree root_2 = (CommonTree)adaptor.nil();
                root_2 = (CommonTree)adaptor.becomeRoot(adaptor.create(RULE, "RULE"), root_2);

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

                adaptor.addChild(root_1, root_2);
                }
                adaptor.addChild(root_1, stream_param.next());

                adaptor.addChild(root_0, root_1);
                }

            }

            }

            }

            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, 5, iterator_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end iterator

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

    // $ANTLR start param
    // antlr/Validation.g:41:1: param : ( name -> ^( GROUP name ) | java_method -> ^( RULE java_method ) );
    public final param_return param() throws RecognitionException {
        param_return retval = new param_return();
        retval.start = input.LT(1);
        int param_StartIndex = input.index();
        CommonTree root_0 = null;

        name_return name18 = null;

        java_method_return java_method19 = null;


        RewriteRuleSubtreeStream stream_name=new RewriteRuleSubtreeStream(adaptor,"rule name");
        RewriteRuleSubtreeStream stream_java_method=new RewriteRuleSubtreeStream(adaptor,"rule java_method");
        try {
            if ( backtracking>0 && alreadyParsedRule(input, 6) ) { return retval; }
            // antlr/Validation.g:41:7: ( name -> ^( GROUP name ) | java_method -> ^( RULE java_method ) )
            int alt5=2;
            int LA5_0 = input.LA(1);

            if ( (LA5_0==ID) ) {
                int LA5_1 = input.LA(2);

                if ( (LA5_1==18) ) {
                    alt5=2;
                }
                else if ( (LA5_1==EOF||(LA5_1>=13 && LA5_1<=14)) ) {
                    alt5=1;
                }
                else {
                    if (backtracking>0) {failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("41:1: param : ( name -> ^( GROUP name ) | java_method -> ^( RULE java_method ) );", 5, 1, input);

                    throw nvae;
                }
            }
            else {
                if (backtracking>0) {failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("41:1: param : ( name -> ^( GROUP name ) | java_method -> ^( RULE java_method ) );", 5, 0, input);

                throw nvae;
            }
            switch (alt5) {
                case 1 :
                    // antlr/Validation.g:41:10: name
                    {
                    pushFollow(FOLLOW_name_in_param240);
                    name18=name();
                    _fsp--;
                    if (failed) return retval;
                    if ( backtracking==0 ) stream_name.add(name18.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();
                    // 41:15: -> ^( GROUP name )
                    {
                        // antlr/Validation.g:41:18: ^( 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:42:6: java_method
                    {
                    pushFollow(FOLLOW_java_method_in_param255);
                    java_method19=java_method();
                    _fsp--;
                    if (failed) return retval;
                    if ( backtracking==0 ) stream_java_method.add(java_method19.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();
                    // 42:18: -> ^( RULE java_method )
                    {
                        // antlr/Validation.g:42: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;

            }
            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, 6, param_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end param

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

    // $ANTLR start importDefinition
    // antlr/Validation.g:44:1: importDefinition : 'import' className ';' -> ^( IMPORT className ) ;
    public final importDefinition_return importDefinition() throws RecognitionException {
        importDefinition_return retval = new importDefinition_return();
        retval.start = input.LT(1);
        int importDefinition_StartIndex = input.index();
        CommonTree root_0 = null;

        Token string_literal20=null;
        Token char_literal22=null;
        className_return className21 = null;


        CommonTree string_literal20_tree=null;
        CommonTree char_literal22_tree=null;
        RewriteRuleTokenStream stream_17=new RewriteRuleTokenStream(adaptor,"token 17");
        RewriteRuleTokenStream stream_13=new RewriteRuleTokenStream(adaptor,"token 13");
        RewriteRuleSubtreeStream stream_className=new RewriteRuleSubtreeStream(adaptor,"rule className");
        try {
            if ( backtracking>0 && alreadyParsedRule(input, 7) ) { return retval; }
            // antlr/Validation.g:44:17: ( 'import' className ';' -> ^( IMPORT className ) )
            // antlr/Validation.g:44:19: 'import' className ';'
            {
            string_literal20=(Token)input.LT(1);
            match(input,17,FOLLOW_17_in_importDefinition270); if (failed) return retval;
            if ( backtracking==0 ) stream_17.add(string_literal20);

            pushFollow(FOLLOW_className_in_importDefinition272);
            className21=className();
            _fsp--;
            if (failed) return retval;
            if ( backtracking==0 ) stream_className.add(className21.getTree());
            char_literal22=(Token)input.LT(1);
            match(input,13,FOLLOW_13_in_importDefinition274); if (failed) return retval;
            if ( backtracking==0 ) stream_13.add(char_literal22);


            // AST REWRITE
            // elements: className
            // 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();
            // 44:42: -> ^( IMPORT className )
            {
                // antlr/Validation.g:44:45: ^( IMPORT className )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot(adaptor.create(IMPORT, "IMPORT"), root_1);

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

                adaptor.addChild(root_0, root_1);
                }

            }

            }

            }

            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, 7, importDefinition_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end importDefinition

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

    // $ANTLR start className
    // antlr/Validation.g:46:1: className : ID ( '.' ID )+ ;
    public final className_return className() throws RecognitionException {
        className_return retval = new className_return();
        retval.start = input.LT(1);
        int className_StartIndex = input.index();
        CommonTree root_0 = null;

        Token ID23=null;
        Token char_literal24=null;
        Token ID25=null;

        CommonTree ID23_tree=null;
        CommonTree char_literal24_tree=null;
        CommonTree ID25_tree=null;

        try {
            if ( backtracking>0 && alreadyParsedRule(input, 8) ) { return retval; }
            // antlr/Validation.g:46:11: ( ID ( '.' ID )+ )
            // antlr/Validation.g:46:13: ID ( '.' ID )+
            {
            root_0 = (CommonTree)adaptor.nil();

            ID23=(Token)input.LT(1);
            match(input,ID,FOLLOW_ID_in_className290); if (failed) return retval;