Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
caustic.grammar.CausticParser Maven / Gradle / Ivy
// Generated from caustic-compiler/src/main/antlr/Caustic.g4 by ANTLR 4.7
package caustic.grammar;
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 CausticParser extends Parser {
static { RuntimeMetaData.checkVersion("4.7", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
Def=1, Del=2, Elif=3, Else=4, False=5, If=6, Import=7, Module=8, Null=9,
Rollback=10, Service=11, Struct=12, While=13, True=14, Var=15, Add=16,
AddAssign=17, Ampersand=18, And=19, Arrow=20, Assign=21, Colon=22, Comma=23,
Div=24, DivAssign=25, Equal=26, GreaterEqual=27, GreaterThan=28, LeftBlock=29,
LeftBracket=30, LeftParen=31, LessEqual=32, LessThan=33, Mod=34, ModAssign=35,
Mul=36, MulAssign=37, Not=38, NotEqual=39, Or=40, Period=41, Question=42,
RightBlock=43, RightBracket=44, RightParen=45, Semicolon=46, Sub=47, SubAssign=48,
Underscore=49, Number=50, Identifier=51, String=52, BlockComment=53, LineComment=54,
Whitespace=55;
public static final int
RULE_comment = 0, RULE_constant = 1, RULE_name = 2, RULE_funcall = 3,
RULE_primaryExpression = 4, RULE_prefixExpression = 5, RULE_multiplicativeExpression = 6,
RULE_additiveExpression = 7, RULE_relationalExpression = 8, RULE_equalityExpression = 9,
RULE_logicalAndExpression = 10, RULE_logicalOrExpression = 11, RULE_expression = 12,
RULE_conditional = 13, RULE_loop = 14, RULE_deletion = 15, RULE_definition = 16,
RULE_assignment = 17, RULE_rollback = 18, RULE_statement = 19, RULE_block = 20,
RULE_type = 21, RULE_parameter = 22, RULE_parameters = 23, RULE_function = 24,
RULE_service = 25, RULE_struct = 26, RULE_declaration = 27, RULE_module = 28,
RULE_include = 29, RULE_program = 30;
public static final String[] ruleNames = {
"comment", "constant", "name", "funcall", "primaryExpression", "prefixExpression",
"multiplicativeExpression", "additiveExpression", "relationalExpression",
"equalityExpression", "logicalAndExpression", "logicalOrExpression", "expression",
"conditional", "loop", "deletion", "definition", "assignment", "rollback",
"statement", "block", "type", "parameter", "parameters", "function", "service",
"struct", "declaration", "module", "include", "program"
};
private static final String[] _LITERAL_NAMES = {
null, "'def'", "'del'", "'elif'", "'else'", "'false'", "'if'", "'import'",
"'module'", "'null'", "'rollback'", "'service'", "'struct'", "'while'",
"'true'", "'var'", "'+'", "'+='", "'&'", "'&&'", "'=>'", "'='", "':'",
"','", "'/'", "'/='", "'=='", "'>='", "'>'", "'['", "'{'", "'('", "'<='",
"'<'", "'%'", "'%='", "'*'", "'*='", "'!'", "'!='", "'||'", "'.'", "'?'",
"']'", "'}'", "')'", "';'", "'-'", "'-='", "'_'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, "Def", "Del", "Elif", "Else", "False", "If", "Import", "Module",
"Null", "Rollback", "Service", "Struct", "While", "True", "Var", "Add",
"AddAssign", "Ampersand", "And", "Arrow", "Assign", "Colon", "Comma",
"Div", "DivAssign", "Equal", "GreaterEqual", "GreaterThan", "LeftBlock",
"LeftBracket", "LeftParen", "LessEqual", "LessThan", "Mod", "ModAssign",
"Mul", "MulAssign", "Not", "NotEqual", "Or", "Period", "Question", "RightBlock",
"RightBracket", "RightParen", "Semicolon", "Sub", "SubAssign", "Underscore",
"Number", "Identifier", "String", "BlockComment", "LineComment", "Whitespace"
};
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] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "Caustic.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public CausticParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class CommentContext extends ParserRuleContext {
public TerminalNode BlockComment() { return getToken(CausticParser.BlockComment, 0); }
public List LineComment() { return getTokens(CausticParser.LineComment); }
public TerminalNode LineComment(int i) {
return getToken(CausticParser.LineComment, i);
}
public CommentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comment; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterComment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitComment(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitComment(this);
else return visitor.visitChildren(this);
}
}
public final CommentContext comment() throws RecognitionException {
CommentContext _localctx = new CommentContext(_ctx, getState());
enterRule(_localctx, 0, RULE_comment);
try {
int _alt;
setState(68);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BlockComment:
enterOuterAlt(_localctx, 1);
{
setState(62);
match(BlockComment);
}
break;
case LineComment:
enterOuterAlt(_localctx, 2);
{
setState(64);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(63);
match(LineComment);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(66);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
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 ConstantContext extends ParserRuleContext {
public TerminalNode True() { return getToken(CausticParser.True, 0); }
public TerminalNode False() { return getToken(CausticParser.False, 0); }
public TerminalNode Number() { return getToken(CausticParser.Number, 0); }
public TerminalNode String() { return getToken(CausticParser.String, 0); }
public TerminalNode Null() { return getToken(CausticParser.Null, 0); }
public ConstantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constant; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterConstant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitConstant(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitConstant(this);
else return visitor.visitChildren(this);
}
}
public final ConstantContext constant() throws RecognitionException {
ConstantContext _localctx = new ConstantContext(_ctx, getState());
enterRule(_localctx, 2, RULE_constant);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(70);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << False) | (1L << Null) | (1L << True) | (1L << Number) | (1L << String))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
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 List Identifier() { return getTokens(CausticParser.Identifier); }
public TerminalNode Identifier(int i) {
return getToken(CausticParser.Identifier, i);
}
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 CausticListener ) ((CausticListener)listener).enterName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitName(this);
else return visitor.visitChildren(this);
}
}
public final NameContext name() throws RecognitionException {
NameContext _localctx = new NameContext(_ctx, getState());
enterRule(_localctx, 4, RULE_name);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(72);
match(Identifier);
setState(77);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(73);
match(Period);
setState(74);
match(Identifier);
}
}
}
setState(79);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FuncallContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public FuncallContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_funcall; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterFuncall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitFuncall(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitFuncall(this);
else return visitor.visitChildren(this);
}
}
public final FuncallContext funcall() throws RecognitionException {
FuncallContext _localctx = new FuncallContext(_ctx, getState());
enterRule(_localctx, 6, RULE_funcall);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(80);
name();
setState(81);
match(LeftParen);
setState(87);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(82);
expression();
setState(83);
match(Comma);
}
}
}
setState(89);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
}
setState(91);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << False) | (1L << Null) | (1L << True) | (1L << Add) | (1L << LeftParen) | (1L << Not) | (1L << Sub) | (1L << Number) | (1L << Identifier) | (1L << String))) != 0)) {
{
setState(90);
expression();
}
}
setState(93);
match(RightParen);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryExpressionContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public FuncallContext funcall() {
return getRuleContext(FuncallContext.class,0);
}
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public PrimaryExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterPrimaryExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitPrimaryExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitPrimaryExpression(this);
else return visitor.visitChildren(this);
}
}
public final PrimaryExpressionContext primaryExpression() throws RecognitionException {
PrimaryExpressionContext _localctx = new PrimaryExpressionContext(_ctx, getState());
enterRule(_localctx, 8, RULE_primaryExpression);
try {
setState(102);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(95);
name();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(96);
funcall();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(97);
constant();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(98);
match(LeftParen);
setState(99);
expression();
setState(100);
match(RightParen);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrefixExpressionContext extends ParserRuleContext {
public PrimaryExpressionContext primaryExpression() {
return getRuleContext(PrimaryExpressionContext.class,0);
}
public TerminalNode Add() { return getToken(CausticParser.Add, 0); }
public TerminalNode Sub() { return getToken(CausticParser.Sub, 0); }
public TerminalNode Not() { return getToken(CausticParser.Not, 0); }
public PrefixExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_prefixExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterPrefixExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitPrefixExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitPrefixExpression(this);
else return visitor.visitChildren(this);
}
}
public final PrefixExpressionContext prefixExpression() throws RecognitionException {
PrefixExpressionContext _localctx = new PrefixExpressionContext(_ctx, getState());
enterRule(_localctx, 10, RULE_prefixExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(105);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Add) | (1L << Not) | (1L << Sub))) != 0)) {
{
setState(104);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Add) | (1L << Not) | (1L << Sub))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(107);
primaryExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MultiplicativeExpressionContext extends ParserRuleContext {
public PrefixExpressionContext prefixExpression() {
return getRuleContext(PrefixExpressionContext.class,0);
}
public MultiplicativeExpressionContext multiplicativeExpression() {
return getRuleContext(MultiplicativeExpressionContext.class,0);
}
public TerminalNode Mul() { return getToken(CausticParser.Mul, 0); }
public TerminalNode Div() { return getToken(CausticParser.Div, 0); }
public TerminalNode Mod() { return getToken(CausticParser.Mod, 0); }
public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiplicativeExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterMultiplicativeExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitMultiplicativeExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitMultiplicativeExpression(this);
else return visitor.visitChildren(this);
}
}
public final MultiplicativeExpressionContext multiplicativeExpression() throws RecognitionException {
return multiplicativeExpression(0);
}
private MultiplicativeExpressionContext multiplicativeExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
MultiplicativeExpressionContext _localctx = new MultiplicativeExpressionContext(_ctx, _parentState);
MultiplicativeExpressionContext _prevctx = _localctx;
int _startState = 12;
enterRecursionRule(_localctx, 12, RULE_multiplicativeExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(110);
prefixExpression();
}
_ctx.stop = _input.LT(-1);
setState(123);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(121);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
case 1:
{
_localctx = new MultiplicativeExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression);
setState(112);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(113);
match(Mul);
setState(114);
prefixExpression();
}
break;
case 2:
{
_localctx = new MultiplicativeExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression);
setState(115);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(116);
match(Div);
setState(117);
prefixExpression();
}
break;
case 3:
{
_localctx = new MultiplicativeExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression);
setState(118);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(119);
match(Mod);
setState(120);
prefixExpression();
}
break;
}
}
}
setState(125);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class AdditiveExpressionContext extends ParserRuleContext {
public MultiplicativeExpressionContext multiplicativeExpression() {
return getRuleContext(MultiplicativeExpressionContext.class,0);
}
public AdditiveExpressionContext additiveExpression() {
return getRuleContext(AdditiveExpressionContext.class,0);
}
public TerminalNode Add() { return getToken(CausticParser.Add, 0); }
public TerminalNode Sub() { return getToken(CausticParser.Sub, 0); }
public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_additiveExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterAdditiveExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitAdditiveExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitAdditiveExpression(this);
else return visitor.visitChildren(this);
}
}
public final AdditiveExpressionContext additiveExpression() throws RecognitionException {
return additiveExpression(0);
}
private AdditiveExpressionContext additiveExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, _parentState);
AdditiveExpressionContext _prevctx = _localctx;
int _startState = 14;
enterRecursionRule(_localctx, 14, RULE_additiveExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(127);
multiplicativeExpression(0);
}
_ctx.stop = _input.LT(-1);
setState(137);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(135);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
{
_localctx = new AdditiveExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_additiveExpression);
setState(129);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(130);
match(Add);
setState(131);
multiplicativeExpression(0);
}
break;
case 2:
{
_localctx = new AdditiveExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_additiveExpression);
setState(132);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(133);
match(Sub);
setState(134);
multiplicativeExpression(0);
}
break;
}
}
}
setState(139);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class RelationalExpressionContext extends ParserRuleContext {
public AdditiveExpressionContext additiveExpression() {
return getRuleContext(AdditiveExpressionContext.class,0);
}
public RelationalExpressionContext relationalExpression() {
return getRuleContext(RelationalExpressionContext.class,0);
}
public TerminalNode LessThan() { return getToken(CausticParser.LessThan, 0); }
public TerminalNode GreaterThan() { return getToken(CausticParser.GreaterThan, 0); }
public TerminalNode LessEqual() { return getToken(CausticParser.LessEqual, 0); }
public TerminalNode GreaterEqual() { return getToken(CausticParser.GreaterEqual, 0); }
public RelationalExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relationalExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterRelationalExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitRelationalExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitRelationalExpression(this);
else return visitor.visitChildren(this);
}
}
public final RelationalExpressionContext relationalExpression() throws RecognitionException {
return relationalExpression(0);
}
private RelationalExpressionContext relationalExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
RelationalExpressionContext _localctx = new RelationalExpressionContext(_ctx, _parentState);
RelationalExpressionContext _prevctx = _localctx;
int _startState = 16;
enterRecursionRule(_localctx, 16, RULE_relationalExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(141);
additiveExpression(0);
}
_ctx.stop = _input.LT(-1);
setState(157);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(155);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
{
_localctx = new RelationalExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression);
setState(143);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(144);
match(LessThan);
setState(145);
additiveExpression(0);
}
break;
case 2:
{
_localctx = new RelationalExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression);
setState(146);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(147);
match(GreaterThan);
setState(148);
additiveExpression(0);
}
break;
case 3:
{
_localctx = new RelationalExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression);
setState(149);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(150);
match(LessEqual);
setState(151);
additiveExpression(0);
}
break;
case 4:
{
_localctx = new RelationalExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression);
setState(152);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(153);
match(GreaterEqual);
setState(154);
additiveExpression(0);
}
break;
}
}
}
setState(159);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class EqualityExpressionContext extends ParserRuleContext {
public RelationalExpressionContext relationalExpression() {
return getRuleContext(RelationalExpressionContext.class,0);
}
public EqualityExpressionContext equalityExpression() {
return getRuleContext(EqualityExpressionContext.class,0);
}
public TerminalNode Equal() { return getToken(CausticParser.Equal, 0); }
public TerminalNode NotEqual() { return getToken(CausticParser.NotEqual, 0); }
public EqualityExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_equalityExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterEqualityExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitEqualityExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitEqualityExpression(this);
else return visitor.visitChildren(this);
}
}
public final EqualityExpressionContext equalityExpression() throws RecognitionException {
return equalityExpression(0);
}
private EqualityExpressionContext equalityExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
EqualityExpressionContext _localctx = new EqualityExpressionContext(_ctx, _parentState);
EqualityExpressionContext _prevctx = _localctx;
int _startState = 18;
enterRecursionRule(_localctx, 18, RULE_equalityExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(161);
relationalExpression(0);
}
_ctx.stop = _input.LT(-1);
setState(171);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(169);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
{
_localctx = new EqualityExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_equalityExpression);
setState(163);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(164);
match(Equal);
setState(165);
relationalExpression(0);
}
break;
case 2:
{
_localctx = new EqualityExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_equalityExpression);
setState(166);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(167);
match(NotEqual);
setState(168);
relationalExpression(0);
}
break;
}
}
}
setState(173);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class LogicalAndExpressionContext extends ParserRuleContext {
public EqualityExpressionContext equalityExpression() {
return getRuleContext(EqualityExpressionContext.class,0);
}
public LogicalAndExpressionContext logicalAndExpression() {
return getRuleContext(LogicalAndExpressionContext.class,0);
}
public TerminalNode And() { return getToken(CausticParser.And, 0); }
public LogicalAndExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_logicalAndExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterLogicalAndExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitLogicalAndExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitLogicalAndExpression(this);
else return visitor.visitChildren(this);
}
}
public final LogicalAndExpressionContext logicalAndExpression() throws RecognitionException {
return logicalAndExpression(0);
}
private LogicalAndExpressionContext logicalAndExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
LogicalAndExpressionContext _localctx = new LogicalAndExpressionContext(_ctx, _parentState);
LogicalAndExpressionContext _prevctx = _localctx;
int _startState = 20;
enterRecursionRule(_localctx, 20, RULE_logicalAndExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(175);
equalityExpression(0);
}
_ctx.stop = _input.LT(-1);
setState(182);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,15,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new LogicalAndExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_logicalAndExpression);
setState(177);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(178);
match(And);
setState(179);
equalityExpression(0);
}
}
}
setState(184);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,15,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class LogicalOrExpressionContext extends ParserRuleContext {
public LogicalAndExpressionContext logicalAndExpression() {
return getRuleContext(LogicalAndExpressionContext.class,0);
}
public LogicalOrExpressionContext logicalOrExpression() {
return getRuleContext(LogicalOrExpressionContext.class,0);
}
public TerminalNode Or() { return getToken(CausticParser.Or, 0); }
public LogicalOrExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_logicalOrExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterLogicalOrExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitLogicalOrExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitLogicalOrExpression(this);
else return visitor.visitChildren(this);
}
}
public final LogicalOrExpressionContext logicalOrExpression() throws RecognitionException {
return logicalOrExpression(0);
}
private LogicalOrExpressionContext logicalOrExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
LogicalOrExpressionContext _localctx = new LogicalOrExpressionContext(_ctx, _parentState);
LogicalOrExpressionContext _prevctx = _localctx;
int _startState = 22;
enterRecursionRule(_localctx, 22, RULE_logicalOrExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(186);
logicalAndExpression(0);
}
_ctx.stop = _input.LT(-1);
setState(193);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new LogicalOrExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_logicalOrExpression);
setState(188);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(189);
match(Or);
setState(190);
logicalAndExpression(0);
}
}
}
setState(195);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class ExpressionContext extends ParserRuleContext {
public LogicalOrExpressionContext logicalOrExpression() {
return getRuleContext(LogicalOrExpressionContext.class,0);
}
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitExpression(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
enterRule(_localctx, 24, RULE_expression);
try {
enterOuterAlt(_localctx, 1);
{
setState(196);
logicalOrExpression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConditionalContext extends ParserRuleContext {
public TerminalNode If() { return getToken(CausticParser.If, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List block() {
return getRuleContexts(BlockContext.class);
}
public BlockContext block(int i) {
return getRuleContext(BlockContext.class,i);
}
public List Elif() { return getTokens(CausticParser.Elif); }
public TerminalNode Elif(int i) {
return getToken(CausticParser.Elif, i);
}
public TerminalNode Else() { return getToken(CausticParser.Else, 0); }
public ConditionalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conditional; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterConditional(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitConditional(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitConditional(this);
else return visitor.visitChildren(this);
}
}
public final ConditionalContext conditional() throws RecognitionException {
ConditionalContext _localctx = new ConditionalContext(_ctx, getState());
enterRule(_localctx, 26, RULE_conditional);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(198);
match(If);
setState(199);
expression();
setState(200);
block();
setState(207);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,17,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(201);
match(Elif);
setState(202);
expression();
setState(203);
block();
}
}
}
setState(209);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,17,_ctx);
}
setState(212);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
{
setState(210);
match(Else);
setState(211);
block();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LoopContext extends ParserRuleContext {
public TerminalNode While() { return getToken(CausticParser.While, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public LoopContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_loop; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterLoop(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitLoop(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitLoop(this);
else return visitor.visitChildren(this);
}
}
public final LoopContext loop() throws RecognitionException {
LoopContext _localctx = new LoopContext(_ctx, getState());
enterRule(_localctx, 28, RULE_loop);
try {
enterOuterAlt(_localctx, 1);
{
setState(214);
match(While);
setState(215);
expression();
setState(216);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeletionContext extends ParserRuleContext {
public TerminalNode Del() { return getToken(CausticParser.Del, 0); }
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public DeletionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_deletion; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterDeletion(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitDeletion(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitDeletion(this);
else return visitor.visitChildren(this);
}
}
public final DeletionContext deletion() throws RecognitionException {
DeletionContext _localctx = new DeletionContext(_ctx, getState());
enterRule(_localctx, 30, RULE_deletion);
try {
enterOuterAlt(_localctx, 1);
{
setState(218);
match(Del);
setState(219);
name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DefinitionContext extends ParserRuleContext {
public TerminalNode Var() { return getToken(CausticParser.Var, 0); }
public TerminalNode Identifier() { return getToken(CausticParser.Identifier, 0); }
public TerminalNode Assign() { return getToken(CausticParser.Assign, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public DefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_definition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitDefinition(this);
else return visitor.visitChildren(this);
}
}
public final DefinitionContext definition() throws RecognitionException {
DefinitionContext _localctx = new DefinitionContext(_ctx, getState());
enterRule(_localctx, 32, RULE_definition);
try {
enterOuterAlt(_localctx, 1);
{
setState(221);
match(Var);
setState(222);
match(Identifier);
setState(223);
match(Assign);
setState(224);
expression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AssignmentContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode Assign() { return getToken(CausticParser.Assign, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode MulAssign() { return getToken(CausticParser.MulAssign, 0); }
public TerminalNode DivAssign() { return getToken(CausticParser.DivAssign, 0); }
public TerminalNode ModAssign() { return getToken(CausticParser.ModAssign, 0); }
public TerminalNode AddAssign() { return getToken(CausticParser.AddAssign, 0); }
public TerminalNode SubAssign() { return getToken(CausticParser.SubAssign, 0); }
public AssignmentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignment; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterAssignment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitAssignment(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitAssignment(this);
else return visitor.visitChildren(this);
}
}
public final AssignmentContext assignment() throws RecognitionException {
AssignmentContext _localctx = new AssignmentContext(_ctx, getState());
enterRule(_localctx, 34, RULE_assignment);
try {
setState(250);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(226);
name();
setState(227);
match(Assign);
setState(228);
expression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(230);
name();
setState(231);
match(MulAssign);
setState(232);
expression();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(234);
name();
setState(235);
match(DivAssign);
setState(236);
expression();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(238);
name();
setState(239);
match(ModAssign);
setState(240);
expression();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(242);
name();
setState(243);
match(AddAssign);
setState(244);
expression();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(246);
name();
setState(247);
match(SubAssign);
setState(248);
expression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RollbackContext extends ParserRuleContext {
public TerminalNode Rollback() { return getToken(CausticParser.Rollback, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public RollbackContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rollback; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterRollback(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitRollback(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitRollback(this);
else return visitor.visitChildren(this);
}
}
public final RollbackContext rollback() throws RecognitionException {
RollbackContext _localctx = new RollbackContext(_ctx, getState());
enterRule(_localctx, 36, RULE_rollback);
try {
enterOuterAlt(_localctx, 1);
{
setState(252);
match(Rollback);
setState(253);
expression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StatementContext extends ParserRuleContext {
public DefinitionContext definition() {
return getRuleContext(DefinitionContext.class,0);
}
public ConditionalContext conditional() {
return getRuleContext(ConditionalContext.class,0);
}
public DeletionContext deletion() {
return getRuleContext(DeletionContext.class,0);
}
public LoopContext loop() {
return getRuleContext(LoopContext.class,0);
}
public AssignmentContext assignment() {
return getRuleContext(AssignmentContext.class,0);
}
public RollbackContext rollback() {
return getRuleContext(RollbackContext.class,0);
}
public FuncallContext funcall() {
return getRuleContext(FuncallContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public CommentContext comment() {
return getRuleContext(CommentContext.class,0);
}
public StatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitStatement(this);
else return visitor.visitChildren(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 38, RULE_statement);
try {
setState(264);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(255);
definition();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(256);
conditional();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(257);
deletion();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(258);
loop();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(259);
assignment();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(260);
rollback();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(261);
funcall();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(262);
expression();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(263);
comment();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BlockContext extends ParserRuleContext {
public List statement() {
return getRuleContexts(StatementContext.class);
}
public StatementContext statement(int i) {
return getRuleContext(StatementContext.class,i);
}
public BlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_block; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitBlock(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitBlock(this);
else return visitor.visitChildren(this);
}
}
public final BlockContext block() throws RecognitionException {
BlockContext _localctx = new BlockContext(_ctx, getState());
enterRule(_localctx, 40, RULE_block);
int _la;
try {
setState(281);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Del:
case False:
case If:
case Null:
case Rollback:
case While:
case True:
case Var:
case Add:
case LeftParen:
case Not:
case Sub:
case Number:
case Identifier:
case String:
case BlockComment:
case LineComment:
enterOuterAlt(_localctx, 1);
{
setState(266);
statement();
setState(268);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
case 1:
{
setState(267);
match(Semicolon);
}
break;
}
}
break;
case LeftBracket:
enterOuterAlt(_localctx, 2);
{
setState(270);
match(LeftBracket);
setState(277);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Del) | (1L << False) | (1L << If) | (1L << Null) | (1L << Rollback) | (1L << While) | (1L << True) | (1L << Var) | (1L << Add) | (1L << LeftParen) | (1L << Not) | (1L << Sub) | (1L << Number) | (1L << Identifier) | (1L << String) | (1L << BlockComment) | (1L << LineComment))) != 0)) {
{
{
setState(271);
statement();
setState(273);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Semicolon) {
{
setState(272);
match(Semicolon);
}
}
}
}
setState(279);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(280);
match(RightBracket);
}
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 TypeContext extends ParserRuleContext {
public List Identifier() { return getTokens(CausticParser.Identifier); }
public TerminalNode Identifier(int i) {
return getToken(CausticParser.Identifier, i);
}
public TypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_type; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitType(this);
else return visitor.visitChildren(this);
}
}
public final TypeContext type() throws RecognitionException {
TypeContext _localctx = new TypeContext(_ctx, getState());
enterRule(_localctx, 42, RULE_type);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(283);
match(Identifier);
setState(294);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LeftBlock) {
{
setState(284);
match(LeftBlock);
setState(289);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,25,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(285);
match(Identifier);
setState(286);
match(Comma);
}
}
}
setState(291);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,25,_ctx);
}
setState(292);
match(Identifier);
setState(293);
match(RightBlock);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParameterContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CausticParser.Identifier, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public ParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitParameter(this);
else return visitor.visitChildren(this);
}
}
public final ParameterContext parameter() throws RecognitionException {
ParameterContext _localctx = new ParameterContext(_ctx, getState());
enterRule(_localctx, 44, RULE_parameter);
try {
enterOuterAlt(_localctx, 1);
{
setState(296);
match(Identifier);
setState(297);
match(Colon);
setState(298);
type();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParametersContext extends ParserRuleContext {
public List parameter() {
return getRuleContexts(ParameterContext.class);
}
public ParameterContext parameter(int i) {
return getRuleContext(ParameterContext.class,i);
}
public ParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitParameters(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitParameters(this);
else return visitor.visitChildren(this);
}
}
public final ParametersContext parameters() throws RecognitionException {
ParametersContext _localctx = new ParametersContext(_ctx, getState());
enterRule(_localctx, 46, RULE_parameters);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(305);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,27,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(300);
parameter();
setState(301);
match(Comma);
}
}
}
setState(307);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,27,_ctx);
}
setState(309);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Identifier) {
{
setState(308);
parameter();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FunctionContext extends ParserRuleContext {
public TerminalNode Def() { return getToken(CausticParser.Def, 0); }
public TerminalNode Identifier() { return getToken(CausticParser.Identifier, 0); }
public ParametersContext parameters() {
return getRuleContext(ParametersContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public CommentContext comment() {
return getRuleContext(CommentContext.class,0);
}
public FunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitFunction(this);
else return visitor.visitChildren(this);
}
}
public final FunctionContext function() throws RecognitionException {
FunctionContext _localctx = new FunctionContext(_ctx, getState());
enterRule(_localctx, 48, RULE_function);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(312);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BlockComment || _la==LineComment) {
{
setState(311);
comment();
}
}
setState(314);
match(Def);
setState(315);
match(Identifier);
setState(316);
match(LeftParen);
setState(317);
parameters();
setState(318);
match(RightParen);
setState(319);
match(Colon);
setState(320);
type();
setState(321);
match(Assign);
setState(322);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ServiceContext extends ParserRuleContext {
public TerminalNode Service() { return getToken(CausticParser.Service, 0); }
public TerminalNode Identifier() { return getToken(CausticParser.Identifier, 0); }
public CommentContext comment() {
return getRuleContext(CommentContext.class,0);
}
public List function() {
return getRuleContexts(FunctionContext.class);
}
public FunctionContext function(int i) {
return getRuleContext(FunctionContext.class,i);
}
public ServiceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_service; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterService(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitService(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitService(this);
else return visitor.visitChildren(this);
}
}
public final ServiceContext service() throws RecognitionException {
ServiceContext _localctx = new ServiceContext(_ctx, getState());
enterRule(_localctx, 50, RULE_service);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(325);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BlockComment || _la==LineComment) {
{
setState(324);
comment();
}
}
setState(327);
match(Service);
setState(328);
match(Identifier);
setState(329);
match(LeftBracket);
setState(333);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Def) | (1L << BlockComment) | (1L << LineComment))) != 0)) {
{
{
setState(330);
function();
}
}
setState(335);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(336);
match(RightBracket);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StructContext extends ParserRuleContext {
public TerminalNode Struct() { return getToken(CausticParser.Struct, 0); }
public TerminalNode Identifier() { return getToken(CausticParser.Identifier, 0); }
public ParametersContext parameters() {
return getRuleContext(ParametersContext.class,0);
}
public CommentContext comment() {
return getRuleContext(CommentContext.class,0);
}
public StructContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_struct; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterStruct(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitStruct(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitStruct(this);
else return visitor.visitChildren(this);
}
}
public final StructContext struct() throws RecognitionException {
StructContext _localctx = new StructContext(_ctx, getState());
enterRule(_localctx, 52, RULE_struct);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(339);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BlockComment || _la==LineComment) {
{
setState(338);
comment();
}
}
setState(341);
match(Struct);
setState(342);
match(Identifier);
setState(343);
match(LeftBracket);
setState(344);
parameters();
setState(345);
match(RightBracket);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclarationContext extends ParserRuleContext {
public StructContext struct() {
return getRuleContext(StructContext.class,0);
}
public ServiceContext service() {
return getRuleContext(ServiceContext.class,0);
}
public DeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final DeclarationContext declaration() throws RecognitionException {
DeclarationContext _localctx = new DeclarationContext(_ctx, getState());
enterRule(_localctx, 54, RULE_declaration);
try {
setState(349);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(347);
struct();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(348);
service();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ModuleContext extends ParserRuleContext {
public TerminalNode Module() { return getToken(CausticParser.Module, 0); }
public List Identifier() { return getTokens(CausticParser.Identifier); }
public TerminalNode Identifier(int i) {
return getToken(CausticParser.Identifier, i);
}
public ModuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_module; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterModule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitModule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitModule(this);
else return visitor.visitChildren(this);
}
}
public final ModuleContext module() throws RecognitionException {
ModuleContext _localctx = new ModuleContext(_ctx, getState());
enterRule(_localctx, 56, RULE_module);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(351);
match(Module);
setState(352);
match(Identifier);
setState(357);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Period) {
{
{
setState(353);
match(Period);
setState(354);
match(Identifier);
}
}
setState(359);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IncludeContext extends ParserRuleContext {
public TerminalNode Import() { return getToken(CausticParser.Import, 0); }
public TerminalNode String() { return getToken(CausticParser.String, 0); }
public IncludeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_include; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterInclude(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitInclude(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitInclude(this);
else return visitor.visitChildren(this);
}
}
public final IncludeContext include() throws RecognitionException {
IncludeContext _localctx = new IncludeContext(_ctx, getState());
enterRule(_localctx, 58, RULE_include);
try {
enterOuterAlt(_localctx, 1);
{
setState(360);
match(Import);
setState(361);
match(String);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ProgramContext extends ParserRuleContext {
public ModuleContext module() {
return getRuleContext(ModuleContext.class,0);
}
public List include() {
return getRuleContexts(IncludeContext.class);
}
public IncludeContext include(int i) {
return getRuleContext(IncludeContext.class,i);
}
public List declaration() {
return getRuleContexts(DeclarationContext.class);
}
public DeclarationContext declaration(int i) {
return getRuleContext(DeclarationContext.class,i);
}
public ProgramContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_program; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).enterProgram(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CausticListener ) ((CausticListener)listener).exitProgram(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CausticVisitor ) return ((CausticVisitor)visitor).visitProgram(this);
else return visitor.visitChildren(this);
}
}
public final ProgramContext program() throws RecognitionException {
ProgramContext _localctx = new ProgramContext(_ctx, getState());
enterRule(_localctx, 60, RULE_program);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(364);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Module) {
{
setState(363);
module();
}
}
setState(369);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Import) {
{
{
setState(366);
include();
}
}
setState(371);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(375);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Service) | (1L << Struct) | (1L << BlockComment) | (1L << LineComment))) != 0)) {
{
{
setState(372);
declaration();
}
}
setState(377);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 6:
return multiplicativeExpression_sempred((MultiplicativeExpressionContext)_localctx, predIndex);
case 7:
return additiveExpression_sempred((AdditiveExpressionContext)_localctx, predIndex);
case 8:
return relationalExpression_sempred((RelationalExpressionContext)_localctx, predIndex);
case 9:
return equalityExpression_sempred((EqualityExpressionContext)_localctx, predIndex);
case 10:
return logicalAndExpression_sempred((LogicalAndExpressionContext)_localctx, predIndex);
case 11:
return logicalOrExpression_sempred((LogicalOrExpressionContext)_localctx, predIndex);
}
return true;
}
private boolean multiplicativeExpression_sempred(MultiplicativeExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 3);
case 1:
return precpred(_ctx, 2);
case 2:
return precpred(_ctx, 1);
}
return true;
}
private boolean additiveExpression_sempred(AdditiveExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 3:
return precpred(_ctx, 2);
case 4:
return precpred(_ctx, 1);
}
return true;
}
private boolean relationalExpression_sempred(RelationalExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 5:
return precpred(_ctx, 4);
case 6:
return precpred(_ctx, 3);
case 7:
return precpred(_ctx, 2);
case 8:
return precpred(_ctx, 1);
}
return true;
}
private boolean equalityExpression_sempred(EqualityExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 9:
return precpred(_ctx, 2);
case 10:
return precpred(_ctx, 1);
}
return true;
}
private boolean logicalAndExpression_sempred(LogicalAndExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 11:
return precpred(_ctx, 1);
}
return true;
}
private boolean logicalOrExpression_sempred(LogicalOrExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 12:
return precpred(_ctx, 1);
}
return true;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\39\u017d\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\4\n\t\n\4\13\t"+
"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \3\2"+
"\3\2\6\2C\n\2\r\2\16\2D\5\2G\n\2\3\3\3\3\3\4\3\4\3\4\7\4N\n\4\f\4\16\4"+
"Q\13\4\3\5\3\5\3\5\3\5\3\5\7\5X\n\5\f\5\16\5[\13\5\3\5\5\5^\n\5\3\5\3"+
"\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6i\n\6\3\7\5\7l\n\7\3\7\3\7\3\b\3\b\3"+
"\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\7\b|\n\b\f\b\16\b\177\13\b\3\t"+
"\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\7\t\u008a\n\t\f\t\16\t\u008d\13\t\3\n"+
"\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\7\n\u009e\n\n"+
"\f\n\16\n\u00a1\13\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\7\13"+
"\u00ac\n\13\f\13\16\13\u00af\13\13\3\f\3\f\3\f\3\f\3\f\3\f\7\f\u00b7\n"+
"\f\f\f\16\f\u00ba\13\f\3\r\3\r\3\r\3\r\3\r\3\r\7\r\u00c2\n\r\f\r\16\r"+
"\u00c5\13\r\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\17\3\17\7\17\u00d0\n"+
"\17\f\17\16\17\u00d3\13\17\3\17\3\17\5\17\u00d7\n\17\3\20\3\20\3\20\3"+
"\20\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3"+
"\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3"+
"\23\3\23\3\23\3\23\3\23\5\23\u00fd\n\23\3\24\3\24\3\24\3\25\3\25\3\25"+
"\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u010b\n\25\3\26\3\26\5\26\u010f\n"+
"\26\3\26\3\26\3\26\5\26\u0114\n\26\7\26\u0116\n\26\f\26\16\26\u0119\13"+
"\26\3\26\5\26\u011c\n\26\3\27\3\27\3\27\3\27\7\27\u0122\n\27\f\27\16\27"+
"\u0125\13\27\3\27\3\27\5\27\u0129\n\27\3\30\3\30\3\30\3\30\3\31\3\31\3"+
"\31\7\31\u0132\n\31\f\31\16\31\u0135\13\31\3\31\5\31\u0138\n\31\3\32\5"+
"\32\u013b\n\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\33"+
"\5\33\u0148\n\33\3\33\3\33\3\33\3\33\7\33\u014e\n\33\f\33\16\33\u0151"+
"\13\33\3\33\3\33\3\34\5\34\u0156\n\34\3\34\3\34\3\34\3\34\3\34\3\34\3"+
"\35\3\35\5\35\u0160\n\35\3\36\3\36\3\36\3\36\7\36\u0166\n\36\f\36\16\36"+
"\u0169\13\36\3\37\3\37\3\37\3 \5 \u016f\n \3 \7 \u0172\n \f \16 \u0175"+
"\13 \3 \7 \u0178\n \f \16 \u017b\13 \3 \2\b\16\20\22\24\26\30!\2\4\6\b"+
"\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>\2\4\7\2\7\7\13"+
"\13\20\20\64\64\66\66\5\2\22\22((\61\61\2\u0193\2F\3\2\2\2\4H\3\2\2\2"+
"\6J\3\2\2\2\bR\3\2\2\2\nh\3\2\2\2\fk\3\2\2\2\16o\3\2\2\2\20\u0080\3\2"+
"\2\2\22\u008e\3\2\2\2\24\u00a2\3\2\2\2\26\u00b0\3\2\2\2\30\u00bb\3\2\2"+
"\2\32\u00c6\3\2\2\2\34\u00c8\3\2\2\2\36\u00d8\3\2\2\2 \u00dc\3\2\2\2\""+
"\u00df\3\2\2\2$\u00fc\3\2\2\2&\u00fe\3\2\2\2(\u010a\3\2\2\2*\u011b\3\2"+
"\2\2,\u011d\3\2\2\2.\u012a\3\2\2\2\60\u0133\3\2\2\2\62\u013a\3\2\2\2\64"+
"\u0147\3\2\2\2\66\u0155\3\2\2\28\u015f\3\2\2\2:\u0161\3\2\2\2<\u016a\3"+
"\2\2\2>\u016e\3\2\2\2@G\7\67\2\2AC\78\2\2BA\3\2\2\2CD\3\2\2\2DB\3\2\2"+
"\2DE\3\2\2\2EG\3\2\2\2F@\3\2\2\2FB\3\2\2\2G\3\3\2\2\2HI\t\2\2\2I\5\3\2"+
"\2\2JO\7\65\2\2KL\7+\2\2LN\7\65\2\2MK\3\2\2\2NQ\3\2\2\2OM\3\2\2\2OP\3"+
"\2\2\2P\7\3\2\2\2QO\3\2\2\2RS\5\6\4\2SY\7!\2\2TU\5\32\16\2UV\7\31\2\2"+
"VX\3\2\2\2WT\3\2\2\2X[\3\2\2\2YW\3\2\2\2YZ\3\2\2\2Z]\3\2\2\2[Y\3\2\2\2"+
"\\^\5\32\16\2]\\\3\2\2\2]^\3\2\2\2^_\3\2\2\2_`\7/\2\2`\t\3\2\2\2ai\5\6"+
"\4\2bi\5\b\5\2ci\5\4\3\2de\7!\2\2ef\5\32\16\2fg\7/\2\2gi\3\2\2\2ha\3\2"+
"\2\2hb\3\2\2\2hc\3\2\2\2hd\3\2\2\2i\13\3\2\2\2jl\t\3\2\2kj\3\2\2\2kl\3"+
"\2\2\2lm\3\2\2\2mn\5\n\6\2n\r\3\2\2\2op\b\b\1\2pq\5\f\7\2q}\3\2\2\2rs"+
"\f\5\2\2st\7&\2\2t|\5\f\7\2uv\f\4\2\2vw\7\32\2\2w|\5\f\7\2xy\f\3\2\2y"+
"z\7$\2\2z|\5\f\7\2{r\3\2\2\2{u\3\2\2\2{x\3\2\2\2|\177\3\2\2\2}{\3\2\2"+
"\2}~\3\2\2\2~\17\3\2\2\2\177}\3\2\2\2\u0080\u0081\b\t\1\2\u0081\u0082"+
"\5\16\b\2\u0082\u008b\3\2\2\2\u0083\u0084\f\4\2\2\u0084\u0085\7\22\2\2"+
"\u0085\u008a\5\16\b\2\u0086\u0087\f\3\2\2\u0087\u0088\7\61\2\2\u0088\u008a"+
"\5\16\b\2\u0089\u0083\3\2\2\2\u0089\u0086\3\2\2\2\u008a\u008d\3\2\2\2"+
"\u008b\u0089\3\2\2\2\u008b\u008c\3\2\2\2\u008c\21\3\2\2\2\u008d\u008b"+
"\3\2\2\2\u008e\u008f\b\n\1\2\u008f\u0090\5\20\t\2\u0090\u009f\3\2\2\2"+
"\u0091\u0092\f\6\2\2\u0092\u0093\7#\2\2\u0093\u009e\5\20\t\2\u0094\u0095"+
"\f\5\2\2\u0095\u0096\7\36\2\2\u0096\u009e\5\20\t\2\u0097\u0098\f\4\2\2"+
"\u0098\u0099\7\"\2\2\u0099\u009e\5\20\t\2\u009a\u009b\f\3\2\2\u009b\u009c"+
"\7\35\2\2\u009c\u009e\5\20\t\2\u009d\u0091\3\2\2\2\u009d\u0094\3\2\2\2"+
"\u009d\u0097\3\2\2\2\u009d\u009a\3\2\2\2\u009e\u00a1\3\2\2\2\u009f\u009d"+
"\3\2\2\2\u009f\u00a0\3\2\2\2\u00a0\23\3\2\2\2\u00a1\u009f\3\2\2\2\u00a2"+
"\u00a3\b\13\1\2\u00a3\u00a4\5\22\n\2\u00a4\u00ad\3\2\2\2\u00a5\u00a6\f"+
"\4\2\2\u00a6\u00a7\7\34\2\2\u00a7\u00ac\5\22\n\2\u00a8\u00a9\f\3\2\2\u00a9"+
"\u00aa\7)\2\2\u00aa\u00ac\5\22\n\2\u00ab\u00a5\3\2\2\2\u00ab\u00a8\3\2"+
"\2\2\u00ac\u00af\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ad\u00ae\3\2\2\2\u00ae"+
"\25\3\2\2\2\u00af\u00ad\3\2\2\2\u00b0\u00b1\b\f\1\2\u00b1\u00b2\5\24\13"+
"\2\u00b2\u00b8\3\2\2\2\u00b3\u00b4\f\3\2\2\u00b4\u00b5\7\25\2\2\u00b5"+
"\u00b7\5\24\13\2\u00b6\u00b3\3\2\2\2\u00b7\u00ba\3\2\2\2\u00b8\u00b6\3"+
"\2\2\2\u00b8\u00b9\3\2\2\2\u00b9\27\3\2\2\2\u00ba\u00b8\3\2\2\2\u00bb"+
"\u00bc\b\r\1\2\u00bc\u00bd\5\26\f\2\u00bd\u00c3\3\2\2\2\u00be\u00bf\f"+
"\3\2\2\u00bf\u00c0\7*\2\2\u00c0\u00c2\5\26\f\2\u00c1\u00be\3\2\2\2\u00c2"+
"\u00c5\3\2\2\2\u00c3\u00c1\3\2\2\2\u00c3\u00c4\3\2\2\2\u00c4\31\3\2\2"+
"\2\u00c5\u00c3\3\2\2\2\u00c6\u00c7\5\30\r\2\u00c7\33\3\2\2\2\u00c8\u00c9"+
"\7\b\2\2\u00c9\u00ca\5\32\16\2\u00ca\u00d1\5*\26\2\u00cb\u00cc\7\5\2\2"+
"\u00cc\u00cd\5\32\16\2\u00cd\u00ce\5*\26\2\u00ce\u00d0\3\2\2\2\u00cf\u00cb"+
"\3\2\2\2\u00d0\u00d3\3\2\2\2\u00d1\u00cf\3\2\2\2\u00d1\u00d2\3\2\2\2\u00d2"+
"\u00d6\3\2\2\2\u00d3\u00d1\3\2\2\2\u00d4\u00d5\7\6\2\2\u00d5\u00d7\5*"+
"\26\2\u00d6\u00d4\3\2\2\2\u00d6\u00d7\3\2\2\2\u00d7\35\3\2\2\2\u00d8\u00d9"+
"\7\17\2\2\u00d9\u00da\5\32\16\2\u00da\u00db\5*\26\2\u00db\37\3\2\2\2\u00dc"+
"\u00dd\7\4\2\2\u00dd\u00de\5\6\4\2\u00de!\3\2\2\2\u00df\u00e0\7\21\2\2"+
"\u00e0\u00e1\7\65\2\2\u00e1\u00e2\7\27\2\2\u00e2\u00e3\5\32\16\2\u00e3"+
"#\3\2\2\2\u00e4\u00e5\5\6\4\2\u00e5\u00e6\7\27\2\2\u00e6\u00e7\5\32\16"+
"\2\u00e7\u00fd\3\2\2\2\u00e8\u00e9\5\6\4\2\u00e9\u00ea\7\'\2\2\u00ea\u00eb"+
"\5\32\16\2\u00eb\u00fd\3\2\2\2\u00ec\u00ed\5\6\4\2\u00ed\u00ee\7\33\2"+
"\2\u00ee\u00ef\5\32\16\2\u00ef\u00fd\3\2\2\2\u00f0\u00f1\5\6\4\2\u00f1"+
"\u00f2\7%\2\2\u00f2\u00f3\5\32\16\2\u00f3\u00fd\3\2\2\2\u00f4\u00f5\5"+
"\6\4\2\u00f5\u00f6\7\23\2\2\u00f6\u00f7\5\32\16\2\u00f7\u00fd\3\2\2\2"+
"\u00f8\u00f9\5\6\4\2\u00f9\u00fa\7\62\2\2\u00fa\u00fb\5\32\16\2\u00fb"+
"\u00fd\3\2\2\2\u00fc\u00e4\3\2\2\2\u00fc\u00e8\3\2\2\2\u00fc\u00ec\3\2"+
"\2\2\u00fc\u00f0\3\2\2\2\u00fc\u00f4\3\2\2\2\u00fc\u00f8\3\2\2\2\u00fd"+
"%\3\2\2\2\u00fe\u00ff\7\f\2\2\u00ff\u0100\5\32\16\2\u0100\'\3\2\2\2\u0101"+
"\u010b\5\"\22\2\u0102\u010b\5\34\17\2\u0103\u010b\5 \21\2\u0104\u010b"+
"\5\36\20\2\u0105\u010b\5$\23\2\u0106\u010b\5&\24\2\u0107\u010b\5\b\5\2"+
"\u0108\u010b\5\32\16\2\u0109\u010b\5\2\2\2\u010a\u0101\3\2\2\2\u010a\u0102"+
"\3\2\2\2\u010a\u0103\3\2\2\2\u010a\u0104\3\2\2\2\u010a\u0105\3\2\2\2\u010a"+
"\u0106\3\2\2\2\u010a\u0107\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u0109\3\2"+
"\2\2\u010b)\3\2\2\2\u010c\u010e\5(\25\2\u010d\u010f\7\60\2\2\u010e\u010d"+
"\3\2\2\2\u010e\u010f\3\2\2\2\u010f\u011c\3\2\2\2\u0110\u0117\7 \2\2\u0111"+
"\u0113\5(\25\2\u0112\u0114\7\60\2\2\u0113\u0112\3\2\2\2\u0113\u0114\3"+
"\2\2\2\u0114\u0116\3\2\2\2\u0115\u0111\3\2\2\2\u0116\u0119\3\2\2\2\u0117"+
"\u0115\3\2\2\2\u0117\u0118\3\2\2\2\u0118\u011a\3\2\2\2\u0119\u0117\3\2"+
"\2\2\u011a\u011c\7.\2\2\u011b\u010c\3\2\2\2\u011b\u0110\3\2\2\2\u011c"+
"+\3\2\2\2\u011d\u0128\7\65\2\2\u011e\u0123\7\37\2\2\u011f\u0120\7\65\2"+
"\2\u0120\u0122\7\31\2\2\u0121\u011f\3\2\2\2\u0122\u0125\3\2\2\2\u0123"+
"\u0121\3\2\2\2\u0123\u0124\3\2\2\2\u0124\u0126\3\2\2\2\u0125\u0123\3\2"+
"\2\2\u0126\u0127\7\65\2\2\u0127\u0129\7-\2\2\u0128\u011e\3\2\2\2\u0128"+
"\u0129\3\2\2\2\u0129-\3\2\2\2\u012a\u012b\7\65\2\2\u012b\u012c\7\30\2"+
"\2\u012c\u012d\5,\27\2\u012d/\3\2\2\2\u012e\u012f\5.\30\2\u012f\u0130"+
"\7\31\2\2\u0130\u0132\3\2\2\2\u0131\u012e\3\2\2\2\u0132\u0135\3\2\2\2"+
"\u0133\u0131\3\2\2\2\u0133\u0134\3\2\2\2\u0134\u0137\3\2\2\2\u0135\u0133"+
"\3\2\2\2\u0136\u0138\5.\30\2\u0137\u0136\3\2\2\2\u0137\u0138\3\2\2\2\u0138"+
"\61\3\2\2\2\u0139\u013b\5\2\2\2\u013a\u0139\3\2\2\2\u013a\u013b\3\2\2"+
"\2\u013b\u013c\3\2\2\2\u013c\u013d\7\3\2\2\u013d\u013e\7\65\2\2\u013e"+
"\u013f\7!\2\2\u013f\u0140\5\60\31\2\u0140\u0141\7/\2\2\u0141\u0142\7\30"+
"\2\2\u0142\u0143\5,\27\2\u0143\u0144\7\27\2\2\u0144\u0145\5*\26\2\u0145"+
"\63\3\2\2\2\u0146\u0148\5\2\2\2\u0147\u0146\3\2\2\2\u0147\u0148\3\2\2"+
"\2\u0148\u0149\3\2\2\2\u0149\u014a\7\r\2\2\u014a\u014b\7\65\2\2\u014b"+
"\u014f\7 \2\2\u014c\u014e\5\62\32\2\u014d\u014c\3\2\2\2\u014e\u0151\3"+
"\2\2\2\u014f\u014d\3\2\2\2\u014f\u0150\3\2\2\2\u0150\u0152\3\2\2\2\u0151"+
"\u014f\3\2\2\2\u0152\u0153\7.\2\2\u0153\65\3\2\2\2\u0154\u0156\5\2\2\2"+
"\u0155\u0154\3\2\2\2\u0155\u0156\3\2\2\2\u0156\u0157\3\2\2\2\u0157\u0158"+
"\7\16\2\2\u0158\u0159\7\65\2\2\u0159\u015a\7 \2\2\u015a\u015b\5\60\31"+
"\2\u015b\u015c\7.\2\2\u015c\67\3\2\2\2\u015d\u0160\5\66\34\2\u015e\u0160"+
"\5\64\33\2\u015f\u015d\3\2\2\2\u015f\u015e\3\2\2\2\u01609\3\2\2\2\u0161"+
"\u0162\7\n\2\2\u0162\u0167\7\65\2\2\u0163\u0164\7+\2\2\u0164\u0166\7\65"+
"\2\2\u0165\u0163\3\2\2\2\u0166\u0169\3\2\2\2\u0167\u0165\3\2\2\2\u0167"+
"\u0168\3\2\2\2\u0168;\3\2\2\2\u0169\u0167\3\2\2\2\u016a\u016b\7\t\2\2"+
"\u016b\u016c\7\66\2\2\u016c=\3\2\2\2\u016d\u016f\5:\36\2\u016e\u016d\3"+
"\2\2\2\u016e\u016f\3\2\2\2\u016f\u0173\3\2\2\2\u0170\u0172\5<\37\2\u0171"+
"\u0170\3\2\2\2\u0172\u0175\3\2\2\2\u0173\u0171\3\2\2\2\u0173\u0174\3\2"+
"\2\2\u0174\u0179\3\2\2\2\u0175\u0173\3\2\2\2\u0176\u0178\58\35\2\u0177"+
"\u0176\3\2\2\2\u0178\u017b\3\2\2\2\u0179\u0177\3\2\2\2\u0179\u017a\3\2"+
"\2\2\u017a?\3\2\2\2\u017b\u0179\3\2\2\2(DFOY]hk{}\u0089\u008b\u009d\u009f"+
"\u00ab\u00ad\u00b8\u00c3\u00d1\u00d6\u00fc\u010a\u010e\u0113\u0117\u011b"+
"\u0123\u0128\u0133\u0137\u013a\u0147\u014f\u0155\u015f\u0167\u016e\u0173"+
"\u0179";
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);
}
}
}
