validationparser.java

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

// $ANTLR 3.0.1 antlr/Validation.g 2007-10-15 00:18:54

package com.asterix.validation.antlr;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

import org.antlr.runtime.tree.*;

public class ValidationParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "GROUP", "RULE", "CLASS", "ITERATOR", "IMPORT", "BREAK", "ID", "WS", "'->'", "';'", "','", "'!'", "'#'", "'import'", "'.'", "'/**'", "'*/'"
    };
    public static final int GROUP=4;
    public static final int IMPORT=8;
    public static final int CLASS=6;
    public static final int WS=11;
    public static final int RULE=5;
    public static final int ITERATOR=7;
    public static final int ID=10;
    public static final int EOF=-1;
    public static final int BREAK=9;

        public ValidationParser(TokenStream input) {
            super(input);
            ruleMemo = new HashMap[21+1];
         }
        
    protected TreeAdaptor adaptor = new CommonTreeAdaptor();

    public void setTreeAdaptor(TreeAdaptor adaptor) {
        this.adaptor = adaptor;
    }
    public TreeAdaptor getTreeAdaptor() {
        return adaptor;
    }

    public String[] getTokenNames() { return tokenNames; }
    public String getGrammarFileName() { return "antlr/Validation.g"; }


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

    // $ANTLR start parse
    // antlr/Validation.g:27:1: parse : ( importDefinition )+ ( groupDefinition | comment )+ ;
    public final parse_return parse() throws RecognitionException {
        parse_return retval = new parse_return();
        retval.start = input.LT(1);
        int parse_StartIndex = input.index();
        CommonTree root_0 = null;

        importDefinition_return importDefinition1 = null;

        groupDefinition_return groupDefinition2 = null;

        comment_return comment3 = null;



        try {
            if ( backtracking>0 && alreadyParsedRule(input, 1) ) { return retval; }
            // antlr/Validation.g:27:7: ( ( importDefinition )+ ( groupDefinition | comment )+ )
            // antlr/Validation.g:27:9: ( importDefinition )+ ( groupDefinition | comment )+
            {
            root_0 = (CommonTree)adaptor.nil();

            // antlr/Validation.g:27:9: ( importDefinition )+
            int cnt1=0;
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0==17) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // antlr/Validation.g:0:0: importDefinition
            	    {
            	    pushFollow(FOLLOW_importDefinition_in_parse93);
            	    importDefinition1=importDefinition();
            	    _fsp--;
            	    if (failed) return retval;
            	    if ( backtracking==0 ) adaptor.addChild(root_0, importDefinition1.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt1 >= 1 ) break loop1;
            	    if (backtracking>0) {failed=true; return retval;}
                        EarlyExitException eee =
                            new EarlyExitException(1, input);
                        throw eee;
                }
                cnt1++;
            } while (true);

            // antlr/Validation.g:27:27: ( groupDefinition | comment )+
            int cnt2=0;
            loop2:
            do {
                int alt2=3;
                int LA2_0 = input.LA(1);

                if ( (LA2_0==ID) ) {
                    alt2=1;
                }
                else if ( (LA2_0==19) ) {
                    alt2=2;
                }


                switch (alt2) {
            	case 1 :
            	    // antlr/Validation.g:27:28: groupDefinition
            	    {
            	    pushFollow(FOLLOW_groupDefinition_in_parse97);
            	    groupDefinition2=groupDefinition();
            	    _fsp--;
            	    if (failed) return retval;
            	    if ( backtracking==0 ) adaptor.addChild(root_0, groupDefinition2.getTree());

            	    }
            	    break;
            	case 2 :
            	    // antlr/Validation.g:27:46: comment
            	    {
            	    pushFollow(FOLLOW_comment_in_parse101);
            	    comment3=comment();
            	    _fsp--;
            	    if (failed) return retval;

            	    }
            	    break;

            	default :
            	    if ( cnt2 >= 1 ) break loop2;
            	    if (backtracking>0) {failed=true; return retval;}
                        EarlyExitException eee =
                            new EarlyExitException(2, input);
                        throw eee;
                }
                cnt2++;
            } 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, 1, parse_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end parse

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

    // $ANTLR start groupDefinition
    // antlr/Validation.g:29:1: groupDefinition : name '->' rulesList ';' -> ^( GROUP name ^( name rulesList ) ) ;
    public final groupDefinition_return groupDefinition() throws RecognitionException {
        groupDefinition_return retval = new groupDefinition_return();
        retval.start = input.LT(1);
        int groupDefinition_StartIndex = input.index();
        CommonTree root_0 = null;

        Token string_literal5=null;
        Token char_literal7=null;
        name_return name4 = null;

        rulesList_return rulesList6 = null;


        CommonTree string_literal5_tree=null;
        CommonTree char_literal7_tree=null;
        RewriteRuleTokenStream stream_13=new RewriteRuleTokenStream(adaptor,"token 13");
        RewriteRuleTokenStream stream_12=new RewriteRuleTokenStream(adaptor,"token 12");
        RewriteRuleSubtreeStream stream_name=new RewriteRuleSubtreeStream(adaptor,"rule name");
        RewriteRuleSubtreeStream stream_rulesList=new RewriteRuleSubtreeStream(adaptor,"rule rulesList");
        try {
            if ( backtracking>0 && alreadyParsedRule(input, 2) ) { return retval; }
            // antlr/Validation.g:29:17: ( name '->' rulesList ';' -> ^( GROUP name ^( name rulesList ) ) )
            // antlr/Validation.g:29:19: name '->' rulesList ';'
            {
            pushFollow(FOLLOW_name_in_groupDefinition112);
            name4=name();
            _fsp--;
            if (failed) return retval;
            if ( backtracking==0 ) stream_name.add(name4.getTree());
            string_literal5=(Token)input.LT(1);
            match(input,12,FOLLOW_12_in_groupDefinition114); if (failed) return retval;
            if ( backtracking==0 ) stream_12.add(string_literal5);

            pushFollow(FOLLOW_rulesList_in_groupDefinition116);
            rulesList6=rulesList();
            _fsp--;
            if (failed) return retval;
            if ( backtracking==0 ) stream_rulesList.add(rulesList6.getTree());
            char_literal7=(Token)input.LT(1);
            match(input,13,FOLLOW_13_in_groupDefinition118); if (failed) return retval;
            if ( backtracking==0 ) stream_13.add(char_literal7);


            // AST REWRITE
            // elements: name, rulesList, 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();
            // 29:43: -> ^( GROUP name ^( name rulesList ) )
            {
                // antlr/Validation.g:29:46: ^( GROUP name ^( name rulesList ) )
                {
                CommonTree root_1 = (CommonTree)adaptor.nil();
                root_1 = (CommonTree)adaptor.becomeRoot(adaptor.create(GROUP, "GROUP"), root_1);

                adaptor.addChild(root_1, stream_name.next());
                // antlr/Validation.g:29:59: ^( name rulesList )
                {
                CommonTree root_2 = (CommonTree)adaptor.nil();
                root_2 = (CommonTree)adaptor.becomeRoot(stream_name.nextNode(), root_2);

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

                adaptor.addChild(root_1, root_2);
                }

                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, 2, groupDefinition_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end groupDefinition

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

    // $ANTLR start rulesList
    // antlr/Validation.g:31:1: rulesList : ruleBody ( ',' ruleBody )* ;
    public final rulesList_return rulesList() throws RecognitionException {
        rulesList_return retval = new rulesList_return();
        retval.start = input.LT(1);
        int rulesList_StartIndex = input.index();
        CommonTree root_0 = null;

        Token char_literal9=null;
        ruleBody_return ruleBody8 = null;

        ruleBody_return ruleBody10 = null;


        CommonTree char_literal9_tree=null;

        try {
            if ( backtracking>0 && alreadyParsedRule(input, 3) ) { return retval; }
            // antlr/Validation.g:31:11: ( ruleBody ( ',' ruleBody )* )
            // antlr/Validation.g:31:13: ruleBody ( ',' ruleBody )*
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_ruleBody_in_rulesList140);
            ruleBody8=ruleBody();
            _fsp--;
            if (failed) return retval;
            if ( backtracking==0 ) adaptor.addChild(root_0, ruleBody8.getTree());
            // antlr/Validation.g:31:22: ( ',' ruleBody )*
            loop3:
            do {
                int alt3=2;
                int LA3_0 = input.LA(1);