Java Source Code: com.cloudera.flume.shell.antlr.FlumeShellParser

// $ANTLR 3.1.3 Mar 18, 2009 10:09:25 /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g 2010-08-18 11:16:21 
/** * Licensed to Cloudera, Inc. under one 
 * or more contributor license agreements.  See the NOTICE file 
 * distributed with this work for additional information 
 * regarding copyright ownership.  Cloudera, Inc. licenses this file 
 * to you under the Apache License, Version 2.0 (the 
 * "License"); you may not use this file except in compliance 
 * with the License.  You may obtain a copy of the License at 
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */ 
 
package com.cloudera.flume.shell.antlr;  
 
 
import org.antlr.runtime.*; 
import java.util.Stack; 
import java.util.List; 
import java.util.ArrayList; 
 
 
import org.antlr.runtime.tree.*; 
 
/** * Licensed to Cloudera, Inc. under one 
 * or more contributor license agreements.  See the NOTICE file 
 * distributed with this work for additional information 
 * regarding copyright ownership.  Cloudera, Inc. licenses this file 
 * to you under the Apache License, Version 2.0 (the 
 * "License"); you may not use this file except in compliance 
 * with the License.  You may obtain a copy of the License at 
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */ 
public class FlumeShellParser extends Parser { 
    public static final String[] tokenNames = new String[] { 
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "CMD", "DQUOTE", "SQUOTE", "STRING", "DQuoteLiteral", "SQuoteLiteral", "Argument", "HexDigit", "EscapeSequence", "UnicodeEscape", "OctalEscape", "Letter", "JavaIDDigit", "WS", "LINE_COMMENT", "';'" 
    }; 
    public static final int DQuoteLiteral=8; 
    public static final int LINE_COMMENT=18; 
    public static final int CMD=4; 
    public static final int DQUOTE=5; 
    public static final int SQUOTE=6; 
    public static final int EOF=-1; 
    public static final int HexDigit=11; 
    public static final int T__19=19; 
    public static final int WS=17; 
    public static final int UnicodeEscape=13; 
    public static final int SQuoteLiteral=9; 
    public static final int JavaIDDigit=16; 
    public static final int Argument=10; 
    public static final int EscapeSequence=12; 
    public static final int OctalEscape=14; 
    public static final int Letter=15; 
    public static final int STRING=7; 
 
    // delegates 
    // delegators 
 
 
        public FlumeShellParser(TokenStream input) { 
            this(input, new RecognizerSharedState()); 
        } 
        public FlumeShellParser(TokenStream input, RecognizerSharedState state) { 
            super(input, state); 
              
        } 
         
    protected TreeAdaptor adaptor = new CommonTreeAdaptor(); 
 
    public void setTreeAdaptor(TreeAdaptor adaptor) { 
        this.adaptor = adaptor; 
    } 
    public TreeAdaptor getTreeAdaptor() { 
        return adaptor; 
    } 
 
    public String[] getTokenNames() { return FlumeShellParser.tokenNames; } 
    public String getGrammarFileName() { return "/home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g"; } 
 
      
     public void reportError(RecognitionException re) { 
      throw new RuntimeException ("Parser Error: "+re); 
      // throw re; // TODO (jon) provide more info on a parser fail 
     } 
 
 
    public static class lines_return extends ParserRuleReturnScope { 
        Object tree; 
        public Object getTree() { return tree; } 
    }; 
 
    // $ANTLR start "lines" 
    // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:86:1: lines : command ( ';' command )* EOF -> ( command )+ ; 
    public final FlumeShellParser.lines_return lines() throws RecognitionException { 
        FlumeShellParser.lines_return retval = new FlumeShellParser.lines_return(); 
        retval.start = input.LT(1); 
 
        Object root_0 = null; 
 
        Token char_literal2=null; 
        Token EOF4=null; 
        FlumeShellParser.command_return command1 = null; 
 
        FlumeShellParser.command_return command3 = null; 
 
 
        Object char_literal2_tree=null; 
        Object EOF4_tree=null; 
        RewriteRuleTokenStream stream_19=new RewriteRuleTokenStream(adaptor,"token 19"); 
        RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF"); 
        RewriteRuleSubtreeStream stream_command=new RewriteRuleSubtreeStream(adaptor,"rule command"); 
        try { 
            // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:86:7: ( command ( ';' command )* EOF -> ( command )+ ) 
            // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:86:9: command ( ';' command )* EOF 
            { 
            pushFollow(FOLLOW_command_in_lines85); 
            command1=command(); 
 
            state._fsp--; 
 
            stream_command.add(command1.getTree()); 
            // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:86:17: ( ';' command )* 
            loop1: 
            do { 
                int alt1=2; 
                int LA1_0 = input.LA(1); 
 
                if ( (LA1_0==19) ) { 
                    alt1=1; 
                } 
 
 
                switch (alt1) { 
             case 1 : 
                 // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:86:18: ';' command 
                 { 
                 char_literal2=(Token)match(input,19,FOLLOW_19_in_lines88);   
                 stream_19.add(char_literal2); 
 
                 pushFollow(FOLLOW_command_in_lines90); 
                 command3=command(); 
 
                 state._fsp--; 
 
                 stream_command.add(command3.getTree()); 
 
                 } 
                 break; 
 
             default : 
                 break loop1; 
                } 
            } while (true); 
 
            EOF4=(Token)match(input,EOF,FOLLOW_EOF_in_lines94);   
            stream_EOF.add(EOF4); 
 
 
 
            // AST REWRITE 
            // elements: command 
            // token labels:  
            // rule labels: retval 
            // token list labels:  
            // rule list labels:  
            // wildcard labels:  
            retval.tree = root_0; 
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); 
 
            root_0 = (Object)adaptor.nil(); 
            // 86:36: -> ( command )+ 
            { 
                if ( !(stream_command.hasNext()) ) { 
                    throw new RewriteEarlyExitException(); 
                } 
                while ( stream_command.hasNext() ) { 
                    adaptor.addChild(root_0, stream_command.nextTree()); 
 
                } 
                stream_command.reset(); 
 
            } 
 
            retval.tree = root_0; 
            } 
 
            retval.stop = input.LT(-1); 
 
            retval.tree = (Object)adaptor.rulePostProcessing(root_0); 
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 
 
        } 
        catch (RecognitionException re) { 
            reportError(re); 
            recover(input,re); 
     retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); 
 
        } 
        finally { 
        } 
        return retval; 
    } 
    // $ANTLR end "lines" 
 
    public static class line_return extends ParserRuleReturnScope { 
        Object tree; 
        public Object getTree() { return tree; } 
    }; 
 
    // $ANTLR start "line" 
    // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:88:1: line : command EOF -> command ; 
    public final FlumeShellParser.line_return line() throws RecognitionException { 
        FlumeShellParser.line_return retval = new FlumeShellParser.line_return(); 
        retval.start = input.LT(1); 
 
        Object root_0 = null; 
 
        Token EOF6=null; 
        FlumeShellParser.command_return command5 = null; 
 
 
        Object EOF6_tree=null; 
        RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF"); 
        RewriteRuleSubtreeStream stream_command=new RewriteRuleSubtreeStream(adaptor,"rule command"); 
        try { 
            // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:88:6: ( command EOF -> command ) 
            // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:88:8: command EOF 
            { 
            pushFollow(FOLLOW_command_in_line107); 
            command5=command(); 
 
            state._fsp--; 
 
            stream_command.add(command5.getTree()); 
            EOF6=(Token)match(input,EOF,FOLLOW_EOF_in_line109);   
            stream_EOF.add(EOF6); 
 
 
 
            // AST REWRITE 
            // elements: command 
            // token labels:  
            // rule labels: retval 
            // token list labels:  
            // rule list labels:  
            // wildcard labels:  
            retval.tree = root_0; 
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); 
 
            root_0 = (Object)adaptor.nil(); 
            // 88:20: -> command 
            { 
                adaptor.addChild(root_0, stream_command.nextTree()); 
 
            } 
 
            retval.tree = root_0; 
            } 
 
            retval.stop = input.LT(-1); 
 
            retval.tree = (Object)adaptor.rulePostProcessing(root_0); 
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 
 
        } 
        catch (RecognitionException re) { 
            reportError(re); 
            recover(input,re); 
     retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); 
 
        } 
        finally { 
        } 
        return retval; 
    } 
    // $ANTLR end "line" 
 
    public static class command_return extends ParserRuleReturnScope { 
        Object tree; 
        public Object getTree() { return tree; } 
    }; 
 
    // $ANTLR start "command" 
    // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:90:1: command : ( literal )+ -> ^( CMD ( literal )+ ) ; 
    public final FlumeShellParser.command_return command() throws RecognitionException { 
        FlumeShellParser.command_return retval = new FlumeShellParser.command_return(); 
        retval.start = input.LT(1); 
 
        Object root_0 = null; 
 
        FlumeShellParser.literal_return literal7 = null; 
 
 
        RewriteRuleSubtreeStream stream_literal=new RewriteRuleSubtreeStream(adaptor,"rule literal"); 
        try { 
            // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:90:9: ( ( literal )+ -> ^( CMD ( literal )+ ) ) 
            // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:90:11: ( literal )+ 
            { 
            // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:90:11: ( literal )+ 
            int cnt2=0; 
            loop2: 
            do { 
                int alt2=2; 
                int LA2_0 = input.LA(1); 
 
                if ( ((LA2_0>=DQuoteLiteral && LA2_0<=Argument)) ) { 
                    alt2=1; 
                } 
 
 
                switch (alt2) { 
             case 1 : 
                 // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:90:11: literal 
                 { 
                 pushFollow(FOLLOW_literal_in_command122); 
                 literal7=literal(); 
 
                 state._fsp--; 
 
                 stream_literal.add(literal7.getTree()); 
 
                 } 
                 break; 
 
             default : 
                 if ( cnt2 >= 1 ) break loop2; 
                        EarlyExitException eee = 
                            new EarlyExitException(2, input); 
                        throw eee; 
                } 
                cnt2++; 
            } while (true); 
 
 
 
            // AST REWRITE 
            // elements: literal 
            // token labels:  
            // rule labels: retval 
            // token list labels:  
            // rule list labels:  
            // wildcard labels:  
            retval.tree = root_0; 
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); 
 
            root_0 = (Object)adaptor.nil(); 
            // 90:20: -> ^( CMD ( literal )+ ) 
            { 
                // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:90:23: ^( CMD ( literal )+ ) 
                { 
                Object root_1 = (Object)adaptor.nil(); 
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(CMD, "CMD"), root_1); 
 
                if ( !(stream_literal.hasNext()) ) { 
                    throw new RewriteEarlyExitException(); 
                } 
                while ( stream_literal.hasNext() ) { 
                    adaptor.addChild(root_1, stream_literal.nextTree()); 
 
                } 
                stream_literal.reset(); 
 
                adaptor.addChild(root_0, root_1); 
                } 
 
            } 
 
            retval.tree = root_0; 
            } 
 
            retval.stop = input.LT(-1); 
 
            retval.tree = (Object)adaptor.rulePostProcessing(root_0); 
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 
 
        } 
        catch (RecognitionException re) { 
            reportError(re); 
            recover(input,re); 
     retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); 
 
        } 
        finally { 
        } 
        return retval; 
    } 
    // $ANTLR end "command" 
 
    public static class literal_return extends ParserRuleReturnScope { 
        Object tree; 
        public Object getTree() { return tree; } 
    }; 
 
    // $ANTLR start "literal" 
    // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:93:1: literal : ( DQuoteLiteral -> ^( DQUOTE DQuoteLiteral ) | SQuoteLiteral -> ^( SQUOTE SQuoteLiteral ) | Argument -> ^( STRING Argument ) ); 
    public final FlumeShellParser.literal_return literal() throws RecognitionException { 
        FlumeShellParser.literal_return retval = new FlumeShellParser.literal_return(); 
        retval.start = input.LT(1); 
 
        Object root_0 = null; 
 
        Token DQuoteLiteral8=null; 
        Token SQuoteLiteral9=null; 
        Token Argument10=null; 
 
        Object DQuoteLiteral8_tree=null; 
        Object SQuoteLiteral9_tree=null; 
        Object Argument10_tree=null; 
        RewriteRuleTokenStream stream_Argument=new RewriteRuleTokenStream(adaptor,"token Argument"); 
        RewriteRuleTokenStream stream_DQuoteLiteral=new RewriteRuleTokenStream(adaptor,"token DQuoteLiteral"); 
        RewriteRuleTokenStream stream_SQuoteLiteral=new RewriteRuleTokenStream(adaptor,"token SQuoteLiteral"); 
 
        try { 
            // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:94:5: ( DQuoteLiteral -> ^( DQUOTE DQuoteLiteral ) | SQuoteLiteral -> ^( SQUOTE SQuoteLiteral ) | Argument -> ^( STRING Argument ) ) 
            int alt3=3; 
            switch ( input.LA(1) ) { 
            case DQuoteLiteral: 
                { 
                alt3=1; 
                } 
                break; 
            case SQuoteLiteral: 
                { 
                alt3=2; 
                } 
                break; 
            case Argument: 
                { 
                alt3=3; 
                } 
                break; 
            default: 
                NoViableAltException nvae = 
                    new NoViableAltException("", 3, 0, input); 
 
                throw nvae; 
            } 
 
            switch (alt3) { 
                case 1 : 
                    // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:94:9: DQuoteLiteral 
                    { 
                    DQuoteLiteral8=(Token)match(input,DQuoteLiteral,FOLLOW_DQuoteLiteral_in_literal150);   
                    stream_DQuoteLiteral.add(DQuoteLiteral8); 
 
 
 
                    // AST REWRITE 
                    // elements: DQuoteLiteral 
                    // token labels:  
                    // rule labels: retval 
                    // token list labels:  
                    // rule list labels:  
                    // wildcard labels:  
                    retval.tree = root_0; 
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); 
 
                    root_0 = (Object)adaptor.nil(); 
                    // 94:23: -> ^( DQUOTE DQuoteLiteral ) 
                    { 
                        // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:94:26: ^( DQUOTE DQuoteLiteral ) 
                        { 
                        Object root_1 = (Object)adaptor.nil(); 
                        root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(DQUOTE, "DQUOTE"), root_1); 
 
                        adaptor.addChild(root_1, stream_DQuoteLiteral.nextNode()); 
 
                        adaptor.addChild(root_0, root_1); 
                        } 
 
                    } 
 
                    retval.tree = root_0; 
                    } 
                    break; 
                case 2 : 
                    // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:95:9: SQuoteLiteral 
                    { 
                    SQuoteLiteral9=(Token)match(input,SQuoteLiteral,FOLLOW_SQuoteLiteral_in_literal170);   
                    stream_SQuoteLiteral.add(SQuoteLiteral9); 
 
 
 
                    // AST REWRITE 
                    // elements: SQuoteLiteral 
                    // token labels:  
                    // rule labels: retval 
                    // token list labels:  
                    // rule list labels:  
                    // wildcard labels:  
                    retval.tree = root_0; 
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); 
 
                    root_0 = (Object)adaptor.nil(); 
                    // 95:23: -> ^( SQUOTE SQuoteLiteral ) 
                    { 
                        // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:95:26: ^( SQUOTE SQuoteLiteral ) 
                        { 
                        Object root_1 = (Object)adaptor.nil(); 
                        root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(SQUOTE, "SQUOTE"), root_1); 
 
                        adaptor.addChild(root_1, stream_SQuoteLiteral.nextNode()); 
 
                        adaptor.addChild(root_0, root_1); 
                        } 
 
                    } 
 
                    retval.tree = root_0; 
                    } 
                    break; 
                case 3 : 
                    // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:96:9: Argument 
                    { 
                    Argument10=(Token)match(input,Argument,FOLLOW_Argument_in_literal188);   
                    stream_Argument.add(Argument10); 
 
 
 
                    // AST REWRITE 
                    // elements: Argument 
                    // token labels:  
                    // rule labels: retval 
                    // token list labels:  
                    // rule list labels:  
                    // wildcard labels:  
                    retval.tree = root_0; 
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null); 
 
                    root_0 = (Object)adaptor.nil(); 
                    // 96:21: -> ^( STRING Argument ) 
                    { 
                        // /home/patrick/Documents/flume-git2/flume/src/antlr/FlumeShell.g:96:24: ^( STRING Argument ) 
                        { 
                        Object root_1 = (Object)adaptor.nil(); 
                        root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(STRING, "STRING"), root_1); 
 
                        adaptor.addChild(root_1, stream_Argument.nextNode()); 
 
                        adaptor.addChild(root_0, root_1); 
                        } 
 
                    } 
 
                    retval.tree = root_0; 
                    } 
                    break; 
 
            } 
            retval.stop = input.LT(-1); 
 
            retval.tree = (Object)adaptor.rulePostProcessing(root_0); 
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); 
 
        } 
        catch (RecognitionException re) { 
            reportError(re); 
            recover(input,re); 
     retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); 
 
        } 
        finally { 
        } 
        return retval; 
    } 
    // $ANTLR end "literal" 
 
    // Delegated rules 
 
 
  
 
    public static final BitSet FOLLOW_command_in_lines85 = new BitSet(new long[]{0x0000000000080000L}); 
    public static final BitSet FOLLOW_19_in_lines88 = new BitSet(new long[]{0x0000000000000700L}); 
    public static final BitSet FOLLOW_command_in_lines90 = new BitSet(new long[]{0x0000000000080000L}); 
    public static final BitSet FOLLOW_EOF_in_lines94 = new BitSet(new long[]{0x0000000000000002L}); 
    public static final BitSet FOLLOW_command_in_line107 = new BitSet(new long[]{0x0000000000000000L}); 
    public static final BitSet FOLLOW_EOF_in_line109 = new BitSet(new long[]{0x0000000000000002L}); 
    public static final BitSet FOLLOW_literal_in_command122 = new BitSet(new long[]{0x0000000000000702L}); 
    public static final BitSet FOLLOW_DQuoteLiteral_in_literal150 = new BitSet(new long[]{0x0000000000000002L}); 
    public static final BitSet FOLLOW_SQuoteLiteral_in_literal170 = new BitSet(new long[]{0x0000000000000002L}); 
    public static final BitSet FOLLOW_Argument_in_literal188 = new BitSet(new long[]{0x0000000000000002L}); 
 
}