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.
org.fulib.scenarios.parser.ScenarioParser Maven / Gradle / Ivy
// Generated from ScenarioParser.g4 by ANTLR 4.9.3
package org.fulib.scenarios.parser;
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 ScenarioParser extends Parser {
static { RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
A=1, ADD=2, ADDS=3, ALL=4, AN=5, AND=6, ANSWER=7, ANSWERS=8, ARE=9, AS=10,
ATTRIBUTE=11, CALL=12, CALLS=13, CARD=14, CARDS=15, CF=16, CONTAIN=17,
CONTAINS=18, CREATE=19, CREATES=20, DO=21, DOES=22, EG=23, EMPTY=24, EQUAL=25,
EVERY=26, EXPECT=27, FALSE=28, FROM=29, GREATER=30, HAS=31, HAVE=32, IN=33,
INTO=34, IS=35, IT=36, LESS=37, LIKE=38, LINK=39, MANY=40, MATCH=41, MATCHES=42,
NOT=43, OF=44, OR=45, ON=46, ONE=47, READ=48, READS=49, REGISTER=50, REMOVE=51,
REMOVES=52, SAME=53, SOME=54, TAKE=55, TAKES=56, THAN=57, THAT=58, THE=59,
THEN=60, THERE=61, THROUGH=62, TRUE=63, TYPE=64, TO=65, WE=66, WITH=67,
WHERE=68, WHICH=69, WHOSE=70, WRITE=71, WRITES=72, H1=73, H2=74, LINE_COMMENT=75,
BLOCKQUOTE=76, CODE_BLOCK=77, BULLET=78, NUMBERED=79, COMMA=80, FULL_STOP=81,
PLUS=82, COLON=83, INTEGER=84, DECIMAL=85, STRING_LITERAL=86, WORD=87,
WHITESPACE=88, LINEBREAK=89, COMMENT=90, IMG_START=91, IMG_SEP=92, IMG_END=93,
FILE_NAME=94, HEADLINE_END=95, HEADLINE_TEXT=96, CODE_BLOCK_HEADER_END=97,
CODE_BLOCK_LANGUAGE=98, CODE_BLOCK_END=99, CODE_BLOCK_LINE=100;
public static final int
RULE_file = 0, RULE_scenario = 1, RULE_header = 2, RULE_actor = 3, RULE_sentence = 4,
RULE_sentenceEnd = 5, RULE_simpleSentence = 6, RULE_simpleSentences = 7,
RULE_compoundSentence = 8, RULE_sectionSentence = 9, RULE_commentSentence = 10,
RULE_codeBlock = 11, RULE_thereSentence = 12, RULE_simpleDescriptor = 13,
RULE_multiDescriptor = 14, RULE_typeName = 15, RULE_typesName = 16, RULE_isSentence = 17,
RULE_areSentence = 18, RULE_withClauses = 19, RULE_withClause = 20, RULE_namedExpr = 21,
RULE_bidiNamedExpr = 22, RULE_placeholderNamedExpr = 23, RULE_aPlaceholder = 24,
RULE_manyPlaceholder = 25, RULE_likePlaceholder = 26, RULE_ofTypePlaceholder = 27,
RULE_everyPlaceholder = 28, RULE_hasSentence = 29, RULE_hasClauses = 30,
RULE_hasClause = 31, RULE_createSentence = 32, RULE_callSentence = 33,
RULE_answerSentence = 34, RULE_writeSentence = 35, RULE_addSentence = 36,
RULE_removeSentence = 37, RULE_conditionalSentence = 38, RULE_takeSentence = 39,
RULE_compoundSentenceBody = 40, RULE_expectSentence = 41, RULE_thatClauses = 42,
RULE_thatClause = 43, RULE_diagramSentence = 44, RULE_matchSentence = 45,
RULE_patternObjects = 46, RULE_patternObject = 47, RULE_constraints = 48,
RULE_constraint = 49, RULE_linkConstraint = 50, RULE_attributeEqualityConstraint = 51,
RULE_attributeConditionalConstraint = 52, RULE_attributePredicateConstraint = 53,
RULE_matchConstraint = 54, RULE_expr = 55, RULE_primary = 56, RULE_primaryExpr = 57,
RULE_number = 58, RULE_booleanLiteral = 59, RULE_stringLiteral = 60, RULE_it = 61,
RULE_answer = 62, RULE_simpleName = 63, RULE_name = 64, RULE_identifier = 65,
RULE_nameAccess = 66, RULE_access = 67, RULE_namedAccess = 68, RULE_named = 69,
RULE_attributeAccess = 70, RULE_exampleAccess = 71, RULE_filterExpr = 72,
RULE_sep = 73, RULE_collection = 74, RULE_list = 75, RULE_listElem = 76,
RULE_range = 77, RULE_condExpr = 78, RULE_andCondExpr = 79, RULE_orCondExpr = 80,
RULE_primaryCondExpr = 81, RULE_attrCheck = 82, RULE_condOpExpr = 83,
RULE_condOp = 84, RULE_eqOp = 85, RULE_cmpOp = 86, RULE_collOp = 87, RULE_strOp = 88,
RULE_predOpExpr = 89, RULE_predOp = 90;
private static String[] makeRuleNames() {
return new String[] {
"file", "scenario", "header", "actor", "sentence", "sentenceEnd", "simpleSentence",
"simpleSentences", "compoundSentence", "sectionSentence", "commentSentence",
"codeBlock", "thereSentence", "simpleDescriptor", "multiDescriptor",
"typeName", "typesName", "isSentence", "areSentence", "withClauses",
"withClause", "namedExpr", "bidiNamedExpr", "placeholderNamedExpr", "aPlaceholder",
"manyPlaceholder", "likePlaceholder", "ofTypePlaceholder", "everyPlaceholder",
"hasSentence", "hasClauses", "hasClause", "createSentence", "callSentence",
"answerSentence", "writeSentence", "addSentence", "removeSentence", "conditionalSentence",
"takeSentence", "compoundSentenceBody", "expectSentence", "thatClauses",
"thatClause", "diagramSentence", "matchSentence", "patternObjects", "patternObject",
"constraints", "constraint", "linkConstraint", "attributeEqualityConstraint",
"attributeConditionalConstraint", "attributePredicateConstraint", "matchConstraint",
"expr", "primary", "primaryExpr", "number", "booleanLiteral", "stringLiteral",
"it", "answer", "simpleName", "name", "identifier", "nameAccess", "access",
"namedAccess", "named", "attributeAccess", "exampleAccess", "filterExpr",
"sep", "collection", "list", "listElem", "range", "condExpr", "andCondExpr",
"orCondExpr", "primaryCondExpr", "attrCheck", "condOpExpr", "condOp",
"eqOp", "cmpOp", "collOp", "strOp", "predOpExpr", "predOp"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'a'", "'add'", "'adds'", "'all'", "'an'", "'and'", "'answer'",
"'answers'", "'are'", null, "'attribute'", "'call'", "'calls'", "'card'",
"'cards'", "'cf.'", "'contain'", "'contains'", "'create'", "'creates'",
"'do'", "'does'", "'e.g.'", "'empty'", "'equal'", "'Every'", "'expect'",
"'false'", "'from'", "'greater'", "'has'", "'have'", "'in'", "'into'",
"'is'", "'it'", "'less'", "'like'", "'link'", "'many'", "'match'", "'matches'",
"'not'", "'of'", "'or'", "'on'", "'one'", "'read'", "'reads'", "'register'",
"'remove'", "'removes'", "'same'", "'some'", "'take'", "'takes'", "'than'",
"'that'", null, "'then'", null, "'through'", "'true'", "'type'", "'to'",
null, "'with'", "'where'", "'which'", "'whose'", "'write'", "'writes'",
"'#'", "'##'", "'//'", null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, "'!['", "']('", "')'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "A", "ADD", "ADDS", "ALL", "AN", "AND", "ANSWER", "ANSWERS", "ARE",
"AS", "ATTRIBUTE", "CALL", "CALLS", "CARD", "CARDS", "CF", "CONTAIN",
"CONTAINS", "CREATE", "CREATES", "DO", "DOES", "EG", "EMPTY", "EQUAL",
"EVERY", "EXPECT", "FALSE", "FROM", "GREATER", "HAS", "HAVE", "IN", "INTO",
"IS", "IT", "LESS", "LIKE", "LINK", "MANY", "MATCH", "MATCHES", "NOT",
"OF", "OR", "ON", "ONE", "READ", "READS", "REGISTER", "REMOVE", "REMOVES",
"SAME", "SOME", "TAKE", "TAKES", "THAN", "THAT", "THE", "THEN", "THERE",
"THROUGH", "TRUE", "TYPE", "TO", "WE", "WITH", "WHERE", "WHICH", "WHOSE",
"WRITE", "WRITES", "H1", "H2", "LINE_COMMENT", "BLOCKQUOTE", "CODE_BLOCK",
"BULLET", "NUMBERED", "COMMA", "FULL_STOP", "PLUS", "COLON", "INTEGER",
"DECIMAL", "STRING_LITERAL", "WORD", "WHITESPACE", "LINEBREAK", "COMMENT",
"IMG_START", "IMG_SEP", "IMG_END", "FILE_NAME", "HEADLINE_END", "HEADLINE_TEXT",
"CODE_BLOCK_HEADER_END", "CODE_BLOCK_LANGUAGE", "CODE_BLOCK_END", "CODE_BLOCK_LINE"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "ScenarioParser.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public ScenarioParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class FileContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(ScenarioParser.EOF, 0); }
public List scenario() {
return getRuleContexts(ScenarioContext.class);
}
public ScenarioContext scenario(int i) {
return getRuleContext(ScenarioContext.class,i);
}
public FileContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_file; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterFile(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitFile(this);
}
}
public final FileContext file() throws RecognitionException {
FileContext _localctx = new FileContext(_ctx, getState());
enterRule(_localctx, 0, RULE_file);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(185);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==H1) {
{
{
setState(182);
scenario();
}
}
setState(187);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(188);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ScenarioContext extends ParserRuleContext {
public HeaderContext header() {
return getRuleContext(HeaderContext.class,0);
}
public List sentence() {
return getRuleContexts(SentenceContext.class);
}
public SentenceContext sentence(int i) {
return getRuleContext(SentenceContext.class,i);
}
public ScenarioContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_scenario; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterScenario(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitScenario(this);
}
}
public final ScenarioContext scenario() throws RecognitionException {
ScenarioContext _localctx = new ScenarioContext(_ctx, getState());
enterRule(_localctx, 2, RULE_scenario);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(190);
header();
setState(194);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AS) | (1L << ATTRIBUTE) | (1L << EVERY) | (1L << FALSE) | (1L << LINK) | (1L << MATCH) | (1L << MATCHES) | (1L << SOME) | (1L << THE) | (1L << THERE) | (1L << TRUE))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TYPE - 64)) | (1L << (WE - 64)) | (1L << (WHERE - 64)) | (1L << (WHOSE - 64)) | (1L << (H2 - 64)) | (1L << (LINE_COMMENT - 64)) | (1L << (BLOCKQUOTE - 64)) | (1L << (WORD - 64)) | (1L << (IMG_START - 64)))) != 0)) {
{
{
setState(191);
sentence();
}
}
setState(196);
_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 HeaderContext extends ParserRuleContext {
public TerminalNode H1() { return getToken(ScenarioParser.H1, 0); }
public TerminalNode HEADLINE_TEXT() { return getToken(ScenarioParser.HEADLINE_TEXT, 0); }
public TerminalNode HEADLINE_END() { return getToken(ScenarioParser.HEADLINE_END, 0); }
public HeaderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_header; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitHeader(this);
}
}
public final HeaderContext header() throws RecognitionException {
HeaderContext _localctx = new HeaderContext(_ctx, getState());
enterRule(_localctx, 4, RULE_header);
try {
enterOuterAlt(_localctx, 1);
{
setState(197);
match(H1);
setState(198);
match(HEADLINE_TEXT);
setState(199);
match(HEADLINE_END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ActorContext extends ParserRuleContext {
public TerminalNode WE() { return getToken(ScenarioParser.WE, 0); }
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode THE() { return getToken(ScenarioParser.THE, 0); }
public ActorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_actor; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterActor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitActor(this);
}
}
public final ActorContext actor() throws RecognitionException {
ActorContext _localctx = new ActorContext(_ctx, getState());
enterRule(_localctx, 6, RULE_actor);
int _la;
try {
setState(206);
_errHandler.sync(this);
switch (_input.LA(1)) {
case WE:
enterOuterAlt(_localctx, 1);
{
setState(201);
match(WE);
}
break;
case ATTRIBUTE:
case EVERY:
case FALSE:
case LINK:
case MATCH:
case MATCHES:
case SOME:
case THE:
case TRUE:
case TYPE:
case WHERE:
case WHOSE:
case WORD:
enterOuterAlt(_localctx, 2);
{
setState(203);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THE) {
{
setState(202);
match(THE);
}
}
setState(205);
name();
}
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 SentenceContext extends ParserRuleContext {
public SimpleSentencesContext simpleSentences() {
return getRuleContext(SimpleSentencesContext.class,0);
}
public SentenceEndContext sentenceEnd() {
return getRuleContext(SentenceEndContext.class,0);
}
public CompoundSentenceContext compoundSentence() {
return getRuleContext(CompoundSentenceContext.class,0);
}
public DiagramSentenceContext diagramSentence() {
return getRuleContext(DiagramSentenceContext.class,0);
}
public SectionSentenceContext sectionSentence() {
return getRuleContext(SectionSentenceContext.class,0);
}
public CommentSentenceContext commentSentence() {
return getRuleContext(CommentSentenceContext.class,0);
}
public SentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sentence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitSentence(this);
}
}
public final SentenceContext sentence() throws RecognitionException {
SentenceContext _localctx = new SentenceContext(_ctx, getState());
enterRule(_localctx, 8, RULE_sentence);
try {
setState(217);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(208);
simpleSentences();
setState(209);
sentenceEnd();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(211);
compoundSentence();
setState(212);
sentenceEnd();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(214);
diagramSentence();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(215);
sectionSentence();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(216);
commentSentence();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SentenceEndContext extends ParserRuleContext {
public TerminalNode FULL_STOP() { return getToken(ScenarioParser.FULL_STOP, 0); }
public SentenceEndContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sentenceEnd; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterSentenceEnd(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitSentenceEnd(this);
}
}
public final SentenceEndContext sentenceEnd() throws RecognitionException {
SentenceEndContext _localctx = new SentenceEndContext(_ctx, getState());
enterRule(_localctx, 10, RULE_sentenceEnd);
try {
setState(221);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(219);
match(FULL_STOP);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(220);
if (!(_input.LA(-1) == CODE_BLOCK_END)) throw new FailedPredicateException(this, "_input.LA(-1) == CODE_BLOCK_END");
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SimpleSentenceContext extends ParserRuleContext {
public ThereSentenceContext thereSentence() {
return getRuleContext(ThereSentenceContext.class,0);
}
public IsSentenceContext isSentence() {
return getRuleContext(IsSentenceContext.class,0);
}
public AreSentenceContext areSentence() {
return getRuleContext(AreSentenceContext.class,0);
}
public HasSentenceContext hasSentence() {
return getRuleContext(HasSentenceContext.class,0);
}
public ExpectSentenceContext expectSentence() {
return getRuleContext(ExpectSentenceContext.class,0);
}
public MatchSentenceContext matchSentence() {
return getRuleContext(MatchSentenceContext.class,0);
}
public CreateSentenceContext createSentence() {
return getRuleContext(CreateSentenceContext.class,0);
}
public CallSentenceContext callSentence() {
return getRuleContext(CallSentenceContext.class,0);
}
public AnswerSentenceContext answerSentence() {
return getRuleContext(AnswerSentenceContext.class,0);
}
public WriteSentenceContext writeSentence() {
return getRuleContext(WriteSentenceContext.class,0);
}
public AddSentenceContext addSentence() {
return getRuleContext(AddSentenceContext.class,0);
}
public RemoveSentenceContext removeSentence() {
return getRuleContext(RemoveSentenceContext.class,0);
}
public SimpleSentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleSentence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterSimpleSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitSimpleSentence(this);
}
}
public final SimpleSentenceContext simpleSentence() throws RecognitionException {
SimpleSentenceContext _localctx = new SimpleSentenceContext(_ctx, getState());
enterRule(_localctx, 12, RULE_simpleSentence);
try {
setState(235);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(223);
thereSentence();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(224);
isSentence();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(225);
areSentence();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(226);
hasSentence();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(227);
expectSentence();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(228);
matchSentence();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(229);
createSentence();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(230);
callSentence();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(231);
answerSentence();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(232);
writeSentence();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(233);
addSentence();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(234);
removeSentence();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SimpleSentencesContext extends ParserRuleContext {
public List simpleSentence() {
return getRuleContexts(SimpleSentenceContext.class);
}
public SimpleSentenceContext simpleSentence(int i) {
return getRuleContext(SimpleSentenceContext.class,i);
}
public List sep() {
return getRuleContexts(SepContext.class);
}
public SepContext sep(int i) {
return getRuleContext(SepContext.class,i);
}
public CompoundSentenceContext compoundSentence() {
return getRuleContext(CompoundSentenceContext.class,0);
}
public SimpleSentencesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleSentences; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterSimpleSentences(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitSimpleSentences(this);
}
}
public final SimpleSentencesContext simpleSentences() throws RecognitionException {
SimpleSentencesContext _localctx = new SimpleSentencesContext(_ctx, getState());
enterRule(_localctx, 14, RULE_simpleSentences);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(237);
simpleSentence();
setState(243);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(238);
sep();
setState(239);
simpleSentence();
}
}
}
setState(245);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
}
setState(249);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
case 1:
{
setState(246);
sep();
setState(247);
compoundSentence();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CompoundSentenceContext extends ParserRuleContext {
public ConditionalSentenceContext conditionalSentence() {
return getRuleContext(ConditionalSentenceContext.class,0);
}
public TakeSentenceContext takeSentence() {
return getRuleContext(TakeSentenceContext.class,0);
}
public CompoundSentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_compoundSentence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterCompoundSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitCompoundSentence(this);
}
}
public final CompoundSentenceContext compoundSentence() throws RecognitionException {
CompoundSentenceContext _localctx = new CompoundSentenceContext(_ctx, getState());
enterRule(_localctx, 16, RULE_compoundSentence);
try {
setState(253);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
enterOuterAlt(_localctx, 1);
{
setState(251);
conditionalSentence();
}
break;
case ATTRIBUTE:
case EVERY:
case FALSE:
case LINK:
case MATCH:
case MATCHES:
case SOME:
case THE:
case TRUE:
case TYPE:
case WE:
case WHERE:
case WHOSE:
case WORD:
enterOuterAlt(_localctx, 2);
{
setState(252);
takeSentence();
}
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 SectionSentenceContext extends ParserRuleContext {
public TerminalNode H2() { return getToken(ScenarioParser.H2, 0); }
public TerminalNode HEADLINE_TEXT() { return getToken(ScenarioParser.HEADLINE_TEXT, 0); }
public TerminalNode HEADLINE_END() { return getToken(ScenarioParser.HEADLINE_END, 0); }
public SectionSentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sectionSentence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterSectionSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitSectionSentence(this);
}
}
public final SectionSentenceContext sectionSentence() throws RecognitionException {
SectionSentenceContext _localctx = new SectionSentenceContext(_ctx, getState());
enterRule(_localctx, 18, RULE_sectionSentence);
try {
enterOuterAlt(_localctx, 1);
{
setState(255);
match(H2);
setState(256);
match(HEADLINE_TEXT);
setState(257);
match(HEADLINE_END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CommentSentenceContext extends ParserRuleContext {
public TerminalNode HEADLINE_TEXT() { return getToken(ScenarioParser.HEADLINE_TEXT, 0); }
public TerminalNode HEADLINE_END() { return getToken(ScenarioParser.HEADLINE_END, 0); }
public TerminalNode LINE_COMMENT() { return getToken(ScenarioParser.LINE_COMMENT, 0); }
public TerminalNode BLOCKQUOTE() { return getToken(ScenarioParser.BLOCKQUOTE, 0); }
public CommentSentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_commentSentence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterCommentSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitCommentSentence(this);
}
}
public final CommentSentenceContext commentSentence() throws RecognitionException {
CommentSentenceContext _localctx = new CommentSentenceContext(_ctx, getState());
enterRule(_localctx, 20, RULE_commentSentence);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(259);
_la = _input.LA(1);
if ( !(_la==LINE_COMMENT || _la==BLOCKQUOTE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(260);
match(HEADLINE_TEXT);
setState(261);
match(HEADLINE_END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CodeBlockContext extends ParserRuleContext {
public TerminalNode CODE_BLOCK() { return getToken(ScenarioParser.CODE_BLOCK, 0); }
public TerminalNode CODE_BLOCK_END() { return getToken(ScenarioParser.CODE_BLOCK_END, 0); }
public TerminalNode CODE_BLOCK_LANGUAGE() { return getToken(ScenarioParser.CODE_BLOCK_LANGUAGE, 0); }
public List CODE_BLOCK_LINE() { return getTokens(ScenarioParser.CODE_BLOCK_LINE); }
public TerminalNode CODE_BLOCK_LINE(int i) {
return getToken(ScenarioParser.CODE_BLOCK_LINE, i);
}
public CodeBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_codeBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterCodeBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitCodeBlock(this);
}
}
public final CodeBlockContext codeBlock() throws RecognitionException {
CodeBlockContext _localctx = new CodeBlockContext(_ctx, getState());
enterRule(_localctx, 22, RULE_codeBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(263);
match(CODE_BLOCK);
setState(265);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CODE_BLOCK_LANGUAGE) {
{
setState(264);
match(CODE_BLOCK_LANGUAGE);
}
}
setState(270);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CODE_BLOCK_LINE) {
{
{
setState(267);
match(CODE_BLOCK_LINE);
}
}
setState(272);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(273);
match(CODE_BLOCK_END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ThereSentenceContext extends ParserRuleContext {
public TerminalNode THERE() { return getToken(ScenarioParser.THERE, 0); }
public TerminalNode IS() { return getToken(ScenarioParser.IS, 0); }
public SimpleDescriptorContext simpleDescriptor() {
return getRuleContext(SimpleDescriptorContext.class,0);
}
public TerminalNode ARE() { return getToken(ScenarioParser.ARE, 0); }
public MultiDescriptorContext multiDescriptor() {
return getRuleContext(MultiDescriptorContext.class,0);
}
public ThereSentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_thereSentence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterThereSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitThereSentence(this);
}
}
public final ThereSentenceContext thereSentence() throws RecognitionException {
ThereSentenceContext _localctx = new ThereSentenceContext(_ctx, getState());
enterRule(_localctx, 24, RULE_thereSentence);
try {
setState(281);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(275);
match(THERE);
setState(276);
match(IS);
setState(277);
simpleDescriptor();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(278);
match(THERE);
setState(279);
match(ARE);
setState(280);
multiDescriptor();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SimpleDescriptorContext extends ParserRuleContext {
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public TerminalNode A() { return getToken(ScenarioParser.A, 0); }
public TerminalNode AN() { return getToken(ScenarioParser.AN, 0); }
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public WithClausesContext withClauses() {
return getRuleContext(WithClausesContext.class,0);
}
public TerminalNode THE() { return getToken(ScenarioParser.THE, 0); }
public SimpleDescriptorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleDescriptor; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterSimpleDescriptor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitSimpleDescriptor(this);
}
}
public final SimpleDescriptorContext simpleDescriptor() throws RecognitionException {
SimpleDescriptorContext _localctx = new SimpleDescriptorContext(_ctx, getState());
enterRule(_localctx, 26, RULE_simpleDescriptor);
int _la;
try {
setState(297);
_errHandler.sync(this);
switch (_input.LA(1)) {
case A:
case AN:
enterOuterAlt(_localctx, 1);
{
setState(283);
_la = _input.LA(1);
if ( !(_la==A || _la==AN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(284);
typeName();
setState(286);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
{
setState(285);
name();
}
break;
}
setState(289);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
case 1:
{
setState(288);
withClauses();
}
break;
}
}
break;
case THE:
enterOuterAlt(_localctx, 2);
{
setState(291);
match(THE);
setState(292);
typeName();
setState(293);
name();
setState(295);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
{
setState(294);
withClauses();
}
break;
}
}
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 MultiDescriptorContext extends ParserRuleContext {
public TypesNameContext typesName() {
return getRuleContext(TypesNameContext.class,0);
}
public List name() {
return getRuleContexts(NameContext.class);
}
public NameContext name(int i) {
return getRuleContext(NameContext.class,i);
}
public WithClausesContext withClauses() {
return getRuleContext(WithClausesContext.class,0);
}
public List sep() {
return getRuleContexts(SepContext.class);
}
public SepContext sep(int i) {
return getRuleContext(SepContext.class,i);
}
public TerminalNode THE() { return getToken(ScenarioParser.THE, 0); }
public MultiDescriptorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiDescriptor; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterMultiDescriptor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitMultiDescriptor(this);
}
}
public final MultiDescriptorContext multiDescriptor() throws RecognitionException {
MultiDescriptorContext _localctx = new MultiDescriptorContext(_ctx, getState());
enterRule(_localctx, 28, RULE_multiDescriptor);
try {
int _alt;
setState(326);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ATTRIBUTE:
case EVERY:
case FALSE:
case LINK:
case MATCH:
case MATCHES:
case SOME:
case TRUE:
case TYPE:
case WHERE:
case WHOSE:
case WORD:
enterOuterAlt(_localctx, 1);
{
setState(299);
typesName();
setState(308);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
{
setState(300);
name();
setState(304);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(301);
sep();
setState(302);
name();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(306);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,17,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
break;
}
setState(311);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
case 1:
{
setState(310);
withClauses();
}
break;
}
}
break;
case THE:
enterOuterAlt(_localctx, 2);
{
setState(313);
match(THE);
setState(314);
typesName();
setState(315);
name();
setState(319);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(316);
sep();
setState(317);
name();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(321);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,20,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(324);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
case 1:
{
setState(323);
withClauses();
}
break;
}
}
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 TypeNameContext extends ParserRuleContext {
public SimpleNameContext simpleName() {
return getRuleContext(SimpleNameContext.class,0);
}
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode CARD() { return getToken(ScenarioParser.CARD, 0); }
public TypeNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterTypeName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitTypeName(this);
}
}
public final TypeNameContext typeName() throws RecognitionException {
TypeNameContext _localctx = new TypeNameContext(_ctx, getState());
enterRule(_localctx, 30, RULE_typeName);
try {
setState(332);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(328);
simpleName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(329);
name();
setState(330);
match(CARD);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypesNameContext extends ParserRuleContext {
public SimpleNameContext simpleName() {
return getRuleContext(SimpleNameContext.class,0);
}
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode CARDS() { return getToken(ScenarioParser.CARDS, 0); }
public TypesNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typesName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterTypesName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitTypesName(this);
}
}
public final TypesNameContext typesName() throws RecognitionException {
TypesNameContext _localctx = new TypesNameContext(_ctx, getState());
enterRule(_localctx, 32, RULE_typesName);
try {
setState(338);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(334);
simpleName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(335);
name();
setState(336);
match(CARDS);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IsSentenceContext extends ParserRuleContext {
public IsSentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_isSentence; }
public IsSentenceContext() { }
public void copyFrom(IsSentenceContext ctx) {
super.copyFrom(ctx);
}
}
public static class InheritanceIsSentenceContext extends IsSentenceContext {
public TerminalNode EVERY() { return getToken(ScenarioParser.EVERY, 0); }
public List typeName() {
return getRuleContexts(TypeNameContext.class);
}
public TypeNameContext typeName(int i) {
return getRuleContext(TypeNameContext.class,i);
}
public TerminalNode IS() { return getToken(ScenarioParser.IS, 0); }
public TerminalNode A() { return getToken(ScenarioParser.A, 0); }
public TerminalNode AN() { return getToken(ScenarioParser.AN, 0); }
public InheritanceIsSentenceContext(IsSentenceContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterInheritanceIsSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitInheritanceIsSentence(this);
}
}
public static class SimpleIsSentenceContext extends IsSentenceContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode IS() { return getToken(ScenarioParser.IS, 0); }
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public TerminalNode A() { return getToken(ScenarioParser.A, 0); }
public TerminalNode AN() { return getToken(ScenarioParser.AN, 0); }
public TerminalNode THE() { return getToken(ScenarioParser.THE, 0); }
public WithClausesContext withClauses() {
return getRuleContext(WithClausesContext.class,0);
}
public SimpleIsSentenceContext(IsSentenceContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterSimpleIsSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitSimpleIsSentence(this);
}
}
public final IsSentenceContext isSentence() throws RecognitionException {
IsSentenceContext _localctx = new IsSentenceContext(_ctx, getState());
enterRule(_localctx, 34, RULE_isSentence);
int _la;
try {
setState(356);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
case 1:
_localctx = new InheritanceIsSentenceContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(340);
match(EVERY);
setState(341);
typeName();
setState(342);
match(IS);
setState(343);
_la = _input.LA(1);
if ( !(_la==A || _la==AN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(344);
typeName();
}
break;
case 2:
_localctx = new SimpleIsSentenceContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(347);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THE) {
{
setState(346);
match(THE);
}
}
setState(349);
name();
setState(350);
match(IS);
setState(351);
_la = _input.LA(1);
if ( !(_la==A || _la==AN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(352);
typeName();
setState(354);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
case 1:
{
setState(353);
withClauses();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AreSentenceContext extends ParserRuleContext {
public List name() {
return getRuleContexts(NameContext.class);
}
public NameContext name(int i) {
return getRuleContext(NameContext.class,i);
}
public TerminalNode ARE() { return getToken(ScenarioParser.ARE, 0); }
public TypesNameContext typesName() {
return getRuleContext(TypesNameContext.class,0);
}
public List sep() {
return getRuleContexts(SepContext.class);
}
public SepContext sep(int i) {
return getRuleContext(SepContext.class,i);
}
public WithClausesContext withClauses() {
return getRuleContext(WithClausesContext.class,0);
}
public AreSentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_areSentence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterAreSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitAreSentence(this);
}
}
public final AreSentenceContext areSentence() throws RecognitionException {
AreSentenceContext _localctx = new AreSentenceContext(_ctx, getState());
enterRule(_localctx, 36, RULE_areSentence);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(358);
name();
setState(362);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(359);
sep();
setState(360);
name();
}
}
setState(364);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==AND || _la==COMMA );
setState(366);
match(ARE);
setState(367);
typesName();
setState(369);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) {
case 1:
{
setState(368);
withClauses();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WithClausesContext extends ParserRuleContext {
public List withClause() {
return getRuleContexts(WithClauseContext.class);
}
public WithClauseContext withClause(int i) {
return getRuleContext(WithClauseContext.class,i);
}
public List sep() {
return getRuleContexts(SepContext.class);
}
public SepContext sep(int i) {
return getRuleContext(SepContext.class,i);
}
public WithClausesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_withClauses; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterWithClauses(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitWithClauses(this);
}
}
public final WithClausesContext withClauses() throws RecognitionException {
WithClausesContext _localctx = new WithClausesContext(_ctx, getState());
enterRule(_localctx, 38, RULE_withClauses);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(371);
withClause();
setState(377);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,30,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(372);
sep();
setState(373);
withClause();
}
}
}
setState(379);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,30,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WithClauseContext extends ParserRuleContext {
public TerminalNode WITH() { return getToken(ScenarioParser.WITH, 0); }
public NamedExprContext namedExpr() {
return getRuleContext(NamedExprContext.class,0);
}
public WithClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_withClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterWithClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitWithClause(this);
}
}
public final WithClauseContext withClause() throws RecognitionException {
WithClauseContext _localctx = new WithClauseContext(_ctx, getState());
enterRule(_localctx, 40, RULE_withClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(380);
match(WITH);
setState(381);
namedExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NamedExprContext extends ParserRuleContext {
public NamedExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_namedExpr; }
public NamedExprContext() { }
public void copyFrom(NamedExprContext ctx) {
super.copyFrom(ctx);
}
}
public static class NamedSimpleContext extends NamedExprContext {
public SimpleNameContext simpleName() {
return getRuleContext(SimpleNameContext.class,0);
}
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode THE() { return getToken(ScenarioParser.THE, 0); }
public NamedSimpleContext(NamedExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterNamedSimple(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitNamedSimple(this);
}
}
public static class NamedNumberContext extends NamedExprContext {
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public NamedNumberContext(NamedExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterNamedNumber(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitNamedNumber(this);
}
}
public final NamedExprContext namedExpr() throws RecognitionException {
NamedExprContext _localctx = new NamedExprContext(_ctx, getState());
enterRule(_localctx, 42, RULE_namedExpr);
int _la;
try {
setState(392);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ATTRIBUTE:
case EVERY:
case FALSE:
case LINK:
case MATCH:
case MATCHES:
case SOME:
case THE:
case TRUE:
case TYPE:
case WHERE:
case WHOSE:
case WORD:
_localctx = new NamedSimpleContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(384);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THE) {
{
setState(383);
match(THE);
}
}
setState(386);
simpleName();
setState(387);
expr();
}
break;
case INTEGER:
case DECIMAL:
_localctx = new NamedNumberContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(389);
number();
setState(390);
name();
}
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 BidiNamedExprContext extends ParserRuleContext {
public SimpleNameContext firstName;
public SimpleNameContext otherName;
public TerminalNode AND() { return getToken(ScenarioParser.AND, 0); }
public List OF() { return getTokens(ScenarioParser.OF); }
public TerminalNode OF(int i) {
return getToken(ScenarioParser.OF, i);
}
public List simpleName() {
return getRuleContexts(SimpleNameContext.class);
}
public SimpleNameContext simpleName(int i) {
return getRuleContext(SimpleNameContext.class,i);
}
public TerminalNode IS() { return getToken(ScenarioParser.IS, 0); }
public TerminalNode ARE() { return getToken(ScenarioParser.ARE, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public APlaceholderContext aPlaceholder() {
return getRuleContext(APlaceholderContext.class,0);
}
public ManyPlaceholderContext manyPlaceholder() {
return getRuleContext(ManyPlaceholderContext.class,0);
}
public TerminalNode ONE() { return getToken(ScenarioParser.ONE, 0); }
public TerminalNode THE() { return getToken(ScenarioParser.THE, 0); }
public BidiNamedExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bidiNamedExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterBidiNamedExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitBidiNamedExpr(this);
}
}
public final BidiNamedExprContext bidiNamedExpr() throws RecognitionException {
BidiNamedExprContext _localctx = new BidiNamedExprContext(_ctx, getState());
enterRule(_localctx, 44, RULE_bidiNamedExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(394);
((BidiNamedExprContext)_localctx).firstName = simpleName();
setState(395);
match(AND);
setState(396);
_la = _input.LA(1);
if ( !(_la==ARE || _la==IS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(399);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ONE) {
{
setState(397);
match(ONE);
setState(398);
match(OF);
}
}
setState(402);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THE) {
{
setState(401);
match(THE);
}
}
setState(404);
((BidiNamedExprContext)_localctx).otherName = simpleName();
setState(405);
match(OF);
setState(409);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ALL:
case ANSWER:
case ATTRIBUTE:
case EVERY:
case FALSE:
case IT:
case LINK:
case MATCH:
case MATCHES:
case SOME:
case THE:
case TRUE:
case TYPE:
case WHERE:
case WHOSE:
case CODE_BLOCK:
case INTEGER:
case DECIMAL:
case STRING_LITERAL:
case WORD:
{
setState(406);
expr();
}
break;
case A:
case AN:
{
setState(407);
aPlaceholder();
}
break;
case MANY:
{
setState(408);
manyPlaceholder();
}
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 PlaceholderNamedExprContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public LikePlaceholderContext likePlaceholder() {
return getRuleContext(LikePlaceholderContext.class,0);
}
public OfTypePlaceholderContext ofTypePlaceholder() {
return getRuleContext(OfTypePlaceholderContext.class,0);
}
public TerminalNode A() { return getToken(ScenarioParser.A, 0); }
public TerminalNode AN() { return getToken(ScenarioParser.AN, 0); }
public PlaceholderNamedExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_placeholderNamedExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterPlaceholderNamedExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitPlaceholderNamedExpr(this);
}
}
public final PlaceholderNamedExprContext placeholderNamedExpr() throws RecognitionException {
PlaceholderNamedExprContext _localctx = new PlaceholderNamedExprContext(_ctx, getState());
enterRule(_localctx, 46, RULE_placeholderNamedExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(412);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==A || _la==AN) {
{
setState(411);
_la = _input.LA(1);
if ( !(_la==A || _la==AN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(414);
name();
setState(417);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LIKE:
{
setState(415);
likePlaceholder();
}
break;
case OF:
{
setState(416);
ofTypePlaceholder();
}
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 APlaceholderContext extends ParserRuleContext {
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public TerminalNode A() { return getToken(ScenarioParser.A, 0); }
public TerminalNode AN() { return getToken(ScenarioParser.AN, 0); }
public TerminalNode LIKE() { return getToken(ScenarioParser.LIKE, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public APlaceholderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_aPlaceholder; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterAPlaceholder(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitAPlaceholder(this);
}
}
public final APlaceholderContext aPlaceholder() throws RecognitionException {
APlaceholderContext _localctx = new APlaceholderContext(_ctx, getState());
enterRule(_localctx, 48, RULE_aPlaceholder);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(419);
_la = _input.LA(1);
if ( !(_la==A || _la==AN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(420);
typeName();
setState(423);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
case 1:
{
setState(421);
match(LIKE);
setState(422);
expr();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ManyPlaceholderContext extends ParserRuleContext {
public TerminalNode MANY() { return getToken(ScenarioParser.MANY, 0); }
public TypesNameContext typesName() {
return getRuleContext(TypesNameContext.class,0);
}
public TerminalNode LIKE() { return getToken(ScenarioParser.LIKE, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public ManyPlaceholderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_manyPlaceholder; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterManyPlaceholder(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitManyPlaceholder(this);
}
}
public final ManyPlaceholderContext manyPlaceholder() throws RecognitionException {
ManyPlaceholderContext _localctx = new ManyPlaceholderContext(_ctx, getState());
enterRule(_localctx, 50, RULE_manyPlaceholder);
try {
enterOuterAlt(_localctx, 1);
{
setState(425);
match(MANY);
setState(426);
typesName();
setState(429);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
case 1:
{
setState(427);
match(LIKE);
setState(428);
expr();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LikePlaceholderContext extends ParserRuleContext {
public TerminalNode LIKE() { return getToken(ScenarioParser.LIKE, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public LikePlaceholderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_likePlaceholder; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterLikePlaceholder(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitLikePlaceholder(this);
}
}
public final LikePlaceholderContext likePlaceholder() throws RecognitionException {
LikePlaceholderContext _localctx = new LikePlaceholderContext(_ctx, getState());
enterRule(_localctx, 52, RULE_likePlaceholder);
try {
enterOuterAlt(_localctx, 1);
{
setState(431);
match(LIKE);
setState(432);
expr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OfTypePlaceholderContext extends ParserRuleContext {
public TerminalNode OF() { return getToken(ScenarioParser.OF, 0); }
public TerminalNode TYPE() { return getToken(ScenarioParser.TYPE, 0); }
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public TerminalNode LIKE() { return getToken(ScenarioParser.LIKE, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public OfTypePlaceholderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ofTypePlaceholder; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterOfTypePlaceholder(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitOfTypePlaceholder(this);
}
}
public final OfTypePlaceholderContext ofTypePlaceholder() throws RecognitionException {
OfTypePlaceholderContext _localctx = new OfTypePlaceholderContext(_ctx, getState());
enterRule(_localctx, 54, RULE_ofTypePlaceholder);
try {
enterOuterAlt(_localctx, 1);
{
setState(434);
match(OF);
setState(435);
match(TYPE);
setState(436);
typeName();
setState(439);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
case 1:
{
setState(437);
match(LIKE);
setState(438);
expr();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EveryPlaceholderContext extends ParserRuleContext {
public TerminalNode EVERY() { return getToken(ScenarioParser.EVERY, 0); }
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public TerminalNode LIKE() { return getToken(ScenarioParser.LIKE, 0); }
public NameAccessContext nameAccess() {
return getRuleContext(NameAccessContext.class,0);
}
public EveryPlaceholderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_everyPlaceholder; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterEveryPlaceholder(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitEveryPlaceholder(this);
}
}
public final EveryPlaceholderContext everyPlaceholder() throws RecognitionException {
EveryPlaceholderContext _localctx = new EveryPlaceholderContext(_ctx, getState());
enterRule(_localctx, 56, RULE_everyPlaceholder);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(441);
match(EVERY);
setState(442);
typeName();
setState(445);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIKE) {
{
setState(443);
match(LIKE);
setState(444);
nameAccess();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HasSentenceContext extends ParserRuleContext {
public HasClausesContext hasClauses() {
return getRuleContext(HasClausesContext.class,0);
}
public EveryPlaceholderContext everyPlaceholder() {
return getRuleContext(EveryPlaceholderContext.class,0);
}
public NameAccessContext nameAccess() {
return getRuleContext(NameAccessContext.class,0);
}
public HasSentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hasSentence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterHasSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitHasSentence(this);
}
}
public final HasSentenceContext hasSentence() throws RecognitionException {
HasSentenceContext _localctx = new HasSentenceContext(_ctx, getState());
enterRule(_localctx, 58, RULE_hasSentence);
try {
enterOuterAlt(_localctx, 1);
{
setState(449);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
case 1:
{
setState(447);
everyPlaceholder();
}
break;
case 2:
{
setState(448);
nameAccess();
}
break;
}
setState(451);
hasClauses();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HasClausesContext extends ParserRuleContext {
public List hasClause() {
return getRuleContexts(HasClauseContext.class);
}
public HasClauseContext hasClause(int i) {
return getRuleContext(HasClauseContext.class,i);
}
public List sep() {
return getRuleContexts(SepContext.class);
}
public SepContext sep(int i) {
return getRuleContext(SepContext.class,i);
}
public HasClausesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hasClauses; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterHasClauses(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitHasClauses(this);
}
}
public final HasClausesContext hasClauses() throws RecognitionException {
HasClausesContext _localctx = new HasClausesContext(_ctx, getState());
enterRule(_localctx, 60, RULE_hasClauses);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(453);
hasClause();
setState(459);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,43,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(454);
sep();
setState(455);
hasClause();
}
}
}
setState(461);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,43,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HasClauseContext extends ParserRuleContext {
public Token verb;
public TerminalNode HAS() { return getToken(ScenarioParser.HAS, 0); }
public TerminalNode HAVE() { return getToken(ScenarioParser.HAVE, 0); }
public NamedExprContext namedExpr() {
return getRuleContext(NamedExprContext.class,0);
}
public BidiNamedExprContext bidiNamedExpr() {
return getRuleContext(BidiNamedExprContext.class,0);
}
public PlaceholderNamedExprContext placeholderNamedExpr() {
return getRuleContext(PlaceholderNamedExprContext.class,0);
}
public HasClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hasClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterHasClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitHasClause(this);
}
}
public final HasClauseContext hasClause() throws RecognitionException {
HasClauseContext _localctx = new HasClauseContext(_ctx, getState());
enterRule(_localctx, 62, RULE_hasClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(462);
((HasClauseContext)_localctx).verb = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==HAS || _la==HAVE) ) {
((HasClauseContext)_localctx).verb = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(466);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
{
setState(463);
namedExpr();
}
break;
case 2:
{
setState(464);
bidiNamedExpr();
}
break;
case 3:
{
setState(465);
placeholderNamedExpr();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateSentenceContext extends ParserRuleContext {
public Token verb;
public ActorContext actor() {
return getRuleContext(ActorContext.class,0);
}
public TerminalNode CREATE() { return getToken(ScenarioParser.CREATE, 0); }
public TerminalNode CREATES() { return getToken(ScenarioParser.CREATES, 0); }
public SimpleDescriptorContext simpleDescriptor() {
return getRuleContext(SimpleDescriptorContext.class,0);
}
public MultiDescriptorContext multiDescriptor() {
return getRuleContext(MultiDescriptorContext.class,0);
}
public CreateSentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createSentence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterCreateSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitCreateSentence(this);
}
}
public final CreateSentenceContext createSentence() throws RecognitionException {
CreateSentenceContext _localctx = new CreateSentenceContext(_ctx, getState());
enterRule(_localctx, 64, RULE_createSentence);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(468);
actor();
setState(469);
((CreateSentenceContext)_localctx).verb = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==CREATE || _la==CREATES) ) {
((CreateSentenceContext)_localctx).verb = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(472);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
case 1:
{
setState(470);
simpleDescriptor();
}
break;
case 2:
{
setState(471);
multiDescriptor();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CallSentenceContext extends ParserRuleContext {
public Token verb;
public ActorContext actor() {
return getRuleContext(ActorContext.class,0);
}
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode CALL() { return getToken(ScenarioParser.CALL, 0); }
public TerminalNode CALLS() { return getToken(ScenarioParser.CALLS, 0); }
public TerminalNode ON() { return getToken(ScenarioParser.ON, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public WithClausesContext withClauses() {
return getRuleContext(WithClausesContext.class,0);
}
public CallSentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_callSentence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterCallSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitCallSentence(this);
}
}
public final CallSentenceContext callSentence() throws RecognitionException {
CallSentenceContext _localctx = new CallSentenceContext(_ctx, getState());
enterRule(_localctx, 66, RULE_callSentence);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(474);
actor();
setState(475);
((CallSentenceContext)_localctx).verb = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==CALL || _la==CALLS) ) {
((CallSentenceContext)_localctx).verb = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(476);
name();
setState(479);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
case 1:
{
setState(477);
match(ON);
setState(478);
expr();
}
break;
}
setState(482);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) {
case 1:
{
setState(481);
withClauses();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnswerSentenceContext extends ParserRuleContext {
public Token verb;
public ActorContext actor() {
return getRuleContext(ActorContext.class,0);
}
public TerminalNode WITH() { return getToken(ScenarioParser.WITH, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode ANSWER() { return getToken(ScenarioParser.ANSWER, 0); }
public TerminalNode ANSWERS() { return getToken(ScenarioParser.ANSWERS, 0); }
public TerminalNode INTO() { return getToken(ScenarioParser.INTO, 0); }
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode THE() { return getToken(ScenarioParser.THE, 0); }
public AnswerSentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_answerSentence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterAnswerSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitAnswerSentence(this);
}
}
public final AnswerSentenceContext answerSentence() throws RecognitionException {
AnswerSentenceContext _localctx = new AnswerSentenceContext(_ctx, getState());
enterRule(_localctx, 68, RULE_answerSentence);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(484);
actor();
setState(485);
((AnswerSentenceContext)_localctx).verb = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ANSWER || _la==ANSWERS) ) {
((AnswerSentenceContext)_localctx).verb = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(486);
match(WITH);
setState(487);
expr();
setState(493);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
case 1:
{
setState(488);
match(INTO);
setState(490);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THE) {
{
setState(489);
match(THE);
}
}
setState(492);
name();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WriteSentenceContext extends ParserRuleContext {
public Token verb;
public ActorContext actor() {
return getRuleContext(ActorContext.class,0);
}
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode INTO() { return getToken(ScenarioParser.INTO, 0); }
public TerminalNode WRITE() { return getToken(ScenarioParser.WRITE, 0); }
public TerminalNode WRITES() { return getToken(ScenarioParser.WRITES, 0); }
public WriteSentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_writeSentence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterWriteSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitWriteSentence(this);
}
}
public final WriteSentenceContext writeSentence() throws RecognitionException {
WriteSentenceContext _localctx = new WriteSentenceContext(_ctx, getState());
enterRule(_localctx, 70, RULE_writeSentence);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(495);
actor();
setState(496);
((WriteSentenceContext)_localctx).verb = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==WRITE || _la==WRITES) ) {
((WriteSentenceContext)_localctx).verb = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(497);
expr();
setState(498);
match(INTO);
setState(499);
expr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AddSentenceContext extends ParserRuleContext {
public Token verb;
public ActorContext actor() {
return getRuleContext(ActorContext.class,0);
}
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode TO() { return getToken(ScenarioParser.TO, 0); }
public TerminalNode ADD() { return getToken(ScenarioParser.ADD, 0); }
public TerminalNode ADDS() { return getToken(ScenarioParser.ADDS, 0); }
public AddSentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_addSentence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterAddSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitAddSentence(this);
}
}
public final AddSentenceContext addSentence() throws RecognitionException {
AddSentenceContext _localctx = new AddSentenceContext(_ctx, getState());
enterRule(_localctx, 72, RULE_addSentence);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(501);
actor();
setState(502);
((AddSentenceContext)_localctx).verb = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ADD || _la==ADDS) ) {
((AddSentenceContext)_localctx).verb = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(503);
expr();
setState(504);
match(TO);
setState(505);
expr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RemoveSentenceContext extends ParserRuleContext {
public Token verb;
public ActorContext actor() {
return getRuleContext(ActorContext.class,0);
}
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode FROM() { return getToken(ScenarioParser.FROM, 0); }
public TerminalNode REMOVE() { return getToken(ScenarioParser.REMOVE, 0); }
public TerminalNode REMOVES() { return getToken(ScenarioParser.REMOVES, 0); }
public RemoveSentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_removeSentence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterRemoveSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitRemoveSentence(this);
}
}
public final RemoveSentenceContext removeSentence() throws RecognitionException {
RemoveSentenceContext _localctx = new RemoveSentenceContext(_ctx, getState());
enterRule(_localctx, 74, RULE_removeSentence);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(507);
actor();
setState(508);
((RemoveSentenceContext)_localctx).verb = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==REMOVE || _la==REMOVES) ) {
((RemoveSentenceContext)_localctx).verb = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(509);
expr();
setState(510);
match(FROM);
setState(511);
expr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConditionalSentenceContext extends ParserRuleContext {
public TerminalNode AS() { return getToken(ScenarioParser.AS, 0); }
public CondExprContext condExpr() {
return getRuleContext(CondExprContext.class,0);
}
public TerminalNode COMMA() { return getToken(ScenarioParser.COMMA, 0); }
public CompoundSentenceBodyContext compoundSentenceBody() {
return getRuleContext(CompoundSentenceBodyContext.class,0);
}
public ConditionalSentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conditionalSentence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterConditionalSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitConditionalSentence(this);
}
}
public final ConditionalSentenceContext conditionalSentence() throws RecognitionException {
ConditionalSentenceContext _localctx = new ConditionalSentenceContext(_ctx, getState());
enterRule(_localctx, 76, RULE_conditionalSentence);
try {
enterOuterAlt(_localctx, 1);
{
setState(513);
match(AS);
setState(514);
condExpr();
setState(515);
match(COMMA);
setState(516);
compoundSentenceBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TakeSentenceContext extends ParserRuleContext {
public Token verb;
public ExprContext example;
public SimpleNameContext simpleVarName;
public ExprContext source;
public ActorContext actor() {
return getRuleContext(ActorContext.class,0);
}
public TerminalNode FROM() { return getToken(ScenarioParser.FROM, 0); }
public TerminalNode AND() { return getToken(ScenarioParser.AND, 0); }
public CompoundSentenceBodyContext compoundSentenceBody() {
return getRuleContext(CompoundSentenceBodyContext.class,0);
}
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode TAKE() { return getToken(ScenarioParser.TAKE, 0); }
public TerminalNode TAKES() { return getToken(ScenarioParser.TAKES, 0); }
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode A() { return getToken(ScenarioParser.A, 0); }
public TerminalNode AN() { return getToken(ScenarioParser.AN, 0); }
public TerminalNode COMMA() { return getToken(ScenarioParser.COMMA, 0); }
public TerminalNode LIKE() { return getToken(ScenarioParser.LIKE, 0); }
public SimpleNameContext simpleName() {
return getRuleContext(SimpleNameContext.class,0);
}
public TerminalNode THE() { return getToken(ScenarioParser.THE, 0); }
public TakeSentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_takeSentence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterTakeSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitTakeSentence(this);
}
}
public final TakeSentenceContext takeSentence() throws RecognitionException {
TakeSentenceContext _localctx = new TakeSentenceContext(_ctx, getState());
enterRule(_localctx, 78, RULE_takeSentence);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(518);
actor();
setState(519);
((TakeSentenceContext)_localctx).verb = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==TAKE || _la==TAKES) ) {
((TakeSentenceContext)_localctx).verb = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(533);
_errHandler.sync(this);
switch (_input.LA(1)) {
case A:
case AN:
{
setState(520);
_la = _input.LA(1);
if ( !(_la==A || _la==AN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(521);
name();
setState(524);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIKE) {
{
setState(522);
match(LIKE);
setState(523);
((TakeSentenceContext)_localctx).example = expr();
}
}
}
break;
case ALL:
case ANSWER:
case ATTRIBUTE:
case EVERY:
case FALSE:
case IT:
case LINK:
case MATCH:
case MATCHES:
case SOME:
case THE:
case TRUE:
case TYPE:
case WHERE:
case WHOSE:
case CODE_BLOCK:
case INTEGER:
case DECIMAL:
case STRING_LITERAL:
case WORD:
{
setState(530);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) {
case 1:
{
setState(527);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THE) {
{
setState(526);
match(THE);
}
}
setState(529);
((TakeSentenceContext)_localctx).simpleVarName = simpleName();
}
break;
}
setState(532);
((TakeSentenceContext)_localctx).example = expr();
}
break;
default:
throw new NoViableAltException(this);
}
setState(535);
match(FROM);
setState(536);
((TakeSentenceContext)_localctx).source = expr();
setState(538);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(537);
match(COMMA);
}
}
setState(540);
match(AND);
setState(541);
compoundSentenceBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CompoundSentenceBodyContext extends ParserRuleContext {
public CompoundSentenceContext compoundSentence() {
return getRuleContext(CompoundSentenceContext.class,0);
}
public SimpleSentencesContext simpleSentences() {
return getRuleContext(SimpleSentencesContext.class,0);
}
public CompoundSentenceBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_compoundSentenceBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterCompoundSentenceBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitCompoundSentenceBody(this);
}
}
public final CompoundSentenceBodyContext compoundSentenceBody() throws RecognitionException {
CompoundSentenceBodyContext _localctx = new CompoundSentenceBodyContext(_ctx, getState());
enterRule(_localctx, 80, RULE_compoundSentenceBody);
try {
setState(545);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(543);
compoundSentence();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(544);
simpleSentences();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpectSentenceContext extends ParserRuleContext {
public TerminalNode WE() { return getToken(ScenarioParser.WE, 0); }
public TerminalNode EXPECT() { return getToken(ScenarioParser.EXPECT, 0); }
public ThatClausesContext thatClauses() {
return getRuleContext(ThatClausesContext.class,0);
}
public ExpectSentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expectSentence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterExpectSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitExpectSentence(this);
}
}
public final ExpectSentenceContext expectSentence() throws RecognitionException {
ExpectSentenceContext _localctx = new ExpectSentenceContext(_ctx, getState());
enterRule(_localctx, 82, RULE_expectSentence);
try {
enterOuterAlt(_localctx, 1);
{
setState(547);
match(WE);
setState(548);
match(EXPECT);
setState(549);
thatClauses();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ThatClausesContext extends ParserRuleContext {
public List thatClause() {
return getRuleContexts(ThatClauseContext.class);
}
public ThatClauseContext thatClause(int i) {
return getRuleContext(ThatClauseContext.class,i);
}
public List sep() {
return getRuleContexts(SepContext.class);
}
public SepContext sep(int i) {
return getRuleContext(SepContext.class,i);
}
public ThatClausesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_thatClauses; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterThatClauses(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitThatClauses(this);
}
}
public final ThatClausesContext thatClauses() throws RecognitionException {
ThatClausesContext _localctx = new ThatClausesContext(_ctx, getState());
enterRule(_localctx, 84, RULE_thatClauses);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(551);
thatClause();
setState(557);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,56,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(552);
sep();
setState(553);
thatClause();
}
}
}
setState(559);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,56,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ThatClauseContext extends ParserRuleContext {
public TerminalNode THAT() { return getToken(ScenarioParser.THAT, 0); }
public CondExprContext condExpr() {
return getRuleContext(CondExprContext.class,0);
}
public ThatClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_thatClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterThatClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitThatClause(this);
}
}
public final ThatClauseContext thatClause() throws RecognitionException {
ThatClauseContext _localctx = new ThatClauseContext(_ctx, getState());
enterRule(_localctx, 86, RULE_thatClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(560);
match(THAT);
setState(561);
condExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DiagramSentenceContext extends ParserRuleContext {
public Token fileName;
public TerminalNode IMG_START() { return getToken(ScenarioParser.IMG_START, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode IMG_SEP() { return getToken(ScenarioParser.IMG_SEP, 0); }
public TerminalNode IMG_END() { return getToken(ScenarioParser.IMG_END, 0); }
public TerminalNode FILE_NAME() { return getToken(ScenarioParser.FILE_NAME, 0); }
public DiagramSentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_diagramSentence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterDiagramSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitDiagramSentence(this);
}
}
public final DiagramSentenceContext diagramSentence() throws RecognitionException {
DiagramSentenceContext _localctx = new DiagramSentenceContext(_ctx, getState());
enterRule(_localctx, 88, RULE_diagramSentence);
try {
enterOuterAlt(_localctx, 1);
{
setState(563);
match(IMG_START);
setState(564);
expr();
setState(565);
match(IMG_SEP);
setState(566);
((DiagramSentenceContext)_localctx).fileName = match(FILE_NAME);
setState(567);
match(IMG_END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchSentenceContext extends ParserRuleContext {
public Token verb;
public ActorContext actor() {
return getRuleContext(ActorContext.class,0);
}
public PatternObjectsContext patternObjects() {
return getRuleContext(PatternObjectsContext.class,0);
}
public TerminalNode MATCH() { return getToken(ScenarioParser.MATCH, 0); }
public TerminalNode MATCHES() { return getToken(ScenarioParser.MATCHES, 0); }
public TerminalNode ON() { return getToken(ScenarioParser.ON, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public MatchSentenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchSentence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterMatchSentence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitMatchSentence(this);
}
}
public final MatchSentenceContext matchSentence() throws RecognitionException {
MatchSentenceContext _localctx = new MatchSentenceContext(_ctx, getState());
enterRule(_localctx, 90, RULE_matchSentence);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(569);
actor();
setState(570);
((MatchSentenceContext)_localctx).verb = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==MATCH || _la==MATCHES) ) {
((MatchSentenceContext)_localctx).verb = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(573);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(571);
match(ON);
setState(572);
expr();
}
}
setState(575);
patternObjects();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PatternObjectsContext extends ParserRuleContext {
public List patternObject() {
return getRuleContexts(PatternObjectContext.class);
}
public PatternObjectContext patternObject(int i) {
return getRuleContext(PatternObjectContext.class,i);
}
public List sep() {
return getRuleContexts(SepContext.class);
}
public SepContext sep(int i) {
return getRuleContext(SepContext.class,i);
}
public TerminalNode COLON() { return getToken(ScenarioParser.COLON, 0); }
public List BULLET() { return getTokens(ScenarioParser.BULLET); }
public TerminalNode BULLET(int i) {
return getToken(ScenarioParser.BULLET, i);
}
public List NUMBERED() { return getTokens(ScenarioParser.NUMBERED); }
public TerminalNode NUMBERED(int i) {
return getToken(ScenarioParser.NUMBERED, i);
}
public PatternObjectsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_patternObjects; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterPatternObjects(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitPatternObjects(this);
}
}
public final PatternObjectsContext patternObjects() throws RecognitionException {
PatternObjectsContext _localctx = new PatternObjectsContext(_ctx, getState());
enterRule(_localctx, 92, RULE_patternObjects);
int _la;
try {
int _alt;
setState(593);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ALL:
case SOME:
enterOuterAlt(_localctx, 1);
{
setState(577);
patternObject();
setState(583);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,58,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(578);
sep();
setState(579);
patternObject();
}
}
}
setState(585);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,58,_ctx);
}
}
break;
case COLON:
enterOuterAlt(_localctx, 2);
{
setState(586);
match(COLON);
setState(589);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(587);
_la = _input.LA(1);
if ( !(_la==BULLET || _la==NUMBERED) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(588);
patternObject();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(591);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,59,_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 PatternObjectContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode SOME() { return getToken(ScenarioParser.SOME, 0); }
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public TerminalNode ALL() { return getToken(ScenarioParser.ALL, 0); }
public TypesNameContext typesName() {
return getRuleContext(TypesNameContext.class,0);
}
public ConstraintsContext constraints() {
return getRuleContext(ConstraintsContext.class,0);
}
public PatternObjectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_patternObject; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterPatternObject(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitPatternObject(this);
}
}
public final PatternObjectContext patternObject() throws RecognitionException {
PatternObjectContext _localctx = new PatternObjectContext(_ctx, getState());
enterRule(_localctx, 94, RULE_patternObject);
try {
enterOuterAlt(_localctx, 1);
{
setState(599);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SOME:
{
setState(595);
match(SOME);
setState(596);
typeName();
}
break;
case ALL:
{
setState(597);
match(ALL);
setState(598);
typesName();
}
break;
default:
throw new NoViableAltException(this);
}
setState(601);
name();
setState(603);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
case 1:
{
setState(602);
constraints();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstraintsContext extends ParserRuleContext {
public List constraint() {
return getRuleContexts(ConstraintContext.class);
}
public ConstraintContext constraint(int i) {
return getRuleContext(ConstraintContext.class,i);
}
public List sep() {
return getRuleContexts(SepContext.class);
}
public SepContext sep(int i) {
return getRuleContext(SepContext.class,i);
}
public ConstraintsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constraints; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterConstraints(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitConstraints(this);
}
}
public final ConstraintsContext constraints() throws RecognitionException {
ConstraintsContext _localctx = new ConstraintsContext(_ctx, getState());
enterRule(_localctx, 96, RULE_constraints);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(605);
constraint();
setState(611);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,63,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(606);
sep();
setState(607);
constraint();
}
}
}
setState(613);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,63,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstraintContext extends ParserRuleContext {
public LinkConstraintContext linkConstraint() {
return getRuleContext(LinkConstraintContext.class,0);
}
public AttributeEqualityConstraintContext attributeEqualityConstraint() {
return getRuleContext(AttributeEqualityConstraintContext.class,0);
}
public AttributeConditionalConstraintContext attributeConditionalConstraint() {
return getRuleContext(AttributeConditionalConstraintContext.class,0);
}
public MatchConstraintContext matchConstraint() {
return getRuleContext(MatchConstraintContext.class,0);
}
public ConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitConstraint(this);
}
}
public final ConstraintContext constraint() throws RecognitionException {
ConstraintContext _localctx = new ConstraintContext(_ctx, getState());
enterRule(_localctx, 98, RULE_constraint);
try {
setState(618);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(614);
linkConstraint();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(615);
attributeEqualityConstraint();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(616);
attributeConditionalConstraint();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(617);
matchConstraint();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LinkConstraintContext extends ParserRuleContext {
public TerminalNode WITH() { return getToken(ScenarioParser.WITH, 0); }
public TerminalNode SOME() { return getToken(ScenarioParser.SOME, 0); }
public TerminalNode LINK() { return getToken(ScenarioParser.LINK, 0); }
public TerminalNode TO() { return getToken(ScenarioParser.TO, 0); }
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public LinkConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_linkConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterLinkConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitLinkConstraint(this);
}
}
public final LinkConstraintContext linkConstraint() throws RecognitionException {
LinkConstraintContext _localctx = new LinkConstraintContext(_ctx, getState());
enterRule(_localctx, 100, RULE_linkConstraint);
try {
enterOuterAlt(_localctx, 1);
{
setState(620);
match(WITH);
setState(621);
match(SOME);
setState(622);
match(LINK);
setState(623);
match(TO);
setState(624);
name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributeEqualityConstraintContext extends ParserRuleContext {
public TerminalNode WITH() { return getToken(ScenarioParser.WITH, 0); }
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public AttributeEqualityConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributeEqualityConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterAttributeEqualityConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitAttributeEqualityConstraint(this);
}
}
public final AttributeEqualityConstraintContext attributeEqualityConstraint() throws RecognitionException {
AttributeEqualityConstraintContext _localctx = new AttributeEqualityConstraintContext(_ctx, getState());
enterRule(_localctx, 102, RULE_attributeEqualityConstraint);
try {
enterOuterAlt(_localctx, 1);
{
setState(626);
match(WITH);
setState(633);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ATTRIBUTE:
case EVERY:
case FALSE:
case LINK:
case MATCH:
case MATCHES:
case SOME:
case TRUE:
case TYPE:
case WHERE:
case WHOSE:
case WORD:
{
setState(627);
name();
setState(628);
expr();
}
break;
case INTEGER:
case DECIMAL:
{
setState(630);
number();
setState(631);
name();
}
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 AttributeConditionalConstraintContext extends ParserRuleContext {
public ExprContext rhs;
public CondOpContext condOp() {
return getRuleContext(CondOpContext.class,0);
}
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode WHERE() { return getToken(ScenarioParser.WHERE, 0); }
public TerminalNode SOME() { return getToken(ScenarioParser.SOME, 0); }
public TerminalNode ATTRIBUTE() { return getToken(ScenarioParser.ATTRIBUTE, 0); }
public TerminalNode WHOSE() { return getToken(ScenarioParser.WHOSE, 0); }
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public AttributeConditionalConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributeConditionalConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterAttributeConditionalConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitAttributeConditionalConstraint(this);
}
}
public final AttributeConditionalConstraintContext attributeConditionalConstraint() throws RecognitionException {
AttributeConditionalConstraintContext _localctx = new AttributeConditionalConstraintContext(_ctx, getState());
enterRule(_localctx, 104, RULE_attributeConditionalConstraint);
try {
enterOuterAlt(_localctx, 1);
{
setState(640);
_errHandler.sync(this);
switch (_input.LA(1)) {
case WHERE:
{
setState(635);
match(WHERE);
setState(636);
match(SOME);
setState(637);
match(ATTRIBUTE);
}
break;
case WHOSE:
{
setState(638);
match(WHOSE);
setState(639);
name();
}
break;
default:
throw new NoViableAltException(this);
}
setState(642);
condOp();
setState(643);
((AttributeConditionalConstraintContext)_localctx).rhs = expr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributePredicateConstraintContext extends ParserRuleContext {
public PredOpContext predOp() {
return getRuleContext(PredOpContext.class,0);
}
public TerminalNode WHERE() { return getToken(ScenarioParser.WHERE, 0); }
public TerminalNode SOME() { return getToken(ScenarioParser.SOME, 0); }
public TerminalNode ATTRIBUTE() { return getToken(ScenarioParser.ATTRIBUTE, 0); }
public TerminalNode WHOSE() { return getToken(ScenarioParser.WHOSE, 0); }
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public AttributePredicateConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributePredicateConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterAttributePredicateConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitAttributePredicateConstraint(this);
}
}
public final AttributePredicateConstraintContext attributePredicateConstraint() throws RecognitionException {
AttributePredicateConstraintContext _localctx = new AttributePredicateConstraintContext(_ctx, getState());
enterRule(_localctx, 106, RULE_attributePredicateConstraint);
try {
enterOuterAlt(_localctx, 1);
{
setState(650);
_errHandler.sync(this);
switch (_input.LA(1)) {
case WHERE:
{
setState(645);
match(WHERE);
setState(646);
match(SOME);
setState(647);
match(ATTRIBUTE);
}
break;
case WHOSE:
{
setState(648);
match(WHOSE);
setState(649);
name();
}
break;
default:
throw new NoViableAltException(this);
}
setState(652);
predOp();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchConstraintContext extends ParserRuleContext {
public TerminalNode WHERE() { return getToken(ScenarioParser.WHERE, 0); }
public CondExprContext condExpr() {
return getRuleContext(CondExprContext.class,0);
}
public MatchConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterMatchConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitMatchConstraint(this);
}
}
public final MatchConstraintContext matchConstraint() throws RecognitionException {
MatchConstraintContext _localctx = new MatchConstraintContext(_ctx, getState());
enterRule(_localctx, 108, RULE_matchConstraint);
try {
enterOuterAlt(_localctx, 1);
{
setState(654);
match(WHERE);
setState(655);
condExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExprContext extends ParserRuleContext {
public AccessContext access() {
return getRuleContext(AccessContext.class,0);
}
public CollectionContext collection() {
return getRuleContext(CollectionContext.class,0);
}
public ExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitExpr(this);
}
}
public final ExprContext expr() throws RecognitionException {
ExprContext _localctx = new ExprContext(_ctx, getState());
enterRule(_localctx, 110, RULE_expr);
try {
setState(659);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(657);
access();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(658);
collection();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryContext extends ParserRuleContext {
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public BooleanLiteralContext booleanLiteral() {
return getRuleContext(BooleanLiteralContext.class,0);
}
public StringLiteralContext stringLiteral() {
return getRuleContext(StringLiteralContext.class,0);
}
public CodeBlockContext codeBlock() {
return getRuleContext(CodeBlockContext.class,0);
}
public ItContext it() {
return getRuleContext(ItContext.class,0);
}
public AnswerContext answer() {
return getRuleContext(AnswerContext.class,0);
}
public NameAccessContext nameAccess() {
return getRuleContext(NameAccessContext.class,0);
}
public PrimaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterPrimary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitPrimary(this);
}
}
public final PrimaryContext primary() throws RecognitionException {
PrimaryContext _localctx = new PrimaryContext(_ctx, getState());
enterRule(_localctx, 112, RULE_primary);
try {
setState(668);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(661);
number();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(662);
booleanLiteral();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(663);
stringLiteral();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(664);
codeBlock();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(665);
it();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(666);
answer();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(667);
nameAccess();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryExprContext extends ParserRuleContext {
public PrimaryContext primary() {
return getRuleContext(PrimaryContext.class,0);
}
public PrimaryExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterPrimaryExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitPrimaryExpr(this);
}
}
public final PrimaryExprContext primaryExpr() throws RecognitionException {
PrimaryExprContext _localctx = new PrimaryExprContext(_ctx, getState());
enterRule(_localctx, 114, RULE_primaryExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(670);
primary();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumberContext extends ParserRuleContext {
public TerminalNode DECIMAL() { return getToken(ScenarioParser.DECIMAL, 0); }
public TerminalNode INTEGER() { return getToken(ScenarioParser.INTEGER, 0); }
public NumberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_number; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterNumber(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitNumber(this);
}
}
public final NumberContext number() throws RecognitionException {
NumberContext _localctx = new NumberContext(_ctx, getState());
enterRule(_localctx, 116, RULE_number);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(672);
_la = _input.LA(1);
if ( !(_la==INTEGER || _la==DECIMAL) ) {
_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 BooleanLiteralContext extends ParserRuleContext {
public TerminalNode TRUE() { return getToken(ScenarioParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(ScenarioParser.FALSE, 0); }
public BooleanLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_booleanLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterBooleanLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitBooleanLiteral(this);
}
}
public final BooleanLiteralContext booleanLiteral() throws RecognitionException {
BooleanLiteralContext _localctx = new BooleanLiteralContext(_ctx, getState());
enterRule(_localctx, 118, RULE_booleanLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(674);
_la = _input.LA(1);
if ( !(_la==FALSE || _la==TRUE) ) {
_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 StringLiteralContext extends ParserRuleContext {
public TerminalNode STRING_LITERAL() { return getToken(ScenarioParser.STRING_LITERAL, 0); }
public StringLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitStringLiteral(this);
}
}
public final StringLiteralContext stringLiteral() throws RecognitionException {
StringLiteralContext _localctx = new StringLiteralContext(_ctx, getState());
enterRule(_localctx, 120, RULE_stringLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(676);
match(STRING_LITERAL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ItContext extends ParserRuleContext {
public TerminalNode IT() { return getToken(ScenarioParser.IT, 0); }
public ItContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_it; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterIt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitIt(this);
}
}
public final ItContext it() throws RecognitionException {
ItContext _localctx = new ItContext(_ctx, getState());
enterRule(_localctx, 122, RULE_it);
try {
enterOuterAlt(_localctx, 1);
{
setState(678);
match(IT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnswerContext extends ParserRuleContext {
public TerminalNode ANSWER() { return getToken(ScenarioParser.ANSWER, 0); }
public TerminalNode THE() { return getToken(ScenarioParser.THE, 0); }
public AnswerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_answer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterAnswer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitAnswer(this);
}
}
public final AnswerContext answer() throws RecognitionException {
AnswerContext _localctx = new AnswerContext(_ctx, getState());
enterRule(_localctx, 124, RULE_answer);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(681);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THE) {
{
setState(680);
match(THE);
}
}
setState(683);
match(ANSWER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SimpleNameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public SimpleNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterSimpleName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitSimpleName(this);
}
}
public final SimpleNameContext simpleName() throws RecognitionException {
SimpleNameContext _localctx = new SimpleNameContext(_ctx, getState());
enterRule(_localctx, 126, RULE_simpleName);
try {
enterOuterAlt(_localctx, 1);
{
setState(685);
identifier();
}
}
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 getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public List INTEGER() { return getTokens(ScenarioParser.INTEGER); }
public TerminalNode INTEGER(int i) {
return getToken(ScenarioParser.INTEGER, 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 ScenarioParserListener ) ((ScenarioParserListener)listener).enterName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitName(this);
}
}
public final NameContext name() throws RecognitionException {
NameContext _localctx = new NameContext(_ctx, getState());
enterRule(_localctx, 128, RULE_name);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(687);
identifier();
setState(692);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,72,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
setState(690);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ATTRIBUTE:
case EVERY:
case FALSE:
case LINK:
case MATCH:
case MATCHES:
case SOME:
case TRUE:
case TYPE:
case WHERE:
case WHOSE:
case WORD:
{
setState(688);
identifier();
}
break;
case INTEGER:
{
setState(689);
match(INTEGER);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(694);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,72,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdentifierContext extends ParserRuleContext {
public TerminalNode WORD() { return getToken(ScenarioParser.WORD, 0); }
public TerminalNode ATTRIBUTE() { return getToken(ScenarioParser.ATTRIBUTE, 0); }
public TerminalNode LINK() { return getToken(ScenarioParser.LINK, 0); }
public TerminalNode MATCH() { return getToken(ScenarioParser.MATCH, 0); }
public TerminalNode MATCHES() { return getToken(ScenarioParser.MATCHES, 0); }
public TerminalNode SOME() { return getToken(ScenarioParser.SOME, 0); }
public TerminalNode WHERE() { return getToken(ScenarioParser.WHERE, 0); }
public TerminalNode WHOSE() { return getToken(ScenarioParser.WHOSE, 0); }
public TerminalNode EVERY() { return getToken(ScenarioParser.EVERY, 0); }
public TerminalNode TYPE() { return getToken(ScenarioParser.TYPE, 0); }
public TerminalNode TRUE() { return getToken(ScenarioParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(ScenarioParser.FALSE, 0); }
public IdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitIdentifier(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 130, RULE_identifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(695);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ATTRIBUTE) | (1L << EVERY) | (1L << FALSE) | (1L << LINK) | (1L << MATCH) | (1L << MATCHES) | (1L << SOME) | (1L << TRUE))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TYPE - 64)) | (1L << (WHERE - 64)) | (1L << (WHOSE - 64)) | (1L << (WORD - 64)))) != 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 NameAccessContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode THE() { return getToken(ScenarioParser.THE, 0); }
public NameAccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nameAccess; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterNameAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitNameAccess(this);
}
}
public final NameAccessContext nameAccess() throws RecognitionException {
NameAccessContext _localctx = new NameAccessContext(_ctx, getState());
enterRule(_localctx, 132, RULE_nameAccess);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(698);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THE) {
{
setState(697);
match(THE);
}
}
setState(700);
name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AccessContext extends ParserRuleContext {
public PrimaryContext primary() {
return getRuleContext(PrimaryContext.class,0);
}
public AttributeAccessContext attributeAccess() {
return getRuleContext(AttributeAccessContext.class,0);
}
public ExampleAccessContext exampleAccess() {
return getRuleContext(ExampleAccessContext.class,0);
}
public FilterExprContext filterExpr() {
return getRuleContext(FilterExprContext.class,0);
}
public AccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_access; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitAccess(this);
}
}
public final AccessContext access() throws RecognitionException {
AccessContext _localctx = new AccessContext(_ctx, getState());
enterRule(_localctx, 134, RULE_access);
try {
setState(706);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(702);
primary();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(703);
attributeAccess();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(704);
exampleAccess();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(705);
filterExpr();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NamedAccessContext extends ParserRuleContext {
public NameAccessContext nameAccess() {
return getRuleContext(NameAccessContext.class,0);
}
public AttributeAccessContext attributeAccess() {
return getRuleContext(AttributeAccessContext.class,0);
}
public NamedAccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_namedAccess; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterNamedAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitNamedAccess(this);
}
}
public final NamedAccessContext namedAccess() throws RecognitionException {
NamedAccessContext _localctx = new NamedAccessContext(_ctx, getState());
enterRule(_localctx, 136, RULE_namedAccess);
try {
setState(710);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(708);
nameAccess();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(709);
attributeAccess();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NamedContext extends ParserRuleContext {
public NamedAccessContext namedAccess() {
return getRuleContext(NamedAccessContext.class,0);
}
public ExampleAccessContext exampleAccess() {
return getRuleContext(ExampleAccessContext.class,0);
}
public NamedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_named; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterNamed(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitNamed(this);
}
}
public final NamedContext named() throws RecognitionException {
NamedContext _localctx = new NamedContext(_ctx, getState());
enterRule(_localctx, 138, RULE_named);
try {
setState(714);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(712);
namedAccess();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(713);
exampleAccess();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributeAccessContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode OF() { return getToken(ScenarioParser.OF, 0); }
public AccessContext access() {
return getRuleContext(AccessContext.class,0);
}
public TerminalNode THE() { return getToken(ScenarioParser.THE, 0); }
public AttributeAccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributeAccess; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterAttributeAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitAttributeAccess(this);
}
}
public final AttributeAccessContext attributeAccess() throws RecognitionException {
AttributeAccessContext _localctx = new AttributeAccessContext(_ctx, getState());
enterRule(_localctx, 140, RULE_attributeAccess);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(717);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THE) {
{
setState(716);
match(THE);
}
}
setState(719);
name();
setState(720);
match(OF);
setState(721);
access();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExampleAccessContext extends ParserRuleContext {
public PrimaryExprContext primaryExpr() {
return getRuleContext(PrimaryExprContext.class,0);
}
public TerminalNode FROM() { return getToken(ScenarioParser.FROM, 0); }
public NamedAccessContext namedAccess() {
return getRuleContext(NamedAccessContext.class,0);
}
public ExampleAccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exampleAccess; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterExampleAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitExampleAccess(this);
}
}
public final ExampleAccessContext exampleAccess() throws RecognitionException {
ExampleAccessContext _localctx = new ExampleAccessContext(_ctx, getState());
enterRule(_localctx, 142, RULE_exampleAccess);
try {
enterOuterAlt(_localctx, 1);
{
setState(723);
primaryExpr();
setState(724);
match(FROM);
setState(725);
namedAccess();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FilterExprContext extends ParserRuleContext {
public TerminalNode ALL() { return getToken(ScenarioParser.ALL, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode WHICH() { return getToken(ScenarioParser.WHICH, 0); }
public CondExprContext condExpr() {
return getRuleContext(CondExprContext.class,0);
}
public FilterExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_filterExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterFilterExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitFilterExpr(this);
}
}
public final FilterExprContext filterExpr() throws RecognitionException {
FilterExprContext _localctx = new FilterExprContext(_ctx, getState());
enterRule(_localctx, 144, RULE_filterExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(727);
match(ALL);
setState(728);
expr();
setState(729);
match(WHICH);
setState(730);
condExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SepContext extends ParserRuleContext {
public TerminalNode COMMA() { return getToken(ScenarioParser.COMMA, 0); }
public TerminalNode AND() { return getToken(ScenarioParser.AND, 0); }
public SepContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sep; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterSep(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitSep(this);
}
}
public final SepContext sep() throws RecognitionException {
SepContext _localctx = new SepContext(_ctx, getState());
enterRule(_localctx, 146, RULE_sep);
try {
setState(736);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(732);
match(COMMA);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(733);
match(AND);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(734);
match(COMMA);
setState(735);
match(AND);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CollectionContext extends ParserRuleContext {
public ListContext list() {
return getRuleContext(ListContext.class,0);
}
public RangeContext range() {
return getRuleContext(RangeContext.class,0);
}
public CollectionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_collection; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterCollection(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitCollection(this);
}
}
public final CollectionContext collection() throws RecognitionException {
CollectionContext _localctx = new CollectionContext(_ctx, getState());
enterRule(_localctx, 148, RULE_collection);
try {
setState(740);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(738);
list();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(739);
range();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ListContext extends ParserRuleContext {
public List listElem() {
return getRuleContexts(ListElemContext.class);
}
public ListElemContext listElem(int i) {
return getRuleContext(ListElemContext.class,i);
}
public List sep() {
return getRuleContexts(SepContext.class);
}
public SepContext sep(int i) {
return getRuleContext(SepContext.class,i);
}
public ListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitList(this);
}
}
public final ListContext list() throws RecognitionException {
ListContext _localctx = new ListContext(_ctx, getState());
enterRule(_localctx, 150, RULE_list);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(742);
listElem();
setState(746);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(743);
sep();
setState(744);
listElem();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(748);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,80,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ListElemContext extends ParserRuleContext {
public AccessContext access() {
return getRuleContext(AccessContext.class,0);
}
public RangeContext range() {
return getRuleContext(RangeContext.class,0);
}
public ListElemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_listElem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterListElem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitListElem(this);
}
}
public final ListElemContext listElem() throws RecognitionException {
ListElemContext _localctx = new ListElemContext(_ctx, getState());
enterRule(_localctx, 152, RULE_listElem);
try {
setState(752);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(750);
access();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(751);
range();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RangeContext extends ParserRuleContext {
public List access() {
return getRuleContexts(AccessContext.class);
}
public AccessContext access(int i) {
return getRuleContext(AccessContext.class,i);
}
public TerminalNode TO() { return getToken(ScenarioParser.TO, 0); }
public RangeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_range; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterRange(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitRange(this);
}
}
public final RangeContext range() throws RecognitionException {
RangeContext _localctx = new RangeContext(_ctx, getState());
enterRule(_localctx, 154, RULE_range);
try {
enterOuterAlt(_localctx, 1);
{
setState(754);
access();
setState(755);
match(TO);
setState(756);
access();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CondExprContext extends ParserRuleContext {
public AndCondExprContext andCondExpr() {
return getRuleContext(AndCondExprContext.class,0);
}
public CondExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_condExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterCondExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitCondExpr(this);
}
}
public final CondExprContext condExpr() throws RecognitionException {
CondExprContext _localctx = new CondExprContext(_ctx, getState());
enterRule(_localctx, 156, RULE_condExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(758);
andCondExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AndCondExprContext extends ParserRuleContext {
public List orCondExpr() {
return getRuleContexts(OrCondExprContext.class);
}
public OrCondExprContext orCondExpr(int i) {
return getRuleContext(OrCondExprContext.class,i);
}
public List AND() { return getTokens(ScenarioParser.AND); }
public TerminalNode AND(int i) {
return getToken(ScenarioParser.AND, i);
}
public AndCondExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_andCondExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterAndCondExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitAndCondExpr(this);
}
}
public final AndCondExprContext andCondExpr() throws RecognitionException {
AndCondExprContext _localctx = new AndCondExprContext(_ctx, getState());
enterRule(_localctx, 158, RULE_andCondExpr);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(760);
orCondExpr();
setState(765);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,82,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(761);
match(AND);
setState(762);
orCondExpr();
}
}
}
setState(767);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,82,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrCondExprContext extends ParserRuleContext {
public List primaryCondExpr() {
return getRuleContexts(PrimaryCondExprContext.class);
}
public PrimaryCondExprContext primaryCondExpr(int i) {
return getRuleContext(PrimaryCondExprContext.class,i);
}
public List OR() { return getTokens(ScenarioParser.OR); }
public TerminalNode OR(int i) {
return getToken(ScenarioParser.OR, i);
}
public OrCondExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orCondExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterOrCondExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitOrCondExpr(this);
}
}
public final OrCondExprContext orCondExpr() throws RecognitionException {
OrCondExprContext _localctx = new OrCondExprContext(_ctx, getState());
enterRule(_localctx, 160, RULE_orCondExpr);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(768);
primaryCondExpr();
setState(773);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,83,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(769);
match(OR);
setState(770);
primaryCondExpr();
}
}
}
setState(775);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,83,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryCondExprContext extends ParserRuleContext {
public AttrCheckContext attrCheck() {
return getRuleContext(AttrCheckContext.class,0);
}
public CondOpExprContext condOpExpr() {
return getRuleContext(CondOpExprContext.class,0);
}
public PredOpExprContext predOpExpr() {
return getRuleContext(PredOpExprContext.class,0);
}
public PrimaryCondExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryCondExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterPrimaryCondExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitPrimaryCondExpr(this);
}
}
public final PrimaryCondExprContext primaryCondExpr() throws RecognitionException {
PrimaryCondExprContext _localctx = new PrimaryCondExprContext(_ctx, getState());
enterRule(_localctx, 162, RULE_primaryCondExpr);
try {
setState(779);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(776);
attrCheck();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(777);
condOpExpr();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(778);
predOpExpr();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttrCheckContext extends ParserRuleContext {
public NamedExprContext namedExpr() {
return getRuleContext(NamedExprContext.class,0);
}
public TerminalNode HAS() { return getToken(ScenarioParser.HAS, 0); }
public TerminalNode HAVE() { return getToken(ScenarioParser.HAVE, 0); }
public AccessContext access() {
return getRuleContext(AccessContext.class,0);
}
public AttrCheckContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attrCheck; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterAttrCheck(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitAttrCheck(this);
}
}
public final AttrCheckContext attrCheck() throws RecognitionException {
AttrCheckContext _localctx = new AttrCheckContext(_ctx, getState());
enterRule(_localctx, 164, RULE_attrCheck);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(782);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ALL) | (1L << ANSWER) | (1L << ATTRIBUTE) | (1L << EVERY) | (1L << FALSE) | (1L << IT) | (1L << LINK) | (1L << MATCH) | (1L << MATCHES) | (1L << SOME) | (1L << THE) | (1L << TRUE))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TYPE - 64)) | (1L << (WHERE - 64)) | (1L << (WHOSE - 64)) | (1L << (CODE_BLOCK - 64)) | (1L << (INTEGER - 64)) | (1L << (DECIMAL - 64)) | (1L << (STRING_LITERAL - 64)) | (1L << (WORD - 64)))) != 0)) {
{
setState(781);
access();
}
}
setState(784);
_la = _input.LA(1);
if ( !(_la==HAS || _la==HAVE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(785);
namedExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CondOpExprContext extends ParserRuleContext {
public AccessContext lhs;
public AccessContext rhs;
public CondOpContext condOp() {
return getRuleContext(CondOpContext.class,0);
}
public List access() {
return getRuleContexts(AccessContext.class);
}
public AccessContext access(int i) {
return getRuleContext(AccessContext.class,i);
}
public CondOpExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_condOpExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterCondOpExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitCondOpExpr(this);
}
}
public final CondOpExprContext condOpExpr() throws RecognitionException {
CondOpExprContext _localctx = new CondOpExprContext(_ctx, getState());
enterRule(_localctx, 166, RULE_condOpExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(788);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,86,_ctx) ) {
case 1:
{
setState(787);
((CondOpExprContext)_localctx).lhs = access();
}
break;
}
setState(790);
condOp();
setState(791);
((CondOpExprContext)_localctx).rhs = access();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CondOpContext extends ParserRuleContext {
public EqOpContext eqOp() {
return getRuleContext(EqOpContext.class,0);
}
public CmpOpContext cmpOp() {
return getRuleContext(CmpOpContext.class,0);
}
public CollOpContext collOp() {
return getRuleContext(CollOpContext.class,0);
}
public StrOpContext strOp() {
return getRuleContext(StrOpContext.class,0);
}
public CondOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_condOp; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterCondOp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitCondOp(this);
}
}
public final CondOpContext condOp() throws RecognitionException {
CondOpContext _localctx = new CondOpContext(_ctx, getState());
enterRule(_localctx, 168, RULE_condOp);
try {
setState(797);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(793);
eqOp();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(794);
cmpOp();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(795);
collOp();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(796);
strOp();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EqOpContext extends ParserRuleContext {
public TerminalNode IS() { return getToken(ScenarioParser.IS, 0); }
public TerminalNode ARE() { return getToken(ScenarioParser.ARE, 0); }
public TerminalNode NOT() { return getToken(ScenarioParser.NOT, 0); }
public TerminalNode THE() { return getToken(ScenarioParser.THE, 0); }
public TerminalNode SAME() { return getToken(ScenarioParser.SAME, 0); }
public TerminalNode AS() { return getToken(ScenarioParser.AS, 0); }
public EqOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eqOp; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterEqOp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitEqOp(this);
}
}
public final EqOpContext eqOp() throws RecognitionException {
EqOpContext _localctx = new EqOpContext(_ctx, getState());
enterRule(_localctx, 170, RULE_eqOp);
int _la;
try {
setState(812);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(799);
match(IS);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(800);
match(ARE);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(801);
_la = _input.LA(1);
if ( !(_la==ARE || _la==IS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(802);
match(NOT);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(803);
_la = _input.LA(1);
if ( !(_la==ARE || _la==IS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(804);
match(THE);
setState(805);
match(SAME);
setState(806);
match(AS);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(807);
_la = _input.LA(1);
if ( !(_la==ARE || _la==IS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(808);
match(NOT);
setState(809);
match(THE);
setState(810);
match(SAME);
setState(811);
match(AS);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CmpOpContext extends ParserRuleContext {
public TerminalNode LESS() { return getToken(ScenarioParser.LESS, 0); }
public TerminalNode THAN() { return getToken(ScenarioParser.THAN, 0); }
public TerminalNode IS() { return getToken(ScenarioParser.IS, 0); }
public TerminalNode ARE() { return getToken(ScenarioParser.ARE, 0); }
public TerminalNode NOT() { return getToken(ScenarioParser.NOT, 0); }
public TerminalNode EQUAL() { return getToken(ScenarioParser.EQUAL, 0); }
public TerminalNode GREATER() { return getToken(ScenarioParser.GREATER, 0); }
public CmpOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_cmpOp; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterCmpOp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitCmpOp(this);
}
}
public final CmpOpContext cmpOp() throws RecognitionException {
CmpOpContext _localctx = new CmpOpContext(_ctx, getState());
enterRule(_localctx, 172, RULE_cmpOp);
int _la;
try {
setState(834);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(814);
_la = _input.LA(1);
if ( !(_la==ARE || _la==IS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(815);
match(LESS);
setState(816);
match(THAN);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(817);
_la = _input.LA(1);
if ( !(_la==ARE || _la==IS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(818);
match(NOT);
setState(819);
match(LESS);
setState(820);
match(THAN);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(821);
_la = _input.LA(1);
if ( !(_la==ARE || _la==IS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(822);
match(LESS);
setState(823);
match(EQUAL);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(824);
_la = _input.LA(1);
if ( !(_la==ARE || _la==IS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(825);
match(GREATER);
setState(826);
match(THAN);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(827);
_la = _input.LA(1);
if ( !(_la==ARE || _la==IS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(828);
match(GREATER);
setState(829);
match(EQUAL);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(830);
_la = _input.LA(1);
if ( !(_la==ARE || _la==IS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(831);
match(NOT);
setState(832);
match(GREATER);
setState(833);
match(THAN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CollOpContext extends ParserRuleContext {
public TerminalNode CONTAIN() { return getToken(ScenarioParser.CONTAIN, 0); }
public TerminalNode CONTAINS() { return getToken(ScenarioParser.CONTAINS, 0); }
public TerminalNode NOT() { return getToken(ScenarioParser.NOT, 0); }
public TerminalNode DO() { return getToken(ScenarioParser.DO, 0); }
public TerminalNode DOES() { return getToken(ScenarioParser.DOES, 0); }
public CollOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_collOp; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterCollOp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitCollOp(this);
}
}
public final CollOpContext collOp() throws RecognitionException {
CollOpContext _localctx = new CollOpContext(_ctx, getState());
enterRule(_localctx, 174, RULE_collOp);
int _la;
try {
setState(841);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CONTAIN:
enterOuterAlt(_localctx, 1);
{
setState(836);
match(CONTAIN);
}
break;
case CONTAINS:
enterOuterAlt(_localctx, 2);
{
setState(837);
match(CONTAINS);
}
break;
case DO:
case DOES:
enterOuterAlt(_localctx, 3);
{
setState(838);
_la = _input.LA(1);
if ( !(_la==DO || _la==DOES) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(839);
match(NOT);
setState(840);
match(CONTAIN);
}
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 StrOpContext extends ParserRuleContext {
public TerminalNode MATCH() { return getToken(ScenarioParser.MATCH, 0); }
public TerminalNode MATCHES() { return getToken(ScenarioParser.MATCHES, 0); }
public StrOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_strOp; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterStrOp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitStrOp(this);
}
}
public final StrOpContext strOp() throws RecognitionException {
StrOpContext _localctx = new StrOpContext(_ctx, getState());
enterRule(_localctx, 176, RULE_strOp);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(843);
_la = _input.LA(1);
if ( !(_la==MATCH || _la==MATCHES) ) {
_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 PredOpExprContext extends ParserRuleContext {
public AccessContext lhs;
public PredOpContext predOp() {
return getRuleContext(PredOpContext.class,0);
}
public AccessContext access() {
return getRuleContext(AccessContext.class,0);
}
public PredOpExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_predOpExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterPredOpExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitPredOpExpr(this);
}
}
public final PredOpExprContext predOpExpr() throws RecognitionException {
PredOpExprContext _localctx = new PredOpExprContext(_ctx, getState());
enterRule(_localctx, 178, RULE_predOpExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(846);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ALL) | (1L << ANSWER) | (1L << ATTRIBUTE) | (1L << EVERY) | (1L << FALSE) | (1L << IT) | (1L << LINK) | (1L << MATCH) | (1L << MATCHES) | (1L << SOME) | (1L << THE) | (1L << TRUE))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TYPE - 64)) | (1L << (WHERE - 64)) | (1L << (WHOSE - 64)) | (1L << (CODE_BLOCK - 64)) | (1L << (INTEGER - 64)) | (1L << (DECIMAL - 64)) | (1L << (STRING_LITERAL - 64)) | (1L << (WORD - 64)))) != 0)) {
{
setState(845);
((PredOpExprContext)_localctx).lhs = access();
}
}
setState(848);
predOp();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PredOpContext extends ParserRuleContext {
public TerminalNode EMPTY() { return getToken(ScenarioParser.EMPTY, 0); }
public TerminalNode IS() { return getToken(ScenarioParser.IS, 0); }
public TerminalNode ARE() { return getToken(ScenarioParser.ARE, 0); }
public TerminalNode NOT() { return getToken(ScenarioParser.NOT, 0); }
public PredOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_predOp; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).enterPredOp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ScenarioParserListener ) ((ScenarioParserListener)listener).exitPredOp(this);
}
}
public final PredOpContext predOp() throws RecognitionException {
PredOpContext _localctx = new PredOpContext(_ctx, getState());
enterRule(_localctx, 180, RULE_predOp);
int _la;
try {
setState(855);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(850);
_la = _input.LA(1);
if ( !(_la==ARE || _la==IS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(851);
match(EMPTY);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(852);
_la = _input.LA(1);
if ( !(_la==ARE || _la==IS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(853);
match(NOT);
setState(854);
match(EMPTY);
}
break;
}
}
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 5:
return sentenceEnd_sempred((SentenceEndContext)_localctx, predIndex);
}
return true;
}
private boolean sentenceEnd_sempred(SentenceEndContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return _input.LA(-1) == CODE_BLOCK_END;
}
return true;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3f\u035c\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 \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\3\2\7\2\u00ba\n\2\f"+
"\2\16\2\u00bd\13\2\3\2\3\2\3\3\3\3\7\3\u00c3\n\3\f\3\16\3\u00c6\13\3\3"+
"\4\3\4\3\4\3\4\3\5\3\5\5\5\u00ce\n\5\3\5\5\5\u00d1\n\5\3\6\3\6\3\6\3\6"+
"\3\6\3\6\3\6\3\6\3\6\5\6\u00dc\n\6\3\7\3\7\5\7\u00e0\n\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\5\b\u00ee\n\b\3\t\3\t\3\t\3\t\7\t\u00f4"+
"\n\t\f\t\16\t\u00f7\13\t\3\t\3\t\3\t\5\t\u00fc\n\t\3\n\3\n\5\n\u0100\n"+
"\n\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\r\3\r\5\r\u010c\n\r\3\r\7\r\u010f"+
"\n\r\f\r\16\r\u0112\13\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\16\5\16\u011c"+
"\n\16\3\17\3\17\3\17\5\17\u0121\n\17\3\17\5\17\u0124\n\17\3\17\3\17\3"+
"\17\3\17\5\17\u012a\n\17\5\17\u012c\n\17\3\20\3\20\3\20\3\20\3\20\6\20"+
"\u0133\n\20\r\20\16\20\u0134\5\20\u0137\n\20\3\20\5\20\u013a\n\20\3\20"+
"\3\20\3\20\3\20\3\20\3\20\6\20\u0142\n\20\r\20\16\20\u0143\3\20\5\20\u0147"+
"\n\20\5\20\u0149\n\20\3\21\3\21\3\21\3\21\5\21\u014f\n\21\3\22\3\22\3"+
"\22\3\22\5\22\u0155\n\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23\5\23\u015e"+
"\n\23\3\23\3\23\3\23\3\23\3\23\5\23\u0165\n\23\5\23\u0167\n\23\3\24\3"+
"\24\3\24\3\24\6\24\u016d\n\24\r\24\16\24\u016e\3\24\3\24\3\24\5\24\u0174"+
"\n\24\3\25\3\25\3\25\3\25\7\25\u017a\n\25\f\25\16\25\u017d\13\25\3\26"+
"\3\26\3\26\3\27\5\27\u0183\n\27\3\27\3\27\3\27\3\27\3\27\3\27\5\27\u018b"+
"\n\27\3\30\3\30\3\30\3\30\3\30\5\30\u0192\n\30\3\30\5\30\u0195\n\30\3"+
"\30\3\30\3\30\3\30\3\30\5\30\u019c\n\30\3\31\5\31\u019f\n\31\3\31\3\31"+
"\3\31\5\31\u01a4\n\31\3\32\3\32\3\32\3\32\5\32\u01aa\n\32\3\33\3\33\3"+
"\33\3\33\5\33\u01b0\n\33\3\34\3\34\3\34\3\35\3\35\3\35\3\35\3\35\5\35"+
"\u01ba\n\35\3\36\3\36\3\36\3\36\5\36\u01c0\n\36\3\37\3\37\5\37\u01c4\n"+
"\37\3\37\3\37\3 \3 \3 \3 \7 \u01cc\n \f \16 \u01cf\13 \3!\3!\3!\3!\5!"+
"\u01d5\n!\3\"\3\"\3\"\3\"\5\"\u01db\n\"\3#\3#\3#\3#\3#\5#\u01e2\n#\3#"+
"\5#\u01e5\n#\3$\3$\3$\3$\3$\3$\5$\u01ed\n$\3$\5$\u01f0\n$\3%\3%\3%\3%"+
"\3%\3%\3&\3&\3&\3&\3&\3&\3\'\3\'\3\'\3\'\3\'\3\'\3(\3(\3(\3(\3(\3)\3)"+
"\3)\3)\3)\3)\5)\u020f\n)\3)\5)\u0212\n)\3)\5)\u0215\n)\3)\5)\u0218\n)"+
"\3)\3)\3)\5)\u021d\n)\3)\3)\3)\3*\3*\5*\u0224\n*\3+\3+\3+\3+\3,\3,\3,"+
"\3,\7,\u022e\n,\f,\16,\u0231\13,\3-\3-\3-\3.\3.\3.\3.\3.\3.\3/\3/\3/\3"+
"/\5/\u0240\n/\3/\3/\3\60\3\60\3\60\3\60\7\60\u0248\n\60\f\60\16\60\u024b"+
"\13\60\3\60\3\60\3\60\6\60\u0250\n\60\r\60\16\60\u0251\5\60\u0254\n\60"+
"\3\61\3\61\3\61\3\61\5\61\u025a\n\61\3\61\3\61\5\61\u025e\n\61\3\62\3"+
"\62\3\62\3\62\7\62\u0264\n\62\f\62\16\62\u0267\13\62\3\63\3\63\3\63\3"+
"\63\5\63\u026d\n\63\3\64\3\64\3\64\3\64\3\64\3\64\3\65\3\65\3\65\3\65"+
"\3\65\3\65\3\65\5\65\u027c\n\65\3\66\3\66\3\66\3\66\3\66\5\66\u0283\n"+
"\66\3\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67\5\67\u028d\n\67\3\67\3\67"+
"\38\38\38\39\39\59\u0296\n9\3:\3:\3:\3:\3:\3:\3:\5:\u029f\n:\3;\3;\3<"+
"\3<\3=\3=\3>\3>\3?\3?\3@\5@\u02ac\n@\3@\3@\3A\3A\3B\3B\3B\7B\u02b5\nB"+
"\fB\16B\u02b8\13B\3C\3C\3D\5D\u02bd\nD\3D\3D\3E\3E\3E\3E\5E\u02c5\nE\3"+
"F\3F\5F\u02c9\nF\3G\3G\5G\u02cd\nG\3H\5H\u02d0\nH\3H\3H\3H\3H\3I\3I\3"+
"I\3I\3J\3J\3J\3J\3J\3K\3K\3K\3K\5K\u02e3\nK\3L\3L\5L\u02e7\nL\3M\3M\3"+
"M\3M\6M\u02ed\nM\rM\16M\u02ee\3N\3N\5N\u02f3\nN\3O\3O\3O\3O\3P\3P\3Q\3"+
"Q\3Q\7Q\u02fe\nQ\fQ\16Q\u0301\13Q\3R\3R\3R\7R\u0306\nR\fR\16R\u0309\13"+
"R\3S\3S\3S\5S\u030e\nS\3T\5T\u0311\nT\3T\3T\3T\3U\5U\u0317\nU\3U\3U\3"+
"U\3V\3V\3V\3V\5V\u0320\nV\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\5W\u032f"+
"\nW\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\5X\u0345"+
"\nX\3Y\3Y\3Y\3Y\3Y\5Y\u034c\nY\3Z\3Z\3[\5[\u0351\n[\3[\3[\3\\\3\\\3\\"+
"\3\\\3\\\5\\\u035a\n\\\3\\\2\2]\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36"+
" \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082"+
"\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a"+
"\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2"+
"\u00b4\u00b6\2\23\3\2MN\4\2\3\3\7\7\4\2\13\13%%\3\2!\"\3\2\25\26\3\2\16"+
"\17\3\2\t\n\3\2IJ\3\2\4\5\3\2\65\66\3\29:\3\2+,\3\2PQ\3\2VW\4\2\36\36"+
"AA\f\2\r\r\34\34\36\36))+,88ABFFHHYY\3\2\27\30\2\u0381\2\u00bb\3\2\2\2"+
"\4\u00c0\3\2\2\2\6\u00c7\3\2\2\2\b\u00d0\3\2\2\2\n\u00db\3\2\2\2\f\u00df"+
"\3\2\2\2\16\u00ed\3\2\2\2\20\u00ef\3\2\2\2\22\u00ff\3\2\2\2\24\u0101\3"+
"\2\2\2\26\u0105\3\2\2\2\30\u0109\3\2\2\2\32\u011b\3\2\2\2\34\u012b\3\2"+
"\2\2\36\u0148\3\2\2\2 \u014e\3\2\2\2\"\u0154\3\2\2\2$\u0166\3\2\2\2&\u0168"+
"\3\2\2\2(\u0175\3\2\2\2*\u017e\3\2\2\2,\u018a\3\2\2\2.\u018c\3\2\2\2\60"+
"\u019e\3\2\2\2\62\u01a5\3\2\2\2\64\u01ab\3\2\2\2\66\u01b1\3\2\2\28\u01b4"+
"\3\2\2\2:\u01bb\3\2\2\2<\u01c3\3\2\2\2>\u01c7\3\2\2\2@\u01d0\3\2\2\2B"+
"\u01d6\3\2\2\2D\u01dc\3\2\2\2F\u01e6\3\2\2\2H\u01f1\3\2\2\2J\u01f7\3\2"+
"\2\2L\u01fd\3\2\2\2N\u0203\3\2\2\2P\u0208\3\2\2\2R\u0223\3\2\2\2T\u0225"+
"\3\2\2\2V\u0229\3\2\2\2X\u0232\3\2\2\2Z\u0235\3\2\2\2\\\u023b\3\2\2\2"+
"^\u0253\3\2\2\2`\u0259\3\2\2\2b\u025f\3\2\2\2d\u026c\3\2\2\2f\u026e\3"+
"\2\2\2h\u0274\3\2\2\2j\u0282\3\2\2\2l\u028c\3\2\2\2n\u0290\3\2\2\2p\u0295"+
"\3\2\2\2r\u029e\3\2\2\2t\u02a0\3\2\2\2v\u02a2\3\2\2\2x\u02a4\3\2\2\2z"+
"\u02a6\3\2\2\2|\u02a8\3\2\2\2~\u02ab\3\2\2\2\u0080\u02af\3\2\2\2\u0082"+
"\u02b1\3\2\2\2\u0084\u02b9\3\2\2\2\u0086\u02bc\3\2\2\2\u0088\u02c4\3\2"+
"\2\2\u008a\u02c8\3\2\2\2\u008c\u02cc\3\2\2\2\u008e\u02cf\3\2\2\2\u0090"+
"\u02d5\3\2\2\2\u0092\u02d9\3\2\2\2\u0094\u02e2\3\2\2\2\u0096\u02e6\3\2"+
"\2\2\u0098\u02e8\3\2\2\2\u009a\u02f2\3\2\2\2\u009c\u02f4\3\2\2\2\u009e"+
"\u02f8\3\2\2\2\u00a0\u02fa\3\2\2\2\u00a2\u0302\3\2\2\2\u00a4\u030d\3\2"+
"\2\2\u00a6\u0310\3\2\2\2\u00a8\u0316\3\2\2\2\u00aa\u031f\3\2\2\2\u00ac"+
"\u032e\3\2\2\2\u00ae\u0344\3\2\2\2\u00b0\u034b\3\2\2\2\u00b2\u034d\3\2"+
"\2\2\u00b4\u0350\3\2\2\2\u00b6\u0359\3\2\2\2\u00b8\u00ba\5\4\3\2\u00b9"+
"\u00b8\3\2\2\2\u00ba\u00bd\3\2\2\2\u00bb\u00b9\3\2\2\2\u00bb\u00bc\3\2"+
"\2\2\u00bc\u00be\3\2\2\2\u00bd\u00bb\3\2\2\2\u00be\u00bf\7\2\2\3\u00bf"+
"\3\3\2\2\2\u00c0\u00c4\5\6\4\2\u00c1\u00c3\5\n\6\2\u00c2\u00c1\3\2\2\2"+
"\u00c3\u00c6\3\2\2\2\u00c4\u00c2\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5\5\3"+
"\2\2\2\u00c6\u00c4\3\2\2\2\u00c7\u00c8\7K\2\2\u00c8\u00c9\7b\2\2\u00c9"+
"\u00ca\7a\2\2\u00ca\7\3\2\2\2\u00cb\u00d1\7D\2\2\u00cc\u00ce\7=\2\2\u00cd"+
"\u00cc\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce\u00cf\3\2\2\2\u00cf\u00d1\5\u0082"+
"B\2\u00d0\u00cb\3\2\2\2\u00d0\u00cd\3\2\2\2\u00d1\t\3\2\2\2\u00d2\u00d3"+
"\5\20\t\2\u00d3\u00d4\5\f\7\2\u00d4\u00dc\3\2\2\2\u00d5\u00d6\5\22\n\2"+
"\u00d6\u00d7\5\f\7\2\u00d7\u00dc\3\2\2\2\u00d8\u00dc\5Z.\2\u00d9\u00dc"+
"\5\24\13\2\u00da\u00dc\5\26\f\2\u00db\u00d2\3\2\2\2\u00db\u00d5\3\2\2"+
"\2\u00db\u00d8\3\2\2\2\u00db\u00d9\3\2\2\2\u00db\u00da\3\2\2\2\u00dc\13"+
"\3\2\2\2\u00dd\u00e0\7S\2\2\u00de\u00e0\6\7\2\2\u00df\u00dd\3\2\2\2\u00df"+
"\u00de\3\2\2\2\u00e0\r\3\2\2\2\u00e1\u00ee\5\32\16\2\u00e2\u00ee\5$\23"+
"\2\u00e3\u00ee\5&\24\2\u00e4\u00ee\5<\37\2\u00e5\u00ee\5T+\2\u00e6\u00ee"+
"\5\\/\2\u00e7\u00ee\5B\"\2\u00e8\u00ee\5D#\2\u00e9\u00ee\5F$\2\u00ea\u00ee"+
"\5H%\2\u00eb\u00ee\5J&\2\u00ec\u00ee\5L\'\2\u00ed\u00e1\3\2\2\2\u00ed"+
"\u00e2\3\2\2\2\u00ed\u00e3\3\2\2\2\u00ed\u00e4\3\2\2\2\u00ed\u00e5\3\2"+
"\2\2\u00ed\u00e6\3\2\2\2\u00ed\u00e7\3\2\2\2\u00ed\u00e8\3\2\2\2\u00ed"+
"\u00e9\3\2\2\2\u00ed\u00ea\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ec\3\2"+
"\2\2\u00ee\17\3\2\2\2\u00ef\u00f5\5\16\b\2\u00f0\u00f1\5\u0094K\2\u00f1"+
"\u00f2\5\16\b\2\u00f2\u00f4\3\2\2\2\u00f3\u00f0\3\2\2\2\u00f4\u00f7\3"+
"\2\2\2\u00f5\u00f3\3\2\2\2\u00f5\u00f6\3\2\2\2\u00f6\u00fb\3\2\2\2\u00f7"+
"\u00f5\3\2\2\2\u00f8\u00f9\5\u0094K\2\u00f9\u00fa\5\22\n\2\u00fa\u00fc"+
"\3\2\2\2\u00fb\u00f8\3\2\2\2\u00fb\u00fc\3\2\2\2\u00fc\21\3\2\2\2\u00fd"+
"\u0100\5N(\2\u00fe\u0100\5P)\2\u00ff\u00fd\3\2\2\2\u00ff\u00fe\3\2\2\2"+
"\u0100\23\3\2\2\2\u0101\u0102\7L\2\2\u0102\u0103\7b\2\2\u0103\u0104\7"+
"a\2\2\u0104\25\3\2\2\2\u0105\u0106\t\2\2\2\u0106\u0107\7b\2\2\u0107\u0108"+
"\7a\2\2\u0108\27\3\2\2\2\u0109\u010b\7O\2\2\u010a\u010c\7d\2\2\u010b\u010a"+
"\3\2\2\2\u010b\u010c\3\2\2\2\u010c\u0110\3\2\2\2\u010d\u010f\7f\2\2\u010e"+
"\u010d\3\2\2\2\u010f\u0112\3\2\2\2\u0110\u010e\3\2\2\2\u0110\u0111\3\2"+
"\2\2\u0111\u0113\3\2\2\2\u0112\u0110\3\2\2\2\u0113\u0114\7e\2\2\u0114"+
"\31\3\2\2\2\u0115\u0116\7?\2\2\u0116\u0117\7%\2\2\u0117\u011c\5\34\17"+
"\2\u0118\u0119\7?\2\2\u0119\u011a\7\13\2\2\u011a\u011c\5\36\20\2\u011b"+
"\u0115\3\2\2\2\u011b\u0118\3\2\2\2\u011c\33\3\2\2\2\u011d\u011e\t\3\2"+
"\2\u011e\u0120\5 \21\2\u011f\u0121\5\u0082B\2\u0120\u011f\3\2\2\2\u0120"+
"\u0121\3\2\2\2\u0121\u0123\3\2\2\2\u0122\u0124\5(\25\2\u0123\u0122\3\2"+
"\2\2\u0123\u0124\3\2\2\2\u0124\u012c\3\2\2\2\u0125\u0126\7=\2\2\u0126"+
"\u0127\5 \21\2\u0127\u0129\5\u0082B\2\u0128\u012a\5(\25\2\u0129\u0128"+
"\3\2\2\2\u0129\u012a\3\2\2\2\u012a\u012c\3\2\2\2\u012b\u011d\3\2\2\2\u012b"+
"\u0125\3\2\2\2\u012c\35\3\2\2\2\u012d\u0136\5\"\22\2\u012e\u0132\5\u0082"+
"B\2\u012f\u0130\5\u0094K\2\u0130\u0131\5\u0082B\2\u0131\u0133\3\2\2\2"+
"\u0132\u012f\3\2\2\2\u0133\u0134\3\2\2\2\u0134\u0132\3\2\2\2\u0134\u0135"+
"\3\2\2\2\u0135\u0137\3\2\2\2\u0136\u012e\3\2\2\2\u0136\u0137\3\2\2\2\u0137"+
"\u0139\3\2\2\2\u0138\u013a\5(\25\2\u0139\u0138\3\2\2\2\u0139\u013a\3\2"+
"\2\2\u013a\u0149\3\2\2\2\u013b\u013c\7=\2\2\u013c\u013d\5\"\22\2\u013d"+
"\u0141\5\u0082B\2\u013e\u013f\5\u0094K\2\u013f\u0140\5\u0082B\2\u0140"+
"\u0142\3\2\2\2\u0141\u013e\3\2\2\2\u0142\u0143\3\2\2\2\u0143\u0141\3\2"+
"\2\2\u0143\u0144\3\2\2\2\u0144\u0146\3\2\2\2\u0145\u0147\5(\25\2\u0146"+
"\u0145\3\2\2\2\u0146\u0147\3\2\2\2\u0147\u0149\3\2\2\2\u0148\u012d\3\2"+
"\2\2\u0148\u013b\3\2\2\2\u0149\37\3\2\2\2\u014a\u014f\5\u0080A\2\u014b"+
"\u014c\5\u0082B\2\u014c\u014d\7\20\2\2\u014d\u014f\3\2\2\2\u014e\u014a"+
"\3\2\2\2\u014e\u014b\3\2\2\2\u014f!\3\2\2\2\u0150\u0155\5\u0080A\2\u0151"+
"\u0152\5\u0082B\2\u0152\u0153\7\21\2\2\u0153\u0155\3\2\2\2\u0154\u0150"+
"\3\2\2\2\u0154\u0151\3\2\2\2\u0155#\3\2\2\2\u0156\u0157\7\34\2\2\u0157"+
"\u0158\5 \21\2\u0158\u0159\7%\2\2\u0159\u015a\t\3\2\2\u015a\u015b\5 \21"+
"\2\u015b\u0167\3\2\2\2\u015c\u015e\7=\2\2\u015d\u015c\3\2\2\2\u015d\u015e"+
"\3\2\2\2\u015e\u015f\3\2\2\2\u015f\u0160\5\u0082B\2\u0160\u0161\7%\2\2"+
"\u0161\u0162\t\3\2\2\u0162\u0164\5 \21\2\u0163\u0165\5(\25\2\u0164\u0163"+
"\3\2\2\2\u0164\u0165\3\2\2\2\u0165\u0167\3\2\2\2\u0166\u0156\3\2\2\2\u0166"+
"\u015d\3\2\2\2\u0167%\3\2\2\2\u0168\u016c\5\u0082B\2\u0169\u016a\5\u0094"+
"K\2\u016a\u016b\5\u0082B\2\u016b\u016d\3\2\2\2\u016c\u0169\3\2\2\2\u016d"+
"\u016e\3\2\2\2\u016e\u016c\3\2\2\2\u016e\u016f\3\2\2\2\u016f\u0170\3\2"+
"\2\2\u0170\u0171\7\13\2\2\u0171\u0173\5\"\22\2\u0172\u0174\5(\25\2\u0173"+
"\u0172\3\2\2\2\u0173\u0174\3\2\2\2\u0174\'\3\2\2\2\u0175\u017b\5*\26\2"+
"\u0176\u0177\5\u0094K\2\u0177\u0178\5*\26\2\u0178\u017a\3\2\2\2\u0179"+
"\u0176\3\2\2\2\u017a\u017d\3\2\2\2\u017b\u0179\3\2\2\2\u017b\u017c\3\2"+
"\2\2\u017c)\3\2\2\2\u017d\u017b\3\2\2\2\u017e\u017f\7E\2\2\u017f\u0180"+
"\5,\27\2\u0180+\3\2\2\2\u0181\u0183\7=\2\2\u0182\u0181\3\2\2\2\u0182\u0183"+
"\3\2\2\2\u0183\u0184\3\2\2\2\u0184\u0185\5\u0080A\2\u0185\u0186\5p9\2"+
"\u0186\u018b\3\2\2\2\u0187\u0188\5v<\2\u0188\u0189\5\u0082B\2\u0189\u018b"+
"\3\2\2\2\u018a\u0182\3\2\2\2\u018a\u0187\3\2\2\2\u018b-\3\2\2\2\u018c"+
"\u018d\5\u0080A\2\u018d\u018e\7\b\2\2\u018e\u0191\t\4\2\2\u018f\u0190"+
"\7\61\2\2\u0190\u0192\7.\2\2\u0191\u018f\3\2\2\2\u0191\u0192\3\2\2\2\u0192"+
"\u0194\3\2\2\2\u0193\u0195\7=\2\2\u0194\u0193\3\2\2\2\u0194\u0195\3\2"+
"\2\2\u0195\u0196\3\2\2\2\u0196\u0197\5\u0080A\2\u0197\u019b\7.\2\2\u0198"+
"\u019c\5p9\2\u0199\u019c\5\62\32\2\u019a\u019c\5\64\33\2\u019b\u0198\3"+
"\2\2\2\u019b\u0199\3\2\2\2\u019b\u019a\3\2\2\2\u019c/\3\2\2\2\u019d\u019f"+
"\t\3\2\2\u019e\u019d\3\2\2\2\u019e\u019f\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0"+
"\u01a3\5\u0082B\2\u01a1\u01a4\5\66\34\2\u01a2\u01a4\58\35\2\u01a3\u01a1"+
"\3\2\2\2\u01a3\u01a2\3\2\2\2\u01a4\61\3\2\2\2\u01a5\u01a6\t\3\2\2\u01a6"+
"\u01a9\5 \21\2\u01a7\u01a8\7(\2\2\u01a8\u01aa\5p9\2\u01a9\u01a7\3\2\2"+
"\2\u01a9\u01aa\3\2\2\2\u01aa\63\3\2\2\2\u01ab\u01ac\7*\2\2\u01ac\u01af"+
"\5\"\22\2\u01ad\u01ae\7(\2\2\u01ae\u01b0\5p9\2\u01af\u01ad\3\2\2\2\u01af"+
"\u01b0\3\2\2\2\u01b0\65\3\2\2\2\u01b1\u01b2\7(\2\2\u01b2\u01b3\5p9\2\u01b3"+
"\67\3\2\2\2\u01b4\u01b5\7.\2\2\u01b5\u01b6\7B\2\2\u01b6\u01b9\5 \21\2"+
"\u01b7\u01b8\7(\2\2\u01b8\u01ba\5p9\2\u01b9\u01b7\3\2\2\2\u01b9\u01ba"+
"\3\2\2\2\u01ba9\3\2\2\2\u01bb\u01bc\7\34\2\2\u01bc\u01bf\5 \21\2\u01bd"+
"\u01be\7(\2\2\u01be\u01c0\5\u0086D\2\u01bf\u01bd\3\2\2\2\u01bf\u01c0\3"+
"\2\2\2\u01c0;\3\2\2\2\u01c1\u01c4\5:\36\2\u01c2\u01c4\5\u0086D\2\u01c3"+
"\u01c1\3\2\2\2\u01c3\u01c2\3\2\2\2\u01c4\u01c5\3\2\2\2\u01c5\u01c6\5>"+
" \2\u01c6=\3\2\2\2\u01c7\u01cd\5@!\2\u01c8\u01c9\5\u0094K\2\u01c9\u01ca"+
"\5@!\2\u01ca\u01cc\3\2\2\2\u01cb\u01c8\3\2\2\2\u01cc\u01cf\3\2\2\2\u01cd"+
"\u01cb\3\2\2\2\u01cd\u01ce\3\2\2\2\u01ce?\3\2\2\2\u01cf\u01cd\3\2\2\2"+
"\u01d0\u01d4\t\5\2\2\u01d1\u01d5\5,\27\2\u01d2\u01d5\5.\30\2\u01d3\u01d5"+
"\5\60\31\2\u01d4\u01d1\3\2\2\2\u01d4\u01d2\3\2\2\2\u01d4\u01d3\3\2\2\2"+
"\u01d5A\3\2\2\2\u01d6\u01d7\5\b\5\2\u01d7\u01da\t\6\2\2\u01d8\u01db\5"+
"\34\17\2\u01d9\u01db\5\36\20\2\u01da\u01d8\3\2\2\2\u01da\u01d9\3\2\2\2"+
"\u01dbC\3\2\2\2\u01dc\u01dd\5\b\5\2\u01dd\u01de\t\7\2\2\u01de\u01e1\5"+
"\u0082B\2\u01df\u01e0\7\60\2\2\u01e0\u01e2\5p9\2\u01e1\u01df\3\2\2\2\u01e1"+
"\u01e2\3\2\2\2\u01e2\u01e4\3\2\2\2\u01e3\u01e5\5(\25\2\u01e4\u01e3\3\2"+
"\2\2\u01e4\u01e5\3\2\2\2\u01e5E\3\2\2\2\u01e6\u01e7\5\b\5\2\u01e7\u01e8"+
"\t\b\2\2\u01e8\u01e9\7E\2\2\u01e9\u01ef\5p9\2\u01ea\u01ec\7$\2\2\u01eb"+
"\u01ed\7=\2\2\u01ec\u01eb\3\2\2\2\u01ec\u01ed\3\2\2\2\u01ed\u01ee\3\2"+
"\2\2\u01ee\u01f0\5\u0082B\2\u01ef\u01ea\3\2\2\2\u01ef\u01f0\3\2\2\2\u01f0"+
"G\3\2\2\2\u01f1\u01f2\5\b\5\2\u01f2\u01f3\t\t\2\2\u01f3\u01f4\5p9\2\u01f4"+
"\u01f5\7$\2\2\u01f5\u01f6\5p9\2\u01f6I\3\2\2\2\u01f7\u01f8\5\b\5\2\u01f8"+
"\u01f9\t\n\2\2\u01f9\u01fa\5p9\2\u01fa\u01fb\7C\2\2\u01fb\u01fc\5p9\2"+
"\u01fcK\3\2\2\2\u01fd\u01fe\5\b\5\2\u01fe\u01ff\t\13\2\2\u01ff\u0200\5"+
"p9\2\u0200\u0201\7\37\2\2\u0201\u0202\5p9\2\u0202M\3\2\2\2\u0203\u0204"+
"\7\f\2\2\u0204\u0205\5\u009eP\2\u0205\u0206\7R\2\2\u0206\u0207\5R*\2\u0207"+
"O\3\2\2\2\u0208\u0209\5\b\5\2\u0209\u0217\t\f\2\2\u020a\u020b\t\3\2\2"+
"\u020b\u020e\5\u0082B\2\u020c\u020d\7(\2\2\u020d\u020f\5p9\2\u020e\u020c"+
"\3\2\2\2\u020e\u020f\3\2\2\2\u020f\u0218\3\2\2\2\u0210\u0212\7=\2\2\u0211"+
"\u0210\3\2\2\2\u0211\u0212\3\2\2\2\u0212\u0213\3\2\2\2\u0213\u0215\5\u0080"+
"A\2\u0214\u0211\3\2\2\2\u0214\u0215\3\2\2\2\u0215\u0216\3\2\2\2\u0216"+
"\u0218\5p9\2\u0217\u020a\3\2\2\2\u0217\u0214\3\2\2\2\u0218\u0219\3\2\2"+
"\2\u0219\u021a\7\37\2\2\u021a\u021c\5p9\2\u021b\u021d\7R\2\2\u021c\u021b"+
"\3\2\2\2\u021c\u021d\3\2\2\2\u021d\u021e\3\2\2\2\u021e\u021f\7\b\2\2\u021f"+
"\u0220\5R*\2\u0220Q\3\2\2\2\u0221\u0224\5\22\n\2\u0222\u0224\5\20\t\2"+
"\u0223\u0221\3\2\2\2\u0223\u0222\3\2\2\2\u0224S\3\2\2\2\u0225\u0226\7"+
"D\2\2\u0226\u0227\7\35\2\2\u0227\u0228\5V,\2\u0228U\3\2\2\2\u0229\u022f"+
"\5X-\2\u022a\u022b\5\u0094K\2\u022b\u022c\5X-\2\u022c\u022e\3\2\2\2\u022d"+
"\u022a\3\2\2\2\u022e\u0231\3\2\2\2\u022f\u022d\3\2\2\2\u022f\u0230\3\2"+
"\2\2\u0230W\3\2\2\2\u0231\u022f\3\2\2\2\u0232\u0233\7<\2\2\u0233\u0234"+
"\5\u009eP\2\u0234Y\3\2\2\2\u0235\u0236\7]\2\2\u0236\u0237\5p9\2\u0237"+
"\u0238\7^\2\2\u0238\u0239\7`\2\2\u0239\u023a\7_\2\2\u023a[\3\2\2\2\u023b"+
"\u023c\5\b\5\2\u023c\u023f\t\r\2\2\u023d\u023e\7\60\2\2\u023e\u0240\5"+
"p9\2\u023f\u023d\3\2\2\2\u023f\u0240\3\2\2\2\u0240\u0241\3\2\2\2\u0241"+
"\u0242\5^\60\2\u0242]\3\2\2\2\u0243\u0249\5`\61\2\u0244\u0245\5\u0094"+
"K\2\u0245\u0246\5`\61\2\u0246\u0248\3\2\2\2\u0247\u0244\3\2\2\2\u0248"+
"\u024b\3\2\2\2\u0249\u0247\3\2\2\2\u0249\u024a\3\2\2\2\u024a\u0254\3\2"+
"\2\2\u024b\u0249\3\2\2\2\u024c\u024f\7U\2\2\u024d\u024e\t\16\2\2\u024e"+
"\u0250\5`\61\2\u024f\u024d\3\2\2\2\u0250\u0251\3\2\2\2\u0251\u024f\3\2"+
"\2\2\u0251\u0252\3\2\2\2\u0252\u0254\3\2\2\2\u0253\u0243\3\2\2\2\u0253"+
"\u024c\3\2\2\2\u0254_\3\2\2\2\u0255\u0256\78\2\2\u0256\u025a\5 \21\2\u0257"+
"\u0258\7\6\2\2\u0258\u025a\5\"\22\2\u0259\u0255\3\2\2\2\u0259\u0257\3"+
"\2\2\2\u025a\u025b\3\2\2\2\u025b\u025d\5\u0082B\2\u025c\u025e\5b\62\2"+
"\u025d\u025c\3\2\2\2\u025d\u025e\3\2\2\2\u025ea\3\2\2\2\u025f\u0265\5"+
"d\63\2\u0260\u0261\5\u0094K\2\u0261\u0262\5d\63\2\u0262\u0264\3\2\2\2"+
"\u0263\u0260\3\2\2\2\u0264\u0267\3\2\2\2\u0265\u0263\3\2\2\2\u0265\u0266"+
"\3\2\2\2\u0266c\3\2\2\2\u0267\u0265\3\2\2\2\u0268\u026d\5f\64\2\u0269"+
"\u026d\5h\65\2\u026a\u026d\5j\66\2\u026b\u026d\5n8\2\u026c\u0268\3\2\2"+
"\2\u026c\u0269\3\2\2\2\u026c\u026a\3\2\2\2\u026c\u026b\3\2\2\2\u026de"+
"\3\2\2\2\u026e\u026f\7E\2\2\u026f\u0270\78\2\2\u0270\u0271\7)\2\2\u0271"+
"\u0272\7C\2\2\u0272\u0273\5\u0082B\2\u0273g\3\2\2\2\u0274\u027b\7E\2\2"+
"\u0275\u0276\5\u0082B\2\u0276\u0277\5p9\2\u0277\u027c\3\2\2\2\u0278\u0279"+
"\5v<\2\u0279\u027a\5\u0082B\2\u027a\u027c\3\2\2\2\u027b\u0275\3\2\2\2"+
"\u027b\u0278\3\2\2\2\u027ci\3\2\2\2\u027d\u027e\7F\2\2\u027e\u027f\78"+
"\2\2\u027f\u0283\7\r\2\2\u0280\u0281\7H\2\2\u0281\u0283\5\u0082B\2\u0282"+
"\u027d\3\2\2\2\u0282\u0280\3\2\2\2\u0283\u0284\3\2\2\2\u0284\u0285\5\u00aa"+
"V\2\u0285\u0286\5p9\2\u0286k\3\2\2\2\u0287\u0288\7F\2\2\u0288\u0289\7"+
"8\2\2\u0289\u028d\7\r\2\2\u028a\u028b\7H\2\2\u028b\u028d\5\u0082B\2\u028c"+
"\u0287\3\2\2\2\u028c\u028a\3\2\2\2\u028d\u028e\3\2\2\2\u028e\u028f\5\u00b6"+
"\\\2\u028fm\3\2\2\2\u0290\u0291\7F\2\2\u0291\u0292\5\u009eP\2\u0292o\3"+
"\2\2\2\u0293\u0296\5\u0088E\2\u0294\u0296\5\u0096L\2\u0295\u0293\3\2\2"+
"\2\u0295\u0294\3\2\2\2\u0296q\3\2\2\2\u0297\u029f\5v<\2\u0298\u029f\5"+
"x=\2\u0299\u029f\5z>\2\u029a\u029f\5\30\r\2\u029b\u029f\5|?\2\u029c\u029f"+
"\5~@\2\u029d\u029f\5\u0086D\2\u029e\u0297\3\2\2\2\u029e\u0298\3\2\2\2"+
"\u029e\u0299\3\2\2\2\u029e\u029a\3\2\2\2\u029e\u029b\3\2\2\2\u029e\u029c"+
"\3\2\2\2\u029e\u029d\3\2\2\2\u029fs\3\2\2\2\u02a0\u02a1\5r:\2\u02a1u\3"+
"\2\2\2\u02a2\u02a3\t\17\2\2\u02a3w\3\2\2\2\u02a4\u02a5\t\20\2\2\u02a5"+
"y\3\2\2\2\u02a6\u02a7\7X\2\2\u02a7{\3\2\2\2\u02a8\u02a9\7&\2\2\u02a9}"+
"\3\2\2\2\u02aa\u02ac\7=\2\2\u02ab\u02aa\3\2\2\2\u02ab\u02ac\3\2\2\2\u02ac"+
"\u02ad\3\2\2\2\u02ad\u02ae\7\t\2\2\u02ae\177\3\2\2\2\u02af\u02b0\5\u0084"+
"C\2\u02b0\u0081\3\2\2\2\u02b1\u02b6\5\u0084C\2\u02b2\u02b5\5\u0084C\2"+
"\u02b3\u02b5\7V\2\2\u02b4\u02b2\3\2\2\2\u02b4\u02b3\3\2\2\2\u02b5\u02b8"+
"\3\2\2\2\u02b6\u02b4\3\2\2\2\u02b6\u02b7\3\2\2\2\u02b7\u0083\3\2\2\2\u02b8"+
"\u02b6\3\2\2\2\u02b9\u02ba\t\21\2\2\u02ba\u0085\3\2\2\2\u02bb\u02bd\7"+
"=\2\2\u02bc\u02bb\3\2\2\2\u02bc\u02bd\3\2\2\2\u02bd\u02be\3\2\2\2\u02be"+
"\u02bf\5\u0082B\2\u02bf\u0087\3\2\2\2\u02c0\u02c5\5r:\2\u02c1\u02c5\5"+
"\u008eH\2\u02c2\u02c5\5\u0090I\2\u02c3\u02c5\5\u0092J\2\u02c4\u02c0\3"+
"\2\2\2\u02c4\u02c1\3\2\2\2\u02c4\u02c2\3\2\2\2\u02c4\u02c3\3\2\2\2\u02c5"+
"\u0089\3\2\2\2\u02c6\u02c9\5\u0086D\2\u02c7\u02c9\5\u008eH\2\u02c8\u02c6"+
"\3\2\2\2\u02c8\u02c7\3\2\2\2\u02c9\u008b\3\2\2\2\u02ca\u02cd\5\u008aF"+
"\2\u02cb\u02cd\5\u0090I\2\u02cc\u02ca\3\2\2\2\u02cc\u02cb\3\2\2\2\u02cd"+
"\u008d\3\2\2\2\u02ce\u02d0\7=\2\2\u02cf\u02ce\3\2\2\2\u02cf\u02d0\3\2"+
"\2\2\u02d0\u02d1\3\2\2\2\u02d1\u02d2\5\u0082B\2\u02d2\u02d3\7.\2\2\u02d3"+
"\u02d4\5\u0088E\2\u02d4\u008f\3\2\2\2\u02d5\u02d6\5t;\2\u02d6\u02d7\7"+
"\37\2\2\u02d7\u02d8\5\u008aF\2\u02d8\u0091\3\2\2\2\u02d9\u02da\7\6\2\2"+
"\u02da\u02db\5p9\2\u02db\u02dc\7G\2\2\u02dc\u02dd\5\u009eP\2\u02dd\u0093"+
"\3\2\2\2\u02de\u02e3\7R\2\2\u02df\u02e3\7\b\2\2\u02e0\u02e1\7R\2\2\u02e1"+
"\u02e3\7\b\2\2\u02e2\u02de\3\2\2\2\u02e2\u02df\3\2\2\2\u02e2\u02e0\3\2"+
"\2\2\u02e3\u0095\3\2\2\2\u02e4\u02e7\5\u0098M\2\u02e5\u02e7\5\u009cO\2"+
"\u02e6\u02e4\3\2\2\2\u02e6\u02e5\3\2\2\2\u02e7\u0097\3\2\2\2\u02e8\u02ec"+
"\5\u009aN\2\u02e9\u02ea\5\u0094K\2\u02ea\u02eb\5\u009aN\2\u02eb\u02ed"+
"\3\2\2\2\u02ec\u02e9\3\2\2\2\u02ed\u02ee\3\2\2\2\u02ee\u02ec\3\2\2\2\u02ee"+
"\u02ef\3\2\2\2\u02ef\u0099\3\2\2\2\u02f0\u02f3\5\u0088E\2\u02f1\u02f3"+
"\5\u009cO\2\u02f2\u02f0\3\2\2\2\u02f2\u02f1\3\2\2\2\u02f3\u009b\3\2\2"+
"\2\u02f4\u02f5\5\u0088E\2\u02f5\u02f6\7C\2\2\u02f6\u02f7\5\u0088E\2\u02f7"+
"\u009d\3\2\2\2\u02f8\u02f9\5\u00a0Q\2\u02f9\u009f\3\2\2\2\u02fa\u02ff"+
"\5\u00a2R\2\u02fb\u02fc\7\b\2\2\u02fc\u02fe\5\u00a2R\2\u02fd\u02fb\3\2"+
"\2\2\u02fe\u0301\3\2\2\2\u02ff\u02fd\3\2\2\2\u02ff\u0300\3\2\2\2\u0300"+
"\u00a1\3\2\2\2\u0301\u02ff\3\2\2\2\u0302\u0307\5\u00a4S\2\u0303\u0304"+
"\7/\2\2\u0304\u0306\5\u00a4S\2\u0305\u0303\3\2\2\2\u0306\u0309\3\2\2\2"+
"\u0307\u0305\3\2\2\2\u0307\u0308\3\2\2\2\u0308\u00a3\3\2\2\2\u0309\u0307"+
"\3\2\2\2\u030a\u030e\5\u00a6T\2\u030b\u030e\5\u00a8U\2\u030c\u030e\5\u00b4"+
"[\2\u030d\u030a\3\2\2\2\u030d\u030b\3\2\2\2\u030d\u030c\3\2\2\2\u030e"+
"\u00a5\3\2\2\2\u030f\u0311\5\u0088E\2\u0310\u030f\3\2\2\2\u0310\u0311"+
"\3\2\2\2\u0311\u0312\3\2\2\2\u0312\u0313\t\5\2\2\u0313\u0314\5,\27\2\u0314"+
"\u00a7\3\2\2\2\u0315\u0317\5\u0088E\2\u0316\u0315\3\2\2\2\u0316\u0317"+
"\3\2\2\2\u0317\u0318\3\2\2\2\u0318\u0319\5\u00aaV\2\u0319\u031a\5\u0088"+
"E\2\u031a\u00a9\3\2\2\2\u031b\u0320\5\u00acW\2\u031c\u0320\5\u00aeX\2"+
"\u031d\u0320\5\u00b0Y\2\u031e\u0320\5\u00b2Z\2\u031f\u031b\3\2\2\2\u031f"+
"\u031c\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u031e\3\2\2\2\u0320\u00ab\3\2"+
"\2\2\u0321\u032f\7%\2\2\u0322\u032f\7\13\2\2\u0323\u0324\t\4\2\2\u0324"+
"\u032f\7-\2\2\u0325\u0326\t\4\2\2\u0326\u0327\7=\2\2\u0327\u0328\7\67"+
"\2\2\u0328\u032f\7\f\2\2\u0329\u032a\t\4\2\2\u032a\u032b\7-\2\2\u032b"+
"\u032c\7=\2\2\u032c\u032d\7\67\2\2\u032d\u032f\7\f\2\2\u032e\u0321\3\2"+
"\2\2\u032e\u0322\3\2\2\2\u032e\u0323\3\2\2\2\u032e\u0325\3\2\2\2\u032e"+
"\u0329\3\2\2\2\u032f\u00ad\3\2\2\2\u0330\u0331\t\4\2\2\u0331\u0332\7\'"+
"\2\2\u0332\u0345\7;\2\2\u0333\u0334\t\4\2\2\u0334\u0335\7-\2\2\u0335\u0336"+
"\7\'\2\2\u0336\u0345\7;\2\2\u0337\u0338\t\4\2\2\u0338\u0339\7\'\2\2\u0339"+
"\u0345\7\33\2\2\u033a\u033b\t\4\2\2\u033b\u033c\7 \2\2\u033c\u0345\7;"+
"\2\2\u033d\u033e\t\4\2\2\u033e\u033f\7 \2\2\u033f\u0345\7\33\2\2\u0340"+
"\u0341\t\4\2\2\u0341\u0342\7-\2\2\u0342\u0343\7 \2\2\u0343\u0345\7;\2"+
"\2\u0344\u0330\3\2\2\2\u0344\u0333\3\2\2\2\u0344\u0337\3\2\2\2\u0344\u033a"+
"\3\2\2\2\u0344\u033d\3\2\2\2\u0344\u0340\3\2\2\2\u0345\u00af\3\2\2\2\u0346"+
"\u034c\7\23\2\2\u0347\u034c\7\24\2\2\u0348\u0349\t\22\2\2\u0349\u034a"+
"\7-\2\2\u034a\u034c\7\23\2\2\u034b\u0346\3\2\2\2\u034b\u0347\3\2\2\2\u034b"+
"\u0348\3\2\2\2\u034c\u00b1\3\2\2\2\u034d\u034e\t\r\2\2\u034e\u00b3\3\2"+
"\2\2\u034f\u0351\5\u0088E\2\u0350\u034f\3\2\2\2\u0350\u0351\3\2\2\2\u0351"+
"\u0352\3\2\2\2\u0352\u0353\5\u00b6\\\2\u0353\u00b5\3\2\2\2\u0354\u0355"+
"\t\4\2\2\u0355\u035a\7\32\2\2\u0356\u0357\t\4\2\2\u0357\u0358\7-\2\2\u0358"+
"\u035a\7\32\2\2\u0359\u0354\3\2\2\2\u0359\u0356\3\2\2\2\u035a\u00b7\3"+
"\2\2\2_\u00bb\u00c4\u00cd\u00d0\u00db\u00df\u00ed\u00f5\u00fb\u00ff\u010b"+
"\u0110\u011b\u0120\u0123\u0129\u012b\u0134\u0136\u0139\u0143\u0146\u0148"+
"\u014e\u0154\u015d\u0164\u0166\u016e\u0173\u017b\u0182\u018a\u0191\u0194"+
"\u019b\u019e\u01a3\u01a9\u01af\u01b9\u01bf\u01c3\u01cd\u01d4\u01da\u01e1"+
"\u01e4\u01ec\u01ef\u020e\u0211\u0214\u0217\u021c\u0223\u022f\u023f\u0249"+
"\u0251\u0253\u0259\u025d\u0265\u026c\u027b\u0282\u028c\u0295\u029e\u02ab"+
"\u02b4\u02b6\u02bc\u02c4\u02c8\u02cc\u02cf\u02e2\u02e6\u02ee\u02f2\u02ff"+
"\u0307\u030d\u0310\u0316\u031f\u032e\u0344\u034b\u0350\u0359";
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);
}
}
}
