ork.cql.3.16.0.source-code.cqlParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of cql Show documentation
Show all versions of cql Show documentation
The cql library for the Clinical Quality Language Java reference implementation
// Generated from cql.g4 by ANTLR 4.13.1
package org.cqframework.cql.gen;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"})
public class cqlParser extends Parser {
static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9,
T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17,
T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24,
T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31,
T__31=32, T__32=33, T__33=34, T__34=35, T__35=36, T__36=37, T__37=38,
T__38=39, T__39=40, T__40=41, T__41=42, T__42=43, T__43=44, T__44=45,
T__45=46, T__46=47, T__47=48, T__48=49, T__49=50, T__50=51, T__51=52,
T__52=53, T__53=54, T__54=55, T__55=56, T__56=57, T__57=58, T__58=59,
T__59=60, T__60=61, T__61=62, T__62=63, T__63=64, T__64=65, T__65=66,
T__66=67, T__67=68, T__68=69, T__69=70, T__70=71, T__71=72, T__72=73,
T__73=74, T__74=75, T__75=76, T__76=77, T__77=78, T__78=79, T__79=80,
T__80=81, T__81=82, T__82=83, T__83=84, T__84=85, T__85=86, T__86=87,
T__87=88, T__88=89, T__89=90, T__90=91, T__91=92, T__92=93, T__93=94,
T__94=95, T__95=96, T__96=97, T__97=98, T__98=99, T__99=100, T__100=101,
T__101=102, T__102=103, T__103=104, T__104=105, T__105=106, T__106=107,
T__107=108, T__108=109, T__109=110, T__110=111, T__111=112, T__112=113,
T__113=114, T__114=115, T__115=116, T__116=117, T__117=118, T__118=119,
T__119=120, T__120=121, T__121=122, T__122=123, T__123=124, T__124=125,
T__125=126, T__126=127, T__127=128, T__128=129, T__129=130, T__130=131,
T__131=132, T__132=133, T__133=134, T__134=135, T__135=136, T__136=137,
T__137=138, T__138=139, T__139=140, T__140=141, T__141=142, T__142=143,
T__143=144, T__144=145, T__145=146, T__146=147, T__147=148, T__148=149,
T__149=150, T__150=151, T__151=152, T__152=153, T__153=154, T__154=155,
T__155=156, T__156=157, QUOTEDIDENTIFIER=158, DATETIME=159, LONGNUMBER=160,
DATE=161, TIME=162, IDENTIFIER=163, DELIMITEDIDENTIFIER=164, STRING=165,
NUMBER=166, WS=167, COMMENT=168, LINE_COMMENT=169;
public static final int
RULE_definition = 0, RULE_library = 1, RULE_libraryDefinition = 2, RULE_usingDefinition = 3,
RULE_includeDefinition = 4, RULE_localIdentifier = 5, RULE_accessModifier = 6,
RULE_parameterDefinition = 7, RULE_codesystemDefinition = 8, RULE_valuesetDefinition = 9,
RULE_codesystems = 10, RULE_codesystemIdentifier = 11, RULE_libraryIdentifier = 12,
RULE_codeDefinition = 13, RULE_conceptDefinition = 14, RULE_codeIdentifier = 15,
RULE_codesystemId = 16, RULE_valuesetId = 17, RULE_versionSpecifier = 18,
RULE_codeId = 19, RULE_typeSpecifier = 20, RULE_namedTypeSpecifier = 21,
RULE_modelIdentifier = 22, RULE_listTypeSpecifier = 23, RULE_intervalTypeSpecifier = 24,
RULE_tupleTypeSpecifier = 25, RULE_tupleElementDefinition = 26, RULE_choiceTypeSpecifier = 27,
RULE_statement = 28, RULE_expressionDefinition = 29, RULE_contextDefinition = 30,
RULE_fluentModifier = 31, RULE_functionDefinition = 32, RULE_operandDefinition = 33,
RULE_functionBody = 34, RULE_querySource = 35, RULE_aliasedQuerySource = 36,
RULE_alias = 37, RULE_queryInclusionClause = 38, RULE_withClause = 39,
RULE_withoutClause = 40, RULE_retrieve = 41, RULE_contextIdentifier = 42,
RULE_codePath = 43, RULE_codeComparator = 44, RULE_terminology = 45, RULE_qualifier = 46,
RULE_query = 47, RULE_sourceClause = 48, RULE_letClause = 49, RULE_letClauseItem = 50,
RULE_whereClause = 51, RULE_returnClause = 52, RULE_aggregateClause = 53,
RULE_startingClause = 54, RULE_sortClause = 55, RULE_sortDirection = 56,
RULE_sortByItem = 57, RULE_qualifiedIdentifier = 58, RULE_qualifiedIdentifierExpression = 59,
RULE_qualifierExpression = 60, RULE_simplePath = 61, RULE_simpleLiteral = 62,
RULE_expression = 63, RULE_dateTimePrecision = 64, RULE_dateTimeComponent = 65,
RULE_pluralDateTimePrecision = 66, RULE_expressionTerm = 67, RULE_caseExpressionItem = 68,
RULE_dateTimePrecisionSpecifier = 69, RULE_relativeQualifier = 70, RULE_offsetRelativeQualifier = 71,
RULE_exclusiveRelativeQualifier = 72, RULE_quantityOffset = 73, RULE_temporalRelationship = 74,
RULE_intervalOperatorPhrase = 75, RULE_term = 76, RULE_qualifiedInvocation = 77,
RULE_qualifiedFunction = 78, RULE_invocation = 79, RULE_function = 80,
RULE_ratio = 81, RULE_literal = 82, RULE_intervalSelector = 83, RULE_tupleSelector = 84,
RULE_tupleElementSelector = 85, RULE_instanceSelector = 86, RULE_instanceElementSelector = 87,
RULE_listSelector = 88, RULE_displayClause = 89, RULE_codeSelector = 90,
RULE_conceptSelector = 91, RULE_keyword = 92, RULE_reservedWord = 93,
RULE_keywordIdentifier = 94, RULE_obsoleteIdentifier = 95, RULE_functionIdentifier = 96,
RULE_typeNameIdentifier = 97, RULE_referentialIdentifier = 98, RULE_referentialOrTypeNameIdentifier = 99,
RULE_identifierOrFunctionIdentifier = 100, RULE_identifier = 101, RULE_externalConstant = 102,
RULE_paramList = 103, RULE_quantity = 104, RULE_unit = 105;
private static String[] makeRuleNames() {
return new String[] {
"definition", "library", "libraryDefinition", "usingDefinition", "includeDefinition",
"localIdentifier", "accessModifier", "parameterDefinition", "codesystemDefinition",
"valuesetDefinition", "codesystems", "codesystemIdentifier", "libraryIdentifier",
"codeDefinition", "conceptDefinition", "codeIdentifier", "codesystemId",
"valuesetId", "versionSpecifier", "codeId", "typeSpecifier", "namedTypeSpecifier",
"modelIdentifier", "listTypeSpecifier", "intervalTypeSpecifier", "tupleTypeSpecifier",
"tupleElementDefinition", "choiceTypeSpecifier", "statement", "expressionDefinition",
"contextDefinition", "fluentModifier", "functionDefinition", "operandDefinition",
"functionBody", "querySource", "aliasedQuerySource", "alias", "queryInclusionClause",
"withClause", "withoutClause", "retrieve", "contextIdentifier", "codePath",
"codeComparator", "terminology", "qualifier", "query", "sourceClause",
"letClause", "letClauseItem", "whereClause", "returnClause", "aggregateClause",
"startingClause", "sortClause", "sortDirection", "sortByItem", "qualifiedIdentifier",
"qualifiedIdentifierExpression", "qualifierExpression", "simplePath",
"simpleLiteral", "expression", "dateTimePrecision", "dateTimeComponent",
"pluralDateTimePrecision", "expressionTerm", "caseExpressionItem", "dateTimePrecisionSpecifier",
"relativeQualifier", "offsetRelativeQualifier", "exclusiveRelativeQualifier",
"quantityOffset", "temporalRelationship", "intervalOperatorPhrase", "term",
"qualifiedInvocation", "qualifiedFunction", "invocation", "function",
"ratio", "literal", "intervalSelector", "tupleSelector", "tupleElementSelector",
"instanceSelector", "instanceElementSelector", "listSelector", "displayClause",
"codeSelector", "conceptSelector", "keyword", "reservedWord", "keywordIdentifier",
"obsoleteIdentifier", "functionIdentifier", "typeNameIdentifier", "referentialIdentifier",
"referentialOrTypeNameIdentifier", "identifierOrFunctionIdentifier",
"identifier", "externalConstant", "paramList", "quantity", "unit"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'library'", "'version'", "'using'", "'called'", "'include'", "'public'",
"'private'", "'parameter'", "'default'", "'codesystem'", "':'", "'valueset'",
"'codesystems'", "'{'", "','", "'}'", "'.'", "'code'", "'from'", "'concept'",
"'List'", "'<'", "'>'", "'Interval'", "'Tuple'", "'Choice'", "'define'",
"'context'", "'fluent'", "'function'", "'('", "')'", "'returns'", "'external'",
"'with'", "'such that'", "'without'", "'['", "'->'", "']'", "'in'", "'='",
"'~'", "'let'", "'where'", "'return'", "'all'", "'distinct'", "'aggregate'",
"'starting'", "'sort'", "'by'", "'asc'", "'ascending'", "'desc'", "'descending'",
"'is'", "'not'", "'null'", "'true'", "'false'", "'as'", "'cast'", "'exists'",
"'properly'", "'between'", "'and'", "'duration'", "'difference'", "'<='",
"'>='", "'!='", "'!~'", "'contains'", "'or'", "'xor'", "'implies'", "'|'",
"'union'", "'intersect'", "'except'", "'year'", "'month'", "'week'",
"'day'", "'hour'", "'minute'", "'second'", "'millisecond'", "'date'",
"'time'", "'timezone'", "'timezoneoffset'", "'years'", "'months'", "'weeks'",
"'days'", "'hours'", "'minutes'", "'seconds'", "'milliseconds'", "'convert'",
"'to'", "'+'", "'-'", "'start'", "'end'", "'of'", "'width'", "'successor'",
"'predecessor'", "'singleton'", "'point'", "'minimum'", "'maximum'",
"'^'", "'*'", "'/'", "'div'", "'mod'", "'&'", "'if'", "'then'", "'else'",
"'case'", "'flatten'", "'expand'", "'collapse'", "'per'", "'when'", "'or before'",
"'or after'", "'or more'", "'or less'", "'less than'", "'more than'",
"'on or'", "'before'", "'after'", "'or on'", "'starts'", "'ends'", "'occurs'",
"'same'", "'includes'", "'during'", "'included in'", "'within'", "'meets'",
"'overlaps'", "'$this'", "'$index'", "'$total'", "'display'", "'Code'",
"'Concept'", "'%'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
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, 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, 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, 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, null, null, null, null, null, null, null, null,
null, null, "QUOTEDIDENTIFIER", "DATETIME", "LONGNUMBER", "DATE", "TIME",
"IDENTIFIER", "DELIMITEDIDENTIFIER", "STRING", "NUMBER", "WS", "COMMENT",
"LINE_COMMENT"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "cql.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public cqlParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@SuppressWarnings("CheckReturnValue")
public static class DefinitionContext extends ParserRuleContext {
public UsingDefinitionContext usingDefinition() {
return getRuleContext(UsingDefinitionContext.class,0);
}
public IncludeDefinitionContext includeDefinition() {
return getRuleContext(IncludeDefinitionContext.class,0);
}
public CodesystemDefinitionContext codesystemDefinition() {
return getRuleContext(CodesystemDefinitionContext.class,0);
}
public ValuesetDefinitionContext valuesetDefinition() {
return getRuleContext(ValuesetDefinitionContext.class,0);
}
public CodeDefinitionContext codeDefinition() {
return getRuleContext(CodeDefinitionContext.class,0);
}
public ConceptDefinitionContext conceptDefinition() {
return getRuleContext(ConceptDefinitionContext.class,0);
}
public ParameterDefinitionContext parameterDefinition() {
return getRuleContext(ParameterDefinitionContext.class,0);
}
public DefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_definition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitDefinition(this);
else return visitor.visitChildren(this);
}
}
public final DefinitionContext definition() throws RecognitionException {
DefinitionContext _localctx = new DefinitionContext(_ctx, getState());
enterRule(_localctx, 0, RULE_definition);
try {
setState(219);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(212);
usingDefinition();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(213);
includeDefinition();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(214);
codesystemDefinition();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(215);
valuesetDefinition();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(216);
codeDefinition();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(217);
conceptDefinition();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(218);
parameterDefinition();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LibraryContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(cqlParser.EOF, 0); }
public LibraryDefinitionContext libraryDefinition() {
return getRuleContext(LibraryDefinitionContext.class,0);
}
public List definition() {
return getRuleContexts(DefinitionContext.class);
}
public DefinitionContext definition(int i) {
return getRuleContext(DefinitionContext.class,i);
}
public List statement() {
return getRuleContexts(StatementContext.class);
}
public StatementContext statement(int i) {
return getRuleContext(StatementContext.class,i);
}
public LibraryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_library; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterLibrary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitLibrary(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitLibrary(this);
else return visitor.visitChildren(this);
}
}
public final LibraryContext library() throws RecognitionException {
LibraryContext _localctx = new LibraryContext(_ctx, getState());
enterRule(_localctx, 2, RULE_library);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(222);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__0) {
{
setState(221);
libraryDefinition();
}
}
setState(227);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1316328L) != 0)) {
{
{
setState(224);
definition();
}
}
setState(229);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(233);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__26 || _la==T__27) {
{
{
setState(230);
statement();
}
}
setState(235);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(236);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LibraryDefinitionContext extends ParserRuleContext {
public QualifiedIdentifierContext qualifiedIdentifier() {
return getRuleContext(QualifiedIdentifierContext.class,0);
}
public VersionSpecifierContext versionSpecifier() {
return getRuleContext(VersionSpecifierContext.class,0);
}
public LibraryDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_libraryDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterLibraryDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitLibraryDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitLibraryDefinition(this);
else return visitor.visitChildren(this);
}
}
public final LibraryDefinitionContext libraryDefinition() throws RecognitionException {
LibraryDefinitionContext _localctx = new LibraryDefinitionContext(_ctx, getState());
enterRule(_localctx, 4, RULE_libraryDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(238);
match(T__0);
setState(239);
qualifiedIdentifier();
setState(242);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1) {
{
setState(240);
match(T__1);
setState(241);
versionSpecifier();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UsingDefinitionContext extends ParserRuleContext {
public QualifiedIdentifierContext qualifiedIdentifier() {
return getRuleContext(QualifiedIdentifierContext.class,0);
}
public VersionSpecifierContext versionSpecifier() {
return getRuleContext(VersionSpecifierContext.class,0);
}
public LocalIdentifierContext localIdentifier() {
return getRuleContext(LocalIdentifierContext.class,0);
}
public UsingDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_usingDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterUsingDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitUsingDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitUsingDefinition(this);
else return visitor.visitChildren(this);
}
}
public final UsingDefinitionContext usingDefinition() throws RecognitionException {
UsingDefinitionContext _localctx = new UsingDefinitionContext(_ctx, getState());
enterRule(_localctx, 6, RULE_usingDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(244);
match(T__2);
setState(245);
qualifiedIdentifier();
setState(248);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1) {
{
setState(246);
match(T__1);
setState(247);
versionSpecifier();
}
}
setState(252);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__3) {
{
setState(250);
match(T__3);
setState(251);
localIdentifier();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IncludeDefinitionContext extends ParserRuleContext {
public QualifiedIdentifierContext qualifiedIdentifier() {
return getRuleContext(QualifiedIdentifierContext.class,0);
}
public VersionSpecifierContext versionSpecifier() {
return getRuleContext(VersionSpecifierContext.class,0);
}
public LocalIdentifierContext localIdentifier() {
return getRuleContext(LocalIdentifierContext.class,0);
}
public IncludeDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_includeDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterIncludeDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitIncludeDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitIncludeDefinition(this);
else return visitor.visitChildren(this);
}
}
public final IncludeDefinitionContext includeDefinition() throws RecognitionException {
IncludeDefinitionContext _localctx = new IncludeDefinitionContext(_ctx, getState());
enterRule(_localctx, 8, RULE_includeDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(254);
match(T__4);
setState(255);
qualifiedIdentifier();
setState(258);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1) {
{
setState(256);
match(T__1);
setState(257);
versionSpecifier();
}
}
setState(262);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__3) {
{
setState(260);
match(T__3);
setState(261);
localIdentifier();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LocalIdentifierContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public LocalIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_localIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterLocalIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitLocalIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitLocalIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final LocalIdentifierContext localIdentifier() throws RecognitionException {
LocalIdentifierContext _localctx = new LocalIdentifierContext(_ctx, getState());
enterRule(_localctx, 10, RULE_localIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(264);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AccessModifierContext extends ParserRuleContext {
public AccessModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_accessModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterAccessModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitAccessModifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitAccessModifier(this);
else return visitor.visitChildren(this);
}
}
public final AccessModifierContext accessModifier() throws RecognitionException {
AccessModifierContext _localctx = new AccessModifierContext(_ctx, getState());
enterRule(_localctx, 12, RULE_accessModifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(266);
_la = _input.LA(1);
if ( !(_la==T__5 || _la==T__6) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ParameterDefinitionContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public AccessModifierContext accessModifier() {
return getRuleContext(AccessModifierContext.class,0);
}
public TypeSpecifierContext typeSpecifier() {
return getRuleContext(TypeSpecifierContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ParameterDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameterDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterParameterDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitParameterDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitParameterDefinition(this);
else return visitor.visitChildren(this);
}
}
public final ParameterDefinitionContext parameterDefinition() throws RecognitionException {
ParameterDefinitionContext _localctx = new ParameterDefinitionContext(_ctx, getState());
enterRule(_localctx, 14, RULE_parameterDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(269);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__5 || _la==T__6) {
{
setState(268);
accessModifier();
}
}
setState(271);
match(T__7);
setState(272);
identifier();
setState(274);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
{
setState(273);
typeSpecifier();
}
break;
}
setState(278);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__8) {
{
setState(276);
match(T__8);
setState(277);
expression(0);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CodesystemDefinitionContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public CodesystemIdContext codesystemId() {
return getRuleContext(CodesystemIdContext.class,0);
}
public AccessModifierContext accessModifier() {
return getRuleContext(AccessModifierContext.class,0);
}
public VersionSpecifierContext versionSpecifier() {
return getRuleContext(VersionSpecifierContext.class,0);
}
public CodesystemDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_codesystemDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterCodesystemDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitCodesystemDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitCodesystemDefinition(this);
else return visitor.visitChildren(this);
}
}
public final CodesystemDefinitionContext codesystemDefinition() throws RecognitionException {
CodesystemDefinitionContext _localctx = new CodesystemDefinitionContext(_ctx, getState());
enterRule(_localctx, 16, RULE_codesystemDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(281);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__5 || _la==T__6) {
{
setState(280);
accessModifier();
}
}
setState(283);
match(T__9);
setState(284);
identifier();
setState(285);
match(T__10);
setState(286);
codesystemId();
setState(289);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1) {
{
setState(287);
match(T__1);
setState(288);
versionSpecifier();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ValuesetDefinitionContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ValuesetIdContext valuesetId() {
return getRuleContext(ValuesetIdContext.class,0);
}
public AccessModifierContext accessModifier() {
return getRuleContext(AccessModifierContext.class,0);
}
public VersionSpecifierContext versionSpecifier() {
return getRuleContext(VersionSpecifierContext.class,0);
}
public CodesystemsContext codesystems() {
return getRuleContext(CodesystemsContext.class,0);
}
public ValuesetDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_valuesetDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterValuesetDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitValuesetDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitValuesetDefinition(this);
else return visitor.visitChildren(this);
}
}
public final ValuesetDefinitionContext valuesetDefinition() throws RecognitionException {
ValuesetDefinitionContext _localctx = new ValuesetDefinitionContext(_ctx, getState());
enterRule(_localctx, 18, RULE_valuesetDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(292);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__5 || _la==T__6) {
{
setState(291);
accessModifier();
}
}
setState(294);
match(T__11);
setState(295);
identifier();
setState(296);
match(T__10);
setState(297);
valuesetId();
setState(300);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1) {
{
setState(298);
match(T__1);
setState(299);
versionSpecifier();
}
}
setState(303);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__12) {
{
setState(302);
codesystems();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CodesystemsContext extends ParserRuleContext {
public List codesystemIdentifier() {
return getRuleContexts(CodesystemIdentifierContext.class);
}
public CodesystemIdentifierContext codesystemIdentifier(int i) {
return getRuleContext(CodesystemIdentifierContext.class,i);
}
public CodesystemsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_codesystems; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterCodesystems(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitCodesystems(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitCodesystems(this);
else return visitor.visitChildren(this);
}
}
public final CodesystemsContext codesystems() throws RecognitionException {
CodesystemsContext _localctx = new CodesystemsContext(_ctx, getState());
enterRule(_localctx, 20, RULE_codesystems);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(305);
match(T__12);
setState(306);
match(T__13);
setState(307);
codesystemIdentifier();
setState(312);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__14) {
{
{
setState(308);
match(T__14);
setState(309);
codesystemIdentifier();
}
}
setState(314);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(315);
match(T__15);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CodesystemIdentifierContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public LibraryIdentifierContext libraryIdentifier() {
return getRuleContext(LibraryIdentifierContext.class,0);
}
public CodesystemIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_codesystemIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterCodesystemIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitCodesystemIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitCodesystemIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final CodesystemIdentifierContext codesystemIdentifier() throws RecognitionException {
CodesystemIdentifierContext _localctx = new CodesystemIdentifierContext(_ctx, getState());
enterRule(_localctx, 22, RULE_codesystemIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(320);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
{
setState(317);
libraryIdentifier();
setState(318);
match(T__16);
}
break;
}
setState(322);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LibraryIdentifierContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public LibraryIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_libraryIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterLibraryIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitLibraryIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitLibraryIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final LibraryIdentifierContext libraryIdentifier() throws RecognitionException {
LibraryIdentifierContext _localctx = new LibraryIdentifierContext(_ctx, getState());
enterRule(_localctx, 24, RULE_libraryIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(324);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CodeDefinitionContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public CodeIdContext codeId() {
return getRuleContext(CodeIdContext.class,0);
}
public CodesystemIdentifierContext codesystemIdentifier() {
return getRuleContext(CodesystemIdentifierContext.class,0);
}
public AccessModifierContext accessModifier() {
return getRuleContext(AccessModifierContext.class,0);
}
public DisplayClauseContext displayClause() {
return getRuleContext(DisplayClauseContext.class,0);
}
public CodeDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_codeDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterCodeDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitCodeDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitCodeDefinition(this);
else return visitor.visitChildren(this);
}
}
public final CodeDefinitionContext codeDefinition() throws RecognitionException {
CodeDefinitionContext _localctx = new CodeDefinitionContext(_ctx, getState());
enterRule(_localctx, 26, RULE_codeDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(327);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__5 || _la==T__6) {
{
setState(326);
accessModifier();
}
}
setState(329);
match(T__17);
setState(330);
identifier();
setState(331);
match(T__10);
setState(332);
codeId();
setState(333);
match(T__18);
setState(334);
codesystemIdentifier();
setState(336);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__153) {
{
setState(335);
displayClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConceptDefinitionContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List codeIdentifier() {
return getRuleContexts(CodeIdentifierContext.class);
}
public CodeIdentifierContext codeIdentifier(int i) {
return getRuleContext(CodeIdentifierContext.class,i);
}
public AccessModifierContext accessModifier() {
return getRuleContext(AccessModifierContext.class,0);
}
public DisplayClauseContext displayClause() {
return getRuleContext(DisplayClauseContext.class,0);
}
public ConceptDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conceptDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterConceptDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitConceptDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitConceptDefinition(this);
else return visitor.visitChildren(this);
}
}
public final ConceptDefinitionContext conceptDefinition() throws RecognitionException {
ConceptDefinitionContext _localctx = new ConceptDefinitionContext(_ctx, getState());
enterRule(_localctx, 28, RULE_conceptDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(339);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__5 || _la==T__6) {
{
setState(338);
accessModifier();
}
}
setState(341);
match(T__19);
setState(342);
identifier();
setState(343);
match(T__10);
setState(344);
match(T__13);
setState(345);
codeIdentifier();
setState(350);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__14) {
{
{
setState(346);
match(T__14);
setState(347);
codeIdentifier();
}
}
setState(352);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(353);
match(T__15);
setState(355);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__153) {
{
setState(354);
displayClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CodeIdentifierContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public LibraryIdentifierContext libraryIdentifier() {
return getRuleContext(LibraryIdentifierContext.class,0);
}
public CodeIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_codeIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterCodeIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitCodeIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitCodeIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final CodeIdentifierContext codeIdentifier() throws RecognitionException {
CodeIdentifierContext _localctx = new CodeIdentifierContext(_ctx, getState());
enterRule(_localctx, 30, RULE_codeIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(360);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
case 1:
{
setState(357);
libraryIdentifier();
setState(358);
match(T__16);
}
break;
}
setState(362);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CodesystemIdContext extends ParserRuleContext {
public TerminalNode STRING() { return getToken(cqlParser.STRING, 0); }
public CodesystemIdContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_codesystemId; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterCodesystemId(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitCodesystemId(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitCodesystemId(this);
else return visitor.visitChildren(this);
}
}
public final CodesystemIdContext codesystemId() throws RecognitionException {
CodesystemIdContext _localctx = new CodesystemIdContext(_ctx, getState());
enterRule(_localctx, 32, RULE_codesystemId);
try {
enterOuterAlt(_localctx, 1);
{
setState(364);
match(STRING);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ValuesetIdContext extends ParserRuleContext {
public TerminalNode STRING() { return getToken(cqlParser.STRING, 0); }
public ValuesetIdContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_valuesetId; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterValuesetId(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitValuesetId(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitValuesetId(this);
else return visitor.visitChildren(this);
}
}
public final ValuesetIdContext valuesetId() throws RecognitionException {
ValuesetIdContext _localctx = new ValuesetIdContext(_ctx, getState());
enterRule(_localctx, 34, RULE_valuesetId);
try {
enterOuterAlt(_localctx, 1);
{
setState(366);
match(STRING);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VersionSpecifierContext extends ParserRuleContext {
public TerminalNode STRING() { return getToken(cqlParser.STRING, 0); }
public VersionSpecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_versionSpecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterVersionSpecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitVersionSpecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitVersionSpecifier(this);
else return visitor.visitChildren(this);
}
}
public final VersionSpecifierContext versionSpecifier() throws RecognitionException {
VersionSpecifierContext _localctx = new VersionSpecifierContext(_ctx, getState());
enterRule(_localctx, 36, RULE_versionSpecifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(368);
match(STRING);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CodeIdContext extends ParserRuleContext {
public TerminalNode STRING() { return getToken(cqlParser.STRING, 0); }
public CodeIdContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_codeId; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterCodeId(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitCodeId(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitCodeId(this);
else return visitor.visitChildren(this);
}
}
public final CodeIdContext codeId() throws RecognitionException {
CodeIdContext _localctx = new CodeIdContext(_ctx, getState());
enterRule(_localctx, 38, RULE_codeId);
try {
enterOuterAlt(_localctx, 1);
{
setState(370);
match(STRING);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TypeSpecifierContext extends ParserRuleContext {
public NamedTypeSpecifierContext namedTypeSpecifier() {
return getRuleContext(NamedTypeSpecifierContext.class,0);
}
public ListTypeSpecifierContext listTypeSpecifier() {
return getRuleContext(ListTypeSpecifierContext.class,0);
}
public IntervalTypeSpecifierContext intervalTypeSpecifier() {
return getRuleContext(IntervalTypeSpecifierContext.class,0);
}
public TupleTypeSpecifierContext tupleTypeSpecifier() {
return getRuleContext(TupleTypeSpecifierContext.class,0);
}
public ChoiceTypeSpecifierContext choiceTypeSpecifier() {
return getRuleContext(ChoiceTypeSpecifierContext.class,0);
}
public TypeSpecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeSpecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterTypeSpecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitTypeSpecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitTypeSpecifier(this);
else return visitor.visitChildren(this);
}
}
public final TypeSpecifierContext typeSpecifier() throws RecognitionException {
TypeSpecifierContext _localctx = new TypeSpecifierContext(_ctx, getState());
enterRule(_localctx, 40, RULE_typeSpecifier);
try {
setState(377);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case T__9:
case T__11:
case T__12:
case T__17:
case T__19:
case T__26:
case T__27:
case T__28:
case T__29:
case T__44:
case T__49:
case T__51:
case T__52:
case T__53:
case T__54:
case T__55:
case T__73:
case T__75:
case T__76:
case T__78:
case T__79:
case T__80:
case T__89:
case T__90:
case T__91:
case T__92:
case T__105:
case T__106:
case T__108:
case T__109:
case T__110:
case T__118:
case T__119:
case T__130:
case T__131:
case T__132:
case T__133:
case T__140:
case T__141:
case T__144:
case T__148:
case T__149:
case T__153:
case T__154:
case T__155:
case QUOTEDIDENTIFIER:
case IDENTIFIER:
case DELIMITEDIDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(372);
namedTypeSpecifier();
}
break;
case T__20:
enterOuterAlt(_localctx, 2);
{
setState(373);
listTypeSpecifier();
}
break;
case T__23:
enterOuterAlt(_localctx, 3);
{
setState(374);
intervalTypeSpecifier();
}
break;
case T__24:
enterOuterAlt(_localctx, 4);
{
setState(375);
tupleTypeSpecifier();
}
break;
case T__25:
enterOuterAlt(_localctx, 5);
{
setState(376);
choiceTypeSpecifier();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NamedTypeSpecifierContext extends ParserRuleContext {
public ReferentialOrTypeNameIdentifierContext referentialOrTypeNameIdentifier() {
return getRuleContext(ReferentialOrTypeNameIdentifierContext.class,0);
}
public List qualifier() {
return getRuleContexts(QualifierContext.class);
}
public QualifierContext qualifier(int i) {
return getRuleContext(QualifierContext.class,i);
}
public NamedTypeSpecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_namedTypeSpecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterNamedTypeSpecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitNamedTypeSpecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitNamedTypeSpecifier(this);
else return visitor.visitChildren(this);
}
}
public final NamedTypeSpecifierContext namedTypeSpecifier() throws RecognitionException {
NamedTypeSpecifierContext _localctx = new NamedTypeSpecifierContext(_ctx, getState());
enterRule(_localctx, 42, RULE_namedTypeSpecifier);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(384);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,26,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(379);
qualifier();
setState(380);
match(T__16);
}
}
}
setState(386);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,26,_ctx);
}
setState(387);
referentialOrTypeNameIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ModelIdentifierContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ModelIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_modelIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterModelIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitModelIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitModelIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final ModelIdentifierContext modelIdentifier() throws RecognitionException {
ModelIdentifierContext _localctx = new ModelIdentifierContext(_ctx, getState());
enterRule(_localctx, 44, RULE_modelIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(389);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ListTypeSpecifierContext extends ParserRuleContext {
public TypeSpecifierContext typeSpecifier() {
return getRuleContext(TypeSpecifierContext.class,0);
}
public ListTypeSpecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_listTypeSpecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterListTypeSpecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitListTypeSpecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitListTypeSpecifier(this);
else return visitor.visitChildren(this);
}
}
public final ListTypeSpecifierContext listTypeSpecifier() throws RecognitionException {
ListTypeSpecifierContext _localctx = new ListTypeSpecifierContext(_ctx, getState());
enterRule(_localctx, 46, RULE_listTypeSpecifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(391);
match(T__20);
setState(392);
match(T__21);
setState(393);
typeSpecifier();
setState(394);
match(T__22);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IntervalTypeSpecifierContext extends ParserRuleContext {
public TypeSpecifierContext typeSpecifier() {
return getRuleContext(TypeSpecifierContext.class,0);
}
public IntervalTypeSpecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_intervalTypeSpecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterIntervalTypeSpecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitIntervalTypeSpecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitIntervalTypeSpecifier(this);
else return visitor.visitChildren(this);
}
}
public final IntervalTypeSpecifierContext intervalTypeSpecifier() throws RecognitionException {
IntervalTypeSpecifierContext _localctx = new IntervalTypeSpecifierContext(_ctx, getState());
enterRule(_localctx, 48, RULE_intervalTypeSpecifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(396);
match(T__23);
setState(397);
match(T__21);
setState(398);
typeSpecifier();
setState(399);
match(T__22);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TupleTypeSpecifierContext extends ParserRuleContext {
public List tupleElementDefinition() {
return getRuleContexts(TupleElementDefinitionContext.class);
}
public TupleElementDefinitionContext tupleElementDefinition(int i) {
return getRuleContext(TupleElementDefinitionContext.class,i);
}
public TupleTypeSpecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tupleTypeSpecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterTupleTypeSpecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitTupleTypeSpecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitTupleTypeSpecifier(this);
else return visitor.visitChildren(this);
}
}
public final TupleTypeSpecifierContext tupleTypeSpecifier() throws RecognitionException {
TupleTypeSpecifierContext _localctx = new TupleTypeSpecifierContext(_ctx, getState());
enterRule(_localctx, 50, RULE_tupleTypeSpecifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(401);
match(T__24);
setState(402);
match(T__13);
setState(403);
tupleElementDefinition();
setState(408);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__14) {
{
{
setState(404);
match(T__14);
setState(405);
tupleElementDefinition();
}
}
setState(410);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(411);
match(T__15);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TupleElementDefinitionContext extends ParserRuleContext {
public ReferentialIdentifierContext referentialIdentifier() {
return getRuleContext(ReferentialIdentifierContext.class,0);
}
public TypeSpecifierContext typeSpecifier() {
return getRuleContext(TypeSpecifierContext.class,0);
}
public TupleElementDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tupleElementDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterTupleElementDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitTupleElementDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitTupleElementDefinition(this);
else return visitor.visitChildren(this);
}
}
public final TupleElementDefinitionContext tupleElementDefinition() throws RecognitionException {
TupleElementDefinitionContext _localctx = new TupleElementDefinitionContext(_ctx, getState());
enterRule(_localctx, 52, RULE_tupleElementDefinition);
try {
enterOuterAlt(_localctx, 1);
{
setState(413);
referentialIdentifier();
setState(414);
typeSpecifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ChoiceTypeSpecifierContext extends ParserRuleContext {
public List typeSpecifier() {
return getRuleContexts(TypeSpecifierContext.class);
}
public TypeSpecifierContext typeSpecifier(int i) {
return getRuleContext(TypeSpecifierContext.class,i);
}
public ChoiceTypeSpecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_choiceTypeSpecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterChoiceTypeSpecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitChoiceTypeSpecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitChoiceTypeSpecifier(this);
else return visitor.visitChildren(this);
}
}
public final ChoiceTypeSpecifierContext choiceTypeSpecifier() throws RecognitionException {
ChoiceTypeSpecifierContext _localctx = new ChoiceTypeSpecifierContext(_ctx, getState());
enterRule(_localctx, 54, RULE_choiceTypeSpecifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(416);
match(T__25);
setState(417);
match(T__21);
setState(418);
typeSpecifier();
setState(423);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__14) {
{
{
setState(419);
match(T__14);
setState(420);
typeSpecifier();
}
}
setState(425);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(426);
match(T__22);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StatementContext extends ParserRuleContext {
public ExpressionDefinitionContext expressionDefinition() {
return getRuleContext(ExpressionDefinitionContext.class,0);
}
public ContextDefinitionContext contextDefinition() {
return getRuleContext(ContextDefinitionContext.class,0);
}
public FunctionDefinitionContext functionDefinition() {
return getRuleContext(FunctionDefinitionContext.class,0);
}
public StatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitStatement(this);
else return visitor.visitChildren(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 56, RULE_statement);
try {
setState(431);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(428);
expressionDefinition();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(429);
contextDefinition();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(430);
functionDefinition();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExpressionDefinitionContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public AccessModifierContext accessModifier() {
return getRuleContext(AccessModifierContext.class,0);
}
public ExpressionDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterExpressionDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitExpressionDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitExpressionDefinition(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionDefinitionContext expressionDefinition() throws RecognitionException {
ExpressionDefinitionContext _localctx = new ExpressionDefinitionContext(_ctx, getState());
enterRule(_localctx, 58, RULE_expressionDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(433);
match(T__26);
setState(435);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__5 || _la==T__6) {
{
setState(434);
accessModifier();
}
}
setState(437);
identifier();
setState(438);
match(T__10);
setState(439);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ContextDefinitionContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ModelIdentifierContext modelIdentifier() {
return getRuleContext(ModelIdentifierContext.class,0);
}
public ContextDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_contextDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterContextDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitContextDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitContextDefinition(this);
else return visitor.visitChildren(this);
}
}
public final ContextDefinitionContext contextDefinition() throws RecognitionException {
ContextDefinitionContext _localctx = new ContextDefinitionContext(_ctx, getState());
enterRule(_localctx, 60, RULE_contextDefinition);
try {
enterOuterAlt(_localctx, 1);
{
setState(441);
match(T__27);
setState(445);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
{
setState(442);
modelIdentifier();
setState(443);
match(T__16);
}
break;
}
setState(447);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FluentModifierContext extends ParserRuleContext {
public FluentModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fluentModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterFluentModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitFluentModifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitFluentModifier(this);
else return visitor.visitChildren(this);
}
}
public final FluentModifierContext fluentModifier() throws RecognitionException {
FluentModifierContext _localctx = new FluentModifierContext(_ctx, getState());
enterRule(_localctx, 62, RULE_fluentModifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(449);
match(T__28);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionDefinitionContext extends ParserRuleContext {
public IdentifierOrFunctionIdentifierContext identifierOrFunctionIdentifier() {
return getRuleContext(IdentifierOrFunctionIdentifierContext.class,0);
}
public FunctionBodyContext functionBody() {
return getRuleContext(FunctionBodyContext.class,0);
}
public AccessModifierContext accessModifier() {
return getRuleContext(AccessModifierContext.class,0);
}
public FluentModifierContext fluentModifier() {
return getRuleContext(FluentModifierContext.class,0);
}
public List operandDefinition() {
return getRuleContexts(OperandDefinitionContext.class);
}
public OperandDefinitionContext operandDefinition(int i) {
return getRuleContext(OperandDefinitionContext.class,i);
}
public TypeSpecifierContext typeSpecifier() {
return getRuleContext(TypeSpecifierContext.class,0);
}
public FunctionDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterFunctionDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitFunctionDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitFunctionDefinition(this);
else return visitor.visitChildren(this);
}
}
public final FunctionDefinitionContext functionDefinition() throws RecognitionException {
FunctionDefinitionContext _localctx = new FunctionDefinitionContext(_ctx, getState());
enterRule(_localctx, 64, RULE_functionDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(451);
match(T__26);
setState(453);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__5 || _la==T__6) {
{
setState(452);
accessModifier();
}
}
setState(456);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__28) {
{
setState(455);
fluentModifier();
}
}
setState(458);
match(T__29);
setState(459);
identifierOrFunctionIdentifier();
setState(460);
match(T__30);
setState(469);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 140772674742007806L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 2161833627658158317L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 12722963L) != 0)) {
{
setState(461);
operandDefinition();
setState(466);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__14) {
{
{
setState(462);
match(T__14);
setState(463);
operandDefinition();
}
}
setState(468);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(471);
match(T__31);
setState(474);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__32) {
{
setState(472);
match(T__32);
setState(473);
typeSpecifier();
}
}
setState(476);
match(T__10);
setState(479);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case T__9:
case T__11:
case T__12:
case T__13:
case T__17:
case T__18:
case T__19:
case T__20:
case T__23:
case T__24:
case T__26:
case T__27:
case T__28:
case T__29:
case T__30:
case T__37:
case T__44:
case T__47:
case T__49:
case T__51:
case T__52:
case T__53:
case T__54:
case T__55:
case T__57:
case T__58:
case T__59:
case T__60:
case T__62:
case T__63:
case T__67:
case T__68:
case T__73:
case T__75:
case T__76:
case T__78:
case T__79:
case T__80:
case T__81:
case T__82:
case T__83:
case T__84:
case T__85:
case T__86:
case T__87:
case T__88:
case T__89:
case T__90:
case T__91:
case T__92:
case T__93:
case T__94:
case T__95:
case T__96:
case T__97:
case T__98:
case T__99:
case T__100:
case T__101:
case T__103:
case T__104:
case T__105:
case T__106:
case T__108:
case T__109:
case T__110:
case T__111:
case T__112:
case T__113:
case T__114:
case T__118:
case T__119:
case T__121:
case T__124:
case T__125:
case T__126:
case T__127:
case T__130:
case T__131:
case T__132:
case T__133:
case T__140:
case T__141:
case T__144:
case T__148:
case T__149:
case T__150:
case T__151:
case T__152:
case T__153:
case T__154:
case T__155:
case T__156:
case QUOTEDIDENTIFIER:
case DATETIME:
case LONGNUMBER:
case DATE:
case TIME:
case IDENTIFIER:
case DELIMITEDIDENTIFIER:
case STRING:
case NUMBER:
{
setState(477);
functionBody();
}
break;
case T__33:
{
setState(478);
match(T__33);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OperandDefinitionContext extends ParserRuleContext {
public ReferentialIdentifierContext referentialIdentifier() {
return getRuleContext(ReferentialIdentifierContext.class,0);
}
public TypeSpecifierContext typeSpecifier() {
return getRuleContext(TypeSpecifierContext.class,0);
}
public OperandDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_operandDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterOperandDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitOperandDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitOperandDefinition(this);
else return visitor.visitChildren(this);
}
}
public final OperandDefinitionContext operandDefinition() throws RecognitionException {
OperandDefinitionContext _localctx = new OperandDefinitionContext(_ctx, getState());
enterRule(_localctx, 66, RULE_operandDefinition);
try {
enterOuterAlt(_localctx, 1);
{
setState(481);
referentialIdentifier();
setState(482);
typeSpecifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionBodyContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public FunctionBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterFunctionBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitFunctionBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitFunctionBody(this);
else return visitor.visitChildren(this);
}
}
public final FunctionBodyContext functionBody() throws RecognitionException {
FunctionBodyContext _localctx = new FunctionBodyContext(_ctx, getState());
enterRule(_localctx, 68, RULE_functionBody);
try {
enterOuterAlt(_localctx, 1);
{
setState(484);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QuerySourceContext extends ParserRuleContext {
public RetrieveContext retrieve() {
return getRuleContext(RetrieveContext.class,0);
}
public QualifiedIdentifierExpressionContext qualifiedIdentifierExpression() {
return getRuleContext(QualifiedIdentifierExpressionContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public QuerySourceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_querySource; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterQuerySource(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitQuerySource(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitQuerySource(this);
else return visitor.visitChildren(this);
}
}
public final QuerySourceContext querySource() throws RecognitionException {
QuerySourceContext _localctx = new QuerySourceContext(_ctx, getState());
enterRule(_localctx, 70, RULE_querySource);
try {
setState(492);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__37:
enterOuterAlt(_localctx, 1);
{
setState(486);
retrieve();
}
break;
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case T__9:
case T__11:
case T__12:
case T__17:
case T__19:
case T__26:
case T__27:
case T__28:
case T__29:
case T__44:
case T__49:
case T__51:
case T__52:
case T__53:
case T__54:
case T__55:
case T__73:
case T__75:
case T__76:
case T__78:
case T__79:
case T__80:
case T__89:
case T__90:
case T__91:
case T__92:
case T__105:
case T__106:
case T__108:
case T__109:
case T__110:
case T__118:
case T__119:
case T__130:
case T__131:
case T__132:
case T__133:
case T__140:
case T__141:
case T__144:
case T__148:
case T__149:
case T__153:
case QUOTEDIDENTIFIER:
case IDENTIFIER:
case DELIMITEDIDENTIFIER:
enterOuterAlt(_localctx, 2);
{
setState(487);
qualifiedIdentifierExpression();
}
break;
case T__30:
enterOuterAlt(_localctx, 3);
{
setState(488);
match(T__30);
setState(489);
expression(0);
setState(490);
match(T__31);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AliasedQuerySourceContext extends ParserRuleContext {
public QuerySourceContext querySource() {
return getRuleContext(QuerySourceContext.class,0);
}
public AliasContext alias() {
return getRuleContext(AliasContext.class,0);
}
public AliasedQuerySourceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_aliasedQuerySource; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterAliasedQuerySource(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitAliasedQuerySource(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitAliasedQuerySource(this);
else return visitor.visitChildren(this);
}
}
public final AliasedQuerySourceContext aliasedQuerySource() throws RecognitionException {
AliasedQuerySourceContext _localctx = new AliasedQuerySourceContext(_ctx, getState());
enterRule(_localctx, 72, RULE_aliasedQuerySource);
try {
enterOuterAlt(_localctx, 1);
{
setState(494);
querySource();
setState(495);
alias();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AliasContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public AliasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_alias; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitAlias(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitAlias(this);
else return visitor.visitChildren(this);
}
}
public final AliasContext alias() throws RecognitionException {
AliasContext _localctx = new AliasContext(_ctx, getState());
enterRule(_localctx, 74, RULE_alias);
try {
enterOuterAlt(_localctx, 1);
{
setState(497);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QueryInclusionClauseContext extends ParserRuleContext {
public WithClauseContext withClause() {
return getRuleContext(WithClauseContext.class,0);
}
public WithoutClauseContext withoutClause() {
return getRuleContext(WithoutClauseContext.class,0);
}
public QueryInclusionClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_queryInclusionClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterQueryInclusionClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitQueryInclusionClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitQueryInclusionClause(this);
else return visitor.visitChildren(this);
}
}
public final QueryInclusionClauseContext queryInclusionClause() throws RecognitionException {
QueryInclusionClauseContext _localctx = new QueryInclusionClauseContext(_ctx, getState());
enterRule(_localctx, 76, RULE_queryInclusionClause);
try {
setState(501);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__34:
enterOuterAlt(_localctx, 1);
{
setState(499);
withClause();
}
break;
case T__36:
enterOuterAlt(_localctx, 2);
{
setState(500);
withoutClause();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WithClauseContext extends ParserRuleContext {
public AliasedQuerySourceContext aliasedQuerySource() {
return getRuleContext(AliasedQuerySourceContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public WithClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_withClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterWithClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitWithClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitWithClause(this);
else return visitor.visitChildren(this);
}
}
public final WithClauseContext withClause() throws RecognitionException {
WithClauseContext _localctx = new WithClauseContext(_ctx, getState());
enterRule(_localctx, 78, RULE_withClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(503);
match(T__34);
setState(504);
aliasedQuerySource();
setState(505);
match(T__35);
setState(506);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WithoutClauseContext extends ParserRuleContext {
public AliasedQuerySourceContext aliasedQuerySource() {
return getRuleContext(AliasedQuerySourceContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public WithoutClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_withoutClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterWithoutClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitWithoutClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitWithoutClause(this);
else return visitor.visitChildren(this);
}
}
public final WithoutClauseContext withoutClause() throws RecognitionException {
WithoutClauseContext _localctx = new WithoutClauseContext(_ctx, getState());
enterRule(_localctx, 80, RULE_withoutClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(508);
match(T__36);
setState(509);
aliasedQuerySource();
setState(510);
match(T__35);
setState(511);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RetrieveContext extends ParserRuleContext {
public NamedTypeSpecifierContext namedTypeSpecifier() {
return getRuleContext(NamedTypeSpecifierContext.class,0);
}
public ContextIdentifierContext contextIdentifier() {
return getRuleContext(ContextIdentifierContext.class,0);
}
public TerminologyContext terminology() {
return getRuleContext(TerminologyContext.class,0);
}
public CodePathContext codePath() {
return getRuleContext(CodePathContext.class,0);
}
public CodeComparatorContext codeComparator() {
return getRuleContext(CodeComparatorContext.class,0);
}
public RetrieveContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_retrieve; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterRetrieve(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitRetrieve(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitRetrieve(this);
else return visitor.visitChildren(this);
}
}
public final RetrieveContext retrieve() throws RecognitionException {
RetrieveContext _localctx = new RetrieveContext(_ctx, getState());
enterRule(_localctx, 82, RULE_retrieve);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(513);
match(T__37);
setState(517);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
case 1:
{
setState(514);
contextIdentifier();
setState(515);
match(T__38);
}
break;
}
setState(519);
namedTypeSpecifier();
setState(527);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__10) {
{
setState(520);
match(T__10);
setState(524);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
case 1:
{
setState(521);
codePath();
setState(522);
codeComparator();
}
break;
}
setState(526);
terminology();
}
}
setState(529);
match(T__39);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ContextIdentifierContext extends ParserRuleContext {
public QualifiedIdentifierExpressionContext qualifiedIdentifierExpression() {
return getRuleContext(QualifiedIdentifierExpressionContext.class,0);
}
public ContextIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_contextIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterContextIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitContextIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitContextIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final ContextIdentifierContext contextIdentifier() throws RecognitionException {
ContextIdentifierContext _localctx = new ContextIdentifierContext(_ctx, getState());
enterRule(_localctx, 84, RULE_contextIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(531);
qualifiedIdentifierExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CodePathContext extends ParserRuleContext {
public SimplePathContext simplePath() {
return getRuleContext(SimplePathContext.class,0);
}
public CodePathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_codePath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterCodePath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitCodePath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitCodePath(this);
else return visitor.visitChildren(this);
}
}
public final CodePathContext codePath() throws RecognitionException {
CodePathContext _localctx = new CodePathContext(_ctx, getState());
enterRule(_localctx, 86, RULE_codePath);
try {
enterOuterAlt(_localctx, 1);
{
setState(533);
simplePath(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CodeComparatorContext extends ParserRuleContext {
public CodeComparatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_codeComparator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterCodeComparator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitCodeComparator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitCodeComparator(this);
else return visitor.visitChildren(this);
}
}
public final CodeComparatorContext codeComparator() throws RecognitionException {
CodeComparatorContext _localctx = new CodeComparatorContext(_ctx, getState());
enterRule(_localctx, 88, RULE_codeComparator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(535);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 15393162788864L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TerminologyContext extends ParserRuleContext {
public QualifiedIdentifierExpressionContext qualifiedIdentifierExpression() {
return getRuleContext(QualifiedIdentifierExpressionContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminologyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_terminology; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterTerminology(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitTerminology(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitTerminology(this);
else return visitor.visitChildren(this);
}
}
public final TerminologyContext terminology() throws RecognitionException {
TerminologyContext _localctx = new TerminologyContext(_ctx, getState());
enterRule(_localctx, 90, RULE_terminology);
try {
setState(539);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(537);
qualifiedIdentifierExpression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(538);
expression(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QualifierContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public QualifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterQualifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitQualifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitQualifier(this);
else return visitor.visitChildren(this);
}
}
public final QualifierContext qualifier() throws RecognitionException {
QualifierContext _localctx = new QualifierContext(_ctx, getState());
enterRule(_localctx, 92, RULE_qualifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(541);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QueryContext extends ParserRuleContext {
public SourceClauseContext sourceClause() {
return getRuleContext(SourceClauseContext.class,0);
}
public LetClauseContext letClause() {
return getRuleContext(LetClauseContext.class,0);
}
public List queryInclusionClause() {
return getRuleContexts(QueryInclusionClauseContext.class);
}
public QueryInclusionClauseContext queryInclusionClause(int i) {
return getRuleContext(QueryInclusionClauseContext.class,i);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public AggregateClauseContext aggregateClause() {
return getRuleContext(AggregateClauseContext.class,0);
}
public ReturnClauseContext returnClause() {
return getRuleContext(ReturnClauseContext.class,0);
}
public SortClauseContext sortClause() {
return getRuleContext(SortClauseContext.class,0);
}
public QueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_query; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitQuery(this);
else return visitor.visitChildren(this);
}
}
public final QueryContext query() throws RecognitionException {
QueryContext _localctx = new QueryContext(_ctx, getState());
enterRule(_localctx, 94, RULE_query);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(543);
sourceClause();
setState(545);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
{
setState(544);
letClause();
}
break;
}
setState(550);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,45,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(547);
queryInclusionClause();
}
}
}
setState(552);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,45,_ctx);
}
setState(554);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
case 1:
{
setState(553);
whereClause();
}
break;
}
setState(558);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) {
case 1:
{
setState(556);
aggregateClause();
}
break;
case 2:
{
setState(557);
returnClause();
}
break;
}
setState(561);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
case 1:
{
setState(560);
sortClause();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SourceClauseContext extends ParserRuleContext {
public List aliasedQuerySource() {
return getRuleContexts(AliasedQuerySourceContext.class);
}
public AliasedQuerySourceContext aliasedQuerySource(int i) {
return getRuleContext(AliasedQuerySourceContext.class,i);
}
public SourceClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sourceClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterSourceClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitSourceClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitSourceClause(this);
else return visitor.visitChildren(this);
}
}
public final SourceClauseContext sourceClause() throws RecognitionException {
SourceClauseContext _localctx = new SourceClauseContext(_ctx, getState());
enterRule(_localctx, 96, RULE_sourceClause);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(564);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__18) {
{
setState(563);
match(T__18);
}
}
setState(566);
aliasedQuerySource();
setState(571);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,50,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(567);
match(T__14);
setState(568);
aliasedQuerySource();
}
}
}
setState(573);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,50,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LetClauseContext extends ParserRuleContext {
public List letClauseItem() {
return getRuleContexts(LetClauseItemContext.class);
}
public LetClauseItemContext letClauseItem(int i) {
return getRuleContext(LetClauseItemContext.class,i);
}
public LetClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_letClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterLetClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitLetClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitLetClause(this);
else return visitor.visitChildren(this);
}
}
public final LetClauseContext letClause() throws RecognitionException {
LetClauseContext _localctx = new LetClauseContext(_ctx, getState());
enterRule(_localctx, 98, RULE_letClause);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(574);
match(T__43);
setState(575);
letClauseItem();
setState(580);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,51,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(576);
match(T__14);
setState(577);
letClauseItem();
}
}
}
setState(582);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,51,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LetClauseItemContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public LetClauseItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_letClauseItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterLetClauseItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitLetClauseItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitLetClauseItem(this);
else return visitor.visitChildren(this);
}
}
public final LetClauseItemContext letClauseItem() throws RecognitionException {
LetClauseItemContext _localctx = new LetClauseItemContext(_ctx, getState());
enterRule(_localctx, 100, RULE_letClauseItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(583);
identifier();
setState(584);
match(T__10);
setState(585);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WhereClauseContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public WhereClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whereClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterWhereClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitWhereClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitWhereClause(this);
else return visitor.visitChildren(this);
}
}
public final WhereClauseContext whereClause() throws RecognitionException {
WhereClauseContext _localctx = new WhereClauseContext(_ctx, getState());
enterRule(_localctx, 102, RULE_whereClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(587);
match(T__44);
setState(588);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ReturnClauseContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ReturnClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_returnClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterReturnClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitReturnClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitReturnClause(this);
else return visitor.visitChildren(this);
}
}
public final ReturnClauseContext returnClause() throws RecognitionException {
ReturnClauseContext _localctx = new ReturnClauseContext(_ctx, getState());
enterRule(_localctx, 104, RULE_returnClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(590);
match(T__45);
setState(592);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) {
case 1:
{
setState(591);
_la = _input.LA(1);
if ( !(_la==T__46 || _la==T__47) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(594);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AggregateClauseContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public StartingClauseContext startingClause() {
return getRuleContext(StartingClauseContext.class,0);
}
public AggregateClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_aggregateClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterAggregateClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitAggregateClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitAggregateClause(this);
else return visitor.visitChildren(this);
}
}
public final AggregateClauseContext aggregateClause() throws RecognitionException {
AggregateClauseContext _localctx = new AggregateClauseContext(_ctx, getState());
enterRule(_localctx, 106, RULE_aggregateClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(596);
match(T__48);
setState(598);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__46 || _la==T__47) {
{
setState(597);
_la = _input.LA(1);
if ( !(_la==T__46 || _la==T__47) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(600);
identifier();
setState(602);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__49) {
{
setState(601);
startingClause();
}
}
setState(604);
match(T__10);
setState(605);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StartingClauseContext extends ParserRuleContext {
public SimpleLiteralContext simpleLiteral() {
return getRuleContext(SimpleLiteralContext.class,0);
}
public QuantityContext quantity() {
return getRuleContext(QuantityContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public StartingClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_startingClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterStartingClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitStartingClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitStartingClause(this);
else return visitor.visitChildren(this);
}
}
public final StartingClauseContext startingClause() throws RecognitionException {
StartingClauseContext _localctx = new StartingClauseContext(_ctx, getState());
enterRule(_localctx, 108, RULE_startingClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(607);
match(T__49);
setState(614);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
case 1:
{
setState(608);
simpleLiteral();
}
break;
case 2:
{
setState(609);
quantity();
}
break;
case 3:
{
{
setState(610);
match(T__30);
setState(611);
expression(0);
setState(612);
match(T__31);
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SortClauseContext extends ParserRuleContext {
public SortDirectionContext sortDirection() {
return getRuleContext(SortDirectionContext.class,0);
}
public List sortByItem() {
return getRuleContexts(SortByItemContext.class);
}
public SortByItemContext sortByItem(int i) {
return getRuleContext(SortByItemContext.class,i);
}
public SortClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sortClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterSortClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitSortClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitSortClause(this);
else return visitor.visitChildren(this);
}
}
public final SortClauseContext sortClause() throws RecognitionException {
SortClauseContext _localctx = new SortClauseContext(_ctx, getState());
enterRule(_localctx, 110, RULE_sortClause);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(616);
match(T__50);
setState(627);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__52:
case T__53:
case T__54:
case T__55:
{
setState(617);
sortDirection();
}
break;
case T__51:
{
{
setState(618);
match(T__51);
setState(619);
sortByItem();
setState(624);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,56,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(620);
match(T__14);
setState(621);
sortByItem();
}
}
}
setState(626);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,56,_ctx);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SortDirectionContext extends ParserRuleContext {
public SortDirectionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sortDirection; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterSortDirection(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitSortDirection(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitSortDirection(this);
else return visitor.visitChildren(this);
}
}
public final SortDirectionContext sortDirection() throws RecognitionException {
SortDirectionContext _localctx = new SortDirectionContext(_ctx, getState());
enterRule(_localctx, 112, RULE_sortDirection);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(629);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 135107988821114880L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SortByItemContext extends ParserRuleContext {
public ExpressionTermContext expressionTerm() {
return getRuleContext(ExpressionTermContext.class,0);
}
public SortDirectionContext sortDirection() {
return getRuleContext(SortDirectionContext.class,0);
}
public SortByItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sortByItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterSortByItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitSortByItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitSortByItem(this);
else return visitor.visitChildren(this);
}
}
public final SortByItemContext sortByItem() throws RecognitionException {
SortByItemContext _localctx = new SortByItemContext(_ctx, getState());
enterRule(_localctx, 114, RULE_sortByItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(631);
expressionTerm(0);
setState(633);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) {
case 1:
{
setState(632);
sortDirection();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QualifiedIdentifierContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List qualifier() {
return getRuleContexts(QualifierContext.class);
}
public QualifierContext qualifier(int i) {
return getRuleContext(QualifierContext.class,i);
}
public QualifiedIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterQualifiedIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitQualifiedIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitQualifiedIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final QualifiedIdentifierContext qualifiedIdentifier() throws RecognitionException {
QualifiedIdentifierContext _localctx = new QualifiedIdentifierContext(_ctx, getState());
enterRule(_localctx, 116, RULE_qualifiedIdentifier);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(640);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,59,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(635);
qualifier();
setState(636);
match(T__16);
}
}
}
setState(642);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,59,_ctx);
}
setState(643);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QualifiedIdentifierExpressionContext extends ParserRuleContext {
public ReferentialIdentifierContext referentialIdentifier() {
return getRuleContext(ReferentialIdentifierContext.class,0);
}
public List qualifierExpression() {
return getRuleContexts(QualifierExpressionContext.class);
}
public QualifierExpressionContext qualifierExpression(int i) {
return getRuleContext(QualifierExpressionContext.class,i);
}
public QualifiedIdentifierExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedIdentifierExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterQualifiedIdentifierExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitQualifiedIdentifierExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitQualifiedIdentifierExpression(this);
else return visitor.visitChildren(this);
}
}
public final QualifiedIdentifierExpressionContext qualifiedIdentifierExpression() throws RecognitionException {
QualifiedIdentifierExpressionContext _localctx = new QualifiedIdentifierExpressionContext(_ctx, getState());
enterRule(_localctx, 118, RULE_qualifiedIdentifierExpression);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(650);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,60,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(645);
qualifierExpression();
setState(646);
match(T__16);
}
}
}
setState(652);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,60,_ctx);
}
setState(653);
referentialIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QualifierExpressionContext extends ParserRuleContext {
public ReferentialIdentifierContext referentialIdentifier() {
return getRuleContext(ReferentialIdentifierContext.class,0);
}
public QualifierExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifierExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterQualifierExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitQualifierExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitQualifierExpression(this);
else return visitor.visitChildren(this);
}
}
public final QualifierExpressionContext qualifierExpression() throws RecognitionException {
QualifierExpressionContext _localctx = new QualifierExpressionContext(_ctx, getState());
enterRule(_localctx, 120, RULE_qualifierExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(655);
referentialIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SimplePathContext extends ParserRuleContext {
public SimplePathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simplePath; }
public SimplePathContext() { }
public void copyFrom(SimplePathContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SimplePathIndexerContext extends SimplePathContext {
public SimplePathContext simplePath() {
return getRuleContext(SimplePathContext.class,0);
}
public SimpleLiteralContext simpleLiteral() {
return getRuleContext(SimpleLiteralContext.class,0);
}
public SimplePathIndexerContext(SimplePathContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterSimplePathIndexer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitSimplePathIndexer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitSimplePathIndexer(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SimplePathQualifiedIdentifierContext extends SimplePathContext {
public SimplePathContext simplePath() {
return getRuleContext(SimplePathContext.class,0);
}
public ReferentialIdentifierContext referentialIdentifier() {
return getRuleContext(ReferentialIdentifierContext.class,0);
}
public SimplePathQualifiedIdentifierContext(SimplePathContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterSimplePathQualifiedIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitSimplePathQualifiedIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitSimplePathQualifiedIdentifier(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SimplePathReferentialIdentifierContext extends SimplePathContext {
public ReferentialIdentifierContext referentialIdentifier() {
return getRuleContext(ReferentialIdentifierContext.class,0);
}
public SimplePathReferentialIdentifierContext(SimplePathContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterSimplePathReferentialIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitSimplePathReferentialIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitSimplePathReferentialIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final SimplePathContext simplePath() throws RecognitionException {
return simplePath(0);
}
private SimplePathContext simplePath(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
SimplePathContext _localctx = new SimplePathContext(_ctx, _parentState);
SimplePathContext _prevctx = _localctx;
int _startState = 122;
enterRecursionRule(_localctx, 122, RULE_simplePath, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
_localctx = new SimplePathReferentialIdentifierContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(658);
referentialIdentifier();
}
_ctx.stop = _input.LT(-1);
setState(670);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,62,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(668);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) {
case 1:
{
_localctx = new SimplePathQualifiedIdentifierContext(new SimplePathContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_simplePath);
setState(660);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(661);
match(T__16);
setState(662);
referentialIdentifier();
}
break;
case 2:
{
_localctx = new SimplePathIndexerContext(new SimplePathContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_simplePath);
setState(663);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(664);
match(T__37);
setState(665);
simpleLiteral();
setState(666);
match(T__39);
}
break;
}
}
}
setState(672);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,62,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SimpleLiteralContext extends ParserRuleContext {
public SimpleLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleLiteral; }
public SimpleLiteralContext() { }
public void copyFrom(SimpleLiteralContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SimpleNumberLiteralContext extends SimpleLiteralContext {
public TerminalNode NUMBER() { return getToken(cqlParser.NUMBER, 0); }
public SimpleNumberLiteralContext(SimpleLiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterSimpleNumberLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitSimpleNumberLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitSimpleNumberLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SimpleStringLiteralContext extends SimpleLiteralContext {
public TerminalNode STRING() { return getToken(cqlParser.STRING, 0); }
public SimpleStringLiteralContext(SimpleLiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterSimpleStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitSimpleStringLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitSimpleStringLiteral(this);
else return visitor.visitChildren(this);
}
}
public final SimpleLiteralContext simpleLiteral() throws RecognitionException {
SimpleLiteralContext _localctx = new SimpleLiteralContext(_ctx, getState());
enterRule(_localctx, 124, RULE_simpleLiteral);
try {
setState(675);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
_localctx = new SimpleStringLiteralContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(673);
match(STRING);
}
break;
case NUMBER:
_localctx = new SimpleNumberLiteralContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(674);
match(NUMBER);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExpressionContext extends ParserRuleContext {
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
public ExpressionContext() { }
public void copyFrom(ExpressionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DurationBetweenExpressionContext extends ExpressionContext {
public PluralDateTimePrecisionContext pluralDateTimePrecision() {
return getRuleContext(PluralDateTimePrecisionContext.class,0);
}
public List expressionTerm() {
return getRuleContexts(ExpressionTermContext.class);
}
public ExpressionTermContext expressionTerm(int i) {
return getRuleContext(ExpressionTermContext.class,i);
}
public DurationBetweenExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterDurationBetweenExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitDurationBetweenExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitDurationBetweenExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class InFixSetExpressionContext extends ExpressionContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public InFixSetExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterInFixSetExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitInFixSetExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitInFixSetExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RetrieveExpressionContext extends ExpressionContext {
public RetrieveContext retrieve() {
return getRuleContext(RetrieveContext.class,0);
}
public RetrieveExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterRetrieveExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitRetrieveExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitRetrieveExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TimingExpressionContext extends ExpressionContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public IntervalOperatorPhraseContext intervalOperatorPhrase() {
return getRuleContext(IntervalOperatorPhraseContext.class,0);
}
public TimingExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterTimingExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitTimingExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitTimingExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class QueryExpressionContext extends ExpressionContext {
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public QueryExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterQueryExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitQueryExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitQueryExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NotExpressionContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public NotExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterNotExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitNotExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitNotExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BooleanExpressionContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public BooleanExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterBooleanExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitBooleanExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitBooleanExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class OrExpressionContext extends ExpressionContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public OrExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterOrExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitOrExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitOrExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CastExpressionContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TypeSpecifierContext typeSpecifier() {
return getRuleContext(TypeSpecifierContext.class,0);
}
public CastExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterCastExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitCastExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitCastExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AndExpressionContext extends ExpressionContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public AndExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterAndExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitAndExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitAndExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BetweenExpressionContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List expressionTerm() {
return getRuleContexts(ExpressionTermContext.class);
}
public ExpressionTermContext expressionTerm(int i) {
return getRuleContext(ExpressionTermContext.class,i);
}
public BetweenExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterBetweenExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitBetweenExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitBetweenExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class MembershipExpressionContext extends ExpressionContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public DateTimePrecisionSpecifierContext dateTimePrecisionSpecifier() {
return getRuleContext(DateTimePrecisionSpecifierContext.class,0);
}
public MembershipExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterMembershipExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitMembershipExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitMembershipExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DifferenceBetweenExpressionContext extends ExpressionContext {
public PluralDateTimePrecisionContext pluralDateTimePrecision() {
return getRuleContext(PluralDateTimePrecisionContext.class,0);
}
public List expressionTerm() {
return getRuleContexts(ExpressionTermContext.class);
}
public ExpressionTermContext expressionTerm(int i) {
return getRuleContext(ExpressionTermContext.class,i);
}
public DifferenceBetweenExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterDifferenceBetweenExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitDifferenceBetweenExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitDifferenceBetweenExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class InequalityExpressionContext extends ExpressionContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public InequalityExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterInequalityExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitInequalityExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitInequalityExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class EqualityExpressionContext extends ExpressionContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public EqualityExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterEqualityExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitEqualityExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitEqualityExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ExistenceExpressionContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ExistenceExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterExistenceExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitExistenceExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitExistenceExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ImpliesExpressionContext extends ExpressionContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ImpliesExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterImpliesExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitImpliesExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitImpliesExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TermExpressionContext extends ExpressionContext {
public ExpressionTermContext expressionTerm() {
return getRuleContext(ExpressionTermContext.class,0);
}
public TermExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterTermExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitTermExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitTermExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TypeExpressionContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TypeSpecifierContext typeSpecifier() {
return getRuleContext(TypeSpecifierContext.class,0);
}
public TypeExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterTypeExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitTypeExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitTypeExpression(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
return expression(0);
}
private ExpressionContext expression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
ExpressionContext _prevctx = _localctx;
int _startState = 126;
enterRecursionRule(_localctx, 126, RULE_expression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(708);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
case 1:
{
_localctx = new TermExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(678);
expressionTerm(0);
}
break;
case 2:
{
_localctx = new RetrieveExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(679);
retrieve();
}
break;
case 3:
{
_localctx = new QueryExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(680);
query();
}
break;
case 4:
{
_localctx = new CastExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(681);
match(T__62);
setState(682);
expression(0);
setState(683);
match(T__61);
setState(684);
typeSpecifier();
}
break;
case 5:
{
_localctx = new NotExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(686);
match(T__57);
setState(687);
expression(13);
}
break;
case 6:
{
_localctx = new ExistenceExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(688);
match(T__63);
setState(689);
expression(12);
}
break;
case 7:
{
_localctx = new DurationBetweenExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(692);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__67) {
{
setState(690);
match(T__67);
setState(691);
match(T__40);
}
}
setState(694);
pluralDateTimePrecision();
setState(695);
match(T__65);
setState(696);
expressionTerm(0);
setState(697);
match(T__66);
setState(698);
expressionTerm(0);
}
break;
case 8:
{
_localctx = new DifferenceBetweenExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(700);
match(T__68);
setState(701);
match(T__40);
setState(702);
pluralDateTimePrecision();
setState(703);
match(T__65);
setState(704);
expressionTerm(0);
setState(705);
match(T__66);
setState(706);
expressionTerm(0);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(758);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,70,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(756);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) {
case 1:
{
_localctx = new InequalityExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(710);
if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
setState(711);
_la = _input.LA(1);
if ( !(((((_la - 22)) & ~0x3f) == 0 && ((1L << (_la - 22)) & 844424930131971L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(712);
expression(9);
}
break;
case 2:
{
_localctx = new TimingExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(713);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
setState(714);
intervalOperatorPhrase();
setState(715);
expression(8);
}
break;
case 3:
{
_localctx = new EqualityExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(717);
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(718);
_la = _input.LA(1);
if ( !(((((_la - 42)) & ~0x3f) == 0 && ((1L << (_la - 42)) & 3221225475L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(719);
expression(7);
}
break;
case 4:
{
_localctx = new MembershipExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(720);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(721);
_la = _input.LA(1);
if ( !(_la==T__40 || _la==T__73) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(723);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) {
case 1:
{
setState(722);
dateTimePrecisionSpecifier();
}
break;
}
setState(725);
expression(6);
}
break;
case 5:
{
_localctx = new AndExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(726);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(727);
match(T__66);
setState(728);
expression(5);
}
break;
case 6:
{
_localctx = new OrExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(729);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(730);
_la = _input.LA(1);
if ( !(_la==T__74 || _la==T__75) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(731);
expression(4);
}
break;
case 7:
{
_localctx = new ImpliesExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(732);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(733);
match(T__76);
setState(734);
expression(3);
}
break;
case 8:
{
_localctx = new InFixSetExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(735);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(736);
_la = _input.LA(1);
if ( !(((((_la - 78)) & ~0x3f) == 0 && ((1L << (_la - 78)) & 15L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(737);
expression(2);
}
break;
case 9:
{
_localctx = new BooleanExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(738);
if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
setState(739);
match(T__56);
setState(741);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__57) {
{
setState(740);
match(T__57);
}
}
setState(743);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 4035225266123964416L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 10:
{
_localctx = new TypeExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(744);
if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
setState(745);
_la = _input.LA(1);
if ( !(_la==T__56 || _la==T__61) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(746);
typeSpecifier();
}
break;
case 11:
{
_localctx = new BetweenExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(747);
if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
setState(749);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__64) {
{
setState(748);
match(T__64);
}
}
setState(751);
match(T__65);
setState(752);
expressionTerm(0);
setState(753);
match(T__66);
setState(754);
expressionTerm(0);
}
break;
}
}
}
setState(760);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,70,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DateTimePrecisionContext extends ParserRuleContext {
public DateTimePrecisionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dateTimePrecision; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterDateTimePrecision(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitDateTimePrecision(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitDateTimePrecision(this);
else return visitor.visitChildren(this);
}
}
public final DateTimePrecisionContext dateTimePrecision() throws RecognitionException {
DateTimePrecisionContext _localctx = new DateTimePrecisionContext(_ctx, getState());
enterRule(_localctx, 128, RULE_dateTimePrecision);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(761);
_la = _input.LA(1);
if ( !(((((_la - 82)) & ~0x3f) == 0 && ((1L << (_la - 82)) & 255L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DateTimeComponentContext extends ParserRuleContext {
public DateTimePrecisionContext dateTimePrecision() {
return getRuleContext(DateTimePrecisionContext.class,0);
}
public DateTimeComponentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dateTimeComponent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterDateTimeComponent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitDateTimeComponent(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitDateTimeComponent(this);
else return visitor.visitChildren(this);
}
}
public final DateTimeComponentContext dateTimeComponent() throws RecognitionException {
DateTimeComponentContext _localctx = new DateTimeComponentContext(_ctx, getState());
enterRule(_localctx, 130, RULE_dateTimeComponent);
try {
setState(768);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__81:
case T__82:
case T__83:
case T__84:
case T__85:
case T__86:
case T__87:
case T__88:
enterOuterAlt(_localctx, 1);
{
setState(763);
dateTimePrecision();
}
break;
case T__89:
enterOuterAlt(_localctx, 2);
{
setState(764);
match(T__89);
}
break;
case T__90:
enterOuterAlt(_localctx, 3);
{
setState(765);
match(T__90);
}
break;
case T__91:
enterOuterAlt(_localctx, 4);
{
setState(766);
match(T__91);
}
break;
case T__92:
enterOuterAlt(_localctx, 5);
{
setState(767);
match(T__92);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PluralDateTimePrecisionContext extends ParserRuleContext {
public PluralDateTimePrecisionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pluralDateTimePrecision; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterPluralDateTimePrecision(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitPluralDateTimePrecision(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitPluralDateTimePrecision(this);
else return visitor.visitChildren(this);
}
}
public final PluralDateTimePrecisionContext pluralDateTimePrecision() throws RecognitionException {
PluralDateTimePrecisionContext _localctx = new PluralDateTimePrecisionContext(_ctx, getState());
enterRule(_localctx, 132, RULE_pluralDateTimePrecision);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(770);
_la = _input.LA(1);
if ( !(((((_la - 94)) & ~0x3f) == 0 && ((1L << (_la - 94)) & 255L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExpressionTermContext extends ParserRuleContext {
public ExpressionTermContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionTerm; }
public ExpressionTermContext() { }
public void copyFrom(ExpressionTermContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AdditionExpressionTermContext extends ExpressionTermContext {
public List expressionTerm() {
return getRuleContexts(ExpressionTermContext.class);
}
public ExpressionTermContext expressionTerm(int i) {
return getRuleContext(ExpressionTermContext.class,i);
}
public AdditionExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterAdditionExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitAdditionExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitAdditionExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IndexedExpressionTermContext extends ExpressionTermContext {
public ExpressionTermContext expressionTerm() {
return getRuleContext(ExpressionTermContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public IndexedExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterIndexedExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitIndexedExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitIndexedExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class WidthExpressionTermContext extends ExpressionTermContext {
public ExpressionTermContext expressionTerm() {
return getRuleContext(ExpressionTermContext.class,0);
}
public WidthExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterWidthExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitWidthExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitWidthExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SetAggregateExpressionTermContext extends ExpressionTermContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public DateTimePrecisionContext dateTimePrecision() {
return getRuleContext(DateTimePrecisionContext.class,0);
}
public SetAggregateExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterSetAggregateExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitSetAggregateExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitSetAggregateExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TimeUnitExpressionTermContext extends ExpressionTermContext {
public DateTimeComponentContext dateTimeComponent() {
return getRuleContext(DateTimeComponentContext.class,0);
}
public ExpressionTermContext expressionTerm() {
return getRuleContext(ExpressionTermContext.class,0);
}
public TimeUnitExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterTimeUnitExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitTimeUnitExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitTimeUnitExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IfThenElseExpressionTermContext extends ExpressionTermContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public IfThenElseExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterIfThenElseExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitIfThenElseExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitIfThenElseExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TimeBoundaryExpressionTermContext extends ExpressionTermContext {
public ExpressionTermContext expressionTerm() {
return getRuleContext(ExpressionTermContext.class,0);
}
public TimeBoundaryExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterTimeBoundaryExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitTimeBoundaryExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitTimeBoundaryExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ElementExtractorExpressionTermContext extends ExpressionTermContext {
public ExpressionTermContext expressionTerm() {
return getRuleContext(ExpressionTermContext.class,0);
}
public ElementExtractorExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterElementExtractorExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitElementExtractorExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitElementExtractorExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConversionExpressionTermContext extends ExpressionTermContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TypeSpecifierContext typeSpecifier() {
return getRuleContext(TypeSpecifierContext.class,0);
}
public UnitContext unit() {
return getRuleContext(UnitContext.class,0);
}
public ConversionExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterConversionExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitConversionExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitConversionExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TypeExtentExpressionTermContext extends ExpressionTermContext {
public NamedTypeSpecifierContext namedTypeSpecifier() {
return getRuleContext(NamedTypeSpecifierContext.class,0);
}
public TypeExtentExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterTypeExtentExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitTypeExtentExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitTypeExtentExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PredecessorExpressionTermContext extends ExpressionTermContext {
public ExpressionTermContext expressionTerm() {
return getRuleContext(ExpressionTermContext.class,0);
}
public PredecessorExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterPredecessorExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitPredecessorExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitPredecessorExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PointExtractorExpressionTermContext extends ExpressionTermContext {
public ExpressionTermContext expressionTerm() {
return getRuleContext(ExpressionTermContext.class,0);
}
public PointExtractorExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterPointExtractorExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitPointExtractorExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitPointExtractorExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class MultiplicationExpressionTermContext extends ExpressionTermContext {
public List expressionTerm() {
return getRuleContexts(ExpressionTermContext.class);
}
public ExpressionTermContext expressionTerm(int i) {
return getRuleContext(ExpressionTermContext.class,i);
}
public MultiplicationExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterMultiplicationExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitMultiplicationExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitMultiplicationExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AggregateExpressionTermContext extends ExpressionTermContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public AggregateExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterAggregateExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitAggregateExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitAggregateExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DurationExpressionTermContext extends ExpressionTermContext {
public PluralDateTimePrecisionContext pluralDateTimePrecision() {
return getRuleContext(PluralDateTimePrecisionContext.class,0);
}
public ExpressionTermContext expressionTerm() {
return getRuleContext(ExpressionTermContext.class,0);
}
public DurationExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterDurationExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitDurationExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitDurationExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DifferenceExpressionTermContext extends ExpressionTermContext {
public PluralDateTimePrecisionContext pluralDateTimePrecision() {
return getRuleContext(PluralDateTimePrecisionContext.class,0);
}
public ExpressionTermContext expressionTerm() {
return getRuleContext(ExpressionTermContext.class,0);
}
public DifferenceExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterDifferenceExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitDifferenceExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitDifferenceExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CaseExpressionTermContext extends ExpressionTermContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List caseExpressionItem() {
return getRuleContexts(CaseExpressionItemContext.class);
}
public CaseExpressionItemContext caseExpressionItem(int i) {
return getRuleContext(CaseExpressionItemContext.class,i);
}
public CaseExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterCaseExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitCaseExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitCaseExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PowerExpressionTermContext extends ExpressionTermContext {
public List expressionTerm() {
return getRuleContexts(ExpressionTermContext.class);
}
public ExpressionTermContext expressionTerm(int i) {
return getRuleContext(ExpressionTermContext.class,i);
}
public PowerExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterPowerExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitPowerExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitPowerExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SuccessorExpressionTermContext extends ExpressionTermContext {
public ExpressionTermContext expressionTerm() {
return getRuleContext(ExpressionTermContext.class,0);
}
public SuccessorExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterSuccessorExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitSuccessorExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitSuccessorExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PolarityExpressionTermContext extends ExpressionTermContext {
public ExpressionTermContext expressionTerm() {
return getRuleContext(ExpressionTermContext.class,0);
}
public PolarityExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterPolarityExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitPolarityExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitPolarityExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TermExpressionTermContext extends ExpressionTermContext {
public TermContext term() {
return getRuleContext(TermContext.class,0);
}
public TermExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterTermExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitTermExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitTermExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class InvocationExpressionTermContext extends ExpressionTermContext {
public ExpressionTermContext expressionTerm() {
return getRuleContext(ExpressionTermContext.class,0);
}
public QualifiedInvocationContext qualifiedInvocation() {
return getRuleContext(QualifiedInvocationContext.class,0);
}
public InvocationExpressionTermContext(ExpressionTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterInvocationExpressionTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitInvocationExpressionTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitInvocationExpressionTerm(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionTermContext expressionTerm() throws RecognitionException {
return expressionTerm(0);
}
private ExpressionTermContext expressionTerm(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExpressionTermContext _localctx = new ExpressionTermContext(_ctx, _parentState);
ExpressionTermContext _prevctx = _localctx;
int _startState = 134;
enterRecursionRule(_localctx, 134, RULE_expressionTerm, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(850);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
case 1:
{
_localctx = new TermExpressionTermContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(773);
term();
}
break;
case 2:
{
_localctx = new ConversionExpressionTermContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(774);
match(T__101);
setState(775);
expression(0);
setState(776);
match(T__102);
setState(779);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case T__9:
case T__11:
case T__12:
case T__17:
case T__19:
case T__20:
case T__23:
case T__24:
case T__25:
case T__26:
case T__27:
case T__28:
case T__29:
case T__44:
case T__49:
case T__51:
case T__52:
case T__53:
case T__54:
case T__55:
case T__73:
case T__75:
case T__76:
case T__78:
case T__79:
case T__80:
case T__89:
case T__90:
case T__91:
case T__92:
case T__105:
case T__106:
case T__108:
case T__109:
case T__110:
case T__118:
case T__119:
case T__130:
case T__131:
case T__132:
case T__133:
case T__140:
case T__141:
case T__144:
case T__148:
case T__149:
case T__153:
case T__154:
case T__155:
case QUOTEDIDENTIFIER:
case IDENTIFIER:
case DELIMITEDIDENTIFIER:
{
setState(777);
typeSpecifier();
}
break;
case T__81:
case T__82:
case T__83:
case T__84:
case T__85:
case T__86:
case T__87:
case T__88:
case T__93:
case T__94:
case T__95:
case T__96:
case T__97:
case T__98:
case T__99:
case T__100:
case STRING:
{
setState(778);
unit();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 3:
{
_localctx = new PolarityExpressionTermContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(781);
_la = _input.LA(1);
if ( !(_la==T__103 || _la==T__104) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(782);
expressionTerm(18);
}
break;
case 4:
{
_localctx = new TimeBoundaryExpressionTermContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(783);
_la = _input.LA(1);
if ( !(_la==T__105 || _la==T__106) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(784);
match(T__107);
setState(785);
expressionTerm(17);
}
break;
case 5:
{
_localctx = new TimeUnitExpressionTermContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(786);
dateTimeComponent();
setState(787);
match(T__18);
setState(788);
expressionTerm(16);
}
break;
case 6:
{
_localctx = new DurationExpressionTermContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(790);
match(T__67);
setState(791);
match(T__40);
setState(792);
pluralDateTimePrecision();
setState(793);
match(T__107);
setState(794);
expressionTerm(15);
}
break;
case 7:
{
_localctx = new DifferenceExpressionTermContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(796);
match(T__68);
setState(797);
match(T__40);
setState(798);
pluralDateTimePrecision();
setState(799);
match(T__107);
setState(800);
expressionTerm(14);
}
break;
case 8:
{
_localctx = new WidthExpressionTermContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(802);
match(T__108);
setState(803);
match(T__107);
setState(804);
expressionTerm(13);
}
break;
case 9:
{
_localctx = new SuccessorExpressionTermContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(805);
match(T__109);
setState(806);
match(T__107);
setState(807);
expressionTerm(12);
}
break;
case 10:
{
_localctx = new PredecessorExpressionTermContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(808);
match(T__110);
setState(809);
match(T__107);
setState(810);
expressionTerm(11);
}
break;
case 11:
{
_localctx = new ElementExtractorExpressionTermContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(811);
match(T__111);
setState(812);
match(T__18);
setState(813);
expressionTerm(10);
}
break;
case 12:
{
_localctx = new PointExtractorExpressionTermContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(814);
match(T__112);
setState(815);
match(T__18);
setState(816);
expressionTerm(9);
}
break;
case 13:
{
_localctx = new TypeExtentExpressionTermContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(817);
_la = _input.LA(1);
if ( !(_la==T__113 || _la==T__114) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(818);
namedTypeSpecifier();
}
break;
case 14:
{
_localctx = new IfThenElseExpressionTermContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(819);
match(T__121);
setState(820);
expression(0);
setState(821);
match(T__122);
setState(822);
expression(0);
setState(823);
match(T__123);
setState(824);
expression(0);
}
break;
case 15:
{
_localctx = new CaseExpressionTermContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(826);
match(T__124);
setState(828);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4758861967782021122L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -1905040784319597519L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 549753872505L) != 0)) {
{
setState(827);
expression(0);
}
}
setState(831);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(830);
caseExpressionItem();
}
}
setState(833);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==T__129 );
setState(835);
match(T__123);
setState(836);
expression(0);
setState(837);
match(T__106);
}
break;
case 16:
{
_localctx = new AggregateExpressionTermContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(839);
_la = _input.LA(1);
if ( !(_la==T__47 || _la==T__125) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(840);
expression(0);
}
break;
case 17:
{
_localctx = new SetAggregateExpressionTermContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(841);
_la = _input.LA(1);
if ( !(_la==T__126 || _la==T__127) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(842);
expression(0);
setState(848);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) {
case 1:
{
setState(843);
match(T__128);
setState(846);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
case 1:
{
setState(844);
dateTimePrecision();
}
break;
case 2:
{
setState(845);
expression(0);
}
break;
}
}
break;
}
}
break;
}
_ctx.stop = _input.LT(-1);
setState(871);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,79,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(869);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) {
case 1:
{
_localctx = new PowerExpressionTermContext(new ExpressionTermContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expressionTerm);
setState(852);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
setState(853);
match(T__115);
setState(854);
expressionTerm(8);
}
break;
case 2:
{
_localctx = new MultiplicationExpressionTermContext(new ExpressionTermContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expressionTerm);
setState(855);
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(856);
_la = _input.LA(1);
if ( !(((((_la - 117)) & ~0x3f) == 0 && ((1L << (_la - 117)) & 15L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(857);
expressionTerm(7);
}
break;
case 3:
{
_localctx = new AdditionExpressionTermContext(new ExpressionTermContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expressionTerm);
setState(858);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(859);
_la = _input.LA(1);
if ( !(((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & 131075L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(860);
expressionTerm(6);
}
break;
case 4:
{
_localctx = new InvocationExpressionTermContext(new ExpressionTermContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expressionTerm);
setState(861);
if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)");
setState(862);
match(T__16);
setState(863);
qualifiedInvocation();
}
break;
case 5:
{
_localctx = new IndexedExpressionTermContext(new ExpressionTermContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expressionTerm);
setState(864);
if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
setState(865);
match(T__37);
setState(866);
expression(0);
setState(867);
match(T__39);
}
break;
}
}
}
setState(873);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,79,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CaseExpressionItemContext extends ParserRuleContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public CaseExpressionItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_caseExpressionItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterCaseExpressionItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitCaseExpressionItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitCaseExpressionItem(this);
else return visitor.visitChildren(this);
}
}
public final CaseExpressionItemContext caseExpressionItem() throws RecognitionException {
CaseExpressionItemContext _localctx = new CaseExpressionItemContext(_ctx, getState());
enterRule(_localctx, 136, RULE_caseExpressionItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(874);
match(T__129);
setState(875);
expression(0);
setState(876);
match(T__122);
setState(877);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DateTimePrecisionSpecifierContext extends ParserRuleContext {
public DateTimePrecisionContext dateTimePrecision() {
return getRuleContext(DateTimePrecisionContext.class,0);
}
public DateTimePrecisionSpecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dateTimePrecisionSpecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterDateTimePrecisionSpecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitDateTimePrecisionSpecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitDateTimePrecisionSpecifier(this);
else return visitor.visitChildren(this);
}
}
public final DateTimePrecisionSpecifierContext dateTimePrecisionSpecifier() throws RecognitionException {
DateTimePrecisionSpecifierContext _localctx = new DateTimePrecisionSpecifierContext(_ctx, getState());
enterRule(_localctx, 138, RULE_dateTimePrecisionSpecifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(879);
dateTimePrecision();
setState(880);
match(T__107);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RelativeQualifierContext extends ParserRuleContext {
public RelativeQualifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relativeQualifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterRelativeQualifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitRelativeQualifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitRelativeQualifier(this);
else return visitor.visitChildren(this);
}
}
public final RelativeQualifierContext relativeQualifier() throws RecognitionException {
RelativeQualifierContext _localctx = new RelativeQualifierContext(_ctx, getState());
enterRule(_localctx, 140, RULE_relativeQualifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(882);
_la = _input.LA(1);
if ( !(_la==T__130 || _la==T__131) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OffsetRelativeQualifierContext extends ParserRuleContext {
public OffsetRelativeQualifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_offsetRelativeQualifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterOffsetRelativeQualifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitOffsetRelativeQualifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitOffsetRelativeQualifier(this);
else return visitor.visitChildren(this);
}
}
public final OffsetRelativeQualifierContext offsetRelativeQualifier() throws RecognitionException {
OffsetRelativeQualifierContext _localctx = new OffsetRelativeQualifierContext(_ctx, getState());
enterRule(_localctx, 142, RULE_offsetRelativeQualifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(884);
_la = _input.LA(1);
if ( !(_la==T__132 || _la==T__133) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExclusiveRelativeQualifierContext extends ParserRuleContext {
public ExclusiveRelativeQualifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exclusiveRelativeQualifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterExclusiveRelativeQualifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitExclusiveRelativeQualifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitExclusiveRelativeQualifier(this);
else return visitor.visitChildren(this);
}
}
public final ExclusiveRelativeQualifierContext exclusiveRelativeQualifier() throws RecognitionException {
ExclusiveRelativeQualifierContext _localctx = new ExclusiveRelativeQualifierContext(_ctx, getState());
enterRule(_localctx, 144, RULE_exclusiveRelativeQualifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(886);
_la = _input.LA(1);
if ( !(_la==T__134 || _la==T__135) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QuantityOffsetContext extends ParserRuleContext {
public QuantityContext quantity() {
return getRuleContext(QuantityContext.class,0);
}
public OffsetRelativeQualifierContext offsetRelativeQualifier() {
return getRuleContext(OffsetRelativeQualifierContext.class,0);
}
public ExclusiveRelativeQualifierContext exclusiveRelativeQualifier() {
return getRuleContext(ExclusiveRelativeQualifierContext.class,0);
}
public QuantityOffsetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_quantityOffset; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterQuantityOffset(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitQuantityOffset(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitQuantityOffset(this);
else return visitor.visitChildren(this);
}
}
public final QuantityOffsetContext quantityOffset() throws RecognitionException {
QuantityOffsetContext _localctx = new QuantityOffsetContext(_ctx, getState());
enterRule(_localctx, 146, RULE_quantityOffset);
int _la;
try {
setState(895);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NUMBER:
enterOuterAlt(_localctx, 1);
{
{
setState(888);
quantity();
setState(890);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__132 || _la==T__133) {
{
setState(889);
offsetRelativeQualifier();
}
}
}
}
break;
case T__134:
case T__135:
enterOuterAlt(_localctx, 2);
{
{
setState(892);
exclusiveRelativeQualifier();
setState(893);
quantity();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TemporalRelationshipContext extends ParserRuleContext {
public TemporalRelationshipContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_temporalRelationship; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterTemporalRelationship(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitTemporalRelationship(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitTemporalRelationship(this);
else return visitor.visitChildren(this);
}
}
public final TemporalRelationshipContext temporalRelationship() throws RecognitionException {
TemporalRelationshipContext _localctx = new TemporalRelationshipContext(_ctx, getState());
enterRule(_localctx, 148, RULE_temporalRelationship);
int _la;
try {
setState(905);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
{
setState(898);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__136) {
{
setState(897);
match(T__136);
}
}
setState(900);
_la = _input.LA(1);
if ( !(_la==T__137 || _la==T__138) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
{
setState(901);
_la = _input.LA(1);
if ( !(_la==T__137 || _la==T__138) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(903);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__139) {
{
setState(902);
match(T__139);
}
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IntervalOperatorPhraseContext extends ParserRuleContext {
public IntervalOperatorPhraseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_intervalOperatorPhrase; }
public IntervalOperatorPhraseContext() { }
public void copyFrom(IntervalOperatorPhraseContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class WithinIntervalOperatorPhraseContext extends IntervalOperatorPhraseContext {
public QuantityContext quantity() {
return getRuleContext(QuantityContext.class,0);
}
public WithinIntervalOperatorPhraseContext(IntervalOperatorPhraseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterWithinIntervalOperatorPhrase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitWithinIntervalOperatorPhrase(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitWithinIntervalOperatorPhrase(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IncludedInIntervalOperatorPhraseContext extends IntervalOperatorPhraseContext {
public DateTimePrecisionSpecifierContext dateTimePrecisionSpecifier() {
return getRuleContext(DateTimePrecisionSpecifierContext.class,0);
}
public IncludedInIntervalOperatorPhraseContext(IntervalOperatorPhraseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterIncludedInIntervalOperatorPhrase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitIncludedInIntervalOperatorPhrase(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitIncludedInIntervalOperatorPhrase(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class EndsIntervalOperatorPhraseContext extends IntervalOperatorPhraseContext {
public DateTimePrecisionSpecifierContext dateTimePrecisionSpecifier() {
return getRuleContext(DateTimePrecisionSpecifierContext.class,0);
}
public EndsIntervalOperatorPhraseContext(IntervalOperatorPhraseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterEndsIntervalOperatorPhrase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitEndsIntervalOperatorPhrase(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitEndsIntervalOperatorPhrase(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConcurrentWithIntervalOperatorPhraseContext extends IntervalOperatorPhraseContext {
public RelativeQualifierContext relativeQualifier() {
return getRuleContext(RelativeQualifierContext.class,0);
}
public DateTimePrecisionContext dateTimePrecision() {
return getRuleContext(DateTimePrecisionContext.class,0);
}
public ConcurrentWithIntervalOperatorPhraseContext(IntervalOperatorPhraseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterConcurrentWithIntervalOperatorPhrase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitConcurrentWithIntervalOperatorPhrase(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitConcurrentWithIntervalOperatorPhrase(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class OverlapsIntervalOperatorPhraseContext extends IntervalOperatorPhraseContext {
public DateTimePrecisionSpecifierContext dateTimePrecisionSpecifier() {
return getRuleContext(DateTimePrecisionSpecifierContext.class,0);
}
public OverlapsIntervalOperatorPhraseContext(IntervalOperatorPhraseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterOverlapsIntervalOperatorPhrase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitOverlapsIntervalOperatorPhrase(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitOverlapsIntervalOperatorPhrase(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IncludesIntervalOperatorPhraseContext extends IntervalOperatorPhraseContext {
public DateTimePrecisionSpecifierContext dateTimePrecisionSpecifier() {
return getRuleContext(DateTimePrecisionSpecifierContext.class,0);
}
public IncludesIntervalOperatorPhraseContext(IntervalOperatorPhraseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterIncludesIntervalOperatorPhrase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitIncludesIntervalOperatorPhrase(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitIncludesIntervalOperatorPhrase(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BeforeOrAfterIntervalOperatorPhraseContext extends IntervalOperatorPhraseContext {
public TemporalRelationshipContext temporalRelationship() {
return getRuleContext(TemporalRelationshipContext.class,0);
}
public QuantityOffsetContext quantityOffset() {
return getRuleContext(QuantityOffsetContext.class,0);
}
public DateTimePrecisionSpecifierContext dateTimePrecisionSpecifier() {
return getRuleContext(DateTimePrecisionSpecifierContext.class,0);
}
public BeforeOrAfterIntervalOperatorPhraseContext(IntervalOperatorPhraseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterBeforeOrAfterIntervalOperatorPhrase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitBeforeOrAfterIntervalOperatorPhrase(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitBeforeOrAfterIntervalOperatorPhrase(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class MeetsIntervalOperatorPhraseContext extends IntervalOperatorPhraseContext {
public DateTimePrecisionSpecifierContext dateTimePrecisionSpecifier() {
return getRuleContext(DateTimePrecisionSpecifierContext.class,0);
}
public MeetsIntervalOperatorPhraseContext(IntervalOperatorPhraseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterMeetsIntervalOperatorPhrase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitMeetsIntervalOperatorPhrase(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitMeetsIntervalOperatorPhrase(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class StartsIntervalOperatorPhraseContext extends IntervalOperatorPhraseContext {
public DateTimePrecisionSpecifierContext dateTimePrecisionSpecifier() {
return getRuleContext(DateTimePrecisionSpecifierContext.class,0);
}
public StartsIntervalOperatorPhraseContext(IntervalOperatorPhraseContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterStartsIntervalOperatorPhrase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitStartsIntervalOperatorPhrase(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitStartsIntervalOperatorPhrase(this);
else return visitor.visitChildren(this);
}
}
public final IntervalOperatorPhraseContext intervalOperatorPhrase() throws RecognitionException {
IntervalOperatorPhraseContext _localctx = new IntervalOperatorPhraseContext(_ctx, getState());
enterRule(_localctx, 150, RULE_intervalOperatorPhrase);
int _la;
try {
setState(988);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,108,_ctx) ) {
case 1:
_localctx = new ConcurrentWithIntervalOperatorPhraseContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(908);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 7L) != 0)) {
{
setState(907);
_la = _input.LA(1);
if ( !(((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 7L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(910);
match(T__143);
setState(912);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 82)) & ~0x3f) == 0 && ((1L << (_la - 82)) & 255L) != 0)) {
{
setState(911);
dateTimePrecision();
}
}
setState(916);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__130:
case T__131:
{
setState(914);
relativeQualifier();
}
break;
case T__61:
{
setState(915);
match(T__61);
}
break;
default:
throw new NoViableAltException(this);
}
setState(919);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
case 1:
{
setState(918);
_la = _input.LA(1);
if ( !(_la==T__105 || _la==T__106) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
}
break;
case 2:
_localctx = new IncludesIntervalOperatorPhraseContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(922);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__64) {
{
setState(921);
match(T__64);
}
}
setState(924);
match(T__144);
setState(926);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
case 1:
{
setState(925);
dateTimePrecisionSpecifier();
}
break;
}
setState(929);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,91,_ctx) ) {
case 1:
{
setState(928);
_la = _input.LA(1);
if ( !(_la==T__105 || _la==T__106) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
}
break;
case 3:
_localctx = new IncludedInIntervalOperatorPhraseContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(932);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 7L) != 0)) {
{
setState(931);
_la = _input.LA(1);
if ( !(((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 7L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(935);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__64) {
{
setState(934);
match(T__64);
}
}
setState(937);
_la = _input.LA(1);
if ( !(_la==T__145 || _la==T__146) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(939);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) {
case 1:
{
setState(938);
dateTimePrecisionSpecifier();
}
break;
}
}
break;
case 4:
_localctx = new BeforeOrAfterIntervalOperatorPhraseContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(942);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 7L) != 0)) {
{
setState(941);
_la = _input.LA(1);
if ( !(((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 7L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(945);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 135)) & ~0x3f) == 0 && ((1L << (_la - 135)) & 2147483651L) != 0)) {
{
setState(944);
quantityOffset();
}
}
setState(947);
temporalRelationship();
setState(949);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) {
case 1:
{
setState(948);
dateTimePrecisionSpecifier();
}
break;
}
setState(952);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
case 1:
{
setState(951);
_la = _input.LA(1);
if ( !(_la==T__105 || _la==T__106) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
}
break;
case 5:
_localctx = new WithinIntervalOperatorPhraseContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(955);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 7L) != 0)) {
{
setState(954);
_la = _input.LA(1);
if ( !(((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 7L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(958);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__64) {
{
setState(957);
match(T__64);
}
}
setState(960);
match(T__147);
setState(961);
quantity();
setState(962);
match(T__107);
setState(964);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) {
case 1:
{
setState(963);
_la = _input.LA(1);
if ( !(_la==T__105 || _la==T__106) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
}
break;
case 6:
_localctx = new MeetsIntervalOperatorPhraseContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(966);
match(T__148);
setState(968);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__137 || _la==T__138) {
{
setState(967);
_la = _input.LA(1);
if ( !(_la==T__137 || _la==T__138) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(971);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) {
case 1:
{
setState(970);
dateTimePrecisionSpecifier();
}
break;
}
}
break;
case 7:
_localctx = new OverlapsIntervalOperatorPhraseContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(973);
match(T__149);
setState(975);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__137 || _la==T__138) {
{
setState(974);
_la = _input.LA(1);
if ( !(_la==T__137 || _la==T__138) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(978);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) {
case 1:
{
setState(977);
dateTimePrecisionSpecifier();
}
break;
}
}
break;
case 8:
_localctx = new StartsIntervalOperatorPhraseContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(980);
match(T__140);
setState(982);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) {
case 1:
{
setState(981);
dateTimePrecisionSpecifier();
}
break;
}
}
break;
case 9:
_localctx = new EndsIntervalOperatorPhraseContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(984);
match(T__141);
setState(986);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,107,_ctx) ) {
case 1:
{
setState(985);
dateTimePrecisionSpecifier();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TermContext extends ParserRuleContext {
public TermContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_term; }
public TermContext() { }
public void copyFrom(TermContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ExternalConstantTermContext extends TermContext {
public ExternalConstantContext externalConstant() {
return getRuleContext(ExternalConstantContext.class,0);
}
public ExternalConstantTermContext(TermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterExternalConstantTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitExternalConstantTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitExternalConstantTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TupleSelectorTermContext extends TermContext {
public TupleSelectorContext tupleSelector() {
return getRuleContext(TupleSelectorContext.class,0);
}
public TupleSelectorTermContext(TermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterTupleSelectorTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitTupleSelectorTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitTupleSelectorTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LiteralTermContext extends TermContext {
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public LiteralTermContext(TermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterLiteralTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitLiteralTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitLiteralTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConceptSelectorTermContext extends TermContext {
public ConceptSelectorContext conceptSelector() {
return getRuleContext(ConceptSelectorContext.class,0);
}
public ConceptSelectorTermContext(TermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterConceptSelectorTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitConceptSelectorTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitConceptSelectorTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ParenthesizedTermContext extends TermContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ParenthesizedTermContext(TermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterParenthesizedTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitParenthesizedTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitParenthesizedTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CodeSelectorTermContext extends TermContext {
public CodeSelectorContext codeSelector() {
return getRuleContext(CodeSelectorContext.class,0);
}
public CodeSelectorTermContext(TermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterCodeSelectorTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitCodeSelectorTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitCodeSelectorTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class InvocationTermContext extends TermContext {
public InvocationContext invocation() {
return getRuleContext(InvocationContext.class,0);
}
public InvocationTermContext(TermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterInvocationTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitInvocationTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitInvocationTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class InstanceSelectorTermContext extends TermContext {
public InstanceSelectorContext instanceSelector() {
return getRuleContext(InstanceSelectorContext.class,0);
}
public InstanceSelectorTermContext(TermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterInstanceSelectorTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitInstanceSelectorTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitInstanceSelectorTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IntervalSelectorTermContext extends TermContext {
public IntervalSelectorContext intervalSelector() {
return getRuleContext(IntervalSelectorContext.class,0);
}
public IntervalSelectorTermContext(TermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterIntervalSelectorTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitIntervalSelectorTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitIntervalSelectorTerm(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ListSelectorTermContext extends TermContext {
public ListSelectorContext listSelector() {
return getRuleContext(ListSelectorContext.class,0);
}
public ListSelectorTermContext(TermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterListSelectorTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitListSelectorTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitListSelectorTerm(this);
else return visitor.visitChildren(this);
}
}
public final TermContext term() throws RecognitionException {
TermContext _localctx = new TermContext(_ctx, getState());
enterRule(_localctx, 152, RULE_term);
try {
setState(1003);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,109,_ctx) ) {
case 1:
_localctx = new InvocationTermContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(990);
invocation();
}
break;
case 2:
_localctx = new LiteralTermContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(991);
literal();
}
break;
case 3:
_localctx = new ExternalConstantTermContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(992);
externalConstant();
}
break;
case 4:
_localctx = new IntervalSelectorTermContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(993);
intervalSelector();
}
break;
case 5:
_localctx = new TupleSelectorTermContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(994);
tupleSelector();
}
break;
case 6:
_localctx = new InstanceSelectorTermContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(995);
instanceSelector();
}
break;
case 7:
_localctx = new ListSelectorTermContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(996);
listSelector();
}
break;
case 8:
_localctx = new CodeSelectorTermContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(997);
codeSelector();
}
break;
case 9:
_localctx = new ConceptSelectorTermContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(998);
conceptSelector();
}
break;
case 10:
_localctx = new ParenthesizedTermContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(999);
match(T__30);
setState(1000);
expression(0);
setState(1001);
match(T__31);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QualifiedInvocationContext extends ParserRuleContext {
public QualifiedInvocationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedInvocation; }
public QualifiedInvocationContext() { }
public void copyFrom(QualifiedInvocationContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class QualifiedFunctionInvocationContext extends QualifiedInvocationContext {
public QualifiedFunctionContext qualifiedFunction() {
return getRuleContext(QualifiedFunctionContext.class,0);
}
public QualifiedFunctionInvocationContext(QualifiedInvocationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterQualifiedFunctionInvocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitQualifiedFunctionInvocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitQualifiedFunctionInvocation(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class QualifiedMemberInvocationContext extends QualifiedInvocationContext {
public ReferentialIdentifierContext referentialIdentifier() {
return getRuleContext(ReferentialIdentifierContext.class,0);
}
public QualifiedMemberInvocationContext(QualifiedInvocationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterQualifiedMemberInvocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitQualifiedMemberInvocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitQualifiedMemberInvocation(this);
else return visitor.visitChildren(this);
}
}
public final QualifiedInvocationContext qualifiedInvocation() throws RecognitionException {
QualifiedInvocationContext _localctx = new QualifiedInvocationContext(_ctx, getState());
enterRule(_localctx, 154, RULE_qualifiedInvocation);
try {
setState(1007);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) {
case 1:
_localctx = new QualifiedMemberInvocationContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1005);
referentialIdentifier();
}
break;
case 2:
_localctx = new QualifiedFunctionInvocationContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1006);
qualifiedFunction();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QualifiedFunctionContext extends ParserRuleContext {
public IdentifierOrFunctionIdentifierContext identifierOrFunctionIdentifier() {
return getRuleContext(IdentifierOrFunctionIdentifierContext.class,0);
}
public ParamListContext paramList() {
return getRuleContext(ParamListContext.class,0);
}
public QualifiedFunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedFunction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterQualifiedFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitQualifiedFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitQualifiedFunction(this);
else return visitor.visitChildren(this);
}
}
public final QualifiedFunctionContext qualifiedFunction() throws RecognitionException {
QualifiedFunctionContext _localctx = new QualifiedFunctionContext(_ctx, getState());
enterRule(_localctx, 156, RULE_qualifiedFunction);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1009);
identifierOrFunctionIdentifier();
setState(1010);
match(T__30);
setState(1012);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4758861967782021122L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -1905040784319597519L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 549753872505L) != 0)) {
{
setState(1011);
paramList();
}
}
setState(1014);
match(T__31);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class InvocationContext extends ParserRuleContext {
public InvocationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_invocation; }
public InvocationContext() { }
public void copyFrom(InvocationContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TotalInvocationContext extends InvocationContext {
public TotalInvocationContext(InvocationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterTotalInvocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitTotalInvocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitTotalInvocation(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ThisInvocationContext extends InvocationContext {
public ThisInvocationContext(InvocationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterThisInvocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitThisInvocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitThisInvocation(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IndexInvocationContext extends InvocationContext {
public IndexInvocationContext(InvocationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterIndexInvocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitIndexInvocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitIndexInvocation(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionInvocationContext extends InvocationContext {
public FunctionContext function() {
return getRuleContext(FunctionContext.class,0);
}
public FunctionInvocationContext(InvocationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterFunctionInvocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitFunctionInvocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitFunctionInvocation(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class MemberInvocationContext extends InvocationContext {
public ReferentialIdentifierContext referentialIdentifier() {
return getRuleContext(ReferentialIdentifierContext.class,0);
}
public MemberInvocationContext(InvocationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterMemberInvocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitMemberInvocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitMemberInvocation(this);
else return visitor.visitChildren(this);
}
}
public final InvocationContext invocation() throws RecognitionException {
InvocationContext _localctx = new InvocationContext(_ctx, getState());
enterRule(_localctx, 158, RULE_invocation);
try {
setState(1021);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) {
case 1:
_localctx = new MemberInvocationContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1016);
referentialIdentifier();
}
break;
case 2:
_localctx = new FunctionInvocationContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1017);
function();
}
break;
case 3:
_localctx = new ThisInvocationContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1018);
match(T__150);
}
break;
case 4:
_localctx = new IndexInvocationContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1019);
match(T__151);
}
break;
case 5:
_localctx = new TotalInvocationContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(1020);
match(T__152);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionContext extends ParserRuleContext {
public ReferentialIdentifierContext referentialIdentifier() {
return getRuleContext(ReferentialIdentifierContext.class,0);
}
public ParamListContext paramList() {
return getRuleContext(ParamListContext.class,0);
}
public FunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitFunction(this);
else return visitor.visitChildren(this);
}
}
public final FunctionContext function() throws RecognitionException {
FunctionContext _localctx = new FunctionContext(_ctx, getState());
enterRule(_localctx, 160, RULE_function);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1023);
referentialIdentifier();
setState(1024);
match(T__30);
setState(1026);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4758861967782021122L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -1905040784319597519L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 549753872505L) != 0)) {
{
setState(1025);
paramList();
}
}
setState(1028);
match(T__31);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RatioContext extends ParserRuleContext {
public List quantity() {
return getRuleContexts(QuantityContext.class);
}
public QuantityContext quantity(int i) {
return getRuleContext(QuantityContext.class,i);
}
public RatioContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ratio; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterRatio(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitRatio(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitRatio(this);
else return visitor.visitChildren(this);
}
}
public final RatioContext ratio() throws RecognitionException {
RatioContext _localctx = new RatioContext(_ctx, getState());
enterRule(_localctx, 162, RULE_ratio);
try {
enterOuterAlt(_localctx, 1);
{
setState(1030);
quantity();
setState(1031);
match(T__10);
setState(1032);
quantity();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LiteralContext extends ParserRuleContext {
public LiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal; }
public LiteralContext() { }
public void copyFrom(LiteralContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TimeLiteralContext extends LiteralContext {
public TerminalNode TIME() { return getToken(cqlParser.TIME, 0); }
public TimeLiteralContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterTimeLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitTimeLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitTimeLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NullLiteralContext extends LiteralContext {
public NullLiteralContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterNullLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitNullLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitNullLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RatioLiteralContext extends LiteralContext {
public RatioContext ratio() {
return getRuleContext(RatioContext.class,0);
}
public RatioLiteralContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterRatioLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitRatioLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitRatioLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DateTimeLiteralContext extends LiteralContext {
public TerminalNode DATETIME() { return getToken(cqlParser.DATETIME, 0); }
public DateTimeLiteralContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterDateTimeLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitDateTimeLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitDateTimeLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class StringLiteralContext extends LiteralContext {
public TerminalNode STRING() { return getToken(cqlParser.STRING, 0); }
public StringLiteralContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitStringLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitStringLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DateLiteralContext extends LiteralContext {
public TerminalNode DATE() { return getToken(cqlParser.DATE, 0); }
public DateLiteralContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterDateLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitDateLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitDateLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BooleanLiteralContext extends LiteralContext {
public BooleanLiteralContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterBooleanLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitBooleanLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitBooleanLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NumberLiteralContext extends LiteralContext {
public TerminalNode NUMBER() { return getToken(cqlParser.NUMBER, 0); }
public NumberLiteralContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterNumberLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitNumberLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitNumberLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LongNumberLiteralContext extends LiteralContext {
public TerminalNode LONGNUMBER() { return getToken(cqlParser.LONGNUMBER, 0); }
public LongNumberLiteralContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterLongNumberLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitLongNumberLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitLongNumberLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class QuantityLiteralContext extends LiteralContext {
public QuantityContext quantity() {
return getRuleContext(QuantityContext.class,0);
}
public QuantityLiteralContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterQuantityLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitQuantityLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitQuantityLiteral(this);
else return visitor.visitChildren(this);
}
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 164, RULE_literal);
int _la;
try {
setState(1044);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,114,_ctx) ) {
case 1:
_localctx = new BooleanLiteralContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1034);
_la = _input.LA(1);
if ( !(_la==T__59 || _la==T__60) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 2:
_localctx = new NullLiteralContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1035);
match(T__58);
}
break;
case 3:
_localctx = new StringLiteralContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1036);
match(STRING);
}
break;
case 4:
_localctx = new NumberLiteralContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1037);
match(NUMBER);
}
break;
case 5:
_localctx = new LongNumberLiteralContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(1038);
match(LONGNUMBER);
}
break;
case 6:
_localctx = new DateTimeLiteralContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(1039);
match(DATETIME);
}
break;
case 7:
_localctx = new DateLiteralContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(1040);
match(DATE);
}
break;
case 8:
_localctx = new TimeLiteralContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(1041);
match(TIME);
}
break;
case 9:
_localctx = new QuantityLiteralContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(1042);
quantity();
}
break;
case 10:
_localctx = new RatioLiteralContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(1043);
ratio();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IntervalSelectorContext extends ParserRuleContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public IntervalSelectorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_intervalSelector; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterIntervalSelector(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitIntervalSelector(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitIntervalSelector(this);
else return visitor.visitChildren(this);
}
}
public final IntervalSelectorContext intervalSelector() throws RecognitionException {
IntervalSelectorContext _localctx = new IntervalSelectorContext(_ctx, getState());
enterRule(_localctx, 166, RULE_intervalSelector);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1046);
match(T__23);
setState(1047);
_la = _input.LA(1);
if ( !(_la==T__30 || _la==T__37) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1048);
expression(0);
setState(1049);
match(T__14);
setState(1050);
expression(0);
setState(1051);
_la = _input.LA(1);
if ( !(_la==T__31 || _la==T__39) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TupleSelectorContext extends ParserRuleContext {
public List tupleElementSelector() {
return getRuleContexts(TupleElementSelectorContext.class);
}
public TupleElementSelectorContext tupleElementSelector(int i) {
return getRuleContext(TupleElementSelectorContext.class,i);
}
public TupleSelectorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tupleSelector; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterTupleSelector(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitTupleSelector(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitTupleSelector(this);
else return visitor.visitChildren(this);
}
}
public final TupleSelectorContext tupleSelector() throws RecognitionException {
TupleSelectorContext _localctx = new TupleSelectorContext(_ctx, getState());
enterRule(_localctx, 168, RULE_tupleSelector);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1054);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__24) {
{
setState(1053);
match(T__24);
}
}
setState(1056);
match(T__13);
setState(1066);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__10:
{
setState(1057);
match(T__10);
}
break;
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case T__9:
case T__11:
case T__12:
case T__17:
case T__19:
case T__26:
case T__27:
case T__28:
case T__29:
case T__44:
case T__49:
case T__51:
case T__52:
case T__53:
case T__54:
case T__55:
case T__73:
case T__75:
case T__76:
case T__78:
case T__79:
case T__80:
case T__89:
case T__90:
case T__91:
case T__92:
case T__105:
case T__106:
case T__108:
case T__109:
case T__110:
case T__118:
case T__119:
case T__130:
case T__131:
case T__132:
case T__133:
case T__140:
case T__141:
case T__144:
case T__148:
case T__149:
case T__153:
case QUOTEDIDENTIFIER:
case IDENTIFIER:
case DELIMITEDIDENTIFIER:
{
{
setState(1058);
tupleElementSelector();
setState(1063);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__14) {
{
{
setState(1059);
match(T__14);
setState(1060);
tupleElementSelector();
}
}
setState(1065);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1068);
match(T__15);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TupleElementSelectorContext extends ParserRuleContext {
public ReferentialIdentifierContext referentialIdentifier() {
return getRuleContext(ReferentialIdentifierContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TupleElementSelectorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tupleElementSelector; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterTupleElementSelector(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitTupleElementSelector(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitTupleElementSelector(this);
else return visitor.visitChildren(this);
}
}
public final TupleElementSelectorContext tupleElementSelector() throws RecognitionException {
TupleElementSelectorContext _localctx = new TupleElementSelectorContext(_ctx, getState());
enterRule(_localctx, 170, RULE_tupleElementSelector);
try {
enterOuterAlt(_localctx, 1);
{
setState(1070);
referentialIdentifier();
setState(1071);
match(T__10);
setState(1072);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class InstanceSelectorContext extends ParserRuleContext {
public NamedTypeSpecifierContext namedTypeSpecifier() {
return getRuleContext(NamedTypeSpecifierContext.class,0);
}
public List instanceElementSelector() {
return getRuleContexts(InstanceElementSelectorContext.class);
}
public InstanceElementSelectorContext instanceElementSelector(int i) {
return getRuleContext(InstanceElementSelectorContext.class,i);
}
public InstanceSelectorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_instanceSelector; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterInstanceSelector(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitInstanceSelector(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitInstanceSelector(this);
else return visitor.visitChildren(this);
}
}
public final InstanceSelectorContext instanceSelector() throws RecognitionException {
InstanceSelectorContext _localctx = new InstanceSelectorContext(_ctx, getState());
enterRule(_localctx, 172, RULE_instanceSelector);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1074);
namedTypeSpecifier();
setState(1075);
match(T__13);
setState(1085);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__10:
{
setState(1076);
match(T__10);
}
break;
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case T__9:
case T__11:
case T__12:
case T__17:
case T__19:
case T__26:
case T__27:
case T__28:
case T__29:
case T__44:
case T__49:
case T__51:
case T__52:
case T__53:
case T__54:
case T__55:
case T__73:
case T__75:
case T__76:
case T__78:
case T__79:
case T__80:
case T__89:
case T__90:
case T__91:
case T__92:
case T__105:
case T__106:
case T__108:
case T__109:
case T__110:
case T__118:
case T__119:
case T__130:
case T__131:
case T__132:
case T__133:
case T__140:
case T__141:
case T__144:
case T__148:
case T__149:
case T__153:
case QUOTEDIDENTIFIER:
case IDENTIFIER:
case DELIMITEDIDENTIFIER:
{
{
setState(1077);
instanceElementSelector();
setState(1082);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__14) {
{
{
setState(1078);
match(T__14);
setState(1079);
instanceElementSelector();
}
}
setState(1084);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1087);
match(T__15);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class InstanceElementSelectorContext extends ParserRuleContext {
public ReferentialIdentifierContext referentialIdentifier() {
return getRuleContext(ReferentialIdentifierContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public InstanceElementSelectorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_instanceElementSelector; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterInstanceElementSelector(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitInstanceElementSelector(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitInstanceElementSelector(this);
else return visitor.visitChildren(this);
}
}
public final InstanceElementSelectorContext instanceElementSelector() throws RecognitionException {
InstanceElementSelectorContext _localctx = new InstanceElementSelectorContext(_ctx, getState());
enterRule(_localctx, 174, RULE_instanceElementSelector);
try {
enterOuterAlt(_localctx, 1);
{
setState(1089);
referentialIdentifier();
setState(1090);
match(T__10);
setState(1091);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ListSelectorContext extends ParserRuleContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TypeSpecifierContext typeSpecifier() {
return getRuleContext(TypeSpecifierContext.class,0);
}
public ListSelectorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_listSelector; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterListSelector(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitListSelector(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitListSelector(this);
else return visitor.visitChildren(this);
}
}
public final ListSelectorContext listSelector() throws RecognitionException {
ListSelectorContext _localctx = new ListSelectorContext(_ctx, getState());
enterRule(_localctx, 176, RULE_listSelector);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1100);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__20) {
{
setState(1093);
match(T__20);
setState(1098);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__21) {
{
setState(1094);
match(T__21);
setState(1095);
typeSpecifier();
setState(1096);
match(T__22);
}
}
}
}
setState(1102);
match(T__13);
setState(1111);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4758861967782021122L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -1905040784319597519L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 549753872505L) != 0)) {
{
setState(1103);
expression(0);
setState(1108);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__14) {
{
{
setState(1104);
match(T__14);
setState(1105);
expression(0);
}
}
setState(1110);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1113);
match(T__15);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DisplayClauseContext extends ParserRuleContext {
public TerminalNode STRING() { return getToken(cqlParser.STRING, 0); }
public DisplayClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_displayClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterDisplayClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitDisplayClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitDisplayClause(this);
else return visitor.visitChildren(this);
}
}
public final DisplayClauseContext displayClause() throws RecognitionException {
DisplayClauseContext _localctx = new DisplayClauseContext(_ctx, getState());
enterRule(_localctx, 178, RULE_displayClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1115);
match(T__153);
setState(1116);
match(STRING);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CodeSelectorContext extends ParserRuleContext {
public TerminalNode STRING() { return getToken(cqlParser.STRING, 0); }
public CodesystemIdentifierContext codesystemIdentifier() {
return getRuleContext(CodesystemIdentifierContext.class,0);
}
public DisplayClauseContext displayClause() {
return getRuleContext(DisplayClauseContext.class,0);
}
public CodeSelectorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_codeSelector; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterCodeSelector(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitCodeSelector(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitCodeSelector(this);
else return visitor.visitChildren(this);
}
}
public final CodeSelectorContext codeSelector() throws RecognitionException {
CodeSelectorContext _localctx = new CodeSelectorContext(_ctx, getState());
enterRule(_localctx, 180, RULE_codeSelector);
try {
enterOuterAlt(_localctx, 1);
{
setState(1118);
match(T__154);
setState(1119);
match(STRING);
setState(1120);
match(T__18);
setState(1121);
codesystemIdentifier();
setState(1123);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
case 1:
{
setState(1122);
displayClause();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConceptSelectorContext extends ParserRuleContext {
public List codeSelector() {
return getRuleContexts(CodeSelectorContext.class);
}
public CodeSelectorContext codeSelector(int i) {
return getRuleContext(CodeSelectorContext.class,i);
}
public DisplayClauseContext displayClause() {
return getRuleContext(DisplayClauseContext.class,0);
}
public ConceptSelectorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conceptSelector; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterConceptSelector(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitConceptSelector(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitConceptSelector(this);
else return visitor.visitChildren(this);
}
}
public final ConceptSelectorContext conceptSelector() throws RecognitionException {
ConceptSelectorContext _localctx = new ConceptSelectorContext(_ctx, getState());
enterRule(_localctx, 182, RULE_conceptSelector);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1125);
match(T__155);
setState(1126);
match(T__13);
setState(1127);
codeSelector();
setState(1132);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__14) {
{
{
setState(1128);
match(T__14);
setState(1129);
codeSelector();
}
}
setState(1134);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1135);
match(T__15);
setState(1137);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
case 1:
{
setState(1136);
displayClause();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class KeywordContext extends ParserRuleContext {
public KeywordContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_keyword; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterKeyword(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitKeyword(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitKeyword(this);
else return visitor.visitChildren(this);
}
}
public final KeywordContext keyword() throws RecognitionException {
KeywordContext _localctx = new KeywordContext(_ctx, getState());
enterRule(_localctx, 184, RULE_keyword);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1139);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & -15150577076226L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -175643684002350017L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 478150271L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ReservedWordContext extends ParserRuleContext {
public ReservedWordContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_reservedWord; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterReservedWord(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitReservedWord(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitReservedWord(this);
else return visitor.visitChildren(this);
}
}
public final ReservedWordContext reservedWord() throws RecognitionException {
ReservedWordContext _localctx = new ReservedWordContext(_ctx, getState());
enterRule(_localctx, 186, RULE_reservedWord);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1141);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & -140787825319084032L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -283989560810272705L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 404594183L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class KeywordIdentifierContext extends ParserRuleContext {
public KeywordIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_keywordIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterKeywordIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitKeywordIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitKeywordIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final KeywordIdentifierContext keywordIdentifier() throws RecognitionException {
KeywordIdentifierContext _localctx = new KeywordIdentifierContext(_ctx, getState());
enterRule(_localctx, 188, RULE_keywordIdentifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1143);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 140772674742007806L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 2161833627658158317L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 8979L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ObsoleteIdentifierContext extends ParserRuleContext {
public ObsoleteIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_obsoleteIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterObsoleteIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitObsoleteIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitObsoleteIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final ObsoleteIdentifierContext obsoleteIdentifier() throws RecognitionException {
ObsoleteIdentifierContext _localctx = new ObsoleteIdentifierContext(_ctx, getState());
enterRule(_localctx, 190, RULE_obsoleteIdentifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1145);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 288687772990177284L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 13195146167297L) != 0) || ((((_la - 154)) & ~0x3f) == 0 && ((1L << (_la - 154)) & 7L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionIdentifierContext extends ParserRuleContext {
public FunctionIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterFunctionIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitFunctionIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitFunctionIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final FunctionIdentifierContext functionIdentifier() throws RecognitionException {
FunctionIdentifierContext _localctx = new FunctionIdentifierContext(_ctx, getState());
enterRule(_localctx, 192, RULE_functionIdentifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1147);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & -15150577076226L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -175643684002350017L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 478145663L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TypeNameIdentifierContext extends ParserRuleContext {
public TypeNameIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeNameIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterTypeNameIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitTypeNameIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitTypeNameIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final TypeNameIdentifierContext typeNameIdentifier() throws RecognitionException {
TypeNameIdentifierContext _localctx = new TypeNameIdentifierContext(_ctx, getState());
enterRule(_localctx, 194, RULE_typeNameIdentifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1149);
_la = _input.LA(1);
if ( !(_la==T__89 || _la==T__90 || _la==T__154 || _la==T__155) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ReferentialIdentifierContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public KeywordIdentifierContext keywordIdentifier() {
return getRuleContext(KeywordIdentifierContext.class,0);
}
public ReferentialIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_referentialIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterReferentialIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitReferentialIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitReferentialIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final ReferentialIdentifierContext referentialIdentifier() throws RecognitionException {
ReferentialIdentifierContext _localctx = new ReferentialIdentifierContext(_ctx, getState());
enterRule(_localctx, 196, RULE_referentialIdentifier);
try {
setState(1153);
_errHandler.sync(this);
switch (_input.LA(1)) {
case QUOTEDIDENTIFIER:
case IDENTIFIER:
case DELIMITEDIDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(1151);
identifier();
}
break;
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case T__9:
case T__11:
case T__12:
case T__17:
case T__19:
case T__26:
case T__27:
case T__28:
case T__29:
case T__44:
case T__49:
case T__51:
case T__52:
case T__53:
case T__54:
case T__55:
case T__73:
case T__75:
case T__76:
case T__78:
case T__79:
case T__80:
case T__89:
case T__90:
case T__91:
case T__92:
case T__105:
case T__106:
case T__108:
case T__109:
case T__110:
case T__118:
case T__119:
case T__130:
case T__131:
case T__132:
case T__133:
case T__140:
case T__141:
case T__144:
case T__148:
case T__149:
case T__153:
enterOuterAlt(_localctx, 2);
{
setState(1152);
keywordIdentifier();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ReferentialOrTypeNameIdentifierContext extends ParserRuleContext {
public ReferentialIdentifierContext referentialIdentifier() {
return getRuleContext(ReferentialIdentifierContext.class,0);
}
public TypeNameIdentifierContext typeNameIdentifier() {
return getRuleContext(TypeNameIdentifierContext.class,0);
}
public ReferentialOrTypeNameIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_referentialOrTypeNameIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterReferentialOrTypeNameIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitReferentialOrTypeNameIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitReferentialOrTypeNameIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final ReferentialOrTypeNameIdentifierContext referentialOrTypeNameIdentifier() throws RecognitionException {
ReferentialOrTypeNameIdentifierContext _localctx = new ReferentialOrTypeNameIdentifierContext(_ctx, getState());
enterRule(_localctx, 198, RULE_referentialOrTypeNameIdentifier);
try {
setState(1157);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1155);
referentialIdentifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1156);
typeNameIdentifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IdentifierOrFunctionIdentifierContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public FunctionIdentifierContext functionIdentifier() {
return getRuleContext(FunctionIdentifierContext.class,0);
}
public IdentifierOrFunctionIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifierOrFunctionIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterIdentifierOrFunctionIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitIdentifierOrFunctionIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitIdentifierOrFunctionIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierOrFunctionIdentifierContext identifierOrFunctionIdentifier() throws RecognitionException {
IdentifierOrFunctionIdentifierContext _localctx = new IdentifierOrFunctionIdentifierContext(_ctx, getState());
enterRule(_localctx, 200, RULE_identifierOrFunctionIdentifier);
try {
setState(1161);
_errHandler.sync(this);
switch (_input.LA(1)) {
case QUOTEDIDENTIFIER:
case IDENTIFIER:
case DELIMITEDIDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(1159);
identifier();
}
break;
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case T__9:
case T__11:
case T__12:
case T__17:
case T__18:
case T__19:
case T__20:
case T__23:
case T__24:
case T__26:
case T__27:
case T__28:
case T__29:
case T__34:
case T__35:
case T__36:
case T__40:
case T__43:
case T__44:
case T__45:
case T__46:
case T__47:
case T__48:
case T__49:
case T__50:
case T__51:
case T__52:
case T__53:
case T__54:
case T__55:
case T__56:
case T__57:
case T__58:
case T__59:
case T__60:
case T__61:
case T__62:
case T__63:
case T__64:
case T__65:
case T__66:
case T__67:
case T__68:
case T__73:
case T__74:
case T__75:
case T__76:
case T__78:
case T__79:
case T__80:
case T__81:
case T__82:
case T__83:
case T__84:
case T__85:
case T__86:
case T__87:
case T__88:
case T__89:
case T__90:
case T__91:
case T__92:
case T__93:
case T__94:
case T__95:
case T__96:
case T__97:
case T__98:
case T__99:
case T__100:
case T__101:
case T__102:
case T__105:
case T__106:
case T__107:
case T__108:
case T__109:
case T__110:
case T__111:
case T__112:
case T__113:
case T__114:
case T__118:
case T__119:
case T__121:
case T__122:
case T__123:
case T__124:
case T__125:
case T__126:
case T__127:
case T__128:
case T__129:
case T__130:
case T__131:
case T__132:
case T__133:
case T__137:
case T__138:
case T__140:
case T__141:
case T__142:
case T__143:
case T__144:
case T__145:
case T__146:
case T__147:
case T__148:
case T__149:
case T__153:
case T__154:
case T__155:
enterOuterAlt(_localctx, 2);
{
setState(1160);
functionIdentifier();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IdentifierContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(cqlParser.IDENTIFIER, 0); }
public TerminalNode DELIMITEDIDENTIFIER() { return getToken(cqlParser.DELIMITEDIDENTIFIER, 0); }
public TerminalNode QUOTEDIDENTIFIER() { return getToken(cqlParser.QUOTEDIDENTIFIER, 0); }
public IdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 202, RULE_identifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1163);
_la = _input.LA(1);
if ( !(((((_la - 158)) & ~0x3f) == 0 && ((1L << (_la - 158)) & 97L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExternalConstantContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode STRING() { return getToken(cqlParser.STRING, 0); }
public ExternalConstantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_externalConstant; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterExternalConstant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitExternalConstant(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitExternalConstant(this);
else return visitor.visitChildren(this);
}
}
public final ExternalConstantContext externalConstant() throws RecognitionException {
ExternalConstantContext _localctx = new ExternalConstantContext(_ctx, getState());
enterRule(_localctx, 204, RULE_externalConstant);
try {
enterOuterAlt(_localctx, 1);
{
setState(1165);
match(T__156);
setState(1168);
_errHandler.sync(this);
switch (_input.LA(1)) {
case QUOTEDIDENTIFIER:
case IDENTIFIER:
case DELIMITEDIDENTIFIER:
{
setState(1166);
identifier();
}
break;
case STRING:
{
setState(1167);
match(STRING);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ParamListContext extends ParserRuleContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ParamListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_paramList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterParamList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitParamList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitParamList(this);
else return visitor.visitChildren(this);
}
}
public final ParamListContext paramList() throws RecognitionException {
ParamListContext _localctx = new ParamListContext(_ctx, getState());
enterRule(_localctx, 206, RULE_paramList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1170);
expression(0);
setState(1175);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__14) {
{
{
setState(1171);
match(T__14);
setState(1172);
expression(0);
}
}
setState(1177);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QuantityContext extends ParserRuleContext {
public TerminalNode NUMBER() { return getToken(cqlParser.NUMBER, 0); }
public UnitContext unit() {
return getRuleContext(UnitContext.class,0);
}
public QuantityContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_quantity; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterQuantity(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitQuantity(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitQuantity(this);
else return visitor.visitChildren(this);
}
}
public final QuantityContext quantity() throws RecognitionException {
QuantityContext _localctx = new QuantityContext(_ctx, getState());
enterRule(_localctx, 208, RULE_quantity);
try {
enterOuterAlt(_localctx, 1);
{
setState(1178);
match(NUMBER);
setState(1180);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) {
case 1:
{
setState(1179);
unit();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnitContext extends ParserRuleContext {
public DateTimePrecisionContext dateTimePrecision() {
return getRuleContext(DateTimePrecisionContext.class,0);
}
public PluralDateTimePrecisionContext pluralDateTimePrecision() {
return getRuleContext(PluralDateTimePrecisionContext.class,0);
}
public TerminalNode STRING() { return getToken(cqlParser.STRING, 0); }
public UnitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).enterUnit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof cqlListener ) ((cqlListener)listener).exitUnit(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof cqlVisitor ) return ((cqlVisitor)visitor).visitUnit(this);
else return visitor.visitChildren(this);
}
}
public final UnitContext unit() throws RecognitionException {
UnitContext _localctx = new UnitContext(_ctx, getState());
enterRule(_localctx, 210, RULE_unit);
try {
setState(1185);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__81:
case T__82:
case T__83:
case T__84:
case T__85:
case T__86:
case T__87:
case T__88:
enterOuterAlt(_localctx, 1);
{
setState(1182);
dateTimePrecision();
}
break;
case T__93:
case T__94:
case T__95:
case T__96:
case T__97:
case T__98:
case T__99:
case T__100:
enterOuterAlt(_localctx, 2);
{
setState(1183);
pluralDateTimePrecision();
}
break;
case STRING:
enterOuterAlt(_localctx, 3);
{
setState(1184);
match(STRING);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 61:
return simplePath_sempred((SimplePathContext)_localctx, predIndex);
case 63:
return expression_sempred((ExpressionContext)_localctx, predIndex);
case 67:
return expressionTerm_sempred((ExpressionTermContext)_localctx, predIndex);
}
return true;
}
private boolean simplePath_sempred(SimplePathContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 2);
case 1:
return precpred(_ctx, 1);
}
return true;
}
private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 2:
return precpred(_ctx, 8);
case 3:
return precpred(_ctx, 7);
case 4:
return precpred(_ctx, 6);
case 5:
return precpred(_ctx, 5);
case 6:
return precpred(_ctx, 4);
case 7:
return precpred(_ctx, 3);
case 8:
return precpred(_ctx, 2);
case 9:
return precpred(_ctx, 1);
case 10:
return precpred(_ctx, 16);
case 11:
return precpred(_ctx, 15);
case 12:
return precpred(_ctx, 11);
}
return true;
}
private boolean expressionTerm_sempred(ExpressionTermContext _localctx, int predIndex) {
switch (predIndex) {
case 13:
return precpred(_ctx, 7);
case 14:
return precpred(_ctx, 6);
case 15:
return precpred(_ctx, 5);
case 16:
return precpred(_ctx, 21);
case 17:
return precpred(_ctx, 20);
}
return true;
}
public static final String _serializedATN =
"\u0004\u0001\u00a9\u04a4\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001"+
"\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004"+
"\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007"+
"\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b"+
"\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007"+
"\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007"+
"\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007"+
"\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007"+
"\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007"+
"\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007"+
"\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007"+
"\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007"+
"\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007"+
",\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u0007"+
"1\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u0007"+
"6\u00027\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007"+
";\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007"+
"@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007"+
"E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007"+
"J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007"+
"O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007"+
"T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007"+
"Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007"+
"^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007b\u0002c\u0007"+
"c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002g\u0007g\u0002h\u0007"+
"h\u0002i\u0007i\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001"+
"\u0000\u0001\u0000\u0001\u0000\u0003\u0000\u00dc\b\u0000\u0001\u0001\u0003"+
"\u0001\u00df\b\u0001\u0001\u0001\u0005\u0001\u00e2\b\u0001\n\u0001\f\u0001"+
"\u00e5\t\u0001\u0001\u0001\u0005\u0001\u00e8\b\u0001\n\u0001\f\u0001\u00eb"+
"\t\u0001\u0001\u0001\u0001\u0001\u0001\u0002\u0001\u0002\u0001\u0002\u0001"+
"\u0002\u0003\u0002\u00f3\b\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0001"+
"\u0003\u0003\u0003\u00f9\b\u0003\u0001\u0003\u0001\u0003\u0003\u0003\u00fd"+
"\b\u0003\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0003\u0004\u0103"+
"\b\u0004\u0001\u0004\u0001\u0004\u0003\u0004\u0107\b\u0004\u0001\u0005"+
"\u0001\u0005\u0001\u0006\u0001\u0006\u0001\u0007\u0003\u0007\u010e\b\u0007"+
"\u0001\u0007\u0001\u0007\u0001\u0007\u0003\u0007\u0113\b\u0007\u0001\u0007"+
"\u0001\u0007\u0003\u0007\u0117\b\u0007\u0001\b\u0003\b\u011a\b\b\u0001"+
"\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0003\b\u0122\b\b\u0001\t\u0003"+
"\t\u0125\b\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0003\t\u012d"+
"\b\t\u0001\t\u0003\t\u0130\b\t\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n"+
"\u0005\n\u0137\b\n\n\n\f\n\u013a\t\n\u0001\n\u0001\n\u0001\u000b\u0001"+
"\u000b\u0001\u000b\u0003\u000b\u0141\b\u000b\u0001\u000b\u0001\u000b\u0001"+
"\f\u0001\f\u0001\r\u0003\r\u0148\b\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001"+
"\r\u0001\r\u0001\r\u0003\r\u0151\b\r\u0001\u000e\u0003\u000e\u0154\b\u000e"+
"\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e"+
"\u0001\u000e\u0005\u000e\u015d\b\u000e\n\u000e\f\u000e\u0160\t\u000e\u0001"+
"\u000e\u0001\u000e\u0003\u000e\u0164\b\u000e\u0001\u000f\u0001\u000f\u0001"+
"\u000f\u0003\u000f\u0169\b\u000f\u0001\u000f\u0001\u000f\u0001\u0010\u0001"+
"\u0010\u0001\u0011\u0001\u0011\u0001\u0012\u0001\u0012\u0001\u0013\u0001"+
"\u0013\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0003"+
"\u0014\u017a\b\u0014\u0001\u0015\u0001\u0015\u0001\u0015\u0005\u0015\u017f"+
"\b\u0015\n\u0015\f\u0015\u0182\t\u0015\u0001\u0015\u0001\u0015\u0001\u0016"+
"\u0001\u0016\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017"+
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0019"+
"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0005\u0019\u0197\b\u0019"+
"\n\u0019\f\u0019\u019a\t\u0019\u0001\u0019\u0001\u0019\u0001\u001a\u0001"+
"\u001a\u0001\u001a\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001"+
"\u001b\u0005\u001b\u01a6\b\u001b\n\u001b\f\u001b\u01a9\t\u001b\u0001\u001b"+
"\u0001\u001b\u0001\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u01b0\b\u001c"+
"\u0001\u001d\u0001\u001d\u0003\u001d\u01b4\b\u001d\u0001\u001d\u0001\u001d"+
"\u0001\u001d\u0001\u001d\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
"\u0003\u001e\u01be\b\u001e\u0001\u001e\u0001\u001e\u0001\u001f\u0001\u001f"+
"\u0001 \u0001 \u0003 \u01c6\b \u0001 \u0003 \u01c9\b \u0001 \u0001 \u0001"+
" \u0001 \u0001 \u0001 \u0005 \u01d1\b \n \f \u01d4\t \u0003 \u01d6\b "+
"\u0001 \u0001 \u0001 \u0003 \u01db\b \u0001 \u0001 \u0001 \u0003 \u01e0"+
"\b \u0001!\u0001!\u0001!\u0001\"\u0001\"\u0001#\u0001#\u0001#\u0001#\u0001"+
"#\u0001#\u0003#\u01ed\b#\u0001$\u0001$\u0001$\u0001%\u0001%\u0001&\u0001"+
"&\u0003&\u01f6\b&\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001(\u0001"+
"(\u0001(\u0001(\u0001(\u0001)\u0001)\u0001)\u0001)\u0003)\u0206\b)\u0001"+
")\u0001)\u0001)\u0001)\u0001)\u0003)\u020d\b)\u0001)\u0003)\u0210\b)\u0001"+
")\u0001)\u0001*\u0001*\u0001+\u0001+\u0001,\u0001,\u0001-\u0001-\u0003"+
"-\u021c\b-\u0001.\u0001.\u0001/\u0001/\u0003/\u0222\b/\u0001/\u0005/\u0225"+
"\b/\n/\f/\u0228\t/\u0001/\u0003/\u022b\b/\u0001/\u0001/\u0003/\u022f\b"+
"/\u0001/\u0003/\u0232\b/\u00010\u00030\u0235\b0\u00010\u00010\u00010\u0005"+
"0\u023a\b0\n0\f0\u023d\t0\u00011\u00011\u00011\u00011\u00051\u0243\b1"+
"\n1\f1\u0246\t1\u00012\u00012\u00012\u00012\u00013\u00013\u00013\u0001"+
"4\u00014\u00034\u0251\b4\u00014\u00014\u00015\u00015\u00035\u0257\b5\u0001"+
"5\u00015\u00035\u025b\b5\u00015\u00015\u00015\u00016\u00016\u00016\u0001"+
"6\u00016\u00016\u00016\u00036\u0267\b6\u00017\u00017\u00017\u00017\u0001"+
"7\u00017\u00057\u026f\b7\n7\f7\u0272\t7\u00037\u0274\b7\u00018\u00018"+
"\u00019\u00019\u00039\u027a\b9\u0001:\u0001:\u0001:\u0005:\u027f\b:\n"+
":\f:\u0282\t:\u0001:\u0001:\u0001;\u0001;\u0001;\u0005;\u0289\b;\n;\f"+
";\u028c\t;\u0001;\u0001;\u0001<\u0001<\u0001=\u0001=\u0001=\u0001=\u0001"+
"=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0005=\u029d\b=\n=\f=\u02a0"+
"\t=\u0001>\u0001>\u0003>\u02a4\b>\u0001?\u0001?\u0001?\u0001?\u0001?\u0001"+
"?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0003"+
"?\u02b5\b?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001"+
"?\u0001?\u0001?\u0001?\u0001?\u0001?\u0003?\u02c5\b?\u0001?\u0001?\u0001"+
"?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001"+
"?\u0003?\u02d4\b?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001"+
"?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0003?\u02e6"+
"\b?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0003?\u02ee\b?\u0001?\u0001"+
"?\u0001?\u0001?\u0001?\u0005?\u02f5\b?\n?\f?\u02f8\t?\u0001@\u0001@\u0001"+
"A\u0001A\u0001A\u0001A\u0001A\u0003A\u0301\bA\u0001B\u0001B\u0001C\u0001"+
"C\u0001C\u0001C\u0001C\u0001C\u0001C\u0003C\u030c\bC\u0001C\u0001C\u0001"+
"C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001"+
"C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001"+
"C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001"+
"C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001"+
"C\u0001C\u0001C\u0001C\u0001C\u0003C\u033d\bC\u0001C\u0004C\u0340\bC\u000b"+
"C\fC\u0341\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001"+
"C\u0001C\u0001C\u0003C\u034f\bC\u0003C\u0351\bC\u0003C\u0353\bC\u0001"+
"C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001"+
"C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0005C\u0366\bC\nC\fC\u0369"+
"\tC\u0001D\u0001D\u0001D\u0001D\u0001D\u0001E\u0001E\u0001E\u0001F\u0001"+
"F\u0001G\u0001G\u0001H\u0001H\u0001I\u0001I\u0003I\u037b\bI\u0001I\u0001"+
"I\u0001I\u0003I\u0380\bI\u0001J\u0003J\u0383\bJ\u0001J\u0001J\u0001J\u0003"+
"J\u0388\bJ\u0003J\u038a\bJ\u0001K\u0003K\u038d\bK\u0001K\u0001K\u0003"+
"K\u0391\bK\u0001K\u0001K\u0003K\u0395\bK\u0001K\u0003K\u0398\bK\u0001"+
"K\u0003K\u039b\bK\u0001K\u0001K\u0003K\u039f\bK\u0001K\u0003K\u03a2\b"+
"K\u0001K\u0003K\u03a5\bK\u0001K\u0003K\u03a8\bK\u0001K\u0001K\u0003K\u03ac"+
"\bK\u0001K\u0003K\u03af\bK\u0001K\u0003K\u03b2\bK\u0001K\u0001K\u0003"+
"K\u03b6\bK\u0001K\u0003K\u03b9\bK\u0001K\u0003K\u03bc\bK\u0001K\u0003"+
"K\u03bf\bK\u0001K\u0001K\u0001K\u0001K\u0003K\u03c5\bK\u0001K\u0001K\u0003"+
"K\u03c9\bK\u0001K\u0003K\u03cc\bK\u0001K\u0001K\u0003K\u03d0\bK\u0001"+
"K\u0003K\u03d3\bK\u0001K\u0001K\u0003K\u03d7\bK\u0001K\u0001K\u0003K\u03db"+
"\bK\u0003K\u03dd\bK\u0001L\u0001L\u0001L\u0001L\u0001L\u0001L\u0001L\u0001"+
"L\u0001L\u0001L\u0001L\u0001L\u0001L\u0003L\u03ec\bL\u0001M\u0001M\u0003"+
"M\u03f0\bM\u0001N\u0001N\u0001N\u0003N\u03f5\bN\u0001N\u0001N\u0001O\u0001"+
"O\u0001O\u0001O\u0001O\u0003O\u03fe\bO\u0001P\u0001P\u0001P\u0003P\u0403"+
"\bP\u0001P\u0001P\u0001Q\u0001Q\u0001Q\u0001Q\u0001R\u0001R\u0001R\u0001"+
"R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0003R\u0415\bR\u0001S\u0001"+
"S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001T\u0003T\u041f\bT\u0001T\u0001"+
"T\u0001T\u0001T\u0001T\u0005T\u0426\bT\nT\fT\u0429\tT\u0003T\u042b\bT"+
"\u0001T\u0001T\u0001U\u0001U\u0001U\u0001U\u0001V\u0001V\u0001V\u0001"+
"V\u0001V\u0001V\u0005V\u0439\bV\nV\fV\u043c\tV\u0003V\u043e\bV\u0001V"+
"\u0001V\u0001W\u0001W\u0001W\u0001W\u0001X\u0001X\u0001X\u0001X\u0001"+
"X\u0003X\u044b\bX\u0003X\u044d\bX\u0001X\u0001X\u0001X\u0001X\u0005X\u0453"+
"\bX\nX\fX\u0456\tX\u0003X\u0458\bX\u0001X\u0001X\u0001Y\u0001Y\u0001Y"+
"\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0003Z\u0464\bZ\u0001[\u0001[\u0001"+
"[\u0001[\u0001[\u0005[\u046b\b[\n[\f[\u046e\t[\u0001[\u0001[\u0003[\u0472"+
"\b[\u0001\\\u0001\\\u0001]\u0001]\u0001^\u0001^\u0001_\u0001_\u0001`\u0001"+
"`\u0001a\u0001a\u0001b\u0001b\u0003b\u0482\bb\u0001c\u0001c\u0003c\u0486"+
"\bc\u0001d\u0001d\u0003d\u048a\bd\u0001e\u0001e\u0001f\u0001f\u0001f\u0003"+
"f\u0491\bf\u0001g\u0001g\u0001g\u0005g\u0496\bg\ng\fg\u0499\tg\u0001h"+
"\u0001h\u0003h\u049d\bh\u0001i\u0001i\u0001i\u0003i\u04a2\bi\u0001i\u0000"+
"\u0003z~\u0086j\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014"+
"\u0016\u0018\u001a\u001c\u001e \"$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfh"+
"jlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092"+
"\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa"+
"\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2"+
"\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u0000$\u0001\u0000\u0006"+
"\u0007\u0001\u0000)+\u0001\u0000/0\u0001\u000058\u0002\u0000\u0016\u0017"+
"FG\u0002\u0000*+HI\u0002\u0000))JJ\u0001\u0000KL\u0001\u0000NQ\u0001\u0000"+
";=\u0002\u000099>>\u0001\u0000RY\u0001\u0000^e\u0001\u0000hi\u0001\u0000"+
"jk\u0001\u0000rs\u0002\u000000~~\u0001\u0000\u007f\u0080\u0001\u0000u"+
"x\u0002\u0000hiyy\u0001\u0000\u0083\u0084\u0001\u0000\u0085\u0086\u0001"+
"\u0000\u0087\u0088\u0001\u0000\u008a\u008b\u0001\u0000\u008d\u008f\u0001"+
"\u0000\u0092\u0093\u0001\u0000<=\u0002\u0000\u001f\u001f&&\u0002\u0000"+
" ((\u000f\u0000\u0001\n\f\r\u0012\u0015\u0018\u0019\u001b\u001e#%)),"+
"EJMOgjswxz\u0086\u0089\u0096\u009a\u009c\u0013\u0000\u0013\u0013\u0015"+
"\u0015\u0018\u0019#%)),,.1339EKKRY^gllpsz\u0082\u0089\u008c\u008f\u0090"+
"\u0092\u0094\u009b\u009c\u0014\u0000\u0001\n\f\r\u0012\u0012\u0014\u0014"+
"\u001b\u001e--2248JJLMOQZ]jkmowx\u0083\u0086\u008d\u008e\u0091\u0091\u0095"+
"\u0096\u009a\u009a\u000b\u0000\u0002\u0002\u0012\u0012\u0014\u0014--/"+
"0::@@JJZ]jk\u009a\u009c\u0010\u0000\u0001\n\f\r\u0012\u0015\u0018\u0019"+
"\u001b\u001e#%)),EJMOgjswxz\u0086\u008a\u008b\u008d\u0096\u009a\u009c"+
"\u0002\u0000Z[\u009b\u009c\u0002\u0000\u009e\u009e\u00a3\u00a4\u050a\u0000"+
"\u00db\u0001\u0000\u0000\u0000\u0002\u00de\u0001\u0000\u0000\u0000\u0004"+
"\u00ee\u0001\u0000\u0000\u0000\u0006\u00f4\u0001\u0000\u0000\u0000\b\u00fe"+
"\u0001\u0000\u0000\u0000\n\u0108\u0001\u0000\u0000\u0000\f\u010a\u0001"+
"\u0000\u0000\u0000\u000e\u010d\u0001\u0000\u0000\u0000\u0010\u0119\u0001"+
"\u0000\u0000\u0000\u0012\u0124\u0001\u0000\u0000\u0000\u0014\u0131\u0001"+
"\u0000\u0000\u0000\u0016\u0140\u0001\u0000\u0000\u0000\u0018\u0144\u0001"+
"\u0000\u0000\u0000\u001a\u0147\u0001\u0000\u0000\u0000\u001c\u0153\u0001"+
"\u0000\u0000\u0000\u001e\u0168\u0001\u0000\u0000\u0000 \u016c\u0001\u0000"+
"\u0000\u0000\"\u016e\u0001\u0000\u0000\u0000$\u0170\u0001\u0000\u0000"+
"\u0000&\u0172\u0001\u0000\u0000\u0000(\u0179\u0001\u0000\u0000\u0000*"+
"\u0180\u0001\u0000\u0000\u0000,\u0185\u0001\u0000\u0000\u0000.\u0187\u0001"+
"\u0000\u0000\u00000\u018c\u0001\u0000\u0000\u00002\u0191\u0001\u0000\u0000"+
"\u00004\u019d\u0001\u0000\u0000\u00006\u01a0\u0001\u0000\u0000\u00008"+
"\u01af\u0001\u0000\u0000\u0000:\u01b1\u0001\u0000\u0000\u0000<\u01b9\u0001"+
"\u0000\u0000\u0000>\u01c1\u0001\u0000\u0000\u0000@\u01c3\u0001\u0000\u0000"+
"\u0000B\u01e1\u0001\u0000\u0000\u0000D\u01e4\u0001\u0000\u0000\u0000F"+
"\u01ec\u0001\u0000\u0000\u0000H\u01ee\u0001\u0000\u0000\u0000J\u01f1\u0001"+
"\u0000\u0000\u0000L\u01f5\u0001\u0000\u0000\u0000N\u01f7\u0001\u0000\u0000"+
"\u0000P\u01fc\u0001\u0000\u0000\u0000R\u0201\u0001\u0000\u0000\u0000T"+
"\u0213\u0001\u0000\u0000\u0000V\u0215\u0001\u0000\u0000\u0000X\u0217\u0001"+
"\u0000\u0000\u0000Z\u021b\u0001\u0000\u0000\u0000\\\u021d\u0001\u0000"+
"\u0000\u0000^\u021f\u0001\u0000\u0000\u0000`\u0234\u0001\u0000\u0000\u0000"+
"b\u023e\u0001\u0000\u0000\u0000d\u0247\u0001\u0000\u0000\u0000f\u024b"+
"\u0001\u0000\u0000\u0000h\u024e\u0001\u0000\u0000\u0000j\u0254\u0001\u0000"+
"\u0000\u0000l\u025f\u0001\u0000\u0000\u0000n\u0268\u0001\u0000\u0000\u0000"+
"p\u0275\u0001\u0000\u0000\u0000r\u0277\u0001\u0000\u0000\u0000t\u0280"+
"\u0001\u0000\u0000\u0000v\u028a\u0001\u0000\u0000\u0000x\u028f\u0001\u0000"+
"\u0000\u0000z\u0291\u0001\u0000\u0000\u0000|\u02a3\u0001\u0000\u0000\u0000"+
"~\u02c4\u0001\u0000\u0000\u0000\u0080\u02f9\u0001\u0000\u0000\u0000\u0082"+
"\u0300\u0001\u0000\u0000\u0000\u0084\u0302\u0001\u0000\u0000\u0000\u0086"+
"\u0352\u0001\u0000\u0000\u0000\u0088\u036a\u0001\u0000\u0000\u0000\u008a"+
"\u036f\u0001\u0000\u0000\u0000\u008c\u0372\u0001\u0000\u0000\u0000\u008e"+
"\u0374\u0001\u0000\u0000\u0000\u0090\u0376\u0001\u0000\u0000\u0000\u0092"+
"\u037f\u0001\u0000\u0000\u0000\u0094\u0389\u0001\u0000\u0000\u0000\u0096"+
"\u03dc\u0001\u0000\u0000\u0000\u0098\u03eb\u0001\u0000\u0000\u0000\u009a"+
"\u03ef\u0001\u0000\u0000\u0000\u009c\u03f1\u0001\u0000\u0000\u0000\u009e"+
"\u03fd\u0001\u0000\u0000\u0000\u00a0\u03ff\u0001\u0000\u0000\u0000\u00a2"+
"\u0406\u0001\u0000\u0000\u0000\u00a4\u0414\u0001\u0000\u0000\u0000\u00a6"+
"\u0416\u0001\u0000\u0000\u0000\u00a8\u041e\u0001\u0000\u0000\u0000\u00aa"+
"\u042e\u0001\u0000\u0000\u0000\u00ac\u0432\u0001\u0000\u0000\u0000\u00ae"+
"\u0441\u0001\u0000\u0000\u0000\u00b0\u044c\u0001\u0000\u0000\u0000\u00b2"+
"\u045b\u0001\u0000\u0000\u0000\u00b4\u045e\u0001\u0000\u0000\u0000\u00b6"+
"\u0465\u0001\u0000\u0000\u0000\u00b8\u0473\u0001\u0000\u0000\u0000\u00ba"+
"\u0475\u0001\u0000\u0000\u0000\u00bc\u0477\u0001\u0000\u0000\u0000\u00be"+
"\u0479\u0001\u0000\u0000\u0000\u00c0\u047b\u0001\u0000\u0000\u0000\u00c2"+
"\u047d\u0001\u0000\u0000\u0000\u00c4\u0481\u0001\u0000\u0000\u0000\u00c6"+
"\u0485\u0001\u0000\u0000\u0000\u00c8\u0489\u0001\u0000\u0000\u0000\u00ca"+
"\u048b\u0001\u0000\u0000\u0000\u00cc\u048d\u0001\u0000\u0000\u0000\u00ce"+
"\u0492\u0001\u0000\u0000\u0000\u00d0\u049a\u0001\u0000\u0000\u0000\u00d2"+
"\u04a1\u0001\u0000\u0000\u0000\u00d4\u00dc\u0003\u0006\u0003\u0000\u00d5"+
"\u00dc\u0003\b\u0004\u0000\u00d6\u00dc\u0003\u0010\b\u0000\u00d7\u00dc"+
"\u0003\u0012\t\u0000\u00d8\u00dc\u0003\u001a\r\u0000\u00d9\u00dc\u0003"+
"\u001c\u000e\u0000\u00da\u00dc\u0003\u000e\u0007\u0000\u00db\u00d4\u0001"+
"\u0000\u0000\u0000\u00db\u00d5\u0001\u0000\u0000\u0000\u00db\u00d6\u0001"+
"\u0000\u0000\u0000\u00db\u00d7\u0001\u0000\u0000\u0000\u00db\u00d8\u0001"+
"\u0000\u0000\u0000\u00db\u00d9\u0001\u0000\u0000\u0000\u00db\u00da\u0001"+
"\u0000\u0000\u0000\u00dc\u0001\u0001\u0000\u0000\u0000\u00dd\u00df\u0003"+
"\u0004\u0002\u0000\u00de\u00dd\u0001\u0000\u0000\u0000\u00de\u00df\u0001"+
"\u0000\u0000\u0000\u00df\u00e3\u0001\u0000\u0000\u0000\u00e0\u00e2\u0003"+
"\u0000\u0000\u0000\u00e1\u00e0\u0001\u0000\u0000\u0000\u00e2\u00e5\u0001"+
"\u0000\u0000\u0000\u00e3\u00e1\u0001\u0000\u0000\u0000\u00e3\u00e4\u0001"+
"\u0000\u0000\u0000\u00e4\u00e9\u0001\u0000\u0000\u0000\u00e5\u00e3\u0001"+
"\u0000\u0000\u0000\u00e6\u00e8\u00038\u001c\u0000\u00e7\u00e6\u0001\u0000"+
"\u0000\u0000\u00e8\u00eb\u0001\u0000\u0000\u0000\u00e9\u00e7\u0001\u0000"+
"\u0000\u0000\u00e9\u00ea\u0001\u0000\u0000\u0000\u00ea\u00ec\u0001\u0000"+
"\u0000\u0000\u00eb\u00e9\u0001\u0000\u0000\u0000\u00ec\u00ed\u0005\u0000"+
"\u0000\u0001\u00ed\u0003\u0001\u0000\u0000\u0000\u00ee\u00ef\u0005\u0001"+
"\u0000\u0000\u00ef\u00f2\u0003t:\u0000\u00f0\u00f1\u0005\u0002\u0000\u0000"+
"\u00f1\u00f3\u0003$\u0012\u0000\u00f2\u00f0\u0001\u0000\u0000\u0000\u00f2"+
"\u00f3\u0001\u0000\u0000\u0000\u00f3\u0005\u0001\u0000\u0000\u0000\u00f4"+
"\u00f5\u0005\u0003\u0000\u0000\u00f5\u00f8\u0003t:\u0000\u00f6\u00f7\u0005"+
"\u0002\u0000\u0000\u00f7\u00f9\u0003$\u0012\u0000\u00f8\u00f6\u0001\u0000"+
"\u0000\u0000\u00f8\u00f9\u0001\u0000\u0000\u0000\u00f9\u00fc\u0001\u0000"+
"\u0000\u0000\u00fa\u00fb\u0005\u0004\u0000\u0000\u00fb\u00fd\u0003\n\u0005"+
"\u0000\u00fc\u00fa\u0001\u0000\u0000\u0000\u00fc\u00fd\u0001\u0000\u0000"+
"\u0000\u00fd\u0007\u0001\u0000\u0000\u0000\u00fe\u00ff\u0005\u0005\u0000"+
"\u0000\u00ff\u0102\u0003t:\u0000\u0100\u0101\u0005\u0002\u0000\u0000\u0101"+
"\u0103\u0003$\u0012\u0000\u0102\u0100\u0001\u0000\u0000\u0000\u0102\u0103"+
"\u0001\u0000\u0000\u0000\u0103\u0106\u0001\u0000\u0000\u0000\u0104\u0105"+
"\u0005\u0004\u0000\u0000\u0105\u0107\u0003\n\u0005\u0000\u0106\u0104\u0001"+
"\u0000\u0000\u0000\u0106\u0107\u0001\u0000\u0000\u0000\u0107\t\u0001\u0000"+
"\u0000\u0000\u0108\u0109\u0003\u00cae\u0000\u0109\u000b\u0001\u0000\u0000"+
"\u0000\u010a\u010b\u0007\u0000\u0000\u0000\u010b\r\u0001\u0000\u0000\u0000"+
"\u010c\u010e\u0003\f\u0006\u0000\u010d\u010c\u0001\u0000\u0000\u0000\u010d"+
"\u010e\u0001\u0000\u0000\u0000\u010e\u010f\u0001\u0000\u0000\u0000\u010f"+
"\u0110\u0005\b\u0000\u0000\u0110\u0112\u0003\u00cae\u0000\u0111\u0113"+
"\u0003(\u0014\u0000\u0112\u0111\u0001\u0000\u0000\u0000\u0112\u0113\u0001"+
"\u0000\u0000\u0000\u0113\u0116\u0001\u0000\u0000\u0000\u0114\u0115\u0005"+
"\t\u0000\u0000\u0115\u0117\u0003~?\u0000\u0116\u0114\u0001\u0000\u0000"+
"\u0000\u0116\u0117\u0001\u0000\u0000\u0000\u0117\u000f\u0001\u0000\u0000"+
"\u0000\u0118\u011a\u0003\f\u0006\u0000\u0119\u0118\u0001\u0000\u0000\u0000"+
"\u0119\u011a\u0001\u0000\u0000\u0000\u011a\u011b\u0001\u0000\u0000\u0000"+
"\u011b\u011c\u0005\n\u0000\u0000\u011c\u011d\u0003\u00cae\u0000\u011d"+
"\u011e\u0005\u000b\u0000\u0000\u011e\u0121\u0003 \u0010\u0000\u011f\u0120"+
"\u0005\u0002\u0000\u0000\u0120\u0122\u0003$\u0012\u0000\u0121\u011f\u0001"+
"\u0000\u0000\u0000\u0121\u0122\u0001\u0000\u0000\u0000\u0122\u0011\u0001"+
"\u0000\u0000\u0000\u0123\u0125\u0003\f\u0006\u0000\u0124\u0123\u0001\u0000"+
"\u0000\u0000\u0124\u0125\u0001\u0000\u0000\u0000\u0125\u0126\u0001\u0000"+
"\u0000\u0000\u0126\u0127\u0005\f\u0000\u0000\u0127\u0128\u0003\u00cae"+
"\u0000\u0128\u0129\u0005\u000b\u0000\u0000\u0129\u012c\u0003\"\u0011\u0000"+
"\u012a\u012b\u0005\u0002\u0000\u0000\u012b\u012d\u0003$\u0012\u0000\u012c"+
"\u012a\u0001\u0000\u0000\u0000\u012c\u012d\u0001\u0000\u0000\u0000\u012d"+
"\u012f\u0001\u0000\u0000\u0000\u012e\u0130\u0003\u0014\n\u0000\u012f\u012e"+
"\u0001\u0000\u0000\u0000\u012f\u0130\u0001\u0000\u0000\u0000\u0130\u0013"+
"\u0001\u0000\u0000\u0000\u0131\u0132\u0005\r\u0000\u0000\u0132\u0133\u0005"+
"\u000e\u0000\u0000\u0133\u0138\u0003\u0016\u000b\u0000\u0134\u0135\u0005"+
"\u000f\u0000\u0000\u0135\u0137\u0003\u0016\u000b\u0000\u0136\u0134\u0001"+
"\u0000\u0000\u0000\u0137\u013a\u0001\u0000\u0000\u0000\u0138\u0136\u0001"+
"\u0000\u0000\u0000\u0138\u0139\u0001\u0000\u0000\u0000\u0139\u013b\u0001"+
"\u0000\u0000\u0000\u013a\u0138\u0001\u0000\u0000\u0000\u013b\u013c\u0005"+
"\u0010\u0000\u0000\u013c\u0015\u0001\u0000\u0000\u0000\u013d\u013e\u0003"+
"\u0018\f\u0000\u013e\u013f\u0005\u0011\u0000\u0000\u013f\u0141\u0001\u0000"+
"\u0000\u0000\u0140\u013d\u0001\u0000\u0000\u0000\u0140\u0141\u0001\u0000"+
"\u0000\u0000\u0141\u0142\u0001\u0000\u0000\u0000\u0142\u0143\u0003\u00ca"+
"e\u0000\u0143\u0017\u0001\u0000\u0000\u0000\u0144\u0145\u0003\u00cae\u0000"+
"\u0145\u0019\u0001\u0000\u0000\u0000\u0146\u0148\u0003\f\u0006\u0000\u0147"+
"\u0146\u0001\u0000\u0000\u0000\u0147\u0148\u0001\u0000\u0000\u0000\u0148"+
"\u0149\u0001\u0000\u0000\u0000\u0149\u014a\u0005\u0012\u0000\u0000\u014a"+
"\u014b\u0003\u00cae\u0000\u014b\u014c\u0005\u000b\u0000\u0000\u014c\u014d"+
"\u0003&\u0013\u0000\u014d\u014e\u0005\u0013\u0000\u0000\u014e\u0150\u0003"+
"\u0016\u000b\u0000\u014f\u0151\u0003\u00b2Y\u0000\u0150\u014f\u0001\u0000"+
"\u0000\u0000\u0150\u0151\u0001\u0000\u0000\u0000\u0151\u001b\u0001\u0000"+
"\u0000\u0000\u0152\u0154\u0003\f\u0006\u0000\u0153\u0152\u0001\u0000\u0000"+
"\u0000\u0153\u0154\u0001\u0000\u0000\u0000\u0154\u0155\u0001\u0000\u0000"+
"\u0000\u0155\u0156\u0005\u0014\u0000\u0000\u0156\u0157\u0003\u00cae\u0000"+
"\u0157\u0158\u0005\u000b\u0000\u0000\u0158\u0159\u0005\u000e\u0000\u0000"+
"\u0159\u015e\u0003\u001e\u000f\u0000\u015a\u015b\u0005\u000f\u0000\u0000"+
"\u015b\u015d\u0003\u001e\u000f\u0000\u015c\u015a\u0001\u0000\u0000\u0000"+
"\u015d\u0160\u0001\u0000\u0000\u0000\u015e\u015c\u0001\u0000\u0000\u0000"+
"\u015e\u015f\u0001\u0000\u0000\u0000\u015f\u0161\u0001\u0000\u0000\u0000"+
"\u0160\u015e\u0001\u0000\u0000\u0000\u0161\u0163\u0005\u0010\u0000\u0000"+
"\u0162\u0164\u0003\u00b2Y\u0000\u0163\u0162\u0001\u0000\u0000\u0000\u0163"+
"\u0164\u0001\u0000\u0000\u0000\u0164\u001d\u0001\u0000\u0000\u0000\u0165"+
"\u0166\u0003\u0018\f\u0000\u0166\u0167\u0005\u0011\u0000\u0000\u0167\u0169"+
"\u0001\u0000\u0000\u0000\u0168\u0165\u0001\u0000\u0000\u0000\u0168\u0169"+
"\u0001\u0000\u0000\u0000\u0169\u016a\u0001\u0000\u0000\u0000\u016a\u016b"+
"\u0003\u00cae\u0000\u016b\u001f\u0001\u0000\u0000\u0000\u016c\u016d\u0005"+
"\u00a5\u0000\u0000\u016d!\u0001\u0000\u0000\u0000\u016e\u016f\u0005\u00a5"+
"\u0000\u0000\u016f#\u0001\u0000\u0000\u0000\u0170\u0171\u0005\u00a5\u0000"+
"\u0000\u0171%\u0001\u0000\u0000\u0000\u0172\u0173\u0005\u00a5\u0000\u0000"+
"\u0173\'\u0001\u0000\u0000\u0000\u0174\u017a\u0003*\u0015\u0000\u0175"+
"\u017a\u0003.\u0017\u0000\u0176\u017a\u00030\u0018\u0000\u0177\u017a\u0003"+
"2\u0019\u0000\u0178\u017a\u00036\u001b\u0000\u0179\u0174\u0001\u0000\u0000"+
"\u0000\u0179\u0175\u0001\u0000\u0000\u0000\u0179\u0176\u0001\u0000\u0000"+
"\u0000\u0179\u0177\u0001\u0000\u0000\u0000\u0179\u0178\u0001\u0000\u0000"+
"\u0000\u017a)\u0001\u0000\u0000\u0000\u017b\u017c\u0003\\.\u0000\u017c"+
"\u017d\u0005\u0011\u0000\u0000\u017d\u017f\u0001\u0000\u0000\u0000\u017e"+
"\u017b\u0001\u0000\u0000\u0000\u017f\u0182\u0001\u0000\u0000\u0000\u0180"+
"\u017e\u0001\u0000\u0000\u0000\u0180\u0181\u0001\u0000\u0000\u0000\u0181"+
"\u0183\u0001\u0000\u0000\u0000\u0182\u0180\u0001\u0000\u0000\u0000\u0183"+
"\u0184\u0003\u00c6c\u0000\u0184+\u0001\u0000\u0000\u0000\u0185\u0186\u0003"+
"\u00cae\u0000\u0186-\u0001\u0000\u0000\u0000\u0187\u0188\u0005\u0015\u0000"+
"\u0000\u0188\u0189\u0005\u0016\u0000\u0000\u0189\u018a\u0003(\u0014\u0000"+
"\u018a\u018b\u0005\u0017\u0000\u0000\u018b/\u0001\u0000\u0000\u0000\u018c"+
"\u018d\u0005\u0018\u0000\u0000\u018d\u018e\u0005\u0016\u0000\u0000\u018e"+
"\u018f\u0003(\u0014\u0000\u018f\u0190\u0005\u0017\u0000\u0000\u01901\u0001"+
"\u0000\u0000\u0000\u0191\u0192\u0005\u0019\u0000\u0000\u0192\u0193\u0005"+
"\u000e\u0000\u0000\u0193\u0198\u00034\u001a\u0000\u0194\u0195\u0005\u000f"+
"\u0000\u0000\u0195\u0197\u00034\u001a\u0000\u0196\u0194\u0001\u0000\u0000"+
"\u0000\u0197\u019a\u0001\u0000\u0000\u0000\u0198\u0196\u0001\u0000\u0000"+
"\u0000\u0198\u0199\u0001\u0000\u0000\u0000\u0199\u019b\u0001\u0000\u0000"+
"\u0000\u019a\u0198\u0001\u0000\u0000\u0000\u019b\u019c\u0005\u0010\u0000"+
"\u0000\u019c3\u0001\u0000\u0000\u0000\u019d\u019e\u0003\u00c4b\u0000\u019e"+
"\u019f\u0003(\u0014\u0000\u019f5\u0001\u0000\u0000\u0000\u01a0\u01a1\u0005"+
"\u001a\u0000\u0000\u01a1\u01a2\u0005\u0016\u0000\u0000\u01a2\u01a7\u0003"+
"(\u0014\u0000\u01a3\u01a4\u0005\u000f\u0000\u0000\u01a4\u01a6\u0003(\u0014"+
"\u0000\u01a5\u01a3\u0001\u0000\u0000\u0000\u01a6\u01a9\u0001\u0000\u0000"+
"\u0000\u01a7\u01a5\u0001\u0000\u0000\u0000\u01a7\u01a8\u0001\u0000\u0000"+
"\u0000\u01a8\u01aa\u0001\u0000\u0000\u0000\u01a9\u01a7\u0001\u0000\u0000"+
"\u0000\u01aa\u01ab\u0005\u0017\u0000\u0000\u01ab7\u0001\u0000\u0000\u0000"+
"\u01ac\u01b0\u0003:\u001d\u0000\u01ad\u01b0\u0003<\u001e\u0000\u01ae\u01b0"+
"\u0003@ \u0000\u01af\u01ac\u0001\u0000\u0000\u0000\u01af\u01ad\u0001\u0000"+
"\u0000\u0000\u01af\u01ae\u0001\u0000\u0000\u0000\u01b09\u0001\u0000\u0000"+
"\u0000\u01b1\u01b3\u0005\u001b\u0000\u0000\u01b2\u01b4\u0003\f\u0006\u0000"+
"\u01b3\u01b2\u0001\u0000\u0000\u0000\u01b3\u01b4\u0001\u0000\u0000\u0000"+
"\u01b4\u01b5\u0001\u0000\u0000\u0000\u01b5\u01b6\u0003\u00cae\u0000\u01b6"+
"\u01b7\u0005\u000b\u0000\u0000\u01b7\u01b8\u0003~?\u0000\u01b8;\u0001"+
"\u0000\u0000\u0000\u01b9\u01bd\u0005\u001c\u0000\u0000\u01ba\u01bb\u0003"+
",\u0016\u0000\u01bb\u01bc\u0005\u0011\u0000\u0000\u01bc\u01be\u0001\u0000"+
"\u0000\u0000\u01bd\u01ba\u0001\u0000\u0000\u0000\u01bd\u01be\u0001\u0000"+
"\u0000\u0000\u01be\u01bf\u0001\u0000\u0000\u0000\u01bf\u01c0\u0003\u00ca"+
"e\u0000\u01c0=\u0001\u0000\u0000\u0000\u01c1\u01c2\u0005\u001d\u0000\u0000"+
"\u01c2?\u0001\u0000\u0000\u0000\u01c3\u01c5\u0005\u001b\u0000\u0000\u01c4"+
"\u01c6\u0003\f\u0006\u0000\u01c5\u01c4\u0001\u0000\u0000\u0000\u01c5\u01c6"+
"\u0001\u0000\u0000\u0000\u01c6\u01c8\u0001\u0000\u0000\u0000\u01c7\u01c9"+
"\u0003>\u001f\u0000\u01c8\u01c7\u0001\u0000\u0000\u0000\u01c8\u01c9\u0001"+
"\u0000\u0000\u0000\u01c9\u01ca\u0001\u0000\u0000\u0000\u01ca\u01cb\u0005"+
"\u001e\u0000\u0000\u01cb\u01cc\u0003\u00c8d\u0000\u01cc\u01d5\u0005\u001f"+
"\u0000\u0000\u01cd\u01d2\u0003B!\u0000\u01ce\u01cf\u0005\u000f\u0000\u0000"+
"\u01cf\u01d1\u0003B!\u0000\u01d0\u01ce\u0001\u0000\u0000\u0000\u01d1\u01d4"+
"\u0001\u0000\u0000\u0000\u01d2\u01d0\u0001\u0000\u0000\u0000\u01d2\u01d3"+
"\u0001\u0000\u0000\u0000\u01d3\u01d6\u0001\u0000\u0000\u0000\u01d4\u01d2"+
"\u0001\u0000\u0000\u0000\u01d5\u01cd\u0001\u0000\u0000\u0000\u01d5\u01d6"+
"\u0001\u0000\u0000\u0000\u01d6\u01d7\u0001\u0000\u0000\u0000\u01d7\u01da"+
"\u0005 \u0000\u0000\u01d8\u01d9\u0005!\u0000\u0000\u01d9\u01db\u0003("+
"\u0014\u0000\u01da\u01d8\u0001\u0000\u0000\u0000\u01da\u01db\u0001\u0000"+
"\u0000\u0000\u01db\u01dc\u0001\u0000\u0000\u0000\u01dc\u01df\u0005\u000b"+
"\u0000\u0000\u01dd\u01e0\u0003D\"\u0000\u01de\u01e0\u0005\"\u0000\u0000"+
"\u01df\u01dd\u0001\u0000\u0000\u0000\u01df\u01de\u0001\u0000\u0000\u0000"+
"\u01e0A\u0001\u0000\u0000\u0000\u01e1\u01e2\u0003\u00c4b\u0000\u01e2\u01e3"+
"\u0003(\u0014\u0000\u01e3C\u0001\u0000\u0000\u0000\u01e4\u01e5\u0003~"+
"?\u0000\u01e5E\u0001\u0000\u0000\u0000\u01e6\u01ed\u0003R)\u0000\u01e7"+
"\u01ed\u0003v;\u0000\u01e8\u01e9\u0005\u001f\u0000\u0000\u01e9\u01ea\u0003"+
"~?\u0000\u01ea\u01eb\u0005 \u0000\u0000\u01eb\u01ed\u0001\u0000\u0000"+
"\u0000\u01ec\u01e6\u0001\u0000\u0000\u0000\u01ec\u01e7\u0001\u0000\u0000"+
"\u0000\u01ec\u01e8\u0001\u0000\u0000\u0000\u01edG\u0001\u0000\u0000\u0000"+
"\u01ee\u01ef\u0003F#\u0000\u01ef\u01f0\u0003J%\u0000\u01f0I\u0001\u0000"+
"\u0000\u0000\u01f1\u01f2\u0003\u00cae\u0000\u01f2K\u0001\u0000\u0000\u0000"+
"\u01f3\u01f6\u0003N\'\u0000\u01f4\u01f6\u0003P(\u0000\u01f5\u01f3\u0001"+
"\u0000\u0000\u0000\u01f5\u01f4\u0001\u0000\u0000\u0000\u01f6M\u0001\u0000"+
"\u0000\u0000\u01f7\u01f8\u0005#\u0000\u0000\u01f8\u01f9\u0003H$\u0000"+
"\u01f9\u01fa\u0005$\u0000\u0000\u01fa\u01fb\u0003~?\u0000\u01fbO\u0001"+
"\u0000\u0000\u0000\u01fc\u01fd\u0005%\u0000\u0000\u01fd\u01fe\u0003H$"+
"\u0000\u01fe\u01ff\u0005$\u0000\u0000\u01ff\u0200\u0003~?\u0000\u0200"+
"Q\u0001\u0000\u0000\u0000\u0201\u0205\u0005&\u0000\u0000\u0202\u0203\u0003"+
"T*\u0000\u0203\u0204\u0005\'\u0000\u0000\u0204\u0206\u0001\u0000\u0000"+
"\u0000\u0205\u0202\u0001\u0000\u0000\u0000\u0205\u0206\u0001\u0000\u0000"+
"\u0000\u0206\u0207\u0001\u0000\u0000\u0000\u0207\u020f\u0003*\u0015\u0000"+
"\u0208\u020c\u0005\u000b\u0000\u0000\u0209\u020a\u0003V+\u0000\u020a\u020b"+
"\u0003X,\u0000\u020b\u020d\u0001\u0000\u0000\u0000\u020c\u0209\u0001\u0000"+
"\u0000\u0000\u020c\u020d\u0001\u0000\u0000\u0000\u020d\u020e\u0001\u0000"+
"\u0000\u0000\u020e\u0210\u0003Z-\u0000\u020f\u0208\u0001\u0000\u0000\u0000"+
"\u020f\u0210\u0001\u0000\u0000\u0000\u0210\u0211\u0001\u0000\u0000\u0000"+
"\u0211\u0212\u0005(\u0000\u0000\u0212S\u0001\u0000\u0000\u0000\u0213\u0214"+
"\u0003v;\u0000\u0214U\u0001\u0000\u0000\u0000\u0215\u0216\u0003z=\u0000"+
"\u0216W\u0001\u0000\u0000\u0000\u0217\u0218\u0007\u0001\u0000\u0000\u0218"+
"Y\u0001\u0000\u0000\u0000\u0219\u021c\u0003v;\u0000\u021a\u021c\u0003"+
"~?\u0000\u021b\u0219\u0001\u0000\u0000\u0000\u021b\u021a\u0001\u0000\u0000"+
"\u0000\u021c[\u0001\u0000\u0000\u0000\u021d\u021e\u0003\u00cae\u0000\u021e"+
"]\u0001\u0000\u0000\u0000\u021f\u0221\u0003`0\u0000\u0220\u0222\u0003"+
"b1\u0000\u0221\u0220\u0001\u0000\u0000\u0000\u0221\u0222\u0001\u0000\u0000"+
"\u0000\u0222\u0226\u0001\u0000\u0000\u0000\u0223\u0225\u0003L&\u0000\u0224"+
"\u0223\u0001\u0000\u0000\u0000\u0225\u0228\u0001\u0000\u0000\u0000\u0226"+
"\u0224\u0001\u0000\u0000\u0000\u0226\u0227\u0001\u0000\u0000\u0000\u0227"+
"\u022a\u0001\u0000\u0000\u0000\u0228\u0226\u0001\u0000\u0000\u0000\u0229"+
"\u022b\u0003f3\u0000\u022a\u0229\u0001\u0000\u0000\u0000\u022a\u022b\u0001"+
"\u0000\u0000\u0000\u022b\u022e\u0001\u0000\u0000\u0000\u022c\u022f\u0003"+
"j5\u0000\u022d\u022f\u0003h4\u0000\u022e\u022c\u0001\u0000\u0000\u0000"+
"\u022e\u022d\u0001\u0000\u0000\u0000\u022e\u022f\u0001\u0000\u0000\u0000"+
"\u022f\u0231\u0001\u0000\u0000\u0000\u0230\u0232\u0003n7\u0000\u0231\u0230"+
"\u0001\u0000\u0000\u0000\u0231\u0232\u0001\u0000\u0000\u0000\u0232_\u0001"+
"\u0000\u0000\u0000\u0233\u0235\u0005\u0013\u0000\u0000\u0234\u0233\u0001"+
"\u0000\u0000\u0000\u0234\u0235\u0001\u0000\u0000\u0000\u0235\u0236\u0001"+
"\u0000\u0000\u0000\u0236\u023b\u0003H$\u0000\u0237\u0238\u0005\u000f\u0000"+
"\u0000\u0238\u023a\u0003H$\u0000\u0239\u0237\u0001\u0000\u0000\u0000\u023a"+
"\u023d\u0001\u0000\u0000\u0000\u023b\u0239\u0001\u0000\u0000\u0000\u023b"+
"\u023c\u0001\u0000\u0000\u0000\u023ca\u0001\u0000\u0000\u0000\u023d\u023b"+
"\u0001\u0000\u0000\u0000\u023e\u023f\u0005,\u0000\u0000\u023f\u0244\u0003"+
"d2\u0000\u0240\u0241\u0005\u000f\u0000\u0000\u0241\u0243\u0003d2\u0000"+
"\u0242\u0240\u0001\u0000\u0000\u0000\u0243\u0246\u0001\u0000\u0000\u0000"+
"\u0244\u0242\u0001\u0000\u0000\u0000\u0244\u0245\u0001\u0000\u0000\u0000"+
"\u0245c\u0001\u0000\u0000\u0000\u0246\u0244\u0001\u0000\u0000\u0000\u0247"+
"\u0248\u0003\u00cae\u0000\u0248\u0249\u0005\u000b\u0000\u0000\u0249\u024a"+
"\u0003~?\u0000\u024ae\u0001\u0000\u0000\u0000\u024b\u024c\u0005-\u0000"+
"\u0000\u024c\u024d\u0003~?\u0000\u024dg\u0001\u0000\u0000\u0000\u024e"+
"\u0250\u0005.\u0000\u0000\u024f\u0251\u0007\u0002\u0000\u0000\u0250\u024f"+
"\u0001\u0000\u0000\u0000\u0250\u0251\u0001\u0000\u0000\u0000\u0251\u0252"+
"\u0001\u0000\u0000\u0000\u0252\u0253\u0003~?\u0000\u0253i\u0001\u0000"+
"\u0000\u0000\u0254\u0256\u00051\u0000\u0000\u0255\u0257\u0007\u0002\u0000"+
"\u0000\u0256\u0255\u0001\u0000\u0000\u0000\u0256\u0257\u0001\u0000\u0000"+
"\u0000\u0257\u0258\u0001\u0000\u0000\u0000\u0258\u025a\u0003\u00cae\u0000"+
"\u0259\u025b\u0003l6\u0000\u025a\u0259\u0001\u0000\u0000\u0000\u025a\u025b"+
"\u0001\u0000\u0000\u0000\u025b\u025c\u0001\u0000\u0000\u0000\u025c\u025d"+
"\u0005\u000b\u0000\u0000\u025d\u025e\u0003~?\u0000\u025ek\u0001\u0000"+
"\u0000\u0000\u025f\u0266\u00052\u0000\u0000\u0260\u0267\u0003|>\u0000"+
"\u0261\u0267\u0003\u00d0h\u0000\u0262\u0263\u0005\u001f\u0000\u0000\u0263"+
"\u0264\u0003~?\u0000\u0264\u0265\u0005 \u0000\u0000\u0265\u0267\u0001"+
"\u0000\u0000\u0000\u0266\u0260\u0001\u0000\u0000\u0000\u0266\u0261\u0001"+
"\u0000\u0000\u0000\u0266\u0262\u0001\u0000\u0000\u0000\u0267m\u0001\u0000"+
"\u0000\u0000\u0268\u0273\u00053\u0000\u0000\u0269\u0274\u0003p8\u0000"+
"\u026a\u026b\u00054\u0000\u0000\u026b\u0270\u0003r9\u0000\u026c\u026d"+
"\u0005\u000f\u0000\u0000\u026d\u026f\u0003r9\u0000\u026e\u026c\u0001\u0000"+
"\u0000\u0000\u026f\u0272\u0001\u0000\u0000\u0000\u0270\u026e\u0001\u0000"+
"\u0000\u0000\u0270\u0271\u0001\u0000\u0000\u0000\u0271\u0274\u0001\u0000"+
"\u0000\u0000\u0272\u0270\u0001\u0000\u0000\u0000\u0273\u0269\u0001\u0000"+
"\u0000\u0000\u0273\u026a\u0001\u0000\u0000\u0000\u0274o\u0001\u0000\u0000"+
"\u0000\u0275\u0276\u0007\u0003\u0000\u0000\u0276q\u0001\u0000\u0000\u0000"+
"\u0277\u0279\u0003\u0086C\u0000\u0278\u027a\u0003p8\u0000\u0279\u0278"+
"\u0001\u0000\u0000\u0000\u0279\u027a\u0001\u0000\u0000\u0000\u027as\u0001"+
"\u0000\u0000\u0000\u027b\u027c\u0003\\.\u0000\u027c\u027d\u0005\u0011"+
"\u0000\u0000\u027d\u027f\u0001\u0000\u0000\u0000\u027e\u027b\u0001\u0000"+
"\u0000\u0000\u027f\u0282\u0001\u0000\u0000\u0000\u0280\u027e\u0001\u0000"+
"\u0000\u0000\u0280\u0281\u0001\u0000\u0000\u0000\u0281\u0283\u0001\u0000"+
"\u0000\u0000\u0282\u0280\u0001\u0000\u0000\u0000\u0283\u0284\u0003\u00ca"+
"e\u0000\u0284u\u0001\u0000\u0000\u0000\u0285\u0286\u0003x<\u0000\u0286"+
"\u0287\u0005\u0011\u0000\u0000\u0287\u0289\u0001\u0000\u0000\u0000\u0288"+
"\u0285\u0001\u0000\u0000\u0000\u0289\u028c\u0001\u0000\u0000\u0000\u028a"+
"\u0288\u0001\u0000\u0000\u0000\u028a\u028b\u0001\u0000\u0000\u0000\u028b"+
"\u028d\u0001\u0000\u0000\u0000\u028c\u028a\u0001\u0000\u0000\u0000\u028d"+
"\u028e\u0003\u00c4b\u0000\u028ew\u0001\u0000\u0000\u0000\u028f\u0290\u0003"+
"\u00c4b\u0000\u0290y\u0001\u0000\u0000\u0000\u0291\u0292\u0006=\uffff"+
"\uffff\u0000\u0292\u0293\u0003\u00c4b\u0000\u0293\u029e\u0001\u0000\u0000"+
"\u0000\u0294\u0295\n\u0002\u0000\u0000\u0295\u0296\u0005\u0011\u0000\u0000"+
"\u0296\u029d\u0003\u00c4b\u0000\u0297\u0298\n\u0001\u0000\u0000\u0298"+
"\u0299\u0005&\u0000\u0000\u0299\u029a\u0003|>\u0000\u029a\u029b\u0005"+
"(\u0000\u0000\u029b\u029d\u0001\u0000\u0000\u0000\u029c\u0294\u0001\u0000"+
"\u0000\u0000\u029c\u0297\u0001\u0000\u0000\u0000\u029d\u02a0\u0001\u0000"+
"\u0000\u0000\u029e\u029c\u0001\u0000\u0000\u0000\u029e\u029f\u0001\u0000"+
"\u0000\u0000\u029f{\u0001\u0000\u0000\u0000\u02a0\u029e\u0001\u0000\u0000"+
"\u0000\u02a1\u02a4\u0005\u00a5\u0000\u0000\u02a2\u02a4\u0005\u00a6\u0000"+
"\u0000\u02a3\u02a1\u0001\u0000\u0000\u0000\u02a3\u02a2\u0001\u0000\u0000"+
"\u0000\u02a4}\u0001\u0000\u0000\u0000\u02a5\u02a6\u0006?\uffff\uffff\u0000"+
"\u02a6\u02c5\u0003\u0086C\u0000\u02a7\u02c5\u0003R)\u0000\u02a8\u02c5"+
"\u0003^/\u0000\u02a9\u02aa\u0005?\u0000\u0000\u02aa\u02ab\u0003~?\u0000"+
"\u02ab\u02ac\u0005>\u0000\u0000\u02ac\u02ad\u0003(\u0014\u0000\u02ad\u02c5"+
"\u0001\u0000\u0000\u0000\u02ae\u02af\u0005:\u0000\u0000\u02af\u02c5\u0003"+
"~?\r\u02b0\u02b1\u0005@\u0000\u0000\u02b1\u02c5\u0003~?\f\u02b2\u02b3"+
"\u0005D\u0000\u0000\u02b3\u02b5\u0005)\u0000\u0000\u02b4\u02b2\u0001\u0000"+
"\u0000\u0000\u02b4\u02b5\u0001\u0000\u0000\u0000\u02b5\u02b6\u0001\u0000"+
"\u0000\u0000\u02b6\u02b7\u0003\u0084B\u0000\u02b7\u02b8\u0005B\u0000\u0000"+
"\u02b8\u02b9\u0003\u0086C\u0000\u02b9\u02ba\u0005C\u0000\u0000\u02ba\u02bb"+
"\u0003\u0086C\u0000\u02bb\u02c5\u0001\u0000\u0000\u0000\u02bc\u02bd\u0005"+
"E\u0000\u0000\u02bd\u02be\u0005)\u0000\u0000\u02be\u02bf\u0003\u0084B"+
"\u0000\u02bf\u02c0\u0005B\u0000\u0000\u02c0\u02c1\u0003\u0086C\u0000\u02c1"+
"\u02c2\u0005C\u0000\u0000\u02c2\u02c3\u0003\u0086C\u0000\u02c3\u02c5\u0001"+
"\u0000\u0000\u0000\u02c4\u02a5\u0001\u0000\u0000\u0000\u02c4\u02a7\u0001"+
"\u0000\u0000\u0000\u02c4\u02a8\u0001\u0000\u0000\u0000\u02c4\u02a9\u0001"+
"\u0000\u0000\u0000\u02c4\u02ae\u0001\u0000\u0000\u0000\u02c4\u02b0\u0001"+
"\u0000\u0000\u0000\u02c4\u02b4\u0001\u0000\u0000\u0000\u02c4\u02bc\u0001"+
"\u0000\u0000\u0000\u02c5\u02f6\u0001\u0000\u0000\u0000\u02c6\u02c7\n\b"+
"\u0000\u0000\u02c7\u02c8\u0007\u0004\u0000\u0000\u02c8\u02f5\u0003~?\t"+
"\u02c9\u02ca\n\u0007\u0000\u0000\u02ca\u02cb\u0003\u0096K\u0000\u02cb"+
"\u02cc\u0003~?\b\u02cc\u02f5\u0001\u0000\u0000\u0000\u02cd\u02ce\n\u0006"+
"\u0000\u0000\u02ce\u02cf\u0007\u0005\u0000\u0000\u02cf\u02f5\u0003~?\u0007"+
"\u02d0\u02d1\n\u0005\u0000\u0000\u02d1\u02d3\u0007\u0006\u0000\u0000\u02d2"+
"\u02d4\u0003\u008aE\u0000\u02d3\u02d2\u0001\u0000\u0000\u0000\u02d3\u02d4"+
"\u0001\u0000\u0000\u0000\u02d4\u02d5\u0001\u0000\u0000\u0000\u02d5\u02f5"+
"\u0003~?\u0006\u02d6\u02d7\n\u0004\u0000\u0000\u02d7\u02d8\u0005C\u0000"+
"\u0000\u02d8\u02f5\u0003~?\u0005\u02d9\u02da\n\u0003\u0000\u0000\u02da"+
"\u02db\u0007\u0007\u0000\u0000\u02db\u02f5\u0003~?\u0004\u02dc\u02dd\n"+
"\u0002\u0000\u0000\u02dd\u02de\u0005M\u0000\u0000\u02de\u02f5\u0003~?"+
"\u0003\u02df\u02e0\n\u0001\u0000\u0000\u02e0\u02e1\u0007\b\u0000\u0000"+
"\u02e1\u02f5\u0003~?\u0002\u02e2\u02e3\n\u0010\u0000\u0000\u02e3\u02e5"+
"\u00059\u0000\u0000\u02e4\u02e6\u0005:\u0000\u0000\u02e5\u02e4\u0001\u0000"+
"\u0000\u0000\u02e5\u02e6\u0001\u0000\u0000\u0000\u02e6\u02e7\u0001\u0000"+
"\u0000\u0000\u02e7\u02f5\u0007\t\u0000\u0000\u02e8\u02e9\n\u000f\u0000"+
"\u0000\u02e9\u02ea\u0007\n\u0000\u0000\u02ea\u02f5\u0003(\u0014\u0000"+
"\u02eb\u02ed\n\u000b\u0000\u0000\u02ec\u02ee\u0005A\u0000\u0000\u02ed"+
"\u02ec\u0001\u0000\u0000\u0000\u02ed\u02ee\u0001\u0000\u0000\u0000\u02ee"+
"\u02ef\u0001\u0000\u0000\u0000\u02ef\u02f0\u0005B\u0000\u0000\u02f0\u02f1"+
"\u0003\u0086C\u0000\u02f1\u02f2\u0005C\u0000\u0000\u02f2\u02f3\u0003\u0086"+
"C\u0000\u02f3\u02f5\u0001\u0000\u0000\u0000\u02f4\u02c6\u0001\u0000\u0000"+
"\u0000\u02f4\u02c9\u0001\u0000\u0000\u0000\u02f4\u02cd\u0001\u0000\u0000"+
"\u0000\u02f4\u02d0\u0001\u0000\u0000\u0000\u02f4\u02d6\u0001\u0000\u0000"+
"\u0000\u02f4\u02d9\u0001\u0000\u0000\u0000\u02f4\u02dc\u0001\u0000\u0000"+
"\u0000\u02f4\u02df\u0001\u0000\u0000\u0000\u02f4\u02e2\u0001\u0000\u0000"+
"\u0000\u02f4\u02e8\u0001\u0000\u0000\u0000\u02f4\u02eb\u0001\u0000\u0000"+
"\u0000\u02f5\u02f8\u0001\u0000\u0000\u0000\u02f6\u02f4\u0001\u0000\u0000"+
"\u0000\u02f6\u02f7\u0001\u0000\u0000\u0000\u02f7\u007f\u0001\u0000\u0000"+
"\u0000\u02f8\u02f6\u0001\u0000\u0000\u0000\u02f9\u02fa\u0007\u000b\u0000"+
"\u0000\u02fa\u0081\u0001\u0000\u0000\u0000\u02fb\u0301\u0003\u0080@\u0000"+
"\u02fc\u0301\u0005Z\u0000\u0000\u02fd\u0301\u0005[\u0000\u0000\u02fe\u0301"+
"\u0005\\\u0000\u0000\u02ff\u0301\u0005]\u0000\u0000\u0300\u02fb\u0001"+
"\u0000\u0000\u0000\u0300\u02fc\u0001\u0000\u0000\u0000\u0300\u02fd\u0001"+
"\u0000\u0000\u0000\u0300\u02fe\u0001\u0000\u0000\u0000\u0300\u02ff\u0001"+
"\u0000\u0000\u0000\u0301\u0083\u0001\u0000\u0000\u0000\u0302\u0303\u0007"+
"\f\u0000\u0000\u0303\u0085\u0001\u0000\u0000\u0000\u0304\u0305\u0006C"+
"\uffff\uffff\u0000\u0305\u0353\u0003\u0098L\u0000\u0306\u0307\u0005f\u0000"+
"\u0000\u0307\u0308\u0003~?\u0000\u0308\u030b\u0005g\u0000\u0000\u0309"+
"\u030c\u0003(\u0014\u0000\u030a\u030c\u0003\u00d2i\u0000\u030b\u0309\u0001"+
"\u0000\u0000\u0000\u030b\u030a\u0001\u0000\u0000\u0000\u030c\u0353\u0001"+
"\u0000\u0000\u0000\u030d\u030e\u0007\r\u0000\u0000\u030e\u0353\u0003\u0086"+
"C\u0012\u030f\u0310\u0007\u000e\u0000\u0000\u0310\u0311\u0005l\u0000\u0000"+
"\u0311\u0353\u0003\u0086C\u0011\u0312\u0313\u0003\u0082A\u0000\u0313\u0314"+
"\u0005\u0013\u0000\u0000\u0314\u0315\u0003\u0086C\u0010\u0315\u0353\u0001"+
"\u0000\u0000\u0000\u0316\u0317\u0005D\u0000\u0000\u0317\u0318\u0005)\u0000"+
"\u0000\u0318\u0319\u0003\u0084B\u0000\u0319\u031a\u0005l\u0000\u0000\u031a"+
"\u031b\u0003\u0086C\u000f\u031b\u0353\u0001\u0000\u0000\u0000\u031c\u031d"+
"\u0005E\u0000\u0000\u031d\u031e\u0005)\u0000\u0000\u031e\u031f\u0003\u0084"+
"B\u0000\u031f\u0320\u0005l\u0000\u0000\u0320\u0321\u0003\u0086C\u000e"+
"\u0321\u0353\u0001\u0000\u0000\u0000\u0322\u0323\u0005m\u0000\u0000\u0323"+
"\u0324\u0005l\u0000\u0000\u0324\u0353\u0003\u0086C\r\u0325\u0326\u0005"+
"n\u0000\u0000\u0326\u0327\u0005l\u0000\u0000\u0327\u0353\u0003\u0086C"+
"\f\u0328\u0329\u0005o\u0000\u0000\u0329\u032a\u0005l\u0000\u0000\u032a"+
"\u0353\u0003\u0086C\u000b\u032b\u032c\u0005p\u0000\u0000\u032c\u032d\u0005"+
"\u0013\u0000\u0000\u032d\u0353\u0003\u0086C\n\u032e\u032f\u0005q\u0000"+
"\u0000\u032f\u0330\u0005\u0013\u0000\u0000\u0330\u0353\u0003\u0086C\t"+
"\u0331\u0332\u0007\u000f\u0000\u0000\u0332\u0353\u0003*\u0015\u0000\u0333"+
"\u0334\u0005z\u0000\u0000\u0334\u0335\u0003~?\u0000\u0335\u0336\u0005"+
"{\u0000\u0000\u0336\u0337\u0003~?\u0000\u0337\u0338\u0005|\u0000\u0000"+
"\u0338\u0339\u0003~?\u0000\u0339\u0353\u0001\u0000\u0000\u0000\u033a\u033c"+
"\u0005}\u0000\u0000\u033b\u033d\u0003~?\u0000\u033c\u033b\u0001\u0000"+
"\u0000\u0000\u033c\u033d\u0001\u0000\u0000\u0000\u033d\u033f\u0001\u0000"+
"\u0000\u0000\u033e\u0340\u0003\u0088D\u0000\u033f\u033e\u0001\u0000\u0000"+
"\u0000\u0340\u0341\u0001\u0000\u0000\u0000\u0341\u033f\u0001\u0000\u0000"+
"\u0000\u0341\u0342\u0001\u0000\u0000\u0000\u0342\u0343\u0001\u0000\u0000"+
"\u0000\u0343\u0344\u0005|\u0000\u0000\u0344\u0345\u0003~?\u0000\u0345"+
"\u0346\u0005k\u0000\u0000\u0346\u0353\u0001\u0000\u0000\u0000\u0347\u0348"+
"\u0007\u0010\u0000\u0000\u0348\u0353\u0003~?\u0000\u0349\u034a\u0007\u0011"+
"\u0000\u0000\u034a\u0350\u0003~?\u0000\u034b\u034e\u0005\u0081\u0000\u0000"+
"\u034c\u034f\u0003\u0080@\u0000\u034d\u034f\u0003~?\u0000\u034e\u034c"+
"\u0001\u0000\u0000\u0000\u034e\u034d\u0001\u0000\u0000\u0000\u034f\u0351"+
"\u0001\u0000\u0000\u0000\u0350\u034b\u0001\u0000\u0000\u0000\u0350\u0351"+
"\u0001\u0000\u0000\u0000\u0351\u0353\u0001\u0000\u0000\u0000\u0352\u0304"+
"\u0001\u0000\u0000\u0000\u0352\u0306\u0001\u0000\u0000\u0000\u0352\u030d"+
"\u0001\u0000\u0000\u0000\u0352\u030f\u0001\u0000\u0000\u0000\u0352\u0312"+
"\u0001\u0000\u0000\u0000\u0352\u0316\u0001\u0000\u0000\u0000\u0352\u031c"+
"\u0001\u0000\u0000\u0000\u0352\u0322\u0001\u0000\u0000\u0000\u0352\u0325"+
"\u0001\u0000\u0000\u0000\u0352\u0328\u0001\u0000\u0000\u0000\u0352\u032b"+
"\u0001\u0000\u0000\u0000\u0352\u032e\u0001\u0000\u0000\u0000\u0352\u0331"+
"\u0001\u0000\u0000\u0000\u0352\u0333\u0001\u0000\u0000\u0000\u0352\u033a"+
"\u0001\u0000\u0000\u0000\u0352\u0347\u0001\u0000\u0000\u0000\u0352\u0349"+
"\u0001\u0000\u0000\u0000\u0353\u0367\u0001\u0000\u0000\u0000\u0354\u0355"+
"\n\u0007\u0000\u0000\u0355\u0356\u0005t\u0000\u0000\u0356\u0366\u0003"+
"\u0086C\b\u0357\u0358\n\u0006\u0000\u0000\u0358\u0359\u0007\u0012\u0000"+
"\u0000\u0359\u0366\u0003\u0086C\u0007\u035a\u035b\n\u0005\u0000\u0000"+
"\u035b\u035c\u0007\u0013\u0000\u0000\u035c\u0366\u0003\u0086C\u0006\u035d"+
"\u035e\n\u0015\u0000\u0000\u035e\u035f\u0005\u0011\u0000\u0000\u035f\u0366"+
"\u0003\u009aM\u0000\u0360\u0361\n\u0014\u0000\u0000\u0361\u0362\u0005"+
"&\u0000\u0000\u0362\u0363\u0003~?\u0000\u0363\u0364\u0005(\u0000\u0000"+
"\u0364\u0366\u0001\u0000\u0000\u0000\u0365\u0354\u0001\u0000\u0000\u0000"+
"\u0365\u0357\u0001\u0000\u0000\u0000\u0365\u035a\u0001\u0000\u0000\u0000"+
"\u0365\u035d\u0001\u0000\u0000\u0000\u0365\u0360\u0001\u0000\u0000\u0000"+
"\u0366\u0369\u0001\u0000\u0000\u0000\u0367\u0365\u0001\u0000\u0000\u0000"+
"\u0367\u0368\u0001\u0000\u0000\u0000\u0368\u0087\u0001\u0000\u0000\u0000"+
"\u0369\u0367\u0001\u0000\u0000\u0000\u036a\u036b\u0005\u0082\u0000\u0000"+
"\u036b\u036c\u0003~?\u0000\u036c\u036d\u0005{\u0000\u0000\u036d\u036e"+
"\u0003~?\u0000\u036e\u0089\u0001\u0000\u0000\u0000\u036f\u0370\u0003\u0080"+
"@\u0000\u0370\u0371\u0005l\u0000\u0000\u0371\u008b\u0001\u0000\u0000\u0000"+
"\u0372\u0373\u0007\u0014\u0000\u0000\u0373\u008d\u0001\u0000\u0000\u0000"+
"\u0374\u0375\u0007\u0015\u0000\u0000\u0375\u008f\u0001\u0000\u0000\u0000"+
"\u0376\u0377\u0007\u0016\u0000\u0000\u0377\u0091\u0001\u0000\u0000\u0000"+
"\u0378\u037a\u0003\u00d0h\u0000\u0379\u037b\u0003\u008eG\u0000\u037a\u0379"+
"\u0001\u0000\u0000\u0000\u037a\u037b\u0001\u0000\u0000\u0000\u037b\u0380"+
"\u0001\u0000\u0000\u0000\u037c\u037d\u0003\u0090H\u0000\u037d\u037e\u0003"+
"\u00d0h\u0000\u037e\u0380\u0001\u0000\u0000\u0000\u037f\u0378\u0001\u0000"+
"\u0000\u0000\u037f\u037c\u0001\u0000\u0000\u0000\u0380\u0093\u0001\u0000"+
"\u0000\u0000\u0381\u0383\u0005\u0089\u0000\u0000\u0382\u0381\u0001\u0000"+
"\u0000\u0000\u0382\u0383\u0001\u0000\u0000\u0000\u0383\u0384\u0001\u0000"+
"\u0000\u0000\u0384\u038a\u0007\u0017\u0000\u0000\u0385\u0387\u0007\u0017"+
"\u0000\u0000\u0386\u0388\u0005\u008c\u0000\u0000\u0387\u0386\u0001\u0000"+
"\u0000\u0000\u0387\u0388\u0001\u0000\u0000\u0000\u0388\u038a\u0001\u0000"+
"\u0000\u0000\u0389\u0382\u0001\u0000\u0000\u0000\u0389\u0385\u0001\u0000"+
"\u0000\u0000\u038a\u0095\u0001\u0000\u0000\u0000\u038b\u038d\u0007\u0018"+
"\u0000\u0000\u038c\u038b\u0001\u0000\u0000\u0000\u038c\u038d\u0001\u0000"+
"\u0000\u0000\u038d\u038e\u0001\u0000\u0000\u0000\u038e\u0390\u0005\u0090"+
"\u0000\u0000\u038f\u0391\u0003\u0080@\u0000\u0390\u038f\u0001\u0000\u0000"+
"\u0000\u0390\u0391\u0001\u0000\u0000\u0000\u0391\u0394\u0001\u0000\u0000"+
"\u0000\u0392\u0395\u0003\u008cF\u0000\u0393\u0395\u0005>\u0000\u0000\u0394"+
"\u0392\u0001\u0000\u0000\u0000\u0394\u0393\u0001\u0000\u0000\u0000\u0395"+
"\u0397\u0001\u0000\u0000\u0000\u0396\u0398\u0007\u000e\u0000\u0000\u0397"+
"\u0396\u0001\u0000\u0000\u0000\u0397\u0398\u0001\u0000\u0000\u0000\u0398"+
"\u03dd\u0001\u0000\u0000\u0000\u0399\u039b\u0005A\u0000\u0000\u039a\u0399"+
"\u0001\u0000\u0000\u0000\u039a\u039b\u0001\u0000\u0000\u0000\u039b\u039c"+
"\u0001\u0000\u0000\u0000\u039c\u039e\u0005\u0091\u0000\u0000\u039d\u039f"+
"\u0003\u008aE\u0000\u039e\u039d\u0001\u0000\u0000\u0000\u039e\u039f\u0001"+
"\u0000\u0000\u0000\u039f\u03a1\u0001\u0000\u0000\u0000\u03a0\u03a2\u0007"+
"\u000e\u0000\u0000\u03a1\u03a0\u0001\u0000\u0000\u0000\u03a1\u03a2\u0001"+
"\u0000\u0000\u0000\u03a2\u03dd\u0001\u0000\u0000\u0000\u03a3\u03a5\u0007"+
"\u0018\u0000\u0000\u03a4\u03a3\u0001\u0000\u0000\u0000\u03a4\u03a5\u0001"+
"\u0000\u0000\u0000\u03a5\u03a7\u0001\u0000\u0000\u0000\u03a6\u03a8\u0005"+
"A\u0000\u0000\u03a7\u03a6\u0001\u0000\u0000\u0000\u03a7\u03a8\u0001\u0000"+
"\u0000\u0000\u03a8\u03a9\u0001\u0000\u0000\u0000\u03a9\u03ab\u0007\u0019"+
"\u0000\u0000\u03aa\u03ac\u0003\u008aE\u0000\u03ab\u03aa\u0001\u0000\u0000"+
"\u0000\u03ab\u03ac\u0001\u0000\u0000\u0000\u03ac\u03dd\u0001\u0000\u0000"+
"\u0000\u03ad\u03af\u0007\u0018\u0000\u0000\u03ae\u03ad\u0001\u0000\u0000"+
"\u0000\u03ae\u03af\u0001\u0000\u0000\u0000\u03af\u03b1\u0001\u0000\u0000"+
"\u0000\u03b0\u03b2\u0003\u0092I\u0000\u03b1\u03b0\u0001\u0000\u0000\u0000"+
"\u03b1\u03b2\u0001\u0000\u0000\u0000\u03b2\u03b3\u0001\u0000\u0000\u0000"+
"\u03b3\u03b5\u0003\u0094J\u0000\u03b4\u03b6\u0003\u008aE\u0000\u03b5\u03b4"+
"\u0001\u0000\u0000\u0000\u03b5\u03b6\u0001\u0000\u0000\u0000\u03b6\u03b8"+
"\u0001\u0000\u0000\u0000\u03b7\u03b9\u0007\u000e\u0000\u0000\u03b8\u03b7"+
"\u0001\u0000\u0000\u0000\u03b8\u03b9\u0001\u0000\u0000\u0000\u03b9\u03dd"+
"\u0001\u0000\u0000\u0000\u03ba\u03bc\u0007\u0018\u0000\u0000\u03bb\u03ba"+
"\u0001\u0000\u0000\u0000\u03bb\u03bc\u0001\u0000\u0000\u0000\u03bc\u03be"+
"\u0001\u0000\u0000\u0000\u03bd\u03bf\u0005A\u0000\u0000\u03be\u03bd\u0001"+
"\u0000\u0000\u0000\u03be\u03bf\u0001\u0000\u0000\u0000\u03bf\u03c0\u0001"+
"\u0000\u0000\u0000\u03c0\u03c1\u0005\u0094\u0000\u0000\u03c1\u03c2\u0003"+
"\u00d0h\u0000\u03c2\u03c4\u0005l\u0000\u0000\u03c3\u03c5\u0007\u000e\u0000"+
"\u0000\u03c4\u03c3\u0001\u0000\u0000\u0000\u03c4\u03c5\u0001\u0000\u0000"+
"\u0000\u03c5\u03dd\u0001\u0000\u0000\u0000\u03c6\u03c8\u0005\u0095\u0000"+
"\u0000\u03c7\u03c9\u0007\u0017\u0000\u0000\u03c8\u03c7\u0001\u0000\u0000"+
"\u0000\u03c8\u03c9\u0001\u0000\u0000\u0000\u03c9\u03cb\u0001\u0000\u0000"+
"\u0000\u03ca\u03cc\u0003\u008aE\u0000\u03cb\u03ca\u0001\u0000\u0000\u0000"+
"\u03cb\u03cc\u0001\u0000\u0000\u0000\u03cc\u03dd\u0001\u0000\u0000\u0000"+
"\u03cd\u03cf\u0005\u0096\u0000\u0000\u03ce\u03d0\u0007\u0017\u0000\u0000"+
"\u03cf\u03ce\u0001\u0000\u0000\u0000\u03cf\u03d0\u0001\u0000\u0000\u0000"+
"\u03d0\u03d2\u0001\u0000\u0000\u0000\u03d1\u03d3\u0003\u008aE\u0000\u03d2"+
"\u03d1\u0001\u0000\u0000\u0000\u03d2\u03d3\u0001\u0000\u0000\u0000\u03d3"+
"\u03dd\u0001\u0000\u0000\u0000\u03d4\u03d6\u0005\u008d\u0000\u0000\u03d5"+
"\u03d7\u0003\u008aE\u0000\u03d6\u03d5\u0001\u0000\u0000\u0000\u03d6\u03d7"+
"\u0001\u0000\u0000\u0000\u03d7\u03dd\u0001\u0000\u0000\u0000\u03d8\u03da"+
"\u0005\u008e\u0000\u0000\u03d9\u03db\u0003\u008aE\u0000\u03da\u03d9\u0001"+
"\u0000\u0000\u0000\u03da\u03db\u0001\u0000\u0000\u0000\u03db\u03dd\u0001"+
"\u0000\u0000\u0000\u03dc\u038c\u0001\u0000\u0000\u0000\u03dc\u039a\u0001"+
"\u0000\u0000\u0000\u03dc\u03a4\u0001\u0000\u0000\u0000\u03dc\u03ae\u0001"+
"\u0000\u0000\u0000\u03dc\u03bb\u0001\u0000\u0000\u0000\u03dc\u03c6\u0001"+
"\u0000\u0000\u0000\u03dc\u03cd\u0001\u0000\u0000\u0000\u03dc\u03d4\u0001"+
"\u0000\u0000\u0000\u03dc\u03d8\u0001\u0000\u0000\u0000\u03dd\u0097\u0001"+
"\u0000\u0000\u0000\u03de\u03ec\u0003\u009eO\u0000\u03df\u03ec\u0003\u00a4"+
"R\u0000\u03e0\u03ec\u0003\u00ccf\u0000\u03e1\u03ec\u0003\u00a6S\u0000"+
"\u03e2\u03ec\u0003\u00a8T\u0000\u03e3\u03ec\u0003\u00acV\u0000\u03e4\u03ec"+
"\u0003\u00b0X\u0000\u03e5\u03ec\u0003\u00b4Z\u0000\u03e6\u03ec\u0003\u00b6"+
"[\u0000\u03e7\u03e8\u0005\u001f\u0000\u0000\u03e8\u03e9\u0003~?\u0000"+
"\u03e9\u03ea\u0005 \u0000\u0000\u03ea\u03ec\u0001\u0000\u0000\u0000\u03eb"+
"\u03de\u0001\u0000\u0000\u0000\u03eb\u03df\u0001\u0000\u0000\u0000\u03eb"+
"\u03e0\u0001\u0000\u0000\u0000\u03eb\u03e1\u0001\u0000\u0000\u0000\u03eb"+
"\u03e2\u0001\u0000\u0000\u0000\u03eb\u03e3\u0001\u0000\u0000\u0000\u03eb"+
"\u03e4\u0001\u0000\u0000\u0000\u03eb\u03e5\u0001\u0000\u0000\u0000\u03eb"+
"\u03e6\u0001\u0000\u0000\u0000\u03eb\u03e7\u0001\u0000\u0000\u0000\u03ec"+
"\u0099\u0001\u0000\u0000\u0000\u03ed\u03f0\u0003\u00c4b\u0000\u03ee\u03f0"+
"\u0003\u009cN\u0000\u03ef\u03ed\u0001\u0000\u0000\u0000\u03ef\u03ee\u0001"+
"\u0000\u0000\u0000\u03f0\u009b\u0001\u0000\u0000\u0000\u03f1\u03f2\u0003"+
"\u00c8d\u0000\u03f2\u03f4\u0005\u001f\u0000\u0000\u03f3\u03f5\u0003\u00ce"+
"g\u0000\u03f4\u03f3\u0001\u0000\u0000\u0000\u03f4\u03f5\u0001\u0000\u0000"+
"\u0000\u03f5\u03f6\u0001\u0000\u0000\u0000\u03f6\u03f7\u0005 \u0000\u0000"+
"\u03f7\u009d\u0001\u0000\u0000\u0000\u03f8\u03fe\u0003\u00c4b\u0000\u03f9"+
"\u03fe\u0003\u00a0P\u0000\u03fa\u03fe\u0005\u0097\u0000\u0000\u03fb\u03fe"+
"\u0005\u0098\u0000\u0000\u03fc\u03fe\u0005\u0099\u0000\u0000\u03fd\u03f8"+
"\u0001\u0000\u0000\u0000\u03fd\u03f9\u0001\u0000\u0000\u0000\u03fd\u03fa"+
"\u0001\u0000\u0000\u0000\u03fd\u03fb\u0001\u0000\u0000\u0000\u03fd\u03fc"+
"\u0001\u0000\u0000\u0000\u03fe\u009f\u0001\u0000\u0000\u0000\u03ff\u0400"+
"\u0003\u00c4b\u0000\u0400\u0402\u0005\u001f\u0000\u0000\u0401\u0403\u0003"+
"\u00ceg\u0000\u0402\u0401\u0001\u0000\u0000\u0000\u0402\u0403\u0001\u0000"+
"\u0000\u0000\u0403\u0404\u0001\u0000\u0000\u0000\u0404\u0405\u0005 \u0000"+
"\u0000\u0405\u00a1\u0001\u0000\u0000\u0000\u0406\u0407\u0003\u00d0h\u0000"+
"\u0407\u0408\u0005\u000b\u0000\u0000\u0408\u0409\u0003\u00d0h\u0000\u0409"+
"\u00a3\u0001\u0000\u0000\u0000\u040a\u0415\u0007\u001a\u0000\u0000\u040b"+
"\u0415\u0005;\u0000\u0000\u040c\u0415\u0005\u00a5\u0000\u0000\u040d\u0415"+
"\u0005\u00a6\u0000\u0000\u040e\u0415\u0005\u00a0\u0000\u0000\u040f\u0415"+
"\u0005\u009f\u0000\u0000\u0410\u0415\u0005\u00a1\u0000\u0000\u0411\u0415"+
"\u0005\u00a2\u0000\u0000\u0412\u0415\u0003\u00d0h\u0000\u0413\u0415\u0003"+
"\u00a2Q\u0000\u0414\u040a\u0001\u0000\u0000\u0000\u0414\u040b\u0001\u0000"+
"\u0000\u0000\u0414\u040c\u0001\u0000\u0000\u0000\u0414\u040d\u0001\u0000"+
"\u0000\u0000\u0414\u040e\u0001\u0000\u0000\u0000\u0414\u040f\u0001\u0000"+
"\u0000\u0000\u0414\u0410\u0001\u0000\u0000\u0000\u0414\u0411\u0001\u0000"+
"\u0000\u0000\u0414\u0412\u0001\u0000\u0000\u0000\u0414\u0413\u0001\u0000"+
"\u0000\u0000\u0415\u00a5\u0001\u0000\u0000\u0000\u0416\u0417\u0005\u0018"+
"\u0000\u0000\u0417\u0418\u0007\u001b\u0000\u0000\u0418\u0419\u0003~?\u0000"+
"\u0419\u041a\u0005\u000f\u0000\u0000\u041a\u041b\u0003~?\u0000\u041b\u041c"+
"\u0007\u001c\u0000\u0000\u041c\u00a7\u0001\u0000\u0000\u0000\u041d\u041f"+
"\u0005\u0019\u0000\u0000\u041e\u041d\u0001\u0000\u0000\u0000\u041e\u041f"+
"\u0001\u0000\u0000\u0000\u041f\u0420\u0001\u0000\u0000\u0000\u0420\u042a"+
"\u0005\u000e\u0000\u0000\u0421\u042b\u0005\u000b\u0000\u0000\u0422\u0427"+
"\u0003\u00aaU\u0000\u0423\u0424\u0005\u000f\u0000\u0000\u0424\u0426\u0003"+
"\u00aaU\u0000\u0425\u0423\u0001\u0000\u0000\u0000\u0426\u0429\u0001\u0000"+
"\u0000\u0000\u0427\u0425\u0001\u0000\u0000\u0000\u0427\u0428\u0001\u0000"+
"\u0000\u0000\u0428\u042b\u0001\u0000\u0000\u0000\u0429\u0427\u0001\u0000"+
"\u0000\u0000\u042a\u0421\u0001\u0000\u0000\u0000\u042a\u0422\u0001\u0000"+
"\u0000\u0000\u042b\u042c\u0001\u0000\u0000\u0000\u042c\u042d\u0005\u0010"+
"\u0000\u0000\u042d\u00a9\u0001\u0000\u0000\u0000\u042e\u042f\u0003\u00c4"+
"b\u0000\u042f\u0430\u0005\u000b\u0000\u0000\u0430\u0431\u0003~?\u0000"+
"\u0431\u00ab\u0001\u0000\u0000\u0000\u0432\u0433\u0003*\u0015\u0000\u0433"+
"\u043d\u0005\u000e\u0000\u0000\u0434\u043e\u0005\u000b\u0000\u0000\u0435"+
"\u043a\u0003\u00aeW\u0000\u0436\u0437\u0005\u000f\u0000\u0000\u0437\u0439"+
"\u0003\u00aeW\u0000\u0438\u0436\u0001\u0000\u0000\u0000\u0439\u043c\u0001"+
"\u0000\u0000\u0000\u043a\u0438\u0001\u0000\u0000\u0000\u043a\u043b\u0001"+
"\u0000\u0000\u0000\u043b\u043e\u0001\u0000\u0000\u0000\u043c\u043a\u0001"+
"\u0000\u0000\u0000\u043d\u0434\u0001\u0000\u0000\u0000\u043d\u0435\u0001"+
"\u0000\u0000\u0000\u043e\u043f\u0001\u0000\u0000\u0000\u043f\u0440\u0005"+
"\u0010\u0000\u0000\u0440\u00ad\u0001\u0000\u0000\u0000\u0441\u0442\u0003"+
"\u00c4b\u0000\u0442\u0443\u0005\u000b\u0000\u0000\u0443\u0444\u0003~?"+
"\u0000\u0444\u00af\u0001\u0000\u0000\u0000\u0445\u044a\u0005\u0015\u0000"+
"\u0000\u0446\u0447\u0005\u0016\u0000\u0000\u0447\u0448\u0003(\u0014\u0000"+
"\u0448\u0449\u0005\u0017\u0000\u0000\u0449\u044b\u0001\u0000\u0000\u0000"+
"\u044a\u0446\u0001\u0000\u0000\u0000\u044a\u044b\u0001\u0000\u0000\u0000"+
"\u044b\u044d\u0001\u0000\u0000\u0000\u044c\u0445\u0001\u0000\u0000\u0000"+
"\u044c\u044d\u0001\u0000\u0000\u0000\u044d\u044e\u0001\u0000\u0000\u0000"+
"\u044e\u0457\u0005\u000e\u0000\u0000\u044f\u0454\u0003~?\u0000\u0450\u0451"+
"\u0005\u000f\u0000\u0000\u0451\u0453\u0003~?\u0000\u0452\u0450\u0001\u0000"+
"\u0000\u0000\u0453\u0456\u0001\u0000\u0000\u0000\u0454\u0452\u0001\u0000"+
"\u0000\u0000\u0454\u0455\u0001\u0000\u0000\u0000\u0455\u0458\u0001\u0000"+
"\u0000\u0000\u0456\u0454\u0001\u0000\u0000\u0000\u0457\u044f\u0001\u0000"+
"\u0000\u0000\u0457\u0458\u0001\u0000\u0000\u0000\u0458\u0459\u0001\u0000"+
"\u0000\u0000\u0459\u045a\u0005\u0010\u0000\u0000\u045a\u00b1\u0001\u0000"+
"\u0000\u0000\u045b\u045c\u0005\u009a\u0000\u0000\u045c\u045d\u0005\u00a5"+
"\u0000\u0000\u045d\u00b3\u0001\u0000\u0000\u0000\u045e\u045f\u0005\u009b"+
"\u0000\u0000\u045f\u0460\u0005\u00a5\u0000\u0000\u0460\u0461\u0005\u0013"+
"\u0000\u0000\u0461\u0463\u0003\u0016\u000b\u0000\u0462\u0464\u0003\u00b2"+
"Y\u0000\u0463\u0462\u0001\u0000\u0000\u0000\u0463\u0464\u0001\u0000\u0000"+
"\u0000\u0464\u00b5\u0001\u0000\u0000\u0000\u0465\u0466\u0005\u009c\u0000"+
"\u0000\u0466\u0467\u0005\u000e\u0000\u0000\u0467\u046c\u0003\u00b4Z\u0000"+
"\u0468\u0469\u0005\u000f\u0000\u0000\u0469\u046b\u0003\u00b4Z\u0000\u046a"+
"\u0468\u0001\u0000\u0000\u0000\u046b\u046e\u0001\u0000\u0000\u0000\u046c"+
"\u046a\u0001\u0000\u0000\u0000\u046c\u046d\u0001\u0000\u0000\u0000\u046d"+
"\u046f\u0001\u0000\u0000\u0000\u046e\u046c\u0001\u0000\u0000\u0000\u046f"+
"\u0471\u0005\u0010\u0000\u0000\u0470\u0472\u0003\u00b2Y\u0000\u0471\u0470"+
"\u0001\u0000\u0000\u0000\u0471\u0472\u0001\u0000\u0000\u0000\u0472\u00b7"+
"\u0001\u0000\u0000\u0000\u0473\u0474\u0007\u001d\u0000\u0000\u0474\u00b9"+
"\u0001\u0000\u0000\u0000\u0475\u0476\u0007\u001e\u0000\u0000\u0476\u00bb"+
"\u0001\u0000\u0000\u0000\u0477\u0478\u0007\u001f\u0000\u0000\u0478\u00bd"+
"\u0001\u0000\u0000\u0000\u0479\u047a\u0007 \u0000\u0000\u047a\u00bf\u0001"+
"\u0000\u0000\u0000\u047b\u047c\u0007!\u0000\u0000\u047c\u00c1\u0001\u0000"+
"\u0000\u0000\u047d\u047e\u0007\"\u0000\u0000\u047e\u00c3\u0001\u0000\u0000"+
"\u0000\u047f\u0482\u0003\u00cae\u0000\u0480\u0482\u0003\u00bc^\u0000\u0481"+
"\u047f\u0001\u0000\u0000\u0000\u0481\u0480\u0001\u0000\u0000\u0000\u0482"+
"\u00c5\u0001\u0000\u0000\u0000\u0483\u0486\u0003\u00c4b\u0000\u0484\u0486"+
"\u0003\u00c2a\u0000\u0485\u0483\u0001\u0000\u0000\u0000\u0485\u0484\u0001"+
"\u0000\u0000\u0000\u0486\u00c7\u0001\u0000\u0000\u0000\u0487\u048a\u0003"+
"\u00cae\u0000\u0488\u048a\u0003\u00c0`\u0000\u0489\u0487\u0001\u0000\u0000"+
"\u0000\u0489\u0488\u0001\u0000\u0000\u0000\u048a\u00c9\u0001\u0000\u0000"+
"\u0000\u048b\u048c\u0007#\u0000\u0000\u048c\u00cb\u0001\u0000\u0000\u0000"+
"\u048d\u0490\u0005\u009d\u0000\u0000\u048e\u0491\u0003\u00cae\u0000\u048f"+
"\u0491\u0005\u00a5\u0000\u0000\u0490\u048e\u0001\u0000\u0000\u0000\u0490"+
"\u048f\u0001\u0000\u0000\u0000\u0491\u00cd\u0001\u0000\u0000\u0000\u0492"+
"\u0497\u0003~?\u0000\u0493\u0494\u0005\u000f\u0000\u0000\u0494\u0496\u0003"+
"~?\u0000\u0495\u0493\u0001\u0000\u0000\u0000\u0496\u0499\u0001\u0000\u0000"+
"\u0000\u0497\u0495\u0001\u0000\u0000\u0000\u0497\u0498\u0001\u0000\u0000"+
"\u0000\u0498\u00cf\u0001\u0000\u0000\u0000\u0499\u0497\u0001\u0000\u0000"+
"\u0000\u049a\u049c\u0005\u00a6\u0000\u0000\u049b\u049d\u0003\u00d2i\u0000"+
"\u049c\u049b\u0001\u0000\u0000\u0000\u049c\u049d\u0001\u0000\u0000\u0000"+
"\u049d\u00d1\u0001\u0000\u0000\u0000\u049e\u04a2\u0003\u0080@\u0000\u049f"+
"\u04a2\u0003\u0084B\u0000\u04a0\u04a2\u0005\u00a5\u0000\u0000\u04a1\u049e"+
"\u0001\u0000\u0000\u0000\u04a1\u049f\u0001\u0000\u0000\u0000\u04a1\u04a0"+
"\u0001\u0000\u0000\u0000\u04a2\u00d3\u0001\u0000\u0000\u0000\u0086\u00db"+
"\u00de\u00e3\u00e9\u00f2\u00f8\u00fc\u0102\u0106\u010d\u0112\u0116\u0119"+
"\u0121\u0124\u012c\u012f\u0138\u0140\u0147\u0150\u0153\u015e\u0163\u0168"+
"\u0179\u0180\u0198\u01a7\u01af\u01b3\u01bd\u01c5\u01c8\u01d2\u01d5\u01da"+
"\u01df\u01ec\u01f5\u0205\u020c\u020f\u021b\u0221\u0226\u022a\u022e\u0231"+
"\u0234\u023b\u0244\u0250\u0256\u025a\u0266\u0270\u0273\u0279\u0280\u028a"+
"\u029c\u029e\u02a3\u02b4\u02c4\u02d3\u02e5\u02ed\u02f4\u02f6\u0300\u030b"+
"\u033c\u0341\u034e\u0350\u0352\u0365\u0367\u037a\u037f\u0382\u0387\u0389"+
"\u038c\u0390\u0394\u0397\u039a\u039e\u03a1\u03a4\u03a7\u03ab\u03ae\u03b1"+
"\u03b5\u03b8\u03bb\u03be\u03c4\u03c8\u03cb\u03cf\u03d2\u03d6\u03da\u03dc"+
"\u03eb\u03ef\u03f4\u03fd\u0402\u0414\u041e\u0427\u042a\u043a\u043d\u044a"+
"\u044c\u0454\u0457\u0463\u046c\u0471\u0481\u0485\u0489\u0490\u0497\u049c"+
"\u04a1";
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
}