001 // Generated from com/khubla/pragmatach/framework/uri/antlr4/RouteSpecification.g4 by ANTLR 4.1
002 package com.khubla.pragmatach.framework.uri.antlr4;
003 import org.antlr.v4.runtime.atn.*;
004 import org.antlr.v4.runtime.dfa.DFA;
005 import org.antlr.v4.runtime.*;
006 import org.antlr.v4.runtime.misc.*;
007 import org.antlr.v4.runtime.tree.*;
008 import java.util.List;
009 import java.util.Iterator;
010 import java.util.ArrayList;
011
012 @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
013 public class RouteSpecificationParser extends Parser {
014 protected static final DFA[] _decisionToDFA;
015 protected static final PredictionContextCache _sharedContextCache =
016 new PredictionContextCache();
017 public static final int
018 T__0=1, ALPHANUM=2, AMPER=3;
019 public static final String[] tokenNames = {
020 "<INVALID>", "'/'", "ALPHANUM", "'@'"
021 };
022 public static final int
023 RULE_routespecification = 0, RULE_segment = 1, RULE_idsegment = 2, RULE_pathsegment = 3,
024 RULE_id = 4;
025 public static final String[] ruleNames = {
026 "routespecification", "segment", "idsegment", "pathsegment", "id"
027 };
028
029 @Override
030 public String getGrammarFileName() { return "RouteSpecification.g4"; }
031
032 @Override
033 public String[] getTokenNames() { return tokenNames; }
034
035 @Override
036 public String[] getRuleNames() { return ruleNames; }
037
038 @Override
039 public ATN getATN() { return _ATN; }
040
041 public RouteSpecificationParser(TokenStream input) {
042 super(input);
043 _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
044 }
045 public static class RoutespecificationContext extends ParserRuleContext {
046 public List<SegmentContext> segment() {
047 return getRuleContexts(SegmentContext.class);
048 }
049 public SegmentContext segment(int i) {
050 return getRuleContext(SegmentContext.class,i);
051 }
052 public RoutespecificationContext(ParserRuleContext parent, int invokingState) {
053 super(parent, invokingState);
054 }
055 @Override public int getRuleIndex() { return RULE_routespecification; }
056 @Override
057 public void enterRule(ParseTreeListener listener) {
058 if ( listener instanceof RouteSpecificationListener ) ((RouteSpecificationListener)listener).enterRoutespecification(this);
059 }
060 @Override
061 public void exitRule(ParseTreeListener listener) {
062 if ( listener instanceof RouteSpecificationListener ) ((RouteSpecificationListener)listener).exitRoutespecification(this);
063 }
064 }
065
066 public final RoutespecificationContext routespecification() throws RecognitionException {
067 RoutespecificationContext _localctx = new RoutespecificationContext(_ctx, getState());
068 enterRule(_localctx, 0, RULE_routespecification);
069 int _la;
070 try {
071 enterOuterAlt(_localctx, 1);
072 {
073 setState(14);
074 _errHandler.sync(this);
075 _la = _input.LA(1);
076 do {
077 {
078 {
079 setState(10); match(1);
080 setState(12);
081 _la = _input.LA(1);
082 if (_la==ALPHANUM || _la==AMPER) {
083 {
084 setState(11); segment();
085 }
086 }
087
088 }
089 }
090 setState(16);
091 _errHandler.sync(this);
092 _la = _input.LA(1);
093 } while ( _la==1 );
094 }
095 }
096 catch (RecognitionException re) {
097 _localctx.exception = re;
098 _errHandler.reportError(this, re);
099 _errHandler.recover(this, re);
100 }
101 finally {
102 exitRule();
103 }
104 return _localctx;
105 }
106
107 public static class SegmentContext extends ParserRuleContext {
108 public PathsegmentContext pathsegment() {
109 return getRuleContext(PathsegmentContext.class,0);
110 }
111 public IdsegmentContext idsegment() {
112 return getRuleContext(IdsegmentContext.class,0);
113 }
114 public SegmentContext(ParserRuleContext parent, int invokingState) {
115 super(parent, invokingState);
116 }
117 @Override public int getRuleIndex() { return RULE_segment; }
118 @Override
119 public void enterRule(ParseTreeListener listener) {
120 if ( listener instanceof RouteSpecificationListener ) ((RouteSpecificationListener)listener).enterSegment(this);
121 }
122 @Override
123 public void exitRule(ParseTreeListener listener) {
124 if ( listener instanceof RouteSpecificationListener ) ((RouteSpecificationListener)listener).exitSegment(this);
125 }
126 }
127
128 public final SegmentContext segment() throws RecognitionException {
129 SegmentContext _localctx = new SegmentContext(_ctx, getState());
130 enterRule(_localctx, 2, RULE_segment);
131 try {
132 setState(20);
133 switch (_input.LA(1)) {
134 case ALPHANUM:
135 enterOuterAlt(_localctx, 1);
136 {
137 setState(18); pathsegment();
138 }
139 break;
140 case AMPER:
141 enterOuterAlt(_localctx, 2);
142 {
143 setState(19); idsegment();
144 }
145 break;
146 default:
147 throw new NoViableAltException(this);
148 }
149 }
150 catch (RecognitionException re) {
151 _localctx.exception = re;
152 _errHandler.reportError(this, re);
153 _errHandler.recover(this, re);
154 }
155 finally {
156 exitRule();
157 }
158 return _localctx;
159 }
160
161 public static class IdsegmentContext extends ParserRuleContext {
162 public IdContext id() {
163 return getRuleContext(IdContext.class,0);
164 }
165 public TerminalNode AMPER() { return getToken(RouteSpecificationParser.AMPER, 0); }
166 public IdsegmentContext(ParserRuleContext parent, int invokingState) {
167 super(parent, invokingState);
168 }
169 @Override public int getRuleIndex() { return RULE_idsegment; }
170 @Override
171 public void enterRule(ParseTreeListener listener) {
172 if ( listener instanceof RouteSpecificationListener ) ((RouteSpecificationListener)listener).enterIdsegment(this);
173 }
174 @Override
175 public void exitRule(ParseTreeListener listener) {
176 if ( listener instanceof RouteSpecificationListener ) ((RouteSpecificationListener)listener).exitIdsegment(this);
177 }
178 }
179
180 public final IdsegmentContext idsegment() throws RecognitionException {
181 IdsegmentContext _localctx = new IdsegmentContext(_ctx, getState());
182 enterRule(_localctx, 4, RULE_idsegment);
183 try {
184 enterOuterAlt(_localctx, 1);
185 {
186 setState(22); match(AMPER);
187 setState(23); id();
188 }
189 }
190 catch (RecognitionException re) {
191 _localctx.exception = re;
192 _errHandler.reportError(this, re);
193 _errHandler.recover(this, re);
194 }
195 finally {
196 exitRule();
197 }
198 return _localctx;
199 }
200
201 public static class PathsegmentContext extends ParserRuleContext {
202 public TerminalNode ALPHANUM() { return getToken(RouteSpecificationParser.ALPHANUM, 0); }
203 public PathsegmentContext(ParserRuleContext parent, int invokingState) {
204 super(parent, invokingState);
205 }
206 @Override public int getRuleIndex() { return RULE_pathsegment; }
207 @Override
208 public void enterRule(ParseTreeListener listener) {
209 if ( listener instanceof RouteSpecificationListener ) ((RouteSpecificationListener)listener).enterPathsegment(this);
210 }
211 @Override
212 public void exitRule(ParseTreeListener listener) {
213 if ( listener instanceof RouteSpecificationListener ) ((RouteSpecificationListener)listener).exitPathsegment(this);
214 }
215 }
216
217 public final PathsegmentContext pathsegment() throws RecognitionException {
218 PathsegmentContext _localctx = new PathsegmentContext(_ctx, getState());
219 enterRule(_localctx, 6, RULE_pathsegment);
220 try {
221 enterOuterAlt(_localctx, 1);
222 {
223 setState(25); match(ALPHANUM);
224 }
225 }
226 catch (RecognitionException re) {
227 _localctx.exception = re;
228 _errHandler.reportError(this, re);
229 _errHandler.recover(this, re);
230 }
231 finally {
232 exitRule();
233 }
234 return _localctx;
235 }
236
237 public static class IdContext extends ParserRuleContext {
238 public TerminalNode ALPHANUM() { return getToken(RouteSpecificationParser.ALPHANUM, 0); }
239 public IdContext(ParserRuleContext parent, int invokingState) {
240 super(parent, invokingState);
241 }
242 @Override public int getRuleIndex() { return RULE_id; }
243 @Override
244 public void enterRule(ParseTreeListener listener) {
245 if ( listener instanceof RouteSpecificationListener ) ((RouteSpecificationListener)listener).enterId(this);
246 }
247 @Override
248 public void exitRule(ParseTreeListener listener) {
249 if ( listener instanceof RouteSpecificationListener ) ((RouteSpecificationListener)listener).exitId(this);
250 }
251 }
252
253 public final IdContext id() throws RecognitionException {
254 IdContext _localctx = new IdContext(_ctx, getState());
255 enterRule(_localctx, 8, RULE_id);
256 try {
257 enterOuterAlt(_localctx, 1);
258 {
259 setState(27); match(ALPHANUM);
260 }
261 }
262 catch (RecognitionException re) {
263 _localctx.exception = re;
264 _errHandler.reportError(this, re);
265 _errHandler.recover(this, re);
266 }
267 finally {
268 exitRule();
269 }
270 return _localctx;
271 }
272
273 public static final String _serializedATN =
274 "\3\uacf5\uee8c\u4f5d\u8b0d\u4a45\u78bd\u1b2f\u3378\3\5 \4\2\t\2\4\3\t"+
275 "\3\4\4\t\4\4\5\t\5\4\6\t\6\3\2\3\2\5\2\17\n\2\6\2\21\n\2\r\2\16\2\22\3"+
276 "\3\3\3\5\3\27\n\3\3\4\3\4\3\4\3\5\3\5\3\6\3\6\3\6\2\7\2\4\6\b\n\2\2\35"+
277 "\2\20\3\2\2\2\4\26\3\2\2\2\6\30\3\2\2\2\b\33\3\2\2\2\n\35\3\2\2\2\f\16"+
278 "\7\3\2\2\r\17\5\4\3\2\16\r\3\2\2\2\16\17\3\2\2\2\17\21\3\2\2\2\20\f\3"+
279 "\2\2\2\21\22\3\2\2\2\22\20\3\2\2\2\22\23\3\2\2\2\23\3\3\2\2\2\24\27\5"+
280 "\b\5\2\25\27\5\6\4\2\26\24\3\2\2\2\26\25\3\2\2\2\27\5\3\2\2\2\30\31\7"+
281 "\5\2\2\31\32\5\n\6\2\32\7\3\2\2\2\33\34\7\4\2\2\34\t\3\2\2\2\35\36\7\4"+
282 "\2\2\36\13\3\2\2\2\5\16\22\26";
283 public static final ATN _ATN =
284 ATNSimulator.deserialize(_serializedATN.toCharArray());
285 static {
286 _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
287 for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
288 _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
289 }
290 }
291 }