antlr-ng
Version:
Next generation ANTLR Tool
11,680 lines • 197 kB
JavaScript
var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
import * as antlr from "antlr4ng";
class ANTLRv4Parser extends antlr.Parser {
static {
__name(this, "ANTLRv4Parser");
}
static ACTION = 4;
static ARG_ACTION = 5;
static ARG_OR_CHARSET = 6;
static ASSIGN = 7;
static RULE_REF = 8;
static SEMPRED = 9;
static STRING_LITERAL = 10;
static TOKEN_REF = 11;
static UNICODE_ESC = 12;
static UNICODE_EXTENDED_ESC = 13;
static WS = 14;
static ALT = 15;
static BLOCK = 16;
static CLOSURE = 17;
static ELEMENT_OPTIONS = 18;
static EPSILON = 19;
static LEXER_ACTION_CALL = 20;
static LEXER_ALT_ACTION = 21;
static OPTIONAL = 22;
static POSITIVE_CLOSURE = 23;
static RULE = 24;
static RULEMODIFIERS = 25;
static RULES = 26;
static SET = 27;
static WILDCARD = 28;
static LEXER_CHAR_SET = 29;
static DOC_COMMENT = 30;
static BLOCK_COMMENT = 31;
static LINE_COMMENT = 32;
static INT = 33;
static UNTERMINATED_STRING_LITERAL = 34;
static BEGIN_ARGUMENT = 35;
static OPTIONS = 36;
static TOKENS = 37;
static CHANNELS = 38;
static IMPORT = 39;
static FRAGMENT = 40;
static LEXER = 41;
static PARSER = 42;
static GRAMMAR = 43;
static PROTECTED = 44;
static PUBLIC = 45;
static PRIVATE = 46;
static RETURNS = 47;
static LOCALS = 48;
static THROWS = 49;
static CATCH = 50;
static FINALLY = 51;
static MODE = 52;
static COLON = 53;
static COLONCOLON = 54;
static COMMA = 55;
static SEMI = 56;
static LPAREN = 57;
static RPAREN = 58;
static RBRACE = 59;
static RARROW = 60;
static LT = 61;
static GT = 62;
static QUESTION = 63;
static STAR = 64;
static PLUS_ASSIGN = 65;
static PLUS = 66;
static OR = 67;
static DOLLAR = 68;
static RANGE = 69;
static DOT = 70;
static AT = 71;
static POUND = 72;
static NOT = 73;
static ID = 74;
static END_ARGUMENT = 75;
static UNTERMINATED_ARGUMENT = 76;
static ARGUMENT_CONTENT = 77;
static UNTERMINATED_CHAR_SET = 78;
static RULE_grammarSpec = 0;
static RULE_grammarDecl = 1;
static RULE_grammarType = 2;
static RULE_prequelConstruct = 3;
static RULE_optionsSpec = 4;
static RULE_option = 5;
static RULE_optionValue = 6;
static RULE_delegateGrammars = 7;
static RULE_delegateGrammar = 8;
static RULE_tokensSpec = 9;
static RULE_channelsSpec = 10;
static RULE_idList = 11;
static RULE_action_ = 12;
static RULE_actionScopeName = 13;
static RULE_actionBlock = 14;
static RULE_argActionBlock = 15;
static RULE_modeSpec = 16;
static RULE_rules = 17;
static RULE_ruleSpec = 18;
static RULE_parserRuleSpec = 19;
static RULE_exceptionGroup = 20;
static RULE_exceptionHandler = 21;
static RULE_finallyClause = 22;
static RULE_rulePrequel = 23;
static RULE_ruleReturns = 24;
static RULE_throwsSpec = 25;
static RULE_localsSpec = 26;
static RULE_ruleAction = 27;
static RULE_ruleModifiers = 28;
static RULE_ruleModifier = 29;
static RULE_ruleBlock = 30;
static RULE_ruleAltList = 31;
static RULE_labeledAlt = 32;
static RULE_lexerRuleSpec = 33;
static RULE_lexerRuleBlock = 34;
static RULE_lexerAltList = 35;
static RULE_lexerAlt = 36;
static RULE_lexerElements = 37;
static RULE_lexerElement = 38;
static RULE_lexerBlock = 39;
static RULE_lexerCommands = 40;
static RULE_lexerCommand = 41;
static RULE_lexerCommandName = 42;
static RULE_lexerCommandExpr = 43;
static RULE_altList = 44;
static RULE_alternative = 45;
static RULE_element = 46;
static RULE_predicateOptions = 47;
static RULE_predicateOption = 48;
static RULE_labeledElement = 49;
static RULE_ebnf = 50;
static RULE_blockSuffix = 51;
static RULE_ebnfSuffix = 52;
static RULE_lexerAtom = 53;
static RULE_atom = 54;
static RULE_wildcard = 55;
static RULE_notSet = 56;
static RULE_blockSet = 57;
static RULE_setElement = 58;
static RULE_block = 59;
static RULE_ruleref = 60;
static RULE_characterRange = 61;
static RULE_terminalDef = 62;
static RULE_elementOptions = 63;
static RULE_elementOption = 64;
static RULE_identifier = 65;
static RULE_qualifiedIdentifier = 66;
static literalNames = [
null,
null,
null,
null,
null,
null,
null,
"'='",
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
"'['",
null,
null,
null,
"'import'",
"'fragment'",
"'lexer'",
"'parser'",
"'grammar'",
"'protected'",
"'public'",
"'private'",
"'returns'",
"'locals'",
"'throws'",
"'catch'",
"'finally'",
"'mode'",
"':'",
"'::'",
"','",
"';'",
"'('",
"')'",
"'}'",
"'->'",
"'<'",
"'>'",
"'?'",
"'*'",
"'+='",
"'+'",
"'|'",
"'$'",
"'..'",
"'.'",
"'@'",
"'#'",
"'~'"
];
static symbolicNames = [
null,
null,
null,
null,
"ACTION",
"ARG_ACTION",
"ARG_OR_CHARSET",
"ASSIGN",
"RULE_REF",
"SEMPRED",
"STRING_LITERAL",
"TOKEN_REF",
"UNICODE_ESC",
"UNICODE_EXTENDED_ESC",
"WS",
"ALT",
"BLOCK",
"CLOSURE",
"ELEMENT_OPTIONS",
"EPSILON",
"LEXER_ACTION_CALL",
"LEXER_ALT_ACTION",
"OPTIONAL",
"POSITIVE_CLOSURE",
"RULE",
"RULEMODIFIERS",
"RULES",
"SET",
"WILDCARD",
"LEXER_CHAR_SET",
"DOC_COMMENT",
"BLOCK_COMMENT",
"LINE_COMMENT",
"INT",
"UNTERMINATED_STRING_LITERAL",
"BEGIN_ARGUMENT",
"OPTIONS",
"TOKENS",
"CHANNELS",
"IMPORT",
"FRAGMENT",
"LEXER",
"PARSER",
"GRAMMAR",
"PROTECTED",
"PUBLIC",
"PRIVATE",
"RETURNS",
"LOCALS",
"THROWS",
"CATCH",
"FINALLY",
"MODE",
"COLON",
"COLONCOLON",
"COMMA",
"SEMI",
"LPAREN",
"RPAREN",
"RBRACE",
"RARROW",
"LT",
"GT",
"QUESTION",
"STAR",
"PLUS_ASSIGN",
"PLUS",
"OR",
"DOLLAR",
"RANGE",
"DOT",
"AT",
"POUND",
"NOT",
"ID",
"END_ARGUMENT",
"UNTERMINATED_ARGUMENT",
"ARGUMENT_CONTENT",
"UNTERMINATED_CHAR_SET"
];
static ruleNames = [
"grammarSpec",
"grammarDecl",
"grammarType",
"prequelConstruct",
"optionsSpec",
"option",
"optionValue",
"delegateGrammars",
"delegateGrammar",
"tokensSpec",
"channelsSpec",
"idList",
"action_",
"actionScopeName",
"actionBlock",
"argActionBlock",
"modeSpec",
"rules",
"ruleSpec",
"parserRuleSpec",
"exceptionGroup",
"exceptionHandler",
"finallyClause",
"rulePrequel",
"ruleReturns",
"throwsSpec",
"localsSpec",
"ruleAction",
"ruleModifiers",
"ruleModifier",
"ruleBlock",
"ruleAltList",
"labeledAlt",
"lexerRuleSpec",
"lexerRuleBlock",
"lexerAltList",
"lexerAlt",
"lexerElements",
"lexerElement",
"lexerBlock",
"lexerCommands",
"lexerCommand",
"lexerCommandName",
"lexerCommandExpr",
"altList",
"alternative",
"element",
"predicateOptions",
"predicateOption",
"labeledElement",
"ebnf",
"blockSuffix",
"ebnfSuffix",
"lexerAtom",
"atom",
"wildcard",
"notSet",
"blockSet",
"setElement",
"block",
"ruleref",
"characterRange",
"terminalDef",
"elementOptions",
"elementOption",
"identifier",
"qualifiedIdentifier"
];
get grammarFileName() {
return "ANTLRv4Parser.g4";
}
get literalNames() {
return ANTLRv4Parser.literalNames;
}
get symbolicNames() {
return ANTLRv4Parser.symbolicNames;
}
get ruleNames() {
return ANTLRv4Parser.ruleNames;
}
get serializedATN() {
return ANTLRv4Parser._serializedATN;
}
createFailedPredicateException(predicate, message) {
return new antlr.FailedPredicateException(this, predicate, message);
}
constructor(input) {
super(input);
this.interpreter = new antlr.ParserATNSimulator(this, ANTLRv4Parser._ATN, ANTLRv4Parser.decisionsToDFA, new antlr.PredictionContextCache());
}
grammarSpec() {
let localContext = new GrammarSpecContext(this.context, this.state);
this.enterRule(localContext, 0, ANTLRv4Parser.RULE_grammarSpec);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 134;
this.grammarDecl();
this.state = 138;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
while ((_la - 36 & ~31) === 0 && (1 << _la - 36 & 15) !== 0 || _la === 71) {
{
{
this.state = 135;
this.prequelConstruct();
}
}
this.state = 140;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
}
this.state = 141;
this.rules();
this.state = 145;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
while (_la === 52) {
{
{
this.state = 142;
this.modeSpec();
}
}
this.state = 147;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
}
this.state = 148;
this.match(ANTLRv4Parser.EOF);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
grammarDecl() {
let localContext = new GrammarDeclContext(this.context, this.state);
this.enterRule(localContext, 2, ANTLRv4Parser.RULE_grammarDecl);
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 150;
this.grammarType();
this.state = 151;
this.identifier();
this.state = 152;
this.match(ANTLRv4Parser.SEMI);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
grammarType() {
let localContext = new GrammarTypeContext(this.context, this.state);
this.enterRule(localContext, 4, ANTLRv4Parser.RULE_grammarType);
try {
this.state = 159;
this.errorHandler.sync(this);
switch (this.tokenStream.LA(1)) {
case ANTLRv4Parser.LEXER:
this.enterOuterAlt(localContext, 1);
{
this.state = 154;
this.match(ANTLRv4Parser.LEXER);
this.state = 155;
this.match(ANTLRv4Parser.GRAMMAR);
}
break;
case ANTLRv4Parser.PARSER:
this.enterOuterAlt(localContext, 2);
{
this.state = 156;
this.match(ANTLRv4Parser.PARSER);
this.state = 157;
this.match(ANTLRv4Parser.GRAMMAR);
}
break;
case ANTLRv4Parser.GRAMMAR:
this.enterOuterAlt(localContext, 3);
{
this.state = 158;
this.match(ANTLRv4Parser.GRAMMAR);
}
break;
default:
throw new antlr.NoViableAltException(this);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
prequelConstruct() {
let localContext = new PrequelConstructContext(this.context, this.state);
this.enterRule(localContext, 6, ANTLRv4Parser.RULE_prequelConstruct);
try {
this.state = 166;
this.errorHandler.sync(this);
switch (this.tokenStream.LA(1)) {
case ANTLRv4Parser.OPTIONS:
this.enterOuterAlt(localContext, 1);
{
this.state = 161;
this.optionsSpec();
}
break;
case ANTLRv4Parser.IMPORT:
this.enterOuterAlt(localContext, 2);
{
this.state = 162;
this.delegateGrammars();
}
break;
case ANTLRv4Parser.TOKENS:
this.enterOuterAlt(localContext, 3);
{
this.state = 163;
this.tokensSpec();
}
break;
case ANTLRv4Parser.CHANNELS:
this.enterOuterAlt(localContext, 4);
{
this.state = 164;
this.channelsSpec();
}
break;
case ANTLRv4Parser.AT:
this.enterOuterAlt(localContext, 5);
{
this.state = 165;
this.action_();
}
break;
default:
throw new antlr.NoViableAltException(this);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
optionsSpec() {
let localContext = new OptionsSpecContext(this.context, this.state);
this.enterRule(localContext, 8, ANTLRv4Parser.RULE_optionsSpec);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 168;
this.match(ANTLRv4Parser.OPTIONS);
this.state = 174;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
while (_la === 8 || _la === 11) {
{
{
this.state = 169;
this.option();
this.state = 170;
this.match(ANTLRv4Parser.SEMI);
}
}
this.state = 176;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
}
this.state = 177;
this.match(ANTLRv4Parser.RBRACE);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
option() {
let localContext = new OptionContext(this.context, this.state);
this.enterRule(localContext, 10, ANTLRv4Parser.RULE_option);
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 179;
this.identifier();
this.state = 180;
this.match(ANTLRv4Parser.ASSIGN);
this.state = 181;
this.optionValue();
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
optionValue() {
let localContext = new OptionValueContext(this.context, this.state);
this.enterRule(localContext, 12, ANTLRv4Parser.RULE_optionValue);
let _la;
try {
this.state = 194;
this.errorHandler.sync(this);
switch (this.tokenStream.LA(1)) {
case ANTLRv4Parser.RULE_REF:
case ANTLRv4Parser.TOKEN_REF:
this.enterOuterAlt(localContext, 1);
{
this.state = 183;
this.identifier();
this.state = 188;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
while (_la === 70) {
{
{
this.state = 184;
this.match(ANTLRv4Parser.DOT);
this.state = 185;
this.identifier();
}
}
this.state = 190;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
}
}
break;
case ANTLRv4Parser.STRING_LITERAL:
this.enterOuterAlt(localContext, 2);
{
this.state = 191;
this.match(ANTLRv4Parser.STRING_LITERAL);
}
break;
case ANTLRv4Parser.ACTION:
this.enterOuterAlt(localContext, 3);
{
this.state = 192;
this.actionBlock();
}
break;
case ANTLRv4Parser.INT:
this.enterOuterAlt(localContext, 4);
{
this.state = 193;
this.match(ANTLRv4Parser.INT);
}
break;
default:
throw new antlr.NoViableAltException(this);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
delegateGrammars() {
let localContext = new DelegateGrammarsContext(this.context, this.state);
this.enterRule(localContext, 14, ANTLRv4Parser.RULE_delegateGrammars);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 196;
this.match(ANTLRv4Parser.IMPORT);
this.state = 197;
this.delegateGrammar();
this.state = 202;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
while (_la === 55) {
{
{
this.state = 198;
this.match(ANTLRv4Parser.COMMA);
this.state = 199;
this.delegateGrammar();
}
}
this.state = 204;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
}
this.state = 205;
this.match(ANTLRv4Parser.SEMI);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
delegateGrammar() {
let localContext = new DelegateGrammarContext(this.context, this.state);
this.enterRule(localContext, 16, ANTLRv4Parser.RULE_delegateGrammar);
try {
this.state = 212;
this.errorHandler.sync(this);
switch (this.interpreter.adaptivePredict(this.tokenStream, 8, this.context)) {
case 1:
this.enterOuterAlt(localContext, 1);
{
this.state = 207;
this.identifier();
this.state = 208;
this.match(ANTLRv4Parser.ASSIGN);
this.state = 209;
this.identifier();
}
break;
case 2:
this.enterOuterAlt(localContext, 2);
{
this.state = 211;
this.identifier();
}
break;
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
tokensSpec() {
let localContext = new TokensSpecContext(this.context, this.state);
this.enterRule(localContext, 18, ANTLRv4Parser.RULE_tokensSpec);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 214;
this.match(ANTLRv4Parser.TOKENS);
this.state = 216;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 8 || _la === 11) {
{
this.state = 215;
this.idList();
}
}
this.state = 218;
this.match(ANTLRv4Parser.RBRACE);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
channelsSpec() {
let localContext = new ChannelsSpecContext(this.context, this.state);
this.enterRule(localContext, 20, ANTLRv4Parser.RULE_channelsSpec);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 220;
this.match(ANTLRv4Parser.CHANNELS);
this.state = 222;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 8 || _la === 11) {
{
this.state = 221;
this.idList();
}
}
this.state = 224;
this.match(ANTLRv4Parser.RBRACE);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
idList() {
let localContext = new IdListContext(this.context, this.state);
this.enterRule(localContext, 22, ANTLRv4Parser.RULE_idList);
let _la;
try {
let alternative;
this.enterOuterAlt(localContext, 1);
{
this.state = 226;
this.identifier();
this.state = 231;
this.errorHandler.sync(this);
alternative = this.interpreter.adaptivePredict(this.tokenStream, 11, this.context);
while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
if (alternative === 1) {
{
{
this.state = 227;
this.match(ANTLRv4Parser.COMMA);
this.state = 228;
this.identifier();
}
}
}
this.state = 233;
this.errorHandler.sync(this);
alternative = this.interpreter.adaptivePredict(this.tokenStream, 11, this.context);
}
this.state = 235;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 55) {
{
this.state = 234;
this.match(ANTLRv4Parser.COMMA);
}
}
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
action_() {
let localContext = new Action_Context(this.context, this.state);
this.enterRule(localContext, 24, ANTLRv4Parser.RULE_action_);
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 237;
this.match(ANTLRv4Parser.AT);
this.state = 241;
this.errorHandler.sync(this);
switch (this.interpreter.adaptivePredict(this.tokenStream, 13, this.context)) {
case 1:
{
this.state = 238;
this.actionScopeName();
this.state = 239;
this.match(ANTLRv4Parser.COLONCOLON);
}
break;
}
this.state = 243;
this.identifier();
this.state = 244;
this.actionBlock();
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
actionScopeName() {
let localContext = new ActionScopeNameContext(this.context, this.state);
this.enterRule(localContext, 26, ANTLRv4Parser.RULE_actionScopeName);
try {
this.state = 249;
this.errorHandler.sync(this);
switch (this.tokenStream.LA(1)) {
case ANTLRv4Parser.RULE_REF:
case ANTLRv4Parser.TOKEN_REF:
this.enterOuterAlt(localContext, 1);
{
this.state = 246;
this.identifier();
}
break;
case ANTLRv4Parser.LEXER:
this.enterOuterAlt(localContext, 2);
{
this.state = 247;
this.match(ANTLRv4Parser.LEXER);
}
break;
case ANTLRv4Parser.PARSER:
this.enterOuterAlt(localContext, 3);
{
this.state = 248;
this.match(ANTLRv4Parser.PARSER);
}
break;
default:
throw new antlr.NoViableAltException(this);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
actionBlock() {
let localContext = new ActionBlockContext(this.context, this.state);
this.enterRule(localContext, 28, ANTLRv4Parser.RULE_actionBlock);
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 251;
this.match(ANTLRv4Parser.ACTION);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
argActionBlock() {
let localContext = new ArgActionBlockContext(this.context, this.state);
this.enterRule(localContext, 30, ANTLRv4Parser.RULE_argActionBlock);
try {
let alternative;
this.enterOuterAlt(localContext, 1);
{
this.state = 253;
this.match(ANTLRv4Parser.BEGIN_ARGUMENT);
this.state = 257;
this.errorHandler.sync(this);
alternative = this.interpreter.adaptivePredict(this.tokenStream, 15, this.context);
while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
if (alternative === 1 + 1) {
{
{
this.state = 254;
this.match(ANTLRv4Parser.ARGUMENT_CONTENT);
}
}
}
this.state = 259;
this.errorHandler.sync(this);
alternative = this.interpreter.adaptivePredict(this.tokenStream, 15, this.context);
}
this.state = 260;
this.match(ANTLRv4Parser.END_ARGUMENT);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
modeSpec() {
let localContext = new ModeSpecContext(this.context, this.state);
this.enterRule(localContext, 32, ANTLRv4Parser.RULE_modeSpec);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 262;
this.match(ANTLRv4Parser.MODE);
this.state = 263;
this.identifier();
this.state = 264;
this.match(ANTLRv4Parser.SEMI);
this.state = 268;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
while (_la === 11 || _la === 40) {
{
{
this.state = 265;
this.lexerRuleSpec();
}
}
this.state = 270;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
}
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
rules() {
let localContext = new RulesContext(this.context, this.state);
this.enterRule(localContext, 34, ANTLRv4Parser.RULE_rules);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 274;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
while (_la === 8 || _la === 11 || (_la - 40 & ~31) === 0 && (1 << _la - 40 & 113) !== 0) {
{
{
this.state = 271;
this.ruleSpec();
}
}
this.state = 276;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
}
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
ruleSpec() {
let localContext = new RuleSpecContext(this.context, this.state);
this.enterRule(localContext, 36, ANTLRv4Parser.RULE_ruleSpec);
try {
this.state = 279;
this.errorHandler.sync(this);
switch (this.interpreter.adaptivePredict(this.tokenStream, 18, this.context)) {
case 1:
this.enterOuterAlt(localContext, 1);
{
this.state = 277;
this.parserRuleSpec();
}
break;
case 2:
this.enterOuterAlt(localContext, 2);
{
this.state = 278;
this.lexerRuleSpec();
}
break;
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
parserRuleSpec() {
let localContext = new ParserRuleSpecContext(this.context, this.state);
this.enterRule(localContext, 38, ANTLRv4Parser.RULE_parserRuleSpec);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 282;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if ((_la - 40 & ~31) === 0 && (1 << _la - 40 & 113) !== 0) {
{
this.state = 281;
this.ruleModifiers();
}
}
this.state = 284;
this.match(ANTLRv4Parser.RULE_REF);
this.state = 286;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 35) {
{
this.state = 285;
this.argActionBlock();
}
}
this.state = 289;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 47) {
{
this.state = 288;
this.ruleReturns();
}
}
this.state = 292;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 49) {
{
this.state = 291;
this.throwsSpec();
}
}
this.state = 295;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 48) {
{
this.state = 294;
this.localsSpec();
}
}
this.state = 300;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
while (_la === 36 || _la === 71) {
{
{
this.state = 297;
this.rulePrequel();
}
}
this.state = 302;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
}
this.state = 303;
this.match(ANTLRv4Parser.COLON);
this.state = 304;
this.ruleBlock();
this.state = 305;
this.match(ANTLRv4Parser.SEMI);
this.state = 306;
this.exceptionGroup();
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
exceptionGroup() {
let localContext = new ExceptionGroupContext(this.context, this.state);
this.enterRule(localContext, 40, ANTLRv4Parser.RULE_exceptionGroup);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 311;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
while (_la === 50) {
{
{
this.state = 308;
this.exceptionHandler();
}
}
this.state = 313;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
}
this.state = 315;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 51) {
{
this.state = 314;
this.finallyClause();
}
}
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
exceptionHandler() {
let localContext = new ExceptionHandlerContext(this.context, this.state);
this.enterRule(localContext, 42, ANTLRv4Parser.RULE_exceptionHandler);
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 317;
this.match(ANTLRv4Parser.CATCH);
this.state = 318;
this.argActionBlock();
this.state = 319;
this.actionBlock();
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
finallyClause() {
let localContext = new FinallyClauseContext(this.context, this.state);
this.enterRule(localContext, 44, ANTLRv4Parser.RULE_finallyClause);
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 321;
this.match(ANTLRv4Parser.FINALLY);
this.state = 322;
this.actionBlock();
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
rulePrequel() {
let localContext = new RulePrequelContext(this.context, this.state);
this.enterRule(localContext, 46, ANTLRv4Parser.RULE_rulePrequel);
try {
this.state = 326;
this.errorHandler.sync(this);
switch (this.tokenStream.LA(1)) {
case ANTLRv4Parser.OPTIONS:
this.enterOuterAlt(localContext, 1);
{
this.state = 324;
this.optionsSpec();
}
break;
case ANTLRv4Parser.AT:
this.enterOuterAlt(localContext, 2);
{
this.state = 325;
this.ruleAction();
}
break;
default:
throw new antlr.NoViableAltException(this);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
ruleReturns() {
let localContext = new RuleReturnsContext(this.context, this.state);
this.enterRule(localContext, 48, ANTLRv4Parser.RULE_ruleReturns);
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 328;
this.match(ANTLRv4Parser.RETURNS);
this.state = 329;
this.argActionBlock();
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
throwsSpec() {
let localContext = new ThrowsSpecContext(this.context, this.state);
this.enterRule(localContext, 50, ANTLRv4Parser.RULE_throwsSpec);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 331;
this.match(ANTLRv4Parser.THROWS);
this.state = 332;
this.qualifiedIdentifier();
this.state = 337;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
while (_la === 55) {
{
{
this.state = 333;
this.match(ANTLRv4Parser.COMMA);
this.state = 334;
this.qualifiedIdentifier();
}
}
this.state = 339;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
}
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
localsSpec() {
let localContext = new LocalsSpecContext(this.context, this.state);
this.enterRule(localContext, 52, ANTLRv4Parser.RULE_localsSpec);
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 340;
this.match(ANTLRv4Parser.LOCALS);
this.state = 341;
this.argActionBlock();
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
ruleAction() {
let localContext = new RuleActionContext(this.context, this.state);
this.enterRule(localContext, 54, ANTLRv4Parser.RULE_ruleAction);
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 343;
this.match(ANTLRv4Parser.AT);
this.state = 344;
this.identifier();
this.state = 345;
this.actionBlock();
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
ruleModifiers() {
let localContext = new RuleModifiersContext(this.context, this.state);
this.enterRule(localContext, 56, ANTLRv4Parser.RULE_ruleModifiers);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 348;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
do {
{
{
this.state = 347;
this.ruleModifier();
}
}
this.state = 350;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
} while ((_la - 40 & ~31) === 0 && (1 << _la - 40 & 113) !== 0);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
ruleModifier() {
let localContext = new RuleModifierContext(this.context, this.state);
this.enterRule(localContext, 58, ANTLRv4Parser.RULE_ruleModifier);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 352;
_la = this.tokenStream.LA(1);
if (!((_la - 40 & ~31) === 0 && (1 << _la - 40 & 113) !== 0)) {
this.errorHandler.recoverInline(this);
} else {
this.errorHandler.reportMatch(this);
this.consume();
}
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
ruleBlock() {
let localContext = new RuleBlockContext(this.context, this.state);
this.enterRule(localContext, 60, ANTLRv4Parser.RULE_ruleBlock);
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 354;
this.ruleAltList();
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
ruleAltList() {
let localContext = new RuleAltListContext(this.context, this.state);
this.enterRule(localContext, 62, ANTLRv4Parser.RULE_ruleAltList);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 356;
this.labeledAlt();
this.state = 361;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
while (_la === 67) {
{
{
this.state = 357;
this.match(ANTLRv4Parser.OR);
this.state = 358;
this.labeledAlt();
}
}
this.state = 363;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
}
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
labeledAlt() {
let localContext = new LabeledAltContext(this.context, this.state);
this.enterRule(localContext, 64, ANTLRv4Parser.RULE_labeledAlt);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 364;
this.alternative();
this.state = 367;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 72) {
{
this.state = 365;
this.match(ANTLRv4Parser.POUND);
this.state = 366;
this.identifier();
}
}
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
lexerRuleSpec() {
let localContext = new LexerRuleSpecContext(this.context, this.state);
this.enterRule(localContext, 66, ANTLRv4Parser.RULE_lexerRuleSpec);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 370;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 40) {
{
this.state = 369;
this.match(ANTLRv4Parser.FRAGMENT);
}
}
this.state = 372;
this.match(ANTLRv4Parser.TOKEN_REF);
this.state = 374;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 36) {
{
this.state = 373;
this.optionsSpec();
}
}
this.state = 376;
this.match(ANTLRv4Parser.COLON);
this.state = 377;
this.lexerRuleBlock();
this.state = 378;
this.match(ANTLRv4Parser.SEMI);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
lexerRuleBlock() {
let localContext = new LexerRuleBlockContext(this.context, this.state);
this.enterRule(localContext, 68, ANTLRv4Parser.RULE_lexerRuleBlock);
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 380;
this.lexerAltList();
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
lexerAltList() {
let localContext = new LexerAltListContext(this.context, this.state);
this.enterRule(localContext, 70, ANTLRv4Parser.RULE_lexerAltList);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 382;
this.lexerAlt();
this.state = 387;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
while (_la === 67) {
{
{
this.state = 383;
this.match(ANTLRv4Parser.OR);
this.state = 384;
this.lexerAlt();
}
}
this.state = 389;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
}
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
lexerAlt() {
let localContext = new LexerAltContext(this.context, this.state);
this.enterRule(localContext, 72, ANTLRv4Parser.RULE_lexerAlt);
let _la;
try {
this.state = 395;
this.errorHandler.sync(this);
switch (this.interpreter.adaptivePredict(this.tokenStream, 36, this.context)) {
case 1:
this.enterOuterAlt(localContext, 1);
{
this.state = 390;
this.lexerElements();
this.state = 392;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 60) {
{
this.state = 391;
this.lexerCommands();
}
}
}
break;
case 2:
this.enterOuterAlt(localContext, 2);
{
}
break;
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
lexerElements() {
let localContext = new LexerElementsContext(this.context, this.state);
this.enterRule(localContext, 74, ANTLRv4Parser.RULE_lexerElements);
let _la;
try {
this.state = 403;
this.errorHandler.sync(this);
switch (this.tokenStream.LA(1)) {
case ANTLRv4Parser.ACTION:
case ANTLRv4Parser.STRING_LITERAL:
case ANTLRv4Parser.TOKEN_REF:
case ANTLRv4Parser.LEXER_CHAR_SET:
case ANTLRv4Parser.LPAREN:
case ANTLRv4Parser.DOT:
case ANTLRv4Parser.NOT:
this.enterOuterAlt(localContext, 1);
{
this.state = 398;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
do {
{
{
this.state = 397;
this.lexerElement();
}
}
this.state = 400;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
} while ((_la & ~31) === 0 && (1 << _la & 536874e3) !== 0 || (_la - 57 & ~31) === 0 && (1 << _la - 57 & 73729) !== 0);
}
break;
case ANTLRv4Parser.SEMI:
case ANTLRv4Parser.RPAREN:
case ANTLRv4Parser.RARROW:
case ANTLRv4Parser.OR:
this.enterOuterAlt(localContext, 2);
{
}
break;
default:
throw new antlr.NoViableAltException(this);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
lexerElement() {
let localContext = new LexerElementContext(this.context, this.state);
this.enterRule(localContext, 76, ANTLRv4Parser.RULE_lexerElement);
let _la;
try {
this.state = 417;
this.errorHandler.sync(this);
switch (this.tokenStream.LA(1)) {
case ANTLRv4Parser.STRING_LITERAL:
case ANTLRv4Parser.TOKEN_REF:
case ANTLRv4Parser.LEXER_CHAR_SET:
case ANTLRv4Parser.DOT:
case ANTLRv4Parser.NOT:
this.enterOuterAlt(localContext, 1);
{
this.state = 405;
this.lexerAtom();
this.state = 407;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if ((_la - 63 & ~31) === 0 && (1 << _la - 63 & 11) !== 0) {
{
this.state = 406;
this.ebnfSuffix();
}
}
}
break;
case ANTLRv4Parser.LPAREN:
this.enterOuterAlt(localContext, 2);
{
this.state = 409;
this.lexerBlock();
this.state = 411;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if ((_la - 63 & ~31) === 0 && (1 << _la - 63 & 11) !== 0) {
{
this.state = 410;
this.ebnfSuffix();
}
}
}
break;
case ANTLRv4Parser.ACTION:
this.enterOuterAlt(localContext, 3);
{
this.state = 413;
this.actionBlock();
this.state = 415;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 63) {
{
this.state = 414;
this.match(ANTLRv4Parser.QUESTION);
}
}
}
break;
default:
throw new antlr.NoViableAltException(this);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
lexerBlock() {
let localContext = new LexerBlockContext(this.context, this.state);
this.enterRule(localContext, 78, ANTLRv4Parser.RULE_lexerBlock);
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 419;
this.match(ANTLRv4Parser.LPAREN);
this.state = 420;
this.lexerAltList();
this.state = 421;
this.match(ANTLRv4Parser.RPAREN);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
lexerCommands() {
let localContext = new LexerCommandsContext(this.context, this.state);
this.enterRule(localContext, 80, ANTLRv4Parser.RULE_lexerCommands);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 423;
this.match(ANTLRv4Parser.RARROW);
this.state = 424;
this.lexerCommand();
this.state = 429;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
while (_la === 55) {
{
{
this.state = 425;
this.match(ANTLRv4Parser.COMMA);
this.state = 426;
this.lexerCommand();
}
}
this.state = 431;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
}
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
lexerCommand() {
let localContext = new LexerCommandContext(this.context, this.state);
this.enterRule(localContext, 82, ANTLRv4Parser.RULE_lexerCommand);
try {
this.state = 438;
this.errorHandler.sync(this);
switch (this.interpreter.adaptivePredict(this.tokenStream, 44, this.context)) {
case 1:
this.enterOuterAlt(localContext, 1);
{
this.state = 432;
this.lexerCommandName();
this.state = 433;
this.match(ANTLRv4Parser.LPAREN);
this.state = 434;
this.lexerCommandExpr();
this.state = 435;
this.match(ANTLRv4Parser.RPAREN);
}
break;
case 2:
this.enterOuterAlt(localContext, 2);
{
this.state = 437;
this.lexerCommandName();
}
break;
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
lexerCommandName() {
let localContext = new LexerCommandNameContext(this.context, this.state);
this.enterRule(localContext, 84, ANTLRv4Parser.RULE_lexerCommandName);
try {
this.state = 442;
this.errorHandler.sync(this);
switch (this.tokenStream.LA(1)) {
case ANTLRv4Parser.RULE_REF:
case ANTLRv4Parser.TOKEN_REF:
this.enterOuterAlt(localContext, 1);
{
this.state = 440;
this.identifier();
}
break;
case ANTLRv4Parser.MODE:
this.enterOuterAlt(localContext, 2);
{
this.state = 441;
this.match(ANTLRv4Parser.MODE);
}
break;
default:
throw new antlr.NoViableAltException(this);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
lexerCommandExpr() {
let localContext = new LexerCommandExprContext(this.context, this.state);
this.enterRule(localContext, 86, ANTLRv4Parser.RULE_lexerCommandExpr);
try {
this.state = 446;
this.errorHandler.sync(this);
switch (this.tokenStream.LA(1)) {
case ANTLRv4Parser.RULE_REF:
case ANTLRv4Parser.TOKEN_REF:
this.enterOuterAlt(localContext, 1);
{
this.state = 444;
this.identifier();
}
break;
case ANTLRv4Parser.INT:
this.enterOuterAlt(localContext, 2);
{
this.state = 445;
this.match(ANTLRv4Parser.INT);
}
break;
default:
throw new antlr.NoViableAltException(this);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
altList() {
let localContext = new AltListContext(this.context, this.state);
this.enterRule(localContext, 88, ANTLRv4Parser.RULE_altList);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 448;
this.alternative();
this.state = 453;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
while (_la === 67) {
{
{
this.state = 449;
this.match(ANTLRv4Parser.OR);
this.state = 450;
this.alternative();
}
}
this.state = 455;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
}
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
alternative() {
let localContext = new AlternativeContext(this.context, this.state);
this.enterRule(localContext, 90, ANTLRv4Parser.RULE_alternative);
let _la;
try {
this.state = 465;
this.errorHandler.sync(this);
switch (this.tokenStream.LA(1)) {
case ANTLRv4Parser.ACTION:
case ANTLRv4Parser.RULE_REF:
case ANTLRv4Parser.STRING_LITERAL:
case ANTLRv4Parser.TOKEN_REF:
case ANTLRv4Parser.LPAREN:
case ANTLRv4Parser.LT:
case ANTLRv4Parser.DOT:
case ANTLRv4Parser.NOT:
this.enterOuterAlt(localContext, 1);
{
this.state = 457;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 61) {
{
this.state = 456;
this.elementOptions();
}
}
this.state = 460;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
do {
{
{
this.state = 459;
this.element();
}
}
this.state = 462;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
} while ((_la & ~31) === 0 && (1 << _la & 3344) !== 0 || (_la - 57 & ~31) === 0 && (1 << _la - 57 & 73729) !== 0);
}
break;
case ANTLRv4Parser.SEMI:
case ANTLRv4Parser.RPAREN:
case ANTLRv4Parser.OR:
case ANTLRv4Parser.POUND:
this.enterOuterAlt(localContext, 2);
{
}
break;
default:
throw new antlr.NoViableAltException(this);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
element() {
let localContext = new ElementContext(this.context, this.state);
this.enterRule(localContext, 92, ANTLRv4Parser.RULE_element);
let _la;
try {
this.state = 485;
this.errorHandler.sync(this);
switch (this.interpreter.adaptivePredict(this.tokenStream, 55, this.context)) {
case 1:
this.enterOuterAlt(localContext, 1);
{
this.state = 467;
this.labeledElement();
this.state = 470;
this.errorHandler.sync(this);
switch (this.tokenStream.LA(1)) {
case ANTLRv4Parser.QUESTION:
case ANTLRv4Parser.STAR:
case ANTLRv4Parser.PLUS:
{
this.state = 468;
this.ebnfSuffix();
}
break;
case ANTLRv4Parser.ACTION:
case ANTLRv4Parser.RULE_REF:
case ANTLRv4Parser.STRING_LITERAL:
case ANTLRv4Parser.TOKEN_REF:
case ANTLRv4Parser.SEMI:
case ANTLRv4Parser.LPAREN:
case ANTLRv4Parser.RPAREN:
case ANTLRv4Parser.OR:
case ANTLRv4Parser.DOT:
case ANTLRv4Parser.POUND:
case ANTLRv4Parser.NOT:
{
}
break;
default:
throw new antlr.NoViableAltException(this);
}
}
break;
case 2:
this.enterOuterAlt(localContext, 2);
{
this.state = 472;
this.atom();
this.state = 475;
this.errorHandler.sync(this);
switch (this.tokenStream.LA(1)) {
case ANTLRv4Parser.QUESTION:
case ANTLRv4Parser.STAR:
case ANTLRv4Parser.PLUS:
{
this.state = 473;
this.ebnfSuffix();
}
break;
case ANTLRv4Parser.ACTION:
case ANTLRv4Parser.RULE_REF:
case ANTLRv4Parser.STRING_LITERAL:
case ANTLRv4Parser.TOKEN_REF:
case ANTLRv4Parser.SEMI:
case ANTLRv4Parser.LPAREN:
case ANTLRv4Parser.RPAREN:
case ANTLRv4Parser.OR:
case ANTLRv4Parser.DOT:
case ANTLRv4Parser.POUND:
case ANTLRv4Parser.NOT:
{
}
break;
default:
throw new antlr.NoViableAltException(this);
}
}
break;
case 3:
this.enterOuterAlt(localContext, 3);
{
this.state = 477;
this.ebnf();
}
break;
case 4:
this.enterOuterAlt(localContext, 4);
{
this.state = 478;
this.actionBlock();
this.state = 480;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 63) {
{
this.state = 479;
this.match(ANTLRv4Parser.QUESTION);
}
}
this.state = 483;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 61) {
{
this.state = 482;
this.predicateOptions();
}
}
}
break;
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
predicateOptions() {
let localContext = new PredicateOptionsContext(this.context, this.state);
this.enterRule(localContext, 94, ANTLRv4Parser.RULE_predicateOptions);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 487;
this.match(ANTLRv4Parser.LT);
this.state = 488;
this.predicateOption();
this.state = 493;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
while (_la === 55) {
{
{
this.state = 489;
this.match(ANTLRv4Parser.COMMA);
this.state = 490;
this.predicateOption();
}
}
this.state = 495;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
}
this.state = 496;
this.match(ANTLRv4Parser.GT);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
predicateOption() {
let localContext = new PredicateOptionContext(this.context, this.state);
this.enterRule(localContext, 96, ANTLRv4Parser.RULE_predicateOption);
try {
this.state = 506;
this.errorHandler.sync(this);
switch (this.interpreter.adaptivePredict(this.tokenStream, 58, this.context)) {
case 1:
this.enterOuterAlt(localContext, 1);
{
this.state = 498;
this.elementOption();
}
break;
case 2:
this.enterOuterAlt(localContext, 2);
{
this.state = 499;
this.identifier();
this.state = 500;
this.match(ANTLRv4Parser.ASSIGN);
this.state = 504;
this.errorHandler.sync(this);
switch (this.tokenStream.LA(1)) {
case ANTLRv4Parser.ACTION:
{
this.state = 501;
this.actionBlock();
}
break;
case ANTLRv4Parser.INT:
{
this.state = 502;
this.match(ANTLRv4Parser.INT);
}
break;
case ANTLRv4Parser.STRING_LITERAL:
{
this.state = 503;
this.match(ANTLRv4Parser.STRING_LITERAL);
}
break;
default:
throw new antlr.NoViableAltException(this);
}
}
break;
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
labeledElement() {
let localContext = new LabeledElementContext(this.context, this.state);
this.enterRule(localContext, 98, ANTLRv4Parser.RULE_labeledElement);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 508;
this.identifier();
this.state = 509;
_la = this.tokenStream.LA(1);
if (!(_la === 7 || _la === 65)) {
this.errorHandler.recoverInline(this);
} else {
this.errorHandler.reportMatch(this);
this.consume();
}
this.state = 512;
this.errorHandler.sync(this);
switch (this.tokenStream.LA(1)) {
case ANTLRv4Parser.RULE_REF:
case ANTLRv4Parser.STRING_LITERAL:
case ANTLRv4Parser.TOKEN_REF:
case ANTLRv4Parser.DOT:
case ANTLRv4Parser.NOT:
{
this.state = 510;
this.atom();
}
break;
case ANTLRv4Parser.LPAREN:
{
this.state = 511;
this.block();
}
break;
default:
throw new antlr.NoViableAltException(this);
}
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
ebnf() {
let localContext = new EbnfContext(this.context, this.state);
this.enterRule(localContext, 100, ANTLRv4Parser.RULE_ebnf);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 514;
this.block();
this.state = 516;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if ((_la - 63 & ~31) === 0 && (1 << _la - 63 & 11) !== 0) {
{
this.state = 515;
this.blockSuffix();
}
}
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
blockSuffix() {
let localContext = new BlockSuffixContext(this.context, this.state);
this.enterRule(localContext, 102, ANTLRv4Parser.RULE_blockSuffix);
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 518;
this.ebnfSuffix();
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
ebnfSuffix() {
let localContext = new EbnfSuffixContext(this.context, this.state);
this.enterRule(localContext, 104, ANTLRv4Parser.RULE_ebnfSuffix);
let _la;
try {
this.state = 532;
this.errorHandler.sync(this);
switch (this.tokenStream.LA(1)) {
case ANTLRv4Parser.QUESTION:
this.enterOuterAlt(localContext, 1);
{
this.state = 520;
this.match(ANTLRv4Parser.QUESTION);
this.state = 522;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 63) {
{
this.state = 521;
this.match(ANTLRv4Parser.QUESTION);
}
}
}
break;
case ANTLRv4Parser.STAR:
this.enterOuterAlt(localContext, 2);
{
this.state = 524;
this.match(ANTLRv4Parser.STAR);
this.state = 526;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 63) {
{
this.state = 525;
this.match(ANTLRv4Parser.QUESTION);
}
}
}
break;
case ANTLRv4Parser.PLUS:
this.enterOuterAlt(localContext, 3);
{
this.state = 528;
this.match(ANTLRv4Parser.PLUS);
this.state = 530;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 63) {
{
this.state = 529;
this.match(ANTLRv4Parser.QUESTION);
}
}
}
break;
default:
throw new antlr.NoViableAltException(this);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
lexerAtom() {
let localContext = new LexerAtomContext(this.context, this.state);
this.enterRule(localContext, 106, ANTLRv4Parser.RULE_lexerAtom);
try {
this.state = 539;
this.errorHandler.sync(this);
switch (this.interpreter.adaptivePredict(this.tokenStream, 65, this.context)) {
case 1:
this.enterOuterAlt(localContext, 1);
{
this.state = 534;
this.characterRange();
}
break;
case 2:
this.enterOuterAlt(localContext, 2);
{
this.state = 535;
this.terminalDef();
}
break;
case 3:
this.enterOuterAlt(localContext, 3);
{
this.state = 536;
this.notSet();
}
break;
case 4:
this.enterOuterAlt(localContext, 4);
{
this.state = 537;
this.match(ANTLRv4Parser.LEXER_CHAR_SET);
}
break;
case 5:
this.enterOuterAlt(localContext, 5);
{
this.state = 538;
this.wildcard();
}
break;
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
atom() {
let localContext = new AtomContext(this.context, this.state);
this.enterRule(localContext, 108, ANTLRv4Parser.RULE_atom);
try {
this.state = 545;
this.errorHandler.sync(this);
switch (this.tokenStream.LA(1)) {
case ANTLRv4Parser.STRING_LITERAL:
case ANTLRv4Parser.TOKEN_REF:
this.enterOuterAlt(localContext, 1);
{
this.state = 541;
this.terminalDef();
}
break;
case ANTLRv4Parser.RULE_REF:
this.enterOuterAlt(localContext, 2);
{
this.state = 542;
this.ruleref();
}
break;
case ANTLRv4Parser.NOT:
this.enterOuterAlt(localContext, 3);
{
this.state = 543;
this.notSet();
}
break;
case ANTLRv4Parser.DOT:
this.enterOuterAlt(localContext, 4);
{
this.state = 544;
this.wildcard();
}
break;
default:
throw new antlr.NoViableAltException(this);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
wildcard() {
let localContext = new WildcardContext(this.context, this.state);
this.enterRule(localContext, 110, ANTLRv4Parser.RULE_wildcard);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 547;
this.match(ANTLRv4Parser.DOT);
this.state = 549;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 61) {
{
this.state = 548;
this.elementOptions();
}
}
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
notSet() {
let localContext = new NotSetContext(this.context, this.state);
this.enterRule(localContext, 112, ANTLRv4Parser.RULE_notSet);
try {
this.state = 555;
this.errorHandler.sync(this);
switch (this.interpreter.adaptivePredict(this.tokenStream, 68, this.context)) {
case 1:
this.enterOuterAlt(localContext, 1);
{
this.state = 551;
this.match(ANTLRv4Parser.NOT);
this.state = 552;
this.setElement();
}
break;
case 2:
this.enterOuterAlt(localContext, 2);
{
this.state = 553;
this.match(ANTLRv4Parser.NOT);
this.state = 554;
this.blockSet();
}
break;
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
blockSet() {
let localContext = new BlockSetContext(this.context, this.state);
this.enterRule(localContext, 114, ANTLRv4Parser.RULE_blockSet);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 557;
this.match(ANTLRv4Parser.LPAREN);
this.state = 558;
this.setElement();
this.state = 563;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
while (_la === 67) {
{
{
this.state = 559;
this.match(ANTLRv4Parser.OR);
this.state = 560;
this.setElement();
}
}
this.state = 565;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
}
this.state = 566;
this.match(ANTLRv4Parser.RPAREN);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
setElement() {
let localContext = new SetElementContext(this.context, this.state);
this.enterRule(localContext, 116, ANTLRv4Parser.RULE_setElement);
let _la;
try {
this.state = 578;
this.errorHandler.sync(this);
switch (this.interpreter.adaptivePredict(this.tokenStream, 72, this.context)) {
case 1:
this.enterOuterAlt(localContext, 1);
{
this.state = 568;
this.match(ANTLRv4Parser.TOKEN_REF);
this.state = 570;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 61) {
{
this.state = 569;
this.elementOptions();
}
}
}
break;
case 2:
this.enterOuterAlt(localContext, 2);
{
this.state = 572;
this.match(ANTLRv4Parser.STRING_LITERAL);
this.state = 574;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 61) {
{
this.state = 573;
this.elementOptions();
}
}
}
break;
case 3:
this.enterOuterAlt(localContext, 3);
{
this.state = 576;
this.characterRange();
}
break;
case 4:
this.enterOuterAlt(localContext, 4);
{
this.state = 577;
this.match(ANTLRv4Parser.LEXER_CHAR_SET);
}
break;
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
block() {
let localContext = new BlockContext(this.context, this.state);
this.enterRule(localContext, 118, ANTLRv4Parser.RULE_block);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 580;
this.match(ANTLRv4Parser.LPAREN);
this.state = 591;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 36 || _la === 53 || _la === 71) {
{
this.state = 582;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 36) {
{
this.state = 581;
this.optionsSpec();
}
}
this.state = 587;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
while (_la === 71) {
{
{
this.state = 584;
this.ruleAction();
}
}
this.state = 589;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
}
this.state = 590;
this.match(ANTLRv4Parser.COLON);
}
}
this.state = 593;
this.altList();
this.state = 594;
this.match(ANTLRv4Parser.RPAREN);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
ruleref() {
let localContext = new RulerefContext(this.context, this.state);
this.enterRule(localContext, 120, ANTLRv4Parser.RULE_ruleref);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 596;
this.match(ANTLRv4Parser.RULE_REF);
this.state = 598;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 35) {
{
this.state = 597;
this.argActionBlock();
}
}
this.state = 601;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 61) {
{
this.state = 600;
this.elementOptions();
}
}
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
characterRange() {
let localContext = new CharacterRangeContext(this.context, this.state);
this.enterRule(localContext, 122, ANTLRv4Parser.RULE_characterRange);
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 603;
this.match(ANTLRv4Parser.STRING_LITERAL);
this.state = 604;
this.match(ANTLRv4Parser.RANGE);
this.state = 605;
this.match(ANTLRv4Parser.STRING_LITERAL);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
terminalDef() {
let localContext = new TerminalDefContext(this.context, this.state);
this.enterRule(localContext, 124, ANTLRv4Parser.RULE_terminalDef);
let _la;
try {
this.state = 615;
this.errorHandler.sync(this);
switch (this.tokenStream.LA(1)) {
case ANTLRv4Parser.TOKEN_REF:
this.enterOuterAlt(localContext, 1);
{
this.state = 607;
this.match(ANTLRv4Parser.TOKEN_REF);
this.state = 609;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 61) {
{
this.state = 608;
this.elementOptions();
}
}
}
break;
case ANTLRv4Parser.STRING_LITERAL:
this.enterOuterAlt(localContext, 2);
{
this.state = 611;
this.match(ANTLRv4Parser.STRING_LITERAL);
this.state = 613;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
if (_la === 61) {
{
this.state = 612;
this.elementOptions();
}
}
}
break;
default:
throw new antlr.NoViableAltException(this);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
elementOptions() {
let localContext = new ElementOptionsContext(this.context, this.state);
this.enterRule(localContext, 126, ANTLRv4Parser.RULE_elementOptions);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 617;
this.match(ANTLRv4Parser.LT);
this.state = 618;
this.elementOption();
this.state = 623;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
while (_la === 55) {
{
{
this.state = 619;
this.match(ANTLRv4Parser.COMMA);
this.state = 620;
this.elementOption();
}
}
this.state = 625;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
}
this.state = 626;
this.match(ANTLRv4Parser.GT);
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
elementOption() {
let localContext = new ElementOptionContext(this.context, this.state);
this.enterRule(localContext, 128, ANTLRv4Parser.RULE_elementOption);
try {
this.state = 636;
this.errorHandler.sync(this);
switch (this.interpreter.adaptivePredict(this.tokenStream, 83, this.context)) {
case 1:
this.enterOuterAlt(localContext, 1);
{
this.state = 628;
this.qualifiedIdentifier();
}
break;
case 2:
this.enterOuterAlt(localContext, 2);
{
this.state = 629;
this.identifier();
this.state = 630;
this.match(ANTLRv4Parser.ASSIGN);
this.state = 634;
this.errorHandler.sync(this);
switch (this.tokenStream.LA(1)) {
case ANTLRv4Parser.RULE_REF:
case ANTLRv4Parser.TOKEN_REF:
{
this.state = 631;
this.qualifiedIdentifier();
}
break;
case ANTLRv4Parser.STRING_LITERAL:
{
this.state = 632;
this.match(ANTLRv4Parser.STRING_LITERAL);
}
break;
case ANTLRv4Parser.INT:
{
this.state = 633;
this.match(ANTLRv4Parser.INT);
}
break;
default:
throw new antlr.NoViableAltException(this);
}
}
break;
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
identifier() {
let localContext = new IdentifierContext(this.context, this.state);
this.enterRule(localContext, 130, ANTLRv4Parser.RULE_identifier);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 638;
_la = this.tokenStream.LA(1);
if (!(_la === 8 || _la === 11)) {
this.errorHandler.recoverInline(this);
} else {
this.errorHandler.reportMatch(this);
this.consume();
}
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
qualifiedIdentifier() {
let localContext = new QualifiedIdentifierContext(this.context, this.state);
this.enterRule(localContext, 132, ANTLRv4Parser.RULE_qualifiedIdentifier);
let _la;
try {
this.enterOuterAlt(localContext, 1);
{
this.state = 640;
this.identifier();
this.state = 645;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
while (_la === 70) {
{
{
this.state = 641;
this.match(ANTLRv4Parser.DOT);
this.state = 642;
this.identifier();
}
}
this.state = 647;
this.errorHandler.sync(this);
_la = this.tokenStream.LA(1);
}
}
} catch (re) {
if (re instanceof antlr.RecognitionException) {
this.errorHandler.reportError(this, re);
this.errorHandler.recover(this, re);
} else {
throw re;
}
} finally {
this.exitRule();
}
return localContext;
}
static _serializedATN = [
4,
1,
78,
649,
2,
0,
7,
0,
2,
1,
7,
1,
2,
2,
7,
2,
2,
3,
7,
3,
2,
4,
7,
4,
2,
5,
7,
5,
2,
6,
7,
6,
2,
7,
7,
7,
2,
8,
7,
8,
2,
9,
7,
9,
2,
10,
7,
10,
2,
11,
7,
11,
2,
12,
7,
12,
2,
13,
7,
13,
2,
14,
7,
14,
2,
15,
7,
15,
2,
16,
7,
16,
2,
17,
7,
17,
2,
18,
7,
18,
2,
19,
7,
19,
2,
20,
7,
20,
2,
21,
7,
21,
2,
22,
7,
22,
2,
23,
7,
23,
2,
24,
7,
24,
2,
25,
7,
25,
2,
26,
7,
26,
2,
27,
7,
27,
2,
28,
7,
28,
2,
29,
7,
29,
2,
30,
7,
30,
2,
31,
7,
31,
2,
32,
7,
32,
2,
33,
7,
33,
2,
34,
7,
34,
2,
35,
7,
35,
2,
36,
7,
36,
2,
37,
7,
37,
2,
38,
7,
38,
2,
39,
7,
39,
2,
40,
7,
40,
2,
41,
7,
41,
2,
42,
7,
42,
2,
43,
7,
43,
2,
44,
7,
44,
2,
45,
7,
45,
2,
46,
7,
46,
2,
47,
7,
47,
2,
48,
7,
48,
2,
49,
7,
49,
2,
50,
7,
50,
2,
51,
7,
51,
2,
52,
7,
52,
2,
53,
7,
53,
2,
54,
7,
54,
2,
55,
7,
55,
2,
56,
7,
56,
2,
57,
7,
57,
2,
58,
7,
58,
2,
59,
7,
59,
2,
60,
7,
60,
2,
61,
7,
61,
2,
62,
7,
62,
2,
63,
7,
63,
2,
64,
7,
64,
2,
65,
7,
65,
2,
66,
7,
66,
1,
0,
1,
0,
5,
0,
137,
8,
0,
10,
0,
12,
0,
140,
9,
0,
1,
0,
1,
0,
5,
0,
144,
8,
0,
10,
0,
12,
0,
147,
9,
0,
1,
0,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
3,
2,
160,
8,
2,
1,
3,
1,
3,
1,
3,
1,
3,
1,
3,
3,
3,
167,
8,
3,
1,
4,
1,
4,
1,
4,
1,
4,
5,
4,
173,
8,
4,
10,
4,
12,
4,
176,
9,
4,
1,
4,
1,
4,
1,
5,
1,
5,
1,
5,
1,
5,
1,
6,
1,
6,
1,
6,
5,
6,
187,
8,
6,
10,
6,
12,
6,
190,
9,
6,
1,
6,
1,
6,
1,
6,
3,
6,
195,
8,
6,
1,
7,
1,
7,
1,
7,
1,
7,
5,
7,
201,
8,
7,
10,
7,
12,
7,
204,
9,
7,
1,
7,
1,
7,
1,
8,
1,
8,
1,
8,
1,
8,
1,
8,
3,
8,
213,
8,
8,
1,
9,
1,
9,
3,
9,
217,
8,
9,
1,
9,
1,
9,
1,
10,
1,
10,
3,
10,
223,
8,
10,
1,
10,
1,
10,
1,
11,
1,
11,
1,
11,
5,
11,
230,
8,
11,
10,
11,
12,
11,
233,
9,
11,
1,
11,
3,
11,
236,
8,
11,
1,
12,
1,
12,
1,
12,
1,
12,
3,
12,
242,
8,
12,
1,
12,
1,
12,
1,
12,
1,
13,
1,
13,
1,
13,
3,
13,
250,
8,
13,
1,
14,
1,
14,
1,
15,
1,
15,
5,
15,
256,
8,
15,
10,
15,
12,
15,
259,
9,
15,
1,
15,
1,
15,
1,
16,
1,
16,
1,
16,
1,
16,
5,
16,
267,
8,
16,
10,
16,
12,
16,
270,
9,
16,
1,
17,
5,
17,
273,
8,
17,
10,
17,
12,
17,
276,
9,
17,
1,
18,
1,
18,
3,
18,
280,
8,
18,
1,
19,
3,
19,
283,
8,
19,
1,
19,
1,
19,
3,
19,
287,
8,
19,
1,
19,
3,
19,
290,
8,
19,
1,
19,
3,
19,
293,
8,
19,
1,
19,
3,
19,
296,
8,
19,
1,
19,
5,
19,
299,
8,
19,
10,
19,
12,
19,
302,
9,
19,
1,
19,
1,
19,
1,
19,
1,
19,
1,
19,
1,
20,
5,
20,
310,
8,
20,
10,
20,
12,
20,
313,
9,
20,
1,
20,
3,
20,
316,
8,
20,
1,
21,
1,
21,
1,
21,
1,
21,
1,
22,
1,
22,
1,
22,
1,
23,
1,
23,
3,
23,
327,
8,
23,
1,
24,
1,
24,
1,
24,
1,
25,
1,
25,
1,
25,
1,
25,
5,
25,
336,
8,
25,
10,
25,
12,
25,
339,
9,
25,
1,
26,
1,
26,
1,
26,
1,
27,
1,
27,
1,
27,
1,
27,
1,
28,
4,
28,
349,
8,
28,
11,
28,
12,
28,
350,
1,
29,
1,
29,
1,
30,
1,
30,
1,
31,
1,
31,
1,
31,
5,
31,
360,
8,
31,
10,
31,
12,
31,
363,
9,
31,
1,
32,
1,
32,
1,
32,
3,
32,
368,
8,
32,
1,
33,
3,
33,
371,
8,
33,
1,
33,
1,
33,
3,
33,
375,
8,
33,
1,
33,
1,
33,
1,
33,
1,
33,
1,
34,
1,
34,
1,
35,
1,
35,
1,
35,
5,
35,
386,
8,
35,
10,
35,
12,
35,
389,
9,
35,
1,
36,
1,
36,
3,
36,
393,
8,
36,
1,
36,
3,
36,
396,
8,
36,
1,
37,
4,
37,
399,
8,
37,
11,
37,
12,
37,
400,
1,
37,
3,
37,
404,
8,
37,
1,
38,
1,
38,
3,
38,
408,
8,
38,
1,
38,
1,
38,
3,
38,
412,
8,
38,
1,
38,
1,
38,
3,
38,
416,
8,
38,
3,
38,
418,
8,
38,
1,
39,
1,
39,
1,
39,
1,
39,
1,
40,
1,
40,
1,
40,
1,
40,
5,
40,
428,
8,
40,
10,
40,
12,
40,
431,
9,
40,
1,
41,
1,
41,
1,
41,
1,
41,
1,
41,
1,
41,
3,
41,
439,
8,
41,
1,
42,
1,
42,
3,
42,
443,
8,
42,
1,
43,
1,
43,
3,
43,
447,
8,
43,
1,
44,
1,
44,
1,
44,
5,
44,
452,
8,
44,
10,
44,
12,
44,
455,
9,
44,
1,
45,
3,
45,
458,
8,
45,
1,
45,
4,
45,
461,
8,
45,
11,
45,
12,
45,
462,
1,
45,
3,
45,
466,
8,
45,
1,
46,
1,
46,
1,
46,
3,
46,
471,
8,
46,
1,
46,
1,
46,
1,
46,
3,
46,
476,
8,
46,
1,
46,
1,
46,
1,
46,
3,
46,
481,
8,
46,
1,
46,
3,
46,
484,
8,
46,
3,
46,
486,
8,
46,
1,
47,
1,
47,
1,
47,
1,
47,
5,
47,
492,
8,
47,
10,
47,
12,
47,
495,
9,
47,
1,
47,
1,
47,
1,
48,
1,
48,
1,
48,
1,
48,
1,
48,
1,
48,
3,
48,
505,
8,
48,
3,
48,
507,
8,
48,
1,
49,
1,
49,
1,
49,
1,
49,
3,
49,
513,
8,
49,
1,
50,
1,
50,
3,
50,
517,
8,
50,
1,
51,
1,
51,
1,
52,
1,
52,
3,
52,
523,
8,
52,
1,
52,
1,
52,
3,
52,
527,
8,
52,
1,
52,
1,
52,
3,
52,
531,
8,
52,
3,
52,
533,
8,
52,
1,
53,
1,
53,
1,
53,
1,
53,
1,
53,
3,
53,
540,
8,
53,
1,
54,
1,
54,
1,
54,
1,
54,
3,
54,
546,
8,
54,
1,
55,
1,
55,
3,
55,
550,
8,
55,
1,
56,
1,
56,
1,
56,
1,
56,
3,
56,
556,
8,
56,
1,
57,
1,
57,
1,
57,
1,
57,
5,
57,
562,
8,
57,
10,
57,
12,
57,
565,
9,
57,
1,
57,
1,
57,
1,
58,
1,
58,
3,
58,
571,
8,
58,
1,
58,
1,
58,
3,
58,
575,
8,
58,
1,
58,
1,
58,
3,
58,
579,
8,
58,
1,
59,
1,
59,
3,
59,
583,
8,
59,
1,
59,
5,
59,
586,
8,
59,
10,
59,
12,
59,
589,
9,
59,
1,
59,
3,
59,
592,
8,
59,
1,
59,
1,
59,
1,
59,
1,
60,
1,
60,
3,
60,
599,
8,
60,
1,
60,
3,
60,
602,
8,
60,
1,
61,
1,
61,
1,
61,
1,
61,
1,
62,
1,
62,
3,
62,
610,
8,
62,
1,
62,
1,
62,
3,
62,
614,
8,
62,
3,
62,
616,
8,
62,
1,
63,
1,
63,
1,
63,
1,
63,
5,
63,
622,
8,
63,
10,
63,
12,
63,
625,
9,
63,
1,
63,
1,
63,
1,
64,
1,
64,
1,
64,
1,
64,
1,
64,
1,
64,
3,
64,
635,
8,
64,
3,
64,
637,
8,
64,
1,
65,
1,
65,
1,
66,
1,
66,
1,
66,
5,
66,
644,
8,
66,
10,
66,
12,
66,
647,
9,
66,
1,
66,
1,
257,
0,
67,
0,
2,
4,
6,
8,
10,
12,
14,
16,
18,
20,
22,
24,
26,
28,
30,
32,
34,
36,
38,
40,
42,
44,
46,
48,
50,
52,
54,
56,
58,
60,
62,
64,
66,
68,
70,
72,
74,
76,
78,
80,
82,
84,
86,
88,
90,
92,
94,
96,
98,
100,
102,
104,
106,
108,
110,
112,
114,
116,
118,
120,
122,
124,
126,
128,
130,
132,
0,
3,
2,
0,
40,
40,
44,
46,
2,
0,
7,
7,
65,
65,
2,
0,
8,
8,
11,
11,
686,
0,
134,
1,
0,
0,
0,
2,
150,
1,
0,
0,
0,
4,
159,
1,
0,
0,
0,
6,
166,
1,
0,
0,
0,
8,
168,
1,
0,
0,
0,
10,
179,
1,
0,
0,
0,
12,
194,
1,
0,
0,
0,
14,
196,
1,
0,
0,
0,
16,
212,
1,
0,
0,
0,
18,
214,
1,
0,
0,
0,
20,
220,
1,
0,
0,
0,
22,
226,
1,
0,
0,
0,
24,
237,
1,
0,
0,
0,
26,
249,
1,
0,
0,
0,
28,
251,
1,
0,
0,
0,
30,
253,
1,
0,
0,
0,
32,
262,
1,
0,
0,
0,
34,
274,
1,
0,
0,
0,
36,
279,
1,
0,
0,
0,
38,
282,
1,
0,
0,
0,
40,
311,
1,
0,
0,
0,
42,
317,
1,
0,
0,
0,
44,
321,
1,
0,
0,
0,
46,
326,
1,
0,
0,
0,
48,
328,
1,
0,
0,
0,
50,
331,
1,
0,
0,
0,
52,
340,
1,
0,
0,
0,
54,
343,
1,
0,
0,
0,
56,
348,
1,
0,
0,
0,
58,
352,
1,
0,
0,
0,
60,
354,
1,
0,
0,
0,
62,
356,
1,
0,
0,
0,
64,
364,
1,
0,
0,
0,
66,
370,
1,
0,
0,
0,
68,
380,
1,
0,
0,
0,
70,
382,
1,
0,
0,
0,
72,
395,
1,
0,
0,
0,
74,
403,
1,
0,
0,
0,
76,
417,
1,
0,
0,
0,
78,
419,
1,
0,
0,
0,
80,
423,
1,
0,
0,
0,
82,
438,
1,
0,
0,
0,
84,
442,
1,
0,
0,
0,
86,
446,
1,
0,
0,
0,
88,
448,
1,
0,
0,
0,
90,
465,
1,
0,
0,
0,
92,
485,
1,
0,
0,
0,
94,
487,
1,
0,
0,
0,
96,
506,
1,
0,
0,
0,
98,
508,
1,
0,
0,
0,
100,
514,
1,
0,
0,
0,
102,
518,
1,
0,
0,
0,
104,
532,
1,
0,
0,
0,
106,
539,
1,
0,
0,
0,
108,
545,
1,
0,
0,
0,
110,
547,
1,
0,
0,
0,
112,
555,
1,
0,
0,
0,
114,
557,
1,
0,
0,
0,
116,
578,
1,
0,
0,
0,
118,
580,
1,
0,
0,
0,
120,
596,
1,
0,
0,
0,
122,
603,
1,
0,
0,
0,
124,
615,
1,
0,
0,
0,
126,
617,
1,
0,
0,
0,
128,
636,
1,
0,
0,
0,
130,
638,
1,
0,
0,
0,
132,
640,
1,
0,
0,
0,
134,
138,
3,
2,
1,
0,
135,
137,
3,
6,
3,
0,
136,
135,
1,
0,
0,
0,
137,
140,
1,
0,
0,
0,
138,
136,
1,
0,
0,
0,
138,
139,
1,
0,
0,
0,
139,
141,
1,
0,
0,
0,
140,
138,
1,
0,
0,
0,
141,
145,
3,
34,
17,
0,
142,
144,
3,
32,
16,
0,
143,
142,
1,
0,
0,
0,
144,
147,
1,
0,
0,
0,
145,
143,
1,
0,
0,
0,
145,
146,
1,
0,
0,
0,
146,
148,
1,
0,
0,
0,
147,
145,
1,
0,
0,
0,
148,
149,
5,
0,
0,
1,
149,
1,
1,
0,
0,
0,
150,
151,
3,
4,
2,
0,
151,
152,
3,
130,
65,
0,
152,
153,
5,
56,
0,
0,
153,
3,
1,
0,
0,
0,
154,
155,
5,
41,
0,
0,
155,
160,
5,
43,
0,
0,
156,
157,
5,
42,
0,
0,
157,
160,
5,
43,
0,
0,
158,
160,
5,
43,
0,
0,
159,
154,
1,
0,
0,
0,
159,
156,
1,
0,
0,
0,
159,
158,
1,
0,
0,
0,
160,
5,
1,
0,
0,
0,
161,
167,
3,
8,
4,
0,
162,
167,
3,
14,
7,
0,
163,
167,
3,
18,
9,
0,
164,
167,
3,
20,
10,
0,
165,
167,
3,
24,
12,
0,
166,
161,
1,
0,
0,
0,
166,
162,
1,
0,
0,
0,
166,
163,
1,
0,
0,
0,
166,
164,
1,
0,
0,
0,
166,
165,
1,
0,
0,
0,
167,
7,
1,
0,
0,
0,
168,
174,
5,
36,
0,
0,
169,
170,
3,
10,
5,
0,
170,
171,
5,
56,
0,
0,
171,
173,
1,
0,
0,
0,
172,
169,
1,
0,
0,
0,
173,
176,
1,
0,
0,
0,
174,
172,
1,
0,
0,
0,
174,
175,
1,
0,
0,
0,
175,
177,
1,
0,
0,
0,
176,
174,
1,
0,
0,
0,
177,
178,
5,
59,
0,
0,
178,
9,
1,
0,
0,
0,
179,
180,
3,
130,
65,
0,
180,
181,
5,
7,
0,
0,
181,
182,
3,
12,
6,
0,
182,
11,
1,
0,
0,
0,
183,
188,
3,
130,
65,
0,
184,
185,
5,
70,
0,
0,
185,
187,
3,
130,
65,
0,
186,
184,
1,
0,
0,
0,
187,
190,
1,
0,
0,
0,
188,
186,
1,
0,
0,
0,
188,
189,
1,
0,
0,
0,
189,
195,
1,
0,
0,
0,
190,
188,
1,
0,
0,
0,
191,
195,
5,
10,
0,
0,
192,
195,
3,
28,
14,
0,
193,
195,
5,
33,
0,
0,
194,
183,
1,
0,
0,
0,
194,
191,
1,
0,
0,
0,
194,
192,
1,
0,
0,
0,
194,
193,
1,
0,
0,
0,
195,
13,
1,
0,
0,
0,
196,
197,
5,
39,
0,
0,
197,
202,
3,
16,
8,
0,
198,
199,
5,
55,
0,
0,
199,
201,
3,
16,
8,
0,
200,
198,
1,
0,
0,
0,
201,
204,
1,
0,
0,
0,
202,
200,
1,
0,
0,
0,
202,
203,
1,
0,
0,
0,
203,
205,
1,
0,
0,
0,
204,
202,
1,
0,
0,
0,
205,
206,
5,
56,
0,
0,
206,
15,
1,
0,
0,
0,
207,
208,
3,
130,
65,
0,
208,
209,
5,
7,
0,
0,
209,
210,
3,
130,
65,
0,
210,
213,
1,
0,
0,
0,
211,
213,
3,
130,
65,
0,
212,
207,
1,
0,
0,
0,
212,
211,
1,
0,
0,
0,
213,
17,
1,
0,
0,
0,
214,
216,
5,
37,
0,
0,
215,
217,
3,
22,
11,
0,
216,
215,
1,
0,
0,
0,
216,
217,
1,
0,
0,
0,
217,
218,
1,
0,
0,
0,
218,
219,
5,
59,
0,
0,
219,
19,
1,
0,
0,
0,
220,
222,
5,
38,
0,
0,
221,
223,
3,
22,
11,
0,
222,
221,
1,
0,
0,
0,
222,
223,
1,
0,
0,
0,
223,
224,
1,
0,
0,
0,
224,
225,
5,
59,
0,
0,
225,
21,
1,
0,
0,
0,
226,
231,
3,
130,
65,
0,
227,
228,
5,
55,
0,
0,
228,
230,
3,
130,
65,
0,
229,
227,
1,
0,
0,
0,
230,
233,
1,
0,
0,
0,
231,
229,
1,
0,
0,
0,
231,
232,
1,
0,
0,
0,
232,
235,
1,
0,
0,
0,
233,
231,
1,
0,
0,
0,
234,
236,
5,
55,
0,
0,
235,
234,
1,
0,
0,
0,
235,
236,
1,
0,
0,
0,
236,
23,
1,
0,
0,
0,
237,
241,
5,
71,
0,
0,
238,
239,
3,
26,
13,
0,
239,
240,
5,
54,
0,
0,
240,
242,
1,
0,
0,
0,
241,
238,
1,
0,
0,
0,
241,
242,
1,
0,
0,
0,
242,
243,
1,
0,
0,
0,
243,
244,
3,
130,
65,
0,
244,
245,
3,
28,
14,
0,
245,
25,
1,
0,
0,
0,
246,
250,
3,
130,
65,
0,
247,
250,
5,
41,
0,
0,
248,
250,
5,
42,
0,
0,
249,
246,
1,
0,
0,
0,
249,
247,
1,
0,
0,
0,
249,
248,
1,
0,
0,
0,
250,
27,
1,
0,
0,
0,
251,
252,
5,
4,
0,
0,
252,
29,
1,
0,
0,
0,
253,
257,
5,
35,
0,
0,
254,
256,
5,
77,
0,
0,
255,
254,
1,
0,
0,
0,
256,
259,
1,
0,
0,
0,
257,
258,
1,
0,
0,
0,
257,
255,
1,
0,
0,
0,
258,
260,
1,
0,
0,
0,
259,
257,
1,
0,
0,
0,
260,
261,
5,
75,
0,
0,
261,
31,
1,
0,
0,
0,
262,
263,
5,
52,
0,
0,
263,
264,
3,
130,
65,
0,
264,
268,
5,
56,
0,
0,
265,
267,
3,
66,
33,
0,
266,
265,
1,
0,
0,
0,
267,
270,
1,
0,
0,
0,
268,
266,
1,
0,
0,
0,
268,
269,
1,
0,
0,
0,
269,
33,
1,
0,
0,
0,
270,
268,
1,
0,
0,
0,
271,
273,
3,
36,
18,
0,
272,
271,
1,
0,
0,
0,
273,
276,
1,
0,
0,
0,
274,
272,
1,
0,
0,
0,
274,
275,
1,
0,
0,
0,
275,
35,
1,
0,
0,
0,
276,
274,
1,
0,
0,
0,
277,
280,
3,
38,
19,
0,
278,
280,
3,
66,
33,
0,
279,
277,
1,
0,
0,
0,
279,
278,
1,
0,
0,
0,
280,
37,
1,
0,
0,
0,
281,
283,
3,
56,
28,
0,
282,
281,
1,
0,
0,
0,
282,
283,
1,
0,
0,
0,
283,
284,
1,
0,
0,
0,
284,
286,
5,
8,
0,
0,
285,
287,
3,
30,
15,
0,
286,
285,
1,
0,
0,
0,
286,
287,
1,
0,
0,
0,
287,
289,
1,
0,
0,
0,
288,
290,
3,
48,
24,
0,
289,
288,
1,
0,
0,
0,
289,
290,
1,
0,
0,
0,
290,
292,
1,
0,
0,
0,
291,
293,
3,
50,
25,
0,
292,
291,
1,
0,
0,
0,
292,
293,
1,
0,
0,
0,
293,
295,
1,
0,
0,
0,
294,
296,
3,
52,
26,
0,
295,
294,
1,
0,
0,
0,
295,
296,
1,
0,
0,
0,
296,
300,
1,
0,
0,
0,
297,
299,
3,
46,
23,
0,
298,
297,
1,
0,
0,
0,
299,
302,
1,
0,
0,
0,
300,
298,
1,
0,
0,
0,
300,
301,
1,
0,
0,
0,
301,
303,
1,
0,
0,
0,
302,
300,
1,
0,
0,
0,
303,
304,
5,
53,
0,
0,
304,
305,
3,
60,
30,
0,
305,
306,
5,
56,
0,
0,
306,
307,
3,
40,
20,
0,
307,
39,
1,
0,
0,
0,
308,
310,
3,
42,
21,
0,
309,
308,
1,
0,
0,
0,
310,
313,
1,
0,
0,
0,
311,
309,
1,
0,
0,
0,
311,
312,
1,
0,
0,
0,
312,
315,
1,
0,
0,
0,
313,
311,
1,
0,
0,
0,
314,
316,
3,
44,
22,
0,
315,
314,
1,
0,
0,
0,
315,
316,
1,
0,
0,
0,
316,
41,
1,
0,
0,
0,
317,
318,
5,
50,
0,
0,
318,
319,
3,
30,
15,
0,
319,
320,
3,
28,
14,
0,
320,
43,
1,
0,
0,
0,
321,
322,
5,
51,
0,
0,
322,
323,
3,
28,
14,
0,
323,
45,
1,
0,
0,
0,
324,
327,
3,
8,
4,
0,
325,
327,
3,
54,
27,
0,
326,
324,
1,
0,
0,
0,
326,
325,
1,
0,
0,
0,
327,
47,
1,
0,
0,
0,
328,
329,
5,
47,
0,
0,
329,
330,
3,
30,
15,
0,
330,
49,
1,
0,
0,
0,
331,
332,
5,
49,
0,
0,
332,
337,
3,
132,
66,
0,
333,
334,
5,
55,
0,
0,
334,
336,
3,
132,
66,
0,
335,
333,
1,
0,
0,
0,
336,
339,
1,
0,
0,
0,
337,
335,
1,
0,
0,
0,
337,
338,
1,
0,
0,
0,
338,
51,
1,
0,
0,
0,
339,
337,
1,
0,
0,
0,
340,
341,
5,
48,
0,
0,
341,
342,
3,
30,
15,
0,
342,
53,
1,
0,
0,
0,
343,
344,
5,
71,
0,
0,
344,
345,
3,
130,
65,
0,
345,
346,
3,
28,
14,
0,
346,
55,
1,
0,
0,
0,
347,
349,
3,
58,
29,
0,
348,
347,
1,
0,
0,
0,
349,
350,
1,
0,
0,
0,
350,
348,
1,
0,
0,
0,
350,
351,
1,
0,
0,
0,
351,
57,
1,
0,
0,
0,
352,
353,
7,
0,
0,
0,
353,
59,
1,
0,
0,
0,
354,
355,
3,
62,
31,
0,
355,
61,
1,
0,
0,
0,
356,
361,
3,
64,
32,
0,
357,
358,
5,
67,
0,
0,
358,
360,
3,
64,
32,
0,
359,
357,
1,
0,
0,
0,
360,
363,
1,
0,
0,
0,
361,
359,
1,
0,
0,
0,
361,
362,
1,
0,
0,
0,
362,
63,
1,
0,
0,
0,
363,
361,
1,
0,
0,
0,
364,
367,
3,
90,
45,
0,
365,
366,
5,
72,
0,
0,
366,
368,
3,
130,
65,
0,
367,
365,
1,
0,
0,
0,
367,
368,
1,
0,
0,
0,
368,
65,
1,
0,
0,
0,
369,
371,
5,
40,
0,
0,
370,
369,
1,
0,
0,
0,
370,
371,
1,
0,
0,
0,
371,
372,
1,
0,
0,
0,
372,
374,
5,
11,
0,
0,
373,
375,
3,
8,
4,
0,
374,
373,
1,
0,
0,
0,
374,
375,
1,
0,
0,
0,
375,
376,
1,
0,
0,
0,
376,
377,
5,
53,
0,
0,
377,
378,
3,
68,
34,
0,
378,
379,
5,
56,
0,
0,
379,
67,
1,
0,
0,
0,
380,
381,
3,
70,
35,
0,
381,
69,
1,
0,
0,
0,
382,
387,
3,
72,
36,
0,
383,
384,
5,
67,
0,
0,
384,
386,
3,
72,
36,
0,
385,
383,
1,
0,
0,
0,
386,
389,
1,
0,
0,
0,
387,
385,
1,
0,
0,
0,
387,
388,
1,
0,
0,
0,
388,
71,
1,
0,
0,
0,
389,
387,
1,
0,
0,
0,
390,
392,
3,
74,
37,
0,
391,
393,
3,
80,
40,
0,
392,
391,
1,
0,
0,
0,
392,
393,
1,
0,
0,
0,
393,
396,
1,
0,
0,
0,
394,
396,
1,
0,
0,
0,
395,
390,
1,
0,
0,
0,
395,
394,
1,
0,
0,
0,
396,
73,
1,
0,
0,
0,
397,
399,
3,
76,
38,
0,
398,
397,
1,
0,
0,
0,
399,
400,
1,
0,
0,
0,
400,
398,
1,
0,
0,
0,
400,
401,
1,
0,
0,
0,
401,
404,
1,
0,
0,
0,
402,
404,
1,
0,
0,
0,
403,
398,
1,
0,
0,
0,
403,
402,
1,
0,
0,
0,
404,
75,
1,
0,
0,
0,
405,
407,
3,
106,
53,
0,
406,
408,
3,
104,
52,
0,
407,
406,
1,
0,
0,
0,
407,
408,
1,
0,
0,
0,
408,
418,
1,
0,
0,
0,
409,
411,
3,
78,
39,
0,
410,
412,
3,
104,
52,
0,
411,
410,
1,
0,
0,
0,
411,
412,
1,
0,
0,
0,
412,
418,
1,
0,
0,
0,
413,
415,
3,
28,
14,
0,
414,
416,
5,
63,
0,
0,
415,
414,
1,
0,
0,
0,
415,
416,
1,
0,
0,
0,
416,
418,
1,
0,
0,
0,
417,
405,
1,
0,
0,
0,
417,
409,
1,
0,
0,
0,
417,
413,
1,
0,
0,
0,
418,
77,
1,
0,
0,
0,
419,
420,
5,
57,
0,
0,
420,
421,
3,
70,
35,
0,
421,
422,
5,
58,
0,
0,
422,
79,
1,
0,
0,
0,
423,
424,
5,
60,
0,
0,
424,
429,
3,
82,
41,
0,
425,
426,
5,
55,
0,
0,
426,
428,
3,
82,
41,
0,
427,
425,
1,
0,
0,
0,
428,
431,
1,
0,
0,
0,
429,
427,
1,
0,
0,
0,
429,
430,
1,
0,
0,
0,
430,
81,
1,
0,
0,
0,
431,
429,
1,
0,
0,
0,
432,
433,
3,
84,
42,
0,
433,
434,
5,
57,
0,
0,
434,
435,
3,
86,
43,
0,
435,
436,
5,
58,
0,
0,
436,
439,
1,
0,
0,
0,
437,
439,
3,
84,
42,
0,
438,
432,
1,
0,
0,
0,
438,
437,
1,
0,
0,
0,
439,
83,
1,
0,
0,
0,
440,
443,
3,
130,
65,
0,
441,
443,
5,
52,
0,
0,
442,
440,
1,
0,
0,
0,
442,
441,
1,
0,
0,
0,
443,
85,
1,
0,
0,
0,
444,
447,
3,
130,
65,
0,
445,
447,
5,
33,
0,
0,
446,
444,
1,
0,
0,
0,
446,
445,
1,
0,
0,
0,
447,
87,
1,
0,
0,
0,
448,
453,
3,
90,
45,
0,
449,
450,
5,
67,
0,
0,
450,
452,
3,
90,
45,
0,
451,
449,
1,
0,
0,
0,
452,
455,
1,
0,
0,
0,
453,
451,
1,
0,
0,
0,
453,
454,
1,
0,
0,
0,
454,
89,
1,
0,
0,
0,
455,
453,
1,
0,
0,
0,
456,
458,
3,
126,
63,
0,
457,
456,
1,
0,
0,
0,
457,
458,
1,
0,
0,
0,
458,
460,
1,
0,
0,
0,
459,
461,
3,
92,
46,
0,
460,
459,
1,
0,
0,
0,
461,
462,
1,
0,
0,
0,
462,
460,
1,
0,
0,
0,
462,
463,
1,
0,
0,
0,
463,
466,
1,
0,
0,
0,
464,
466,
1,
0,
0,
0,
465,
457,
1,
0,
0,
0,
465,
464,
1,
0,
0,
0,
466,
91,
1,
0,
0,
0,
467,
470,
3,
98,
49,
0,
468,
471,
3,
104,
52,
0,
469,
471,
1,
0,
0,
0,
470,
468,
1,
0,
0,
0,
470,
469,
1,
0,
0,
0,
471,
486,
1,
0,
0,
0,
472,
475,
3,
108,
54,
0,
473,
476,
3,
104,
52,
0,
474,
476,
1,
0,
0,
0,
475,
473,
1,
0,
0,
0,
475,
474,
1,
0,
0,
0,
476,
486,
1,
0,
0,
0,
477,
486,
3,
100,
50,
0,
478,
480,
3,
28,
14,
0,
479,
481,
5,
63,
0,
0,
480,
479,
1,
0,
0,
0,
480,
481,
1,
0,
0,
0,
481,
483,
1,
0,
0,
0,
482,
484,
3,
94,
47,
0,
483,
482,
1,
0,
0,
0,
483,
484,
1,
0,
0,
0,
484,
486,
1,
0,
0,
0,
485,
467,
1,
0,
0,
0,
485,
472,
1,
0,
0,
0,
485,
477,
1,
0,
0,
0,
485,
478,
1,
0,
0,
0,
486,
93,
1,
0,
0,
0,
487,
488,
5,
61,
0,
0,
488,
493,
3,
96,
48,
0,
489,
490,
5,
55,
0,
0,
490,
492,
3,
96,
48,
0,
491,
489,
1,
0,
0,
0,
492,
495,
1,
0,
0,
0,
493,
491,
1,
0,
0,
0,
493,
494,
1,
0,
0,
0,
494,
496,
1,
0,
0,
0,
495,
493,
1,
0,
0,
0,
496,
497,
5,
62,
0,
0,
497,
95,
1,
0,
0,
0,
498,
507,
3,
128,
64,
0,
499,
500,
3,
130,
65,
0,
500,
504,
5,
7,
0,
0,
501,
505,
3,
28,
14,
0,
502,
505,
5,
33,
0,
0,
503,
505,
5,
10,
0,
0,
504,
501,
1,
0,
0,
0,
504,
502,
1,
0,
0,
0,
504,
503,
1,
0,
0,
0,
505,
507,
1,
0,
0,
0,
506,
498,
1,
0,
0,
0,
506,
499,
1,
0,
0,
0,
507,
97,
1,
0,
0,
0,
508,
509,
3,
130,
65,
0,
509,
512,
7,
1,
0,
0,
510,
513,
3,
108,
54,
0,
511,
513,
3,
118,
59,
0,
512,
510,
1,
0,
0,
0,
512,
511,
1,
0,
0,
0,
513,
99,
1,
0,
0,
0,
514,
516,
3,
118,
59,
0,
515,
517,
3,
102,
51,
0,
516,
515,
1,
0,
0,
0,
516,
517,
1,
0,
0,
0,
517,
101,
1,
0,
0,
0,
518,
519,
3,
104,
52,
0,
519,
103,
1,
0,
0,
0,
520,
522,
5,
63,
0,
0,
521,
523,
5,
63,
0,
0,
522,
521,
1,
0,
0,
0,
522,
523,
1,
0,
0,
0,
523,
533,
1,
0,
0,
0,
524,
526,
5,
64,
0,
0,
525,
527,
5,
63,
0,
0,
526,
525,
1,
0,
0,
0,
526,
527,
1,
0,
0,
0,
527,
533,
1,
0,
0,
0,
528,
530,
5,
66,
0,
0,
529,
531,
5,
63,
0,
0,
530,
529,
1,
0,
0,
0,
530,
531,
1,
0,
0,
0,
531,
533,
1,
0,
0,
0,
532,
520,
1,
0,
0,
0,
532,
524,
1,
0,
0,
0,
532,
528,
1,
0,
0,
0,
533,
105,
1,
0,
0,
0,
534,
540,
3,
122,
61,
0,
535,
540,
3,
124,
62,
0,
536,
540,
3,
112,
56,
0,
537,
540,
5,
29,
0,
0,
538,
540,
3,
110,
55,
0,
539,
534,
1,
0,
0,
0,
539,
535,
1,
0,
0,
0,
539,
536,
1,
0,
0,
0,
539,
537,
1,
0,
0,
0,
539,
538,
1,
0,
0,
0,
540,
107,
1,
0,
0,
0,
541,
546,
3,
124,
62,
0,
542,
546,
3,
120,
60,
0,
543,
546,
3,
112,
56,
0,
544,
546,
3,
110,
55,
0,
545,
541,
1,
0,
0,
0,
545,
542,
1,
0,
0,
0,
545,
543,
1,
0,
0,
0,
545,
544,
1,
0,
0,
0,
546,
109,
1,
0,
0,
0,
547,
549,
5,
70,
0,
0,
548,
550,
3,
126,
63,
0,
549,
548,
1,
0,
0,
0,
549,
550,
1,
0,
0,
0,
550,
111,
1,
0,
0,
0,
551,
552,
5,
73,
0,
0,
552,
556,
3,
116,
58,
0,
553,
554,
5,
73,
0,
0,
554,
556,
3,
114,
57,
0,
555,
551,
1,
0,
0,
0,
555,
553,
1,
0,
0,
0,
556,
113,
1,
0,
0,
0,
557,
558,
5,
57,
0,
0,
558,
563,
3,
116,
58,
0,
559,
560,
5,
67,
0,
0,
560,
562,
3,
116,
58,
0,
561,
559,
1,
0,
0,
0,
562,
565,
1,
0,
0,
0,
563,
561,
1,
0,
0,
0,
563,
564,
1,
0,
0,
0,
564,
566,
1,
0,
0,
0,
565,
563,
1,
0,
0,
0,
566,
567,
5,
58,
0,
0,
567,
115,
1,
0,
0,
0,
568,
570,
5,
11,
0,
0,
569,
571,
3,
126,
63,
0,
570,
569,
1,
0,
0,
0,
570,
571,
1,
0,
0,
0,
571,
579,
1,
0,
0,
0,
572,
574,
5,
10,
0,
0,
573,
575,
3,
126,
63,
0,
574,
573,
1,
0,
0,
0,
574,
575,
1,
0,
0,
0,
575,
579,
1,
0,
0,
0,
576,
579,
3,
122,
61,
0,
577,
579,
5,
29,
0,
0,
578,
568,
1,
0,
0,
0,
578,
572,
1,
0,
0,
0,
578,
576,
1,
0,
0,
0,
578,
577,
1,
0,
0,
0,
579,
117,
1,
0,
0,
0,
580,
591,
5,
57,
0,
0,
581,
583,
3,
8,
4,
0,
582,
581,
1,
0,
0,
0,
582,
583,
1,
0,
0,
0,
583,
587,
1,
0,
0,
0,
584,
586,
3,
54,
27,
0,
585,
584,
1,
0,
0,
0,
586,
589,
1,
0,
0,
0,
587,
585,
1,
0,
0,
0,
587,
588,
1,
0,
0,
0,
588,
590,
1,
0,
0,
0,
589,
587,
1,
0,
0,
0,
590,
592,
5,
53,
0,
0,
591,
582,
1,
0,
0,
0,
591,
592,
1,
0,
0,
0,
592,
593,
1,
0,
0,
0,
593,
594,
3,
88,
44,
0,
594,
595,
5,
58,
0,
0,
595,
119,
1,
0,
0,
0,
596,
598,
5,
8,
0,
0,
597,
599,
3,
30,
15,
0,
598,
597,
1,
0,
0,
0,
598,
599,
1,
0,
0,
0,
599,
601,
1,
0,
0,
0,
600,
602,
3,
126,
63,
0,
601,
600,
1,
0,
0,
0,
601,
602,
1,
0,
0,
0,
602,
121,
1,
0,
0,
0,
603,
604,
5,
10,
0,
0,
604,
605,
5,
69,
0,
0,
605,
606,
5,
10,
0,
0,
606,
123,
1,
0,
0,
0,
607,
609,
5,
11,
0,
0,
608,
610,
3,
126,
63,
0,
609,
608,
1,
0,
0,
0,
609,
610,
1,
0,
0,
0,
610,
616,
1,
0,
0,
0,
611,
613,
5,
10,
0,
0,
612,
614,
3,
126,
63,
0,
613,
612,
1,
0,
0,
0,
613,
614,
1,
0,
0,
0,
614,
616,
1,
0,
0,
0,
615,
607,
1,
0,
0,
0,
615,
611,
1,
0,
0,
0,
616,
125,
1,
0,
0,
0,
617,
618,
5,
61,
0,
0,
618,
623,
3,
128,
64,
0,
619,
620,
5,
55,
0,
0,
620,
622,
3,
128,
64,
0,
621,
619,
1,
0,
0,
0,
622,
625,
1,
0,
0,
0,
623,
621,
1,
0,
0,
0,
623,
624,
1,
0,
0,
0,
624,
626,
1,
0,
0,
0,
625,
623,
1,
0,
0,
0,
626,
627,
5,
62,
0,
0,
627,
127,
1,
0,
0,
0,
628,
637,
3,
132,
66,
0,
629,
630,
3,
130,
65,
0,
630,
634,
5,
7,
0,
0,
631,
635,
3,
132,
66,
0,
632,
635,
5,
10,
0,
0,
633,
635,
5,
33,
0,
0,
634,
631,
1,
0,
0,
0,
634,
632,
1,
0,
0,
0,
634,
633,
1,
0,
0,
0,
635,
637,
1,
0,
0,
0,
636,
628,
1,
0,
0,
0,
636,
629,
1,
0,
0,
0,
637,
129,
1,
0,
0,
0,
638,
639,
7,
2,
0,
0,
639,
131,
1,
0,
0,
0,
640,
645,
3,
130,
65,
0,
641,
642,
5,
70,
0,
0,
642,
644,
3,
130,
65,
0,
643,
641,
1,
0,
0,
0,
644,
647,
1,
0,
0,
0,
645,
643,
1,
0,
0,
0,
645,
646,
1,
0,
0,
0,
646,
133,
1,
0,
0,
0,
647,
645,
1,
0,
0,
0,
85,
138,
145,
159,
166,
174,
188,
194,
202,
212,
216,
222,
231,
235,
241,
249,
257,
268,
274,
279,
282,
286,
289,
292,
295,
300,
311,
315,
326,
337,
350,
361,
367,
370,
374,
387,
392,
395,
400,
403,
407,
411,
415,
417,
429,
438,
442,
446,
453,
457,
462,
465,
470,
475,
480,
483,
485,
493,
504,
506,
512,
516,
522,
526,
530,
532,
539,
545,
549,
555,
563,
570,
574,
578,
582,
587,
591,
598,
601,
609,
613,
615,
623,
634,
636,
645
];
static __ATN;
static get _ATN() {
if (!ANTLRv4Parser.__ATN) {
ANTLRv4Parser.__ATN = new antlr.ATNDeserializer().deserialize(ANTLRv4Parser._serializedATN);
}
return ANTLRv4Parser.__ATN;
}
static vocabulary = new antlr.Vocabulary(ANTLRv4Parser.literalNames, ANTLRv4Parser.symbolicNames, []);
get vocabulary() {
return ANTLRv4Parser.vocabulary;
}
static decisionsToDFA = ANTLRv4Parser._ATN.decisionToState.map((ds, index) => new antlr.DFA(ds, index));
}
class GrammarSpecContext extends antlr.ParserRuleContext {
static {
__name(this, "GrammarSpecContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
grammarDecl() {
return this.getRuleContext(0, GrammarDeclContext);
}
rules() {
return this.getRuleContext(0, RulesContext);
}
EOF() {
return this.getToken(ANTLRv4Parser.EOF, 0);
}
prequelConstruct(i) {
if (i === void 0) {
return this.getRuleContexts(PrequelConstructContext);
}
return this.getRuleContext(i, PrequelConstructContext);
}
modeSpec(i) {
if (i === void 0) {
return this.getRuleContexts(ModeSpecContext);
}
return this.getRuleContext(i, ModeSpecContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_grammarSpec;
}
enterRule(listener) {
if (listener.enterGrammarSpec) {
listener.enterGrammarSpec(this);
}
}
exitRule(listener) {
if (listener.exitGrammarSpec) {
listener.exitGrammarSpec(this);
}
}
accept(visitor) {
if (visitor.visitGrammarSpec) {
return visitor.visitGrammarSpec(this);
} else {
return visitor.visitChildren(this);
}
}
}
class GrammarDeclContext extends antlr.ParserRuleContext {
static {
__name(this, "GrammarDeclContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
grammarType() {
return this.getRuleContext(0, GrammarTypeContext);
}
identifier() {
return this.getRuleContext(0, IdentifierContext);
}
SEMI() {
return this.getToken(ANTLRv4Parser.SEMI, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_grammarDecl;
}
enterRule(listener) {
if (listener.enterGrammarDecl) {
listener.enterGrammarDecl(this);
}
}
exitRule(listener) {
if (listener.exitGrammarDecl) {
listener.exitGrammarDecl(this);
}
}
accept(visitor) {
if (visitor.visitGrammarDecl) {
return visitor.visitGrammarDecl(this);
} else {
return visitor.visitChildren(this);
}
}
}
class GrammarTypeContext extends antlr.ParserRuleContext {
static {
__name(this, "GrammarTypeContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
LEXER() {
return this.getToken(ANTLRv4Parser.LEXER, 0);
}
GRAMMAR() {
return this.getToken(ANTLRv4Parser.GRAMMAR, 0);
}
PARSER() {
return this.getToken(ANTLRv4Parser.PARSER, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_grammarType;
}
enterRule(listener) {
if (listener.enterGrammarType) {
listener.enterGrammarType(this);
}
}
exitRule(listener) {
if (listener.exitGrammarType) {
listener.exitGrammarType(this);
}
}
accept(visitor) {
if (visitor.visitGrammarType) {
return visitor.visitGrammarType(this);
} else {
return visitor.visitChildren(this);
}
}
}
class PrequelConstructContext extends antlr.ParserRuleContext {
static {
__name(this, "PrequelConstructContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
optionsSpec() {
return this.getRuleContext(0, OptionsSpecContext);
}
delegateGrammars() {
return this.getRuleContext(0, DelegateGrammarsContext);
}
tokensSpec() {
return this.getRuleContext(0, TokensSpecContext);
}
channelsSpec() {
return this.getRuleContext(0, ChannelsSpecContext);
}
action_() {
return this.getRuleContext(0, Action_Context);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_prequelConstruct;
}
enterRule(listener) {
if (listener.enterPrequelConstruct) {
listener.enterPrequelConstruct(this);
}
}
exitRule(listener) {
if (listener.exitPrequelConstruct) {
listener.exitPrequelConstruct(this);
}
}
accept(visitor) {
if (visitor.visitPrequelConstruct) {
return visitor.visitPrequelConstruct(this);
} else {
return visitor.visitChildren(this);
}
}
}
class OptionsSpecContext extends antlr.ParserRuleContext {
static {
__name(this, "OptionsSpecContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
OPTIONS() {
return this.getToken(ANTLRv4Parser.OPTIONS, 0);
}
RBRACE() {
return this.getToken(ANTLRv4Parser.RBRACE, 0);
}
option(i) {
if (i === void 0) {
return this.getRuleContexts(OptionContext);
}
return this.getRuleContext(i, OptionContext);
}
SEMI(i) {
if (i === void 0) {
return this.getTokens(ANTLRv4Parser.SEMI);
} else {
return this.getToken(ANTLRv4Parser.SEMI, i);
}
}
get ruleIndex() {
return ANTLRv4Parser.RULE_optionsSpec;
}
enterRule(listener) {
if (listener.enterOptionsSpec) {
listener.enterOptionsSpec(this);
}
}
exitRule(listener) {
if (listener.exitOptionsSpec) {
listener.exitOptionsSpec(this);
}
}
accept(visitor) {
if (visitor.visitOptionsSpec) {
return visitor.visitOptionsSpec(this);
} else {
return visitor.visitChildren(this);
}
}
}
class OptionContext extends antlr.ParserRuleContext {
static {
__name(this, "OptionContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
identifier() {
return this.getRuleContext(0, IdentifierContext);
}
ASSIGN() {
return this.getToken(ANTLRv4Parser.ASSIGN, 0);
}
optionValue() {
return this.getRuleContext(0, OptionValueContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_option;
}
enterRule(listener) {
if (listener.enterOption) {
listener.enterOption(this);
}
}
exitRule(listener) {
if (listener.exitOption) {
listener.exitOption(this);
}
}
accept(visitor) {
if (visitor.visitOption) {
return visitor.visitOption(this);
} else {
return visitor.visitChildren(this);
}
}
}
class OptionValueContext extends antlr.ParserRuleContext {
static {
__name(this, "OptionValueContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
identifier(i) {
if (i === void 0) {
return this.getRuleContexts(IdentifierContext);
}
return this.getRuleContext(i, IdentifierContext);
}
DOT(i) {
if (i === void 0) {
return this.getTokens(ANTLRv4Parser.DOT);
} else {
return this.getToken(ANTLRv4Parser.DOT, i);
}
}
STRING_LITERAL() {
return this.getToken(ANTLRv4Parser.STRING_LITERAL, 0);
}
actionBlock() {
return this.getRuleContext(0, ActionBlockContext);
}
INT() {
return this.getToken(ANTLRv4Parser.INT, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_optionValue;
}
enterRule(listener) {
if (listener.enterOptionValue) {
listener.enterOptionValue(this);
}
}
exitRule(listener) {
if (listener.exitOptionValue) {
listener.exitOptionValue(this);
}
}
accept(visitor) {
if (visitor.visitOptionValue) {
return visitor.visitOptionValue(this);
} else {
return visitor.visitChildren(this);
}
}
}
class DelegateGrammarsContext extends antlr.ParserRuleContext {
static {
__name(this, "DelegateGrammarsContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
IMPORT() {
return this.getToken(ANTLRv4Parser.IMPORT, 0);
}
delegateGrammar(i) {
if (i === void 0) {
return this.getRuleContexts(DelegateGrammarContext);
}
return this.getRuleContext(i, DelegateGrammarContext);
}
SEMI() {
return this.getToken(ANTLRv4Parser.SEMI, 0);
}
COMMA(i) {
if (i === void 0) {
return this.getTokens(ANTLRv4Parser.COMMA);
} else {
return this.getToken(ANTLRv4Parser.COMMA, i);
}
}
get ruleIndex() {
return ANTLRv4Parser.RULE_delegateGrammars;
}
enterRule(listener) {
if (listener.enterDelegateGrammars) {
listener.enterDelegateGrammars(this);
}
}
exitRule(listener) {
if (listener.exitDelegateGrammars) {
listener.exitDelegateGrammars(this);
}
}
accept(visitor) {
if (visitor.visitDelegateGrammars) {
return visitor.visitDelegateGrammars(this);
} else {
return visitor.visitChildren(this);
}
}
}
class DelegateGrammarContext extends antlr.ParserRuleContext {
static {
__name(this, "DelegateGrammarContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
identifier(i) {
if (i === void 0) {
return this.getRuleContexts(IdentifierContext);
}
return this.getRuleContext(i, IdentifierContext);
}
ASSIGN() {
return this.getToken(ANTLRv4Parser.ASSIGN, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_delegateGrammar;
}
enterRule(listener) {
if (listener.enterDelegateGrammar) {
listener.enterDelegateGrammar(this);
}
}
exitRule(listener) {
if (listener.exitDelegateGrammar) {
listener.exitDelegateGrammar(this);
}
}
accept(visitor) {
if (visitor.visitDelegateGrammar) {
return visitor.visitDelegateGrammar(this);
} else {
return visitor.visitChildren(this);
}
}
}
class TokensSpecContext extends antlr.ParserRuleContext {
static {
__name(this, "TokensSpecContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
TOKENS() {
return this.getToken(ANTLRv4Parser.TOKENS, 0);
}
RBRACE() {
return this.getToken(ANTLRv4Parser.RBRACE, 0);
}
idList() {
return this.getRuleContext(0, IdListContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_tokensSpec;
}
enterRule(listener) {
if (listener.enterTokensSpec) {
listener.enterTokensSpec(this);
}
}
exitRule(listener) {
if (listener.exitTokensSpec) {
listener.exitTokensSpec(this);
}
}
accept(visitor) {
if (visitor.visitTokensSpec) {
return visitor.visitTokensSpec(this);
} else {
return visitor.visitChildren(this);
}
}
}
class ChannelsSpecContext extends antlr.ParserRuleContext {
static {
__name(this, "ChannelsSpecContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
CHANNELS() {
return this.getToken(ANTLRv4Parser.CHANNELS, 0);
}
RBRACE() {
return this.getToken(ANTLRv4Parser.RBRACE, 0);
}
idList() {
return this.getRuleContext(0, IdListContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_channelsSpec;
}
enterRule(listener) {
if (listener.enterChannelsSpec) {
listener.enterChannelsSpec(this);
}
}
exitRule(listener) {
if (listener.exitChannelsSpec) {
listener.exitChannelsSpec(this);
}
}
accept(visitor) {
if (visitor.visitChannelsSpec) {
return visitor.visitChannelsSpec(this);
} else {
return visitor.visitChildren(this);
}
}
}
class IdListContext extends antlr.ParserRuleContext {
static {
__name(this, "IdListContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
identifier(i) {
if (i === void 0) {
return this.getRuleContexts(IdentifierContext);
}
return this.getRuleContext(i, IdentifierContext);
}
COMMA(i) {
if (i === void 0) {
return this.getTokens(ANTLRv4Parser.COMMA);
} else {
return this.getToken(ANTLRv4Parser.COMMA, i);
}
}
get ruleIndex() {
return ANTLRv4Parser.RULE_idList;
}
enterRule(listener) {
if (listener.enterIdList) {
listener.enterIdList(this);
}
}
exitRule(listener) {
if (listener.exitIdList) {
listener.exitIdList(this);
}
}
accept(visitor) {
if (visitor.visitIdList) {
return visitor.visitIdList(this);
} else {
return visitor.visitChildren(this);
}
}
}
class Action_Context extends antlr.ParserRuleContext {
static {
__name(this, "Action_Context");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
AT() {
return this.getToken(ANTLRv4Parser.AT, 0);
}
identifier() {
return this.getRuleContext(0, IdentifierContext);
}
actionBlock() {
return this.getRuleContext(0, ActionBlockContext);
}
actionScopeName() {
return this.getRuleContext(0, ActionScopeNameContext);
}
COLONCOLON() {
return this.getToken(ANTLRv4Parser.COLONCOLON, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_action_;
}
enterRule(listener) {
if (listener.enterAction_) {
listener.enterAction_(this);
}
}
exitRule(listener) {
if (listener.exitAction_) {
listener.exitAction_(this);
}
}
accept(visitor) {
if (visitor.visitAction_) {
return visitor.visitAction_(this);
} else {
return visitor.visitChildren(this);
}
}
}
class ActionScopeNameContext extends antlr.ParserRuleContext {
static {
__name(this, "ActionScopeNameContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
identifier() {
return this.getRuleContext(0, IdentifierContext);
}
LEXER() {
return this.getToken(ANTLRv4Parser.LEXER, 0);
}
PARSER() {
return this.getToken(ANTLRv4Parser.PARSER, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_actionScopeName;
}
enterRule(listener) {
if (listener.enterActionScopeName) {
listener.enterActionScopeName(this);
}
}
exitRule(listener) {
if (listener.exitActionScopeName) {
listener.exitActionScopeName(this);
}
}
accept(visitor) {
if (visitor.visitActionScopeName) {
return visitor.visitActionScopeName(this);
} else {
return visitor.visitChildren(this);
}
}
}
class ActionBlockContext extends antlr.ParserRuleContext {
static {
__name(this, "ActionBlockContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
ACTION() {
return this.getToken(ANTLRv4Parser.ACTION, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_actionBlock;
}
enterRule(listener) {
if (listener.enterActionBlock) {
listener.enterActionBlock(this);
}
}
exitRule(listener) {
if (listener.exitActionBlock) {
listener.exitActionBlock(this);
}
}
accept(visitor) {
if (visitor.visitActionBlock) {
return visitor.visitActionBlock(this);
} else {
return visitor.visitChildren(this);
}
}
}
class ArgActionBlockContext extends antlr.ParserRuleContext {
static {
__name(this, "ArgActionBlockContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
BEGIN_ARGUMENT() {
return this.getToken(ANTLRv4Parser.BEGIN_ARGUMENT, 0);
}
END_ARGUMENT() {
return this.getToken(ANTLRv4Parser.END_ARGUMENT, 0);
}
ARGUMENT_CONTENT(i) {
if (i === void 0) {
return this.getTokens(ANTLRv4Parser.ARGUMENT_CONTENT);
} else {
return this.getToken(ANTLRv4Parser.ARGUMENT_CONTENT, i);
}
}
get ruleIndex() {
return ANTLRv4Parser.RULE_argActionBlock;
}
enterRule(listener) {
if (listener.enterArgActionBlock) {
listener.enterArgActionBlock(this);
}
}
exitRule(listener) {
if (listener.exitArgActionBlock) {
listener.exitArgActionBlock(this);
}
}
accept(visitor) {
if (visitor.visitArgActionBlock) {
return visitor.visitArgActionBlock(this);
} else {
return visitor.visitChildren(this);
}
}
}
class ModeSpecContext extends antlr.ParserRuleContext {
static {
__name(this, "ModeSpecContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
MODE() {
return this.getToken(ANTLRv4Parser.MODE, 0);
}
identifier() {
return this.getRuleContext(0, IdentifierContext);
}
SEMI() {
return this.getToken(ANTLRv4Parser.SEMI, 0);
}
lexerRuleSpec(i) {
if (i === void 0) {
return this.getRuleContexts(LexerRuleSpecContext);
}
return this.getRuleContext(i, LexerRuleSpecContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_modeSpec;
}
enterRule(listener) {
if (listener.enterModeSpec) {
listener.enterModeSpec(this);
}
}
exitRule(listener) {
if (listener.exitModeSpec) {
listener.exitModeSpec(this);
}
}
accept(visitor) {
if (visitor.visitModeSpec) {
return visitor.visitModeSpec(this);
} else {
return visitor.visitChildren(this);
}
}
}
class RulesContext extends antlr.ParserRuleContext {
static {
__name(this, "RulesContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
ruleSpec(i) {
if (i === void 0) {
return this.getRuleContexts(RuleSpecContext);
}
return this.getRuleContext(i, RuleSpecContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_rules;
}
enterRule(listener) {
if (listener.enterRules) {
listener.enterRules(this);
}
}
exitRule(listener) {
if (listener.exitRules) {
listener.exitRules(this);
}
}
accept(visitor) {
if (visitor.visitRules) {
return visitor.visitRules(this);
} else {
return visitor.visitChildren(this);
}
}
}
class RuleSpecContext extends antlr.ParserRuleContext {
static {
__name(this, "RuleSpecContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
parserRuleSpec() {
return this.getRuleContext(0, ParserRuleSpecContext);
}
lexerRuleSpec() {
return this.getRuleContext(0, LexerRuleSpecContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_ruleSpec;
}
enterRule(listener) {
if (listener.enterRuleSpec) {
listener.enterRuleSpec(this);
}
}
exitRule(listener) {
if (listener.exitRuleSpec) {
listener.exitRuleSpec(this);
}
}
accept(visitor) {
if (visitor.visitRuleSpec) {
return visitor.visitRuleSpec(this);
} else {
return visitor.visitChildren(this);
}
}
}
class ParserRuleSpecContext extends antlr.ParserRuleContext {
static {
__name(this, "ParserRuleSpecContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
RULE_REF() {
return this.getToken(ANTLRv4Parser.RULE_REF, 0);
}
COLON() {
return this.getToken(ANTLRv4Parser.COLON, 0);
}
ruleBlock() {
return this.getRuleContext(0, RuleBlockContext);
}
SEMI() {
return this.getToken(ANTLRv4Parser.SEMI, 0);
}
exceptionGroup() {
return this.getRuleContext(0, ExceptionGroupContext);
}
ruleModifiers() {
return this.getRuleContext(0, RuleModifiersContext);
}
argActionBlock() {
return this.getRuleContext(0, ArgActionBlockContext);
}
ruleReturns() {
return this.getRuleContext(0, RuleReturnsContext);
}
throwsSpec() {
return this.getRuleContext(0, ThrowsSpecContext);
}
localsSpec() {
return this.getRuleContext(0, LocalsSpecContext);
}
rulePrequel(i) {
if (i === void 0) {
return this.getRuleContexts(RulePrequelContext);
}
return this.getRuleContext(i, RulePrequelContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_parserRuleSpec;
}
enterRule(listener) {
if (listener.enterParserRuleSpec) {
listener.enterParserRuleSpec(this);
}
}
exitRule(listener) {
if (listener.exitParserRuleSpec) {
listener.exitParserRuleSpec(this);
}
}
accept(visitor) {
if (visitor.visitParserRuleSpec) {
return visitor.visitParserRuleSpec(this);
} else {
return visitor.visitChildren(this);
}
}
}
class ExceptionGroupContext extends antlr.ParserRuleContext {
static {
__name(this, "ExceptionGroupContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
exceptionHandler(i) {
if (i === void 0) {
return this.getRuleContexts(ExceptionHandlerContext);
}
return this.getRuleContext(i, ExceptionHandlerContext);
}
finallyClause() {
return this.getRuleContext(0, FinallyClauseContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_exceptionGroup;
}
enterRule(listener) {
if (listener.enterExceptionGroup) {
listener.enterExceptionGroup(this);
}
}
exitRule(listener) {
if (listener.exitExceptionGroup) {
listener.exitExceptionGroup(this);
}
}
accept(visitor) {
if (visitor.visitExceptionGroup) {
return visitor.visitExceptionGroup(this);
} else {
return visitor.visitChildren(this);
}
}
}
class ExceptionHandlerContext extends antlr.ParserRuleContext {
static {
__name(this, "ExceptionHandlerContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
CATCH() {
return this.getToken(ANTLRv4Parser.CATCH, 0);
}
argActionBlock() {
return this.getRuleContext(0, ArgActionBlockContext);
}
actionBlock() {
return this.getRuleContext(0, ActionBlockContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_exceptionHandler;
}
enterRule(listener) {
if (listener.enterExceptionHandler) {
listener.enterExceptionHandler(this);
}
}
exitRule(listener) {
if (listener.exitExceptionHandler) {
listener.exitExceptionHandler(this);
}
}
accept(visitor) {
if (visitor.visitExceptionHandler) {
return visitor.visitExceptionHandler(this);
} else {
return visitor.visitChildren(this);
}
}
}
class FinallyClauseContext extends antlr.ParserRuleContext {
static {
__name(this, "FinallyClauseContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
FINALLY() {
return this.getToken(ANTLRv4Parser.FINALLY, 0);
}
actionBlock() {
return this.getRuleContext(0, ActionBlockContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_finallyClause;
}
enterRule(listener) {
if (listener.enterFinallyClause) {
listener.enterFinallyClause(this);
}
}
exitRule(listener) {
if (listener.exitFinallyClause) {
listener.exitFinallyClause(this);
}
}
accept(visitor) {
if (visitor.visitFinallyClause) {
return visitor.visitFinallyClause(this);
} else {
return visitor.visitChildren(this);
}
}
}
class RulePrequelContext extends antlr.ParserRuleContext {
static {
__name(this, "RulePrequelContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
optionsSpec() {
return this.getRuleContext(0, OptionsSpecContext);
}
ruleAction() {
return this.getRuleContext(0, RuleActionContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_rulePrequel;
}
enterRule(listener) {
if (listener.enterRulePrequel) {
listener.enterRulePrequel(this);
}
}
exitRule(listener) {
if (listener.exitRulePrequel) {
listener.exitRulePrequel(this);
}
}
accept(visitor) {
if (visitor.visitRulePrequel) {
return visitor.visitRulePrequel(this);
} else {
return visitor.visitChildren(this);
}
}
}
class RuleReturnsContext extends antlr.ParserRuleContext {
static {
__name(this, "RuleReturnsContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
RETURNS() {
return this.getToken(ANTLRv4Parser.RETURNS, 0);
}
argActionBlock() {
return this.getRuleContext(0, ArgActionBlockContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_ruleReturns;
}
enterRule(listener) {
if (listener.enterRuleReturns) {
listener.enterRuleReturns(this);
}
}
exitRule(listener) {
if (listener.exitRuleReturns) {
listener.exitRuleReturns(this);
}
}
accept(visitor) {
if (visitor.visitRuleReturns) {
return visitor.visitRuleReturns(this);
} else {
return visitor.visitChildren(this);
}
}
}
class ThrowsSpecContext extends antlr.ParserRuleContext {
static {
__name(this, "ThrowsSpecContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
THROWS() {
return this.getToken(ANTLRv4Parser.THROWS, 0);
}
qualifiedIdentifier(i) {
if (i === void 0) {
return this.getRuleContexts(QualifiedIdentifierContext);
}
return this.getRuleContext(i, QualifiedIdentifierContext);
}
COMMA(i) {
if (i === void 0) {
return this.getTokens(ANTLRv4Parser.COMMA);
} else {
return this.getToken(ANTLRv4Parser.COMMA, i);
}
}
get ruleIndex() {
return ANTLRv4Parser.RULE_throwsSpec;
}
enterRule(listener) {
if (listener.enterThrowsSpec) {
listener.enterThrowsSpec(this);
}
}
exitRule(listener) {
if (listener.exitThrowsSpec) {
listener.exitThrowsSpec(this);
}
}
accept(visitor) {
if (visitor.visitThrowsSpec) {
return visitor.visitThrowsSpec(this);
} else {
return visitor.visitChildren(this);
}
}
}
class LocalsSpecContext extends antlr.ParserRuleContext {
static {
__name(this, "LocalsSpecContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
LOCALS() {
return this.getToken(ANTLRv4Parser.LOCALS, 0);
}
argActionBlock() {
return this.getRuleContext(0, ArgActionBlockContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_localsSpec;
}
enterRule(listener) {
if (listener.enterLocalsSpec) {
listener.enterLocalsSpec(this);
}
}
exitRule(listener) {
if (listener.exitLocalsSpec) {
listener.exitLocalsSpec(this);
}
}
accept(visitor) {
if (visitor.visitLocalsSpec) {
return visitor.visitLocalsSpec(this);
} else {
return visitor.visitChildren(this);
}
}
}
class RuleActionContext extends antlr.ParserRuleContext {
static {
__name(this, "RuleActionContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
AT() {
return this.getToken(ANTLRv4Parser.AT, 0);
}
identifier() {
return this.getRuleContext(0, IdentifierContext);
}
actionBlock() {
return this.getRuleContext(0, ActionBlockContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_ruleAction;
}
enterRule(listener) {
if (listener.enterRuleAction) {
listener.enterRuleAction(this);
}
}
exitRule(listener) {
if (listener.exitRuleAction) {
listener.exitRuleAction(this);
}
}
accept(visitor) {
if (visitor.visitRuleAction) {
return visitor.visitRuleAction(this);
} else {
return visitor.visitChildren(this);
}
}
}
class RuleModifiersContext extends antlr.ParserRuleContext {
static {
__name(this, "RuleModifiersContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
ruleModifier(i) {
if (i === void 0) {
return this.getRuleContexts(RuleModifierContext);
}
return this.getRuleContext(i, RuleModifierContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_ruleModifiers;
}
enterRule(listener) {
if (listener.enterRuleModifiers) {
listener.enterRuleModifiers(this);
}
}
exitRule(listener) {
if (listener.exitRuleModifiers) {
listener.exitRuleModifiers(this);
}
}
accept(visitor) {
if (visitor.visitRuleModifiers) {
return visitor.visitRuleModifiers(this);
} else {
return visitor.visitChildren(this);
}
}
}
class RuleModifierContext extends antlr.ParserRuleContext {
static {
__name(this, "RuleModifierContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
PUBLIC() {
return this.getToken(ANTLRv4Parser.PUBLIC, 0);
}
PRIVATE() {
return this.getToken(ANTLRv4Parser.PRIVATE, 0);
}
PROTECTED() {
return this.getToken(ANTLRv4Parser.PROTECTED, 0);
}
FRAGMENT() {
return this.getToken(ANTLRv4Parser.FRAGMENT, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_ruleModifier;
}
enterRule(listener) {
if (listener.enterRuleModifier) {
listener.enterRuleModifier(this);
}
}
exitRule(listener) {
if (listener.exitRuleModifier) {
listener.exitRuleModifier(this);
}
}
accept(visitor) {
if (visitor.visitRuleModifier) {
return visitor.visitRuleModifier(this);
} else {
return visitor.visitChildren(this);
}
}
}
class RuleBlockContext extends antlr.ParserRuleContext {
static {
__name(this, "RuleBlockContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
ruleAltList() {
return this.getRuleContext(0, RuleAltListContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_ruleBlock;
}
enterRule(listener) {
if (listener.enterRuleBlock) {
listener.enterRuleBlock(this);
}
}
exitRule(listener) {
if (listener.exitRuleBlock) {
listener.exitRuleBlock(this);
}
}
accept(visitor) {
if (visitor.visitRuleBlock) {
return visitor.visitRuleBlock(this);
} else {
return visitor.visitChildren(this);
}
}
}
class RuleAltListContext extends antlr.ParserRuleContext {
static {
__name(this, "RuleAltListContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
labeledAlt(i) {
if (i === void 0) {
return this.getRuleContexts(LabeledAltContext);
}
return this.getRuleContext(i, LabeledAltContext);
}
OR(i) {
if (i === void 0) {
return this.getTokens(ANTLRv4Parser.OR);
} else {
return this.getToken(ANTLRv4Parser.OR, i);
}
}
get ruleIndex() {
return ANTLRv4Parser.RULE_ruleAltList;
}
enterRule(listener) {
if (listener.enterRuleAltList) {
listener.enterRuleAltList(this);
}
}
exitRule(listener) {
if (listener.exitRuleAltList) {
listener.exitRuleAltList(this);
}
}
accept(visitor) {
if (visitor.visitRuleAltList) {
return visitor.visitRuleAltList(this);
} else {
return visitor.visitChildren(this);
}
}
}
class LabeledAltContext extends antlr.ParserRuleContext {
static {
__name(this, "LabeledAltContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
alternative() {
return this.getRuleContext(0, AlternativeContext);
}
POUND() {
return this.getToken(ANTLRv4Parser.POUND, 0);
}
identifier() {
return this.getRuleContext(0, IdentifierContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_labeledAlt;
}
enterRule(listener) {
if (listener.enterLabeledAlt) {
listener.enterLabeledAlt(this);
}
}
exitRule(listener) {
if (listener.exitLabeledAlt) {
listener.exitLabeledAlt(this);
}
}
accept(visitor) {
if (visitor.visitLabeledAlt) {
return visitor.visitLabeledAlt(this);
} else {
return visitor.visitChildren(this);
}
}
}
class LexerRuleSpecContext extends antlr.ParserRuleContext {
static {
__name(this, "LexerRuleSpecContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
TOKEN_REF() {
return this.getToken(ANTLRv4Parser.TOKEN_REF, 0);
}
COLON() {
return this.getToken(ANTLRv4Parser.COLON, 0);
}
lexerRuleBlock() {
return this.getRuleContext(0, LexerRuleBlockContext);
}
SEMI() {
return this.getToken(ANTLRv4Parser.SEMI, 0);
}
FRAGMENT() {
return this.getToken(ANTLRv4Parser.FRAGMENT, 0);
}
optionsSpec() {
return this.getRuleContext(0, OptionsSpecContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_lexerRuleSpec;
}
enterRule(listener) {
if (listener.enterLexerRuleSpec) {
listener.enterLexerRuleSpec(this);
}
}
exitRule(listener) {
if (listener.exitLexerRuleSpec) {
listener.exitLexerRuleSpec(this);
}
}
accept(visitor) {
if (visitor.visitLexerRuleSpec) {
return visitor.visitLexerRuleSpec(this);
} else {
return visitor.visitChildren(this);
}
}
}
class LexerRuleBlockContext extends antlr.ParserRuleContext {
static {
__name(this, "LexerRuleBlockContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
lexerAltList() {
return this.getRuleContext(0, LexerAltListContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_lexerRuleBlock;
}
enterRule(listener) {
if (listener.enterLexerRuleBlock) {
listener.enterLexerRuleBlock(this);
}
}
exitRule(listener) {
if (listener.exitLexerRuleBlock) {
listener.exitLexerRuleBlock(this);
}
}
accept(visitor) {
if (visitor.visitLexerRuleBlock) {
return visitor.visitLexerRuleBlock(this);
} else {
return visitor.visitChildren(this);
}
}
}
class LexerAltListContext extends antlr.ParserRuleContext {
static {
__name(this, "LexerAltListContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
lexerAlt(i) {
if (i === void 0) {
return this.getRuleContexts(LexerAltContext);
}
return this.getRuleContext(i, LexerAltContext);
}
OR(i) {
if (i === void 0) {
return this.getTokens(ANTLRv4Parser.OR);
} else {
return this.getToken(ANTLRv4Parser.OR, i);
}
}
get ruleIndex() {
return ANTLRv4Parser.RULE_lexerAltList;
}
enterRule(listener) {
if (listener.enterLexerAltList) {
listener.enterLexerAltList(this);
}
}
exitRule(listener) {
if (listener.exitLexerAltList) {
listener.exitLexerAltList(this);
}
}
accept(visitor) {
if (visitor.visitLexerAltList) {
return visitor.visitLexerAltList(this);
} else {
return visitor.visitChildren(this);
}
}
}
class LexerAltContext extends antlr.ParserRuleContext {
static {
__name(this, "LexerAltContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
lexerElements() {
return this.getRuleContext(0, LexerElementsContext);
}
lexerCommands() {
return this.getRuleContext(0, LexerCommandsContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_lexerAlt;
}
enterRule(listener) {
if (listener.enterLexerAlt) {
listener.enterLexerAlt(this);
}
}
exitRule(listener) {
if (listener.exitLexerAlt) {
listener.exitLexerAlt(this);
}
}
accept(visitor) {
if (visitor.visitLexerAlt) {
return visitor.visitLexerAlt(this);
} else {
return visitor.visitChildren(this);
}
}
}
class LexerElementsContext extends antlr.ParserRuleContext {
static {
__name(this, "LexerElementsContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
lexerElement(i) {
if (i === void 0) {
return this.getRuleContexts(LexerElementContext);
}
return this.getRuleContext(i, LexerElementContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_lexerElements;
}
enterRule(listener) {
if (listener.enterLexerElements) {
listener.enterLexerElements(this);
}
}
exitRule(listener) {
if (listener.exitLexerElements) {
listener.exitLexerElements(this);
}
}
accept(visitor) {
if (visitor.visitLexerElements) {
return visitor.visitLexerElements(this);
} else {
return visitor.visitChildren(this);
}
}
}
class LexerElementContext extends antlr.ParserRuleContext {
static {
__name(this, "LexerElementContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
lexerAtom() {
return this.getRuleContext(0, LexerAtomContext);
}
ebnfSuffix() {
return this.getRuleContext(0, EbnfSuffixContext);
}
lexerBlock() {
return this.getRuleContext(0, LexerBlockContext);
}
actionBlock() {
return this.getRuleContext(0, ActionBlockContext);
}
QUESTION() {
return this.getToken(ANTLRv4Parser.QUESTION, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_lexerElement;
}
enterRule(listener) {
if (listener.enterLexerElement) {
listener.enterLexerElement(this);
}
}
exitRule(listener) {
if (listener.exitLexerElement) {
listener.exitLexerElement(this);
}
}
accept(visitor) {
if (visitor.visitLexerElement) {
return visitor.visitLexerElement(this);
} else {
return visitor.visitChildren(this);
}
}
}
class LexerBlockContext extends antlr.ParserRuleContext {
static {
__name(this, "LexerBlockContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
LPAREN() {
return this.getToken(ANTLRv4Parser.LPAREN, 0);
}
lexerAltList() {
return this.getRuleContext(0, LexerAltListContext);
}
RPAREN() {
return this.getToken(ANTLRv4Parser.RPAREN, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_lexerBlock;
}
enterRule(listener) {
if (listener.enterLexerBlock) {
listener.enterLexerBlock(this);
}
}
exitRule(listener) {
if (listener.exitLexerBlock) {
listener.exitLexerBlock(this);
}
}
accept(visitor) {
if (visitor.visitLexerBlock) {
return visitor.visitLexerBlock(this);
} else {
return visitor.visitChildren(this);
}
}
}
class LexerCommandsContext extends antlr.ParserRuleContext {
static {
__name(this, "LexerCommandsContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
RARROW() {
return this.getToken(ANTLRv4Parser.RARROW, 0);
}
lexerCommand(i) {
if (i === void 0) {
return this.getRuleContexts(LexerCommandContext);
}
return this.getRuleContext(i, LexerCommandContext);
}
COMMA(i) {
if (i === void 0) {
return this.getTokens(ANTLRv4Parser.COMMA);
} else {
return this.getToken(ANTLRv4Parser.COMMA, i);
}
}
get ruleIndex() {
return ANTLRv4Parser.RULE_lexerCommands;
}
enterRule(listener) {
if (listener.enterLexerCommands) {
listener.enterLexerCommands(this);
}
}
exitRule(listener) {
if (listener.exitLexerCommands) {
listener.exitLexerCommands(this);
}
}
accept(visitor) {
if (visitor.visitLexerCommands) {
return visitor.visitLexerCommands(this);
} else {
return visitor.visitChildren(this);
}
}
}
class LexerCommandContext extends antlr.ParserRuleContext {
static {
__name(this, "LexerCommandContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
lexerCommandName() {
return this.getRuleContext(0, LexerCommandNameContext);
}
LPAREN() {
return this.getToken(ANTLRv4Parser.LPAREN, 0);
}
lexerCommandExpr() {
return this.getRuleContext(0, LexerCommandExprContext);
}
RPAREN() {
return this.getToken(ANTLRv4Parser.RPAREN, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_lexerCommand;
}
enterRule(listener) {
if (listener.enterLexerCommand) {
listener.enterLexerCommand(this);
}
}
exitRule(listener) {
if (listener.exitLexerCommand) {
listener.exitLexerCommand(this);
}
}
accept(visitor) {
if (visitor.visitLexerCommand) {
return visitor.visitLexerCommand(this);
} else {
return visitor.visitChildren(this);
}
}
}
class LexerCommandNameContext extends antlr.ParserRuleContext {
static {
__name(this, "LexerCommandNameContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
identifier() {
return this.getRuleContext(0, IdentifierContext);
}
MODE() {
return this.getToken(ANTLRv4Parser.MODE, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_lexerCommandName;
}
enterRule(listener) {
if (listener.enterLexerCommandName) {
listener.enterLexerCommandName(this);
}
}
exitRule(listener) {
if (listener.exitLexerCommandName) {
listener.exitLexerCommandName(this);
}
}
accept(visitor) {
if (visitor.visitLexerCommandName) {
return visitor.visitLexerCommandName(this);
} else {
return visitor.visitChildren(this);
}
}
}
class LexerCommandExprContext extends antlr.ParserRuleContext {
static {
__name(this, "LexerCommandExprContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
identifier() {
return this.getRuleContext(0, IdentifierContext);
}
INT() {
return this.getToken(ANTLRv4Parser.INT, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_lexerCommandExpr;
}
enterRule(listener) {
if (listener.enterLexerCommandExpr) {
listener.enterLexerCommandExpr(this);
}
}
exitRule(listener) {
if (listener.exitLexerCommandExpr) {
listener.exitLexerCommandExpr(this);
}
}
accept(visitor) {
if (visitor.visitLexerCommandExpr) {
return visitor.visitLexerCommandExpr(this);
} else {
return visitor.visitChildren(this);
}
}
}
class AltListContext extends antlr.ParserRuleContext {
static {
__name(this, "AltListContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
alternative(i) {
if (i === void 0) {
return this.getRuleContexts(AlternativeContext);
}
return this.getRuleContext(i, AlternativeContext);
}
OR(i) {
if (i === void 0) {
return this.getTokens(ANTLRv4Parser.OR);
} else {
return this.getToken(ANTLRv4Parser.OR, i);
}
}
get ruleIndex() {
return ANTLRv4Parser.RULE_altList;
}
enterRule(listener) {
if (listener.enterAltList) {
listener.enterAltList(this);
}
}
exitRule(listener) {
if (listener.exitAltList) {
listener.exitAltList(this);
}
}
accept(visitor) {
if (visitor.visitAltList) {
return visitor.visitAltList(this);
} else {
return visitor.visitChildren(this);
}
}
}
class AlternativeContext extends antlr.ParserRuleContext {
static {
__name(this, "AlternativeContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
elementOptions() {
return this.getRuleContext(0, ElementOptionsContext);
}
element(i) {
if (i === void 0) {
return this.getRuleContexts(ElementContext);
}
return this.getRuleContext(i, ElementContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_alternative;
}
enterRule(listener) {
if (listener.enterAlternative) {
listener.enterAlternative(this);
}
}
exitRule(listener) {
if (listener.exitAlternative) {
listener.exitAlternative(this);
}
}
accept(visitor) {
if (visitor.visitAlternative) {
return visitor.visitAlternative(this);
} else {
return visitor.visitChildren(this);
}
}
}
class ElementContext extends antlr.ParserRuleContext {
static {
__name(this, "ElementContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
labeledElement() {
return this.getRuleContext(0, LabeledElementContext);
}
ebnfSuffix() {
return this.getRuleContext(0, EbnfSuffixContext);
}
atom() {
return this.getRuleContext(0, AtomContext);
}
ebnf() {
return this.getRuleContext(0, EbnfContext);
}
actionBlock() {
return this.getRuleContext(0, ActionBlockContext);
}
QUESTION() {
return this.getToken(ANTLRv4Parser.QUESTION, 0);
}
predicateOptions() {
return this.getRuleContext(0, PredicateOptionsContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_element;
}
enterRule(listener) {
if (listener.enterElement) {
listener.enterElement(this);
}
}
exitRule(listener) {
if (listener.exitElement) {
listener.exitElement(this);
}
}
accept(visitor) {
if (visitor.visitElement) {
return visitor.visitElement(this);
} else {
return visitor.visitChildren(this);
}
}
}
class PredicateOptionsContext extends antlr.ParserRuleContext {
static {
__name(this, "PredicateOptionsContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
LT() {
return this.getToken(ANTLRv4Parser.LT, 0);
}
predicateOption(i) {
if (i === void 0) {
return this.getRuleContexts(PredicateOptionContext);
}
return this.getRuleContext(i, PredicateOptionContext);
}
GT() {
return this.getToken(ANTLRv4Parser.GT, 0);
}
COMMA(i) {
if (i === void 0) {
return this.getTokens(ANTLRv4Parser.COMMA);
} else {
return this.getToken(ANTLRv4Parser.COMMA, i);
}
}
get ruleIndex() {
return ANTLRv4Parser.RULE_predicateOptions;
}
enterRule(listener) {
if (listener.enterPredicateOptions) {
listener.enterPredicateOptions(this);
}
}
exitRule(listener) {
if (listener.exitPredicateOptions) {
listener.exitPredicateOptions(this);
}
}
accept(visitor) {
if (visitor.visitPredicateOptions) {
return visitor.visitPredicateOptions(this);
} else {
return visitor.visitChildren(this);
}
}
}
class PredicateOptionContext extends antlr.ParserRuleContext {
static {
__name(this, "PredicateOptionContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
elementOption() {
return this.getRuleContext(0, ElementOptionContext);
}
identifier() {
return this.getRuleContext(0, IdentifierContext);
}
ASSIGN() {
return this.getToken(ANTLRv4Parser.ASSIGN, 0);
}
actionBlock() {
return this.getRuleContext(0, ActionBlockContext);
}
INT() {
return this.getToken(ANTLRv4Parser.INT, 0);
}
STRING_LITERAL() {
return this.getToken(ANTLRv4Parser.STRING_LITERAL, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_predicateOption;
}
enterRule(listener) {
if (listener.enterPredicateOption) {
listener.enterPredicateOption(this);
}
}
exitRule(listener) {
if (listener.exitPredicateOption) {
listener.exitPredicateOption(this);
}
}
accept(visitor) {
if (visitor.visitPredicateOption) {
return visitor.visitPredicateOption(this);
} else {
return visitor.visitChildren(this);
}
}
}
class LabeledElementContext extends antlr.ParserRuleContext {
static {
__name(this, "LabeledElementContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
identifier() {
return this.getRuleContext(0, IdentifierContext);
}
ASSIGN() {
return this.getToken(ANTLRv4Parser.ASSIGN, 0);
}
PLUS_ASSIGN() {
return this.getToken(ANTLRv4Parser.PLUS_ASSIGN, 0);
}
atom() {
return this.getRuleContext(0, AtomContext);
}
block() {
return this.getRuleContext(0, BlockContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_labeledElement;
}
enterRule(listener) {
if (listener.enterLabeledElement) {
listener.enterLabeledElement(this);
}
}
exitRule(listener) {
if (listener.exitLabeledElement) {
listener.exitLabeledElement(this);
}
}
accept(visitor) {
if (visitor.visitLabeledElement) {
return visitor.visitLabeledElement(this);
} else {
return visitor.visitChildren(this);
}
}
}
class EbnfContext extends antlr.ParserRuleContext {
static {
__name(this, "EbnfContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
block() {
return this.getRuleContext(0, BlockContext);
}
blockSuffix() {
return this.getRuleContext(0, BlockSuffixContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_ebnf;
}
enterRule(listener) {
if (listener.enterEbnf) {
listener.enterEbnf(this);
}
}
exitRule(listener) {
if (listener.exitEbnf) {
listener.exitEbnf(this);
}
}
accept(visitor) {
if (visitor.visitEbnf) {
return visitor.visitEbnf(this);
} else {
return visitor.visitChildren(this);
}
}
}
class BlockSuffixContext extends antlr.ParserRuleContext {
static {
__name(this, "BlockSuffixContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
ebnfSuffix() {
return this.getRuleContext(0, EbnfSuffixContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_blockSuffix;
}
enterRule(listener) {
if (listener.enterBlockSuffix) {
listener.enterBlockSuffix(this);
}
}
exitRule(listener) {
if (listener.exitBlockSuffix) {
listener.exitBlockSuffix(this);
}
}
accept(visitor) {
if (visitor.visitBlockSuffix) {
return visitor.visitBlockSuffix(this);
} else {
return visitor.visitChildren(this);
}
}
}
class EbnfSuffixContext extends antlr.ParserRuleContext {
static {
__name(this, "EbnfSuffixContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
QUESTION(i) {
if (i === void 0) {
return this.getTokens(ANTLRv4Parser.QUESTION);
} else {
return this.getToken(ANTLRv4Parser.QUESTION, i);
}
}
STAR() {
return this.getToken(ANTLRv4Parser.STAR, 0);
}
PLUS() {
return this.getToken(ANTLRv4Parser.PLUS, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_ebnfSuffix;
}
enterRule(listener) {
if (listener.enterEbnfSuffix) {
listener.enterEbnfSuffix(this);
}
}
exitRule(listener) {
if (listener.exitEbnfSuffix) {
listener.exitEbnfSuffix(this);
}
}
accept(visitor) {
if (visitor.visitEbnfSuffix) {
return visitor.visitEbnfSuffix(this);
} else {
return visitor.visitChildren(this);
}
}
}
class LexerAtomContext extends antlr.ParserRuleContext {
static {
__name(this, "LexerAtomContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
characterRange() {
return this.getRuleContext(0, CharacterRangeContext);
}
terminalDef() {
return this.getRuleContext(0, TerminalDefContext);
}
notSet() {
return this.getRuleContext(0, NotSetContext);
}
LEXER_CHAR_SET() {
return this.getToken(ANTLRv4Parser.LEXER_CHAR_SET, 0);
}
wildcard() {
return this.getRuleContext(0, WildcardContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_lexerAtom;
}
enterRule(listener) {
if (listener.enterLexerAtom) {
listener.enterLexerAtom(this);
}
}
exitRule(listener) {
if (listener.exitLexerAtom) {
listener.exitLexerAtom(this);
}
}
accept(visitor) {
if (visitor.visitLexerAtom) {
return visitor.visitLexerAtom(this);
} else {
return visitor.visitChildren(this);
}
}
}
class AtomContext extends antlr.ParserRuleContext {
static {
__name(this, "AtomContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
terminalDef() {
return this.getRuleContext(0, TerminalDefContext);
}
ruleref() {
return this.getRuleContext(0, RulerefContext);
}
notSet() {
return this.getRuleContext(0, NotSetContext);
}
wildcard() {
return this.getRuleContext(0, WildcardContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_atom;
}
enterRule(listener) {
if (listener.enterAtom) {
listener.enterAtom(this);
}
}
exitRule(listener) {
if (listener.exitAtom) {
listener.exitAtom(this);
}
}
accept(visitor) {
if (visitor.visitAtom) {
return visitor.visitAtom(this);
} else {
return visitor.visitChildren(this);
}
}
}
class WildcardContext extends antlr.ParserRuleContext {
static {
__name(this, "WildcardContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
DOT() {
return this.getToken(ANTLRv4Parser.DOT, 0);
}
elementOptions() {
return this.getRuleContext(0, ElementOptionsContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_wildcard;
}
enterRule(listener) {
if (listener.enterWildcard) {
listener.enterWildcard(this);
}
}
exitRule(listener) {
if (listener.exitWildcard) {
listener.exitWildcard(this);
}
}
accept(visitor) {
if (visitor.visitWildcard) {
return visitor.visitWildcard(this);
} else {
return visitor.visitChildren(this);
}
}
}
class NotSetContext extends antlr.ParserRuleContext {
static {
__name(this, "NotSetContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
NOT() {
return this.getToken(ANTLRv4Parser.NOT, 0);
}
setElement() {
return this.getRuleContext(0, SetElementContext);
}
blockSet() {
return this.getRuleContext(0, BlockSetContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_notSet;
}
enterRule(listener) {
if (listener.enterNotSet) {
listener.enterNotSet(this);
}
}
exitRule(listener) {
if (listener.exitNotSet) {
listener.exitNotSet(this);
}
}
accept(visitor) {
if (visitor.visitNotSet) {
return visitor.visitNotSet(this);
} else {
return visitor.visitChildren(this);
}
}
}
class BlockSetContext extends antlr.ParserRuleContext {
static {
__name(this, "BlockSetContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
LPAREN() {
return this.getToken(ANTLRv4Parser.LPAREN, 0);
}
setElement(i) {
if (i === void 0) {
return this.getRuleContexts(SetElementContext);
}
return this.getRuleContext(i, SetElementContext);
}
RPAREN() {
return this.getToken(ANTLRv4Parser.RPAREN, 0);
}
OR(i) {
if (i === void 0) {
return this.getTokens(ANTLRv4Parser.OR);
} else {
return this.getToken(ANTLRv4Parser.OR, i);
}
}
get ruleIndex() {
return ANTLRv4Parser.RULE_blockSet;
}
enterRule(listener) {
if (listener.enterBlockSet) {
listener.enterBlockSet(this);
}
}
exitRule(listener) {
if (listener.exitBlockSet) {
listener.exitBlockSet(this);
}
}
accept(visitor) {
if (visitor.visitBlockSet) {
return visitor.visitBlockSet(this);
} else {
return visitor.visitChildren(this);
}
}
}
class SetElementContext extends antlr.ParserRuleContext {
static {
__name(this, "SetElementContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
TOKEN_REF() {
return this.getToken(ANTLRv4Parser.TOKEN_REF, 0);
}
elementOptions() {
return this.getRuleContext(0, ElementOptionsContext);
}
STRING_LITERAL() {
return this.getToken(ANTLRv4Parser.STRING_LITERAL, 0);
}
characterRange() {
return this.getRuleContext(0, CharacterRangeContext);
}
LEXER_CHAR_SET() {
return this.getToken(ANTLRv4Parser.LEXER_CHAR_SET, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_setElement;
}
enterRule(listener) {
if (listener.enterSetElement) {
listener.enterSetElement(this);
}
}
exitRule(listener) {
if (listener.exitSetElement) {
listener.exitSetElement(this);
}
}
accept(visitor) {
if (visitor.visitSetElement) {
return visitor.visitSetElement(this);
} else {
return visitor.visitChildren(this);
}
}
}
class BlockContext extends antlr.ParserRuleContext {
static {
__name(this, "BlockContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
LPAREN() {
return this.getToken(ANTLRv4Parser.LPAREN, 0);
}
altList() {
return this.getRuleContext(0, AltListContext);
}
RPAREN() {
return this.getToken(ANTLRv4Parser.RPAREN, 0);
}
COLON() {
return this.getToken(ANTLRv4Parser.COLON, 0);
}
optionsSpec() {
return this.getRuleContext(0, OptionsSpecContext);
}
ruleAction(i) {
if (i === void 0) {
return this.getRuleContexts(RuleActionContext);
}
return this.getRuleContext(i, RuleActionContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_block;
}
enterRule(listener) {
if (listener.enterBlock) {
listener.enterBlock(this);
}
}
exitRule(listener) {
if (listener.exitBlock) {
listener.exitBlock(this);
}
}
accept(visitor) {
if (visitor.visitBlock) {
return visitor.visitBlock(this);
} else {
return visitor.visitChildren(this);
}
}
}
class RulerefContext extends antlr.ParserRuleContext {
static {
__name(this, "RulerefContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
RULE_REF() {
return this.getToken(ANTLRv4Parser.RULE_REF, 0);
}
argActionBlock() {
return this.getRuleContext(0, ArgActionBlockContext);
}
elementOptions() {
return this.getRuleContext(0, ElementOptionsContext);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_ruleref;
}
enterRule(listener) {
if (listener.enterRuleref) {
listener.enterRuleref(this);
}
}
exitRule(listener) {
if (listener.exitRuleref) {
listener.exitRuleref(this);
}
}
accept(visitor) {
if (visitor.visitRuleref) {
return visitor.visitRuleref(this);
} else {
return visitor.visitChildren(this);
}
}
}
class CharacterRangeContext extends antlr.ParserRuleContext {
static {
__name(this, "CharacterRangeContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
STRING_LITERAL(i) {
if (i === void 0) {
return this.getTokens(ANTLRv4Parser.STRING_LITERAL);
} else {
return this.getToken(ANTLRv4Parser.STRING_LITERAL, i);
}
}
RANGE() {
return this.getToken(ANTLRv4Parser.RANGE, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_characterRange;
}
enterRule(listener) {
if (listener.enterCharacterRange) {
listener.enterCharacterRange(this);
}
}
exitRule(listener) {
if (listener.exitCharacterRange) {
listener.exitCharacterRange(this);
}
}
accept(visitor) {
if (visitor.visitCharacterRange) {
return visitor.visitCharacterRange(this);
} else {
return visitor.visitChildren(this);
}
}
}
class TerminalDefContext extends antlr.ParserRuleContext {
static {
__name(this, "TerminalDefContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
TOKEN_REF() {
return this.getToken(ANTLRv4Parser.TOKEN_REF, 0);
}
elementOptions() {
return this.getRuleContext(0, ElementOptionsContext);
}
STRING_LITERAL() {
return this.getToken(ANTLRv4Parser.STRING_LITERAL, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_terminalDef;
}
enterRule(listener) {
if (listener.enterTerminalDef) {
listener.enterTerminalDef(this);
}
}
exitRule(listener) {
if (listener.exitTerminalDef) {
listener.exitTerminalDef(this);
}
}
accept(visitor) {
if (visitor.visitTerminalDef) {
return visitor.visitTerminalDef(this);
} else {
return visitor.visitChildren(this);
}
}
}
class ElementOptionsContext extends antlr.ParserRuleContext {
static {
__name(this, "ElementOptionsContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
LT() {
return this.getToken(ANTLRv4Parser.LT, 0);
}
elementOption(i) {
if (i === void 0) {
return this.getRuleContexts(ElementOptionContext);
}
return this.getRuleContext(i, ElementOptionContext);
}
GT() {
return this.getToken(ANTLRv4Parser.GT, 0);
}
COMMA(i) {
if (i === void 0) {
return this.getTokens(ANTLRv4Parser.COMMA);
} else {
return this.getToken(ANTLRv4Parser.COMMA, i);
}
}
get ruleIndex() {
return ANTLRv4Parser.RULE_elementOptions;
}
enterRule(listener) {
if (listener.enterElementOptions) {
listener.enterElementOptions(this);
}
}
exitRule(listener) {
if (listener.exitElementOptions) {
listener.exitElementOptions(this);
}
}
accept(visitor) {
if (visitor.visitElementOptions) {
return visitor.visitElementOptions(this);
} else {
return visitor.visitChildren(this);
}
}
}
class ElementOptionContext extends antlr.ParserRuleContext {
static {
__name(this, "ElementOptionContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
qualifiedIdentifier() {
return this.getRuleContext(0, QualifiedIdentifierContext);
}
identifier() {
return this.getRuleContext(0, IdentifierContext);
}
ASSIGN() {
return this.getToken(ANTLRv4Parser.ASSIGN, 0);
}
STRING_LITERAL() {
return this.getToken(ANTLRv4Parser.STRING_LITERAL, 0);
}
INT() {
return this.getToken(ANTLRv4Parser.INT, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_elementOption;
}
enterRule(listener) {
if (listener.enterElementOption) {
listener.enterElementOption(this);
}
}
exitRule(listener) {
if (listener.exitElementOption) {
listener.exitElementOption(this);
}
}
accept(visitor) {
if (visitor.visitElementOption) {
return visitor.visitElementOption(this);
} else {
return visitor.visitChildren(this);
}
}
}
class IdentifierContext extends antlr.ParserRuleContext {
static {
__name(this, "IdentifierContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
RULE_REF() {
return this.getToken(ANTLRv4Parser.RULE_REF, 0);
}
TOKEN_REF() {
return this.getToken(ANTLRv4Parser.TOKEN_REF, 0);
}
get ruleIndex() {
return ANTLRv4Parser.RULE_identifier;
}
enterRule(listener) {
if (listener.enterIdentifier) {
listener.enterIdentifier(this);
}
}
exitRule(listener) {
if (listener.exitIdentifier) {
listener.exitIdentifier(this);
}
}
accept(visitor) {
if (visitor.visitIdentifier) {
return visitor.visitIdentifier(this);
} else {
return visitor.visitChildren(this);
}
}
}
class QualifiedIdentifierContext extends antlr.ParserRuleContext {
static {
__name(this, "QualifiedIdentifierContext");
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
identifier(i) {
if (i === void 0) {
return this.getRuleContexts(IdentifierContext);
}
return this.getRuleContext(i, IdentifierContext);
}
DOT(i) {
if (i === void 0) {
return this.getTokens(ANTLRv4Parser.DOT);
} else {
return this.getToken(ANTLRv4Parser.DOT, i);
}
}
get ruleIndex() {
return ANTLRv4Parser.RULE_qualifiedIdentifier;
}
enterRule(listener) {
if (listener.enterQualifiedIdentifier) {
listener.enterQualifiedIdentifier(this);
}
}
exitRule(listener) {
if (listener.exitQualifiedIdentifier) {
listener.exitQualifiedIdentifier(this);
}
}
accept(visitor) {
if (visitor.visitQualifiedIdentifier) {
return visitor.visitQualifiedIdentifier(this);
} else {
return visitor.visitChildren(this);
}
}
}
export {
ANTLRv4Parser,
ActionBlockContext,
ActionScopeNameContext,
Action_Context,
AltListContext,
AlternativeContext,
ArgActionBlockContext,
AtomContext,
BlockContext,
BlockSetContext,
BlockSuffixContext,
ChannelsSpecContext,
CharacterRangeContext,
DelegateGrammarContext,
DelegateGrammarsContext,
EbnfContext,
EbnfSuffixContext,
ElementContext,
ElementOptionContext,
ElementOptionsContext,
ExceptionGroupContext,
ExceptionHandlerContext,
FinallyClauseContext,
GrammarDeclContext,
GrammarSpecContext,
GrammarTypeContext,
IdListContext,
IdentifierContext,
LabeledAltContext,
LabeledElementContext,
LexerAltContext,
LexerAltListContext,
LexerAtomContext,
LexerBlockContext,
LexerCommandContext,
LexerCommandExprContext,
LexerCommandNameContext,
LexerCommandsContext,
LexerElementContext,
LexerElementsContext,
LexerRuleBlockContext,
LexerRuleSpecContext,
LocalsSpecContext,
ModeSpecContext,
NotSetContext,
OptionContext,
OptionValueContext,
OptionsSpecContext,
ParserRuleSpecContext,
PredicateOptionContext,
PredicateOptionsContext,
PrequelConstructContext,
QualifiedIdentifierContext,
RuleActionContext,
RuleAltListContext,
RuleBlockContext,
RuleModifierContext,
RuleModifiersContext,
RulePrequelContext,
RuleReturnsContext,
RuleSpecContext,
RulerefContext,
RulesContext,
SetElementContext,
TerminalDefContext,
ThrowsSpecContext,
TokensSpecContext,
WildcardContext
};