diff options
Diffstat (limited to 'Homework/cs5300/project-three/cfgparser/GrammarParser.java')
| -rw-r--r-- | Homework/cs5300/project-three/cfgparser/GrammarParser.java | 503 |
1 files changed, 503 insertions, 0 deletions
diff --git a/Homework/cs5300/project-three/cfgparser/GrammarParser.java b/Homework/cs5300/project-three/cfgparser/GrammarParser.java new file mode 100644 index 0000000..20c523c --- /dev/null +++ b/Homework/cs5300/project-three/cfgparser/GrammarParser.java @@ -0,0 +1,503 @@ +// Generated from Grammar.g4 by ANTLR 4.9.1 +package cfgparser; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.misc.*; +import org.antlr.v4.runtime.tree.*; +import java.util.List; +import java.util.Iterator; +import java.util.ArrayList; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +public class GrammarParser extends Parser { + static { RuntimeMetaData.checkVersion("4.9.1", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + T__0=1, T__1=2, T__2=3, GRAMMAR=4, IDENT=5, WS=6, COMMENT=7; + public static final int + RULE_goal = 0, RULE_name = 1, RULE_rule_list = 2, RULE_lhs = 3, RULE_rhs = 4, + RULE_or_list = 5, RULE_symbol_list = 6, RULE_symbol = 7; + private static String[] makeRuleNames() { + return new String[] { + "goal", "name", "rule_list", "lhs", "rhs", "or_list", "symbol_list", + "symbol" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, "';'", "':'", "'|'", "'grammar'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, null, null, null, "GRAMMAR", "IDENT", "WS", "COMMENT" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = "<INVALID>"; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getGrammarFileName() { return "Grammar.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public ATN getATN() { return _ATN; } + + public GrammarParser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + public static class GoalContext extends ParserRuleContext { + public TerminalNode GRAMMAR() { return getToken(GrammarParser.GRAMMAR, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Rule_listContext rule_list() { + return getRuleContext(Rule_listContext.class,0); + } + public GoalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_goal; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof GrammarListener ) ((GrammarListener)listener).enterGoal(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof GrammarListener ) ((GrammarListener)listener).exitGoal(this); + } + } + + public final GoalContext goal() throws RecognitionException { + GoalContext _localctx = new GoalContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_goal); + try { + enterOuterAlt(_localctx, 1); + { + setState(16); + match(GRAMMAR); + setState(17); + name(); + setState(18); + match(T__0); + setState(19); + rule_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NameContext extends ParserRuleContext { + public TerminalNode IDENT() { return getToken(GrammarParser.IDENT, 0); } + public NameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof GrammarListener ) ((GrammarListener)listener).enterName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof GrammarListener ) ((GrammarListener)listener).exitName(this); + } + } + + public final NameContext name() throws RecognitionException { + NameContext _localctx = new NameContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_name); + try { + enterOuterAlt(_localctx, 1); + { + setState(21); + match(IDENT); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Rule_listContext extends ParserRuleContext { + public LhsContext lhs() { + return getRuleContext(LhsContext.class,0); + } + public RhsContext rhs() { + return getRuleContext(RhsContext.class,0); + } + public Or_listContext or_list() { + return getRuleContext(Or_listContext.class,0); + } + public Rule_listContext rule_list() { + return getRuleContext(Rule_listContext.class,0); + } + public Rule_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_rule_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof GrammarListener ) ((GrammarListener)listener).enterRule_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof GrammarListener ) ((GrammarListener)listener).exitRule_list(this); + } + } + + public final Rule_listContext rule_list() throws RecognitionException { + Rule_listContext _localctx = new Rule_listContext(_ctx, getState()); + enterRule(_localctx, 4, RULE_rule_list); + try { + setState(31); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IDENT: + enterOuterAlt(_localctx, 1); + { + setState(23); + lhs(); + setState(24); + match(T__1); + setState(25); + rhs(); + setState(26); + or_list(); + setState(27); + match(T__0); + setState(28); + rule_list(); + } + break; + case EOF: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LhsContext extends ParserRuleContext { + public TerminalNode IDENT() { return getToken(GrammarParser.IDENT, 0); } + public LhsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lhs; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof GrammarListener ) ((GrammarListener)listener).enterLhs(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof GrammarListener ) ((GrammarListener)listener).exitLhs(this); + } + } + + public final LhsContext lhs() throws RecognitionException { + LhsContext _localctx = new LhsContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_lhs); + try { + enterOuterAlt(_localctx, 1); + { + setState(33); + match(IDENT); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class RhsContext extends ParserRuleContext { + public Symbol_listContext symbol_list() { + return getRuleContext(Symbol_listContext.class,0); + } + public RhsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_rhs; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof GrammarListener ) ((GrammarListener)listener).enterRhs(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof GrammarListener ) ((GrammarListener)listener).exitRhs(this); + } + } + + public final RhsContext rhs() throws RecognitionException { + RhsContext _localctx = new RhsContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_rhs); + try { + enterOuterAlt(_localctx, 1); + { + setState(35); + symbol_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Or_listContext extends ParserRuleContext { + public RhsContext rhs() { + return getRuleContext(RhsContext.class,0); + } + public Or_listContext or_list() { + return getRuleContext(Or_listContext.class,0); + } + public Or_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_or_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof GrammarListener ) ((GrammarListener)listener).enterOr_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof GrammarListener ) ((GrammarListener)listener).exitOr_list(this); + } + } + + public final Or_listContext or_list() throws RecognitionException { + Or_listContext _localctx = new Or_listContext(_ctx, getState()); + enterRule(_localctx, 10, RULE_or_list); + try { + setState(42); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__2: + enterOuterAlt(_localctx, 1); + { + setState(37); + match(T__2); + setState(38); + rhs(); + setState(39); + or_list(); + } + break; + case T__0: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Symbol_listContext extends ParserRuleContext { + public SymbolContext symbol() { + return getRuleContext(SymbolContext.class,0); + } + public Symbol_listContext symbol_list() { + return getRuleContext(Symbol_listContext.class,0); + } + public Symbol_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_symbol_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof GrammarListener ) ((GrammarListener)listener).enterSymbol_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof GrammarListener ) ((GrammarListener)listener).exitSymbol_list(this); + } + } + + public final Symbol_listContext symbol_list() throws RecognitionException { + Symbol_listContext _localctx = new Symbol_listContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_symbol_list); + try { + setState(48); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IDENT: + enterOuterAlt(_localctx, 1); + { + setState(44); + symbol(); + setState(45); + symbol_list(); + } + break; + case T__0: + case T__2: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SymbolContext extends ParserRuleContext { + public TerminalNode IDENT() { return getToken(GrammarParser.IDENT, 0); } + public SymbolContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_symbol; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof GrammarListener ) ((GrammarListener)listener).enterSymbol(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof GrammarListener ) ((GrammarListener)listener).exitSymbol(this); + } + } + + public final SymbolContext symbol() throws RecognitionException { + SymbolContext _localctx = new SymbolContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_symbol); + try { + enterOuterAlt(_localctx, 1); + { + setState(50); + match(IDENT); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static final String _serializedATN = + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\t\67\4\2\t\2\4\3"+ + "\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\3\2\3\2\3\2\3\2\3"+ + "\2\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\5\4\"\n\4\3\5\3\5\3\6\3\6\3"+ + "\7\3\7\3\7\3\7\3\7\5\7-\n\7\3\b\3\b\3\b\3\b\5\b\63\n\b\3\t\3\t\3\t\2\2"+ + "\n\2\4\6\b\n\f\16\20\2\2\2\61\2\22\3\2\2\2\4\27\3\2\2\2\6!\3\2\2\2\b#"+ + "\3\2\2\2\n%\3\2\2\2\f,\3\2\2\2\16\62\3\2\2\2\20\64\3\2\2\2\22\23\7\6\2"+ + "\2\23\24\5\4\3\2\24\25\7\3\2\2\25\26\5\6\4\2\26\3\3\2\2\2\27\30\7\7\2"+ + "\2\30\5\3\2\2\2\31\32\5\b\5\2\32\33\7\4\2\2\33\34\5\n\6\2\34\35\5\f\7"+ + "\2\35\36\7\3\2\2\36\37\5\6\4\2\37\"\3\2\2\2 \"\3\2\2\2!\31\3\2\2\2! \3"+ + "\2\2\2\"\7\3\2\2\2#$\7\7\2\2$\t\3\2\2\2%&\5\16\b\2&\13\3\2\2\2\'(\7\5"+ + "\2\2()\5\n\6\2)*\5\f\7\2*-\3\2\2\2+-\3\2\2\2,\'\3\2\2\2,+\3\2\2\2-\r\3"+ + "\2\2\2./\5\20\t\2/\60\5\16\b\2\60\63\3\2\2\2\61\63\3\2\2\2\62.\3\2\2\2"+ + "\62\61\3\2\2\2\63\17\3\2\2\2\64\65\7\7\2\2\65\21\3\2\2\2\5!,\62"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +}
\ No newline at end of file |