ExprParser source code

1 // Generated from doc/examples/simple_expression/Expr.g4 by ANTLR 4.9.2
2 module ExprParser;
3 
4 import antlr.v4.runtime.atn.ATN : ATN;
5 alias ATNType = ATN;
6 import antlr.v4.runtime.atn.ATNDeserializer;
7 import antlr.v4.runtime.atn.PredictionContextCache;
8 import antlr.v4.runtime.atn.PredictionModeConst;
9 import antlr.v4.runtime.atn.ParserATNSimulator;
10 import antlr.v4.runtime.atn.InterfaceParserATNSimulator;
11 import antlr.v4.runtime.dfa.DFA;
12 import antlr.v4.runtime.BailErrorStrategy;
13 import antlr.v4.runtime.RuntimeMetaData;
14 import antlr.v4.runtime.Parser;
15 import antlr.v4.runtime.Token;
16 import antlr.v4.runtime.CommonToken;
17 import antlr.v4.runtime.TokenConstantDefinition;
18 import antlr.v4.runtime.ParserRuleContext;
19 import antlr.v4.runtime.InterfaceRuleContext;
20 import antlr.v4.runtime.LexerNoViableAltException;
21 import antlr.v4.runtime.FailedPredicateException;
22 import antlr.v4.runtime.NoViableAltException;
23 import antlr.v4.runtime.RecognitionException;
24 import antlr.v4.runtime.Vocabulary;
25 import antlr.v4.runtime.VocabularyImpl;
26 import antlr.v4.runtime.TokenStream;
27 import antlr.v4.runtime.tree.ParseTreeListener;
28 import antlr.v4.runtime.tree.ParseTreeVisitor;
29 import antlr.v4.runtime.tree.TerminalNode;
30 import antlr.v4.runtime.tree.ParseTreeWalker;
31 import ExprListener : ExprListener;
32 import ExprVisitor : ExprVisitor;
33 import std.conv : to;
34 import std.variant : Variant;
35 
36 public class ExprParser : Parser {
37     static this() { RuntimeMetaData.checkVersion("4.9.2", RuntimeMetaData.VERSION); }
38 
39     protected static DFA[] _decisionToDFA;
40     protected PredictionContextCache _sharedContextCache =
41         new PredictionContextCache();
42     public enum int
43         T__0=1,T__1=2,T__2=3,T__3=4,T__4=5,T__5=6,NEWLINE=7,INT=8;
44     public enum int
45         RULE_prog = 0,RULE_expr = 1;
46     public static const string[] ruleNames = [
47         "prog","expr"
48     ];
49 
50     private static const string[] _LITERAL_NAMES = [
51         null,"'/'","'*'","'-'","'+'","'('","')'"
52     ];
53     private static const string[] _SYMBOLIC_NAMES = [
54         null,null,null,null,null,null,null,"NEWLINE","INT"
55     ];
56     public static Vocabulary VOCABULARY;
57 
58     /**
59      * @deprecated Use {@link #VOCABULARY} instead.
60      */
61     public static string[_SYMBOLIC_NAMES.length] tokenNames;
62 
63     static this() {
64         VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
65         int index = 0;
66         foreach (ref tokenName; tokenNames)
67             {
68                 tokenName = VOCABULARY.getLiteralName(index);
69                     if (!tokenName) {
70                         tokenName = VOCABULARY.getSymbolicName(index);
71                 }
72                 if (!tokenName)
73                 {
74                     tokenName = "<INVALID>";
75                 }
76             }
77             ++index;
78     }
79 
80     override public string[] getTokenNames() {
81         return tokenNames;
82     }
83 
84     override public Vocabulary getVocabulary() {
85         return VOCABULARY;
86     }
87 
88     override
89     public string getGrammarFileName() { return "Expr.g4"; }
90 
91     override
92     public string[] getRuleNames() { return ruleNames.dup; }
93 
94     override
95     public wstring getSerializedATN() { return _serializedATN; }
96 
97     override
98     public ATNType getATN() { return _ATN; }
99 
100     public this(TokenStream input) {
101         super(input);
102         _interp = new ParserATNSimulator(this,_ATN, _decisionToDFA, _sharedContextCache);
103     }
104 
105     public static class ProgContext : ParserRuleContext {
106         public ExprContext[] expr() {
107             return getRuleContexts!ExprContext;
108         }
109         public ExprContext expr(int i) {
110             return getRuleContext!ExprContext(i);
111         }
112         public TerminalNode[] NEWLINE() { return getTokens(ExprParser.NEWLINE); }
113         public TerminalNode NEWLINE(int i) {
114             return getToken(ExprParser.NEWLINE, i);
115         }
116         public this(ParserRuleContext parent, int invokingState) {
117             super(parent, invokingState);
118         }
119         override public size_t getRuleIndex() { return RULE_prog; }
120         override
121         public void enterRule(ParseTreeListener listener) {
122             if (cast(ExprListener) listener)
123                 (cast(ExprListener) listener).enterProg(this);
124         }
125         override
126         public void exitRule(ParseTreeListener listener) {
127             if (cast(ExprListener) listener)
128                 (cast(ExprListener) listener).exitProg(this);
129         }
130         override
131         public Variant accept(ParseTreeVisitor visitor) {
132             if (cast(ExprVisitor) visitor)
133                 return (cast(ExprVisitor) visitor).visitProg(this);
134             else
135                 return visitor.visitChildren(this);
136         }
137     }
138 
139     public ProgContext prog() {
140         ProgContext _localctx = new ProgContext(ctx_, getState());
141         enterRule(_localctx, 0, RULE_prog);
142         int _la;
143         try {
144             enterOuterAlt(_localctx, 1);
145             {
146             setState(9);
147             _errHandler.sync(this);
148             _la = _input.LA(1);
149             while (_la==T__4 || _la==INT) {
150                 {
151                 {
152                 setState(4);
153                 expr(0);
154                 setState(5);
155                 match(NEWLINE);
156                 }
157                 }
158                 setState(11);
159                 _errHandler.sync(this);
160                 _la = _input.LA(1);
161             }
162             }
163         }
164         catch (RecognitionException re) {
165             _localctx.exception = re;
166             _errHandler.reportError(this, re);
167             _errHandler.recover(this, re);
168         }
169         finally {
170             exitRule();
171         }
172         return _localctx;
173     }
174 
175     public static class ExprContext : ParserRuleContext {
176         public this(ParserRuleContext parent, int invokingState) {
177             super(parent, invokingState);
178         }
179         override public size_t getRuleIndex() { return RULE_expr; }
180      
181         public this() { }
182             alias copyFrom = ParserRuleContext.copyFrom;
183         public void copyFrom(ExprContext ctx) {
184             super.copyFrom(ctx);
185         }
186     }
187     public static class DivContext : ExprContext {
188         public ExprContext[] expr() {
189             return getRuleContexts!ExprContext;
190         }
191         public ExprContext expr(int i) {
192             return getRuleContext!ExprContext(i);
193         }
194             alias copyFrom = ExprContext.copyFrom;
195         public this(ExprContext ctx) { copyFrom(ctx); }
196         override
197         public void enterRule(ParseTreeListener listener) {
198             if (cast(ExprListener) listener)
199                 (cast(ExprListener) listener).enterDiv(this);
200         }
201         override
202         public void exitRule(ParseTreeListener listener) {
203             if (cast(ExprListener) listener)
204                 (cast(ExprListener) listener).exitDiv(this);
205         }
206         override
207         public Variant accept(ParseTreeVisitor visitor) {
208             if (cast(ExprVisitor) visitor)
209                 return (cast(ExprVisitor) visitor).visitDiv(this);
210             else
211                 return visitor.visitChildren(this);
212         }
213     }
214     public static class AddContext : ExprContext {
215         public ExprContext[] expr() {
216             return getRuleContexts!ExprContext;
217         }
218         public ExprContext expr(int i) {
219             return getRuleContext!ExprContext(i);
220         }
221             alias copyFrom = ExprContext.copyFrom;
222         public this(ExprContext ctx) { copyFrom(ctx); }
223         override
224         public void enterRule(ParseTreeListener listener) {
225             if (cast(ExprListener) listener)
226                 (cast(ExprListener) listener).enterAdd(this);
227         }
228         override
229         public void exitRule(ParseTreeListener listener) {
230             if (cast(ExprListener) listener)
231                 (cast(ExprListener) listener).exitAdd(this);
232         }
233         override
234         public Variant accept(ParseTreeVisitor visitor) {
235             if (cast(ExprVisitor) visitor)
236                 return (cast(ExprVisitor) visitor).visitAdd(this);
237             else
238                 return visitor.visitChildren(this);
239         }
240     }
241     public static class SubContext : ExprContext {
242         public ExprContext[] expr() {
243             return getRuleContexts!ExprContext;
244         }
245         public ExprContext expr(int i) {
246             return getRuleContext!ExprContext(i);
247         }
248             alias copyFrom = ExprContext.copyFrom;
249         public this(ExprContext ctx) { copyFrom(ctx); }
250         override
251         public void enterRule(ParseTreeListener listener) {
252             if (cast(ExprListener) listener)
253                 (cast(ExprListener) listener).enterSub(this);
254         }
255         override
256         public void exitRule(ParseTreeListener listener) {
257             if (cast(ExprListener) listener)
258                 (cast(ExprListener) listener).exitSub(this);
259         }
260         override
261         public Variant accept(ParseTreeVisitor visitor) {
262             if (cast(ExprVisitor) visitor)
263                 return (cast(ExprVisitor) visitor).visitSub(this);
264             else
265                 return visitor.visitChildren(this);
266         }
267     }
268     public static class MulContext : ExprContext {
269         public ExprContext[] expr() {
270             return getRuleContexts!ExprContext;
271         }
272         public ExprContext expr(int i) {
273             return getRuleContext!ExprContext(i);
274         }
275             alias copyFrom = ExprContext.copyFrom;
276         public this(ExprContext ctx) { copyFrom(ctx); }
277         override
278         public void enterRule(ParseTreeListener listener) {
279             if (cast(ExprListener) listener)
280                 (cast(ExprListener) listener).enterMul(this);
281         }
282         override
283         public void exitRule(ParseTreeListener listener) {
284             if (cast(ExprListener) listener)
285                 (cast(ExprListener) listener).exitMul(this);
286         }
287         override
288         public Variant accept(ParseTreeVisitor visitor) {
289             if (cast(ExprVisitor) visitor)
290                 return (cast(ExprVisitor) visitor).visitMul(this);
291             else
292                 return visitor.visitChildren(this);
293         }
294     }
295     public static class BracketExprContext : ExprContext {
296         public ExprContext expr() {
297             return getRuleContext!ExprContext(0);
298         }
299             alias copyFrom = ExprContext.copyFrom;
300         public this(ExprContext ctx) { copyFrom(ctx); }
301         override
302         public void enterRule(ParseTreeListener listener) {
303             if (cast(ExprListener) listener)
304                 (cast(ExprListener) listener).enterBracketExpr(this);
305         }
306         override
307         public void exitRule(ParseTreeListener listener) {
308             if (cast(ExprListener) listener)
309                 (cast(ExprListener) listener).exitBracketExpr(this);
310         }
311         override
312         public Variant accept(ParseTreeVisitor visitor) {
313             if (cast(ExprVisitor) visitor)
314                 return (cast(ExprVisitor) visitor).visitBracketExpr(this);
315             else
316                 return visitor.visitChildren(this);
317         }
318     }
319     public static class IntContext : ExprContext {
320         public TerminalNode INT() { return getToken(ExprParser.INT, 0); }
321             alias copyFrom = ExprContext.copyFrom;
322         public this(ExprContext ctx) { copyFrom(ctx); }
323         override
324         public void enterRule(ParseTreeListener listener) {
325             if (cast(ExprListener) listener)
326                 (cast(ExprListener) listener).enterInt(this);
327         }
328         override
329         public void exitRule(ParseTreeListener listener) {
330             if (cast(ExprListener) listener)
331                 (cast(ExprListener) listener).exitInt(this);
332         }
333         override
334         public Variant accept(ParseTreeVisitor visitor) {
335             if (cast(ExprVisitor) visitor)
336                 return (cast(ExprVisitor) visitor).visitInt(this);
337             else
338                 return visitor.visitChildren(this);
339         }
340     }
341 
342     public ExprContext expr() {
343         return expr(0);
344     }
345 
346     private ExprContext expr(int _p) {
347         ParserRuleContext _parentctx = ctx_;
348         int _parentState = getState();
349         ExprContext _localctx = new ExprContext(ctx_, _parentState);
350         ExprContext _prevctx = _localctx;
351         int _startState = 2;
352         enterRecursionRule(_localctx, 2, RULE_expr, _p);
353         try {
354             int _alt;
355             enterOuterAlt(_localctx, 1);
356             {
357             setState(18);
358             _errHandler.sync(this);
359             switch (_input.LA(1)) {
360             case INT:
361                 {
362                 _localctx = new IntContext(_localctx);
363                 ctx_ = _localctx;
364                 _prevctx = _localctx;
365 
366                 setState(13);
367                 match(INT);
368                 }
369                 break;
370             case T__4:
371                 {
372                 _localctx = new BracketExprContext(_localctx);
373                 ctx_ = _localctx;
374                 _prevctx = _localctx;
375                 setState(14);
376                 match(T__4);
377                 setState(15);
378                 expr(0);
379                 setState(16);
380                 match(T__5);
381                 }
382                 break;
383             default:
384                 throw new NoViableAltException(this);
385             }
386             ctx_.stop = _input.LT(-1);
387             setState(34);
388             _errHandler.sync(this);
389             _alt = getInterpreter.adaptivePredict(_input,3, ctx_);
390             while ( _alt!=2 && _alt!=ATNType.INVALID_ALT_NUMBER ) {
391                 if ( _alt==1 ) {
392                     if (_parseListeners) triggerExitRuleEvent();
393                     _prevctx = _localctx;
394                     {
395                     setState(32);
396                     _errHandler.sync(this);
397                     switch ( getInterpreter.adaptivePredict(_input,2, ctx_) ) {
398                     case 1:
399                         {
400                         _localctx = new DivContext(new ExprContext(_parentctx, _parentState));
401                         pushNewRecursionContext(_localctx, _startState, RULE_expr);
402                         setState(20);
403                         if (!(precpred(ctx_, 6))) throw new FailedPredicateException(this, "precpred(ctx_, 6)");
404                         setState(21);
405                         match(T__0);
406                         setState(22);
407                         expr(7);
408                         }
409                         break;
410                     case 2:
411                         {
412                         _localctx = new MulContext(new ExprContext(_parentctx, _parentState));
413                         pushNewRecursionContext(_localctx, _startState, RULE_expr);
414                         setState(23);
415                         if (!(precpred(ctx_, 5))) throw new FailedPredicateException(this, "precpred(ctx_, 5)");
416                         setState(24);
417                         match(T__1);
418                         setState(25);
419                         expr(6);
420                         }
421                         break;
422                     case 3:
423                         {
424                         _localctx = new SubContext(new ExprContext(_parentctx, _parentState));
425                         pushNewRecursionContext(_localctx, _startState, RULE_expr);
426                         setState(26);
427                         if (!(precpred(ctx_, 4))) throw new FailedPredicateException(this, "precpred(ctx_, 4)");
428                         setState(27);
429                         match(T__2);
430                         setState(28);
431                         expr(5);
432                         }
433                         break;
434                     case 4:
435                         {
436                         _localctx = new AddContext(new ExprContext(_parentctx, _parentState));
437                         pushNewRecursionContext(_localctx, _startState, RULE_expr);
438                         setState(29);
439                         if (!(precpred(ctx_, 3))) throw new FailedPredicateException(this, "precpred(ctx_, 3)");
440                         setState(30);
441                         match(T__3);
442                         setState(31);
443                         expr(4);
444                         }
445                         break;
446                             default: {}
447                     }
448                     } 
449                 }
450                 setState(36);
451                 _errHandler.sync(this);
452                 _alt = getInterpreter.adaptivePredict(_input,3, ctx_);
453             }
454             }
455         }
456         catch (RecognitionException re) {
457             _localctx.exception = re;
458             _errHandler.reportError(this, re);
459             _errHandler.recover(this, re);
460         }
461         finally {
462             unrollRecursionContexts(_parentctx);
463         }
464         return _localctx;
465     }
466 
467     override
468     public bool sempred(InterfaceRuleContext _localctx, int ruleIndex, int predIndex) {
469         switch (ruleIndex) {
470         case 1:
471             return expr_sempred(cast(ExprContext)_localctx, predIndex);
472     default: {}
473     }
474     return true;
475 }
476     private bool expr_sempred(ExprContext _localctx, int predIndex) {
477         switch (predIndex) {
478         case 0:
479             return precpred(ctx_, 6);
480         case 1:
481             return precpred(ctx_, 5);
482         case 2:
483             return precpred(ctx_, 4);
484         case 3:
485             return precpred(ctx_, 3);
486             default: {}
487         }
488         return true;
489     }
490 
491     public static immutable wstring _serializedATN =
492         "\x03\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\x03\n(\x04"~
493     	"\x02\t\x02\x04\x03\t\x03\x03\x02\x03\x02\x03\x02\x07\x02\n\n\x02\f"~
494     	"\x02\x0e\x02\r\x0b\x02\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03"~
495     	"\x03\x05\x03\x15\n\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03"~
496     	"\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x07\x03#\n\x03"~
497     	"\f\x03\x0e\x03&\x0b\x03\x03\x03\x02\x03\x04\x04\x02\x04\x02\x02\x02"~
498     	"+\x02\x0b\x03\x02\x02\x02\x04\x14\x03\x02\x02\x02\x06\x07\x05\x04\x03"~
499     	"\x02\x07\b\x07\t\x02\x02\b\n\x03\x02\x02\x02\t\x06\x03\x02\x02\x02"~
500     	"\n\r\x03\x02\x02\x02\x0b\t\x03\x02\x02\x02\x0b\f\x03\x02\x02\x02\f"~
501     	"\x03\x03\x02\x02\x02\r\x0b\x03\x02\x02\x02\x0e\x0f\b\x03\x01\x02\x0f"~
502     	"\x15\x07\n\x02\x02\x10\x11\x07\x07\x02\x02\x11\x12\x05\x04\x03\x02"~
503     	"\x12\x13\x07\b\x02\x02\x13\x15\x03\x02\x02\x02\x14\x0e\x03\x02\x02"~
504     	"\x02\x14\x10\x03\x02\x02\x02\x15$\x03\x02\x02\x02\x16\x17\f\b\x02\x02"~
505     	"\x17\x18\x07\x03\x02\x02\x18#\x05\x04\x03\t\x19\x1a\f\x07\x02\x02\x1a"~
506     	"\x1b\x07\x04\x02\x02\x1b#\x05\x04\x03\b\x1c\x1d\f\x06\x02\x02\x1d\x1e"~
507     	"\x07\x05\x02\x02\x1e#\x05\x04\x03\x07\x1f \f\x05\x02\x02 !\x07\x06"~
508     	"\x02\x02!#\x05\x04\x03\x06\"\x16\x03\x02\x02\x02\"\x19\x03\x02\x02"~
509     	"\x02\"\x1c\x03\x02\x02\x02\"\x1f\x03\x02\x02\x02#&\x03\x02\x02\x02"~
510     	"$\"\x03\x02\x02\x02$%\x03\x02\x02\x02%\x05\x03\x02\x02\x02&$\x03\x02"~
511     	"\x02\x02\x06\x0b\x14\"$";
512     public static ATNType _ATN;
513 
514     static this() {
515         auto atnDeserializer = new ATNDeserializer;
516         _ATN = atnDeserializer.deserialize(_serializedATN);
517         _decisionToDFA.length = 0;
518         for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
519             _decisionToDFA ~= new DFA(_ATN.getDecisionState(i), i);
520         }
521     }
522 }